Add glBindUniformLocationCHROMIUM

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/string_number_conversions.h"
@@ skipping 161 matching lines @@
   static const char* kUniform3GoodName;
   static const GLint kUniform1Size = 1;
   static const GLint kUniform2Size = 3;
   static const GLint kUniform3Size = 2;
   static const GLint kUniform1FakeLocation = 0;  // These are hard coded
   static const GLint kUniform2FakeLocation = 1;  // to match
   static const GLint kUniform3FakeLocation = 2;  // ProgramManager.
   static const GLint kUniform1RealLocation = 11;
   static const GLint kUniform2RealLocation = 22;
   static const GLint kUniform3RealLocation = 33;
+  static const GLint kUniform1DesiredLocation = -1;
+  static const GLint kUniform2DesiredLocation = -1;
+  static const GLint kUniform3DesiredLocation = -1;
   static const GLenum kUniform1Type = GL_FLOAT_VEC4;
   static const GLenum kUniform2Type = GL_INT_VEC2;
   static const GLenum kUniform3Type = GL_FLOAT_VEC3;
   static const GLint kInvalidUniformLocation = 30;
   static const GLint kBadUniformIndex = 1000;
 
   static const size_t kNumAttribs;
   static const size_t kNumUniforms;
 
  protected:
@@ skipping 101 matching lines @@
 const GLint ProgramManagerWithShaderTest::kBadAttribIndex;
 const GLint ProgramManagerWithShaderTest::kUniform1Size;
 const GLint ProgramManagerWithShaderTest::kUniform2Size;
 const GLint ProgramManagerWithShaderTest::kUniform3Size;
 const GLint ProgramManagerWithShaderTest::kUniform1FakeLocation;
 const GLint ProgramManagerWithShaderTest::kUniform2FakeLocation;
 const GLint ProgramManagerWithShaderTest::kUniform3FakeLocation;
 const GLint ProgramManagerWithShaderTest::kUniform1RealLocation;
 const GLint ProgramManagerWithShaderTest::kUniform2RealLocation;
 const GLint ProgramManagerWithShaderTest::kUniform3RealLocation;
+const GLint ProgramManagerWithShaderTest::kUniform1DesiredLocation;
+const GLint ProgramManagerWithShaderTest::kUniform2DesiredLocation;
+const GLint ProgramManagerWithShaderTest::kUniform3DesiredLocation;
 const GLenum ProgramManagerWithShaderTest::kUniform1Type;
 const GLenum ProgramManagerWithShaderTest::kUniform2Type;
 const GLenum ProgramManagerWithShaderTest::kUniform3Type;
 const GLint ProgramManagerWithShaderTest::kInvalidUniformLocation;
 const GLint ProgramManagerWithShaderTest::kBadUniformIndex;
 #endif
 
 const size_t ProgramManagerWithShaderTest::kNumAttribs =
     arraysize(ProgramManagerWithShaderTest::kAttribs);
 
 ProgramManagerWithShaderTest::UniformInfo
     ProgramManagerWithShaderTest::kUniforms[] = {
   { kUniform1Name,
     kUniform1Size,
     kUniform1Type,
     kUniform1FakeLocation,
     kUniform1RealLocation,
+    kUniform1DesiredLocation,
     kUniform1Name,
   },
   { kUniform2Name,
     kUniform2Size,
     kUniform2Type,
     kUniform2FakeLocation,
     kUniform2RealLocation,
+    kUniform2DesiredLocation,
     kUniform2Name,
   },
   { kUniform3BadName,
     kUniform3Size,
     kUniform3Type,
     kUniform3FakeLocation,
     kUniform3RealLocation,
+    kUniform3DesiredLocation,
     kUniform3GoodName,
   },
 };
 
 const size_t ProgramManagerWithShaderTest::kNumUniforms =
     arraysize(ProgramManagerWithShaderTest::kUniforms);
 
 const char* ProgramManagerWithShaderTest::kAttrib1Name = "attrib1";
 const char* ProgramManagerWithShaderTest::kAttrib2Name = "attrib2";
 const char* ProgramManagerWithShaderTest::kAttrib3Name = "attrib3";
@@ skipping 132 matching lines @@
              program_info->GetUniformFakeLocation(kUniform3BadName));
   // Check we can get uniform2 as "uniform2" even though the name is
   // "uniform2[0]"
   EXPECT_EQ(kUniform2FakeLocation,
             program_info->GetUniformFakeLocation("uniform2"));
   // Check we can get uniform3 as "uniform3[0]" even though we simulated GL
   // returning "uniform3"
   EXPECT_EQ(kUniform3FakeLocation,
             program_info->GetUniformFakeLocation(kUniform3GoodName));
   // Check that we can get the locations of the array elements > 1
