Changes the code to use separate ids namspaces...

gpu/command_buffer/service/program_manager_unittest.cc

 // Copyright (c) 2010 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 "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "gpu/command_buffer/service/gl_mock.h"
 
@@ skipping 20 matching lines @@
   virtual void SetUp() {
   }
 
   virtual void TearDown() {
   }
 
   ProgramManager manager_;
 };
 
 TEST_F(ProgramManagerTest, Basic) {
-  const GLuint kProgram1Id = 1;
-  const GLuint kProgram2Id = 2;
+  const GLuint kClient1Id = 1;
+  const GLuint kService1Id = 11;
+  const GLuint kClient2Id = 2;
   // Check we can create program.
-  manager_.CreateProgramInfo(kProgram1Id);
+  manager_.CreateProgramInfo(kClient1Id, kService1Id);
   // Check program got created.
-  ProgramManager::ProgramInfo* info1 = manager_.GetProgramInfo(kProgram1Id);
+  ProgramManager::ProgramInfo* info1 = manager_.GetProgramInfo(kClient1Id);
   ASSERT_TRUE(info1 != NULL);
+  EXPECT_EQ(kService1Id, info1->service_id());
   // Check we get nothing for a non-existent program.
-  EXPECT_TRUE(manager_.GetProgramInfo(kProgram2Id) == NULL);
+  EXPECT_TRUE(manager_.GetProgramInfo(kClient2Id) == NULL);
   // Check trying to a remove non-existent programs does not crash.
-  manager_.RemoveProgramInfo(kProgram2Id);
+  manager_.RemoveProgramInfo(kClient2Id);
   // Check we can't get the program after we remove it.
-  manager_.RemoveProgramInfo(kProgram1Id);
-  EXPECT_TRUE(manager_.GetProgramInfo(kProgram1Id) == NULL);
+  manager_.RemoveProgramInfo(kClient1Id);
+  EXPECT_TRUE(manager_.GetProgramInfo(kClient1Id) == NULL);
 }
 
 class ProgramManagerWithShaderTest : public testing::Test {
  public:
   ProgramManagerWithShaderTest()
       : program_info_(NULL) {
   }
 
   static const GLint kNumVertexAttribs = 16;
 
-  static const GLuint kProgramId = 123;
+  static const GLuint kClientProgramId = 123;
+  static const GLuint kServiceProgramId = 456;
 
   static const char* kAttrib1Name;
   static const char* kAttrib2Name;
   static const char* kAttrib3Name;
   static const GLint kAttrib1Size = 1;
   static const GLint kAttrib2Size = 1;
   static const GLint kAttrib3Size = 1;
   static const GLint kAttrib1Location = 0;
   static const GLint kAttrib2Location = 1;
   static const GLint kAttrib3Location = 2;
@@ skipping 35 matching lines @@
     GLenum type;
     GLint location;
   };
 
   virtual void SetUp() {
     gl_.reset(new StrictMock<MockGLInterface>());
     ::gles2::GLInterface::SetGLInterface(gl_.get());
 
     SetupDefaultShaderExpectations();
 
-    manager_.CreateProgramInfo(kProgramId);
-    program_info_ = manager_.GetProgramInfo(kProgramId);
+    manager_.CreateProgramInfo(kClientProgramId, kServiceProgramId);
+    program_info_ = manager_.GetProgramInfo(kClientProgramId);
     program_info_->Update();
   }
 
   void SetupShader(AttribInfo* attribs, size_t num_attribs,
                    UniformInfo* uniforms, size_t num_uniforms,
                    GLuint service_id) {
     InSequence s;
     EXPECT_CALL(*gl_,
         GetProgramiv(service_id, GL_ACTIVE_ATTRIBUTES, _))
         .WillOnce(SetArgumentPointee<2>(num_attribs))
@@ skipping 66 matching lines @@
                 .RetiresOnSaturation();
           }
         }
       }
     }
   }
 
 
   void SetupDefaultShaderExpectations() {
     SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
-                kProgramId);
+                kServiceProgramId);
   }
 
   virtual void TearDown() {
   }
 
   static AttribInfo kAttribs[];
   static UniformInfo kUniforms[];
 
   scoped_ptr<StrictMock<MockGLInterface> > gl_;
 
   ProgramManager manager_;
 
   ProgramManager::ProgramInfo* program_info_;
 };
 
 ProgramManagerWithShaderTest::AttribInfo
     ProgramManagerWithShaderTest::kAttribs[] = {
   { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
   { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
   { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
 const GLint ProgramManagerWithShaderTest::kNumVertexAttribs;
-const GLuint ProgramManagerWithShaderTest::kProgramId;
+const GLuint ProgramManagerWithShaderTest::kClientProgramId;
+const GLuint ProgramManagerWithShaderTest::kServiceProgramId;
 const GLint ProgramManagerWithShaderTest::kAttrib1Size;
 const GLint ProgramManagerWithShaderTest::kAttrib2Size;
 const GLint ProgramManagerWithShaderTest::kAttrib3Size;
 const GLint ProgramManagerWithShaderTest::kAttrib1Location;
 const GLint ProgramManagerWithShaderTest::kAttrib2Location;
 const GLint ProgramManagerWithShaderTest::kAttrib3Location;
 const GLenum ProgramManagerWithShaderTest::kAttrib1Type;
 const GLenum ProgramManagerWithShaderTest::kAttrib2Type;
 const GLenum ProgramManagerWithShaderTest::kAttrib3Type;
 const GLint ProgramManagerWithShaderTest::kInvalidAttribLocation;
@@ skipping 28 matching lines @@
 const char* ProgramManagerWithShaderTest::kAttrib2Name = "attrib2";
 const char* ProgramManagerWithShaderTest::kAttrib3Name = "attrib3";
 const char* ProgramManagerWithShaderTest::kUniform1Name = "uniform1";
 // Correctly has array spec.
 const char* ProgramManagerWithShaderTest::kUniform2Name = "uniform2[0]";
 // Incorrectly missing array spec.
 const char* ProgramManagerWithShaderTest::kUniform3Name = "uniform3";
 
 TEST_F(ProgramManagerWithShaderTest, GetAttribInfos) {
   const ProgramManager::ProgramInfo* program_info =
-      manager_.GetProgramInfo(kProgramId);
+      manager_.GetProgramInfo(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
   const ProgramManager::ProgramInfo::AttribInfoVector& infos =
       program_info->GetAttribInfos();
   for (size_t ii = 0; ii < kNumAttribs; ++ii) {
     const ProgramManager::ProgramInfo::VertexAttribInfo& info = infos[ii];
     const AttribInfo& expected = kAttribs[ii];
     EXPECT_EQ(expected.size, info.size);
     EXPECT_EQ(expected.type, info.type);
     EXPECT_EQ(expected.location, info.location);
     EXPECT_STREQ(expected.name, info.name.c_str());
   }
 }
 
 TEST_F(ProgramManagerWithShaderTest, GetAttribInfo) {
   const GLint kValidIndex = 1;
   const GLint kInvalidIndex = 1000;
   const ProgramManager::ProgramInfo* program_info =
-      manager_.GetProgramInfo(kProgramId);
+      manager_.GetProgramInfo(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
   const ProgramManager::ProgramInfo::VertexAttribInfo* info =
       program_info->GetAttribInfo(kValidIndex);
   ASSERT_TRUE(info != NULL);
   EXPECT_EQ(kAttrib2Size, info->size);
   EXPECT_EQ(kAttrib2Type, info->type);
   EXPECT_EQ(kAttrib2Location, info->location);
   EXPECT_STREQ(kAttrib2Name, info->name.c_str());
   EXPECT_TRUE(program_info->GetAttribInfo(kInvalidIndex) == NULL);
 }
 
 TEST_F(ProgramManagerWithShaderTest, GetAttribLocation) {
   const char* kInvalidName = "foo";
   const ProgramManager::ProgramInfo* program_info =
-      manager_.GetProgramInfo(kProgramId);
+      manager_.GetProgramInfo(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_EQ(kAttrib2Location, program_info->GetAttribLocation(kAttrib2Name));
   EXPECT_EQ(-1, program_info->GetAttribLocation(kInvalidName));
 }
 
 TEST_F(ProgramManagerWithShaderTest, GetUniformInfo) {
   const GLint kInvalidIndex = 1000;
   const ProgramManager::ProgramInfo* program_info =
-      manager_.GetProgramInfo(kProgramId);
+      manager_.GetProgramInfo(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
   const ProgramManager::ProgramInfo::UniformInfo* info =
       program_info->GetUniformInfo(0);
   ASSERT_TRUE(info != NULL);
   EXPECT_EQ(kUniform1Size, info->size);
   EXPECT_EQ(kUniform1Type, info->type);
   EXPECT_EQ(kUniform1Location, info->element_locations[0]);
   EXPECT_STREQ(kUniform1Name, info->name.c_str());
   info = program_info->GetUniformInfo(1);
   ASSERT_TRUE(info != NULL);
   EXPECT_EQ(kUniform2Size, info->size);
   EXPECT_EQ(kUniform2Type, info->type);
   EXPECT_EQ(kUniform2Location, info->element_locations[0]);
   EXPECT_STREQ(kUniform2Name, info->name.c_str());
   info = program_info->GetUniformInfo(2);
   // We emulate certain OpenGL drivers by supplying the name without
   // the array spec. Our implementation should correctly add the required spec.
   const std::string expected_name(std::string(kUniform3Name) + "[0]");
   ASSERT_TRUE(info != NULL);
   EXPECT_EQ(kUniform3Size, info->size);
   EXPECT_EQ(kUniform3Type, info->type);
   EXPECT_EQ(kUniform3Location, info->element_locations[0]);
   EXPECT_STREQ(expected_name.c_str(), info->name.c_str());
   EXPECT_TRUE(program_info->GetUniformInfo(kInvalidIndex) == NULL);
 }
 
 TEST_F(ProgramManagerWithShaderTest, GetUniformLocation) {
   const ProgramManager::ProgramInfo* program_info =
-      manager_.GetProgramInfo(kProgramId);
+      manager_.GetProgramInfo(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_EQ(kUniform1Location, program_info->GetUniformLocation(kUniform1Name));
   EXPECT_EQ(kUniform2Location, program_info->GetUniformLocation(kUniform2Name));
   EXPECT_EQ(kUniform3Location, program_info->GetUniformLocation(kUniform3Name));
   // Check we can get uniform2 as "uniform2" even though the name is
   // "uniform2[0]"
   EXPECT_EQ(kUniform2Location, program_info->GetUniformLocation("uniform2"));
   // Check we can get uniform3 as "uniform3[0]" even though we simulated GL
   // returning "uniform3"
   EXPECT_EQ(kUniform3Location, program_info->GetUniformLocation("uniform3[0]"));
   // Check that we can get the locations of the array elements > 1
   EXPECT_EQ(kUniform2Location + 2,
             program_info->GetUniformLocation("uniform2[1]"));
   EXPECT_EQ(kUniform2Location + 4,
             program_info->GetUniformLocation("uniform2[2]"));
   EXPECT_EQ(-1,
             program_info->GetUniformLocation("uniform2[3]"));
   EXPECT_EQ(kUniform3Location + 2,
             program_info->GetUniformLocation("uniform3[1]"));
   EXPECT_EQ(-1,
             program_info->GetUniformLocation("uniform3[2]"));
 }
 
 TEST_F(ProgramManagerWithShaderTest, GetUniformTypeByLocation) {
   const GLint kInvalidLocation = 1234;
   GLenum type = 0u;
   const ProgramManager::ProgramInfo* program_info =
-      manager_.GetProgramInfo(kProgramId);
+      manager_.GetProgramInfo(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_TRUE(program_info->GetUniformTypeByLocation(kUniform2Location, &type));
   EXPECT_EQ(kUniform2Type, type);
   type = 0u;
   EXPECT_FALSE(program_info->GetUniformTypeByLocation(
       kInvalidLocation, &type));
   EXPECT_EQ(0u, type);
 }
 
 // Some GL drivers incorrectly return gl_DepthRange and possibly other uniforms
 // 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, kUniform1Location, },
     { kUniform2Name, kUniform2Size, kUniform2Type, kUniform2Location, },
     { kUniform3Name, kUniform3Size, kUniform3Type, kUniform3Location, },
   };
   const size_t kNumUniforms = arraysize(kUniforms);
-  static const GLuint kProgramId = 1234;
-  SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms, kProgramId);
-  manager_.CreateProgramInfo(kProgramId);
+  static const GLuint kClientProgramId = 1234;
+  static const GLuint kServiceProgramId = 5679;
+  SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
+              kServiceProgramId);
+  manager_.CreateProgramInfo(kClientProgramId, kServiceProgramId);
   ProgramManager::ProgramInfo* program_info =
-      manager_.GetProgramInfo(kProgramId);
+      manager_.GetProgramInfo(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
   program_info->Update();
   GLint value = 0;
   program_info->GetProgramiv(GL_ACTIVE_ATTRIBUTES, &value);
   EXPECT_EQ(3, value);
   // Check that we skipped the "gl_" uniform.
   program_info->GetProgramiv(GL_ACTIVE_UNIFORMS, &value);
   EXPECT_EQ(2, value);
   // Check that our max length adds room for the array spec and is not as long
   // as the "gl_" uniform we skipped.
   program_info->GetProgramiv(GL_ACTIVE_UNIFORM_MAX_LENGTH, &value);
   EXPECT_EQ(strlen(kUniform3Name) + 3u, static_cast<size_t>(value));
 }
 
 }  // namespace gles2
 }  // namespace gpu