Clean up interfaces between Shader / ShaderTranslator / ANGLE side.

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 209 matching lines @@
     SetupDefaultShaderExpectations();
 
     Shader* vertex_shader = shader_manager_.CreateShader(
         kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     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);
+    TestHelper::SetShaderStates(gl_.get(), vertex_shader, true);
+    TestHelper::SetShaderStates(gl_.get(), fragment_shader, true);
 
     program_ = manager_.CreateProgram(
         kClientProgramId, kServiceProgramId);
     ASSERT_TRUE(program_ != NULL);
 
     program_->AttachShader(&shader_manager_, vertex_shader);
     program_->AttachShader(&shader_manager_, fragment_shader);
     program_->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
                    base::Bind(&ShaderCacheCb));
   }
@@ skipping 34 matching lines @@
   Program* SetupShaderVariableTest(const VarInfo* vertex_variables,
                                    size_t vertex_variable_size,
                                    const VarInfo* fragment_variables,
                                    size_t fragment_variable_size) {
     // Set up shader
     const GLuint kVShaderClientId = 1;
     const GLuint kVShaderServiceId = 11;
     const GLuint kFShaderClientId = 2;
     const GLuint kFShaderServiceId = 12;
 
-    MockShaderTranslator vertex_shader_translator;
     ShaderTranslator::VariableMap vertex_attrib_map;
     ShaderTranslator::VariableMap vertex_uniform_map;
     ShaderTranslator::VariableMap vertex_varying_map;
     for (size_t ii = 0; ii < vertex_variable_size; ++ii) {
       ShaderTranslator::VariableMap* map = NULL;
       switch (vertex_variables[ii].category) {
         case kVarAttribute:
           map = &vertex_attrib_map;
           break;
         case kVarUniform:
           map = &vertex_uniform_map;
           break;
         case kVarVarying:
           map = &vertex_varying_map;
           break;
         default:
           NOTREACHED();
       }
       (*map)[vertex_variables[ii].name] =
           ShaderTranslator::VariableInfo(vertex_variables[ii].type,
                                          vertex_variables[ii].size,
                                          vertex_variables[ii].precision,
                                          vertex_variables[ii].static_use,
                                          vertex_variables[ii].name);
     }
-    ShaderTranslator::NameMap vertex_name_map;
-    EXPECT_CALL(vertex_shader_translator, attrib_map())
-        .WillRepeatedly(ReturnRef(vertex_attrib_map));
-    EXPECT_CALL(vertex_shader_translator, uniform_map())
-        .WillRepeatedly(ReturnRef(vertex_uniform_map));
-    EXPECT_CALL(vertex_shader_translator, varying_map())
-        .WillRepeatedly(ReturnRef(vertex_varying_map));
-    EXPECT_CALL(vertex_shader_translator, name_map())
-      .WillRepeatedly(ReturnRef(vertex_name_map));
 
-    MockShaderTranslator frag_shader_translator;
     ShaderTranslator::VariableMap frag_attrib_map;
     ShaderTranslator::VariableMap frag_uniform_map;
     ShaderTranslator::VariableMap frag_varying_map;
     for (size_t ii = 0; ii < fragment_variable_size; ++ii) {
       ShaderTranslator::VariableMap* map = NULL;
       switch (fragment_variables[ii].category) {
         case kVarAttribute:
           map = &frag_attrib_map;
           break;
         case kVarUniform:
           map = &frag_uniform_map;
           break;
         case kVarVarying:
           map = &frag_varying_map;
           break;
         default:
           NOTREACHED();
       }
       (*map)[fragment_variables[ii].name] =
           ShaderTranslator::VariableInfo(fragment_variables[ii].type,
                                          fragment_variables[ii].size,
                                          fragment_variables[ii].precision,
                                          fragment_variables[ii].static_use,
                                          fragment_variables[ii].name);
     }
-    ShaderTranslator::NameMap frag_name_map;
-    EXPECT_CALL(frag_shader_translator, attrib_map())
-        .WillRepeatedly(ReturnRef(frag_attrib_map));
-    EXPECT_CALL(frag_shader_translator, uniform_map())
-        .WillRepeatedly(ReturnRef(frag_uniform_map));
-    EXPECT_CALL(frag_shader_translator, varying_map())
-        .WillRepeatedly(ReturnRef(frag_varying_map));
-    EXPECT_CALL(frag_shader_translator, name_map())
-      .WillRepeatedly(ReturnRef(frag_name_map));
 
     // Check we can create shader.
     Shader* vshader = shader_manager_.CreateShader(
         kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
     Shader* fshader = shader_manager_.CreateShader(
         kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
     // Check shader got created.
     EXPECT_TRUE(vshader != NULL && fshader != NULL);
     // Set Status
-    vshader->SetStatus(true, "", &vertex_shader_translator);
-    fshader->SetStatus(true, "", &frag_shader_translator);
+    TestHelper::SetShaderStates(
+        gl_.get(), vshader, true, NULL, NULL,
+        &vertex_attrib_map, &vertex_uniform_map, &vertex_varying_map, NULL);
+    TestHelper::SetShaderStates(
+        gl_.get(), fshader, true, NULL, NULL,
+        &frag_attrib_map, &frag_uniform_map, &frag_varying_map, NULL);
 
     // Set up program
     const GLuint kClientProgramId = 6666;
     const GLuint kServiceProgramId = 8888;
     Program* program =
         manager_.CreateProgram(kClientProgramId, kServiceProgramId);
     EXPECT_TRUE(program != NULL);
     EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
     EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
     return program;
@@ skipping 171 matching lines @@
       kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_FALSE(program->CanLink());
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
-  vshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
-  fshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_FALSE(program->CanLink());
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
   EXPECT_TRUE(program->CanLink());
   program->DetachShader(&shader_manager_, vshader);
   EXPECT_FALSE(program->CanLink());
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->CanLink());
   program->DetachShader(&shader_manager_, fshader);
   EXPECT_FALSE(program->CanLink());
   EXPECT_FALSE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_FALSE(program->CanLink());
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
   EXPECT_TRUE(program->CanLink());
-  vshader->SetStatus(false, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, false);
   EXPECT_FALSE(program->CanLink());
-  vshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true);
   EXPECT_TRUE(program->CanLink());
-  fshader->SetStatus(false, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, false);
   EXPECT_FALSE(program->CanLink());
-  fshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true);
   EXPECT_TRUE(program->CanLink());
   EXPECT_TRUE(program->DetachShader(&shader_manager_, fshader));
   EXPECT_FALSE(program->DetachShader(&shader_manager_, fshader));
 }
 
 TEST_F(ProgramManagerWithShaderTest, GetUniformFakeLocation) {
   const Program* program = manager_.GetProgram(kClientProgramId);
   ASSERT_TRUE(program != NULL);
   // Emulate the situation that uniform3[1] isn't used and optimized out by
   // a driver, so it's location is -1.
@@ skipping 90 matching lines @@
   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);
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
-  vshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
-  fshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true);
   Program* program =
       manager_.CreateProgram(kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
   program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
                 base::Bind(&ShaderCacheCb));
   GLint value = 0;
   program->GetProgramiv(GL_ACTIVE_ATTRIBUTES, &value);
   EXPECT_EQ(3, value);
