program_manager: detect interface block mismatches

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1055 matching lines @@
     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;
     }
     if (DetectUniformLocationBindingConflicts()) {
       set_log_info("glBindUniformLocationCHROMIUM() conflicts");
       return false;
     }
+    if (DetectInterfaceBlocksMismatch(&conflicting_name)) {
+      std::string info_log =
+          "Interface blocks with the same name but different"
+          " fields/layout: " +
+          conflicting_name;
+      set_log_info(ProcessLogInfo(info_log).c_str());
+      return false;
+    }
     if (DetectVaryingsMismatch(&conflicting_name)) {
       std::string info_log = "Varyings with the same name but different type, "
                              "or statically used varyings in fragment shader "
                              "are not declared in vertex shader: " +
                              conflicting_name;
       set_log_info(ProcessLogInfo(info_log).c_str());
       return false;
     }
     if (DetectFragmentInputLocationBindingConflicts()) {
       set_log_info("glBindFragmentInputLocationCHROMIUM() conflicts");
@@ skipping 527 matching lines @@
         if (hit->second->isSameUniformAtLinkTime(key_value.second))
           continue;
         *conflicting_name = name;
         return true;
       }
     }
   }
   return false;
 }
 
+bool Program::DetectInterfaceBlocksMismatch(
+    std::string* conflicting_name) const {
+  std::map<std::string, const sh::InterfaceBlock*> interface_pointer_map;
+  for (auto shader : attached_shaders_) {
+    const InterfaceBlockMap& shader_interfaces = shader->interface_block_map();
+    for (const auto& it : shader_interfaces) {
+      const auto& name = it.first;
+      auto hit = interface_pointer_map.find(name);
+      if (hit == interface_pointer_map.end()) {
+        interface_pointer_map[name] = &(it.second);
+      } else {
+        // If an interface is in the map, i.e., it has already been declared by
+        // another shader, then the layout must match.
+        if (hit->second->isSameInterfaceBlockAtLinkTime(it.second))

[Ken Russell (switch to Gerrit), 2016/07/12 20:37:13]

Is isSameInterfaceBlockAtLinkTime a new method in InterfaceBlock? I was curious
to see how it worked and found it doesn't seem to be there.

+          continue;
+        *conflicting_name = name;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 bool Program::DetectVaryingsMismatch(std::string* conflicting_name) const {
   DCHECK(attached_shaders_[0].get() &&
          attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
          attached_shaders_[1].get() &&
          attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
   const VaryingMap* vertex_varyings = &(attached_shaders_[0]->varying_map());
   const VaryingMap* fragment_varyings = &(attached_shaders_[1]->varying_map());
 
   int shader_version = attached_shaders_[0]->shader_version();
 
@@ skipping 733 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32_t ProgramManager::MakeFakeLocation(int32_t index, int32_t element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu