Revert of Optimize GLES2DecoderImpl::ApplyDirtyState.

gpu/command_buffer/service/gles2_cmd_decoder_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/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 21 matching lines @@
 #if !defined(GL_DEPTH24_STENCIL8)
 #define GL_DEPTH24_STENCIL8 0x88F0
 #endif
 
 using ::gfx::MockGLInterface;
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::MatcherCast;
-using ::testing::Mock;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgumentPointee;
 using ::testing::SetArgPointee;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 
 namespace gpu {
 namespace gles2 {
 
 using namespace cmds;
 
 class GLES2DecoderTest : public GLES2DecoderTestBase {
  public:
   GLES2DecoderTest() { }
 
  protected:
   void CheckReadPixelsOutOfRange(
       GLint in_read_x, GLint in_read_y,
       GLsizei in_read_width, GLsizei in_read_height,
       bool init);
 };
 
-class GLES2DecoderTestWithExtensionsOnGLES2 : public GLES2DecoderTest {
+class GLES2DecoderTestWithExtensionsOnGLES2
+    : public GLES2DecoderTest,
+      public ::testing::WithParamInterface<const char*> {
  public:
   GLES2DecoderTestWithExtensionsOnGLES2() {}
 
-  virtual void SetUp() {}
-
-  void Init(const char* extensions) {
+  virtual void SetUp() {
     InitState init;
-    init.extensions = extensions;
+    init.extensions = GetParam();
     init.gl_version = "opengl es 2.0";
     init.has_alpha = true;
     init.has_depth = true;
     init.request_alpha = true;
     init.request_depth = true;
     InitDecoder(init);
   }
 };
 
 class GLES2DecoderWithShaderTest : public GLES2DecoderWithShaderTestBase {
@@ skipping 45 matching lines @@
   }
 };
 
 class GLES2DecoderManualInitTest : public GLES2DecoderWithShaderTest {
  public:
   GLES2DecoderManualInitTest() { }
 
   // Override default setup so nothing gets setup.
   virtual void SetUp() {
   }
-
-  void DirtyStateMaskTest(GLuint color_bits,
-                          bool depth_mask,
-                          GLuint front_stencil_mask,
-                          GLuint back_stencil_mask) {
-    ColorMask color_mask_cmd;
-    color_mask_cmd.Init((color_bits & 0x1000) != 0,
-                        (color_bits & 0x0100) != 0,
-                        (color_bits & 0x0010) != 0,
-                        (color_bits & 0x0001) != 0);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(color_mask_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-
-    DepthMask depth_mask_cmd;
-    depth_mask_cmd.Init(depth_mask);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(depth_mask_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-
-    StencilMaskSeparate front_stencil_mask_cmd;
-    front_stencil_mask_cmd.Init(GL_FRONT, front_stencil_mask);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(front_stencil_mask_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-
-    StencilMaskSeparate back_stencil_mask_cmd;
-    back_stencil_mask_cmd.Init(GL_BACK, back_stencil_mask);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(back_stencil_mask_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-
-    SetupExpectationsForApplyingDirtyState(
-        false,               // Framebuffer is RGB
-        true,                // Framebuffer has depth
-        true,                // Framebuffer has stencil
-        color_bits,          // color bits
-        depth_mask,          // depth mask
-        false,               // depth enabled
-        front_stencil_mask,  // front stencil mask
-        back_stencil_mask,   // back stencil mask
-        false);              // stencil enabled
-
-    EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
-        .Times(1)
-        .RetiresOnSaturation();
-    DrawArrays draw_cmd;
-    draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  }
-
-  void EnableDisableTest(GLenum cap, bool enable, bool expect_set) {
-    if (expect_set) {
-      SetupExpectationsForEnableDisable(cap, enable);
-    }
-    if (enable) {
-      Enable cmd;
-      cmd.Init(cap);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-      EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    } else {
-      Disable cmd;
-      cmd.Init(cap);
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-      EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    }
-  }
 };
 
 class GLES2DecoderCompressedFormatsTest : public GLES2DecoderManualInitTest {
  public:
   GLES2DecoderCompressedFormatsTest() { }
 
   static bool ValueInArray(GLint value, GLint* array, GLint count) {
     for (GLint ii = 0; ii < count; ++ii) {
       if (array[ii] == value) {
         return true;
@@ skipping 83 matching lines @@
     state->texture_units[tt].bound_texture_cube_map = ref_cube_map;
     TextureRef* ref_2d =
         (tt == non_default_unit)
             ? group().texture_manager()->GetTexture(client_texture_id_)
             : group().texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_2D);
     state->texture_units[tt].bound_texture_2d = ref_2d;
   }
   state->active_texture_unit = active_unit;
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysNoAttributesSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysNoAttributesSucceeds) {
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDefaultDirtyState();
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Tests when the math overflows (0x40000000 * sizeof GLfloat)
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OverflowFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OverflowFails) {
   const GLsizei kLargeCount = 0x40000000;
   SetupTexture();
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kLargeCount);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_FALSE(GetDecoder()->WasContextLost());
 }
 
 // Tests when the math overflows (0x7FFFFFFF + 1 = 0x8000000 verts)
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0PosToNegFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0PosToNegFails) {
   const GLsizei kLargeCount = 0x7FFFFFFF;
   SetupTexture();
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kLargeCount);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_FALSE(GetDecoder()->WasContextLost());
 }
 
 // Tests when the driver returns an error
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OOMFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OOMFails) {
   const GLsizei kFakeLargeCount = 0x1234;
   SetupTexture();
   AddExpectationsForSimulatedAttrib0WithError(
       kFakeLargeCount, 0, GL_OUT_OF_MEMORY);
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kFakeLargeCount);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_FALSE(GetDecoder()->WasContextLost());
 }
 
 // Test that we lose context.
-TEST_P(GLES2DecoderManualInitTest, LoseContextWhenOOM) {
+TEST_F(GLES2DecoderManualInitTest, LoseContextWhenOOM) {
   InitState init;
   init.gl_version = "3.0";
   init.has_alpha = true;
   init.has_depth = true;
   init.request_alpha = true;
   init.request_depth = true;
   init.bind_generates_resource = true;
   init.lose_context_when_out_of_memory = true;
   InitDecoder(init);
   SetupDefaultProgram();
 
   const GLsizei kFakeLargeCount = 0x1234;
   SetupTexture();
   AddExpectationsForSimulatedAttrib0WithError(
       kFakeLargeCount, 0, GL_OUT_OF_MEMORY);
   EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation();
   // Other contexts in the group should be lost also.
   EXPECT_CALL(*mock_decoder_, LoseContext(GL_UNKNOWN_CONTEXT_RESET_ARB))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kFakeLargeCount);
   // This context should be lost.
   EXPECT_EQ(error::kLostContext, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_TRUE(decoder_->WasContextLost());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysBadTextureUsesBlack) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysBadTextureUsesBlack) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   // This is an NPOT texture. As the default filtering requires mips
   // this should trigger replacing with black textures before rendering.
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                kSharedMemoryId, kSharedMemoryOffset);
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   {
     InSequence sequence;
     EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
         .Times(1)
@@ skipping 15 matching lines @@
         .Times(1)
         .RetiresOnSaturation();
   }
   SetupExpectationsForApplyingDefaultDirtyState();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysMissingAttributesFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysMissingAttributesFails) {
   DoEnableVertexAttribArray(1);
 
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0);
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        DrawArraysMissingAttributesZeroCountSucceeds) {
   DoEnableVertexAttribArray(1);
 
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0);
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, 0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysValidAttributesSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysValidAttributesSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
   DoEnableVertexAttribArray(1);
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
   AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId);
   SetupExpectationsForApplyingDefaultDirtyState();
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Same as DrawArraysValidAttributesSucceeds, but with workaround
 // |init_vertex_attributes|.
