Defer clearing textures and renderbuffers

gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc

 // Copyright (c) 2011 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/gles2_cmd_decoder_unittest_base.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/string_number_conversions.h"
 #include "gpu/command_buffer/common/gl_mock.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/gl/gl_implementation.h"
 
 using ::gfx::MockGLInterface;
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::MatcherCast;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgumentPointee;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 
 namespace gpu {
 namespace gles2 {
 
 GLES2DecoderTestBase::GLES2DecoderTestBase()
     : surface_(NULL),
       context_(NULL),
       client_buffer_id_(100),
       client_framebuffer_id_(101),
       client_program_id_(102),
       client_renderbuffer_id_(103),
       client_shader_id_(104),
       client_texture_id_(106),
-      client_element_buffer_id_(107) {
+      client_element_buffer_id_(107),
+      client_vertex_shader_id_(121),
+      client_fragment_shader_id_(122) {
   memset(immediate_buffer_, 0xEE, sizeof(immediate_buffer_));
 }
 
 GLES2DecoderTestBase::~GLES2DecoderTestBase() {}
 
 void GLES2DecoderTestBase::SetUp() {
   InitDecoder(
       "",      // extensions
       true,    // has alpha
       true,    // has depth
@@ skipping 240 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
   if (str) {
     memcpy(shared_memory_address_, str, size);
     cmd::SetBucketData cmd2;
     cmd2.Init(bucket_id, 0, size, kSharedMemoryId, kSharedMemoryOffset);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
     ClearSharedMemory();
   }
 }
 
-void GLES2DecoderTestBase::SetupExpectationsForFramebufferAttachment(
+void GLES2DecoderTestBase::SetupClearTextureExpections(
+      GLuint service_id,
+      GLuint old_service_id,
+      GLenum bind_target,
+      GLenum target,
+      GLint level,
+      GLenum format,
+      GLenum type,
+      GLsizei width,
+      GLsizei height) {
+  EXPECT_CALL(*gl_, BindTexture(bind_target, service_id))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, TexImage2D(
+      target, level, format, width, height, 0, format, type, _))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, BindTexture(bind_target, old_service_id))
+      .Times(1)
+      .RetiresOnSaturation();
+}
+
+void GLES2DecoderTestBase::SetupExpectationsForFramebufferClearing(
+    GLenum target,
     GLuint clear_bits,
     GLclampf restore_red,
     GLclampf restore_green,
     GLclampf restore_blue,
     GLclampf restore_alpha,
     GLuint restore_stencil,
     GLclampf restore_depth,
     bool restore_scissor_test) {
-  InSequence sequence;
-  EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
+  // TODO(gman): Figure out why InSequence stopped working.
+  // InSequence sequence;
+  EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(target))
       .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
       .RetiresOnSaturation();
   if ((clear_bits & GL_COLOR_BUFFER_BIT) != 0) {
-    EXPECT_CALL(*gl_, ClearColor(0, 0, 0, 0))
+    EXPECT_CALL(*gl_, ClearColor(0.0f, 0.0f, 0.0f, 0.0f))
         .Times(1)
         .RetiresOnSaturation();
-    EXPECT_CALL(*gl_, ColorMask(1, 1, 1, 1))
+    EXPECT_CALL(*gl_, ColorMask(true, true, true, true))
         .Times(1)
         .RetiresOnSaturation();
   }
   if ((clear_bits & GL_STENCIL_BUFFER_BIT) != 0) {
     EXPECT_CALL(*gl_, ClearStencil(0))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, StencilMask(static_cast<GLuint>(-1)))
         .Times(1)
         .RetiresOnSaturation();
@@ skipping 226 matching lines @@
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   TexImage2D cmd;
   cmd.Init(target, level, internal_format, width, height, border, format,
            type, shared_memory_id, shared_memory_offset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
+void GLES2DecoderTestBase::DoRenderbufferStorage(
+    GLenum target, GLenum internal_format, GLenum actual_format,
+    GLsizei width, GLsizei height,  GLenum error) {
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(GL_NO_ERROR))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, RenderbufferStorageEXT(
+      target, actual_format, width, height))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(error))
+      .RetiresOnSaturation();
+  RenderbufferStorage cmd;
+  cmd.Init(target, internal_format, width, height);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+}
+
+void GLES2DecoderTestBase::DoFramebufferTexture2D(
+    GLenum target, GLenum attachment, GLenum textarget,
+    GLuint texture_client_id, GLuint texture_service_id, GLint level,
+    GLenum error) {
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(GL_NO_ERROR))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, FramebufferTexture2DEXT(
+      target, attachment, textarget, texture_service_id, level))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(error))
+      .RetiresOnSaturation();
+  FramebufferTexture2D cmd;
+  cmd.Init(target, attachment, textarget, texture_client_id, level);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+}
+
+void GLES2DecoderTestBase::DoFramebufferRenderbuffer(
+    GLenum target,
+    GLenum attachment,
+    GLenum renderbuffer_target,
+    GLuint renderbuffer_client_id,
+    GLuint renderbuffer_service_id,
+    GLenum error) {
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(GL_NO_ERROR))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(
+      target, attachment, renderbuffer_target, renderbuffer_service_id))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(error))
+      .RetiresOnSaturation();
+  FramebufferRenderbuffer cmd;
+  cmd.Init(target, attachment, renderbuffer_target, renderbuffer_client_id);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+}
+
 void GLES2DecoderTestBase::DoVertexAttribPointer(
     GLuint index, GLint size, GLenum type, GLsizei stride, GLuint offset) {
   EXPECT_CALL(*gl_,
               VertexAttribPointer(index, size, type, GL_FALSE, stride,
                                   BufferOffset(offset)))
       .Times(1)
       .RetiresOnSaturation();
   VertexAttribPointer cmd;
   cmd.Init(index, size, GL_FLOAT, GL_FALSE, stride, offset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ skipping 29 matching lines @@
 const uint32 GLES2DecoderTestBase::kInvalidSharedMemoryOffset;
 const uint32 GLES2DecoderTestBase::kInitialResult;
 const uint8 GLES2DecoderTestBase::kInitialMemoryValue;
 
 const uint32 GLES2DecoderTestBase::kNewClientId;
 const uint32 GLES2DecoderTestBase::kNewServiceId;
 const uint32 GLES2DecoderTestBase::kInvalidClientId;
 
 const int GLES2DecoderTestBase::kBackBufferWidth;
 const int GLES2DecoderTestBase::kBackBufferHeight;
+
+const GLuint GLES2DecoderTestBase::kServiceVertexShaderId;
+const GLuint GLES2DecoderTestBase::kServiceFragmentShaderId;
+
+const GLsizei GLES2DecoderTestBase::kNumVertices;
+const GLsizei GLES2DecoderTestBase::kNumIndices;
+const int GLES2DecoderTestBase::kValidIndexRangeStart;
+const int GLES2DecoderTestBase::kValidIndexRangeCount;
+const int GLES2DecoderTestBase::kInvalidIndexRangeStart;
+const int GLES2DecoderTestBase::kInvalidIndexRangeCount;
+const int GLES2DecoderTestBase::kOutOfRangeIndexRangeEnd;
+const GLuint GLES2DecoderTestBase::kMaxValidIndex;
+
+const GLint GLES2DecoderTestBase::kMaxAttribLength;
+const GLint GLES2DecoderTestBase::kAttrib1Size;
+const GLint GLES2DecoderTestBase::kAttrib2Size;
+const GLint GLES2DecoderTestBase::kAttrib3Size;
+const GLint GLES2DecoderTestBase::kAttrib1Location;
+const GLint GLES2DecoderTestBase::kAttrib2Location;
+const GLint GLES2DecoderTestBase::kAttrib3Location;
+const GLenum GLES2DecoderTestBase::kAttrib1Type;
+const GLenum GLES2DecoderTestBase::kAttrib2Type;
+const GLenum GLES2DecoderTestBase::kAttrib3Type;
+const GLint GLES2DecoderTestBase::kInvalidAttribLocation;
+const GLint GLES2DecoderTestBase::kBadAttribIndex;
+
+const GLint GLES2DecoderTestBase::kMaxUniformLength;
+const GLint GLES2DecoderTestBase::kUniform1Size;
+const GLint GLES2DecoderTestBase::kUniform2Size;
+const GLint GLES2DecoderTestBase::kUniform3Size;
+const GLint GLES2DecoderTestBase::kUniform1Location;
+const GLint GLES2DecoderTestBase::kUniform2Location;
+const GLint GLES2DecoderTestBase::kUniform2ElementLocation;
+const GLint GLES2DecoderTestBase::kUniform3Location;
+const GLenum GLES2DecoderTestBase::kUniform1Type;
+const GLenum GLES2DecoderTestBase::kUniform2Type;
+const GLenum GLES2DecoderTestBase::kUniform3Type;
+const GLenum GLES2DecoderTestBase::kUniformCubemapType;
+const GLint GLES2DecoderTestBase::kInvalidUniformLocation;
+const GLint GLES2DecoderTestBase::kBadUniformIndex;
+
 #endif
 
-void GLES2DecoderWithShaderTestBase::SetUp() {
-  GLES2DecoderTestBase::SetUp();
-  SetupDefaultProgram();
-}
+const char* GLES2DecoderTestBase::kAttrib1Name = "attrib1";
+const char* GLES2DecoderTestBase::kAttrib2Name = "attrib2";
+const char* GLES2DecoderTestBase::kAttrib3Name = "attrib3";
+const char* GLES2DecoderTestBase::kUniform1Name = "uniform1";
+const char* GLES2DecoderTestBase::kUniform2Name = "uniform2[0]";
+const char* GLES2DecoderTestBase::kUniform3Name = "uniform3[0]";
 
-void GLES2DecoderWithShaderTestBase::SetupDefaultProgram() {
+void GLES2DecoderTestBase::SetupDefaultProgram() {
   {
     static AttribInfo attribs[] = {
       { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
       { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
       { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
     };
     static UniformInfo uniforms[] = {
       { kUniform1Name, kUniform1Size, kUniform1Type, kUniform1Location, },
       { kUniform2Name, kUniform2Size, kUniform2Type, kUniform2Location, },
       { kUniform3Name, kUniform3Size, kUniform3Type, kUniform3Location, },
     };
     SetupShader(attribs, arraysize(attribs), uniforms, arraysize(uniforms),
                 client_program_id_, kServiceProgramId,
                 client_vertex_shader_id_, kServiceVertexShaderId,
                 client_fragment_shader_id_, kServiceFragmentShaderId);
   }
 
   {
     EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
         .Times(1)
         .RetiresOnSaturation();
     UseProgram cmd;
     cmd.Init(client_program_id_);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   }
 }
 
+void GLES2DecoderTestBase::SetupCubemapProgram() {
+  {
+    static AttribInfo attribs[] = {
+      { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
+      { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
+      { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
+    };
+    static UniformInfo uniforms[] = {
+      { kUniform1Name, kUniform1Size, kUniformCubemapType, kUniform1Location, },
+      { kUniform2Name, kUniform2Size, kUniform2Type, kUniform2Location, },
+      { kUniform3Name, kUniform3Size, kUniform3Type, kUniform3Location, },
+    };
+    SetupShader(attribs, arraysize(attribs), uniforms, arraysize(uniforms),
+                client_program_id_, kServiceProgramId,
+                client_vertex_shader_id_, kServiceVertexShaderId,
+                client_fragment_shader_id_, kServiceFragmentShaderId);
+  }
+
+  {
+    EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
+        .Times(1)
+        .RetiresOnSaturation();
+    UseProgram cmd;
+    cmd.Init(client_program_id_);
+    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  }
+}
+
 void GLES2DecoderWithShaderTestBase::TearDown() {
   GLES2DecoderTestBase::TearDown();
 }
 
 void GLES2DecoderTestBase::SetupShader(
     GLES2DecoderTestBase::AttribInfo* attribs, size_t num_attribs,
     GLES2DecoderTestBase::UniformInfo* uniforms, size_t num_uniforms,
     GLuint program_client_id, GLuint program_service_id,
     GLuint vertex_shader_client_id, GLuint vertex_shader_service_id,
     GLuint fragment_shader_client_id, GLuint fragment_shader_service_id) {
@@ skipping 112 matching lines @@
 
   attach_cmd.Init(program_client_id, fragment_shader_client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
 
   LinkProgram link_cmd;
   link_cmd.Init(program_client_id);
 
   EXPECT_EQ(error::kNoError, ExecuteCmd(link_cmd));
 }
 
-void GLES2DecoderWithShaderTestBase::DoEnableVertexAttribArray(GLint index) {
+void GLES2DecoderTestBase::DoEnableVertexAttribArray(GLint index) {
   EXPECT_CALL(*gl_, EnableVertexAttribArray(index))
       .Times(1)
       .RetiresOnSaturation();
   EnableVertexAttribArray cmd;
   cmd.Init(index);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-void GLES2DecoderWithShaderTestBase::DoBufferData(GLenum target, GLsizei size) {
+void GLES2DecoderTestBase::DoBufferData(GLenum target, GLsizei size) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BufferData(target, size, _, GL_STREAM_DRAW))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   BufferData cmd;
   cmd.Init(target, size, 0, 0, GL_STREAM_DRAW);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-void GLES2DecoderWithShaderTestBase::DoBufferSubData(
+void GLES2DecoderTestBase::DoBufferSubData(
     GLenum target, GLint offset, GLsizei size, const void* data) {
   EXPECT_CALL(*gl_, BufferSubData(target, offset, size,
                                   shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   memcpy(shared_memory_address_, data, size);
   BufferSubData cmd;
   cmd.Init(target, offset, size, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-void GLES2DecoderWithShaderTestBase::SetupVertexBuffer() {
+void GLES2DecoderTestBase::SetupVertexBuffer() {
   DoEnableVertexAttribArray(1);
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
   GLfloat f = 0;
   DoBufferData(GL_ARRAY_BUFFER, kNumVertices * 2 * sizeof(f));
 }
 
-void GLES2DecoderWithShaderTestBase::SetupIndexBuffer() {
+void GLES2DecoderTestBase::SetupIndexBuffer() {
   DoBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
                client_element_buffer_id_,
                kServiceElementBufferId);
   static const GLshort indices[] = {100, 1, 2, 3, 4, 5, 6, 7, 100, 9};
   COMPILE_ASSERT(arraysize(indices) == kNumIndices, Indices_is_not_10);
   DoBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices));
   DoBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, 2, indices);
   DoBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 2, sizeof(indices) - 2, &indices[1]);
 }
 
-void GLES2DecoderWithShaderTestBase::SetupTexture() {
+void GLES2DecoderTestBase::SetupTexture() {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-               0, 0);
+               kSharedMemoryId, kSharedMemoryOffset);
 };
 
-void GLES2DecoderWithShaderTestBase::DeleteVertexBuffer() {
+void GLES2DecoderTestBase::DeleteVertexBuffer() {
   DoDeleteBuffer(client_buffer_id_, kServiceBufferId);
 }
 
-void GLES2DecoderWithShaderTestBase::DeleteIndexBuffer() {
+void GLES2DecoderTestBase::DeleteIndexBuffer() {
   DoDeleteBuffer(client_element_buffer_id_, kServiceElementBufferId);
 }
 
-// GCC requires these declarations, but MSVC requires they not be present
-#ifndef COMPILER_MSVC
-const GLuint GLES2DecoderWithShaderTestBase::kServiceVertexShaderId;
-const GLuint GLES2DecoderWithShaderTestBase::kServiceFragmentShaderId;
+void GLES2DecoderTestBase::AddExpectationsForSimulatedAttrib0WithError(
+    GLsizei num_vertices, GLuint buffer_id, GLenum error) {
+  if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
+    return;
+  }
 
-const GLsizei GLES2DecoderWithShaderTestBase::kNumVertices;
-const GLsizei GLES2DecoderWithShaderTestBase::kNumIndices;
-const int GLES2DecoderWithShaderTestBase::kValidIndexRangeStart;
-const int GLES2DecoderWithShaderTestBase::kValidIndexRangeCount;
-const int GLES2DecoderWithShaderTestBase::kInvalidIndexRangeStart;
-const int GLES2DecoderWithShaderTestBase::kInvalidIndexRangeCount;
-const int GLES2DecoderWithShaderTestBase::kOutOfRangeIndexRangeEnd;
-const GLuint GLES2DecoderWithShaderTestBase::kMaxValidIndex;
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(GL_NO_ERROR))
+      .WillOnce(Return(error))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, kServiceAttrib0BufferId))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, BufferData(GL_ARRAY_BUFFER,
+                               num_vertices * sizeof(GLfloat) * 4,
+                               _, GL_DYNAMIC_DRAW))
+      .Times(1)
+      .RetiresOnSaturation();
+  if (error == GL_NO_ERROR) {
+    EXPECT_CALL(*gl_, BufferSubData(
+        GL_ARRAY_BUFFER, 0, num_vertices * sizeof(GLfloat) * 4, _))
+        .Times(1)
+        .RetiresOnSaturation();
+    EXPECT_CALL(*gl_, VertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL))
+        .Times(1)
+        .RetiresOnSaturation();
+    EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, 0))
+        .Times(1)
+        .RetiresOnSaturation();
+    EXPECT_CALL(*gl_, VertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL))
+        .Times(1)
+        .RetiresOnSaturation();
+    EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, buffer_id))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+}
 
-const GLint GLES2DecoderWithShaderTestBase::kMaxAttribLength;
-const GLint GLES2DecoderWithShaderTestBase::kAttrib1Size;
-const GLint GLES2DecoderWithShaderTestBase::kAttrib2Size;
-const GLint GLES2DecoderWithShaderTestBase::kAttrib3Size;
-const GLint GLES2DecoderWithShaderTestBase::kAttrib1Location;
-const GLint GLES2DecoderWithShaderTestBase::kAttrib2Location;
-const GLint GLES2DecoderWithShaderTestBase::kAttrib3Location;
-const GLenum GLES2DecoderWithShaderTestBase::kAttrib1Type;
-const GLenum GLES2DecoderWithShaderTestBase::kAttrib2Type;
-const GLenum GLES2DecoderWithShaderTestBase::kAttrib3Type;
-const GLint GLES2DecoderWithShaderTestBase::kInvalidAttribLocation;
-const GLint GLES2DecoderWithShaderTestBase::kBadAttribIndex;
+void GLES2DecoderTestBase::AddExpectationsForSimulatedAttrib0(
+    GLsizei num_vertices, GLuint buffer_id) {
+  AddExpectationsForSimulatedAttrib0WithError(
+      num_vertices, buffer_id, GL_NO_ERROR);
+}
 
-const GLint GLES2DecoderWithShaderTestBase::kMaxUniformLength;
-const GLint GLES2DecoderWithShaderTestBase::kUniform1Size;
-const GLint GLES2DecoderWithShaderTestBase::kUniform2Size;
-const GLint GLES2DecoderWithShaderTestBase::kUniform3Size;
-const GLint GLES2DecoderWithShaderTestBase::kUniform1Location;
-const GLint GLES2DecoderWithShaderTestBase::kUniform2Location;
-const GLint GLES2DecoderWithShaderTestBase::kUniform2ElementLocation;
-const GLint GLES2DecoderWithShaderTestBase::kUniform3Location;
-const GLenum GLES2DecoderWithShaderTestBase::kUniform1Type;
-const GLenum GLES2DecoderWithShaderTestBase::kUniform2Type;
-const GLenum GLES2DecoderWithShaderTestBase::kUniform3Type;
-const GLint GLES2DecoderWithShaderTestBase::kInvalidUniformLocation;
-const GLint GLES2DecoderWithShaderTestBase::kBadUniformIndex;
-#endif
-
-const char* GLES2DecoderWithShaderTestBase::kAttrib1Name = "attrib1";
-const char* GLES2DecoderWithShaderTestBase::kAttrib2Name = "attrib2";
-const char* GLES2DecoderWithShaderTestBase::kAttrib3Name = "attrib3";
-const char* GLES2DecoderWithShaderTestBase::kUniform1Name = "uniform1";
-const char* GLES2DecoderWithShaderTestBase::kUniform2Name = "uniform2[0]";
-const char* GLES2DecoderWithShaderTestBase::kUniform3Name = "uniform3[0]";
+void GLES2DecoderWithShaderTestBase::SetUp() {
+  GLES2DecoderTestBase::SetUp();
+  SetupDefaultProgram();
+}
 
 }  // namespace gles2
 }  // namespace gpu