Refactor/Rename a bunch of GPU stuff

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 44 matching lines @@
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
   ProgramManager manager_;
 };
 
 TEST_F(ProgramManagerTest, Basic) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLuint kClient2Id = 2;
   // Check we can create program.
-  manager_.CreateProgramInfo(kClient1Id, kService1Id);
+  manager_.CreateProgram(kClient1Id, kService1Id);
   // Check program got created.
-  ProgramManager::ProgramInfo* info1 = manager_.GetProgramInfo(kClient1Id);
+  Program* info1 = manager_.GetProgram(kClient1Id);
   ASSERT_TRUE(info1 != NULL);
   GLuint client_id = 0;
   EXPECT_TRUE(manager_.GetClientId(info1->service_id(), &client_id));
   EXPECT_EQ(kClient1Id, client_id);
   // Check we get nothing for a non-existent program.
-  EXPECT_TRUE(manager_.GetProgramInfo(kClient2Id) == NULL);
+  EXPECT_TRUE(manager_.GetProgram(kClient2Id) == NULL);
 }
 
 TEST_F(ProgramManagerTest, Destroy) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   // Check we can create program.
-  ProgramManager::ProgramInfo* info0 = manager_.CreateProgramInfo(
+  Program* info0 = manager_.CreateProgram(
       kClient1Id, kService1Id);
   ASSERT_TRUE(info0 != NULL);
   // Check program got created.
-  ProgramManager::ProgramInfo* info1 = manager_.GetProgramInfo(kClient1Id);
+  Program* info1 = manager_.GetProgram(kClient1Id);
   ASSERT_EQ(info0, info1);
   EXPECT_CALL(*gl_, DeleteProgram(kService1Id))
       .Times(1)
       .RetiresOnSaturation();
   manager_.Destroy(true);
   // Check the resources were released.
-  info1 = manager_.GetProgramInfo(kClient1Id);
+  info1 = manager_.GetProgram(kClient1Id);
   ASSERT_TRUE(info1 == NULL);
 }
 
 TEST_F(ProgramManagerTest, DeleteBug) {
   ShaderManager shader_manager;
   const GLuint kClient1Id = 1;
   const GLuint kClient2Id = 2;
   const GLuint kService1Id = 11;
   const GLuint kService2Id = 12;
   // Check we can create program.
-  ProgramManager::ProgramInfo::Ref info1(
-      manager_.CreateProgramInfo(kClient1Id, kService1Id));
-  ProgramManager::ProgramInfo::Ref info2(
-      manager_.CreateProgramInfo(kClient2Id, kService2Id));
+  scoped_refptr<Program> info1(
+      manager_.CreateProgram(kClient1Id, kService1Id));
+  scoped_refptr<Program> info2(
+      manager_.CreateProgram(kClient2Id, kService2Id));
   // Check program got created.
   ASSERT_TRUE(info1);
   ASSERT_TRUE(info2);
   manager_.UseProgram(info1);
   manager_.MarkAsDeleted(&shader_manager, info1);
   //  Program will be deleted when last ref is released.
   EXPECT_CALL(*gl_, DeleteProgram(kService2Id))
       .Times(1)
       .RetiresOnSaturation();
   manager_.MarkAsDeleted(&shader_manager, info2);
   EXPECT_TRUE(manager_.IsOwned(info1));
   EXPECT_FALSE(manager_.IsOwned(info2));
 }
 
-TEST_F(ProgramManagerTest, ProgramInfo) {
+TEST_F(ProgramManagerTest, Program) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   // Check we can create program.
-  ProgramManager::ProgramInfo* info1 = manager_.CreateProgramInfo(
+  Program* info1 = manager_.CreateProgram(
       kClient1Id, kService1Id);
   ASSERT_TRUE(info1);
   EXPECT_EQ(kService1Id, info1->service_id());
   EXPECT_FALSE(info1->InUse());
   EXPECT_FALSE(info1->IsValid());
   EXPECT_FALSE(info1->IsDeleted());
   EXPECT_FALSE(info1->CanLink());
   EXPECT_TRUE(info1->log_info() == NULL);
 }
 
@@ skipping 60 matching lines @@
  protected:
   typedef TestHelper::AttribInfo AttribInfo;
   typedef TestHelper::UniformInfo UniformInfo;
 
   virtual void SetUp() {
     gl_.reset(new StrictMock<gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
 
     SetupDefaultShaderExpectations();
 
-    ShaderManager::ShaderInfo* vertex_shader = shader_manager_.CreateShaderInfo(
+    Shader* vertex_shader = shader_manager_.CreateShader(
         kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
-    ShaderManager::ShaderInfo* fragment_shader =
-        shader_manager_.CreateShaderInfo(
+    Shader* fragment_shader =
+        shader_manager_.CreateShader(
             kFragmentShaderClientId, kFragmentShaderServiceId,
             GL_FRAGMENT_SHADER);
     ASSERT_TRUE(vertex_shader != NULL);
     ASSERT_TRUE(fragment_shader != NULL);
     vertex_shader->SetStatus(true, NULL, NULL);
     fragment_shader->SetStatus(true, NULL, NULL);
 
-    program_info_ = manager_.CreateProgramInfo(
+    program_info_ = manager_.CreateProgram(
         kClientProgramId, kServiceProgramId);
     ASSERT_TRUE(program_info_ != NULL);
 
     program_info_->AttachShader(&shader_manager_, vertex_shader);
     program_info_->AttachShader(&shader_manager_, fragment_shader);
     program_info_->Link(NULL, NULL, NULL, NULL);
   }
 
   void SetupShader(AttribInfo* attribs, size_t num_attribs,
                    UniformInfo* uniforms, size_t num_uniforms,
@@ skipping 11 matching lines @@
       UniformInfo* uniforms, size_t num_uniforms) {
     TestHelper::SetupExpectationsForClearingUniforms(
         gl_.get(), uniforms, num_uniforms);
   }
 
   virtual void TearDown() {
     ::gfx::GLInterface::SetGLInterface(NULL);
   }
 
   // Return true if link status matches expected_link_status
-  bool LinkAsExpected(ProgramManager::ProgramInfo* program_info,
+  bool LinkAsExpected(Program* program_info,
                       bool expected_link_status) {
     GLuint service_id = program_info->service_id();
     if (expected_link_status) {
       SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                   service_id);
     }
     program_info->Link(NULL, NULL, NULL, NULL);
     GLint link_status;
     program_info->GetProgramiv(GL_LINK_STATUS, &link_status);
     return (static_cast<bool>(link_status) == expected_link_status);
   }
 
   static AttribInfo kAttribs[];
   static UniformInfo kUniforms[];
 
   scoped_ptr<StrictMock<gfx::MockGLInterface> > gl_;
 
   ProgramManager manager_;
-  ProgramManager::ProgramInfo* program_info_;
+  Program* program_info_;
   ShaderManager shader_manager_;
 };
 
 ProgramManagerWithShaderTest::AttribInfo
     ProgramManagerWithShaderTest::kAttribs[] = {
   { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
   { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
   { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
 };
 
@@ skipping 74 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::kUniform3BadName = "uniform3";
 const char* ProgramManagerWithShaderTest::kUniform3GoodName = "uniform3[0]";
 
 TEST_F(ProgramManagerWithShaderTest, GetAttribInfos) {
-  const ProgramManager::ProgramInfo* program_info =
-      manager_.GetProgramInfo(kClientProgramId);
+  const Program* program_info =
+      manager_.GetProgram(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
-  const ProgramManager::ProgramInfo::AttribInfoVector& infos =
+  const Program::AttribInfoVector& infos =
       program_info->GetAttribInfos();
   ASSERT_EQ(kNumAttribs, infos.size());
   for (size_t ii = 0; ii < kNumAttribs; ++ii) {
-    const ProgramManager::ProgramInfo::VertexAttribInfo& info = infos[ii];
+    const Program::VertexAttrib& 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(kClientProgramId);
+  const Program* program_info =
+      manager_.GetProgram(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
-  const ProgramManager::ProgramInfo::VertexAttribInfo* info =
+  const Program::VertexAttrib* 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(kClientProgramId);
+  const Program* program_info =
+      manager_.GetProgram(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(kClientProgramId);
+  const Program* program_info =
+      manager_.GetProgram(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
-  const ProgramManager::ProgramInfo::UniformInfo* info =
+  const Program::UniformInfo* info =
       program_info->GetUniformInfo(0);
   ASSERT_TRUE(info != NULL);
   EXPECT_EQ(kUniform1Size, info->size);
   EXPECT_EQ(kUniform1Type, info->type);
   EXPECT_EQ(kUniform1RealLocation, 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(kUniform2RealLocation, 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.
   ASSERT_TRUE(info != NULL);
   EXPECT_EQ(kUniform3Size, info->size);
   EXPECT_EQ(kUniform3Type, info->type);
   EXPECT_EQ(kUniform3RealLocation, info->element_locations[0]);
   EXPECT_STREQ(kUniform3GoodName, info->name.c_str());
   EXPECT_TRUE(program_info->GetUniformInfo(kInvalidIndex) == NULL);
 }
 
 TEST_F(ProgramManagerWithShaderTest, AttachDetachShader) {
   static const GLuint kClientProgramId = 124;
   static const GLuint kServiceProgramId = 457;
-  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
+  Program* program_info = manager_.CreateProgram(
       kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_FALSE(program_info->CanLink());
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
-  ShaderManager::ShaderInfo* vshader = shader_manager_.CreateShaderInfo(
+  Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   vshader->SetStatus(true, "", NULL);
-  ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
+  Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   fshader->SetStatus(true, "", NULL);
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, vshader));
   EXPECT_FALSE(program_info->CanLink());
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, fshader));
   EXPECT_TRUE(program_info->CanLink());
   program_info->DetachShader(&shader_manager_, vshader);
   EXPECT_FALSE(program_info->CanLink());
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, vshader));
@@ skipping 10 matching lines @@
   EXPECT_TRUE(program_info->CanLink());
   fshader->SetStatus(false, "", NULL);
   EXPECT_FALSE(program_info->CanLink());
   fshader->SetStatus(true, "", NULL);
   EXPECT_TRUE(program_info->CanLink());
   EXPECT_TRUE(program_info->DetachShader(&shader_manager_, fshader));
   EXPECT_FALSE(program_info->DetachShader(&shader_manager_, fshader));
 }
 
 TEST_F(ProgramManagerWithShaderTest, GetUniformFakeLocation) {
-  const ProgramManager::ProgramInfo* program_info =
-      manager_.GetProgramInfo(kClientProgramId);
+  const Program* program_info =
+      manager_.GetProgram(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_EQ(kUniform1FakeLocation,
             program_info->GetUniformFakeLocation(kUniform1Name));
   EXPECT_EQ(kUniform2FakeLocation,
             program_info->GetUniformFakeLocation(kUniform2Name));
   EXPECT_EQ(kUniform3FakeLocation,
              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(ProgramManager::MakeFakeLocation(kUniform2FakeLocation, 1),
             program_info->GetUniformFakeLocation("uniform2[1]"));
   EXPECT_EQ(ProgramManager::MakeFakeLocation(kUniform2FakeLocation, 2),
             program_info->GetUniformFakeLocation("uniform2[2]"));
   EXPECT_EQ(-1, program_info->GetUniformFakeLocation("uniform2[3]"));
   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);
+  const Program::UniformInfo* info;
+  const Program* program_info =
+      manager_.GetProgram(kClientProgramId);
   GLint real_location = -1;
   GLint array_index = -1;
   ASSERT_TRUE(program_info != NULL);
   info = program_info->GetUniformInfoByFakeLocation(
       kUniform2FakeLocation, &real_location, &array_index);
   EXPECT_EQ(kUniform2RealLocation, real_location);
   EXPECT_EQ(0, array_index);
   ASSERT_TRUE(info != NULL);
   EXPECT_EQ(kUniform2Type, info->type);
   real_location = -1;
@@ skipping 44 matching lines @@
   };
   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;
   SetupShader(
       kAttribs, kNumAttribs, kUniforms, kNumUniforms, kServiceProgramId);
-  ShaderManager::ShaderInfo* vshader = shader_manager_.CreateShaderInfo(
+  Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   vshader->SetStatus(true, "", NULL);
-  ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
+  Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   fshader->SetStatus(true, "", NULL);
-  ProgramManager::ProgramInfo* program_info =
-      manager_.CreateProgramInfo(kClientProgramId, kServiceProgramId);
+  Program* program_info =
+      manager_.CreateProgram(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(NULL, NULL, NULL, NULL);
   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);
@@ skipping 38 matching lines @@
   };
   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;
   SetupShader(
       kAttribs, kNumAttribs, kUniforms, kNumUniforms, kServiceProgramId);
-  ShaderManager::ShaderInfo* vshader = shader_manager_.CreateShaderInfo(
+  Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   vshader->SetStatus(true, "", NULL);
-  ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
+  Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   fshader->SetStatus(true, "", NULL);
-  ProgramManager::ProgramInfo* program_info =
-      manager_.CreateProgramInfo(kClientProgramId, kServiceProgramId);
+  Program* program_info =
+      manager_.CreateProgram(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(NULL, NULL, NULL, NULL);
 
   // Check that we get the correct locations.
   EXPECT_EQ(kUniform2FakeLocation,
             program_info->GetUniformFakeLocation(kUniform2Name));
   EXPECT_EQ(kUniform3FakeLocation,
             program_info->GetUniformFakeLocation(kUniform3Name));
@@ skipping 25 matching lines @@
       .WillRepeatedly(ReturnRef(attrib_map));
   EXPECT_CALL(shader_translator, uniform_map())
       .WillRepeatedly(ReturnRef(uniform_map));
   ShaderTranslator::NameMap name_map;
   EXPECT_CALL(shader_translator, name_map())
       .WillRepeatedly(ReturnRef(name_map));
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
-  ShaderManager::ShaderInfo* vshader = shader_manager_.CreateShaderInfo(
+  Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   vshader->SetStatus(true, "", &shader_translator);
-  ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
+  Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   fshader->SetStatus(true, "", &shader_translator);
   static ProgramManagerWithShaderTest::AttribInfo kAttribs[] = {
     { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
     { kAttrib2Name, kAttrib2Size, kAttrib2BadType, kAttrib2Location, },
     { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
   };
   static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
     { kUniform1Name,
@@ skipping 20 matching lines @@
       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(
+  Program* program_info = manager_.CreateProgram(
       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(NULL, NULL, NULL, NULL);
   // Check that we got the good type, not the bad.
   // Check Attribs
   for (unsigned index = 0; index < kNumAttribs; ++index) {
-    const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
+    const Program::VertexAttrib* attrib_info =
         program_info->GetAttribInfo(index);
     ASSERT_TRUE(attrib_info != NULL);
     ShaderTranslator::VariableMap::const_iterator it = attrib_map.find(
         attrib_info->name);
     ASSERT_TRUE(it != attrib_map.end());
     EXPECT_EQ(it->first, attrib_info->name);
     EXPECT_EQ(static_cast<GLenum>(it->second.type), attrib_info->type);
     EXPECT_EQ(it->second.size, attrib_info->size);
     EXPECT_EQ(it->second.name, attrib_info->name);
   }
   // Check Uniforms
   for (unsigned index = 0; index < kNumUniforms; ++index) {
-    const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
+    const Program::UniformInfo* uniform_info =
         program_info->GetUniformInfo(index);
     ASSERT_TRUE(uniform_info != NULL);
     ShaderTranslator::VariableMap::const_iterator it = uniform_map.find(
         uniform_info->name);
     ASSERT_TRUE(it != uniform_map.end());
     EXPECT_EQ(it->first, uniform_info->name);
     EXPECT_EQ(static_cast<GLenum>(it->second.type), uniform_info->type);
     EXPECT_EQ(it->second.size, uniform_info->size);
     EXPECT_EQ(it->second.name, uniform_info->name);
   }
 }
 
 TEST_F(ProgramManagerWithShaderTest, ProgramInfoUseCount) {
   static const GLuint kClientProgramId = 124;
   static const GLuint kServiceProgramId = 457;
-  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
+  Program* program_info = manager_.CreateProgram(
       kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_FALSE(program_info->CanLink());
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
-  ShaderManager::ShaderInfo* vshader = shader_manager_.CreateShaderInfo(
+  Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   vshader->SetStatus(true, "", NULL);
-  ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
+  Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   fshader->SetStatus(true, "", NULL);
   EXPECT_FALSE(vshader->InUse());
   EXPECT_FALSE(fshader->InUse());
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(vshader->InUse());
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, fshader));
   EXPECT_TRUE(fshader->InUse());
   EXPECT_TRUE(program_info->CanLink());
   EXPECT_FALSE(program_info->InUse());
   EXPECT_FALSE(program_info->IsDeleted());
   manager_.UseProgram(program_info);
   EXPECT_TRUE(program_info->InUse());
   manager_.UseProgram(program_info);
   EXPECT_TRUE(program_info->InUse());
   manager_.MarkAsDeleted(&shader_manager_, program_info);
   EXPECT_TRUE(program_info->IsDeleted());
-  ProgramManager::ProgramInfo* info2 =
-      manager_.GetProgramInfo(kClientProgramId);
+  Program* info2 =
+      manager_.GetProgram(kClientProgramId);
   EXPECT_EQ(program_info, info2);
   manager_.UnuseProgram(&shader_manager_, program_info);
   EXPECT_TRUE(program_info->InUse());
   // this should delete the info.
   EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId))
       .Times(1)
       .RetiresOnSaturation();
   manager_.UnuseProgram(&shader_manager_, program_info);
-  info2 = manager_.GetProgramInfo(kClientProgramId);
+  info2 = manager_.GetProgram(kClientProgramId);
   EXPECT_TRUE(info2 == NULL);
   EXPECT_FALSE(vshader->InUse());
   EXPECT_FALSE(fshader->InUse());
 }
 
 TEST_F(ProgramManagerWithShaderTest, ProgramInfoUseCount2) {
   static const GLuint kClientProgramId = 124;
   static const GLuint kServiceProgramId = 457;
-  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
+  Program* program_info = manager_.CreateProgram(
       kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_FALSE(program_info->CanLink());
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
-  ShaderManager::ShaderInfo* vshader = shader_manager_.CreateShaderInfo(
+  Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   vshader->SetStatus(true, "", NULL);
-  ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
+  Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   fshader->SetStatus(true, "", NULL);
   EXPECT_FALSE(vshader->InUse());
   EXPECT_FALSE(fshader->InUse());
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(vshader->InUse());
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, fshader));
   EXPECT_TRUE(fshader->InUse());
   EXPECT_TRUE(program_info->CanLink());
   EXPECT_FALSE(program_info->InUse());
   EXPECT_FALSE(program_info->IsDeleted());
   manager_.UseProgram(program_info);
   EXPECT_TRUE(program_info->InUse());
   manager_.UseProgram(program_info);
   EXPECT_TRUE(program_info->InUse());
   manager_.UnuseProgram(&shader_manager_, program_info);
   EXPECT_TRUE(program_info->InUse());
   manager_.UnuseProgram(&shader_manager_, program_info);
   EXPECT_FALSE(program_info->InUse());
-  ProgramManager::ProgramInfo* info2 =
-      manager_.GetProgramInfo(kClientProgramId);
+  Program* info2 =
+      manager_.GetProgram(kClientProgramId);
   EXPECT_EQ(program_info, info2);
   // this should delete the program.
   EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId))
       .Times(1)
       .RetiresOnSaturation();
   manager_.MarkAsDeleted(&shader_manager_, program_info);
-  info2 = manager_.GetProgramInfo(kClientProgramId);
+  info2 = manager_.GetProgram(kClientProgramId);
   EXPECT_TRUE(info2 == NULL);
   EXPECT_FALSE(vshader->InUse());
   EXPECT_FALSE(fshader->InUse());
 }
 
 TEST_F(ProgramManagerWithShaderTest, ProgramInfoGetProgramInfo) {
   CommonDecoder::Bucket bucket;
-  const ProgramManager::ProgramInfo* program_info =
-      manager_.GetProgramInfo(kClientProgramId);
+  const Program* program_info =
+      manager_.GetProgram(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
-  program_info->GetProgramInfo(&manager_, &bucket);
+  program_info->GetProgram(&manager_, &bucket);
   ProgramInfoHeader* header =
       bucket.GetDataAs<ProgramInfoHeader*>(0, sizeof(ProgramInfoHeader));
   ASSERT_TRUE(header != NULL);
   EXPECT_EQ(1u, header->link_status);
   EXPECT_EQ(arraysize(kAttribs), header->num_attribs);
   EXPECT_EQ(arraysize(kUniforms), header->num_uniforms);
   const ProgramInput* inputs = bucket.GetDataAs<const ProgramInput*>(
       sizeof(*header),
       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
   ASSERT_TRUE(inputs != NULL);
@@ skipping 52 matching lines @@
   }
   ShaderTranslator::VariableMap uniform_map;
   EXPECT_CALL(shader_translator, attrib_map())
       .WillRepeatedly(ReturnRef(attrib_map));
   EXPECT_CALL(shader_translator, uniform_map())
       .WillRepeatedly(ReturnRef(uniform_map));
   ShaderTranslator::NameMap name_map;
   EXPECT_CALL(shader_translator, name_map())
       .WillRepeatedly(ReturnRef(name_map));
   // Check we can create shader.
-  ShaderManager::ShaderInfo* vshader = shader_manager_.CreateShaderInfo(
+  Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
-  ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
+  Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   // Check shader got created.
   ASSERT_TRUE(vshader != NULL && fshader != NULL);
   // Set Status
   vshader->SetStatus(true, "", &shader_translator);
   // Check attrib infos got copied.
   for (ShaderTranslator::VariableMap::const_iterator it = attrib_map.begin();
        it != attrib_map.end(); ++it) {
-    const ShaderManager::ShaderInfo::VariableInfo* variable_info =
+    const Shader::VariableInfo* variable_info =
         vshader->GetAttribInfo(it->first);
     ASSERT_TRUE(variable_info != NULL);
     EXPECT_EQ(it->second.type, variable_info->type);
     EXPECT_EQ(it->second.size, variable_info->size);
     EXPECT_EQ(it->second.name, variable_info->name);
   }
   fshader->SetStatus(true, "", NULL);
 
   // Set up program
   const GLuint kClientProgramId = 6666;
   const GLuint kServiceProgramId = 8888;
-  ProgramManager::ProgramInfo* program_info =
-      manager_.CreateProgramInfo(kClientProgramId, kServiceProgramId);
+  Program* program_info =
+      manager_.CreateProgram(kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, fshader));
 
   EXPECT_FALSE(program_info->DetectAttribLocationBindingConflicts());
   EXPECT_TRUE(LinkAsExpected(program_info, true));
 
   program_info->SetAttribLocationBinding(kAttrib1Name, 0);
   EXPECT_FALSE(program_info->DetectAttribLocationBindingConflicts());
   EXPECT_TRUE(LinkAsExpected(program_info, true));
 
   program_info->SetAttribLocationBinding("xxx", 0);
   EXPECT_FALSE(program_info->DetectAttribLocationBindingConflicts());
   EXPECT_TRUE(LinkAsExpected(program_info, true));
 
   program_info->SetAttribLocationBinding(kAttrib2Name, 1);
   EXPECT_FALSE(program_info->DetectAttribLocationBindingConflicts());
   EXPECT_TRUE(LinkAsExpected(program_info, true));
 
   program_info->SetAttribLocationBinding(kAttrib2Name, 0);
   EXPECT_TRUE(program_info->DetectAttribLocationBindingConflicts());
   EXPECT_TRUE(LinkAsExpected(program_info, false));
 }
 
 TEST_F(ProgramManagerWithShaderTest, ClearWithSamplerTypes) {
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
-  ShaderManager::ShaderInfo* vshader = shader_manager_.CreateShaderInfo(
+  Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   vshader->SetStatus(true, NULL, NULL);
-  ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
+  Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   fshader->SetStatus(true, NULL, NULL);
   static const GLuint kClientProgramId = 1234;
   static const GLuint kServiceProgramId = 5679;
-  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
+  Program* program_info = manager_.CreateProgram(
       kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, fshader));
 
   static const GLenum kSamplerTypes[] = {
     GL_SAMPLER_2D,
     GL_SAMPLER_CUBE,
     GL_SAMPLER_EXTERNAL_OES,
     GL_SAMPLER_3D_OES,
@@ skipping 45 matching lines @@
 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(
+  Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   vshader->SetStatus(true, NULL, NULL);
-  ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
+  Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   fshader->SetStatus(true, NULL, NULL);
   static const GLuint kClientProgramId = 1234;
   static const GLuint kServiceProgramId = 5679;
-  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
+  Program* program_info = manager_.CreateProgram(
       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[] = {
@@ skipping 61 matching lines @@
   virtual ~ProgramManagerWithCacheTest() {
     manager_.Destroy(false);
     shader_manager_.Destroy(false);
   }
 
  protected:
   virtual void SetUp() {
     gl_.reset(new StrictMock<gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
 
-    vertex_shader_ = shader_manager_.CreateShaderInfo(
+    vertex_shader_ = shader_manager_.CreateShader(
        kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
-    fragment_shader_ = shader_manager_.CreateShaderInfo(
+    fragment_shader_ = shader_manager_.CreateShader(
        kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
     ASSERT_TRUE(vertex_shader_ != NULL);
     ASSERT_TRUE(fragment_shader_ != NULL);
     vertex_shader_->UpdateSource("lka asjf bjajsdfj");
     fragment_shader_->UpdateSource("lka asjf a   fasgag 3rdsf3 bjajsdfj");
 
-    program_info_ = manager_.CreateProgramInfo(
+    program_info_ = manager_.CreateProgram(
         kClientProgramId, kServiceProgramId);
     ASSERT_TRUE(program_info_ != NULL);
 
     program_info_->AttachShader(&shader_manager_, vertex_shader_);
     program_info_->AttachShader(&shader_manager_, fragment_shader_);
   }
 
   virtual void TearDown() {
     ::gfx::GLInterface::SetGLInterface(NULL);
   }
@@ skipping 20 matching lines @@
         &program_info_->bind_attrib_location_map());
   }
 
   void SetExpectationsForProgramCached() {
     SetExpectationsForProgramCached(program_info_,
                                     vertex_shader_,
                                     fragment_shader_);
   }
 
   void SetExpectationsForProgramCached(
-      ProgramManager::ProgramInfo* program_info,
-      ShaderManager::ShaderInfo* vertex_shader,
-      ShaderManager::ShaderInfo* fragment_shader) {
+      Program* program_info,
+      Shader* vertex_shader,
+      Shader* fragment_shader) {
     EXPECT_CALL(*cache_.get(), SaveLinkedProgram(
         program_info->service_id(),
         vertex_shader,
         fragment_shader,
         &program_info->bind_attrib_location_map())).Times(1);
   }
 
   void SetExpectationsForNotCachingProgram() {
     SetExpectationsForNotCachingProgram(program_info_,
                                         vertex_shader_,
                                         fragment_shader_);
   }
 
   void SetExpectationsForNotCachingProgram(
-      ProgramManager::ProgramInfo* program_info,
-      ShaderManager::ShaderInfo* vertex_shader,
-      ShaderManager::ShaderInfo* fragment_shader) {
+      Program* program_info,
+      Shader* vertex_shader,
+      Shader* fragment_shader) {
     EXPECT_CALL(*cache_.get(), SaveLinkedProgram(
         program_info->service_id(),
         vertex_shader,
         fragment_shader,
         &program_info->bind_attrib_location_map())).Times(0);
   }
 
   void SetExpectationsForProgramLoad(ProgramCache::ProgramLoadResult result) {
     SetExpectationsForProgramLoad(kServiceProgramId,
                                   program_info_,
                                   vertex_shader_,
                                   fragment_shader_,
                                   result);
   }
 
   void SetExpectationsForProgramLoad(
       GLuint service_program_id,
-      ProgramManager::ProgramInfo* program_info,
-      ShaderManager::ShaderInfo* vertex_shader,
-      ShaderManager::ShaderInfo* fragment_shader,
+      Program* program_info,
+      Shader* vertex_shader,
+      Shader* fragment_shader,
       ProgramCache::ProgramLoadResult result) {
     EXPECT_CALL(*cache_.get(),
                 LoadLinkedProgram(service_program_id,
                                   vertex_shader,
                                   fragment_shader,
                                   &program_info->bind_attrib_location_map()))
         .WillOnce(Return(result));
   }
 
   void SetExpectationsForProgramLoadSuccess() {
@@ skipping 17 matching lines @@
     TestHelper::SetupShader(gl_.get(), NULL, 0, NULL, 0, service_program_id);
     if (gfx::g_driver_gl.ext.b_GL_ARB_get_program_binary) {
       EXPECT_CALL(*gl_.get(),
                   ProgramParameteri(service_program_id,
                                     PROGRAM_BINARY_RETRIEVABLE_HINT,
                                     GL_TRUE)).Times(1);
     }
   }
 
   void SetExpectationsForSuccessCompile(
-      const ShaderManager::ShaderInfo* shader) {
+      const Shader* shader) {
     const GLuint shader_id = shader->service_id();
     const char* src = shader->source()->c_str();
     EXPECT_CALL(*gl_.get(),
                 ShaderSource(shader_id, 1, Pointee(src), NULL)).Times(1);
     EXPECT_CALL(*gl_.get(), CompileShader(shader_id)).Times(1);
     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_COMPILE_STATUS, _))
       .WillOnce(SetArgumentPointee<2>(GL_TRUE));
   }
 
-  void SetExpectationsForNoCompile(const ShaderManager::ShaderInfo* shader) {
+  void SetExpectationsForNoCompile(const Shader* shader) {
     const GLuint shader_id = shader->service_id();
     const char* src = shader->source()->c_str();
     EXPECT_CALL(*gl_.get(),
                 ShaderSource(shader_id, 1, Pointee(src), NULL)).Times(0);
     EXPECT_CALL(*gl_.get(), CompileShader(shader_id)).Times(0);
     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_COMPILE_STATUS, _))
         .Times(0);
   }
 
-  void SetExpectationsForErrorCompile(const ShaderManager::ShaderInfo* shader) {
+  void SetExpectationsForErrorCompile(const Shader* shader) {
     const GLuint shader_id = shader->service_id();
     const char* src = shader->source()->c_str();
     EXPECT_CALL(*gl_.get(),
                 ShaderSource(shader_id, 1, Pointee(src), NULL)).Times(1);
     EXPECT_CALL(*gl_.get(), CompileShader(shader_id)).Times(1);
     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_COMPILE_STATUS, _))
       .WillOnce(SetArgumentPointee<2>(GL_FALSE));
     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_INFO_LOG_LENGTH, _))
       .WillOnce(SetArgumentPointee<2>(0));
     EXPECT_CALL(*gl_.get(), GetShaderInfoLog(shader_id, 0, _, _))
       .Times(1);
   }
 
   scoped_ptr<StrictMock<gfx::MockGLInterface> > gl_;
 
   scoped_ptr<MockProgramCache> cache_;
   ProgramManager manager_;
 
-  ShaderManager::ShaderInfo* vertex_shader_;
-  ShaderManager::ShaderInfo* fragment_shader_;
-  ProgramManager::ProgramInfo* program_info_;
+  Shader* vertex_shader_;
+  Shader* fragment_shader_;
+  Program* program_info_;
   ShaderManager shader_manager_;
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
 const GLuint ProgramManagerWithCacheTest::kClientProgramId;
 const GLuint ProgramManagerWithCacheTest::kServiceProgramId;
 const GLuint ProgramManagerWithCacheTest::kVertexShaderClientId;
 const GLuint ProgramManagerWithCacheTest::kFragmentShaderClientId;
 const GLuint ProgramManagerWithCacheTest::kVertexShaderServiceId;
 const GLuint ProgramManagerWithCacheTest::kFragmentShaderServiceId;
 #endif
 
 TEST_F(ProgramManagerWithCacheTest, CacheSuccessAfterShaderCompile) {
   SetExpectationsForSuccessCompile(vertex_shader_);
-  FeatureInfo::Ref info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> info(new FeatureInfo());
   manager_.DoCompileShader(vertex_shader_, NULL, info.get());
   EXPECT_EQ(ProgramCache::COMPILATION_SUCCEEDED,
             cache_->GetShaderCompilationStatus(*vertex_shader_->source()));
 }
 
 TEST_F(ProgramManagerWithCacheTest, CacheUnknownAfterShaderError) {
   SetExpectationsForErrorCompile(vertex_shader_);
-  FeatureInfo::Ref info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> info(new FeatureInfo());
   manager_.DoCompileShader(vertex_shader_, NULL, info.get());
   EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN,
             cache_->GetShaderCompilationStatus(*vertex_shader_->source()));
 }
 
 TEST_F(ProgramManagerWithCacheTest, NoCompileWhenShaderCached) {
   cache_->ShaderCompilationSucceeded(vertex_shader_->source()->c_str());
   SetExpectationsForNoCompile(vertex_shader_);
-  FeatureInfo::Ref info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> info(new FeatureInfo());
   manager_.DoCompileShader(vertex_shader_, NULL, info.get());
 }
 
 TEST_F(ProgramManagerWithCacheTest, CacheProgramOnSuccessfulLink) {
   SetShadersCompiled();
   SetExpectationsForProgramLink();
   SetExpectationsForProgramCached();
   EXPECT_TRUE(program_info_->Link(NULL, NULL, NULL, NULL));
 }
 
 TEST_F(ProgramManagerWithCacheTest, CompileShaderOnLinkCacheMiss) {
   SetShadersCompiled();
   vertex_shader_->FlagSourceAsCompiled(false);
 
-  FeatureInfo::Ref info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> info(new FeatureInfo());
 
   SetExpectationsForSuccessCompile(vertex_shader_);
   SetExpectationsForProgramLink();
   SetExpectationsForProgramCached();
   EXPECT_TRUE(program_info_->Link(&shader_manager_, NULL, NULL, info.get()));
 }
 
 TEST_F(ProgramManagerWithCacheTest, LoadProgramOnProgramCacheHit) {
   SetShadersNotCompiledButCached();
   SetProgramCached();
@@ skipping 10 matching lines @@
 TEST_F(ProgramManagerWithCacheTest, CompileAndLinkOnProgramCacheError) {
   SetShadersNotCompiledButCached();
   SetProgramCached();
 
   SetExpectationsForSuccessCompile(vertex_shader_);
   SetExpectationsForSuccessCompile(fragment_shader_);
   SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_FAILURE);
   SetExpectationsForProgramLink();
   SetExpectationsForProgramCached();
 
-  FeatureInfo::Ref info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> info(new FeatureInfo());
   EXPECT_TRUE(program_info_->Link(&shader_manager_, NULL, NULL, info.get()));
 }
 
 TEST_F(ProgramManagerWithCacheTest, CorrectCompileOnSourceChangeNoCompile) {
   SetShadersNotCompiledButCached();
   SetProgramCached();
 
   const GLuint kNewShaderClientId = 4;
   const GLuint kNewShaderServiceId = 40;
   const GLuint kNewProgramClientId = 5;
   const GLuint kNewProgramServiceId = 50;
 
-  ShaderManager::ShaderInfo* new_vertex_shader =
-      shader_manager_.CreateShaderInfo(kNewShaderClientId,
+  Shader* new_vertex_shader =
+      shader_manager_.CreateShader(kNewShaderClientId,
                                        kNewShaderServiceId,
                                        GL_VERTEX_SHADER);
 
   const std::string original_source = *vertex_shader_->source();
   new_vertex_shader->UpdateSource(original_source.c_str());
 
-  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
+  Program* program_info = manager_.CreateProgram(
       kNewProgramClientId, kNewProgramServiceId);
   ASSERT_TRUE(program_info != NULL);
   program_info->AttachShader(&shader_manager_, new_vertex_shader);
   program_info->AttachShader(&shader_manager_, fragment_shader_);
 
   SetExpectationsForNoCompile(new_vertex_shader);
 
   manager_.DoCompileShader(new_vertex_shader, NULL, NULL);
-  EXPECT_EQ(ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE,
+  EXPECT_EQ(Shader::PENDING_DEFERRED_COMPILE,
             new_vertex_shader->compilation_status());
 
   new_vertex_shader->UpdateSource("different!");
   EXPECT_EQ(original_source,
             *new_vertex_shader->deferred_compilation_source());
 
-  EXPECT_EQ(ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE,
+  EXPECT_EQ(Shader::PENDING_DEFERRED_COMPILE,
             new_vertex_shader->compilation_status());
-  EXPECT_EQ(ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE,
+  EXPECT_EQ(Shader::PENDING_DEFERRED_COMPILE,
             fragment_shader_->compilation_status());
 
   SetExpectationsForNoCompile(fragment_shader_);
   SetExpectationsForNotCachingProgram(program_info,
                                       new_vertex_shader,
                                       fragment_shader_);
   SetExpectationsForProgramLoad(kNewProgramServiceId,
                                 program_info,
                                 new_vertex_shader,
                                 fragment_shader_,
                                 ProgramCache::PROGRAM_LOAD_SUCCESS);
   SetExpectationsForProgramLoadSuccess(kNewProgramServiceId);
 
-  FeatureInfo::Ref info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> info(new FeatureInfo());
   EXPECT_TRUE(program_info->Link(&shader_manager_, NULL, NULL, info.get()));
 }
 
 TEST_F(ProgramManagerWithCacheTest, CorrectCompileOnSourceChangeWithCompile) {
   SetShadersNotCompiledButCached();
   SetProgramCached();
 
   const GLuint kNewShaderClientId = 4;
   const GLuint kNewShaderServiceId = 40;
   const GLuint kNewProgramClientId = 5;
   const GLuint kNewProgramServiceId = 50;
 
-  ShaderManager::ShaderInfo* new_vertex_shader =
-      shader_manager_.CreateShaderInfo(kNewShaderClientId,
+  Shader* new_vertex_shader =
+      shader_manager_.CreateShader(kNewShaderClientId,
                                        kNewShaderServiceId,
                                        GL_VERTEX_SHADER);
 
   new_vertex_shader->UpdateSource(vertex_shader_->source()->c_str());
 
-  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
+  Program* program_info = manager_.CreateProgram(
       kNewProgramClientId, kNewProgramServiceId);
   ASSERT_TRUE(program_info != NULL);
   program_info->AttachShader(&shader_manager_, new_vertex_shader);
   program_info->AttachShader(&shader_manager_, fragment_shader_);
 
   SetExpectationsForNoCompile(new_vertex_shader);
 
   manager_.DoCompileShader(new_vertex_shader, NULL, NULL);
 
   const std::string differentSource = "different!";
   new_vertex_shader->UpdateSource(differentSource.c_str());
   SetExpectationsForSuccessCompile(new_vertex_shader);
 
-  FeatureInfo::Ref info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> info(new FeatureInfo());
   manager_.DoCompileShader(new_vertex_shader, NULL, info.get());
   EXPECT_EQ(differentSource,
             *new_vertex_shader->deferred_compilation_source());
 
-  EXPECT_EQ(ShaderManager::ShaderInfo::COMPILED,
+  EXPECT_EQ(Shader::COMPILED,
             new_vertex_shader->compilation_status());
-  EXPECT_EQ(ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE,
+  EXPECT_EQ(Shader::PENDING_DEFERRED_COMPILE,
             fragment_shader_->compilation_status());
 
   // so we don't recompile because we were pending originally
   SetExpectationsForNoCompile(new_vertex_shader);
   SetExpectationsForSuccessCompile(fragment_shader_);
   SetExpectationsForProgramCached(program_info,
                                   new_vertex_shader,
                                   fragment_shader_);
   SetExpectationsForProgramLink(kNewProgramServiceId);
 
   EXPECT_TRUE(program_info->Link(&shader_manager_, NULL, NULL, info.get()));
 }
 
 }  // namespace gles2
 }  // namespace gpu