-  EXPECT_EQ(GLES2Util::MakeFakeLocation(kUniform2FakeLocation, 1),
+  EXPECT_EQ(ProgramManager::MakeFakeLocation(kUniform2FakeLocation, 1),
             program_info->GetUniformFakeLocation("uniform2[1]"));
-  EXPECT_EQ(GLES2Util::MakeFakeLocation(kUniform2FakeLocation, 2),
+  EXPECT_EQ(ProgramManager::MakeFakeLocation(kUniform2FakeLocation, 2),
             program_info->GetUniformFakeLocation("uniform2[2]"));
   EXPECT_EQ(-1, program_info->GetUniformFakeLocation("uniform2[3]"));
-  EXPECT_EQ(GLES2Util::MakeFakeLocation(kUniform3FakeLocation, 1),
+  EXPECT_EQ(ProgramManager::MakeFakeLocation(kUniform3FakeLocation, 1),
             program_info->GetUniformFakeLocation("uniform3[1]"));
   EXPECT_EQ(-1, program_info->GetUniformFakeLocation("uniform3[2]"));
 }
 
 TEST_F(ProgramManagerWithShaderTest, GetUniformInfoByFakeLocation) {
   const GLint kInvalidLocation = 1234;
   const ProgramManager::ProgramInfo::UniformInfo* info;
   const ProgramManager::ProgramInfo* program_info =
       manager_.GetProgramInfo(kClientProgramId);
   GLint real_location = -1;
@@ skipping 24 matching lines @@
 // that start with "gl_". Our implementation catches these and does not allow
 // them back to client.
 TEST_F(ProgramManagerWithShaderTest, GLDriverReturnsGLUnderscoreUniform) {
   static const char* kUniform2Name = "gl_longNameWeCanCheckFor";
   static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
     { kUniform1Name,
       kUniform1Size,
       kUniform1Type,
       kUniform1FakeLocation,
       kUniform1RealLocation,
+      kUniform1DesiredLocation,
       kUniform1Name,
     },
     { kUniform2Name,
       kUniform2Size,
       kUniform2Type,
       kUniform2FakeLocation,
       kUniform2RealLocation,
+      kUniform2DesiredLocation,
       kUniform2Name,
     },
     { kUniform3BadName,
       kUniform3Size,
       kUniform3Type,
       kUniform3FakeLocation,
       kUniform3RealLocation,
+      kUniform3DesiredLocation,
       kUniform3GoodName,
     },
   };
   const size_t kNumUniforms = arraysize(kUniforms);
   static const GLuint kClientProgramId = 1234;
   static const GLuint kServiceProgramId = 5679;
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
@@ skipping 68 matching lines @@
     { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
     { kAttrib2Name, kAttrib2Size, kAttrib2BadType, kAttrib2Location, },
     { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
   };
   static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
     { kUniform1Name,
       kUniform1Size,
       kUniform1Type,
       kUniform1FakeLocation,
       kUniform1RealLocation,
+      kUniform1DesiredLocation,
       kUniform1Name,
     },
     { kUniform2Name,
       kUniform2Size,
       kUniform2BadType,
       kUniform2FakeLocation,
       kUniform2RealLocation,
+      kUniform2DesiredLocation,
       kUniform2Name,
     },
     { kUniform3BadName,
       kUniform3Size,
       kUniform3Type,
       kUniform3FakeLocation,
       kUniform3RealLocation,
+      kUniform3DesiredLocation,
       kUniform3GoodName,
     },
   };
   const size_t kNumAttribs= arraysize(kAttribs);
   const size_t kNumUniforms = arraysize(kUniforms);
   static const GLuint kClientProgramId = 1234;
   static const GLuint kServiceProgramId = 5679;
   SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
               kServiceProgramId);
   ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
@@ skipping 166 matching lines @@
   }
   // TODO(gman): Don't assume these are in order.
   for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
     const UniformInfo& expected = kUniforms[ii];
     EXPECT_EQ(expected.size, input->size);
     EXPECT_EQ(expected.type, input->type);
     const int32* locations = bucket.GetDataAs<const int32*>(
         input->location_offset, sizeof(int32) * input->size);
     ASSERT_TRUE(locations != NULL);
     for (int32 jj = 0; jj < input->size; ++jj) {
-      EXPECT_EQ(GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(expected.fake_location, jj)),
+      EXPECT_EQ(
+          ProgramManager::MakeFakeLocation(expected.fake_location, jj),
           locations[jj]);
     }
     const char* name_buf = bucket.GetDataAs<const char*>(
         input->name_offset, input->name_length);
     ASSERT_TRUE(name_buf != NULL);
     std::string name(name_buf, input->name_length);
     EXPECT_STREQ(expected.good_name, name.c_str());
     ++input;
   }
   EXPECT_EQ(header->num_attribs + header->num_uniforms,
@@ skipping 101 matching lines @@
       { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
       { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
       { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
     };
     ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
       { kUniform1Name,
         kUniform1Size,
         kUniform1Type,
         kUniform1FakeLocation,
         kUniform1RealLocation,
+        kUniform1DesiredLocation,
         kUniform1Name,
       },
       { kUniform2Name,
         kUniform2Size,
         kSamplerTypes[ii],
         kUniform2FakeLocation,
         kUniform2RealLocation,
+        kUniform2DesiredLocation,
         kUniform2Name,
       },
       { kUniform3BadName,
         kUniform3Size,
         kUniform3Type,
         kUniform3FakeLocation,
         kUniform3RealLocation,
+        kUniform3DesiredLocation,
         kUniform3GoodName,
       },
     };
     const size_t kNumAttribs = arraysize(kAttribs);
     const size_t kNumUniforms = arraysize(kUniforms);
     SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                 kServiceProgramId);
     program_info->Link();
     SetupExpectationsForClearingUniforms(kUniforms, kNumUniforms);
     manager_.ClearUniforms(program_info);
   }
 }
 