-TEST_P(GLES2DecoderManualInitTest, InitVertexAttributes) {
+TEST_F(GLES2DecoderManualInitTest, InitVertexAttributes) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::INIT_VERTEX_ATTRIBUTES));
   InitState init;
   init.gl_version = "3.0";
   init.has_alpha = true;
   init.has_depth = true;
   init.request_alpha = true;
   init.request_depth = true;
   init.bind_generates_resource = true;
   InitDecoderWithCommandLine(init, &command_line);
   SetupDefaultProgram();
   SetupTexture();
   SetupVertexBuffer();
   DoEnableVertexAttribArray(1);
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
   AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId);
   SetupExpectationsForApplyingDefaultDirtyState();
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysDeletedBufferFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysDeletedBufferFails) {
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
   DeleteVertexBuffer();
 
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0);
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysDeletedProgramSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysDeletedProgramSucceeds) {
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDefaultDirtyState();
   DoDeleteProgram(client_program_id_, kServiceProgramId);
 
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId))
       .Times(1);
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysWithInvalidModeFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysWithInvalidModeFails) {
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0);
   DrawArrays cmd;
   cmd.Init(GL_QUADS, 0, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
   cmd.Init(GL_POLYGON, 0, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysInvalidCountFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysInvalidCountFails) {
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   // Try start > 0
   EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0);
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 1, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ skipping 17 matching lines @@
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Try with stride > 8 (vec2 + vec2 byte)
   DoVertexAttribPointer(1, 2, GL_FLOAT, sizeof(GLfloat) * 3, 0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysInstancedANGLEFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysInstancedANGLEFails) {
   SetupTexture();
   SetupVertexBuffer();
   DoEnableVertexAttribArray(1);
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLENoAttributesFails) {
   SetupTexture();
 
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLESimulatedAttrib0) {
   SetupTexture();
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId);
   SetupExpectationsForApplyingDefaultDirtyState();
 
   DoVertexAttribDivisorANGLE(0, 1);
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices, 3))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 0))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 1))
       .Times(1)
       .RetiresOnSaturation();
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLEMissingAttributesFails) {
   DoEnableVertexAttribArray(1);
 
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
       .Times(0);
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLEMissingAttributesZeroCountSucceeds) {
   DoEnableVertexAttribArray(1);
 
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
       .Times(0);
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, 0, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLEValidAttributesSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
   DoEnableVertexAttribArray(1);
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
   AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId);
   SetupExpectationsForApplyingDefaultDirtyState();
 
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices, 1))
       .Times(1)
       .RetiresOnSaturation();
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLEWithInvalidModeFails) {
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
       .Times(0);
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_QUADS, 0, 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
   cmd.Init(GL_POLYGON, 0, 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLEInvalidPrimcountFails) {
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
       .Times(0);
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, 1, -1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 // Per-instance data is twice as large, but number of instances is half
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLELargeInstanceSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
   SetupExpectationsForApplyingDefaultDirtyState();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 1);
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices,
                                              kNumVertices / 2))
       .Times(1)
       .RetiresOnSaturation();
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices, kNumVertices / 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Per-instance data is twice as large, but divisor is twice
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLELargeDivisorSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
   SetupExpectationsForApplyingDefaultDirtyState();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 2);
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices,
                                              kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest, DrawArraysInstancedANGLELargeFails) {
+TEST_F(GLES2DecoderGeometryInstancingTest, DrawArraysInstancedANGLELargeFails) {
   SetupTexture();
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 1);
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices, kNumVertices + 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   cmd.Init(GL_TRIANGLES, 0, kNumVertices + 1, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Per-index data is twice as large, but number of indices is half
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLELargeIndexSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
   SetupExpectationsForApplyingDefaultDirtyState();
   DoVertexAttribPointer(1, 4, GL_FLOAT, 0, 0);
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 1);
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices / 2,
                                              kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices / 2, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLENoDivisor0Fails) {
   SetupTexture();
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 1);
   DoVertexAttribDivisorANGLE(1, 1);
   EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArraysInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsNoAttributesSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsNoAttributesSucceeds) {
   SetupTexture();
   SetupIndexBuffer();
   AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, 0);
   SetupExpectationsForApplyingDefaultDirtyState();
   EXPECT_CALL(*gl_, DrawElements(GL_TRIANGLES, kValidIndexRangeCount,
                                  GL_UNSIGNED_SHORT,
                                  BufferOffset(kValidIndexRangeStart * 2)))
       .Times(1)
       .RetiresOnSaturation();
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsMissingAttributesFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsMissingAttributesFails) {
   SetupIndexBuffer();
   DoEnableVertexAttribArray(1);
 
   EXPECT_CALL(*gl_, DrawElements(_, _, _, _))
       .Times(0);
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        DrawElementsMissingAttributesZeroCountSucceeds) {
   SetupIndexBuffer();
   DoEnableVertexAttribArray(1);
 
   EXPECT_CALL(*gl_, DrawElements(_, _, _, _))
       .Times(0);
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, 0, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsExtraAttributesFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsExtraAttributesFails) {
   SetupIndexBuffer();
   DoEnableVertexAttribArray(6);
 
   EXPECT_CALL(*gl_, DrawElements(_, _, _, _))
       .Times(0);
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsValidAttributesSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsValidAttributesSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
   AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, kServiceBufferId);
   SetupExpectationsForApplyingDefaultDirtyState();
 
   EXPECT_CALL(*gl_, DrawElements(GL_TRIANGLES, kValidIndexRangeCount,
                                  GL_UNSIGNED_SHORT,
                                  BufferOffset(kValidIndexRangeStart * 2)))
       .Times(1)
       .RetiresOnSaturation();
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsDeletedBufferFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsDeletedBufferFails) {
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
   DeleteIndexBuffer();
 
   EXPECT_CALL(*gl_, DrawElements(_, _, _, _))
       .Times(0);
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsDeletedProgramSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsDeletedProgramSucceeds) {
   SetupTexture();
   SetupIndexBuffer();
   AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, 0);
   SetupExpectationsForApplyingDefaultDirtyState();
   DoDeleteProgram(client_program_id_, kServiceProgramId);
 
   EXPECT_CALL(*gl_, DrawElements(_, _, _, _))
       .Times(1);
   EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId))
       .Times(1);
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsWithInvalidModeFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsWithInvalidModeFails) {
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   EXPECT_CALL(*gl_, DrawElements(_, _, _, _))
       .Times(0);
   DrawElements cmd;
   cmd.Init(GL_QUADS, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
   cmd.Init(GL_POLYGON, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsInvalidCountFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsInvalidCountFails) {
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   // Try start > 0
   EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kNumIndices, GL_UNSIGNED_SHORT, 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Try with count > size
   cmd.Init(GL_TRIANGLES, kNumIndices + 1, GL_UNSIGNED_SHORT, 0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsOutOfRangeIndicesFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsOutOfRangeIndicesFails) {
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kInvalidIndexRangeCount, GL_UNSIGNED_SHORT,
            kInvalidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsOddOffsetForUint16Fails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsOddOffsetForUint16Fails) {
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kInvalidIndexRangeCount, GL_UNSIGNED_SHORT, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsInstancedANGLEFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsInstancedANGLEFails) {
   SetupTexture();
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoEnableVertexAttribArray(1);
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLENoAttributesFails) {
   SetupTexture();
   SetupIndexBuffer();
 
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLESimulatedAttrib0) {
   SetupTexture();
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, kServiceBufferId);
   SetupExpectationsForApplyingDefaultDirtyState();
 
   DoVertexAttribDivisorANGLE(0, 1);
@@ skipping 11 matching lines @@
   EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 1))
       .Times(1)
       .RetiresOnSaturation();
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLEMissingAttributesFails) {
   SetupIndexBuffer();
   DoEnableVertexAttribArray(1);
 
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
       .Times(0);
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLEMissingAttributesZeroCountSucceeds) {
   SetupIndexBuffer();
   DoEnableVertexAttribArray(1);
 
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
       .Times(0);
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, 0, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLEValidAttributesSucceeds) {
   SetupIndexBuffer();
   SetupTexture();
   SetupVertexBuffer();
   DoEnableVertexAttribArray(1);
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
   AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, kServiceBufferId);
   SetupExpectationsForApplyingDefaultDirtyState();
 
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(
                         GL_TRIANGLES,
                         kValidIndexRangeCount,
                         GL_UNSIGNED_SHORT,
                         BufferOffset(kValidIndexRangeStart * 2),
                         1))
       .Times(1)
       .RetiresOnSaturation();
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLEWithInvalidModeFails) {
   SetupIndexBuffer();
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
       .Times(0);
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_QUADS, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
   cmd.Init(GL_INVALID_ENUM, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 // Per-instance data is twice as large, but number of instances is half
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLELargeInstanceSucceeds) {
   SetupTexture();
   SetupIndexBuffer();
   SetupVertexBuffer();
   SetupExpectationsForApplyingDefaultDirtyState();
   //Add offset so we're sure we're accessing data near the end of the buffer.
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0,
                         (kNumVertices - kMaxValidIndex - 1) * 2 *
                             sizeof(GLfloat));
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 1);
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(
                         GL_TRIANGLES,
                         kValidIndexRangeCount,
                         GL_UNSIGNED_SHORT,
                         BufferOffset(kValidIndexRangeStart * 2),
                         kNumVertices / 2))
       .Times(1)
       .RetiresOnSaturation();
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, kNumVertices / 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Per-instance data is twice as large, but divisor is twice
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLELargeDivisorSucceeds) {
   SetupTexture();
   SetupIndexBuffer();
   SetupVertexBuffer();
   SetupExpectationsForApplyingDefaultDirtyState();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 2);
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(
                         GL_TRIANGLES,
                         kValidIndexRangeCount,
                         GL_UNSIGNED_SHORT,
                         BufferOffset(kValidIndexRangeStart * 2),
                         kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLELargeFails) {
   SetupTexture();
   SetupIndexBuffer();
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 1);
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, kNumVertices + 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   cmd.Init(GL_TRIANGLES, kInvalidIndexRangeCount, GL_UNSIGNED_SHORT,
            kInvalidIndexRangeStart * 2, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLEInvalidPrimcountFails) {
   SetupTexture();
   SetupIndexBuffer();
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 1);
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, -1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Per-index data is twice as large, but values of indices are smaller
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLELargeIndexSucceeds) {
   SetupTexture();
   SetupIndexBuffer();
   SetupVertexBuffer();
   SetupExpectationsForApplyingDefaultDirtyState();
   DoVertexAttribPointer(1, 4, GL_FLOAT, 0, 0);
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 1);
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(
                         GL_TRIANGLES,
                         kValidIndexRangeCount,
                         GL_UNSIGNED_SHORT,
                         BufferOffset(kValidIndexRangeStart * 2),
                         kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLENoDivisor0Fails) {
   SetupTexture();
   SetupIndexBuffer();
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
   DoVertexAttribDivisorANGLE(0, 1);
   DoVertexAttribDivisorANGLE(1, 1);
   EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawElementsInstancedANGLE cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetVertexAttribPointervSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, GetVertexAttribPointervSucceeds) {
   const float dummy = 0;
   const GLuint kOffsetToTestFor = sizeof(dummy) * 4;
   const GLuint kIndexToTest = 1;
   GetVertexAttribPointerv::Result* result =
       static_cast<GetVertexAttribPointerv::Result*>(shared_memory_address_);
   result->size = 0;
   const GLuint* result_value = result->GetData();
   // Test that initial value is 0.
   GetVertexAttribPointerv cmd;
   cmd.Init(kIndexToTest, GL_VERTEX_ATTRIB_ARRAY_POINTER,
            shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(sizeof(*result_value), result->size);
   EXPECT_EQ(0u, *result_value);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Set the value and see that we get it.
   SetupVertexBuffer();
   DoVertexAttribPointer(kIndexToTest, 2, GL_FLOAT, 0, kOffsetToTestFor);
   result->size = 0;
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(sizeof(*result_value), result->size);
   EXPECT_EQ(kOffsetToTestFor, *result_value);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetVertexAttribPointervBadArgsFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetVertexAttribPointervBadArgsFails) {
   const GLuint kIndexToTest = 1;
   GetVertexAttribPointerv::Result* result =
       static_cast<GetVertexAttribPointerv::Result*>(shared_memory_address_);
   result->size = 0;
   const GLuint* result_value = result->GetData();
   // Test pname invalid fails.
   GetVertexAttribPointerv cmd;
   cmd.Init(kIndexToTest, GL_VERTEX_ATTRIB_ARRAY_POINTER + 1,
            shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ skipping 14 matching lines @@
   cmd.Init(kIndexToTest, GL_VERTEX_ATTRIB_ARRAY_POINTER,
            kInvalidSharedMemoryId, shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 
   // Test memory offset bad fails.
   cmd.Init(kIndexToTest, GL_VERTEX_ATTRIB_ARRAY_POINTER,
            shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetUniformivSucceeds) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetUniformivBadProgramFails) {
+TEST_F(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 21 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   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_P(GLES2DecoderWithShaderTest, GetUniformivBadLocationFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetUniformivBadSharedMemoryFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetUniformfvSucceeds) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetUniformfvBadProgramFails) {
+TEST_F(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 21 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   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_P(GLES2DecoderWithShaderTest, GetUniformfvBadLocationFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetUniformfvBadSharedMemoryFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetAttachedShadersSucceeds) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetAttachedShadersResultNotInitFail) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetAttachedShadersBadProgramFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetAttachedShadersBadSharedMemoryFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatSucceeds) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatResultNotInitFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatBadArgsFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest,
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetActiveUniformBadIndexFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetActiveAttribBadIndexFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
+TEST_F(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_P(GLES2DecoderTest, GetIntegervCached) {
+TEST_F(GLES2DecoderTest, GetIntegervCached) {
   struct TestInfo {
     GLenum pname;
     GLint expected;
   };
   TestInfo tests[] = {
     { GL_MAX_TEXTURE_SIZE, TestHelper::kMaxTextureSize, },
     { GL_MAX_CUBE_MAP_TEXTURE_SIZE, TestHelper::kMaxCubeMapTextureSize, },
     { GL_MAX_RENDERBUFFER_SIZE, TestHelper::kMaxRenderbufferSize, },
   };
   typedef GetIntegerv::Result Result;
@@ skipping 11 matching lines @@
     cmd2.Init(test.pname, shared_memory_id_, shared_memory_offset_);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
     EXPECT_EQ(
         decoder_->GetGLES2Util()->GLGetNumValuesReturned(test.pname),
         result->GetNumResults());
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
     EXPECT_EQ(test.expected, result->GetData()[0]);
   }
 }
 
-TEST_P(GLES2DecoderTest, CompileShaderValidArgs) {
+TEST_F(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_P(GLES2DecoderTest, CompileShaderInvalidArgs) {
+TEST_F(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_P(GLES2DecoderTest, ShaderSourceAndGetShaderSourceValidArgs) {
+TEST_F(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_P(GLES2DecoderTest, ShaderSourceInvalidArgs) {
+TEST_F(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);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
   cmd.Init(client_shader_id_,
            kInvalidSharedMemoryId, kSharedMemoryOffset, kSourceSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_shader_id_,
            kSharedMemoryId, kInvalidSharedMemoryOffset, kSourceSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_shader_id_,
            kSharedMemoryId, kSharedMemoryOffset, kSharedBufferSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, ShaderSourceBucketAndGetShaderSourceValidArgs) {
+TEST_F(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_P(GLES2DecoderTest, ShaderSourceBucketInvalidArgs) {
+TEST_F(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_P(GLES2DecoderTest, ShaderSourceStripComments) {
+TEST_F(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_P(GLES2DecoderTest, GenerateMipmapWrongFormatsFails) {
+TEST_F(GLES2DecoderTest, GenerateMipmapWrongFormatsFails) {
   EXPECT_CALL(*gl_, GenerateMipmapEXT(_))
        .Times(0);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       0, 0);
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_2D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, GenerateMipmapHandlesOutOfMemory) {
+TEST_F(GLES2DecoderTest, GenerateMipmapHandlesOutOfMemory) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   GLint width = 0;
   GLint height = 0;
   EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 2, &width, &height));
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_CALL(*gl_, GenerateMipmapEXT(GL_TEXTURE_2D))
       .Times(1);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_2D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 2, &width, &height));
 }
 
-TEST_P(GLES2DecoderTest, GenerateMipmapClearsUnclearedTexture) {
+TEST_F(GLES2DecoderTest, GenerateMipmapClearsUnclearedTexture) {
   EXPECT_CALL(*gl_, GenerateMipmapEXT(_))
        .Times(0);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   SetupClearTextureExpectations(
       kServiceTextureId, kServiceTextureId, GL_TEXTURE_2D, GL_TEXTURE_2D,
       0, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, 2, 2);
   EXPECT_CALL(*gl_, GenerateMipmapEXT(GL_TEXTURE_2D));
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_2D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Same as GenerateMipmapClearsUnclearedTexture, but with workaround
 // |set_texture_filters_before_generating_mipmap|.
-TEST_P(GLES2DecoderManualInitTest, SetTextureFiltersBeforeGenerateMipmap) {
+TEST_F(GLES2DecoderManualInitTest, SetTextureFiltersBeforeGenerateMipmap) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::SET_TEXTURE_FILTER_BEFORE_GENERATING_MIPMAP));
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoderWithCommandLine(init, &command_line);
 
   EXPECT_CALL(*gl_, GenerateMipmapEXT(_))
@@ skipping 16 matching lines @@
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_2D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, Uniform1iValidArgs) {
+TEST_F(GLES2DecoderWithShaderTest, Uniform1iValidArgs) {
   EXPECT_CALL(*gl_, Uniform1i(kUniform1RealLocation, 2));
   Uniform1i cmd;
   cmd.Init(kUniform1FakeLocation, 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, Uniform1ivValidArgs) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_0) {
+TEST_F(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
   Uniform1iv cmd;
   cmd.Init(kUniform1FakeLocation,
            1, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_1) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidValidArgs) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, Uniform1ivZeroCount) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, Uniform1iSamplerIsLmited) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, Uniform1ivSamplerIsLimited) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, BindBufferToDifferentTargetFails) {
+TEST_F(GLES2DecoderWithShaderTest, BindBufferToDifferentTargetFails) {
   // Bind the buffer to GL_ARRAY_BUFFER
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
   // Attempt to rebind to GL_ELEMENT_ARRAY_BUFFER
   // NOTE: Real GLES2 does not have this restriction but WebGL and we do.
   // This can be restriction can be removed at runtime.
   EXPECT_CALL(*gl_, BindBuffer(_, _))
       .Times(0);
   BindBuffer cmd;
   cmd.Init(GL_ELEMENT_ARRAY_BUFFER, client_buffer_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, ActiveTextureValidArgs) {
+TEST_F(GLES2DecoderTest, ActiveTextureValidArgs) {
   EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE1));
   SpecializedSetup<ActiveTexture, 0>(true);
   ActiveTexture cmd;
   cmd.Init(GL_TEXTURE1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, ActiveTextureInvalidArgs) {
+TEST_F(GLES2DecoderTest, ActiveTextureInvalidArgs) {
   EXPECT_CALL(*gl_, ActiveTexture(_)).Times(0);
   SpecializedSetup<ActiveTexture, 0>(false);
   ActiveTexture cmd;
   cmd.Init(GL_TEXTURE0 - 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
   cmd.Init(kNumTextureUnits);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, CheckFramebufferStatusWithNoBoundTarget) {
+TEST_F(GLES2DecoderTest, CheckFramebufferStatusWithNoBoundTarget) {
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(_))
       .Times(0);
   CheckFramebufferStatus::Result* result =
       static_cast<CheckFramebufferStatus::Result*>(shared_memory_address_);
   *result = 0;
   CheckFramebufferStatus cmd;
   cmd.Init(GL_FRAMEBUFFER, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE), *result);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, BindAndDeleteFramebuffer) {
+TEST_F(GLES2DecoderWithShaderTest, BindAndDeleteFramebuffer) {
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDefaultDirtyState();
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   DoDeleteFramebuffer(
       client_framebuffer_id_, kServiceFramebufferId,
       true, GL_FRAMEBUFFER, 0,
       true, GL_FRAMEBUFFER, 0);
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, FramebufferRenderbufferWithNoBoundTarget) {
+TEST_F(GLES2DecoderTest, FramebufferRenderbufferWithNoBoundTarget) {
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(_, _, _, _))
       .Times(0);
   FramebufferRenderbuffer cmd;
   cmd.Init(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
       client_renderbuffer_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, FramebufferTexture2DWithNoBoundTarget) {
+TEST_F(GLES2DecoderTest, FramebufferTexture2DWithNoBoundTarget) {
   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _))
       .Times(0);
   FramebufferTexture2D cmd;
   cmd.Init(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, client_texture_id_,
       0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithNoBoundTarget) {
+TEST_F(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithNoBoundTarget) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(_, _, _, _))
       .Times(0);
   GetFramebufferAttachmentParameteriv cmd;
   cmd.Init(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
       GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithRenderbuffer) {
+TEST_F(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithRenderbuffer) {
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
       kServiceRenderbufferId))
       .Times(1)
       .RetiresOnSaturation();
@@ skipping 17 matching lines @@
   cmd.Init(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
       GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(fbrb_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(static_cast<GLuint>(*result_value), client_renderbuffer_id_);
 }
 
-TEST_P(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithTexture) {
+TEST_F(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithTexture) {
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
       kServiceTextureId, 0))
       .Times(1)
       .RetiresOnSaturation();
@@ skipping 17 matching lines @@
   cmd.Init(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
       GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(fbtex_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(static_cast<GLuint>(*result_value), client_texture_id_);
 }
 
-TEST_P(GLES2DecoderTest, GetRenderbufferParameterivWithNoBoundTarget) {
+TEST_F(GLES2DecoderTest, GetRenderbufferParameterivWithNoBoundTarget) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetRenderbufferParameterivEXT(_, _, _))
       .Times(0);
   GetRenderbufferParameteriv cmd;
   cmd.Init(
       GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, shared_memory_id_,
       shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, RenderbufferStorageWithNoBoundTarget) {
+TEST_F(GLES2DecoderTest, RenderbufferStorageWithNoBoundTarget) {
   EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _))
       .Times(0);
   RenderbufferStorage cmd;
   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 3, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 namespace {
 
@@ skipping 179 matching lines @@
     // check padding
     if (yy != in_read_height - 1) {
       GLint num_padding_bytes =
           (kPackAlignment - 1) - (unpadded_row_size % kPackAlignment);
       EXPECT_EQ(0,
                 memcmp(pack.get(), row + unpadded_row_size, num_padding_bytes));
     }
   }
 }
 
-TEST_P(GLES2DecoderTest, ReadPixels) {
+TEST_F(GLES2DecoderTest, ReadPixels) {
   const GLsizei kWidth = 5;
   const GLsizei kHeight = 3;
   const GLint kBytesPerPixel = 3;
   const GLint kPackAlignment = 4;
   static const int8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
     12, 13, 14, 18, 19, 18, 19, 12, 13, 14, 18, 19, 18, 19, 13,
     29, 28, 23, 22, 21, 22, 21, 29, 28, 23, 22, 21, 22, 21, 28,
     31, 34, 39, 37, 32, 37, 32, 31, 34, 39, 37, 32, 37, 32, 34,
   };
 
@@ skipping 21 matching lines @@
            result_shm_id, result_shm_offset,
            false);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   for (GLint yy = 0; yy < kHeight; ++yy) {
     EXPECT_TRUE(emu.CompareRowSegment(
         0, yy, kWidth,
         emu.ComputePackAlignmentAddress(0, yy, kWidth, dest)));
   }
 }
 
-TEST_P(GLES2DecoderRGBBackbufferTest, ReadPixelsNoAlphaBackbuffer) {
+TEST_F(GLES2DecoderRGBBackbufferTest, ReadPixelsNoAlphaBackbuffer) {
   const GLsizei kWidth = 3;
   const GLsizei kHeight = 3;
   const GLint kBytesPerPixel = 4;
   const GLint kPackAlignment = 4;
   static const uint8 kExpectedPixels[kWidth * kHeight * kBytesPerPixel] = {
     12, 13, 14, 255, 19, 18, 19, 255, 13, 14, 18, 255,
     29, 28, 23, 255, 21, 22, 21, 255, 28, 23, 22, 255,
     31, 34, 39, 255, 32, 37, 32, 255, 34, 39, 37, 255,
   };
   static const uint8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
@@ skipping 27 matching lines @@
            result_shm_id, result_shm_offset,
            false);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   for (GLint yy = 0; yy < kHeight; ++yy) {
     EXPECT_TRUE(emu.CompareRowSegment(
         0, yy, kWidth,
         emu.ComputePackAlignmentAddress(0, yy, kWidth, dest)));
   }
 }
 
-TEST_P(GLES2DecoderTest, ReadPixelsOutOfRange) {
+TEST_F(GLES2DecoderTest, ReadPixelsOutOfRange) {
   static GLint tests[][4] = {
     { -2, -1, 9, 5, },  // out of range on all sides
     { 2, 1, 9, 5, },  // out of range on right, bottom
     { -7, -4, 9, 5, },  // out of range on left, top
     { 0, -5, 9, 5, },  // completely off top
     { 0, 3, 9, 5, },  // completely off bottom
     { -9, 0, 9, 5, },  // completely off left
     { 5, 0, 9, 5, },  // completely off right
   };
 
   for (size_t tt = 0; tt < arraysize(tests); ++tt) {
     CheckReadPixelsOutOfRange(
         tests[tt][0], tests[tt][1], tests[tt][2], tests[tt][3], tt == 0);
   }
 }
 
-TEST_P(GLES2DecoderTest, ReadPixelsInvalidArgs) {
+TEST_F(GLES2DecoderTest, ReadPixelsInvalidArgs) {
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   uint32 result_shm_id = kSharedMemoryId;
   uint32 result_shm_offset = kSharedMemoryOffset;
   uint32 pixels_shm_id = kSharedMemoryId;
   uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
   EXPECT_CALL(*gl_, ReadPixels(_, _, _, _, _, _, _)).Times(0);
   ReadPixels cmd;
   cmd.Init(0, 0, -1, 1, GL_RGB, GL_UNSIGNED_BYTE,
            pixels_shm_id, pixels_shm_offset,
@@ skipping 28 matching lines @@
            kInvalidSharedMemoryId, result_shm_offset,
            false);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_BYTE,
            pixels_shm_id, pixels_shm_offset,
            result_shm_id, kInvalidSharedMemoryOffset,
            false);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderManualInitTest, ReadPixelsAsyncError) {
+TEST_F(GLES2DecoderManualInitTest, ReadPixelsAsyncError) {
   InitState init;
   init.extensions = "GL_ARB_sync";
   init.gl_version = "opengl es 3.0";
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
@@ skipping 22 matching lines @@
     GL_STREAM_READ)).Times(1);
 
   ReadPixels cmd;
   cmd.Init(0, 0, kWidth, kHeight, GL_RGB, GL_UNSIGNED_BYTE,
            pixels_shm_id, pixels_shm_offset,
            result_shm_id, result_shm_offset,
            true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, BindAttribLocation) {
+TEST_F(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_P(GLES2DecoderTest, BindAttribLocationInvalidArgs) {
+TEST_F(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,
            kSharedMemoryId, kSharedMemoryOffset, kNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   cmd.Init(client_program_id_, kLocation,
            kInvalidSharedMemoryId, kSharedMemoryOffset, kNameSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_, kLocation,
            kSharedMemoryId, kInvalidSharedMemoryOffset, kNameSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_program_id_, kLocation,
            kSharedMemoryId, kSharedMemoryOffset, kSharedBufferSize);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   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_P(GLES2DecoderTest, BindAttribLocationBucket) {
+TEST_F(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_P(GLES2DecoderTest, BindAttribLocationBucketInvalidArgs) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetAttribLocation) {
+TEST_F(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;
   cmd.Init(client_program_id_,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
            kNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(kAttrib2Location, *result);
   *result = -1;
   memcpy(name, kNonExistentName, kNonExistentNameSize);
   cmd.Init(client_program_id_,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
            kNonExistentNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) {
+TEST_F(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 37 matching lines @@
   EXPECT_EQ(-1, *result);
   memcpy(name, kBadName, kBadNameSize);
   cmd.Init(client_program_id_,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
            kBadNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationBucket) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetAttribLocationBucketInvalidArgs) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetUniformLocation) {
+TEST_F(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;
   cmd.Init(client_program_id_,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
            kNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(kUniform2FakeLocation, *result);
   memcpy(name, kNonExistentName, kNonExistentNameSize);
   *result = -1;
   cmd.Init(client_program_id_,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
            kNonExistentNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(-1, *result);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationInvalidArgs) {
+TEST_F(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 37 matching lines @@
   EXPECT_EQ(-1, *result);
   memcpy(name, kBadName, kBadNameSize);
   cmd.Init(client_program_id_,
            kSharedMemoryId, kNameOffset,
            kSharedMemoryId, kSharedMemoryOffset,
            kBadNameSize);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationBucket) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetUniformLocationBucketInvalidArgs) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetMaxValueInBufferCHROMIUM) {
+TEST_F(GLES2DecoderWithShaderTest, GetMaxValueInBufferCHROMIUM) {
   SetupIndexBuffer();
   GetMaxValueInBufferCHROMIUM::Result* result =
       static_cast<GetMaxValueInBufferCHROMIUM::Result*>(shared_memory_address_);
   *result = 0;
 
   GetMaxValueInBufferCHROMIUM cmd;
   cmd.Init(client_element_buffer_id_, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(7u, *result);
@@ skipping 34 matching lines @@
            kValidIndexRangeStart * 2,
            kInvalidSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(client_element_buffer_id_, kValidIndexRangeCount + 1,
            GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2,
            kSharedMemoryId, kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, SharedIds) {
+TEST_F(GLES2DecoderTest, SharedIds) {
   GenSharedIdsCHROMIUM gen_cmd;
   RegisterSharedIdsCHROMIUM reg_cmd;
   DeleteSharedIdsCHROMIUM del_cmd;
 
   const GLuint kNamespaceId = id_namespaces::kTextures;
   const GLuint kExpectedId1 = 1;
   const GLuint kExpectedId2 = 2;
   const GLuint kExpectedId3 = 4;
   const GLuint kRegisterId = 3;
   GLuint* ids = GetSharedMemoryAs<GLuint*>();
@@ skipping 50 matching lines @@
 
   // Check passing in an id_offset.
   ClearSharedMemory();
   const GLuint kOffset = 0xABCDEF;
   gen_cmd.Init(kNamespaceId, kOffset, 2, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(gen_cmd));
   EXPECT_EQ(kOffset, ids[0]);
   EXPECT_EQ(kOffset + 1, ids[1]);
 }
 
-TEST_P(GLES2DecoderTest, GenSharedIdsCHROMIUMBadArgs) {
+TEST_F(GLES2DecoderTest, GenSharedIdsCHROMIUMBadArgs) {
   const GLuint kNamespaceId = id_namespaces::kTextures;
   GenSharedIdsCHROMIUM cmd;
   cmd.Init(kNamespaceId, 0, -1, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(kNamespaceId, 0, 1, kInvalidSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(kNamespaceId, 0, 1, kSharedMemoryId, kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, RegisterSharedIdsCHROMIUMBadArgs) {
+TEST_F(GLES2DecoderTest, RegisterSharedIdsCHROMIUMBadArgs) {
   const GLuint kNamespaceId = id_namespaces::kTextures;
   RegisterSharedIdsCHROMIUM cmd;
   cmd.Init(kNamespaceId, -1, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(kNamespaceId, 1, kInvalidSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(kNamespaceId, 1, kSharedMemoryId, kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, RegisterSharedIdsCHROMIUMDuplicateIds) {
+TEST_F(GLES2DecoderTest, RegisterSharedIdsCHROMIUMDuplicateIds) {
   const GLuint kNamespaceId = id_namespaces::kTextures;
   const GLuint kRegisterId = 3;
   RegisterSharedIdsCHROMIUM cmd;
   GLuint* ids = GetSharedMemoryAs<GLuint*>();
   ids[0] = kRegisterId;
   cmd.Init(kNamespaceId, 1, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(kNamespaceId, 1, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, DeleteSharedIdsCHROMIUMBadArgs) {
+TEST_F(GLES2DecoderTest, DeleteSharedIdsCHROMIUMBadArgs) {
   const GLuint kNamespaceId = id_namespaces::kTextures;
   DeleteSharedIdsCHROMIUM cmd;
   cmd.Init(kNamespaceId, -1, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(kNamespaceId, 1, kInvalidSharedMemoryId, kSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(kNamespaceId, 1, kSharedMemoryId, kInvalidSharedMemoryOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, TexSubImage2DValidArgs) {
+TEST_F(GLES2DecoderTest, TexSubImage2DValidArgs) {
   const int kWidth = 16;
   const int kHeight = 8;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 1, GL_RGBA, kWidth, kHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_CALL(*gl_, TexSubImage2D(
       GL_TEXTURE_2D, 1, 1, 0, kWidth - 1, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   TexSubImage2D cmd;
   cmd.Init(
       GL_TEXTURE_2D, 1, 1, 0, kWidth - 1, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
       kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, TexSubImage2DBadArgs) {
+TEST_F(GLES2DecoderTest, TexSubImage2DBadArgs) {
   const int kWidth = 16;
   const int kHeight = 8;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 1, GL_RGBA, kWidth, kHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       0, 0);
   TexSubImage2D cmd;
   cmd.Init(GL_TEXTURE0, 1, 0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
            kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ skipping 40 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   cmd.Init(GL_TEXTURE_2D, 1, 0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
            kInvalidSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(GL_TEXTURE_2D, 1, 0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,
            kSharedMemoryId, kInvalidSharedMemoryOffset, GL_FALSE);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, CopyTexSubImage2DValidArgs) {
+TEST_F(GLES2DecoderTest, CopyTexSubImage2DValidArgs) {
   const int kWidth = 16;
   const int kHeight = 8;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 1, GL_RGBA, kWidth, kHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_CALL(*gl_, CopyTexSubImage2D(
       GL_TEXTURE_2D, 1, 0, 0, 0, 0, kWidth, kHeight))
       .Times(1)
       .RetiresOnSaturation();
   CopyTexSubImage2D cmd;
   cmd.Init(GL_TEXTURE_2D, 1, 0, 0, 0, 0, kWidth, kHeight);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, CopyTexSubImage2DBadArgs) {
+TEST_F(GLES2DecoderTest, CopyTexSubImage2DBadArgs) {
   const int kWidth = 16;
   const int kHeight = 8;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 1, GL_RGBA, kWidth, kHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       0, 0);
   CopyTexSubImage2D cmd;
   cmd.Init(GL_TEXTURE0, 1, 0, 0, 0, 0, kWidth, kHeight);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
@@ skipping 12 matching lines @@
   cmd.Init(GL_TEXTURE_2D, 1, 0, 0, 0, 0, kWidth + 1, kHeight);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   cmd.Init(GL_TEXTURE_2D, 1, 0, 0, 0, 0, kWidth, kHeight + 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 // Check that if a renderbuffer is attached and GL returns
 // GL_FRAMEBUFFER_COMPLETE that the buffer is cleared and state is restored.
-TEST_P(GLES2DecoderManualInitTest, FramebufferRenderbufferClearColor) {
-  InitState init;
-  init.gl_version = "opengl es 2.0";
-  init.has_alpha = true;
-  init.has_depth = true;
-  init.request_alpha = true;
-  init.request_depth = true;
-  InitDecoder(init);
-
+TEST_F(GLES2DecoderTest, FramebufferRenderbufferClearColor) {
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   ClearColor color_cmd;
   ColorMask color_mask_cmd;
   Enable enable_cmd;
   FramebufferRenderbuffer cmd;
   color_cmd.Init(0.1f, 0.2f, 0.3f, 0.4f);
   color_mask_cmd.Init(0, 1, 0, 1);
   enable_cmd.Init(GL_SCISSOR_TEST);
   cmd.Init(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
       client_renderbuffer_id_);
   InSequence sequence;
   EXPECT_CALL(*gl_, ClearColor(0.1f, 0.2f, 0.3f, 0.4f))
       .Times(1)
       .RetiresOnSaturation();
-  SetupExpectationsForEnableDisable(GL_SCISSOR_TEST, true);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
       kServiceRenderbufferId))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(color_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(color_mask_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(enable_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearDepth) {
+TEST_F(GLES2DecoderTest, FramebufferRenderbufferClearDepth) {
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   ClearDepthf depth_cmd;
   DepthMask depth_mask_cmd;
   FramebufferRenderbuffer cmd;
   depth_cmd.Init(0.5f);
   depth_mask_cmd.Init(false);
   cmd.Init(
       GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER,
       client_renderbuffer_id_);
@@ skipping 10 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(depth_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(depth_mask_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearStencil) {
+TEST_F(GLES2DecoderTest, FramebufferRenderbufferClearStencil) {
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   ClearStencil stencil_cmd;
   StencilMaskSeparate stencil_mask_separate_cmd;
   FramebufferRenderbuffer cmd;
   stencil_cmd.Init(123);
   stencil_mask_separate_cmd.Init(GL_BACK, 0x1234u);
   cmd.Init(
       GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
       client_renderbuffer_id_);
@@ skipping 10 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(stencil_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(stencil_mask_separate_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, IsBuffer) {
+TEST_F(GLES2DecoderTest, IsBuffer) {
   EXPECT_FALSE(DoIsBuffer(client_buffer_id_));
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
   EXPECT_TRUE(DoIsBuffer(client_buffer_id_));
   DoDeleteBuffer(client_buffer_id_, kServiceBufferId);
   EXPECT_FALSE(DoIsBuffer(client_buffer_id_));
 }
 
-TEST_P(GLES2DecoderTest, IsFramebuffer) {
+TEST_F(GLES2DecoderTest, IsFramebuffer) {
   EXPECT_FALSE(DoIsFramebuffer(client_framebuffer_id_));
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   EXPECT_TRUE(DoIsFramebuffer(client_framebuffer_id_));
   DoDeleteFramebuffer(
       client_framebuffer_id_, kServiceFramebufferId,
       true, GL_FRAMEBUFFER, 0,
       true, GL_FRAMEBUFFER, 0);
   EXPECT_FALSE(DoIsFramebuffer(client_framebuffer_id_));
 }
 
-TEST_P(GLES2DecoderTest, IsProgram) {
+TEST_F(GLES2DecoderTest, IsProgram) {
   // IsProgram is true as soon as the program is created.
   EXPECT_TRUE(DoIsProgram(client_program_id_));
   EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId))
       .Times(1)
       .RetiresOnSaturation();
   DoDeleteProgram(client_program_id_, kServiceProgramId);
   EXPECT_FALSE(DoIsProgram(client_program_id_));
 
 }
 
-TEST_P(GLES2DecoderTest, IsRenderbuffer) {
+TEST_F(GLES2DecoderTest, IsRenderbuffer) {
   EXPECT_FALSE(DoIsRenderbuffer(client_renderbuffer_id_));
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   EXPECT_TRUE(DoIsRenderbuffer(client_renderbuffer_id_));
   DoDeleteRenderbuffer(client_renderbuffer_id_, kServiceRenderbufferId);
   EXPECT_FALSE(DoIsRenderbuffer(client_renderbuffer_id_));
 }
 
-TEST_P(GLES2DecoderTest, IsShader) {
+TEST_F(GLES2DecoderTest, IsShader) {
   // IsShader is true as soon as the program is created.
   EXPECT_TRUE(DoIsShader(client_shader_id_));
   DoDeleteShader(client_shader_id_, kServiceShaderId);
   EXPECT_FALSE(DoIsShader(client_shader_id_));
 }
 
-TEST_P(GLES2DecoderTest, IsTexture) {
+TEST_F(GLES2DecoderTest, IsTexture) {
   EXPECT_FALSE(DoIsTexture(client_texture_id_));
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   EXPECT_TRUE(DoIsTexture(client_texture_id_));
   DoDeleteTexture(client_texture_id_, kServiceTextureId);
   EXPECT_FALSE(DoIsTexture(client_texture_id_));
 }
 
 #if 0  // Turn this test on once we allow GL_DEPTH_STENCIL_ATTACHMENT
-TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearDepthStencil) {
+TEST_F(GLES2DecoderTest, FramebufferRenderbufferClearDepthStencil) {
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   ClearDepthf depth_cmd;
   ClearStencil stencil_cmd;
   FramebufferRenderbuffer cmd;
   depth_cmd.Init(0.5f);
   stencil_cmd.Init(123);
   cmd.Init(
       GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
       client_renderbuffer_id_);
   InSequence sequence;
   EXPECT_CALL(*gl_, ClearDepth(0.5f))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, ClearStencil(123))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(
       GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
       kServiceRenderbufferId))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(depth_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(stencil_cmd));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 #endif
 
-TEST_P(GLES2DecoderWithShaderTest, VertexAttribPointer) {
+TEST_F(GLES2DecoderWithShaderTest, VertexAttribPointer) {
   SetupVertexBuffer();
   static const GLenum types[] = {
     GL_BYTE,
     GL_UNSIGNED_BYTE,
     GL_SHORT,
     GL_UNSIGNED_SHORT,
     GL_FLOAT,
     GL_FIXED,
     GL_INT,
     GL_UNSIGNED_INT,
@@ skipping 119 matching lines @@
             }
           }
         }
       }
     }
   }
 }
 
 // Test that with an RGB backbuffer if we set the color mask to 1,1,1,1 it is
 // set to 1,1,1,0 at Draw time but is 1,1,1,1 at query time.
-TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMask) {
+TEST_F(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMask) {
   ColorMask cmd;
   cmd.Init(true, true, true, true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
-  SetupExpectationsForApplyingDirtyState(true,    // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1110,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      true,    // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1110,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays draw_cmd;
   draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   EXPECT_CALL(*gl_, GetError())
@@ skipping 13 matching lines @@
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, result->GetData()[0]);
   EXPECT_EQ(1, result->GetData()[1]);
   EXPECT_EQ(1, result->GetData()[2]);
   EXPECT_EQ(1, result->GetData()[3]);
 }
 
 // Test that with no depth if we set DepthMask true that it's set to false at
 // draw time but querying it returns true.
-TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferDepthMask) {
+TEST_F(GLES2DecoderRGBBackbufferTest, RGBBackbufferDepthMask) {
   EXPECT_CALL(*gl_, DepthMask(true))
       .Times(0)
       .RetiresOnSaturation();
   DepthMask cmd;
   cmd.Init(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
-  SetupExpectationsForApplyingDirtyState(true,    // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1110,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      true,    // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1110,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays draw_cmd;
   draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   EXPECT_CALL(*gl_, GetError())
@@ skipping 10 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_WRITEMASK),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, result->GetData()[0]);
 }
 
 // Test that with no stencil if we set the stencil mask it's still set to 0 at
 // draw time but gets our value if we query.
-TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferStencilMask) {
+TEST_F(GLES2DecoderRGBBackbufferTest, RGBBackbufferStencilMask) {
   const GLint kMask = 123;
   EXPECT_CALL(*gl_, StencilMask(kMask))
       .Times(0)
       .RetiresOnSaturation();
   StencilMask cmd;
   cmd.Init(kMask);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
-  SetupExpectationsForApplyingDirtyState(true,    // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1110,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      true,    // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1110,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays draw_cmd;
   draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_WRITEMASK, result->GetData()))
       .Times(0);
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_STENCIL_WRITEMASK, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_WRITEMASK),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(kMask, result->GetData()[0]);
 }
 
 // Test that if an FBO is bound we get the correct masks.
-TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMaskFBO) {
+TEST_F(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMaskFBO) {
   ColorMask cmd;
   cmd.Init(true, true, true, true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupTexture();
   SetupVertexBuffer();
   DoEnableVertexAttribArray(0);
   DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
   DoEnableVertexAttribArray(1);
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
   DoEnableVertexAttribArray(2);
   DoVertexAttribPointer(2, 2, GL_FLOAT, 0, 0);
-  SetupExpectationsForApplyingDirtyState(true,    // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1110,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      true,    // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1110,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays draw_cmd;
   draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Check that no extra calls are made on the next draw.
@@ skipping 16 matching lines @@
   DoBindFramebuffer(
       GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
   DoFramebufferTexture2D(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
       client_texture_id_, kServiceTextureId, 0, GL_NO_ERROR);
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
       .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
       .RetiresOnSaturation();
 
   // This time state needs to be set.
-  SetupExpectationsForApplyingDirtyState(false,   // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1110,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      false,    // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1110,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Check that no extra calls are made on the next draw.
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Unbind
   DoBindFramebuffer(GL_FRAMEBUFFER, 0, 0);
 
-  SetupExpectationsForApplyingDirtyState(true,    // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1110,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      true,    // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1110,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, CachedColorMask) {
+TEST_F(GLES2DecoderManualInitTest, ActualAlphaMatchesRequestedAlpha) {
   InitState init;
   init.gl_version = "3.0";
   init.has_alpha = true;
-  init.has_depth = true;
-  init.has_stencil = true;
-  init.request_alpha = true;
-  init.request_depth = true;
-  init.request_stencil = true;
-  init.bind_generates_resource = true;
-  InitDecoder(init);
-
-  SetupDefaultProgram();
-  SetupAllNeededVertexBuffers();
-  SetupTexture();
-
-  // Test all color_bits combinations twice.
-  for (int i = 0; i < 32; i++) {
-    GLuint color_bits = (i & 1 ? 0x0001 : 0x0000) | (i & 2 ? 0x0010 : 0x0000) |
-                        (i & 4 ? 0x0100 : 0x0000) | (i & 8 ? 0x1000 : 0x0000);
-
-    // Toggle depth_test to force ApplyDirtyState each time.
-    DirtyStateMaskTest(color_bits, false, 0xffffffff, 0xffffffff);
-    DirtyStateMaskTest(color_bits, true, 0xffffffff, 0xffffffff);
-    DirtyStateMaskTest(color_bits, false, 0xffffffff, 0xffffffff);
-  }
-}
-
-TEST_P(GLES2DecoderManualInitTest, CachedDepthMask) {
-  InitState init;
-  init.gl_version = "3.0";
-  init.has_alpha = true;
-  init.has_depth = true;
-  init.has_stencil = true;
-  init.request_alpha = true;
-  init.request_depth = true;
-  init.request_stencil = true;
-  init.bind_generates_resource = true;
-  InitDecoder(init);
-
-  SetupDefaultProgram();
-  SetupAllNeededVertexBuffers();
-  SetupTexture();
-
-  // Test all depth_mask combinations twice.
-  for (int i = 0; i < 4; i++) {
-    bool depth_mask = (i & 1) == 1;
-
-    // Toggle color masks to force ApplyDirtyState each time.
-    DirtyStateMaskTest(0x1010, depth_mask, 0xffffffff, 0xffffffff);
-    DirtyStateMaskTest(0x0101, depth_mask, 0xffffffff, 0xffffffff);
-    DirtyStateMaskTest(0x1010, depth_mask, 0xffffffff, 0xffffffff);
-  }
-}
-
-TEST_P(GLES2DecoderManualInitTest, CachedStencilMask) {
-  InitState init;
-  init.gl_version = "3.0";
-  init.has_alpha = true;
-  init.has_depth = true;
-  init.has_stencil = true;
-  init.request_alpha = true;
-  init.request_depth = true;
-  init.request_stencil = true;
-  init.bind_generates_resource = true;
-  InitDecoder(init);
-
-  SetupDefaultProgram();
-  SetupAllNeededVertexBuffers();
-  SetupTexture();
-
-  // Test all stencil_mask combinations twice.
-  for (int i = 0; i < 4; i++) {
-    GLuint stencil_mask = (i & 1) ? 0xf0f0f0f0 : 0x0f0f0f0f;
-
-    // Toggle color masks to force ApplyDirtyState each time.
-    DirtyStateMaskTest(0x1010, true, stencil_mask, 0xffffffff);
-    DirtyStateMaskTest(0x0101, true, stencil_mask, 0xffffffff);
-    DirtyStateMaskTest(0x1010, true, stencil_mask, 0xffffffff);
-  }
-
-  for (int i = 0; i < 4; i++) {
-    GLuint stencil_mask = (i & 1) ? 0xf0f0f0f0 : 0x0f0f0f0f;
-
-    // Toggle color masks to force ApplyDirtyState each time.
-    DirtyStateMaskTest(0x1010, true, 0xffffffff, stencil_mask);
-    DirtyStateMaskTest(0x0101, true, 0xffffffff, stencil_mask);
-    DirtyStateMaskTest(0x1010, true, 0xffffffff, stencil_mask);
-  }
-}
-
-TEST_P(GLES2DecoderManualInitTest, ActualAlphaMatchesRequestedAlpha) {
-  InitState init;
-  init.gl_version = "3.0";
-  init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
       .WillOnce(SetArgumentPointee<1>(8))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_ALPHA_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_ALPHA_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(8, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ActualAlphaDoesNotMatchRequestedAlpha) {
+TEST_F(GLES2DecoderManualInitTest, ActualAlphaDoesNotMatchRequestedAlpha) {
   InitState init;
   init.gl_version = "3.0";
   init.has_alpha = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
       .WillOnce(SetArgumentPointee<1>(8))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_ALPHA_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_ALPHA_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(0, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ActualDepthMatchesRequestedDepth) {
+TEST_F(GLES2DecoderManualInitTest, ActualDepthMatchesRequestedDepth) {
   InitState init;
   init.gl_version = "3.0";
   init.has_depth = true;
   init.request_depth = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
       .WillOnce(SetArgumentPointee<1>(24))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_DEPTH_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(24, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ActualDepthDoesNotMatchRequestedDepth) {
+TEST_F(GLES2DecoderManualInitTest, ActualDepthDoesNotMatchRequestedDepth) {
   InitState init;
   init.gl_version = "3.0";
   init.has_depth = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
       .WillOnce(SetArgumentPointee<1>(24))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_DEPTH_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(0, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ActualStencilMatchesRequestedStencil) {
+TEST_F(GLES2DecoderManualInitTest, ActualStencilMatchesRequestedStencil) {
   InitState init;
   init.gl_version = "3.0";
   init.has_stencil = true;
   init.request_stencil = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
       .WillOnce(SetArgumentPointee<1>(8))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_STENCIL_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(8, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ActualStencilDoesNotMatchRequestedStencil) {
+TEST_F(GLES2DecoderManualInitTest, ActualStencilDoesNotMatchRequestedStencil) {
   InitState init;
   init.gl_version = "3.0";
   init.has_stencil = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
       .WillOnce(SetArgumentPointee<1>(8))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_STENCIL_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(0, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, DepthEnableWithDepth) {
+TEST_F(GLES2DecoderManualInitTest, DepthEnableWithDepth) {
   InitState init;
   init.gl_version = "3.0";
   init.has_depth = true;
   init.request_depth = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   Enable cmd;
   cmd.Init(GL_DEPTH_TEST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupDefaultProgram();
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
-  SetupExpectationsForApplyingDirtyState(true,    // Framebuffer is RGB
-                                         true,    // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1110,  // color bits
-                                         true,    // depth mask
-                                         true,    // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      true,    // Framebuffer is RGB
+      true,    // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1110,  // color bits
+      true,    // depth mask
+      true,    // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
+
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays draw_cmd;
   draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_TEST, _))
       .Times(0)
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_DEPTH_TEST, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_TEST),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, DepthEnableWithoutRequestedDepth) {
+TEST_F(GLES2DecoderManualInitTest, DepthEnableWithoutRequestedDepth) {
   InitState init;
   init.gl_version = "3.0";
   init.has_depth = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   Enable cmd;
   cmd.Init(GL_DEPTH_TEST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupDefaultProgram();
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
-  SetupExpectationsForApplyingDirtyState(true,    // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1110,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      true,    // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1110,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays draw_cmd;
   draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_TEST, _))
       .Times(0)
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_DEPTH_TEST, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_TEST),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, StencilEnableWithStencil) {
+TEST_F(GLES2DecoderManualInitTest, StencilEnableWithStencil) {
   InitState init;
   init.gl_version = "3.0";
   init.has_stencil = true;
   init.request_stencil = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   Enable cmd;
   cmd.Init(GL_STENCIL_TEST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupDefaultProgram();
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
-  SetupExpectationsForApplyingDirtyState(true,    // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         true,    // Framebuffer has stencil
-                                         0x1110,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         -1,      // front stencil mask
-                                         -1,      // back stencil mask
-                                         true);   // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      true,    // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      true,    // Framebuffer has stencil
+      0x1110,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      -1,      // front stencil mask
+      -1,      // back stencil mask
+      true,    // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays draw_cmd;
   draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_TEST, _))
       .Times(0)
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_STENCIL_TEST, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_TEST),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, StencilEnableWithoutRequestedStencil) {
+TEST_F(GLES2DecoderManualInitTest, StencilEnableWithoutRequestedStencil) {
   InitState init;
   init.gl_version = "3.0";
   init.has_stencil = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   Enable cmd;
   cmd.Init(GL_STENCIL_TEST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupDefaultProgram();
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
-  SetupExpectationsForApplyingDirtyState(true,    // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1110,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      true,    // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1110,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays draw_cmd;
   draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_TEST, _))
       .Times(0)
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_STENCIL_TEST, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_TEST),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilReportsCorrectValues) {
+TEST_F(GLES2DecoderManualInitTest, PackedDepthStencilReportsCorrectValues) {
   InitState init;
   init.extensions = "GL_OES_packed_depth_stencil";
   init.gl_version = "opengl es 2.0";
   init.has_depth = true;
   init.has_stencil = true;
   init.request_depth = true;
   init.request_stencil = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
@@ skipping 23 matching lines @@
       .WillOnce(SetArgumentPointee<1>(24))
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(24, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilNoRequestedStencil) {
+TEST_F(GLES2DecoderManualInitTest, PackedDepthStencilNoRequestedStencil) {
   InitState init;
   init.extensions = "GL_OES_packed_depth_stencil";
   init.gl_version = "opengl es 2.0";
   init.has_depth = true;
   init.has_stencil = true;
   init.request_depth = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
@@ skipping 22 matching lines @@
       .WillOnce(SetArgumentPointee<1>(24))
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(24, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilRenderbufferDepth) {
+TEST_F(GLES2DecoderManualInitTest, PackedDepthStencilRenderbufferDepth) {
   InitState init;
   init.extensions = "GL_OES_packed_depth_stencil";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
 
@@ skipping 46 matching lines @@
       .WillOnce(SetArgumentPointee<1>(24))
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(24, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilRenderbufferStencil) {
+TEST_F(GLES2DecoderManualInitTest, PackedDepthStencilRenderbufferStencil) {
   InitState init;
   init.extensions = "GL_OES_packed_depth_stencil";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
 
@@ skipping 46 matching lines @@
       .WillOnce(SetArgumentPointee<1>(24))
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(0, result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderTest, GetMultipleIntegervCHROMIUMValidArgs) {
+TEST_F(GLES2DecoderTest, GetMultipleIntegervCHROMIUMValidArgs) {
   const GLsizei kCount = 3;
   GLenum* pnames = GetSharedMemoryAs<GLenum*>();
   pnames[0] = GL_DEPTH_WRITEMASK;
   pnames[1] = GL_COLOR_WRITEMASK;
   pnames[2] = GL_STENCIL_WRITEMASK;
   GLint* results =
       GetSharedMemoryAsWithOffset<GLint*>(sizeof(*pnames) * kCount);
 
   GLsizei num_results = 0;
   for (GLsizei ii = 0; ii < kCount; ++ii) {
@@ skipping 15 matching lines @@
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, results[0]);  // Depth writemask
   EXPECT_EQ(1, results[1]);  // color writemask red
   EXPECT_EQ(1, results[2]);  // color writemask green
   EXPECT_EQ(1, results[3]);  // color writemask blue
   EXPECT_EQ(1, results[4]);  // color writemask alpha
   EXPECT_EQ(-1, results[5]);  // stencil writemask alpha
   EXPECT_EQ(kSentinel, results[num_results]);  // End of results
 }
 
-TEST_P(GLES2DecoderTest, GetMultipleIntegervCHROMIUMInvalidArgs) {
+TEST_F(GLES2DecoderTest, GetMultipleIntegervCHROMIUMInvalidArgs) {
   const GLsizei kCount = 3;
   // Offset the pnames because GLGetError will use the first uint32.
   const uint32 kPnameOffset = sizeof(uint32);
   const uint32 kResultsOffset = kPnameOffset + sizeof(GLint) * kCount;
   GLenum* pnames = GetSharedMemoryAsWithOffset<GLenum*>(kPnameOffset);
   pnames[0] = GL_DEPTH_WRITEMASK;
   pnames[1] = GL_COLOR_WRITEMASK;
   pnames[2] = GL_STENCIL_WRITEMASK;
   GLint* results = GetSharedMemoryAsWithOffset<GLint*>(kResultsOffset);
 
@@ skipping 73 matching lines @@
   // Check buffer is what we expect
   EXPECT_EQ(0, results[0]);
   EXPECT_EQ(1, results[1]);
   EXPECT_EQ(0, results[2]);
   EXPECT_EQ(0, results[3]);
   EXPECT_EQ(0, results[4]);
   EXPECT_EQ(0, results[5]);
   EXPECT_EQ(kSentinel, results[num_results]);  // End of results
 }
 
-TEST_P(GLES2DecoderTest, TexImage2DRedefinitionSucceeds) {
+TEST_F(GLES2DecoderTest, TexImage2DRedefinitionSucceeds) {
   const int kWidth = 16;
   const int kHeight = 8;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   EXPECT_CALL(*gl_, GetError())
       .WillRepeatedly(Return(GL_NO_ERROR));
   for (int ii = 0; ii < 2; ++ii) {
     TexImage2D cmd;
     if (ii == 0) {
       EXPECT_CALL(*gl_, TexImage2D(
           GL_TEXTURE_2D, 0, GL_RGBA, kWidth, kHeight, 0, GL_RGBA,
@@ skipping 21 matching lines @@
     // (last GL_TRUE argument). It will be skipped if there are bugs in the
     // redefinition case.
     TexSubImage2D cmd2;
     cmd2.Init(
         GL_TEXTURE_2D, 0, 0, 0, kWidth, kHeight - 1, GL_RGBA, GL_UNSIGNED_BYTE,
         kSharedMemoryId, kSharedMemoryOffset, GL_TRUE);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   }
 }
 
-TEST_P(GLES2DecoderTest, TexImage2DGLError) {
+TEST_F(GLES2DecoderTest, TexImage2DGLError) {
   GLenum target = GL_TEXTURE_2D;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLint border = 0;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureManager* manager = group().texture_manager();
@@ skipping 10 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   TexImage2D cmd;
   cmd.Init(target, level, internal_format, width, height, border, format,
            type, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
 }
 
-TEST_P(GLES2DecoderTest, BufferDataGLError) {
+TEST_F(GLES2DecoderTest, BufferDataGLError) {
   GLenum target = GL_ARRAY_BUFFER;
   GLsizeiptr size = 4;
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
   BufferManager* manager = group().buffer_manager();
   Buffer* buffer = manager->GetBuffer(client_buffer_id_);
   ASSERT_TRUE(buffer != NULL);
   EXPECT_EQ(0, buffer->size());
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BufferData(target, size, _, GL_STREAM_DRAW))
       .Times(1)
       .RetiresOnSaturation();
   BufferData cmd;
   cmd.Init(target, size, 0, 0, GL_STREAM_DRAW);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_EQ(0, buffer->size());
 }
 
-TEST_P(GLES2DecoderTest, CopyTexImage2DGLError) {
+TEST_F(GLES2DecoderTest, CopyTexImage2DGLError) {
   GLenum target = GL_TEXTURE_2D;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLint border = 0;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, CopyTexImage2D(
       target, level, internal_format, 0, 0, width, height, border))
       .Times(1)
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
   cmd.Init(target, level, internal_format, 0, 0, width, height, border);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
 }
 
-TEST_P(GLES2DecoderTest, FramebufferRenderbufferGLError) {
+TEST_F(GLES2DecoderTest, FramebufferRenderbufferGLError) {
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
       kServiceRenderbufferId))
       .Times(1)
       .RetiresOnSaturation();
   FramebufferRenderbuffer cmd;
   cmd.Init(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
       client_renderbuffer_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, FramebufferTexture2DGLError) {
+TEST_F(GLES2DecoderTest, FramebufferTexture2DGLError) {
   const GLsizei kWidth = 5;
   const GLsizei kHeight = 3;
   const GLenum kFormat = GL_RGB;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, kFormat, kWidth, kHeight, 0,
                kFormat, GL_UNSIGNED_BYTE, 0, 0);
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
       kServiceTextureId, 0))
       .Times(1)
       .RetiresOnSaturation();
   FramebufferTexture2D fbtex_cmd;
   fbtex_cmd.Init(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, client_texture_id_,
       0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(fbtex_cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, RenderbufferStorageGLError) {
+TEST_F(GLES2DecoderTest, RenderbufferStorageGLError) {
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, RenderbufferStorageEXT(
       GL_RENDERBUFFER, GL_RGBA, 100, 50))
       .Times(1)
       .RetiresOnSaturation();
   RenderbufferStorage cmd;
   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 100, 50);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, RenderbufferStorageBadArgs) {
+TEST_F(GLES2DecoderTest, RenderbufferStorageBadArgs) {
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   RenderbufferStorage cmd;
   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, TestHelper::kMaxRenderbufferSize + 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 1, TestHelper::kMaxRenderbufferSize + 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest,
+TEST_F(GLES2DecoderManualInitTest,
        RenderbufferStorageMultisampleCHROMIUMGLError) {
   InitState init;
   init.extensions = "GL_EXT_framebuffer_multisample";
   init.gl_version = "2.1";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, RenderbufferStorageMultisampleEXT(
       GL_RENDERBUFFER, 1, GL_RGBA, 100, 50))
       .Times(1)
       .RetiresOnSaturation();
   RenderbufferStorageMultisampleCHROMIUM cmd;
   cmd.Init(GL_RENDERBUFFER, 1, GL_RGBA4, 100, 50);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest,
+TEST_F(GLES2DecoderManualInitTest,
        RenderbufferStorageMultisampleCHROMIUMBadArgs) {
   InitState init;
   init.extensions = "GL_EXT_framebuffer_multisample";
   init.gl_version = "2.1";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   EXPECT_CALL(*gl_, RenderbufferStorageMultisampleEXT(_, _, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   RenderbufferStorageMultisampleCHROMIUM cmd;
   cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples + 1,
            GL_RGBA4, TestHelper::kMaxRenderbufferSize, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples,
            GL_RGBA4, TestHelper::kMaxRenderbufferSize + 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples,
            GL_RGBA4, 1, TestHelper::kMaxRenderbufferSize + 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, RenderbufferStorageMultisampleCHROMIUM) {
+TEST_F(GLES2DecoderManualInitTest, RenderbufferStorageMultisampleCHROMIUM) {
   InitState init;
   init.extensions = "GL_EXT_framebuffer_multisample";
   init.gl_version = "2.1";
   InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   InSequence sequence;
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(
       *gl_,
       RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER,
                                         TestHelper::kMaxSamples,
                                         GL_RGBA,
                                         TestHelper::kMaxRenderbufferSize,
                                         1))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   RenderbufferStorageMultisampleCHROMIUM cmd;
   cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples,
            GL_RGBA4, TestHelper::kMaxRenderbufferSize, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest,
+TEST_F(GLES2DecoderManualInitTest,
        RenderbufferStorageMultisampleEXTNotSupported) {
   InitState init;
   init.extensions = "GL_EXT_framebuffer_multisample";
   init.gl_version = "2.1";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   InSequence sequence;
   // GL_EXT_framebuffer_multisample uses RenderbufferStorageMultisampleCHROMIUM.
   RenderbufferStorageMultisampleEXT cmd;
   cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples,
            GL_RGBA4, TestHelper::kMaxRenderbufferSize, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 class GLES2DecoderMultisampledRenderToTextureTest
-    : public GLES2DecoderTestWithExtensionsOnGLES2 {
- public:
-  void TestNotCompatibleWithRenderbufferStorageMultisampleCHROMIUM() {
-    DoBindRenderbuffer(
-        GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
-    RenderbufferStorageMultisampleCHROMIUM cmd;
-    cmd.Init(GL_RENDERBUFFER,
-             TestHelper::kMaxSamples,
-             GL_RGBA4,
-             TestHelper::kMaxRenderbufferSize,
-             1);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-    EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
-  }
-
-  void TestRenderbufferStorageMultisampleEXT(const char* extension) {
-    DoBindRenderbuffer(
-        GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
-    InSequence sequence;
-    EXPECT_CALL(*gl_, GetError())
-        .WillOnce(Return(GL_NO_ERROR))
-        .RetiresOnSaturation();
-    if (strstr(extension, "GL_IMG_multisampled_render_to_texture")) {
-      EXPECT_CALL(
-          *gl_,
-          RenderbufferStorageMultisampleIMG(GL_RENDERBUFFER,
-                                            TestHelper::kMaxSamples,
-                                            GL_RGBA,
-                                            TestHelper::kMaxRenderbufferSize,
-                                            1))
-          .Times(1)
-          .RetiresOnSaturation();
-    } else {
-      EXPECT_CALL(
-          *gl_,
-          RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER,
-                                            TestHelper::kMaxSamples,
-                                            GL_RGBA,
-                                            TestHelper::kMaxRenderbufferSize,
-                                            1))
-          .Times(1)
-          .RetiresOnSaturation();
-    }
-    EXPECT_CALL(*gl_, GetError())
-        .WillOnce(Return(GL_NO_ERROR))
-        .RetiresOnSaturation();
-    RenderbufferStorageMultisampleEXT cmd;
-    cmd.Init(GL_RENDERBUFFER,
-             TestHelper::kMaxSamples,
-             GL_RGBA4,
-             TestHelper::kMaxRenderbufferSize,
-             1);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-    EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  }
-};
+    : public GLES2DecoderTestWithExtensionsOnGLES2 {};
 
 TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
-       NotCompatibleWithRenderbufferStorageMultisampleCHROMIUM_EXT) {
-  Init("GL_EXT_multisampled_render_to_texture");
-  TestNotCompatibleWithRenderbufferStorageMultisampleCHROMIUM();
+       NotCompatibleWithRenderbufferStorageMultisampleCHROMIUM) {
+  DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
+                    kServiceRenderbufferId);
+  RenderbufferStorageMultisampleCHROMIUM cmd;
+  cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples,
+           GL_RGBA4, TestHelper::kMaxRenderbufferSize, 1);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
-       NotCompatibleWithRenderbufferStorageMultisampleCHROMIUM_IMG) {
-  Init("GL_IMG_multisampled_render_to_texture");
-  TestNotCompatibleWithRenderbufferStorageMultisampleCHROMIUM();
+       RenderbufferStorageMultisampleEXT) {
+  DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
+                    kServiceRenderbufferId);
+  InSequence sequence;
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(GL_NO_ERROR))
+      .RetiresOnSaturation();
+  if (strstr(GetParam(), "GL_IMG_multisampled_render_to_texture")) {
+    EXPECT_CALL(
+        *gl_,
+        RenderbufferStorageMultisampleIMG(GL_RENDERBUFFER,
+                                          TestHelper::kMaxSamples,
+                                          GL_RGBA,
+                                          TestHelper::kMaxRenderbufferSize,
+                                          1))
+        .Times(1)
+        .RetiresOnSaturation();
+  } else {
+    EXPECT_CALL(
+        *gl_,
+        RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER,
+                                          TestHelper::kMaxSamples,
+                                          GL_RGBA,
+                                          TestHelper::kMaxRenderbufferSize,
+                                          1))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+  EXPECT_CALL(*gl_, GetError())
+      .WillOnce(Return(GL_NO_ERROR))
+      .RetiresOnSaturation();
+  RenderbufferStorageMultisampleEXT cmd;
+  cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples,
+           GL_RGBA4, TestHelper::kMaxRenderbufferSize, 1);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
-       RenderbufferStorageMultisampleEXT_EXT) {
-  Init("GL_EXT_multisampled_render_to_texture");
-  TestRenderbufferStorageMultisampleEXT(
-      "GL_EXT_multisampled_render_to_texture");
-}
+INSTANTIATE_TEST_CASE_P(
+    GLES2DecoderMultisampledRenderToTextureTests,
+    GLES2DecoderMultisampledRenderToTextureTest,
+    ::testing::Values("GL_EXT_multisampled_render_to_texture",
+                      "GL_IMG_multisampled_render_to_texture"));
 
-TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
-       RenderbufferStorageMultisampleEXT_IMG) {
-  Init("GL_IMG_multisampled_render_to_texture");
-  TestRenderbufferStorageMultisampleEXT(
-      "GL_IMG_multisampled_render_to_texture");
-}
-
-TEST_P(GLES2DecoderTest, ReadPixelsGLError) {
+TEST_F(GLES2DecoderTest, ReadPixelsGLError) {
   GLenum kFormat = GL_RGBA;
   GLint x = 0;
   GLint y = 0;
   GLsizei width = 2;
   GLsizei height = 4;
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   uint32 result_shm_id = kSharedMemoryId;
   uint32 result_shm_offset = kSharedMemoryOffset;
   uint32 pixels_shm_id = kSharedMemoryId;
   uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(
       *gl_, ReadPixels(x, y, width, height, kFormat, GL_UNSIGNED_BYTE, _))
       .Times(1)
       .RetiresOnSaturation();
   ReadPixels cmd;
   cmd.Init(x, y, width, height, kFormat, GL_UNSIGNED_BYTE,
            pixels_shm_id, pixels_shm_offset,
            result_shm_id, result_shm_offset,
            false);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
 
-TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsS3TC) {
+TEST_F(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsS3TC) {
   const GLenum formats[] = {
     GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
     GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
     GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
     GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
   };
   CheckFormats("GL_EXT_texture_compression_s3tc", formats, 4);
 }
 
-TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsATC) {
+TEST_F(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsATC) {
   const GLenum formats[] = {
     GL_ATC_RGB_AMD,
     GL_ATC_RGBA_EXPLICIT_ALPHA_AMD,
     GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD
   };
   CheckFormats("GL_AMD_compressed_ATC_texture", formats, 3);
 }
 
-TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsPVRTC) {
+TEST_F(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsPVRTC) {
   const GLenum formats[] = {
     GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
     GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
     GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
     GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
   };
   CheckFormats("GL_IMG_texture_compression_pvrtc", formats, 4);
 }
 
-TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsETC1) {
+TEST_F(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsETC1) {
   const GLenum formats[] = {
     GL_ETC1_RGB8_OES
   };
   CheckFormats("GL_OES_compressed_ETC1_RGB8_texture", formats, 1);
 }
 
-TEST_P(GLES2DecoderManualInitTest, GetNoCompressedTextureFormats) {
+TEST_F(GLES2DecoderManualInitTest, GetNoCompressedTextureFormats) {
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ skipping 18 matching lines @@
   result->size = 0;
   cmd.Init(
       GL_COMPRESSED_TEXTURE_FORMATS,
       shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(num_formats, result->GetNumResults());
 
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DBucketBadBucket) {
+TEST_F(GLES2DecoderManualInitTest, CompressedTexImage2DBucketBadBucket) {
   InitState init;
   init.extensions = "GL_EXT_texture_compression_s3tc";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   const uint32 kBadBucketId = 123;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   CompressedTexImage2DBucket cmd;
   cmd.Init(
       GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 4, 4, 0,
       kBadBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   CompressedTexSubImage2DBucket cmd2;
   cmd2.Init(
       GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
       kBadBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 namespace {
 
 struct S3TCTestData {
   GLenum format;
   size_t block_size;
 };
 
 }  // anonymous namespace.
 
-TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
+TEST_F(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
   InitState init;
   init.extensions = "GL_EXT_texture_compression_s3tc";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   const uint32 kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
@@ skipping 129 matching lines @@
                 kBucketId);
             EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
             EXPECT_EQ(GL_NO_ERROR, GetGLError());
           }
         }
       }
     }
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DETC1) {
+TEST_F(GLES2DecoderManualInitTest, CompressedTexImage2DETC1) {
   InitState init;
   init.extensions = "GL_OES_compressed_ETC1_RGB8_texture";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   const uint32 kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
@@ skipping 47 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(texsub_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Test CopyTexSubImage not allowed for ETC1 compressed texture
   CopyTexSubImage2D copy_cmd;
   copy_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 4, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(copy_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) {
+TEST_F(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_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMInvalidArgs) {
+TEST_F(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_P(GLES2DecoderManualInitTest, EGLImageExternalBindTexture) {
+TEST_F(GLES2DecoderManualInitTest, EGLImageExternalBindTexture) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_EXTERNAL_OES, kNewServiceId));
   EXPECT_CALL(*gl_, GenTextures(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_EXTERNAL_OES, kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   TextureRef* texture_ref = GetTexture(kNewClientId);
   EXPECT_TRUE(texture_ref != NULL);
   EXPECT_TRUE(texture_ref->texture()->target() == GL_TEXTURE_EXTERNAL_OES);
 }
 
-TEST_P(GLES2DecoderManualInitTest, EGLImageExternalGetBinding) {
+TEST_F(GLES2DecoderManualInitTest, EGLImageExternalGetBinding) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES,
                                 result->GetData()))
       .Times(0);
   result->size = 0;
   GetIntegerv cmd;
   cmd.Init(GL_TEXTURE_BINDING_EXTERNAL_OES,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
       GL_TEXTURE_BINDING_EXTERNAL_OES), result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(client_texture_id_, (uint32)result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureDefaults) {
+TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureDefaults) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
   TextureRef* texture_ref = GetTexture(client_texture_id_);
   EXPECT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
-TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureParam) {
+TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureParam) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
   EXPECT_CALL(*gl_, TexParameteri(GL_TEXTURE_EXTERNAL_OES,
                                   GL_TEXTURE_MIN_FILTER,
                                   GL_NEAREST));
@@ skipping 33 matching lines @@
 
   TextureRef* texture_ref = GetTexture(client_texture_id_);
   EXPECT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
-TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureParamInvalid) {
+TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureParamInvalid) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
   TexParameteri cmd;
   cmd.Init(GL_TEXTURE_EXTERNAL_OES,
            GL_TEXTURE_MIN_FILTER,
@@ skipping 15 matching lines @@
 
   TextureRef* texture_ref = GetTexture(client_texture_id_);
   EXPECT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
-TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTexImage2DError) {
+TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTexImage2DError) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   GLenum target = GL_TEXTURE_EXTERNAL_OES;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLint border = 0;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
   ASSERT_TRUE(GetTexture(client_texture_id_) != NULL);
   TexImage2D cmd;
   cmd.Init(target, level, internal_format, width, height, border, format,
            type, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 
   // TexImage2D is not allowed with GL_TEXTURE_EXTERNAL_OES targets.
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, BindGeneratesResourceFalse) {
+TEST_F(GLES2DecoderManualInitTest, BindGeneratesResourceFalse) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   BindTexture cmd1;
   cmd1.Init(GL_TEXTURE_2D, kInvalidClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   BindBuffer cmd2;
   cmd2.Init(GL_ARRAY_BUFFER, kInvalidClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   BindFramebuffer cmd3;
   cmd3.Init(GL_FRAMEBUFFER, kInvalidClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd3));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   BindRenderbuffer cmd4;
   cmd4.Init(GL_RENDERBUFFER, kInvalidClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd4));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, DefaultTextureZero) {
+TEST_F(GLES2DecoderManualInitTest, DefaultTextureZero) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   BindTexture cmd1;
   cmd1.Init(GL_TEXTURE_2D, 0);
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   BindTexture cmd2;
   cmd2.Init(GL_TEXTURE_CUBE_MAP, 0);
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_CUBE_MAP, 0));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, DefaultTextureBGR) {
+TEST_F(GLES2DecoderManualInitTest, DefaultTextureBGR) {
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   BindTexture cmd1;
   cmd1.Init(GL_TEXTURE_2D, 0);
   EXPECT_CALL(
       *gl_, BindTexture(GL_TEXTURE_2D, TestHelper::kServiceDefaultTexture2dId));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   BindTexture cmd2;
   cmd2.Init(GL_TEXTURE_CUBE_MAP, 0);
   EXPECT_CALL(*gl_,
               BindTexture(GL_TEXTURE_CUBE_MAP,
                           TestHelper::kServiceDefaultTextureCubemapId));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Test that default texture 0 is immutable.
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameterf) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexParameterf) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   {
     BindTexture cmd1;
     cmd1.Init(GL_TEXTURE_2D, 0);
     EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ skipping 11 matching lines @@
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
     TexParameterf cmd2;
     cmd2.Init(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
     EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameteri) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexParameteri) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   {
     BindTexture cmd1;
     cmd1.Init(GL_TEXTURE_2D, 0);
     EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ skipping 11 matching lines @@
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
     TexParameteri cmd2;
     cmd2.Init(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
     EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameterfv) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexParameterfv) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   {
     BindTexture cmd1;
     cmd1.Init(GL_TEXTURE_2D, 0);
     EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ skipping 19 matching lines @@
     cmd2.Init(GL_TEXTURE_CUBE_MAP,
               GL_TEXTURE_MAG_FILTER,
               shared_memory_id_,
               shared_memory_offset_);
     GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
     EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameteriv) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexParameteriv) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   {
     BindTexture cmd1;
     cmd1.Init(GL_TEXTURE_2D, 0);
     EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ skipping 19 matching lines @@
     cmd2.Init(GL_TEXTURE_CUBE_MAP,
               GL_TEXTURE_MAG_FILTER,
               shared_memory_id_,
               shared_memory_offset_);
     GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
     EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexImage2D) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexImage2D) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   BindTexture cmd1;
   cmd1.Init(GL_TEXTURE_2D, 0);
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   TexImage2D cmd2;
   cmd2.Init(GL_TEXTURE_2D,
             0,
             GL_RGBA,
             2,
             2,
             0,
             GL_RGBA,
             GL_UNSIGNED_BYTE,
             kSharedMemoryId,
             kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexSubImage2D) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexSubImage2D) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   BindTexture cmd1;
   cmd1.Init(GL_TEXTURE_2D, 0);
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   TexSubImage2D cmd2;
   cmd2.Init(GL_TEXTURE_2D,
             0,
             1,
             1,
             1,
             1,
             GL_RGBA,
             GL_UNSIGNED_BYTE,
             kSharedMemoryId,
             kSharedMemoryOffset,
             GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleBindTexture) {
+TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleBindTexture) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_RECTANGLE_ARB, kNewServiceId));
   EXPECT_CALL(*gl_, GenTextures(1, _))
      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB, kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   Texture* texture = GetTexture(kNewClientId)->texture();
   EXPECT_TRUE(texture != NULL);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleGetBinding) {
+TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleGetBinding) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB,
                                 result->GetData()))
       .Times(0);
   result->size = 0;
   GetIntegerv cmd;
   cmd.Init(GL_TEXTURE_BINDING_RECTANGLE_ARB,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
       GL_TEXTURE_BINDING_RECTANGLE_ARB), result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(client_texture_id_, (uint32)result->GetData()[0]);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureDefaults) {
+TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureDefaults) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
   EXPECT_TRUE(texture != NULL);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParam) {
+TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParam) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
   EXPECT_CALL(*gl_, TexParameteri(GL_TEXTURE_RECTANGLE_ARB,
@@ skipping 34 matching lines @@
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
   EXPECT_TRUE(texture != NULL);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParamInvalid) {
+TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParamInvalid) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
   TexParameteri cmd;
@@ skipping 16 matching lines @@
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
   EXPECT_TRUE(texture != NULL);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTexImage2DError) {
+TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTexImage2DError) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   GLenum target = GL_TEXTURE_RECTANGLE_ARB;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLint border = 0;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
   ASSERT_TRUE(GetTexture(client_texture_id_) != NULL);
   TexImage2D cmd;
   cmd.Init(target, level, internal_format, width, height, border, format,
            type, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 
   // TexImage2D is not allowed with GL_TEXTURE_RECTANGLE_ARB targets.
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, EnableFeatureCHROMIUMBadBucket) {
+TEST_F(GLES2DecoderTest, EnableFeatureCHROMIUMBadBucket) {
   const uint32 kBadBucketId = 123;
   EnableFeatureCHROMIUM cmd;
   cmd.Init(kBadBucketId, shared_memory_id_, shared_memory_offset_);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, RequestExtensionCHROMIUMBadBucket) {
+TEST_F(GLES2DecoderTest, RequestExtensionCHROMIUMBadBucket) {
   const uint32 kBadBucketId = 123;
   RequestExtensionCHROMIUM cmd;
   cmd.Init(kBadBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderManualInitTest, TexSubImage2DClearsAfterTexImage2DNULL) {
-  InitState init;
-  init.gl_version = "opengl es 2.0";
-  init.has_alpha = true;
-  init.has_depth = true;
-  init.request_alpha = true;
-  init.request_depth = true;
-  InitDecoder(init);
-
+TEST_F(GLES2DecoderTest, TexSubImage2DClearsAfterTexImage2DNULL) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   SetupClearTextureExpectations(
       kServiceTextureId, kServiceTextureId, GL_TEXTURE_2D, GL_TEXTURE_2D,
       0, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, 2, 2);
   EXPECT_CALL(*gl_, TexSubImage2D(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   TexSubImage2D cmd;
   cmd.Init(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
       kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   // Test if we call it again it does not clear.
   EXPECT_CALL(*gl_, TexSubImage2D(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, TexSubImage2DDoesNotClearAfterTexImage2DNULLThenData) {
+TEST_F(GLES2DecoderTest, TexSubImage2DDoesNotClearAfterTexImage2DNULLThenData) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_CALL(*gl_, TexSubImage2D(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   TexSubImage2D cmd;
   cmd.Init(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
       kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   // Test if we call it again it does not clear.
   EXPECT_CALL(*gl_, TexSubImage2D(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(
+TEST_F(
     GLES2DecoderManualInitTest,
     TexSubImage2DDoesNotClearAfterTexImage2DNULLThenDataWithTexImage2DIsFaster) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::TEXSUBIMAGE2D_FASTER_THAN_TEXIMAGE2D));
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoderWithCommandLine(init, &command_line);
@@ skipping 35 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   // Test if we call it again it does not clear.
   EXPECT_CALL(*gl_, TexSubImage2D(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, TexSubImage2DClearsAfterTexImage2DWithDataThenNULL) {
+TEST_F(GLES2DecoderTest, TexSubImage2DClearsAfterTexImage2DWithDataThenNULL) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   // Put in data (so it should be marked as cleared)
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                kSharedMemoryId, kSharedMemoryOffset);
   // Put in no data.
   TexImage2D tex_cmd;
   tex_cmd.Init(
       GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   // It won't actually call TexImage2D, just mark it as uncleared.
   EXPECT_EQ(error::kNoError, ExecuteCmd(tex_cmd));
   // Next call to TexSubImage2d should clear.
   SetupClearTextureExpectations(
       kServiceTextureId, kServiceTextureId, GL_TEXTURE_2D, GL_TEXTURE_2D,
       0, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, 2, 2);
   EXPECT_CALL(*gl_, TexSubImage2D(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   TexSubImage2D cmd;
   cmd.Init(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
       kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysClearsAfterTexImage2DNULL) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysClearsAfterTexImage2DNULL) {
   SetupAllNeededVertexBuffers();
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   // Create an uncleared texture with 2 levels.
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   // Expect 2 levels will be cleared.
   SetupClearTextureExpectations(
       kServiceTextureId, kServiceTextureId, GL_TEXTURE_2D, GL_TEXTURE_2D,
@@ skipping 11 matching lines @@
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // But not again
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsClearsAfterTexImage2DNULL) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsClearsAfterTexImage2DNULL) {
   SetupAllNeededVertexBuffers();
   SetupIndexBuffer();
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   // Create an uncleared texture with 2 levels.
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   // Expect 2 levels will be cleared.
   SetupClearTextureExpectations(
@@ skipping 18 matching lines @@
   // But not again
   EXPECT_CALL(*gl_, DrawElements(GL_TRIANGLES, kValidIndexRangeCount,
                                  GL_UNSIGNED_SHORT,
                                  BufferOffset(kValidIndexRangeStart * 2)))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterTexImage2DNULLInFBO) {
+TEST_F(GLES2DecoderWithShaderTest, DrawClearsAfterTexImage2DNULLInFBO) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
   SetupAllNeededVertexBuffers();
   // Register a texture id.
   EXPECT_CALL(*gl_, GenTextures(_, _))
       .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
       .RetiresOnSaturation();
   GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
 
@@ skipping 11 matching lines @@
   SetupTexture();
 
   SetupExpectationsForFramebufferClearing(
       GL_FRAMEBUFFER,         // target
       GL_COLOR_BUFFER_BIT,    // clear bits
       0, 0, 0, 0,             // color
       0,                      // stencil
       1.0f,                   // depth
       false);                 // scissor test
 
-  SetupExpectationsForApplyingDirtyState(false,   // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1111,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      false,   // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1111,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // But not again.
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawWitFBOThatCantClearDoesNotDraw) {
+TEST_F(GLES2DecoderWithShaderTest, DrawWitFBOThatCantClearDoesNotDraw) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
   // Register a texture id.
   EXPECT_CALL(*gl_, GenTextures(_, _))
       .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
       .RetiresOnSaturation();
   GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
 
   // Setup "render to" texture.
@@ skipping 14 matching lines @@
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_FRAMEBUFFER_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, CopyTexImage2DMarksTextureAsCleared) {
+TEST_F(GLES2DecoderTest, CopyTexImage2DMarksTextureAsCleared) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, CopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 1, 0))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
   cmd.Init(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 1, 0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 
   EXPECT_TRUE(texture->SafeToRenderFrom());
 }
 
-TEST_P(GLES2DecoderTest, CopyTexSubImage2DClearsUnclearedTexture) {
+TEST_F(GLES2DecoderTest, CopyTexSubImage2DClearsUnclearedTexture) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
 
   SetupClearTextureExpectations(
       kServiceTextureId, kServiceTextureId, GL_TEXTURE_2D, GL_TEXTURE_2D,
       0, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, 2, 2);
   EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1))
       .Times(1)
       .RetiresOnSaturation();
   CopyTexSubImage2D cmd;
   cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderManualInitTest, CompressedImage2DMarksTextureAsCleared) {
+TEST_F(GLES2DecoderManualInitTest, CompressedImage2DMarksTextureAsCleared) {
   InitState init;
   init.extensions = "GL_EXT_texture_compression_s3tc";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, CompressedTexImage2D(
       GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, 8, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   CompressedTexImage2D cmd;
   cmd.Init(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0,
            8, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   TextureManager* manager = group().texture_manager();
   TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
   EXPECT_TRUE(texture_ref->texture()->SafeToRenderFrom());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnClear) {
+TEST_F(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnClear) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
   // Register a texture id.
   EXPECT_CALL(*gl_, GenTextures(_, _))
       .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
       .RetiresOnSaturation();
   GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
 
   // Setup "render to" texture.
   DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   DoBindFramebuffer(
       GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
   DoFramebufferTexture2D(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
       kFBOClientTextureId, kFBOServiceTextureId, 0, GL_NO_ERROR);
 
   // Setup "render from" texture.
   SetupTexture();
 
   SetupExpectationsForFramebufferClearing(
       GL_FRAMEBUFFER,         // target
       GL_COLOR_BUFFER_BIT,    // clear bits
       0, 0, 0, 0,             // color
       0,                      // stencil
       1.0f,                   // depth
       false);                 // scissor test
-  SetupExpectationsForApplyingDirtyState(false,   // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1111,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      false,   // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1111,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, Clear(GL_COLOR_BUFFER_BIT))
       .Times(1)
       .RetiresOnSaturation();
 
   Clear cmd;
   cmd.Init(GL_COLOR_BUFFER_BIT);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnReadPixels) {
+TEST_F(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnReadPixels) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
   // Register a texture id.
   EXPECT_CALL(*gl_, GenTextures(_, _))
       .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
       .RetiresOnSaturation();
   GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
 
   // Setup "render to" texture.
@@ skipping 32 matching lines @@
   uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
   ReadPixels cmd;
   cmd.Init(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
            pixels_shm_id, pixels_shm_offset,
            result_shm_id, result_shm_offset,
            false);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest,
+TEST_F(GLES2DecoderManualInitTest,
        UnClearedAttachmentsGetClearedOnReadPixelsAndDrawBufferGetsRestored) {
   InitState init;
   init.extensions = "GL_EXT_framebuffer_multisample";
   init.gl_version = "2.1";
   init.bind_generates_resource = true;
   InitDecoder(init);
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
   // Register a texture id.
   EXPECT_CALL(*gl_, GenTextures(_, _))
       .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
       .RetiresOnSaturation();
   GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
 
   // Setup "render from" texture.
   DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   DoBindFramebuffer(
       GL_READ_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
   DoFramebufferTexture2D(
       GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
       kFBOClientTextureId, kFBOServiceTextureId, 0, GL_NO_ERROR);
 
-  // Enable GL_SCISSOR_TEST to make sure we disable it in the clear,
-  // then re-enable after.
-  DoEnableDisable(GL_SCISSOR_TEST, true);
-
   SetupExpectationsForFramebufferClearingMulti(
       kServiceFramebufferId,  // read framebuffer service id
       0,                      // backbuffer service id
       GL_READ_FRAMEBUFFER,    // target
       GL_COLOR_BUFFER_BIT,    // clear bits
-      0,
-      0,
-      0,
-      0,      // color
-      0,      // stencil
-      1.0f,   // depth
-      true);  // scissor test
+      0, 0, 0, 0,             // color
+      0,                      // stencil
+      1.0f,                   // depth
+      false);                 // scissor test
 
   EXPECT_CALL(*gl_, GetError())
      .WillOnce(Return(GL_NO_ERROR))
      .WillOnce(Return(GL_NO_ERROR))
      .RetiresOnSaturation();
   EXPECT_CALL(*gl_, ReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, _))
       .Times(1)
       .RetiresOnSaturation();
   typedef ReadPixels::Result Result;
   uint32 result_shm_id = kSharedMemoryId;
   uint32 result_shm_offset = kSharedMemoryOffset;
   uint32 pixels_shm_id = kSharedMemoryId;
   uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
   ReadPixels cmd;
   cmd.Init(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
            pixels_shm_id, pixels_shm_offset,
            result_shm_id, result_shm_offset,
            false);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterRenderbufferStorageInFBO) {
+TEST_F(GLES2DecoderWithShaderTest, DrawClearsAfterRenderbufferStorageInFBO) {
   SetupTexture();
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   DoRenderbufferStorage(
       GL_RENDERBUFFER, GL_RGBA4, GL_RGBA, 100, 50, GL_NO_ERROR);
   DoFramebufferRenderbuffer(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
       client_renderbuffer_id_, kServiceRenderbufferId, GL_NO_ERROR);
 
   SetupExpectationsForFramebufferClearing(
       GL_FRAMEBUFFER,         // target
       GL_COLOR_BUFFER_BIT,    // clear bits
       0, 0, 0, 0,             // color
       0,                      // stencil
       1.0f,                   // depth
       false);                 // scissor test
 
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
-  SetupExpectationsForApplyingDirtyState(false,   // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1111,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      false,   // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1111,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, DrawArraysClearsAfterTexImage2DNULLCubemap) {
-  InitState init;
-  init.gl_version = "opengl es 2.0";
-  init.has_alpha = true;
-  init.has_depth = true;
-  init.request_alpha = true;
-  init.request_depth = true;
-  InitDecoder(init);
-
+TEST_F(GLES2DecoderTest, DrawArraysClearsAfterTexImage2DNULLCubemap) {
   static const GLenum faces[] = {
     GL_TEXTURE_CUBE_MAP_POSITIVE_X,
     GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
     GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
     GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
     GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
     GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
   };
   SetupCubemapProgram();
   DoBindTexture(GL_TEXTURE_CUBE_MAP, client_texture_id_, kServiceTextureId);
@@ skipping 21 matching lines @@
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDefaultDirtyState();
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, TextureUsageAngleExtNotEnabledByDefault) {
+TEST_F(GLES2DecoderTest, TextureUsageAngleExtNotEnabledByDefault) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   TexParameteri cmd;
   cmd.Init(GL_TEXTURE_2D,
            GL_TEXTURE_USAGE_ANGLE,
            GL_FRAMEBUFFER_ATTACHMENT_ANGLE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        DrawClearsAfterRenderbuffersWithMultipleAttachments) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
   // Register a texture id.
   EXPECT_CALL(*gl_, GenTextures(_, _))
       .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
       .RetiresOnSaturation();
   GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
 
@@ skipping 21 matching lines @@
   SetupTexture();
   SetupExpectationsForFramebufferClearing(
       GL_FRAMEBUFFER,         // target
       GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT,    // clear bits
       0, 0, 0, 0,             // color
       0,                      // stencil
       1.0f,                   // depth
       false);                 // scissor test
 
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
-  SetupExpectationsForApplyingDirtyState(false,   // Framebuffer is RGB
-                                         true,    // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1111,  // color bits
-                                         true,    // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      false,   // Framebuffer is RGB
+      true,    // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1111,  // color bits
+      true,    // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, CopyTexImageWithInCompleteFBOFails) {
+TEST_F(GLES2DecoderWithShaderTest, CopyTexImageWithInCompleteFBOFails) {
   GLenum target = GL_TEXTURE_2D;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLint border = 0;
   SetupTexture();
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
@@ skipping 52 matching lines @@
   } else {
     EXPECT_TRUE(framebuffer_manager->IsComplete(framebuffer));
   }
   // Cleanup
   DoDeleteFramebuffer(
       client_framebuffer_id_, kServiceFramebufferId,
       bound_fbo, GL_FRAMEBUFFER, 0,
       bound_fbo, GL_FRAMEBUFFER, 0);
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        RenderbufferChangesMarkFBOAsNotCompleteBoundFBO) {
   CheckRenderbufferChangesMarkFBOAsNotComplete(true);
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        RenderbufferChangesMarkFBOAsNotCompleteUnboundFBO) {
   CheckRenderbufferChangesMarkFBOAsNotComplete(false);
 }
 
 void GLES2DecoderWithShaderTest::CheckTextureChangesMarkFBOAsNotComplete(
     bool bound_fbo) {
   FramebufferManager* framebuffer_manager = group().framebuffer_manager();
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
@@ skipping 68 matching lines @@
   } else {
     EXPECT_TRUE(framebuffer_manager->IsComplete(framebuffer));
   }
   // Cleanup
   DoDeleteFramebuffer(
       client_framebuffer_id_, kServiceFramebufferId,
       bound_fbo, GL_FRAMEBUFFER, 0,
       bound_fbo, GL_FRAMEBUFFER, 0);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, TextureChangesMarkFBOAsNotCompleteBoundFBO) {
+TEST_F(GLES2DecoderWithShaderTest, TextureChangesMarkFBOAsNotCompleteBoundFBO) {
   CheckTextureChangesMarkFBOAsNotComplete(true);
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        TextureChangesMarkFBOAsNotCompleteUnboundFBO) {
   CheckTextureChangesMarkFBOAsNotComplete(false);
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        DrawingWithFBOTwiceChecksForFBOCompleteOnce) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
   SetupAllNeededVertexBuffers();
 
   // Register a texture id.
   EXPECT_CALL(*gl_, GenTextures(_, _))
       .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
       .RetiresOnSaturation();
@@ skipping 11 matching lines @@
       kFBOClientTextureId, kFBOServiceTextureId, 0, GL_NO_ERROR);
 
   // Setup "render from" texture.
   SetupTexture();
 
   // Make sure we check for framebuffer complete.
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
       .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
       .RetiresOnSaturation();
 
-  SetupExpectationsForApplyingDirtyState(false,   // Framebuffer is RGB
-                                         false,   // Framebuffer has depth
-                                         false,   // Framebuffer has stencil
-                                         0x1111,  // color bits
-                                         false,   // depth mask
-                                         false,   // depth enabled
-                                         0,       // front stencil mask
-                                         0,       // back stencil mask
-                                         false);  // stencil enabled
+  SetupExpectationsForApplyingDirtyState(
+      false,   // Framebuffer is RGB
+      false,   // Framebuffer has depth
+      false,   // Framebuffer has stencil
+      0x1111,  // color bits
+      false,   // depth mask
+      false,   // depth enabled
+      0,       // front stencil mask
+      0,       // back stencil mask
+      false,   // stencil enabled
+      false,   // cull_face_enabled
+      false,   // scissor_test_enabled
+      false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // But not again.
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, BeginQueryEXTDisabled) {
+TEST_F(GLES2DecoderTest, BeginQueryEXTDisabled) {
   // Test something fails if off.
 }
 
-TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXT) {
+TEST_F(GLES2DecoderManualInitTest, BeginEndQueryEXT) {
   InitState init;
   init.extensions = "GL_EXT_occlusion_query_boolean";
   init.gl_version = "opengl es 2.0";
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   // Test end fails if no begin.
   EndQueryEXT end_cmd;
@@ skipping 166 matching lines @@
   if (query_type.is_gl) {
     EXPECT_CALL(*gl, DeleteQueriesARB(1, _))
         .Times(1)
         .RetiresOnSaturation();
   }
   if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM)
     EXPECT_CALL(*gl, DeleteSync(kGlSync)).Times(1).RetiresOnSaturation();
   test->ResetDecoder();
 }
 
-TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryIdFails) {
+TEST_F(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryIdFails) {
   for (size_t i = 0; i < arraysize(kQueryTypes); ++i) {
     CheckBeginEndQueryBadMemoryFails(
         this, kNewClientId, kNewServiceId,
         kQueryTypes[i],
         kInvalidSharedMemoryId, kSharedMemoryOffset);
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryOffsetFails) {
+TEST_F(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryOffsetFails) {
   for (size_t i = 0; i < arraysize(kQueryTypes); ++i) {
     // Out-of-bounds.
     CheckBeginEndQueryBadMemoryFails(
         this, kNewClientId, kNewServiceId,
         kQueryTypes[i],
         kSharedMemoryId, kInvalidSharedMemoryOffset);
     // Overflow.
     CheckBeginEndQueryBadMemoryFails(
         this, kNewClientId, kNewServiceId,
         kQueryTypes[i],
         kSharedMemoryId, 0xfffffffcu);
   }
 }
 
-TEST_P(GLES2DecoderTest, BeginEndQueryEXTCommandsIssuedCHROMIUM) {
+TEST_F(GLES2DecoderTest, BeginEndQueryEXTCommandsIssuedCHROMIUM) {
   BeginQueryEXT begin_cmd;
 
   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
 
   // Test valid parameters work.
   begin_cmd.Init(
       GL_COMMANDS_ISSUED_CHROMIUM, kNewClientId,
       kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   QueryManager* query_manager = decoder_->GetQueryManager();
   ASSERT_TRUE(query_manager != NULL);
   QueryManager::Query* query = query_manager->GetQuery(kNewClientId);
   ASSERT_TRUE(query != NULL);
   EXPECT_FALSE(query->pending());
 
   // Test end succeeds
   EndQueryEXT end_cmd;
   end_cmd.Init(GL_COMMANDS_ISSUED_CHROMIUM, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_FALSE(query->pending());
 }
 
-TEST_P(GLES2DecoderTest, BeginEndQueryEXTGetErrorQueryCHROMIUM) {
+TEST_F(GLES2DecoderTest, BeginEndQueryEXTGetErrorQueryCHROMIUM) {
   BeginQueryEXT begin_cmd;
 
   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
 
   // Test valid parameters work.
   begin_cmd.Init(
       GL_GET_ERROR_QUERY_CHROMIUM, kNewClientId,
       kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ skipping 13 matching lines @@
 
   EndQueryEXT end_cmd;
   end_cmd.Init(GL_GET_ERROR_QUERY_CHROMIUM, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_FALSE(query->pending());
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE),
             static_cast<GLenum>(sync->result));
 }
 
-TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTCommandsCompletedCHROMIUM) {
+TEST_F(GLES2DecoderManualInitTest, BeginEndQueryEXTCommandsCompletedCHROMIUM) {
   InitState init;
   init.extensions = "GL_EXT_occlusion_query_boolean GL_ARB_sync";
   init.gl_version = "opengl es 2.0";
   init.has_alpha = true;
   init.request_alpha = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
 
@@ skipping 38 matching lines @@
 
   EXPECT_TRUE(process_success);
   EXPECT_FALSE(query->pending());
   QuerySync* sync = static_cast<QuerySync*>(shared_memory_address_);
   EXPECT_EQ(static_cast<GLenum>(0), static_cast<GLenum>(sync->result));
 
   EXPECT_CALL(*gl_, DeleteSync(kGlSync)).Times(1).RetiresOnSaturation();
   ResetDecoder();
 }
 
-TEST_P(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
+TEST_F(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
   Mailbox mailbox = Mailbox::Generate();
 
   memcpy(shared_memory_address_, mailbox.name, sizeof(mailbox.name));
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   TextureRef* texture_ref = group().texture_manager()->GetTexture(
@@ skipping 62 matching lines @@
   EXPECT_EQ(2, width);
   EXPECT_EQ(4, height);
   EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &internal_format));
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
 
   // Service ID is restored.
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 }
 
-TEST_P(GLES2DecoderTest, CanChangeSurface) {
+
+TEST_F(GLES2DecoderTest, CanChangeSurface) {
   scoped_refptr<GLSurfaceMock> other_surface(new GLSurfaceMock);
   EXPECT_CALL(*other_surface.get(), GetBackingFrameBufferObject()).
       WillOnce(Return(7));
   EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER_EXT, 7));
 
   decoder_->SetSurface(other_surface);
 }
 
-TEST_P(GLES2DecoderTest, IsEnabledReturnsCachedValue) {
+TEST_F(GLES2DecoderTest, IsEnabledReturnsCachedValue) {
   // NOTE: There are no expectations because no GL functions should be
   // called for DEPTH_TEST or STENCIL_TEST
   static const GLenum kStates[] = {
     GL_DEPTH_TEST,
     GL_STENCIL_TEST,
   };
   for (size_t ii = 0; ii < arraysize(kStates); ++ii) {
     Enable enable_cmd;
     GLenum state = kStates[ii];
     enable_cmd.Init(state);
     EXPECT_EQ(error::kNoError, ExecuteCmd(enable_cmd));
     IsEnabled::Result* result =
         static_cast<IsEnabled::Result*>(shared_memory_address_);
     IsEnabled is_enabled_cmd;
     is_enabled_cmd.Init(state, shared_memory_id_, shared_memory_offset_);
     EXPECT_EQ(error::kNoError, ExecuteCmd(is_enabled_cmd));
     EXPECT_NE(0u, *result);
     Disable disable_cmd;
     disable_cmd.Init(state);
     EXPECT_EQ(error::kNoError, ExecuteCmd(disable_cmd));
     EXPECT_EQ(error::kNoError, ExecuteCmd(is_enabled_cmd));
     EXPECT_EQ(0u, *result);
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, DepthTextureBadArgs) {
+TEST_F(GLES2DecoderManualInitTest, DepthTextureBadArgs) {
   InitState init;
   init.extensions = "GL_ANGLE_depth_texture";
   init.gl_version = "opengl es 2.0";
   init.has_depth = true;
   init.has_stencil = true;
   init.request_depth = true;
   init.request_stencil = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
@@ skipping 31 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(copy_tex_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Check that trying to CopyTexSubImage2D fails
   CopyTexSubImage2D copy_sub_cmd;
   copy_sub_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(copy_sub_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, GenerateMipmapDepthTexture) {
+TEST_F(GLES2DecoderManualInitTest, GenerateMipmapDepthTexture) {
   InitState init;
   init.extensions = "GL_ANGLE_depth_texture";
   init.gl_version = "opengl es 2.0";
   init.has_depth = true;
   init.has_stencil = true;
   init.request_depth = true;
   init.request_stencil = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
                2, 2, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
                0, 0);
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_2D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, DrawClearsDepthTexture) {
+TEST_F(GLES2DecoderManualInitTest, DrawClearsDepthTexture) {
   InitState init;
   init.extensions = "GL_ANGLE_depth_texture";
   init.gl_version = "opengl es 2.0";
   init.has_alpha = true;
   init.has_depth = true;
   init.request_alpha = true;
   init.request_depth = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   SetupDefaultProgram();
   SetupAllNeededVertexBuffers();
   const GLenum attachment = GL_DEPTH_ATTACHMENT;
   const GLenum target = GL_TEXTURE_2D;
   const GLint level = 0;
   DoBindTexture(target, client_texture_id_, kServiceTextureId);
 
   // Create a depth texture.
   DoTexImage2D(target, level, GL_DEPTH_COMPONENT, 1, 1, 0,
                GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 0, 0);
 
-  // Enable GL_SCISSOR_TEST to make sure we disable it in the clear,
-  // then re-enable it.
-  DoEnableDisable(GL_SCISSOR_TEST, true);
-
   EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, _))
       .Times(1)
       .RetiresOnSaturation();
 
   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(
       GL_DRAW_FRAMEBUFFER_EXT, attachment, target, kServiceTextureId, level))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT))
       .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
       .RetiresOnSaturation();
 
   EXPECT_CALL(*gl_, ClearStencil(0))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, StencilMask(-1))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, ClearDepth(1.0f))
       .Times(1)
       .RetiresOnSaturation();
-  SetupExpectationsForDepthMask(true);
-  SetupExpectationsForEnableDisable(GL_SCISSOR_TEST, false);
+  EXPECT_CALL(*gl_, DepthMask(true))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, Disable(GL_SCISSOR_TEST))
+      .Times(1)
+      .RetiresOnSaturation();
 
   EXPECT_CALL(*gl_, Clear(GL_DEPTH_BUFFER_BIT))
       .Times(1)
       .RetiresOnSaturation();
 
-  SetupExpectationsForRestoreClearState(0.0f, 0.0f, 0.0f, 0.0f, 0, 1.0f, true);
+  SetupExpectationsForRestoreClearState(
+      0.0f, 0.0f, 0.0f, 0.0f, 0, 1.0f, false);
 
   EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0))
       .Times(1)
       .RetiresOnSaturation();
 
   SetupExpectationsForApplyingDefaultDirtyState();
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, BindUniformLocationCHROMIUM) {
+TEST_F(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_, kLocation, kSharedMemoryId, kSharedMemoryOffset,
@@ skipping 208 matching lines @@
     SetupDefaultProgram();
 
     AddExpectationsForGenVertexArraysOES();
     GenHelper<GenVertexArraysOESImmediate>(client_vertexarray_id_);
 
     vertex_array_deleted_manually_ = false;
   }
 };
 
 // Test vertex array objects with native support
-TEST_P(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESValidArgs) {
+TEST_F(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESValidArgs) {
   GenVertexArraysOESValidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest, GenVertexArraysOESValidArgs) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest, GenVertexArraysOESValidArgs) {
   GenVertexArraysOESValidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESInvalidArgs) {
+TEST_F(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESInvalidArgs) {
   GenVertexArraysOESInvalidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest, ) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest, ) {
   GenVertexArraysOESInvalidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESImmediateValidArgs) {
+TEST_F(GLES2DecoderVertexArraysOESTest, GenVertexArraysOESImmediateValidArgs) {
   GenVertexArraysOESImmediateValidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
-       GenVertexArraysOESImmediateValidArgs) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+    GenVertexArraysOESImmediateValidArgs) {
   GenVertexArraysOESImmediateValidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest,
-       GenVertexArraysOESImmediateInvalidArgs) {
+TEST_F(GLES2DecoderVertexArraysOESTest,
+    GenVertexArraysOESImmediateInvalidArgs) {
   GenVertexArraysOESImmediateInvalidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
-       GenVertexArraysOESImmediateInvalidArgs) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+    GenVertexArraysOESImmediateInvalidArgs) {
   GenVertexArraysOESImmediateInvalidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest, DeleteVertexArraysOESValidArgs) {
+TEST_F(GLES2DecoderVertexArraysOESTest, DeleteVertexArraysOESValidArgs) {
   DeleteVertexArraysOESValidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
-       DeleteVertexArraysOESValidArgs) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+    DeleteVertexArraysOESValidArgs) {
   DeleteVertexArraysOESValidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest, DeleteVertexArraysOESInvalidArgs) {
+TEST_F(GLES2DecoderVertexArraysOESTest, DeleteVertexArraysOESInvalidArgs) {
   DeleteVertexArraysOESInvalidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
-       DeleteVertexArraysOESInvalidArgs) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+    DeleteVertexArraysOESInvalidArgs) {
   DeleteVertexArraysOESInvalidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest,
-       DeleteVertexArraysOESImmediateValidArgs) {
+TEST_F(GLES2DecoderVertexArraysOESTest,
+    DeleteVertexArraysOESImmediateValidArgs) {
   DeleteVertexArraysOESImmediateValidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
-       DeleteVertexArraysOESImmediateValidArgs) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+    DeleteVertexArraysOESImmediateValidArgs) {
   DeleteVertexArraysOESImmediateValidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest,
-       DeleteVertexArraysOESImmediateInvalidArgs) {
+TEST_F(GLES2DecoderVertexArraysOESTest,
+    DeleteVertexArraysOESImmediateInvalidArgs) {
   DeleteVertexArraysOESImmediateInvalidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
-       DeleteVertexArraysOESImmediateInvalidArgs) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+    DeleteVertexArraysOESImmediateInvalidArgs) {
   DeleteVertexArraysOESImmediateInvalidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest,
+TEST_F(GLES2DecoderVertexArraysOESTest,
        DeleteBoundVertexArraysOESImmediateValidArgs) {
   DeleteBoundVertexArraysOESImmediateValidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
        DeleteBoundVertexArraysOESImmediateValidArgs) {
   DeleteBoundVertexArraysOESImmediateValidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest, IsVertexArrayOESValidArgs) {
+TEST_F(GLES2DecoderVertexArraysOESTest, IsVertexArrayOESValidArgs) {
   IsVertexArrayOESValidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest, IsVertexArrayOESValidArgs) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest, IsVertexArrayOESValidArgs) {
   IsVertexArrayOESValidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest,
-       IsVertexArrayOESInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderVertexArraysOESTest,
+    IsVertexArrayOESInvalidArgsBadSharedMemoryId) {
   IsVertexArrayOESInvalidArgsBadSharedMemoryId();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
-       IsVertexArrayOESInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+    IsVertexArrayOESInvalidArgsBadSharedMemoryId) {
   IsVertexArrayOESInvalidArgsBadSharedMemoryId();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest, BindVertexArrayOESValidArgs) {
+TEST_F(GLES2DecoderVertexArraysOESTest, BindVertexArrayOESValidArgs) {
   BindVertexArrayOESValidArgs();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest, BindVertexArrayOESValidArgs) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest, BindVertexArrayOESValidArgs) {
   BindVertexArrayOESValidArgs();
 }
 
-TEST_P(GLES2DecoderVertexArraysOESTest, BindVertexArrayOESValidArgsNewId) {
+TEST_F(GLES2DecoderVertexArraysOESTest, BindVertexArrayOESValidArgsNewId) {
   BindVertexArrayOESValidArgsNewId();
 }
-TEST_P(GLES2DecoderEmulatedVertexArraysOESTest,
-       BindVertexArrayOESValidArgsNewId) {
+TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
+    BindVertexArrayOESValidArgsNewId) {
   BindVertexArrayOESValidArgsNewId();
 }
 
-TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUM) {
+TEST_F(GLES2DecoderTest, BindTexImage2DCHROMIUM) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   TextureRef* texture_ref = group().texture_manager()->GetTexture(
       client_texture_id_);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   group().image_manager()->AddImage(gfx::GLImage::CreateGLImage(0).get(), 1);
@@ skipping 26 matching lines @@
   EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
 
   // Define new texture image.
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
   // Image should no longer be set.
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
 }
 
-TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUMCubeMapNotAllowed) {
+TEST_F(GLES2DecoderTest, BindTexImage2DCHROMIUMCubeMapNotAllowed) {
   group().image_manager()->AddImage(gfx::GLImage::CreateGLImage(0).get(), 1);
   DoBindTexture(GL_TEXTURE_CUBE_MAP, client_texture_id_, kServiceTextureId);
 
   BindTexImage2DCHROMIUM bind_tex_image_2d_cmd;
   bind_tex_image_2d_cmd.Init(GL_TEXTURE_CUBE_MAP, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(bind_tex_image_2d_cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, OrphanGLImageWithTexImage2D) {
+TEST_F(GLES2DecoderTest, OrphanGLImageWithTexImage2D) {
   group().image_manager()->AddImage(gfx::GLImage::CreateGLImage(0).get(), 1);
   DoBindTexture(GL_TEXTURE_CUBE_MAP, client_texture_id_, kServiceTextureId);
 
   BindTexImage2DCHROMIUM bind_tex_image_2d_cmd;
   bind_tex_image_2d_cmd.Init(GL_TEXTURE_CUBE_MAP, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(bind_tex_image_2d_cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   TextureRef* texture_ref = group().texture_manager()->GetTexture(
       client_texture_id_);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
 }
 
-TEST_P(GLES2DecoderTest, ReleaseTexImage2DCHROMIUM) {
+TEST_F(GLES2DecoderTest, ReleaseTexImage2DCHROMIUM) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   TextureRef* texture_ref = group().texture_manager()->GetTexture(
       client_texture_id_);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   group().image_manager()->AddImage(gfx::GLImage::CreateGLImage(0).get(), 1);
@@ skipping 50 matching lines @@
   MOCK_METHOD1(ReleaseTexImage, void(unsigned));
   MOCK_METHOD0(WillUseTexImage, void());
   MOCK_METHOD0(DidUseTexImage, void());
   MOCK_METHOD0(WillModifyTexImage, void());
   MOCK_METHOD0(DidModifyTexImage, void());
 
  protected:
   virtual ~MockGLImage() {}
 };
 
-TEST_P(GLES2DecoderWithShaderTest, UseTexImage) {
+TEST_F(GLES2DecoderWithShaderTest, UseTexImage) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                kSharedMemoryId, kSharedMemoryOffset);
 
   TextureRef* texture_ref = group().texture_manager()->GetTexture(
       client_texture_id_);
   ASSERT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_EQ(kServiceTextureId, texture->service_id());
 
@@ skipping 103 matching lines @@
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   FramebufferRenderbuffer fbrb_cmd;
   fbrb_cmd.Init(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
       client_renderbuffer_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(fbrb_cmd));
 }
 
-TEST_P(GLES2DecoderManualInitTest, DrawWithGLImageExternal) {
+TEST_F(GLES2DecoderManualInitTest, DrawWithGLImageExternal) {
   InitState init;
   init.extensions = "GL_OES_EGL_image_external";
   init.gl_version = "opengl es 2.0";
   init.has_alpha = true;
   init.has_depth = true;
   init.request_alpha = true;
   init.request_depth = true;
   init.bind_generates_resource = true;
   InitDecoder(init);
 
@@ skipping 53 matching lines @@
   EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
       .Times(1)
       .RetiresOnSaturation();
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, GpuMemoryManagerCHROMIUM) {
+TEST_F(GLES2DecoderManualInitTest, GpuMemoryManagerCHROMIUM) {
   InitState init;
   init.extensions = "GL_ARB_texture_rectangle";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
   EXPECT_TRUE(texture != NULL);
   EXPECT_TRUE(texture->pool() == GL_TEXTURE_POOL_UNMANAGED_CHROMIUM);
 
@@ skipping 15 matching lines @@
 
   EXPECT_TRUE(texture->pool() == GL_TEXTURE_POOL_MANAGED_CHROMIUM);
 
   cmd.Init(GL_TEXTURE_2D,
            GL_TEXTURE_POOL_CHROMIUM,
            GL_NONE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
+TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
   InitState init;
   init.extensions = "GL_CHROMIUM_async_pixel_transfers";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   // Set up the texture.
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureRef* texture_ref = GetTexture(client_texture_id_);
   Texture* texture = texture_ref->texture();
@@ skipping 226 matching lines @@
     EXPECT_EQ(error::kNoError, ExecuteCmd(wait_all_cmd));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
   }
 
   // Remove PixelTransferManager before the decoder destroys.
   EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
   decoder_->ResetAsyncPixelTransferManagerForTest();
   manager = NULL;
 }
 
-TEST_P(GLES2DecoderManualInitTest, AsyncPixelTransferManager) {
+TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransferManager) {
   InitState init;
   init.extensions = "GL_CHROMIUM_async_pixel_transfers";
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   // Set up the texture.
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureRef* texture_ref = GetTexture(client_texture_id_);
 
@@ skipping 83 matching lines @@
           size(0) {
     }
     size_t initial_size;
     size_t size;
   };
   std::map<Pool, PoolInfo> pool_infos_;
 };
 
 }  // anonymous namespace.
 
-TEST_P(GLES2DecoderManualInitTest, MemoryTrackerInitialSize) {
+TEST_F(GLES2DecoderManualInitTest, MemoryTrackerInitialSize) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   // Expect that initial size - size is 0.
   EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
   EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kManaged));
 }
 
-TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexImage2D) {
+TEST_F(GLES2DecoderManualInitTest, MemoryTrackerTexImage2D) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(true)).RetiresOnSaturation();
@@ skipping 10 matching lines @@
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(64))
       .WillOnce(Return(false)).RetiresOnSaturation();
   TexImage2D cmd;
   cmd.Init(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE,
            kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_EQ(64u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
 }
 
-TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexStorage2DEXT) {
+TEST_F(GLES2DecoderManualInitTest, MemoryTrackerTexStorage2DEXT) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   // Check we get out of memory and no call to glTexStorage2DEXT
   // if Ensure fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(false)).RetiresOnSaturation();
   TexStorage2DEXT cmd;
   cmd.Init(GL_TEXTURE_2D, 1, GL_RGBA8, 8, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, MemoryTrackerCopyTexImage2D) {
+TEST_F(GLES2DecoderManualInitTest, MemoryTrackerCopyTexImage2D) {
   GLenum target = GL_TEXTURE_2D;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 4;
   GLsizei height = 8;
   GLint border = 0;
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
   InitState init;
@@ skipping 19 matching lines @@
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   // Check we get out of memory and no call to glCopyTexImage2D if Ensure fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(false)).RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
 }
 
-TEST_P(GLES2DecoderManualInitTest, MemoryTrackerRenderbufferStorage) {
+TEST_F(GLES2DecoderManualInitTest, MemoryTrackerRenderbufferStorage) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   EXPECT_CALL(*gl_, GetError())
@@ skipping 13 matching lines @@
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
   // Check we get out of memory and no call to glRenderbufferStorage if Ensure
   // fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(false)).RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
 }
 
-TEST_P(GLES2DecoderManualInitTest, MemoryTrackerBufferData) {
+TEST_F(GLES2DecoderManualInitTest, MemoryTrackerBufferData) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_,
                kServiceBufferId);
   EXPECT_CALL(*gl_, GetError())
@@ skipping 12 matching lines @@
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kManaged));
   // Check we get out of memory and no call to glBufferData if Ensure
   // fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(false)).RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kManaged));
 }
 
-TEST_P(GLES2DecoderTest, DrawBuffersEXTImmediateSuccceeds) {
+TEST_F(GLES2DecoderTest, DrawBuffersEXTImmediateSuccceeds) {
   const GLsizei count = 1;
   const GLenum bufs[] = { GL_COLOR_ATTACHMENT0 };
   DrawBuffersEXTImmediate& cmd =
       *GetImmediateAs<DrawBuffersEXTImmediate>();
   cmd.Init(count, bufs);
 
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   EXPECT_CALL(*gl_, DrawBuffersARB(count, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(bufs)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, DrawBuffersEXTImmediateFails) {
+TEST_F(GLES2DecoderTest, DrawBuffersEXTImmediateFails) {
   const GLsizei count = 1;
   const GLenum bufs[] = { GL_COLOR_ATTACHMENT1_EXT };
   DrawBuffersEXTImmediate& cmd =
       *GetImmediateAs<DrawBuffersEXTImmediate>();
   cmd.Init(count, bufs);
 
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(bufs)));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, DrawBuffersEXTImmediateBackbuffer) {
+TEST_F(GLES2DecoderTest, DrawBuffersEXTImmediateBackbuffer) {
   const GLsizei count = 1;
   const GLenum bufs[] = { GL_BACK };
   DrawBuffersEXTImmediate& cmd =
       *GetImmediateAs<DrawBuffersEXTImmediate>();
   cmd.Init(count, bufs);
 
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(bufs)));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   DoBindFramebuffer(GL_FRAMEBUFFER, 0, 0);  // unbind
 
   EXPECT_CALL(*gl_, DrawBuffersARB(count, _))
       .Times(1)
       .RetiresOnSaturation();
 
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(bufs)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, InvalidateFramebufferBinding) {
+TEST_F(GLES2DecoderManualInitTest, InvalidateFramebufferBinding) {
   InitState init;
   init.gl_version = "opengl es 3.0";
   InitDecoder(init);
 
   // EXPECT_EQ can't be used to compare function pointers
   EXPECT_TRUE(
       gfx::MockGLInterface::GetGLProcAddress("glInvalidateFramebuffer") ==
       gfx::g_driver_gl.fn.glDiscardFramebufferEXTFn);
   EXPECT_TRUE(
       gfx::MockGLInterface::GetGLProcAddress("glInvalidateFramebuffer") !=
       gfx::MockGLInterface::GetGLProcAddress("glDiscardFramebufferEXT"));
 }
 
-TEST_P(GLES2DecoderManualInitTest, DiscardFramebufferEXT) {
+TEST_F(GLES2DecoderManualInitTest, DiscardFramebufferEXT) {
   InitState init;
   init.extensions = "GL_EXT_discard_framebuffer";
   init.gl_version = "opengl es 2.0";
   InitDecoder(init);
 
   // EXPECT_EQ can't be used to compare function pointers
   EXPECT_TRUE(
       gfx::MockGLInterface::GetGLProcAddress("glDiscardFramebufferEXT") ==
       gfx::g_driver_gl.fn.glDiscardFramebufferEXTFn);
 
@@ skipping 22 matching lines @@
   DiscardFramebufferEXTImmediate& cmd =
       *GetImmediateAs<DiscardFramebufferEXTImmediate>();
   cmd.Init(target, count, attachments);
 
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(attachments)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_FALSE(framebuffer->IsCleared());
 }
 
-TEST_P(GLES2DecoderTest, DiscardFramebufferEXTUnsupported) {
+TEST_F(GLES2DecoderTest, DiscardFramebufferEXTUnsupported) {
   const GLenum target = GL_FRAMEBUFFER;
   const GLsizei count = 1;
   const GLenum attachments[] = { GL_COLOR_EXT };
   DiscardFramebufferEXTImmediate& cmd =
       *GetImmediateAs<DiscardFramebufferEXTImmediate>();
   cmd.Init(target, count, attachments);
 
   // Should not result into a call into GL.
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(attachments)));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, NullPreviousStateBGR) {
+TEST_F(GLES2DecoderRestoreStateTest, NullPreviousStateBGR) {
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   SetupTexture();
 
   InSequence sequence;
   // Expect to restore texture bindings for unit GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
   AddExpectationsForBindTexture(GL_TEXTURE_CUBE_MAP,
                                 TestHelper::kServiceDefaultTextureCubemapId);
 
   // Expect to restore texture bindings for remaining units.
   for (uint32 i = 1; i < group().max_texture_units() ; ++i) {
     AddExpectationsForActiveTexture(GL_TEXTURE0 + i);
     AddExpectationsForBindTexture(GL_TEXTURE_2D,
                                   TestHelper::kServiceDefaultTexture2dId);
     AddExpectationsForBindTexture(GL_TEXTURE_CUBE_MAP,
                                   TestHelper::kServiceDefaultTextureCubemapId);
   }
 
   // Expect to restore the active texture unit to GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
 
   GetDecoder()->RestoreAllTextureUnitBindings(NULL);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, NullPreviousState) {
+TEST_F(GLES2DecoderRestoreStateTest, NullPreviousState) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
   SetupTexture();
 
   InSequence sequence;
   // Expect to restore texture bindings for unit GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
   AddExpectationsForBindTexture(GL_TEXTURE_CUBE_MAP, 0);
 
   // Expect to restore texture bindings for remaining units.
   for (uint32 i = 1; i < group().max_texture_units(); ++i) {
     AddExpectationsForActiveTexture(GL_TEXTURE0 + i);
     AddExpectationsForBindTexture(GL_TEXTURE_2D, 0);
     AddExpectationsForBindTexture(GL_TEXTURE_CUBE_MAP, 0);
   }
 
   // Expect to restore the active texture unit to GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
 
   GetDecoder()->RestoreAllTextureUnitBindings(NULL);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, WithPreviousStateBGR) {
+TEST_F(GLES2DecoderRestoreStateTest, WithPreviousStateBGR) {
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
   SetupTexture();
 
   // Construct a previous ContextState with all texture bindings
   // set to default textures.
   ContextState prev_state(NULL, NULL, NULL);
   InitializeContextState(&prev_state, std::numeric_limits<uint32>::max(), 0);
 
   InSequence sequence;
   // Expect to restore only GL_TEXTURE_2D binding for GL_TEXTURE0 unit,
   // since the rest of the bindings haven't changed between the current
   // state and the |prev_state|.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
 
   // Expect to restore active texture unit to GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
 
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, WithPreviousState) {
+TEST_F(GLES2DecoderRestoreStateTest, WithPreviousState) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
   SetupTexture();
 
   // Construct a previous ContextState with all texture bindings
   // set to default textures.
   ContextState prev_state(NULL, NULL, NULL);
   InitializeContextState(&prev_state, std::numeric_limits<uint32>::max(), 0);
 
   InSequence sequence;
   // Expect to restore only GL_TEXTURE_2D binding for GL_TEXTURE0 unit,
   // since the rest of the bindings haven't changed between the current
   // state and the |prev_state|.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
 
   // Expect to restore active texture unit to GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
 
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, ActiveUnit1) {
+TEST_F(GLES2DecoderRestoreStateTest, ActiveUnit1) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   // Bind a non-default texture to GL_TEXTURE1 unit.
   EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE1));
   ActiveTexture cmd;
   cmd.Init(GL_TEXTURE1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ skipping 10 matching lines @@
   // state and the |prev_state|.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
 
   // Expect to restore active texture unit to GL_TEXTURE1.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
 
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, NonDefaultUnit0BGR) {
+TEST_F(GLES2DecoderRestoreStateTest, NonDefaultUnit0BGR) {
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   // Bind a non-default texture to GL_TEXTURE1 unit.
   EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE1));
   SpecializedSetup<ActiveTexture, 0>(true);
   ActiveTexture cmd;
   cmd.Init(GL_TEXTURE1);
@@ skipping 18 matching lines @@
   // non-default.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
 
   // Expect to restore active texture unit to GL_TEXTURE1.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
 
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, NonDefaultUnit1BGR) {
+TEST_F(GLES2DecoderRestoreStateTest, NonDefaultUnit1BGR) {
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   // Bind a non-default texture to GL_TEXTURE0 unit.
   SetupTexture();
 
   // Construct a previous ContextState with GL_TEXTURE_2D target in
   // GL_TEXTURE1 unit bound to a non-default texture and the rest
@@ skipping 12 matching lines @@
   AddExpectationsForActiveTexture(GL_TEXTURE1);
   AddExpectationsForBindTexture(GL_TEXTURE_2D,
                                 TestHelper::kServiceDefaultTexture2dId);
 
   // Expect to restore active texture unit to GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
 
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, DefaultUnit0) {
+TEST_F(GLES2DecoderRestoreStateTest, DefaultUnit0) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   // Bind a non-default texture to GL_TEXTURE1 unit.
   EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE1));
   SpecializedSetup<ActiveTexture, 0>(true);
   ActiveTexture cmd;
   cmd.Init(GL_TEXTURE1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ skipping 16 matching lines @@
   // non-default.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
 
   // Expect to restore active texture unit to GL_TEXTURE1.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
 
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, DefaultUnit1) {
+TEST_F(GLES2DecoderRestoreStateTest, DefaultUnit1) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
 
   // Bind a non-default texture to GL_TEXTURE0 unit.
   SetupTexture();
 
   // Construct a previous ContextState with GL_TEXTURE_2D target in
   // GL_TEXTURE1 unit bound to a non-default texture and the rest
   // set to default textures.
@@ skipping 24 matching lines @@
 // TODO(vmiura): Tests for ContextState::RestoreBufferBindings().
 
 // TODO(vmiura): Tests for ContextState::RestoreProgramBindings().
 
 // TODO(vmiura): Tests for RestoreRenderbufferBindings().
 
 // TODO(vmiura): Tests for RestoreProgramBindings().
 
 // TODO(vmiura): Tests for RestoreGlobalState().
 
-TEST_P(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) {
+TEST_F(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 25 matching lines @@
   {
     EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
         .Times(1)
         .RetiresOnSaturation();
     cmds::UseProgram cmd;
     cmd.Init(client_program_id_);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES2) {
+TEST_F(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES2) {
   InitState init;
   init.extensions = "GL_OES_texture_float";
   init.gl_version = "opengl es 2.0";
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0, GL_RGBA, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 16, 17, 0, GL_RGB, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 17, 0, GL_LUMINANCE,
                GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 17, 0, GL_ALPHA, GL_FLOAT,
                0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 16, 17, 0,
                GL_LUMINANCE_ALPHA, GL_FLOAT, 0, 0);
 }
 
-TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES3) {
+TEST_F(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES3) {
   InitState init;
   init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
   init.gl_version = "opengl es 3.0";
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0, GL_RGBA, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 16, 17, 0, GL_RGB, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 16, 17, 0, GL_RGBA, GL_FLOAT, 0,
                0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 17, 0, GL_LUMINANCE,
                GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 17, 0, GL_ALPHA, GL_FLOAT,
                0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 16, 17, 0,
                GL_LUMINANCE_ALPHA, GL_FLOAT, 0, 0);
 }
 
-TEST_P(GLES2DecoderManualInitTest, TexSubImage2DFloatOnGLES3) {
+TEST_F(GLES2DecoderManualInitTest, TexSubImage2DFloatOnGLES3) {
   InitState init;
   init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
   init.gl_version = "opengl es 3.0";
   InitDecoder(init);
   const int kWidth = 8;
   const int kHeight = 4;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, kWidth, kHeight, 0, GL_RGBA,
                GL_FLOAT, 0, 0);
   EXPECT_CALL(*gl_, TexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA32F, kWidth, kHeight, 0, GL_RGBA, GL_FLOAT,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   TexSubImage2D cmd;
   cmd.Init(
       GL_TEXTURE_2D, 0, 0, 0, kWidth, kHeight, GL_RGBA, GL_FLOAT,
       kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, TexSubImage2DFloatDoesClearOnGLES3) {
+TEST_F(GLES2DecoderManualInitTest, TexSubImage2DFloatDoesClearOnGLES3) {
   InitState init;
   init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
   init.gl_version = "opengl es 3.0";
   InitDecoder(init);
   const int kWidth = 8;
   const int kHeight = 4;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, kWidth, kHeight, 0, GL_RGBA,
                GL_FLOAT, 0, 0);
   SetupClearTextureExpectations(
       kServiceTextureId, kServiceTextureId, GL_TEXTURE_2D, GL_TEXTURE_2D,
       0, GL_RGBA32F, GL_RGBA, GL_FLOAT, kWidth, kHeight);
   EXPECT_CALL(*gl_, TexSubImage2D(
       GL_TEXTURE_2D, 0, 1, 0, kWidth - 1, kHeight, GL_RGBA, GL_FLOAT,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   TexSubImage2D cmd;
   cmd.Init(
       GL_TEXTURE_2D, 0, 1, 0, kWidth - 1, kHeight, GL_RGBA, GL_FLOAT,
       kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatConvertsFormatDesktop) {
+TEST_F(GLES2DecoderManualInitTest, TexImage2DFloatConvertsFormatDesktop) {
   InitState init;
   init.extensions = "GL_ARB_texture_float";
   init.gl_version = "2.1";
   InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 16, 17, 0, GL_RGBA, GL_FLOAT, 0,
                0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, 16, 17, 0, GL_RGB, GL_FLOAT, 0, 0);
   DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0,
                                     GL_RGBA, GL_FLOAT, 0, 0, GL_RGBA32F_ARB);
   DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D, 0, GL_RGB, 16, 17, 0,
                                     GL_RGB, GL_FLOAT, 0, 0, GL_RGB32F_ARB);
   DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 17, 0,
                                     GL_LUMINANCE, GL_FLOAT, 0, 0,
                                     GL_LUMINANCE32F_ARB);
   DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 17, 0,
                                     GL_ALPHA, GL_FLOAT, 0, 0, GL_ALPHA32F_ARB);
   DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 16,
                                     17, 0, GL_LUMINANCE_ALPHA, GL_FLOAT, 0, 0,
                                     GL_LUMINANCE_ALPHA32F_ARB);
 }
 
-TEST_P(GLES2DecoderManualInitTest, ReadFormatExtension) {
+TEST_F(GLES2DecoderManualInitTest, ReadFormatExtension) {
   InitState init;
   init.extensions = "GL_OES_read_format";
   init.gl_version = "2.1";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ skipping 41 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   cmd.Init(
       GL_IMPLEMENTATION_COLOR_READ_TYPE,
       shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(1, result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoReadFormatExtension) {
+TEST_F(GLES2DecoderManualInitTest, NoReadFormatExtension) {
   InitState init;
   init.gl_version = "2.1";
   init.bind_generates_resource = true;
   InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ skipping 37 matching lines @@
       .Times(0)
       .RetiresOnSaturation();
   cmd.Init(
       GL_IMPLEMENTATION_COLOR_READ_TYPE,
       shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(1, result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, ContextStateCapabilityCaching) {
-  struct TestInfo {
-    GLenum gl_enum;
-    bool default_state;
-    bool expect_set;
-  };
-
-  // TODO(vmiura): Should autogen this to match build_gles2_cmd_buffer.py.
-  TestInfo test[] = {{GL_BLEND, false, true},
-                     {GL_CULL_FACE, false, true},
-                     {GL_DEPTH_TEST, false, false},
-                     {GL_DITHER, true, true},
-                     {GL_POLYGON_OFFSET_FILL, false, true},
-                     {GL_SAMPLE_ALPHA_TO_COVERAGE, false, true},
-                     {GL_SAMPLE_COVERAGE, false, true},
-                     {GL_SCISSOR_TEST, false, true},
-                     {GL_STENCIL_TEST, false, false},
-                     {0, false, false}};
-
-  InitState init;
-  init.gl_version = "2.1";
-  InitDecoder(init);
-
-  for (int i = 0; test[i].gl_enum; i++) {
-    bool enable_state = test[i].default_state;
-
-    // Test setting default state initially is ignored.
-    EnableDisableTest(test[i].gl_enum, enable_state, test[i].expect_set);
-
-    // Test new and cached state changes.
-    for (int n = 0; n < 3; n++) {
-      enable_state = !enable_state;
-      EnableDisableTest(test[i].gl_enum, enable_state, test[i].expect_set);
-      EnableDisableTest(test[i].gl_enum, enable_state, test[i].expect_set);
-    }
-  }
-}
-
 // TODO(gman): Complete this test.
-// TEST_P(GLES2DecoderTest, CompressedTexImage2DGLError) {
+// TEST_F(GLES2DecoderTest, CompressedTexImage2DGLError) {
 // }
 
 // TODO(gman): BufferData
 
 // TODO(gman): BufferDataImmediate
 
 // TODO(gman): BufferSubData
 
 // TODO(gman): BufferSubDataImmediate
 
@@ skipping 12 matching lines @@
 // TODO(gman): TexImage2D
 
 // TODO(gman): TexImage2DImmediate
 
 // TODO(gman): TexSubImage2DImmediate
 
 // TODO(gman): UseProgram
 
 // TODO(gman): SwapBuffers
 
-INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest, ::testing::Bool());
-
-INSTANTIATE_TEST_CASE_P(Service,
-                        GLES2DecoderGeometryInstancingTest,
-                        ::testing::Bool());
-
-INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderWithShaderTest, ::testing::Bool());
-
-INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderManualInitTest, ::testing::Bool());
-
-INSTANTIATE_TEST_CASE_P(Service,
-                        GLES2DecoderCompressedFormatsTest,
-                        ::testing::Bool());
-
-INSTANTIATE_TEST_CASE_P(Service,
-                        GLES2DecoderRGBBackbufferTest,
-                        ::testing::Bool());
-
-INSTANTIATE_TEST_CASE_P(Service,
-                        GLES2DecoderVertexArraysOESTest,
-                        ::testing::Bool());
-
-INSTANTIATE_TEST_CASE_P(Service,
-                        GLES2DecoderEmulatedVertexArraysOESTest,
-                        ::testing::Bool());
-
-INSTANTIATE_TEST_CASE_P(Service,
-                        GLES2DecoderRestoreStateTest,
-                        ::testing::Bool());
-
-INSTANTIATE_TEST_CASE_P(Service,
-                        GLES2DecoderMultisampledRenderToTextureTest,
-                        ::testing::Bool());
-
 }  // namespace gles2
 }  // namespace gpu