Report relevant variable names in info logs on failed shader link

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 162 matching lines @@
   attrib_location_to_index_map_.clear();
 }
 
 std::string Program::ProcessLogInfo(
     const std::string& log) {
   std::string output;
   re2::StringPiece input(log);
   std::string prior_log;
   std::string hashed_name;
   while (RE2::Consume(&input,
-                      "(.*)(webgl_[0123456789abcdefABCDEF]+)",
+                      "(.*?)(webgl_[0123456789abcdefABCDEF]+)",
                       &prior_log,
                       &hashed_name)) {
     output += prior_log;
 
     const std::string* original_name =
         GetOriginalNameFromHashedName(hashed_name);
     if (original_name)
       output += *original_name;
     else
       output += hashed_name;
@@ skipping 157 matching lines @@
     attrib_location_to_index_map_[ii] = -1;
   }
   for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
     const VertexAttrib& info = attrib_infos_[ii];
     attrib_location_to_index_map_[info.location] = ii;
   }
 
 #if !defined(NDEBUG)
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUServiceLoggingGPU)) {
-    DLOG(INFO) << "----: attribs for service_id: " << service_id();
+    DVLOG(1) << "----: attribs for service_id: " << service_id();
     for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
       const VertexAttrib& info = attrib_infos_[ii];
-      DLOG(INFO) << ii << ": loc = " << info.location
-                 << ", size = " << info.size
-                 << ", type = " << GLES2Util::GetStringEnum(info.type)
-                 << ", name = " << info.name;
+      DVLOG(1) << ii << ": loc = " << info.location
+               << ", size = " << info.size
+               << ", type = " << GLES2Util::GetStringEnum(info.type)
+               << ", name = " << info.name;
     }
   }
 #endif
 
   max_len = 0;
   GLint num_uniforms = 0;
   glGetProgramiv(service_id_, GL_ACTIVE_UNIFORMS, &num_uniforms);
   glGetProgramiv(service_id_, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_len);
   name_buffer.reset(new char[max_len]);
 