-TEST_F(ProgramManagerWithShaderTest, UniformsAreSorted) {
+TEST_F(ProgramManagerWithShaderTest, BindUniformLocation) {
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
+
+  const GLint kUniform1DesiredLocation = 10;
+  const GLint kUniform2DesiredLocation = -1;
+  const GLint kUniform3DesiredLocation = 5;
+
   ShaderManager::ShaderInfo* vshader = shader_manager_.CreateShaderInfo(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
-  vshader->SetStatus(true, "", NULL);
+  vshader->SetStatus(true, NULL, NULL);
   ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
-  fshader->SetStatus(true, "", NULL);
+  fshader->SetStatus(true, NULL, NULL);
+  static const GLuint kClientProgramId = 1234;
+  static const GLuint kServiceProgramId = 5679;
+  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
+      kClientProgramId, kServiceProgramId);
+  ASSERT_TRUE(program_info != NULL);
+  EXPECT_TRUE(program_info->AttachShader(&shader_manager_, vshader));
+  EXPECT_TRUE(program_info->AttachShader(&shader_manager_, fshader));
+  EXPECT_TRUE(program_info->SetUniformLocationBinding(
+      kUniform1Name, kUniform1DesiredLocation));
+  EXPECT_TRUE(program_info->SetUniformLocationBinding(
+      kUniform3BadName, kUniform3DesiredLocation));
+
   static ProgramManagerWithShaderTest::AttribInfo kAttribs[] = {
     { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
     { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
     { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
   };
-  static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
+  ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
+    { kUniform1Name,
+      kUniform1Size,
+      kUniform1Type,
+      kUniform1FakeLocation,
+      kUniform1RealLocation,
+      kUniform1DesiredLocation,
+      kUniform1Name,
+    },
     { kUniform2Name,
       kUniform2Size,
       kUniform2Type,
       kUniform2FakeLocation,
       kUniform2RealLocation,
+      kUniform2DesiredLocation,
       kUniform2Name,
     },
-    { kUniform3GoodName,
+    { kUniform3BadName,
       kUniform3Size,
       kUniform3Type,
       kUniform3FakeLocation,
       kUniform3RealLocation,
+      kUniform3DesiredLocation,
       kUniform3GoodName,
     },
-    { kUniform1Name,
-      kUniform1Size,
-      kUniform1Type,
-      kUniform1FakeLocation,
-      kUniform1RealLocation,
-      kUniform1Name,
-    },
   };
-  const size_t kNumAttribs= arraysize(kAttribs);
+
+  const size_t kNumAttribs = arraysize(kAttribs);
   const size_t kNumUniforms = arraysize(kUniforms);
-  static const GLuint kClientProgramId = 1234;
-  static const GLuint kServiceProgramId = 5679;
   SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
               kServiceProgramId);
-  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
-      kClientProgramId, kServiceProgramId);
-  ASSERT_TRUE(program_info != NULL);
-  EXPECT_TRUE(program_info->AttachShader(&shader_manager_, vshader));
-  EXPECT_TRUE(program_info->AttachShader(&shader_manager_, fshader));
   program_info->Link();
-  // Check Uniforms
-  const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
-        program_info->GetUniformInfo(0);
-  ASSERT_TRUE(uniform_info != NULL);
-  EXPECT_STREQ(kUniform1Name, uniform_info->name.c_str());
-  EXPECT_EQ(0, uniform_info->fake_location_base);
-  uniform_info = program_info->GetUniformInfo(1);
-  ASSERT_TRUE(uniform_info != NULL);
-  EXPECT_STREQ(kUniform2Name, uniform_info->name.c_str());
-  EXPECT_EQ(1, uniform_info->fake_location_base);
-  uniform_info = program_info->GetUniformInfo(2);
-  ASSERT_TRUE(uniform_info != NULL);
-  EXPECT_STREQ(kUniform3GoodName, uniform_info->name.c_str());
-  EXPECT_EQ(2, uniform_info->fake_location_base);
+
+  EXPECT_EQ(kUniform1DesiredLocation,
+            program_info->GetUniformFakeLocation(kUniform1Name));
+  EXPECT_EQ(kUniform3DesiredLocation,
+            program_info->GetUniformFakeLocation(kUniform3BadName));
+  EXPECT_EQ(kUniform3DesiredLocation,
+            program_info->GetUniformFakeLocation(kUniform3GoodName));
 }
 
 }  // namespace gles2
 }  // namespace gpu