@@ skipping 44 matching lines @@
   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);
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
-  vshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
-  fshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true);
   Program* program =
       manager_.CreateProgram(kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
   program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
                 base::Bind(&ShaderCacheCb));
 
   // Check that we get the correct locations.
   EXPECT_EQ(kUniform2FakeLocation,
             program->GetUniformFakeLocation(kUniform2Name));
   EXPECT_EQ(kUniform3FakeLocation,
             program->GetUniformFakeLocation(kUniform3Name));
 }
 
 // Some GL drivers incorrectly return the wrong type. For example they return
 // GL_FLOAT_VEC2 when they should return GL_FLOAT_MAT2. Check we handle this.
 TEST_F(ProgramManagerWithShaderTest, GLDriverReturnsWrongTypeInfo) {
   static GLenum kAttrib2BadType = GL_FLOAT_VEC2;
   static GLenum kAttrib2GoodType = GL_FLOAT_MAT2;
   static GLenum kUniform2BadType = GL_FLOAT_VEC3;
   static GLenum kUniform2GoodType = GL_FLOAT_MAT3;
-  MockShaderTranslator shader_translator;
   ShaderTranslator::VariableMap attrib_map;
   ShaderTranslator::VariableMap uniform_map;
   ShaderTranslator::VariableMap varying_map;
   attrib_map[kAttrib1Name] = ShaderTranslatorInterface::VariableInfo(
       kAttrib1Type, kAttrib1Size, kAttrib1Precision,
       kAttribStaticUse, kAttrib1Name);
   attrib_map[kAttrib2Name] = ShaderTranslatorInterface::VariableInfo(
       kAttrib2GoodType, kAttrib2Size, kAttrib2Precision,
       kAttribStaticUse, kAttrib2Name);
   attrib_map[kAttrib3Name] = ShaderTranslatorInterface::VariableInfo(
       kAttrib3Type, kAttrib3Size, kAttrib3Precision,
       kAttribStaticUse, kAttrib3Name);
   uniform_map[kUniform1Name] = ShaderTranslatorInterface::VariableInfo(
       kUniform1Type, kUniform1Size, kUniform1Precision,
       kUniform1StaticUse, kUniform1Name);
   uniform_map[kUniform2Name] = ShaderTranslatorInterface::VariableInfo(
       kUniform2GoodType, kUniform2Size, kUniform2Precision,
       kUniform2StaticUse, kUniform2Name);
   uniform_map[kUniform3GoodName] = ShaderTranslatorInterface::VariableInfo(
       kUniform3Type, kUniform3Size, kUniform3Precision,
       kUniform3StaticUse, kUniform3GoodName);
-  EXPECT_CALL(shader_translator, attrib_map())
-      .WillRepeatedly(ReturnRef(attrib_map));
-  EXPECT_CALL(shader_translator, uniform_map())
-      .WillRepeatedly(ReturnRef(uniform_map));
-  EXPECT_CALL(shader_translator, varying_map())
-      .WillRepeatedly(ReturnRef(varying_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;
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
-  vshader->SetStatus(true, "", &shader_translator);
+  TestHelper::SetShaderStates(
+      gl_.get(), vshader, true, NULL, NULL,
+      &attrib_map, &uniform_map, &varying_map, NULL);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
-  fshader->SetStatus(true, "", &shader_translator);
+  TestHelper::SetShaderStates(
+      gl_.get(), fshader, true, NULL, NULL,
+      &attrib_map, &uniform_map, &varying_map, NULL);
   static ProgramManagerWithShaderTest::AttribInfo kAttribs[] = {
     { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
     { kAttrib2Name, kAttrib2Size, kAttrib2BadType, kAttrib2Location, },
     { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
   };
   static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
     { kUniform1Name,
       kUniform1Size,
       kUniform1Type,
       kUniform1FakeLocation,
@@ skipping 67 matching lines @@
       kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_FALSE(program->CanLink());
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
-  vshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
-  fshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true);
   EXPECT_FALSE(vshader->InUse());
   EXPECT_FALSE(fshader->InUse());
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(vshader->InUse());
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
   EXPECT_TRUE(fshader->InUse());
   EXPECT_TRUE(program->CanLink());
   EXPECT_FALSE(program->InUse());
   EXPECT_FALSE(program->IsDeleted());
   manager_.UseProgram(program);
@@ skipping 24 matching lines @@
       kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_FALSE(program->CanLink());
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
-  vshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
-  fshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true);
   EXPECT_FALSE(vshader->InUse());
   EXPECT_FALSE(fshader->InUse());
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(vshader->InUse());
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
   EXPECT_TRUE(fshader->InUse());
   EXPECT_TRUE(program->CanLink());
   EXPECT_FALSE(program->InUse());
   EXPECT_FALSE(program->IsDeleted());
   manager_.UseProgram(program);
@@ skipping 116 matching lines @@
     ++input;
   }
 }
 
 TEST_F(ProgramManagerWithShaderTest, BindAttribLocationConflicts) {
   // Set up shader
   const GLuint kVShaderClientId = 1;
   const GLuint kVShaderServiceId = 11;
   const GLuint kFShaderClientId = 2;
   const GLuint kFShaderServiceId = 12;
-  MockShaderTranslator shader_translator;
   ShaderTranslator::VariableMap attrib_map;
   for (uint32 ii = 0; ii < kNumAttribs; ++ii) {
     attrib_map[kAttribs[ii].name] = ShaderTranslatorInterface::VariableInfo(
         kAttribs[ii].type,
         kAttribs[ii].size,
         SH_PRECISION_MEDIUMP,
         kAttribStaticUse,
         kAttribs[ii].name);
   }
-  ShaderTranslator::VariableMap uniform_map;
-  ShaderTranslator::VariableMap varying_map;
-  EXPECT_CALL(shader_translator, attrib_map())
-      .WillRepeatedly(ReturnRef(attrib_map));
-  EXPECT_CALL(shader_translator, uniform_map())
-      .WillRepeatedly(ReturnRef(uniform_map));
-  EXPECT_CALL(shader_translator, varying_map())
-      .WillRepeatedly(ReturnRef(varying_map));
-  ShaderTranslator::NameMap name_map;
-  EXPECT_CALL(shader_translator, name_map())
-      .WillRepeatedly(ReturnRef(name_map));
   // Check we can create shader.
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   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);
+  TestHelper::SetShaderStates(
+      gl_.get(), vshader, true, NULL, NULL, &attrib_map, NULL, NULL, NULL);
   // Check attrib infos got copied.
   for (ShaderTranslator::VariableMap::const_iterator it = attrib_map.begin();
        it != attrib_map.end(); ++it) {
     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.precision, variable_info->precision);
     EXPECT_EQ(it->second.static_use, variable_info->static_use);
     EXPECT_EQ(it->second.name, variable_info->name);
   }
-  fshader->SetStatus(true, "", NULL);
+  TestHelper::SetShaderStates(
+      gl_.get(), fshader, true, NULL, NULL, &attrib_map, NULL, NULL, NULL);
 
   // 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));
 
@@ skipping 17 matching lines @@
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 TEST_F(ProgramManagerWithShaderTest, UniformsPrecisionMismatch) {
   // Set up shader
   const GLuint kVShaderClientId = 1;
   const GLuint kVShaderServiceId = 11;
   const GLuint kFShaderClientId = 2;
   const GLuint kFShaderServiceId = 12;
 
-  MockShaderTranslator vertex_shader_translator;
-  ShaderTranslator::VariableMap vertex_attrib_map;
   ShaderTranslator::VariableMap vertex_uniform_map;
   vertex_uniform_map["a"] = ShaderTranslator::VariableInfo(
       1, 3, SH_PRECISION_MEDIUMP, 1, "a");
-  ShaderTranslator::VariableMap vertex_varying_map;
-  ShaderTranslator::NameMap vertex_name_map;
-  EXPECT_CALL(vertex_shader_translator, attrib_map())
-      .WillRepeatedly(ReturnRef(vertex_attrib_map));
-  EXPECT_CALL(vertex_shader_translator, uniform_map())
-      .WillRepeatedly(ReturnRef(vertex_uniform_map));
-  EXPECT_CALL(vertex_shader_translator, varying_map())
-      .WillRepeatedly(ReturnRef(vertex_varying_map));
-  EXPECT_CALL(vertex_shader_translator, name_map())
-    .WillRepeatedly(ReturnRef(vertex_name_map));
-
-  MockShaderTranslator frag_shader_translator;
-  ShaderTranslator::VariableMap frag_attrib_map;
   ShaderTranslator::VariableMap frag_uniform_map;
   frag_uniform_map["a"] = ShaderTranslator::VariableInfo(
       1, 3, SH_PRECISION_LOWP, 1, "a");
-  ShaderTranslator::VariableMap frag_varying_map;
-  ShaderTranslator::NameMap frag_name_map;
-  EXPECT_CALL(frag_shader_translator, attrib_map())
-      .WillRepeatedly(ReturnRef(frag_attrib_map));
-  EXPECT_CALL(frag_shader_translator, uniform_map())
-      .WillRepeatedly(ReturnRef(frag_uniform_map));
-  EXPECT_CALL(frag_shader_translator, varying_map())
-      .WillRepeatedly(ReturnRef(frag_varying_map));
-  EXPECT_CALL(frag_shader_translator, name_map())
-    .WillRepeatedly(ReturnRef(frag_name_map));
 
   // Check we can create shader.
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   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, "", &vertex_shader_translator);
-  fshader->SetStatus(true, "", &frag_shader_translator);
+  TestHelper::SetShaderStates(
+      gl_.get(), vshader, true, NULL, NULL, NULL,
+      &vertex_uniform_map, NULL, NULL);
+  TestHelper::SetShaderStates(
+      gl_.get(), fshader, true, NULL, NULL, NULL,
+      &frag_uniform_map, NULL, NULL);
 
   // 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));
 
@@ skipping 158 matching lines @@
 }
 
 TEST_F(ProgramManagerWithShaderTest, ClearWithSamplerTypes) {
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
-  vshader->SetStatus(true, NULL, NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
-  fshader->SetStatus(true, NULL, NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true);
   static const GLuint kClientProgramId = 1234;
   static const GLuint kServiceProgramId = 5679;
   Program* program = manager_.CreateProgram(
       kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 
   static const GLenum kSamplerTypes[] = {
     GL_SAMPLER_2D,
@@ skipping 52 matching lines @@
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
 
   const GLint kUniform1DesiredLocation = 10;
   const GLint kUniform2DesiredLocation = -1;
   const GLint kUniform3DesiredLocation = 5;
 
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
-  vshader->SetStatus(true, NULL, NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
-  fshader->SetStatus(true, NULL, NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true);
   static const GLuint kClientProgramId = 1234;
   static const GLuint kServiceProgramId = 5679;
   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->SetUniformLocationBinding(
       kUniform1Name, kUniform1DesiredLocation));
   EXPECT_TRUE(program->SetUniformLocationBinding(
@@ skipping 70 matching lines @@
  protected:
   virtual void SetUp() {
     GpuServiceTest::SetUp();
 
     vertex_shader_ = shader_manager_.CreateShader(
        kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     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");
+    vertex_shader_->set_source("lka asjf bjajsdfj");
+    fragment_shader_->set_source("lka asjf a   fasgag 3rdsf3 bjajsdfj");
 
     program_ = manager_.CreateProgram(
         kClientProgramId, kServiceProgramId);
     ASSERT_TRUE(program_ != NULL);
 
     program_->AttachShader(&shader_manager_, vertex_shader_);
     program_->AttachShader(&shader_manager_, fragment_shader_);
   }
 
   void SetShadersCompiled() {
-    vertex_shader_->SetStatus(true, NULL, NULL);
-    fragment_shader_->SetStatus(true, NULL, NULL);
+    TestHelper::SetShaderStates(gl_.get(), vertex_shader_, true);
+    TestHelper::SetShaderStates(gl_.get(), fragment_shader_, true);
   }
 
   void SetProgramCached() {
     cache_->LinkedProgramCacheSuccess(
-        vertex_shader_->source()->c_str(),
+        vertex_shader_->source(),
         NULL,
-        fragment_shader_->source()->c_str(),
+        fragment_shader_->source(),
         NULL,
         &program_->bind_attrib_location_map());
   }
 
   void SetExpectationsForProgramCached() {
     SetExpectationsForProgramCached(program_,
                                     vertex_shader_,
                                     fragment_shader_);
   }
 
@@ skipping 79 matching lines @@
       EXPECT_CALL(*gl_.get(),
                   ProgramParameteri(service_program_id,
                                     PROGRAM_BINARY_RETRIEVABLE_HINT,
                                     GL_TRUE)).Times(1);
     }
   }
 
   void SetExpectationsForSuccessCompile(
       const Shader* shader) {
     const GLuint shader_id = shader->service_id();
-    const char* src = shader->source()->c_str();
+    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));
+        .WillOnce(SetArgumentPointee<2>(GL_TRUE));
   }
 
   void SetExpectationsForNoCompile(const Shader* shader) {
     const GLuint shader_id = shader->service_id();
-    const char* src = shader->source()->c_str();
+    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 Shader* shader) {
     const GLuint shader_id = shader->service_id();
-    const char* src = shader->source()->c_str();
+    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));
+        .WillOnce(SetArgumentPointee<2>(GL_FALSE));
     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_INFO_LOG_LENGTH, _))
-      .WillOnce(SetArgumentPointee<2>(0));
+        .WillOnce(SetArgumentPointee<2>(0));
     EXPECT_CALL(*gl_.get(), GetShaderInfoLog(shader_id, 0, _, _))
-      .Times(1);
+        .Times(1);
   }
 
   scoped_ptr<MockProgramCache> cache_;
   ProgramManager manager_;
 
   Shader* vertex_shader_;
   Shader* fragment_shader_;
   Program* program_;
   ShaderManager shader_manager_;
 };
@@ skipping 25 matching lines @@
   SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS);
   SetExpectationsForNotCachingProgram();
   SetExpectationsForProgramLoadSuccess();
 
   EXPECT_TRUE(program_->Link(NULL, NULL, NULL,
       Program::kCountOnlyStaticallyUsed, base::Bind(&ShaderCacheCb)));
 }
 
 }  // namespace gles2
 }  // namespace gpu