@@ skipping 51 matching lines @@
     if (!data.added) {
       AddUniformInfo(
           data.size, data.type, data.location, -1, data.corrected_name,
           data.original_name, &next_available_index);
     }
   }
 
 #if !defined(NDEBUG)
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUServiceLoggingGPU)) {
-    DLOG(INFO) << "----: uniforms for service_id: " << service_id();
+    DVLOG(1) << "----: uniforms for service_id: " << service_id();
     for (size_t ii = 0; ii < uniform_infos_.size(); ++ii) {
       const UniformInfo& info = uniform_infos_[ii];
       if (info.IsValid()) {
-        DLOG(INFO) << ii << ": loc = " << info.element_locations[0]
-                   << ", size = " << info.size
-                   << ", type = " << GLES2Util::GetStringEnum(info.type)
-                   << ", name = " << info.name;
+        DVLOG(1) << ii << ": loc = " << info.element_locations[0]
+                 << ", size = " << info.size
+                 << ", type = " << GLES2Util::GetStringEnum(info.type)
+                 << ", name = " << info.name;
       }
     }
   }
 #endif
 
   valid_ = true;
 }
 
 void Program::ExecuteBindAttribLocationCalls() {
   for (LocationMap::const_iterator it = bind_attrib_location_map_.begin();
@@ skipping 69 matching lines @@
                    const ShaderCacheCallback& shader_callback) {
   ClearLinkStatus();
   if (!CanLink()) {
     set_log_info("missing shaders");
     return false;
   }
   if (DetectAttribLocationBindingConflicts()) {
     set_log_info("glBindAttribLocation() conflicts");
     return false;
   }
-  if (DetectUniformsMismatch()) {
-    set_log_info("Uniforms with the same name but different type/precision");
+  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;
   }
-  if (DetectVaryingsMismatch()) {
-    set_log_info("Varyings with the same name but different type, "
-                 "or statically used varyings in fragment shader are not "
-                 "declared in vertex shader");
+  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 (DetectGlobalNameConflicts()) {
-    set_log_info("Name conflicts between an uniform and an attribute");
+  if (DetectGlobalNameConflicts(&conflicting_name)) {
+    std::string info_log = "Name conflicts between an uniform and an "
+                           "attribute: " + conflicting_name;
+    set_log_info(ProcessLogInfo(info_log).c_str());
     return false;
   }
   if (!CheckVaryingsPacking()) {
     set_log_info("Varyings over maximum register limit");
     return false;
   }
 
   TimeTicks before_time = TimeTicks::HighResNow();
   bool link = true;
   ProgramCache* cache = manager_->program_cache_;
@@ skipping 440 matching lines @@
     if (active) {
       std::pair<std::set<GLint>::iterator, bool> result =
           location_binding_used.insert(it->second);
       if (!result.second)
         return true;
     }
   }
   return false;
 }
 
-bool Program::DetectUniformsMismatch() const {
+bool Program::DetectUniformsMismatch(std::string* conflicting_name) const {
   typedef std::map<std::string, UniformType> UniformMap;
   UniformMap uniform_map;
   for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
     const ShaderTranslator::VariableMap& shader_uniforms =
         attached_shaders_[ii]->uniform_map();
     for (ShaderTranslator::VariableMap::const_iterator iter =
              shader_uniforms.begin();
          iter != shader_uniforms.end(); ++iter) {
       const std::string& name = iter->first;
       UniformType type(iter->second);
       UniformMap::iterator map_entry = uniform_map.find(name);
       if (map_entry == uniform_map.end()) {
         uniform_map[name] = type;
       } else {
         // If a uniform is already in the map, i.e., it has already been
         // declared by other shader, then the type and precision must match.
         if (map_entry->second == type)
           continue;
+        *conflicting_name = name;
         return true;
       }
     }
   }
   return false;
 }
 
-bool Program::DetectVaryingsMismatch() const {
+bool Program::DetectVaryingsMismatch(std::string* conflicting_name) const {
   DCHECK(attached_shaders_[0] &&
          attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
          attached_shaders_[1] &&
          attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
   const ShaderTranslator::VariableMap* vertex_varyings =
       &(attached_shaders_[0]->varying_map());
   const ShaderTranslator::VariableMap* fragment_varyings =
       &(attached_shaders_[1]->varying_map());
 
   for (ShaderTranslator::VariableMap::const_iterator iter =
            fragment_varyings->begin();
        iter != fragment_varyings->end(); ++iter) {
     const std::string& name = iter->first;
     if (IsBuiltInVarying(name))
       continue;
 
     ShaderTranslator::VariableMap::const_iterator hit =
         vertex_varyings->find(name);
     if (hit == vertex_varyings->end()) {
-      if (iter->second.static_use)
+      if (iter->second.static_use) {
+        *conflicting_name = name;
         return true;
+      }
       continue;
     }
 
     if (hit->second.type != iter->second.type ||
-        hit->second.size != iter->second.size)
+        hit->second.size != iter->second.size) {
+      *conflicting_name = name;
       return true;
+    }
 
   }
   return false;
 }
 
-bool Program::DetectGlobalNameConflicts() const {
+bool Program::DetectGlobalNameConflicts(std::string* conflicting_name) const {
   DCHECK(attached_shaders_[0] &&
          attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
          attached_shaders_[1] &&
          attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
   const ShaderTranslator::VariableMap* uniforms[2];
   uniforms[0] = &(attached_shaders_[0]->uniform_map());
   uniforms[1] = &(attached_shaders_[1]->uniform_map());
   const ShaderTranslator::VariableMap* attribs =
       &(attached_shaders_[0]->attrib_map());
 
   for (ShaderTranslator::VariableMap::const_iterator iter =
            attribs->begin(); iter != attribs->end(); ++iter) {
     for (int ii = 0; ii < 2; ++ii) {
-      if (uniforms[ii]->find(iter->first) != uniforms[ii]->end())
+      if (uniforms[ii]->find(iter->first) != uniforms[ii]->end()) {
+        *conflicting_name = iter->first;
         return true;
+      }
     }
   }
   return false;
 }
 
 bool Program::CheckVaryingsPacking() const {
   DCHECK(attached_shaders_[0] &&
          attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
          attached_shaders_[1] &&
          attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
@@ skipping 261 matching lines @@
     program->ClearUniforms(&zero_);
   }
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu