Report relevant variable names in info logs on failed shader link

gpu/command_buffer/service/program_manager_unittest.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 "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 1237 matching lines @@
 
   // Set up program
   const GLuint kClientProgramId = 6666;
   const GLuint kServiceProgramId = 8888;
   Program* program =
       manager_.CreateProgram(kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 
-  EXPECT_TRUE(program->DetectUniformsMismatch());
+  std::string conflicting_name;
+
+  EXPECT_TRUE(program->DetectUniformsMismatch(&conflicting_name));
+  EXPECT_EQ(conflicting_name, "a");
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // If a varying has different type in the vertex and fragment
 // shader, linking should fail.
 TEST_F(ProgramManagerWithShaderTest, VaryingTypeMismatch) {
   const VarInfo kVertexVarying =
       { SH_FLOAT_VEC3, 1, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
   const VarInfo kFragmentVarying =
       { SH_FLOAT_VEC4, 1, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
   Program* program = SetupShaderVariableTest(
       &kVertexVarying, 1, &kFragmentVarying, 1);
 
-  EXPECT_TRUE(program->DetectVaryingsMismatch());
+  std::string conflicting_name;
+
+  EXPECT_TRUE(program->DetectVaryingsMismatch(&conflicting_name));
+  EXPECT_EQ(conflicting_name, "a");
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // If a varying has different array size in the vertex and fragment
 // shader, linking should fail.
 TEST_F(ProgramManagerWithShaderTest, VaryingArraySizeMismatch) {
   const VarInfo kVertexVarying =
       { SH_FLOAT, 2, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
   const VarInfo kFragmentVarying =
       { SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
   Program* program = SetupShaderVariableTest(
       &kVertexVarying, 1, &kFragmentVarying, 1);
 
-  EXPECT_TRUE(program->DetectVaryingsMismatch());
+  std::string conflicting_name;
+
+  EXPECT_TRUE(program->DetectVaryingsMismatch(&conflicting_name));
+  EXPECT_EQ(conflicting_name, "a");
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // If a varying has different precision in the vertex and fragment
 // shader, linking should succeed.
 TEST_F(ProgramManagerWithShaderTest, VaryingPrecisionMismatch) {
   const VarInfo kVertexVarying =
       { SH_FLOAT, 2, SH_PRECISION_HIGHP, 1, "a", kVarVarying };
   const VarInfo kFragmentVarying =
       { SH_FLOAT, 2, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
   Program* program = SetupShaderVariableTest(
       &kVertexVarying, 1, &kFragmentVarying, 1);
 
-  EXPECT_FALSE(program->DetectVaryingsMismatch());
+  std::string conflicting_name;
+
+  EXPECT_FALSE(program->DetectVaryingsMismatch(&conflicting_name));
+  EXPECT_TRUE(conflicting_name.empty());
   EXPECT_TRUE(LinkAsExpected(program, true));
 }
 
 // If a varying is statically used in fragment shader but not
 // declared in vertex shader, link should fail.
 TEST_F(ProgramManagerWithShaderTest, VaryingMissing) {
   const VarInfo kFragmentVarying =
       { SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
   Program* program = SetupShaderVariableTest(
       NULL, 0, &kFragmentVarying, 1);
 
-  EXPECT_TRUE(program->DetectVaryingsMismatch());
+  std::string conflicting_name;
+
+  EXPECT_TRUE(program->DetectVaryingsMismatch(&conflicting_name));
+  EXPECT_EQ(conflicting_name, "a");

[Ken Russell (switch to Gerrit), 2014/01/09 21:40:03]

The constant should come first in these expressions: e.g. EXPECT_EQ("a",
conflicting_name).

   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // If a varying is declared but not statically used in fragment
 // shader, even if it's not declared in vertex shader, link should
 // succeed.
 TEST_F(ProgramManagerWithShaderTest, InactiveVarying) {
   const VarInfo kFragmentVarying =
       { SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 0, "a", kVarVarying };
   Program* program = SetupShaderVariableTest(
       NULL, 0, &kFragmentVarying, 1);
 
-  EXPECT_FALSE(program->DetectVaryingsMismatch());
+  std::string conflicting_name;
+
+  EXPECT_FALSE(program->DetectVaryingsMismatch(&conflicting_name));
+  EXPECT_TRUE(conflicting_name.empty());
   EXPECT_TRUE(LinkAsExpected(program, true));
 }
 
 // Uniforms and attributes are both global variables, thus sharing
 // the same namespace. Any name conflicts should cause link
 // failure.
 TEST_F(ProgramManagerWithShaderTest, AttribUniformNameConflict) {
   const VarInfo kVertexAttribute =
       { SH_FLOAT_VEC4, 1, SH_PRECISION_MEDIUMP, 1, "a", kVarAttribute };
   const VarInfo kFragmentUniform =
       { SH_FLOAT_VEC4, 1, SH_PRECISION_MEDIUMP, 1, "a", kVarUniform };
   Program* program = SetupShaderVariableTest(
       &kVertexAttribute, 1, &kFragmentUniform, 1);
 
-  EXPECT_TRUE(program->DetectGlobalNameConflicts());
+  std::string conflicting_name;
+
+  EXPECT_TRUE(program->DetectGlobalNameConflicts(&conflicting_name));
+  EXPECT_EQ(conflicting_name, "a");
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // Varyings go over 8 rows.
 TEST_F(ProgramManagerWithShaderTest, TooManyVaryings) {
   const VarInfo kVertexVaryings[] = {
       { SH_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying },
       { SH_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b", kVarVarying }
   };
   const VarInfo kFragmentVaryings[] = {
@@ skipping 397 matching lines @@
   SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS);
   SetExpectationsForNotCachingProgram();
   SetExpectationsForProgramLoadSuccess();
 
   EXPECT_TRUE(program_->Link(NULL, NULL, NULL, NULL,
                              base::Bind(&ShaderCacheCb)));
 }
 
 }  // namespace gles2
 }  // namespace gpu