Check for shader version mismatch

gpu/command_buffer/service/program_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/program_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 540 matching lines @@
     }
   }
 
   if (link) {
     CompileAttachedShaders();
 
     if (!CanLink()) {
       set_log_info("invalid shaders");
       return false;
     }
+    if (DetectShaderVersionMismatch()) {
+      set_log_info("Versions of linked shaders have to match.");
+      return false;
+    }
     if (DetectAttribLocationBindingConflicts()) {
       set_log_info("glBindAttribLocation() conflicts");
       return false;
     }
     std::string conflicting_name;
     if (DetectUniformsMismatch(&conflicting_name)) {
       std::string info_log = "Uniforms with the same name but different "
                              "type/precision: " + conflicting_name;
       set_log_info(ProcessLogInfo(info_log).c_str());
       return false;
@@ skipping 456 matching lines @@
 
 bool Program::CanLink() const {
   for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
     if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->valid()) {
       return false;
     }
   }
   return true;
 }
 
+bool Program::DetectShaderVersionMismatch() const {
+  int version = Shader::kUndefinedShaderVersion;
+  for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
+    Shader* shader = attached_shaders_[ii].get();
+    if (shader) {
+      if (version != Shader::kUndefinedShaderVersion &&
+          shader->shader_version() != version) {
+        return true;

[Zhenyao Mo, 2015/05/06 17:57:42]

This is based on the assumption that kMaxAttachedShaders == 2.

We should make the algorithm more robust without this hidden assumption here.

[oetuaho-nv, 2015/05/07 08:02:41]

I don't see how this would be based on that assumption. If any of the shaders
has a different version this function will report the mismatch.

[Jamie Madill, 2015/05/07 11:27:54]

Yes, I think it's sufficient to detect any mismatch between pairs of shaders.

[Zhenyao Mo, 2015/05/07 14:33:08]

You are right.  I misread the code.

+      }
+      version = shader->shader_version();
+      DCHECK(version != Shader::kUndefinedShaderVersion);
+    }
+  }
+  return false;
+}
+
 bool Program::DetectAttribLocationBindingConflicts() const {
   std::set<GLint> location_binding_used;
   for (LocationMap::const_iterator it = bind_attrib_location_map_.begin();
        it != bind_attrib_location_map_.end(); ++it) {
     // Find out if an attribute is statically used in this program's shaders.
     const sh::Attribute* attrib = NULL;
     const std::string* mapped_name = GetAttribMappedName(it->first);
     if (!mapped_name)
       continue;
     for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
@@ skipping 698 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu