Optimize GLES2DecoderImpl::ApplyDirtyState.

gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc

 // Copyright 2014 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.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ skipping 36 matching lines @@
 using ::testing::SetArgumentPointee;
 using ::testing::SetArgPointee;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 
 namespace gpu {
 namespace gles2 {
 
 using namespace cmds;
 
-TEST_F(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) {
   const uint32 kBucketId = 123;
   GetProgramInfoCHROMIUM cmd;
   cmd.Init(client_program_id_, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_GT(bucket->size(), 0u);
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMInvalidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMInvalidArgs) {
   const uint32 kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   EXPECT_TRUE(bucket == NULL);
   GetProgramInfoCHROMIUM cmd;
   cmd.Init(kInvalidClientId, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(sizeof(ProgramInfoHeader), bucket->size());
   ProgramInfoHeader* info =
       bucket->GetDataAs<ProgramInfoHeader*>(0, sizeof(ProgramInfoHeader));
   ASSERT_TRUE(info != 0);
   EXPECT_EQ(0u, info->link_status);
   EXPECT_EQ(0u, info->num_attribs);
   EXPECT_EQ(0u, info->num_uniforms);
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformivSucceeds) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformivSucceeds) {
   GetUniformiv::Result* result =
       static_cast<GetUniformiv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformiv cmd;
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformiv(kServiceProgramId, kUniform2RealLocation, _))
       .Times(1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
             result->size);
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) {
   GetUniformiv::Result* result =
       static_cast<GetUniformiv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformiv cmd;
   cmd.Init(client_program_id_,
            kUniform2ElementFakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_,
               GetUniformiv(kServiceProgramId, kUniform2ElementRealLocation, _))
       .Times(1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
             result->size);
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformivBadProgramFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadProgramFails) {
   GetUniformiv::Result* result =
       static_cast<GetUniformiv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformiv cmd;
   // non-existant program
   cmd.Init(kInvalidClientId,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0);
@@ skipping 23 matching lines @@
   result->size = kInitialResult;
   cmd.Init(kNewClientId,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0U, result->size);
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformivBadLocationFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadLocationFails) {
   GetUniformiv::Result* result =
       static_cast<GetUniformiv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformiv cmd;
   // invalid location
   cmd.Init(client_program_id_,
            kInvalidUniformLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0U, result->size);
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformivBadSharedMemoryFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadSharedMemoryFails) {
   GetUniformiv cmd;
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
            kInvalidSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 };
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformfvSucceeds) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformfvSucceeds) {
   GetUniformfv::Result* result =
       static_cast<GetUniformfv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformfv cmd;
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformfv(kServiceProgramId, kUniform2RealLocation, _))
       .Times(1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
             result->size);
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) {
   GetUniformfv::Result* result =
       static_cast<GetUniformfv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformfv cmd;
   cmd.Init(client_program_id_,
            kUniform2ElementFakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_,
               GetUniformfv(kServiceProgramId, kUniform2ElementRealLocation, _))
       .Times(1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
             result->size);
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformfvBadProgramFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadProgramFails) {
   GetUniformfv::Result* result =
       static_cast<GetUniformfv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformfv cmd;
   // non-existant program
   cmd.Init(kInvalidClientId,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0);
@@ skipping 23 matching lines @@
   result->size = kInitialResult;
   cmd.Init(kNewClientId,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0U, result->size);
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformfvBadLocationFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadLocationFails) {
   GetUniformfv::Result* result =
       static_cast<GetUniformfv::Result*>(shared_memory_address_);
   result->size = 0;
   GetUniformfv cmd;
   // invalid location
   cmd.Init(client_program_id_,
            kInvalidUniformLocation,
            kSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0U, result->size);
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformfvBadSharedMemoryFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadSharedMemoryFails) {
   GetUniformfv cmd;
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
            kInvalidSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
            kSharedMemoryId,
            kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 };
 
-TEST_F(GLES2DecoderWithShaderTest, GetAttachedShadersSucceeds) {
+TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersSucceeds) {
   GetAttachedShaders cmd;
   typedef GetAttachedShaders::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->size = 0;
   EXPECT_CALL(*gl_, GetAttachedShaders(kServiceProgramId, 1, _, _)).WillOnce(
       DoAll(SetArgumentPointee<2>(1), SetArgumentPointee<3>(kServiceShaderId)));
   cmd.Init(client_program_id_,
            shared_memory_id_,
            shared_memory_offset_,
            Result::ComputeSize(1));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(1, result->GetNumResults());
   EXPECT_EQ(client_shader_id_, result->GetData()[0]);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetAttachedShadersResultNotInitFail) {
+TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersResultNotInitFail) {
   GetAttachedShaders cmd;
   typedef GetAttachedShaders::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->size = 1;
   EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0);
   cmd.Init(client_program_id_,
            shared_memory_id_,
            shared_memory_offset_,
            Result::ComputeSize(1));
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetAttachedShadersBadProgramFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersBadProgramFails) {
   GetAttachedShaders cmd;
   typedef GetAttachedShaders::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->size = 0;
   EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0);
   cmd.Init(kInvalidClientId,
            shared_memory_id_,
            shared_memory_offset_,
            Result::ComputeSize(1));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0U, result->size);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetAttachedShadersBadSharedMemoryFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersBadSharedMemoryFails) {
   GetAttachedShaders cmd;
   typedef GetAttachedShaders::Result Result;
   cmd.Init(client_program_id_,
            kInvalidSharedMemoryId,
            shared_memory_offset_,
            Result::ComputeSize(1));
   EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            shared_memory_id_,
            kInvalidSharedMemoryOffset,
            Result::ComputeSize(1));
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatSucceeds) {
+TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatSucceeds) {
   ScopedGLImplementationSetter gl_impl(::gfx::kGLImplementationEGLGLES2);
   GetShaderPrecisionFormat cmd;
   typedef GetShaderPrecisionFormat::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 0;
   const GLint range[2] = {62, 62};
   const GLint precision = 16;
   EXPECT_CALL(*gl_, GetShaderPrecisionFormat(_, _, _, _))
       .WillOnce(DoAll(SetArrayArgument<2>(range, range + 2),
                       SetArgumentPointee<3>(precision)))
       .RetiresOnSaturation();
   cmd.Init(GL_VERTEX_SHADER,
            GL_HIGH_FLOAT,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_NE(0, result->success);
   EXPECT_EQ(range[0], result->min_range);
   EXPECT_EQ(range[1], result->max_range);
   EXPECT_EQ(precision, result->precision);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatResultNotInitFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatResultNotInitFails) {
   GetShaderPrecisionFormat cmd;
   typedef GetShaderPrecisionFormat::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 1;
   // NOTE: GL might not be called. There is no Desktop OpenGL equivalent
   cmd.Init(GL_VERTEX_SHADER,
            GL_HIGH_FLOAT,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatBadArgsFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatBadArgsFails) {
   typedef GetShaderPrecisionFormat::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 0;
   GetShaderPrecisionFormat cmd;
   cmd.Init(
       GL_TEXTURE_2D, GL_HIGH_FLOAT, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
   result->success = 0;
   cmd.Init(GL_VERTEX_SHADER,
            GL_TEXTURE_2D,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest,
+TEST_P(GLES2DecoderWithShaderTest,
        GetShaderPrecisionFormatBadSharedMemoryFails) {
   GetShaderPrecisionFormat cmd;
   cmd.Init(GL_VERTEX_SHADER,
            GL_HIGH_FLOAT,
            kInvalidSharedMemoryId,
            shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(GL_VERTEX_SHADER,
            GL_TEXTURE_2D,
            shared_memory_id_,
            kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) {
+TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) {
   const GLuint kUniformIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveUniform cmd;
   typedef GetActiveUniform::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 0;
   cmd.Init(client_program_id_,
            kUniformIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_NE(0, result->success);
   EXPECT_EQ(kUniform2Size, result->size);
   EXPECT_EQ(kUniform2Type, result->type);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(
       0,
       memcmp(
           bucket->GetData(0, bucket->size()), kUniform2Name, bucket->size()));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) {
   const GLuint kUniformIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveUniform cmd;
   typedef GetActiveUniform::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 1;
   cmd.Init(client_program_id_,
            kUniformIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) {
   const GLuint kUniformIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveUniform cmd;
   typedef GetActiveUniform::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 0;
   cmd.Init(kInvalidClientId,
            kUniformIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->success);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
   result->success = 0;
   cmd.Init(client_shader_id_,
            kUniformIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->success);
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformBadIndexFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadIndexFails) {
   const uint32 kBucketId = 123;
   GetActiveUniform cmd;
   typedef GetActiveUniform::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 0;
   cmd.Init(client_program_id_,
            kBadUniformIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->success);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) {
   const GLuint kUniformIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveUniform cmd;
   cmd.Init(client_program_id_,
            kUniformIndex,
            kBucketId,
            kInvalidSharedMemoryId,
            shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            kUniformIndex,
            kBucketId,
            shared_memory_id_,
            kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) {
+TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) {
   const GLuint kAttribIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveAttrib cmd;
   typedef GetActiveAttrib::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 0;
   cmd.Init(client_program_id_,
            kAttribIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_NE(0, result->success);
   EXPECT_EQ(kAttrib2Size, result->size);
   EXPECT_EQ(kAttrib2Type, result->type);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(
       0,
       memcmp(bucket->GetData(0, bucket->size()), kAttrib2Name, bucket->size()));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) {
   const GLuint kAttribIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveAttrib cmd;
   typedef GetActiveAttrib::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 1;
   cmd.Init(client_program_id_,
            kAttribIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) {
   const GLuint kAttribIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveAttrib cmd;
   typedef GetActiveAttrib::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 0;
   cmd.Init(kInvalidClientId,
            kAttribIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->success);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
   result->success = 0;
   cmd.Init(client_shader_id_,
            kAttribIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->success);
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribBadIndexFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadIndexFails) {
   const uint32 kBucketId = 123;
   GetActiveAttrib cmd;
   typedef GetActiveAttrib::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->success = 0;
   cmd.Init(client_program_id_,
            kBadAttribIndex,
            kBucketId,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0, result->success);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
+TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
   const GLuint kAttribIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveAttrib cmd;
   cmd.Init(client_program_id_,
            kAttribIndex,
            kBucketId,
            kInvalidSharedMemoryId,
            shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            kAttribIndex,
            kBucketId,
            shared_memory_id_,
            kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) {
   const char* kInfo = "hello";
   const uint32 kBucketId = 123;
   CompileShader compile_cmd;
   GetShaderInfoLog cmd;
   EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _));
   EXPECT_CALL(*gl_, CompileShader(kServiceShaderId));
   EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _))
       .WillOnce(SetArgumentPointee<2>(GL_FALSE))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_INFO_LOG_LENGTH, _))
       .WillOnce(SetArgumentPointee<2>(strlen(kInfo) + 1))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetShaderInfoLog(kServiceShaderId, strlen(kInfo) + 1, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(strlen(kInfo)),
                       SetArrayArgument<3>(kInfo, kInfo + strlen(kInfo) + 1)));
   compile_cmd.Init(client_shader_id_);
   cmd.Init(client_shader_id_, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(compile_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(strlen(kInfo) + 1, bucket->size());
   EXPECT_EQ(0,
             memcmp(bucket->GetData(0, bucket->size()), kInfo, bucket->size()));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
   const uint32 kBucketId = 123;
   GetShaderInfoLog cmd;
   cmd.Init(kInvalidClientId, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderTest, CompileShaderValidArgs) {
+TEST_P(GLES2DecoderTest, CompileShaderValidArgs) {
   EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _));
   EXPECT_CALL(*gl_, CompileShader(kServiceShaderId));
   EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _))
       .WillOnce(SetArgumentPointee<2>(GL_TRUE))
       .RetiresOnSaturation();
   CompileShader cmd;
   cmd.Init(client_shader_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderTest, CompileShaderInvalidArgs) {
+TEST_P(GLES2DecoderTest, CompileShaderInvalidArgs) {
   CompileShader cmd;
   cmd.Init(kInvalidClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
   cmd.Init(client_program_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 }
 
-TEST_F(GLES2DecoderTest, ShaderSourceAndGetShaderSourceValidArgs) {
+TEST_P(GLES2DecoderTest, ShaderSourceAndGetShaderSourceValidArgs) {
   const uint32 kBucketId = 123;
   const char kSource[] = "hello";
   const uint32 kSourceSize = sizeof(kSource) - 1;
   memcpy(shared_memory_address_, kSource, kSourceSize);
   ShaderSource cmd;
   cmd.Init(
       client_shader_id_, kSharedMemoryId, kSharedMemoryOffset, kSourceSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   memset(shared_memory_address_, 0, kSourceSize);
   GetShaderSource get_cmd;
   get_cmd.Init(client_shader_id_, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(get_cmd));
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(kSourceSize + 1, bucket->size());
   EXPECT_EQ(
       0, memcmp(bucket->GetData(0, bucket->size()), kSource, bucket->size()));
 }
 
-TEST_F(GLES2DecoderTest, ShaderSourceInvalidArgs) {
+TEST_P(GLES2DecoderTest, ShaderSourceInvalidArgs) {
   const char kSource[] = "hello";
   const uint32 kSourceSize = sizeof(kSource) - 1;
   memcpy(shared_memory_address_, kSource, kSourceSize);
   ShaderSource cmd;
   cmd.Init(kInvalidClientId, kSharedMemoryId, kSharedMemoryOffset, kSourceSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
   cmd.Init(
       client_program_id_, kSharedMemoryId, kSharedMemoryOffset, kSourceSize);
@@ skipping 10 matching lines @@
            kInvalidSharedMemoryOffset,
            kSourceSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_shader_id_,
            kSharedMemoryId,
            kSharedMemoryOffset,
            kSharedBufferSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderTest, ShaderSourceBucketAndGetShaderSourceValidArgs) {
+TEST_P(GLES2DecoderTest, ShaderSourceBucketAndGetShaderSourceValidArgs) {
   const uint32 kInBucketId = 123;
   const uint32 kOutBucketId = 125;
   const char kSource[] = "hello";
   const uint32 kSourceSize = sizeof(kSource) - 1;
   SetBucketAsCString(kInBucketId, kSource);
   ShaderSourceBucket cmd;
   cmd.Init(client_shader_id_, kInBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   ClearSharedMemory();
   GetShaderSource get_cmd;
   get_cmd.Init(client_shader_id_, kOutBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(get_cmd));
   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kOutBucketId);
   ASSERT_TRUE(bucket != NULL);
   EXPECT_EQ(kSourceSize + 1, bucket->size());
   EXPECT_EQ(
       0, memcmp(bucket->GetData(0, bucket->size()), kSource, bucket->size()));
 }
 
-TEST_F(GLES2DecoderTest, ShaderSourceBucketInvalidArgs) {
+TEST_P(GLES2DecoderTest, ShaderSourceBucketInvalidArgs) {
   const uint32 kBucketId = 123;
   const char kSource[] = "hello";
   const uint32 kSourceSize = sizeof(kSource) - 1;
   memcpy(shared_memory_address_, kSource, kSourceSize);
   ShaderSourceBucket cmd;
   // Test no bucket.
   cmd.Init(client_texture_id_, kBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   // Test invalid client.
   SetBucketAsCString(kBucketId, kSource);
   cmd.Init(kInvalidClientId, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderTest, ShaderSourceStripComments) {
+TEST_P(GLES2DecoderTest, ShaderSourceStripComments) {
   const uint32 kInBucketId = 123;
   const char kSource[] = "hello/*te\ast*/world//a\ab";
   SetBucketAsCString(kInBucketId, kSource);
   ShaderSourceBucket cmd;
   cmd.Init(client_shader_id_, kInBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, Uniform1iValidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, Uniform1iValidArgs) {
   EXPECT_CALL(*gl_, Uniform1i(kUniform1RealLocation, 2));
   Uniform1i cmd;
   cmd.Init(kUniform1FakeLocation, 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, Uniform1ivValidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, Uniform1ivValidArgs) {
   EXPECT_CALL(
       *gl_,
       Uniform1iv(kUniform1RealLocation,
                  1,
                  reinterpret_cast<const GLint*>(shared_memory_address_)));
   Uniform1iv cmd;
   cmd.Init(kUniform1FakeLocation, 1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_0) {
+TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
   Uniform1iv cmd;
   cmd.Init(kUniform1FakeLocation, 1, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_1) {
+TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
   Uniform1iv cmd;
   cmd.Init(
       kUniform1FakeLocation, 1, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
   EXPECT_CALL(*gl_,
               Uniform1iv(kUniform1RealLocation,
                          1,
                          reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
   GLint temp[1 * 2] = {
       0,
   };
   cmd.Init(kUniform1FakeLocation, 1, &temp[0]);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, Uniform1ivInvalidValidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidValidArgs) {
   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
   Uniform1iv cmd;
   cmd.Init(kUniform1FakeLocation, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, Uniform1ivZeroCount) {
+TEST_P(GLES2DecoderWithShaderTest, Uniform1ivZeroCount) {
   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
   Uniform1iv cmd;
   cmd.Init(kUniform1FakeLocation, 0, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, Uniform1iSamplerIsLmited) {
+TEST_P(GLES2DecoderWithShaderTest, Uniform1iSamplerIsLmited) {
   EXPECT_CALL(*gl_, Uniform1i(_, _)).Times(0);
   Uniform1i cmd;
   cmd.Init(kUniform1FakeLocation, kNumTextureUnits);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, Uniform1ivSamplerIsLimited) {
+TEST_P(GLES2DecoderWithShaderTest, Uniform1ivSamplerIsLimited) {
   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
   GLint temp[] = {kNumTextureUnits};
   cmd.Init(kUniform1FakeLocation, 1, &temp[0]);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderTest, BindAttribLocation) {
+TEST_P(GLES2DecoderTest, BindAttribLocation) {
   const GLint kLocation = 2;
   const char* kName = "testing";
   const uint32 kNameSize = strlen(kName);
   EXPECT_CALL(*gl_,
               BindAttribLocation(kServiceProgramId, kLocation, StrEq(kName)))
       .Times(1);
   memcpy(shared_memory_address_, kName, kNameSize);
   BindAttribLocation cmd;
   cmd.Init(client_program_id_,
            kLocation,
            kSharedMemoryId,
            kSharedMemoryOffset,
            kNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderTest, BindAttribLocationInvalidArgs) {
+TEST_P(GLES2DecoderTest, BindAttribLocationInvalidArgs) {
   const GLint kLocation = 2;
   const char* kName = "testing";
   const char* kBadName = "test\aing";
   const uint32 kNameSize = strlen(kName);
   const uint32 kBadNameSize = strlen(kBadName);
   EXPECT_CALL(*gl_, BindAttribLocation(_, _, _)).Times(0);
   memcpy(shared_memory_address_, kName, kNameSize);
   BindAttribLocation cmd;
   cmd.Init(kInvalidClientId,
            kLocation,
@@ skipping 23 matching lines @@
   memcpy(shared_memory_address_, kBadName, kBadNameSize);
   cmd.Init(client_program_id_,
            kLocation,
            kSharedMemoryId,
            kSharedMemoryOffset,
            kBadNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderTest, BindAttribLocationBucket) {
+TEST_P(GLES2DecoderTest, BindAttribLocationBucket) {
   const uint32 kBucketId = 123;
   const GLint kLocation = 2;
   const char* kName = "testing";
   EXPECT_CALL(*gl_,
               BindAttribLocation(kServiceProgramId, kLocation, StrEq(kName)))
       .Times(1);
   SetBucketAsCString(kBucketId, kName);
   BindAttribLocationBucket cmd;
   cmd.Init(client_program_id_, kLocation, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderTest, BindAttribLocationBucketInvalidArgs) {
+TEST_P(GLES2DecoderTest, BindAttribLocationBucketInvalidArgs) {
   const uint32 kBucketId = 123;
   const GLint kLocation = 2;
   const char* kName = "testing";
   EXPECT_CALL(*gl_, BindAttribLocation(_, _, _)).Times(0);
   BindAttribLocationBucket cmd;
   // check bucket does not exist.
   cmd.Init(client_program_id_, kLocation, kBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   // check bucket is empty.
   SetBucketAsCString(kBucketId, NULL);
   cmd.Init(client_program_id_, kLocation, kBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   // Check bad program id
   SetBucketAsCString(kBucketId, kName);
   cmd.Init(kInvalidClientId, kLocation, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetAttribLocation) {
+TEST_P(GLES2DecoderWithShaderTest, GetAttribLocation) {
   const uint32 kNameSize = strlen(kAttrib2Name);
   const char* kNonExistentName = "foobar";
   const uint32 kNonExistentNameSize = strlen(kNonExistentName);
   typedef GetAttribLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result));
   const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result);
   memcpy(name, kAttrib2Name, kNameSize);
   GetAttribLocation cmd;
@@ skipping 10 matching lines @@
   cmd.Init(client_program_id_,
            kSharedMemoryId,
            kNameOffset,
            kSharedMemoryId,
            kSharedMemoryOffset,
            kNonExistentNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) {
   const uint32 kNameSize = strlen(kAttrib2Name);
   const char* kBadName = "foo\abar";
   const uint32 kBadNameSize = strlen(kBadName);
   typedef GetAttribLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result));
   const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result);
   memcpy(name, kAttrib2Name, kNameSize);
   GetAttribLocation cmd;
@@ skipping 51 matching lines @@
   cmd.Init(client_program_id_,
            kSharedMemoryId,
            kNameOffset,
            kSharedMemoryId,
            kSharedMemoryOffset,
            kBadNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetAttribLocationBucket) {
+TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationBucket) {
   const uint32 kBucketId = 123;
   const char* kNonExistentName = "foobar";
   typedef GetAttribLocationBucket::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   SetBucketAsCString(kBucketId, kAttrib2Name);
   *result = -1;
   GetAttribLocationBucket cmd;
   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(kAttrib2Location, *result);
   SetBucketAsCString(kBucketId, kNonExistentName);
   *result = -1;
   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetAttribLocationBucketInvalidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationBucketInvalidArgs) {
   const uint32 kBucketId = 123;
   typedef GetAttribLocationBucket::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   GetAttribLocationBucket cmd;
   // Check no bucket
   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
   // Check bad program id.
   SetBucketAsCString(kBucketId, kAttrib2Name);
   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   *result = -1;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   // Check bad memory
   cmd.Init(client_program_id_,
            kBucketId,
            kInvalidSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            kBucketId,
            kSharedMemoryId,
            kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformLocation) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformLocation) {
   const uint32 kNameSize = strlen(kUniform2Name);
   const char* kNonExistentName = "foobar";
   const uint32 kNonExistentNameSize = strlen(kNonExistentName);
   typedef GetUniformLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result));
   const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result);
   memcpy(name, kUniform2Name, kNameSize);
   GetUniformLocation cmd;
@@ skipping 10 matching lines @@
   cmd.Init(client_program_id_,
            kSharedMemoryId,
            kNameOffset,
            kSharedMemoryId,
            kSharedMemoryOffset,
            kNonExistentNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformLocationInvalidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationInvalidArgs) {
   const uint32 kNameSize = strlen(kUniform2Name);
   const char* kBadName = "foo\abar";
   const uint32 kBadNameSize = strlen(kBadName);
   typedef GetUniformLocation::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result));
   const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result);
   memcpy(name, kUniform2Name, kNameSize);
   GetUniformLocation cmd;
@@ skipping 51 matching lines @@
   cmd.Init(client_program_id_,
            kSharedMemoryId,
            kNameOffset,
            kSharedMemoryId,
            kSharedMemoryOffset,
            kBadNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformLocationBucket) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationBucket) {
   const uint32 kBucketId = 123;
   const char* kNonExistentName = "foobar";
   typedef GetUniformLocationBucket::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   SetBucketAsCString(kBucketId, kUniform2Name);
   *result = -1;
   GetUniformLocationBucket cmd;
   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(kUniform2FakeLocation, *result);
   SetBucketAsCString(kBucketId, kNonExistentName);
   *result = -1;
   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
 }
 
-TEST_F(GLES2DecoderWithShaderTest, GetUniformLocationBucketInvalidArgs) {
+TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationBucketInvalidArgs) {
   const uint32 kBucketId = 123;
   typedef GetUniformLocationBucket::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   *result = -1;
   GetUniformLocationBucket cmd;
   // Check no bucket
   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
   // Check bad program id.
   SetBucketAsCString(kBucketId, kUniform2Name);
   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
   *result = -1;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   // Check bad memory
   cmd.Init(client_program_id_,
            kBucketId,
            kInvalidSharedMemoryId,
            kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_,
            kBucketId,
            kSharedMemoryId,
            kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_F(GLES2DecoderWithShaderTest, BindUniformLocationCHROMIUM) {
+TEST_P(GLES2DecoderWithShaderTest, BindUniformLocationCHROMIUM) {
   const GLint kLocation = 2;
   const char* kName = "testing";
   const uint32 kNameSize = strlen(kName);
   const char* kBadName1 = "gl_testing";
   const uint32 kBadName1Size = strlen(kBadName1);
   const char* kBadName2 = "testing[1]";
   const uint32 kBadName2Size = strlen(kBadName2);
   memcpy(shared_memory_address_, kName, kNameSize);
   BindUniformLocationCHROMIUM cmd;
   cmd.Init(client_program_id_,
@@ skipping 42 matching lines @@
   memcpy(shared_memory_address_, kBadName2, kBadName2Size);
   cmd.Init(client_program_id_,
            kLocation,
            kSharedMemoryId,
            kSharedMemoryOffset,
            kBadName2Size);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_F(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) {
+TEST_P(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::CLEAR_UNIFORMS_BEFORE_FIRST_PROGRAM_USE));
   InitState init;
   init.gl_version = "3.0";
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   InitDecoderWithCommandLine(init, &command_line);
@@ skipping 42 matching lines @@
 }
 
 // TODO(gman): DeleteProgram
 
 // TODO(gman): UseProgram
 
 // TODO(gman): DeleteShader
 
 }  // namespace gles2
 }  // namespace gpu