Revert of Optimize GLES2DecoderImpl::ApplyDirtyState. (https://codereview.chromium.org/245923008/)

Reason for revert:
Failing compile on win64 debug waterfall bot

gpu\command_buffer\service\gles2_cmd_decoder_unittest.cc : fatalerror C1128: number of sections exceeded object file format limit : compile with /bigobj

link: http://build.chromium.org/p/chromium.win/builders/Win%20x64%20Builder%20%28dbg%29/builds/7743

Original issue's description:
> Optimize GLES2DecoderImpl::ApplyDirtyState.
> 
> ApplyDirtyState can on average 30% of the time of GLES2
> draw calls.  It previously set Color, Depth, Stencil masks
> and several enables without checking if they changed.
> 
> This change caches values used in ApplyDirtyState among
> other places, and adds ContextState methods for setting
> state with cache checks.
> 
> New cached state aware Set methods:
>  * ContextState::SetDeviceCapabilityState
>  * ContextState::SetDeviceColorMask
>  * ContextState::SetDeviceDepthMask
>  * ContextState::SetDeviceStencilMaskSeparate
> 
> Testing:
>  * gpu_unit tests now run both with cache on and off (ignore_cached_state_for_test = true)
>    to validate behavior independent of cache layering.
>  * New tests specific for caching behavior:
>  ** GLES2DecoderManualInitTest.ContextStateCapabilityCaching
>  ** GLES2DecoderManualInitTest.CachedColorMask
>  ** GLES2DecoderManualInitTest.CachedDepthMask
>  ** GLES2DecoderManualInitTest.CachedStencilMask
> 
> BUG=347364
> 
> Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=267450

TBR=piman@chromium.org,jbates@chromium.org,oetuaho@nvidia.com,vmiura@chromium.org
NOTREECHECKS=true
NOTRY=true
BUG=347364

Review URL: https://codereview.chromium.org/262793002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@267465 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 1191 insertions, 1821 deletions

diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index a3e1674..7105edf 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -78,7 +78,8 @@ _CAPABILITY_FLAGS = [
   {'name': 'polygon_offset_fill'},
   {'name': 'sample_alpha_to_coverage'},
   {'name': 'sample_coverage'},
-  {'name': 'scissor_test'},
+  {'name': 'scissor_test',
+   'state_flag': 'framebuffer_state_.clear_state_dirty'},
   {'name': 'stencil_test',
    'state_flag': 'framebuffer_state_.clear_state_dirty'},
 ]
@@ -108,30 +109,10 @@ _STATES = {
     'func': 'ColorMask',
     'enum': 'GL_COLOR_WRITEMASK',
     'states': [
-      {
-        'name': 'color_mask_red',
-        'type': 'GLboolean',
-        'default': 'true',
-        'cached': True
-      },
-      {
-        'name': 'color_mask_green',
-        'type': 'GLboolean',
-        'default': 'true',
-        'cached': True
-      },
-      {
-        'name': 'color_mask_blue',
-        'type': 'GLboolean',
-        'default': 'true',
-        'cached': True
-      },
-      {
-        'name': 'color_mask_alpha',
-        'type': 'GLboolean',
-        'default': 'true',
-        'cached': True
-      },
+      {'name': 'color_mask_red', 'type': 'GLboolean', 'default': 'true'},
+      {'name': 'color_mask_green', 'type': 'GLboolean', 'default': 'true'},
+      {'name': 'color_mask_blue', 'type': 'GLboolean', 'default': 'true'},
+      {'name': 'color_mask_alpha', 'type': 'GLboolean', 'default': 'true'},
     ],
     'state_flag': 'framebuffer_state_.clear_state_dirty',
   },
@@ -281,14 +262,12 @@ _STATES = {
         'type': 'GLuint',
         'enum': 'GL_STENCIL_WRITEMASK',
         'default': '0xFFFFFFFFU',
-        'cached': True,
       },
       {
         'name': 'stencil_back_writemask',
         'type': 'GLuint',
         'enum': 'GL_STENCIL_BACK_WRITEMASK',
         'default': '0xFFFFFFFFU',
-        'cached': True,
       },
     ],
   },
@@ -432,12 +411,7 @@ _STATES = {
     'func': 'DepthMask',
     'enum': 'GL_DEPTH_WRITEMASK',
     'states': [
-      {
-        'name': 'depth_mask',
-        'type': 'GLboolean',
-        'default': 'true',
-        'cached': True
-      },
+      {'name': 'depth_mask', 'type': 'GLboolean', 'default': 'true'},
     ],
     'state_flag': 'framebuffer_state_.clear_state_dirty',
   },
@@ -2622,11 +2596,6 @@ def ToUnderscore(input_string):
   words = SplitWords(input_string)
   return Lower(words)
 
-def CachedStateName(item):
-  if item.get('cached', False):
-    return 'cached_' + item['name']
-  return item['name']
-
 
 class CWriter(object):
   """Writes to a file formatting it for Google's style guidelines."""
@@ -2984,32 +2953,8 @@ COMPILE_ASSERT(offsetof(%(cmd_name)s::Result, %(field_name)s) == %(offset)d,
 
   def WriteServiceUnitTest(self, func, file):
     """Writes the service unit test for a command."""
-
-    if func.name == 'Enable':
-      valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
-  SetupExpectationsForEnableDisable(%(gl_args)s, true);
-  SpecializedSetup<cmds::%(name)s, 0>(true);
-  cmds::%(name)s cmd;
-  cmd.Init(%(args)s);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-"""
-    elif func.name == 'Disable':
-      valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
-  SetupExpectationsForEnableDisable(%(gl_args)s, false);
-  SpecializedSetup<cmds::%(name)s, 0>(true);
-  cmds::%(name)s cmd;
-  cmd.Init(%(args)s);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-"""
-    else:
-      valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+    valid_test = """
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
@@ -3021,7 +2966,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
     self.WriteValidUnitTest(func, file, valid_test)
 
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
@@ -3293,10 +3238,6 @@ class StateSetHandler(TypeHandler):
     if 'state_flag' in state:
       file.Write("    %s = true;\n" % state['state_flag'])
     if not func.GetInfo("no_gl"):
-      for ndx,item in enumerate(states):
-        if item.get('cached', False):
-          file.Write("    state_.%s = %s;\n" %
-                     (CachedStateName(item), args[ndx].name))
       file.Write("    %s(%s);\n" %
                  (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
     file.Write("  }\n")
@@ -3311,7 +3252,7 @@ class StateSetHandler(TypeHandler):
       if 'range_checks' in item:
         for check_ndx, range_check in enumerate(item['range_checks']):
           valid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidValue%(ndx)d_%(check_ndx)d) {
+TEST_F(%(test_name)s, %(name)sInvalidValue%(ndx)d_%(check_ndx)d) {
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
@@ -3783,7 +3724,7 @@ class BindHandler(TypeHandler):
 
     if len(func.GetOriginalArgs()) == 1:
       valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
@@ -3794,7 +3735,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
 """
       if func.GetInfo("gen_func"):
           valid_test += """
-TEST_P(%(test_name)s, %(name)sValidArgsNewId) {
+TEST_F(%(test_name)s, %(name)sValidArgsNewId) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(kNewServiceId));
   EXPECT_CALL(*gl_, %(gl_gen_func_name)s(1, _))
      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
@@ -3812,7 +3753,7 @@ TEST_P(%(test_name)s, %(name)sValidArgsNewId) {
       })
     else:
       valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
@@ -3823,7 +3764,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
 """
       if func.GetInfo("gen_func"):
           valid_test += """
-TEST_P(%(test_name)s, %(name)sValidArgsNewId) {
+TEST_F(%(test_name)s, %(name)sValidArgsNewId) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(first_gl_arg)s, kNewServiceId));
   EXPECT_CALL(*gl_, %(gl_gen_func_name)s(1, _))
      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
@@ -3843,7 +3784,7 @@ TEST_P(%(test_name)s, %(name)sValidArgsNewId) {
       })
 
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
@@ -4030,7 +3971,7 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
@@ -4046,7 +3987,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
         'resource_name': func.GetInfo('resource_type'),
       })
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
   GetSharedMemoryAs<GLuint*>()[0] = client_%(resource_name)s_id_;
   SpecializedSetup<cmds::%(name)s, 0>(false);
@@ -4062,7 +4003,7 @@ TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   def WriteImmediateServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   cmds::%(name)s* cmd = GetImmediateAs<cmds::%(name)s>();
@@ -4079,7 +4020,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
         'resource_name': func.GetInfo('resource_type'),
       })
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
   cmds::%(name)s* cmd = GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(false);
@@ -4196,7 +4137,7 @@ class CreateHandler(TypeHandler):
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s))
       .WillOnce(Return(kNewServiceId));
   SpecializedSetup<cmds::%(name)s, 0>(true);
@@ -4215,7 +4156,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
           'resource_type': func.name[6:],
         })
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
@@ -4327,7 +4268,7 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(1, Pointee(kService%(upper_resource_name)sId)))
@@ -4347,7 +4288,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
           'upper_resource_name': func.GetInfo('resource_type'),
         })
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs) {
   GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
@@ -4360,7 +4301,7 @@ TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   def WriteImmediateServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(1, Pointee(kService%(upper_resource_name)sId)))
@@ -4380,7 +4321,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
           'upper_resource_name': func.GetInfo('resource_type'),
         })
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(false);
   GLuint temp = kInvalidClientId;
@@ -4676,7 +4617,7 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ -4713,7 +4654,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
       })
 
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s::Result* result =
@@ -4745,7 +4686,7 @@ class PUTHandler(TypeHandler):
       expected_call = ("EXPECT_CALL(*gl_, %%(gl_func_name)s(%s));" %
           ", ".join(gl_arg_strings))
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
@@ -4763,7 +4704,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
@@ -4777,7 +4718,7 @@ TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   def WriteImmediateServiceUnitTest(self, func, file):
     """Writes the service unit test for a command."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(true);
   %(data_type)s temp[%(data_count)s] = { %(data_value)s, };
@@ -4807,7 +4748,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_any_args)s, _)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
@@ -5008,7 +4949,7 @@ class PUTnHandler(TypeHandler):
     TypeHandler.WriteServiceUnitTest(self, func, file)
 
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgsCountTooLarge) {
+TEST_F(%(test_name)s, %(name)sValidArgsCountTooLarge) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
@@ -5043,7 +4984,7 @@ TEST_P(%(test_name)s, %(name)sValidArgsCountTooLarge) {
   def WriteImmediateServiceUnitTest(self, func, file):
     """Overridden from TypeHandler."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   EXPECT_CALL(
       *gl_,
@@ -5074,7 +5015,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_any_args)s, _)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
@@ -5304,7 +5245,7 @@ class PUTXnHandler(TypeHandler):
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(name)sv(%(local_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
@@ -5322,7 +5263,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
       })
 
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(name)sv(_, _, _).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
@@ -5513,7 +5454,7 @@ class IsHandler(TypeHandler):
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
@@ -5530,7 +5471,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
         })
 
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
@@ -5543,7 +5484,7 @@ TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
         })
 
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgsBadSharedMemoryId) {
+TEST_F(%(test_name)s, %(name)sInvalidArgsBadSharedMemoryId) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
@@ -5712,7 +5653,7 @@ class STRnHandler(TypeHandler):
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
-TEST_P(%(test_name)s, %(name)sValidArgs) {
+TEST_F(%(test_name)s, %(name)sValidArgs) {
   const char* kInfo = "hello";
   const uint32 kBucketId = 123;
   SpecializedSetup<cmds::%(name)s, 0>(true);
@@ -5752,7 +5693,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
     self.WriteValidUnitTest(func, file, valid_test, sub)
 
     invalid_test = """
-TEST_P(%(test_name)s, %(name)sInvalidArgs) {
+TEST_F(%(test_name)s, %(name)sInvalidArgs) {
   const uint32 kBucketId = 123;
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _, _, _))
       .Times(0);
@@ -7138,45 +7079,14 @@ class GLGenerator(object):
     file.Write("  EnableFlags();\n")
     for capability in _CAPABILITY_FLAGS:
       file.Write("  bool %s;\n" % capability['name'])
-      file.Write("  bool cached_%s;\n" % capability['name'])
     file.Write("};\n\n")
 
     for state_name in sorted(_STATES.keys()):
       state = _STATES[state_name]
       for item in state['states']:
         file.Write("%s %s;\n" % (item['type'], item['name']))
-        if item.get('cached', False):
-          file.Write("%s cached_%s;\n" % (item['type'], item['name']))
     file.Write("\n")
 
-    file.Write("""
-        inline void SetDeviceCapabilityState(GLenum cap, bool enable) {
-          switch (cap) {
-        """)
-    for capability in _CAPABILITY_FLAGS:
-      file.Write("""\
-            case GL_%s:
-          """ % capability['name'].upper())
-      file.Write("""\
-              if (enable_flags.cached_%(name)s == enable &&
-                  !ignore_cached_state)
-                return;
-              enable_flags.cached_%(name)s = enable;
-              break;
-          """ % capability)
-
-    file.Write("""\
-            default:
-              NOTREACHED();
-              return;
-          }
-          if (enable)
-            glEnable(cap);
-          else
-            glDisable(cap);
-        }
-        """)
-
     file.Close()
 
   def WriteClientContextStateHeader(self, filename):
@@ -7245,9 +7155,6 @@ bool %s::GetStateAs%s(
       code.append("%s(%s)" %
                   (capability['name'],
                    ('false', 'true')['default' in capability]))
-      code.append("cached_%s(%s)" %
-                  (capability['name'],
-                   ('false', 'true')['default' in capability]))
     file.Write("ContextState::EnableFlags::EnableFlags()\n    : %s {\n}\n" %
                ",\n      ".join(code))
     file.Write("\n")
@@ -7257,8 +7164,6 @@ bool %s::GetStateAs%s(
       state = _STATES[state_name]
       for item in state['states']:
         file.Write("  %s = %s;\n" % (item['name'], item['default']))
-        if item.get('cached', False):
-          file.Write("  cached_%s = %s;\n" % (item['name'], item['default']))
     file.Write("}\n")
 
     file.Write("""
@@ -7268,10 +7173,9 @@ void ContextState::InitCapabilities(const ContextState* prev_state) const {
       for capability in _CAPABILITY_FLAGS:
         capability_name = capability['name']
         if test_prev:
-          file.Write("""  if (prev_state->enable_flags.cached_%s !=
-                              enable_flags.cached_%s)\n""" %
+          file.Write("  if (prev_state->enable_flags.%s != enable_flags.%s)\n" %
                      (capability_name, capability_name))
-        file.Write("    EnableDisable(GL_%s, enable_flags.cached_%s);\n" %
+        file.Write("    EnableDisable(GL_%s, enable_flags.%s);\n" %
                    (capability_name.upper(), capability_name))
 
     file.Write("  if (prev_state) {")
@@ -7296,7 +7200,7 @@ void ContextState::InitState(const ContextState *prev_state) const {
               file.Write("  if (")
             args = []
             for place, item in enumerate(group):
-              item_name = CachedStateName(item)
+              item_name = item['name']
               args.append('%s' % item_name)
               if test_prev:
                 if place > 0:
@@ -7309,22 +7213,20 @@ void ContextState::InitState(const ContextState *prev_state) const {
                 (state['func'], ('GL_FRONT', 'GL_BACK')[ndx], ", ".join(args)))
         elif state['type'] == 'NamedParameter':
           for item in state['states']:
-            item_name = CachedStateName(item)
-
             if 'extension_flag' in item:
               file.Write("  if (feature_info_->feature_flags().%s)\n  " %
                          item['extension_flag'])
             if test_prev:
               file.Write("  if (prev_state->%s != %s)\n" %
-                         (item_name, item_name))
+                         (item['name'], item['name']))
             file.Write("  gl%s(%s, %s);\n" %
-                       (state['func'], item['enum'], item_name))
+                       (state['func'], item['enum'], item['name']))
         else:
           if test_prev:
             file.Write("  if (")
           args = []
           for place, item in enumerate(state['states']):
-            item_name = CachedStateName(item)
+            item_name = item['name']
             args.append('%s' % item_name)
             if test_prev:
               if place > 0:
@@ -7427,25 +7329,16 @@ bool GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
     for capability in _CAPABILITY_FLAGS:
       file.Write("    case GL_%s:\n" % capability['name'].upper())
       if 'state_flag' in capability:
-
-        file.Write("""\
-            state_.enable_flags.%(name)s = enabled;
-            if (state_.enable_flags.cached_%(name)s != enabled
-                || state_.ignore_cached_state) {
-              %(state_flag)s = true;
-            }
-            return false;
-            """ % capability)
+        file.Write("""      if (state_.enable_flags.%(name)s != enabled) {
+        state_.enable_flags.%(name)s = enabled;
+        %(state_flag)s = true;
+      }
+      return false;
+""" % capability)
       else:
-        file.Write("""\
-            state_.enable_flags.%(name)s = enabled;
-            if (state_.enable_flags.cached_%(name)s != enabled
-                || state_.ignore_cached_state) {
-              state_.enable_flags.cached_%(name)s = enabled;
-              return true;
-            }
-            return false;
-            """ % capability)
+        file.Write("""      state_.enable_flags.%(name)s = enabled;
+      return true;
+""" % capability)
     file.Write("""    default:
       NOTREACHED();
       return false;
diff --git a/gpu/command_buffer/service/context_state.cc b/gpu/command_buffer/service/context_state.cc
index 77d1f92..2eb3f99 100644
--- a/gpu/command_buffer/service/context_state.cc
+++ b/gpu/command_buffer/service/context_state.cc
@@ -18,7 +18,7 @@ namespace gles2 {
 
 namespace {
 
-static void EnableDisable(GLenum pname, bool enable) {
+void EnableDisable(GLenum pname, bool enable) {
   if (enable) {
     glEnable(pname);
   } else {
@@ -92,7 +92,6 @@ ContextState::ContextState(FeatureInfo* feature_info,
                            Logger* logger)
     : active_texture_unit(0),
       pack_reverse_row_order(false),
-      ignore_cached_state(false),
       fbo_binding_for_scissor_workaround_dirty_(false),
       feature_info_(feature_info),
       error_state_(ErrorState::Create(error_state_client, logger)) {
diff --git a/gpu/command_buffer/service/context_state.h b/gpu/command_buffer/service/context_state.h
index e436e74..83818e9 100644
--- a/gpu/command_buffer/service/context_state.h
+++ b/gpu/command_buffer/service/context_state.h
@@ -101,10 +101,6 @@ struct GPU_EXPORT ContextState {
 
   void Initialize();
 
-  void SetIgnoreCachedStateForTest(bool ignore) {
-    ignore_cached_state = ignore;
-  }
-
   void RestoreState(const ContextState* prev_state) const;
   void InitCapabilities(const ContextState* prev_state) const;
   void InitState(const ContextState* prev_state) const;
@@ -130,44 +126,6 @@ struct GPU_EXPORT ContextState {
       GLenum pname, GLfloat* params, GLsizei* num_written) const;
   bool GetEnabled(GLenum cap) const;
 
-  inline void SetDeviceColorMask(GLboolean red,
-                                 GLboolean green,
-                                 GLboolean blue,
-                                 GLboolean alpha) {
-    if (cached_color_mask_red == red && cached_color_mask_green == green &&
-        cached_color_mask_blue == blue && cached_color_mask_alpha == alpha &&
-        !ignore_cached_state)
-      return;
-    cached_color_mask_red = red;
-    cached_color_mask_green = green;
-    cached_color_mask_blue = blue;
-    cached_color_mask_alpha = alpha;
-    glColorMask(red, green, blue, alpha);
-  }
-
-  inline void SetDeviceDepthMask(GLboolean mask) {
-    if (cached_depth_mask == mask && !ignore_cached_state)
-      return;
-    cached_depth_mask = mask;
-    glDepthMask(mask);
-  }
-
-  inline void SetDeviceStencilMaskSeparate(GLenum op, GLuint mask) {
-    if (op == GL_FRONT) {
-      if (cached_stencil_front_writemask == mask && !ignore_cached_state)
-        return;
-      cached_stencil_front_writemask = mask;
-    } else if (op == GL_BACK) {
-      if (cached_stencil_back_writemask == mask && !ignore_cached_state)
-        return;
-      cached_stencil_back_writemask = mask;
-    } else {
-      NOTREACHED();
-      return;
-    }
-    glStencilMaskSeparate(op, mask);
-  }
-
   ErrorState* GetErrorState();
 
   #include "gpu/command_buffer/service/context_state_autogen.h"
@@ -204,7 +162,6 @@ struct GPU_EXPORT ContextState {
   QueryMap current_queries;
 
   bool pack_reverse_row_order;
-  bool ignore_cached_state;
 
   mutable bool fbo_binding_for_scissor_workaround_dirty_;
   FeatureInfo* feature_info_;
diff --git a/gpu/command_buffer/service/context_state_autogen.h b/gpu/command_buffer/service/context_state_autogen.h
index 309301f..6e408a3 100644
--- a/gpu/command_buffer/service/context_state_autogen.h
+++ b/gpu/command_buffer/service/context_state_autogen.h
@@ -15,23 +15,14 @@
 struct EnableFlags {
   EnableFlags();
   bool blend;
-  bool cached_blend;
   bool cull_face;
-  bool cached_cull_face;
   bool depth_test;
-  bool cached_depth_test;
   bool dither;
-  bool cached_dither;
   bool polygon_offset_fill;
-  bool cached_polygon_offset_fill;
   bool sample_alpha_to_coverage;
-  bool cached_sample_alpha_to_coverage;
   bool sample_coverage;
-  bool cached_sample_coverage;
   bool scissor_test;
-  bool cached_scissor_test;
   bool stencil_test;
-  bool cached_stencil_test;
 };
 
 GLfloat blend_color_red;
@@ -51,17 +42,12 @@ GLfloat color_clear_alpha;
 GLclampf depth_clear;
 GLint stencil_clear;
 GLboolean color_mask_red;
-GLboolean cached_color_mask_red;
 GLboolean color_mask_green;
-GLboolean cached_color_mask_green;
 GLboolean color_mask_blue;
-GLboolean cached_color_mask_blue;
 GLboolean color_mask_alpha;
-GLboolean cached_color_mask_alpha;
 GLenum cull_mode;
 GLenum depth_func;
 GLboolean depth_mask;
-GLboolean cached_depth_mask;
 GLclampf z_near;
 GLclampf z_far;
 GLenum front_face;
@@ -85,9 +71,7 @@ GLenum stencil_back_func;
 GLint stencil_back_ref;
 GLuint stencil_back_mask;
 GLuint stencil_front_writemask;
-GLuint cached_stencil_front_writemask;
 GLuint stencil_back_writemask;
-GLuint cached_stencil_back_writemask;
 GLenum stencil_front_fail_op;
 GLenum stencil_front_z_fail_op;
 GLenum stencil_front_z_pass_op;
@@ -99,62 +83,4 @@ GLint viewport_y;
 GLsizei viewport_width;
 GLsizei viewport_height;
 
-inline void SetDeviceCapabilityState(GLenum cap, bool enable) {
-  switch (cap) {
-    case GL_BLEND:
-      if (enable_flags.cached_blend == enable && !ignore_cached_state)
-        return;
-      enable_flags.cached_blend = enable;
-      break;
-    case GL_CULL_FACE:
-      if (enable_flags.cached_cull_face == enable && !ignore_cached_state)
-        return;
-      enable_flags.cached_cull_face = enable;
-      break;
-    case GL_DEPTH_TEST:
-      if (enable_flags.cached_depth_test == enable && !ignore_cached_state)
-        return;
-      enable_flags.cached_depth_test = enable;
-      break;
-    case GL_DITHER:
-      if (enable_flags.cached_dither == enable && !ignore_cached_state)
-        return;
-      enable_flags.cached_dither = enable;
-      break;
-    case GL_POLYGON_OFFSET_FILL:
-      if (enable_flags.cached_polygon_offset_fill == enable &&
-          !ignore_cached_state)
-        return;
-      enable_flags.cached_polygon_offset_fill = enable;
-      break;
-    case GL_SAMPLE_ALPHA_TO_COVERAGE:
-      if (enable_flags.cached_sample_alpha_to_coverage == enable &&
-          !ignore_cached_state)
-        return;
-      enable_flags.cached_sample_alpha_to_coverage = enable;
-      break;
-    case GL_SAMPLE_COVERAGE:
-      if (enable_flags.cached_sample_coverage == enable && !ignore_cached_state)
-        return;
-      enable_flags.cached_sample_coverage = enable;
-      break;
-    case GL_SCISSOR_TEST:
-      if (enable_flags.cached_scissor_test == enable && !ignore_cached_state)
-        return;
-      enable_flags.cached_scissor_test = enable;
-      break;
-    case GL_STENCIL_TEST:
-      if (enable_flags.cached_stencil_test == enable && !ignore_cached_state)
-        return;
-      enable_flags.cached_stencil_test = enable;
-      break;
-    default:
-      NOTREACHED();
-      return;
-  }
-  if (enable)
-    glEnable(cap);
-  else
-    glDisable(cap);
-}
 #endif  // GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_AUTOGEN_H_
diff --git a/gpu/command_buffer/service/context_state_impl_autogen.h b/gpu/command_buffer/service/context_state_impl_autogen.h
index 056a382..5b3709c 100644
--- a/gpu/command_buffer/service/context_state_impl_autogen.h
+++ b/gpu/command_buffer/service/context_state_impl_autogen.h
@@ -14,23 +14,14 @@
 
 ContextState::EnableFlags::EnableFlags()
     : blend(false),
-      cached_blend(false),
       cull_face(false),
-      cached_cull_face(false),
       depth_test(false),
-      cached_depth_test(false),
       dither(true),
-      cached_dither(true),
       polygon_offset_fill(false),
-      cached_polygon_offset_fill(false),
       sample_alpha_to_coverage(false),
-      cached_sample_alpha_to_coverage(false),
       sample_coverage(false),
-      cached_sample_coverage(false),
       scissor_test(false),
-      cached_scissor_test(false),
-      stencil_test(false),
-      cached_stencil_test(false) {
+      stencil_test(false) {
 }
 
 void ContextState::Initialize() {
@@ -51,17 +42,12 @@ void ContextState::Initialize() {
   depth_clear = 1.0f;
   stencil_clear = 0;
   color_mask_red = true;
-  cached_color_mask_red = true;
   color_mask_green = true;
-  cached_color_mask_green = true;
   color_mask_blue = true;
-  cached_color_mask_blue = true;
   color_mask_alpha = true;
-  cached_color_mask_alpha = true;
   cull_mode = GL_BACK;
   depth_func = GL_LESS;
   depth_mask = true;
-  cached_depth_mask = true;
   z_near = 0.0f;
   z_far = 1.0f;
   front_face = GL_CCW;
@@ -85,9 +71,7 @@ void ContextState::Initialize() {
   stencil_back_ref = 0;
   stencil_back_mask = 0xFFFFFFFFU;
   stencil_front_writemask = 0xFFFFFFFFU;
-  cached_stencil_front_writemask = 0xFFFFFFFFU;
   stencil_back_writemask = 0xFFFFFFFFU;
-  cached_stencil_back_writemask = 0xFFFFFFFFU;
   stencil_front_fail_op = GL_KEEP;
   stencil_front_z_fail_op = GL_KEEP;
   stencil_front_z_pass_op = GL_KEEP;
@@ -102,45 +86,39 @@ void ContextState::Initialize() {
 
 void ContextState::InitCapabilities(const ContextState* prev_state) const {
   if (prev_state) {
-    if (prev_state->enable_flags.cached_blend != enable_flags.cached_blend)
-      EnableDisable(GL_BLEND, enable_flags.cached_blend);
-    if (prev_state->enable_flags.cached_cull_face !=
-        enable_flags.cached_cull_face)
-      EnableDisable(GL_CULL_FACE, enable_flags.cached_cull_face);
-    if (prev_state->enable_flags.cached_depth_test !=
-        enable_flags.cached_depth_test)
-      EnableDisable(GL_DEPTH_TEST, enable_flags.cached_depth_test);
-    if (prev_state->enable_flags.cached_dither != enable_flags.cached_dither)
-      EnableDisable(GL_DITHER, enable_flags.cached_dither);
-    if (prev_state->enable_flags.cached_polygon_offset_fill !=
-        enable_flags.cached_polygon_offset_fill)
-      EnableDisable(GL_POLYGON_OFFSET_FILL,
-                    enable_flags.cached_polygon_offset_fill);
-    if (prev_state->enable_flags.cached_sample_alpha_to_coverage !=
-        enable_flags.cached_sample_alpha_to_coverage)
+    if (prev_state->enable_flags.blend != enable_flags.blend)
+      EnableDisable(GL_BLEND, enable_flags.blend);
+    if (prev_state->enable_flags.cull_face != enable_flags.cull_face)
+      EnableDisable(GL_CULL_FACE, enable_flags.cull_face);
+    if (prev_state->enable_flags.depth_test != enable_flags.depth_test)
+      EnableDisable(GL_DEPTH_TEST, enable_flags.depth_test);
+    if (prev_state->enable_flags.dither != enable_flags.dither)
+      EnableDisable(GL_DITHER, enable_flags.dither);
+    if (prev_state->enable_flags.polygon_offset_fill !=
+        enable_flags.polygon_offset_fill)
+      EnableDisable(GL_POLYGON_OFFSET_FILL, enable_flags.polygon_offset_fill);
+    if (prev_state->enable_flags.sample_alpha_to_coverage !=
+        enable_flags.sample_alpha_to_coverage)
       EnableDisable(GL_SAMPLE_ALPHA_TO_COVERAGE,
-                    enable_flags.cached_sample_alpha_to_coverage);
-    if (prev_state->enable_flags.cached_sample_coverage !=
-        enable_flags.cached_sample_coverage)
-      EnableDisable(GL_SAMPLE_COVERAGE, enable_flags.cached_sample_coverage);
-    if (prev_state->enable_flags.cached_scissor_test !=
-        enable_flags.cached_scissor_test)
-      EnableDisable(GL_SCISSOR_TEST, enable_flags.cached_scissor_test);
-    if (prev_state->enable_flags.cached_stencil_test !=
-        enable_flags.cached_stencil_test)
-      EnableDisable(GL_STENCIL_TEST, enable_flags.cached_stencil_test);
+                    enable_flags.sample_alpha_to_coverage);
+    if (prev_state->enable_flags.sample_coverage !=
+        enable_flags.sample_coverage)
+      EnableDisable(GL_SAMPLE_COVERAGE, enable_flags.sample_coverage);
+    if (prev_state->enable_flags.scissor_test != enable_flags.scissor_test)
+      EnableDisable(GL_SCISSOR_TEST, enable_flags.scissor_test);
+    if (prev_state->enable_flags.stencil_test != enable_flags.stencil_test)
+      EnableDisable(GL_STENCIL_TEST, enable_flags.stencil_test);
   } else {
-    EnableDisable(GL_BLEND, enable_flags.cached_blend);
-    EnableDisable(GL_CULL_FACE, enable_flags.cached_cull_face);
-    EnableDisable(GL_DEPTH_TEST, enable_flags.cached_depth_test);
-    EnableDisable(GL_DITHER, enable_flags.cached_dither);
-    EnableDisable(GL_POLYGON_OFFSET_FILL,
-                  enable_flags.cached_polygon_offset_fill);
+    EnableDisable(GL_BLEND, enable_flags.blend);
+    EnableDisable(GL_CULL_FACE, enable_flags.cull_face);
+    EnableDisable(GL_DEPTH_TEST, enable_flags.depth_test);
+    EnableDisable(GL_DITHER, enable_flags.dither);
+    EnableDisable(GL_POLYGON_OFFSET_FILL, enable_flags.polygon_offset_fill);
     EnableDisable(GL_SAMPLE_ALPHA_TO_COVERAGE,
-                  enable_flags.cached_sample_alpha_to_coverage);
-    EnableDisable(GL_SAMPLE_COVERAGE, enable_flags.cached_sample_coverage);
-    EnableDisable(GL_SCISSOR_TEST, enable_flags.cached_scissor_test);
-    EnableDisable(GL_STENCIL_TEST, enable_flags.cached_stencil_test);
+                  enable_flags.sample_alpha_to_coverage);
+    EnableDisable(GL_SAMPLE_COVERAGE, enable_flags.sample_coverage);
+    EnableDisable(GL_SCISSOR_TEST, enable_flags.scissor_test);
+    EnableDisable(GL_STENCIL_TEST, enable_flags.stencil_test);
   }
 }
 
@@ -177,20 +155,18 @@ void ContextState::InitState(const ContextState* prev_state) const {
       glClearDepth(depth_clear);
     if ((stencil_clear != prev_state->stencil_clear))
       glClearStencil(stencil_clear);
-    if ((cached_color_mask_red != prev_state->cached_color_mask_red) ||
-        (cached_color_mask_green != prev_state->cached_color_mask_green) ||
-        (cached_color_mask_blue != prev_state->cached_color_mask_blue) ||
-        (cached_color_mask_alpha != prev_state->cached_color_mask_alpha))
-      glColorMask(cached_color_mask_red,
-                  cached_color_mask_green,
-                  cached_color_mask_blue,
-                  cached_color_mask_alpha);
+    if ((color_mask_red != prev_state->color_mask_red) ||
+        (color_mask_green != prev_state->color_mask_green) ||
+        (color_mask_blue != prev_state->color_mask_blue) ||
+        (color_mask_alpha != prev_state->color_mask_alpha))
+      glColorMask(
+          color_mask_red, color_mask_green, color_mask_blue, color_mask_alpha);
     if ((cull_mode != prev_state->cull_mode))
       glCullFace(cull_mode);
     if ((depth_func != prev_state->depth_func))
       glDepthFunc(depth_func);
-    if ((cached_depth_mask != prev_state->cached_depth_mask))
-      glDepthMask(cached_depth_mask);
+    if ((depth_mask != prev_state->depth_mask))
+      glDepthMask(depth_mask);
     if ((z_near != prev_state->z_near) || (z_far != prev_state->z_far))
       glDepthRange(z_near, z_far);
     if ((front_face != prev_state->front_face))
@@ -229,12 +205,10 @@ void ContextState::InitState(const ContextState* prev_state) const {
         (stencil_back_mask != prev_state->stencil_back_mask))
       glStencilFuncSeparate(
           GL_BACK, stencil_back_func, stencil_back_ref, stencil_back_mask);
-    if ((cached_stencil_front_writemask !=
-         prev_state->cached_stencil_front_writemask))
-      glStencilMaskSeparate(GL_FRONT, cached_stencil_front_writemask);
-    if ((cached_stencil_back_writemask !=
-         prev_state->cached_stencil_back_writemask))
-      glStencilMaskSeparate(GL_BACK, cached_stencil_back_writemask);
+    if ((stencil_front_writemask != prev_state->stencil_front_writemask))
+      glStencilMaskSeparate(GL_FRONT, stencil_front_writemask);
+    if ((stencil_back_writemask != prev_state->stencil_back_writemask))
+      glStencilMaskSeparate(GL_BACK, stencil_back_writemask);
     if ((stencil_front_fail_op != prev_state->stencil_front_fail_op) ||
         (stencil_front_z_fail_op != prev_state->stencil_front_z_fail_op) ||
         (stencil_front_z_pass_op != prev_state->stencil_front_z_pass_op))
@@ -268,13 +242,11 @@ void ContextState::InitState(const ContextState* prev_state) const {
                  color_clear_alpha);
     glClearDepth(depth_clear);
     glClearStencil(stencil_clear);
-    glColorMask(cached_color_mask_red,
-                cached_color_mask_green,
-                cached_color_mask_blue,
-                cached_color_mask_alpha);
+    glColorMask(
+        color_mask_red, color_mask_green, color_mask_blue, color_mask_alpha);
     glCullFace(cull_mode);
     glDepthFunc(depth_func);
-    glDepthMask(cached_depth_mask);
+    glDepthMask(depth_mask);
     glDepthRange(z_near, z_far);
     glFrontFace(front_face);
     glHint(GL_GENERATE_MIPMAP_HINT, hint_generate_mipmap);
@@ -291,8 +263,8 @@ void ContextState::InitState(const ContextState* prev_state) const {
         GL_FRONT, stencil_front_func, stencil_front_ref, stencil_front_mask);
     glStencilFuncSeparate(
         GL_BACK, stencil_back_func, stencil_back_ref, stencil_back_mask);
-    glStencilMaskSeparate(GL_FRONT, cached_stencil_front_writemask);
-    glStencilMaskSeparate(GL_BACK, cached_stencil_back_writemask);
+    glStencilMaskSeparate(GL_FRONT, stencil_front_writemask);
+    glStencilMaskSeparate(GL_BACK, stencil_back_writemask);
     glStencilOpSeparate(GL_FRONT,
                         stencil_front_fail_op,
                         stencil_front_z_fail_op,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 605ec14..4b75c2e 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -278,6 +278,15 @@ static bool StringIsValidForGLES(const char* str) {
   return true;
 }
 
+// Wrapper for glEnable/glDisable that doesn't suck.
+static void EnableDisable(GLenum pname, bool enable) {
+  if (enable) {
+    glEnable(pname);
+  } else {
+    glDisable(pname);
+  }
+}
+
 // This class prevents any GL errors that occur when it is in scope from
 // being reported to the client.
 class ScopedGLErrorSuppressor {
@@ -652,7 +661,6 @@ class GLES2DecoderImpl : public GLES2Decoder,
   virtual void ResetAsyncPixelTransferManagerForTest() OVERRIDE;
   virtual void SetAsyncPixelTransferManagerForTest(
       AsyncPixelTransferManager* manager) OVERRIDE;
-  virtual void SetIgnoreCachedStateForTest(bool ignore) OVERRIDE;
   void ProcessFinishedAsyncTransfers();
 
   virtual bool GetServiceTextureId(uint32 client_texture_id,
@@ -1924,7 +1932,7 @@ ScopedResolvedFrameBufferBinder::ScopedResolvedFrameBufferBinder(
   glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, targetid);
   const int width = decoder_->offscreen_size_.width();
   const int height = decoder_->offscreen_size_.height();
-  decoder->state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
+  glDisable(GL_SCISSOR_TEST);
   decoder->BlitFramebufferHelper(0,
                                  0,
                                  width,
@@ -1946,7 +1954,7 @@ ScopedResolvedFrameBufferBinder::~ScopedResolvedFrameBufferBinder() {
       "ScopedResolvedFrameBufferBinder::dtor", decoder_->GetErrorState());
   decoder_->RestoreCurrentFramebufferBindings();
   if (decoder_->state_.enable_flags.scissor_test) {
-    decoder_->state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, true);
+    glEnable(GL_SCISSOR_TEST);
   }
 }
 
@@ -3062,12 +3070,12 @@ bool GLES2DecoderImpl::CheckFramebufferValid(
     if (backbuffer_needs_clear_bits_) {
       glClearColor(0, 0, 0, (GLES2Util::GetChannelsForFormat(
           offscreen_target_color_format_) & 0x0008) != 0 ? 0 : 1);
-      state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+      glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       glClearStencil(0);
       glStencilMask(-1);
       glClearDepth(1.0f);
-      state_.SetDeviceDepthMask(GL_TRUE);
-      state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
+      glDepthMask(true);
+      glDisable(GL_SCISSOR_TEST);
       glClear(backbuffer_needs_clear_bits_);
       backbuffer_needs_clear_bits_ = 0;
       RestoreClearState();
@@ -3570,13 +3578,13 @@ bool GLES2DecoderImpl::ResizeOffscreenFrameBuffer(const gfx::Size& size) {
     ScopedFrameBufferBinder binder(this, offscreen_target_frame_buffer_->id());
     glClearColor(0, 0, 0, (GLES2Util::GetChannelsForFormat(
         offscreen_target_color_format_) & 0x0008) != 0 ? 0 : 1);
-    state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     glClearStencil(0);
-    state_.SetDeviceStencilMaskSeparate(GL_FRONT, -1);
-    state_.SetDeviceStencilMaskSeparate(GL_BACK, -1);
+    glStencilMaskSeparate(GL_FRONT, -1);
+    glStencilMaskSeparate(GL_BACK, -1);
     glClearDepth(0);
-    state_.SetDeviceDepthMask(GL_TRUE);
-    state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
+    glDepthMask(GL_TRUE);
+    glDisable(GL_SCISSOR_TEST);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
     RestoreClearState();
   }
@@ -3839,25 +3847,23 @@ bool GLES2DecoderImpl::BoundFramebufferHasStencilAttachment() {
 
 void GLES2DecoderImpl::ApplyDirtyState() {
   if (framebuffer_state_.clear_state_dirty) {
-    bool have_alpha = BoundFramebufferHasColorAttachmentWithAlpha(true);
-    state_.SetDeviceColorMask(state_.color_mask_red,
-                              state_.color_mask_green,
-                              state_.color_mask_blue,
-                              state_.color_mask_alpha && have_alpha);
-
+    glColorMask(
+        state_.color_mask_red, state_.color_mask_green, state_.color_mask_blue,
+        state_.color_mask_alpha &&
+            BoundFramebufferHasColorAttachmentWithAlpha(true));
     bool have_depth = BoundFramebufferHasDepthAttachment();
-    state_.SetDeviceDepthMask(state_.depth_mask && have_depth);
-
+    glDepthMask(state_.depth_mask && have_depth);
+    EnableDisable(GL_DEPTH_TEST, state_.enable_flags.depth_test && have_depth);
     bool have_stencil = BoundFramebufferHasStencilAttachment();
-    state_.SetDeviceStencilMaskSeparate(
+    glStencilMaskSeparate(
         GL_FRONT, have_stencil ? state_.stencil_front_writemask : 0);
-    state_.SetDeviceStencilMaskSeparate(
+    glStencilMaskSeparate(
         GL_BACK, have_stencil ? state_.stencil_back_writemask : 0);
-
-    state_.SetDeviceCapabilityState(
-        GL_DEPTH_TEST, state_.enable_flags.depth_test && have_depth);
-    state_.SetDeviceCapabilityState(
+    EnableDisable(
         GL_STENCIL_TEST, state_.enable_flags.stencil_test && have_stencil);
+    EnableDisable(GL_CULL_FACE, state_.enable_flags.cull_face);
+    EnableDisable(GL_SCISSOR_TEST, state_.enable_flags.scissor_test);
+    EnableDisable(GL_BLEND, state_.enable_flags.blend);
     framebuffer_state_.clear_state_dirty = false;
   }
 }
@@ -3930,10 +3936,6 @@ void GLES2DecoderImpl::RestoreAllAttributes() const {
   state_.RestoreVertexAttribs();
 }
 
-void GLES2DecoderImpl::SetIgnoreCachedStateForTest(bool ignore) {
-  state_.SetIgnoreCachedStateForTest(ignore);
-}
-
 void GLES2DecoderImpl::OnFboChanged() const {
   if (workarounds().restore_scissor_on_fbo_change)
     state_.fbo_binding_for_scissor_workaround_dirty_ = true;
@@ -5027,7 +5029,7 @@ void GLES2DecoderImpl::ClearUnclearedAttachments(
         (GLES2Util::GetChannelsForFormat(
              framebuffer->GetColorAttachmentFormat()) & 0x0008) != 0 ? 0.0f :
                                                                        1.0f);
-    state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+    glColorMask(true, true, true, true);
     clear_bits |= GL_COLOR_BUFFER_BIT;
   }
 
@@ -5041,11 +5043,11 @@ void GLES2DecoderImpl::ClearUnclearedAttachments(
   if (framebuffer->HasUnclearedAttachment(GL_DEPTH_ATTACHMENT) ||
       framebuffer->HasUnclearedAttachment(GL_DEPTH_STENCIL_ATTACHMENT)) {
     glClearDepth(1.0f);
-    state_.SetDeviceDepthMask(GL_TRUE);
+    glDepthMask(true);
     clear_bits |= GL_DEPTH_BUFFER_BIT;
   }
 
-  state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
+  glDisable(GL_SCISSOR_TEST);
   glClear(clear_bits);
 
   framebuffer_manager()->MarkAttachmentsAsCleared(
@@ -5071,7 +5073,7 @@ void GLES2DecoderImpl::RestoreClearState() {
   glClearStencil(state_.stencil_clear);
   glClearDepth(state_.depth_clear);
   if (state_.enable_flags.scissor_test) {
-    state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, true);
+    glEnable(GL_SCISSOR_TEST);
   }
 }
 
@@ -5248,11 +5250,10 @@ void GLES2DecoderImpl::DoBlitFramebufferCHROMIUM(
     return;
   }
 
-  state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
+  glDisable(GL_SCISSOR_TEST);
   BlitFramebufferHelper(
       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-  state_.SetDeviceCapabilityState(GL_SCISSOR_TEST,
-                                  state_.enable_flags.scissor_test);
+  EnableDisable(GL_SCISSOR_TEST, state_.enable_flags.scissor_test);
 }
 
 void GLES2DecoderImpl::RenderbufferStorageMultisampleHelper(
@@ -5491,11 +5492,11 @@ bool GLES2DecoderImpl::VerifyMultisampleRenderbufferIntegrity(
   GLboolean scissor_enabled = false;
   glGetBooleanv(GL_SCISSOR_TEST, &scissor_enabled);
   if (scissor_enabled)
-    state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
+    glDisable(GL_SCISSOR_TEST);
 
-  GLboolean color_mask[4] = {GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE};
+  GLboolean color_mask[4] = {true, true, true, true};
   glGetBooleanv(GL_COLOR_WRITEMASK, color_mask);
-  state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+  glColorMask(true, true, true, true);
 
   GLfloat clear_color[4] = {0.0f, 0.0f, 0.0f, 0.0f};
   glGetFloatv(GL_COLOR_CLEAR_VALUE, clear_color);
@@ -5524,10 +5525,9 @@ bool GLES2DecoderImpl::VerifyMultisampleRenderbufferIntegrity(
 
   // Restore cached state.
   if (scissor_enabled)
-    state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, true);
+    glEnable(GL_SCISSOR_TEST);
 
-  state_.SetDeviceColorMask(
-      color_mask[0], color_mask[1], color_mask[2], color_mask[3]);
+  glColorMask(color_mask[0], color_mask[1], color_mask[2], color_mask[3]);
   glClearColor(clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
   glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER, draw_framebuffer);
   glBindFramebufferEXT(GL_READ_FRAMEBUFFER, read_framebuffer);
@@ -7843,8 +7843,8 @@ bool GLES2DecoderImpl::ClearLevel(
     glClearStencil(0);
     glStencilMask(-1);
     glClearDepth(1.0f);
-    state_.SetDeviceDepthMask(GL_TRUE);
-    state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
+    glDepthMask(true);
+    glDisable(GL_SCISSOR_TEST);
     glClear(GL_DEPTH_BUFFER_BIT | (have_stencil ? GL_STENCIL_BUFFER_BIT : 0));
 
     RestoreClearState();
@@ -9170,8 +9170,8 @@ void GLES2DecoderImpl::DoSwapBuffers() {
           ScopedFrameBufferBinder binder(this,
                                          offscreen_saved_frame_buffer_->id());
           glClearColor(0, 0, 0, 0);
-          state_.SetDeviceColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-          state_.SetDeviceCapabilityState(GL_SCISSOR_TEST, false);
+          glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+          glDisable(GL_SCISSOR_TEST);
           glClear(GL_COLOR_BUFFER_BIT);
           RestoreClearState();
         }
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.h b/gpu/command_buffer/service/gles2_cmd_decoder.h
index ad06a6e..c573b23 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.h
@@ -152,8 +152,6 @@ class GPU_EXPORT GLES2Decoder : public base::SupportsWeakPtr<GLES2Decoder>,
   virtual void ClearAllAttributes() const = 0;
   virtual void RestoreAllAttributes() const = 0;
 
-  virtual void SetIgnoreCachedStateForTest(bool ignore) = 0;
-
   // Gets the QueryManager for this context.
   virtual QueryManager* GetQueryManager() = 0;
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
index efc2b9b..c94c0bf 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
@@ -3451,71 +3451,37 @@ bool GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
   switch (cap) {
     case GL_BLEND:
       state_.enable_flags.blend = enabled;
-      if (state_.enable_flags.cached_blend != enabled ||
-          state_.ignore_cached_state) {
-        state_.enable_flags.cached_blend = enabled;
-        return true;
-      }
-      return false;
+      return true;
     case GL_CULL_FACE:
       state_.enable_flags.cull_face = enabled;
-      if (state_.enable_flags.cached_cull_face != enabled ||
-          state_.ignore_cached_state) {
-        state_.enable_flags.cached_cull_face = enabled;
-        return true;
-      }
-      return false;
+      return true;
     case GL_DEPTH_TEST:
-      state_.enable_flags.depth_test = enabled;
-      if (state_.enable_flags.cached_depth_test != enabled ||
-          state_.ignore_cached_state) {
+      if (state_.enable_flags.depth_test != enabled) {
+        state_.enable_flags.depth_test = enabled;
         framebuffer_state_.clear_state_dirty = true;
       }
       return false;
     case GL_DITHER:
       state_.enable_flags.dither = enabled;
-      if (state_.enable_flags.cached_dither != enabled ||
-          state_.ignore_cached_state) {
-        state_.enable_flags.cached_dither = enabled;
-        return true;
-      }
-      return false;
+      return true;
     case GL_POLYGON_OFFSET_FILL:
       state_.enable_flags.polygon_offset_fill = enabled;
-      if (state_.enable_flags.cached_polygon_offset_fill != enabled ||
-          state_.ignore_cached_state) {
-        state_.enable_flags.cached_polygon_offset_fill = enabled;
-        return true;
-      }
-      return false;
+      return true;
     case GL_SAMPLE_ALPHA_TO_COVERAGE:
       state_.enable_flags.sample_alpha_to_coverage = enabled;
-      if (state_.enable_flags.cached_sample_alpha_to_coverage != enabled ||
-          state_.ignore_cached_state) {
-        state_.enable_flags.cached_sample_alpha_to_coverage = enabled;
-        return true;
-      }
-      return false;
+      return true;
     case GL_SAMPLE_COVERAGE:
       state_.enable_flags.sample_coverage = enabled;
-      if (state_.enable_flags.cached_sample_coverage != enabled ||
-          state_.ignore_cached_state) {
-        state_.enable_flags.cached_sample_coverage = enabled;
-        return true;
-      }
-      return false;
+      return true;
     case GL_SCISSOR_TEST:
-      state_.enable_flags.scissor_test = enabled;
-      if (state_.enable_flags.cached_scissor_test != enabled ||
-          state_.ignore_cached_state) {
-        state_.enable_flags.cached_scissor_test = enabled;
-        return true;
+      if (state_.enable_flags.scissor_test != enabled) {
+        state_.enable_flags.scissor_test = enabled;
+        framebuffer_state_.clear_state_dirty = true;
       }
       return false;
     case GL_STENCIL_TEST:
-      state_.enable_flags.stencil_test = enabled;
-      if (state_.enable_flags.cached_stencil_test != enabled ||
-          state_.ignore_cached_state) {
+      if (state_.enable_flags.stencil_test != enabled) {
+        state_.enable_flags.stencil_test = enabled;
         framebuffer_state_.clear_state_dirty = true;
       }
       return false;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
index 94bf3aa..8043514 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
@@ -81,7 +81,6 @@ class MockGLES2Decoder : public GLES2Decoder {
   MOCK_METHOD0(ResetAsyncPixelTransferManagerForTest, void());
   MOCK_METHOD1(SetAsyncPixelTransferManagerForTest,
       void(AsyncPixelTransferManager*));
-  MOCK_METHOD1(SetIgnoreCachedStateForTest, void(bool ignore));
   MOCK_METHOD3(DoCommand, error::Error(unsigned int command,
                                        unsigned int arg_count,
                                        const void* cmd_data));
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
index 79f9a75..e0bfc2c 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
@@ -39,7 +39,6 @@ using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::MatcherCast;
-using ::testing::Mock;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SaveArg;
@@ -65,15 +64,15 @@ class GLES2DecoderTest : public GLES2DecoderTestBase {
       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;
@@ -139,70 +138,6 @@ class GLES2DecoderManualInitTest : public GLES2DecoderWithShaderTest {
   // 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 {
@@ -306,7 +241,7 @@ void GLES2DecoderRestoreStateTest::InitializeContextState(
   state->active_texture_unit = active_unit;
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysNoAttributesSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysNoAttributesSucceeds) {
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDefaultDirtyState();
@@ -321,7 +256,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysNoAttributesSucceeds) {
 }
 
 // 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(_, _, _))
@@ -335,7 +270,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OverflowFails) {
 }
 
 // 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(_, _, _))
@@ -349,7 +284,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0PosToNegFails) {
 }
 
 // Tests when the driver returns an error
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OOMFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OOMFails) {
   const GLsizei kFakeLargeCount = 0x1234;
   SetupTexture();
   AddExpectationsForSimulatedAttrib0WithError(
@@ -365,7 +300,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OOMFails) {
 }
 
 // Test that we lose context.
-TEST_P(GLES2DecoderManualInitTest, LoseContextWhenOOM) {
+TEST_F(GLES2DecoderManualInitTest, LoseContextWhenOOM) {
   InitState init;
   init.gl_version = "3.0";
   init.has_alpha = true;
@@ -394,7 +329,7 @@ TEST_P(GLES2DecoderManualInitTest, LoseContextWhenOOM) {
   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.
@@ -430,7 +365,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysBadTextureUsesBlack) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysMissingAttributesFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysMissingAttributesFails) {
   DoEnableVertexAttribArray(1);
 
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
@@ -441,7 +376,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysMissingAttributesFails) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        DrawArraysMissingAttributesZeroCountSucceeds) {
   DoEnableVertexAttribArray(1);
 
@@ -453,7 +388,7 @@ TEST_P(GLES2DecoderWithShaderTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysValidAttributesSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysValidAttributesSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
   DoEnableVertexAttribArray(1);
@@ -472,7 +407,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysValidAttributesSucceeds) {
 
 // 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,
@@ -502,7 +437,7 @@ TEST_P(GLES2DecoderManualInitTest, InitVertexAttributes) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysDeletedBufferFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysDeletedBufferFails) {
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
   DeleteVertexBuffer();
@@ -515,7 +450,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysDeletedBufferFails) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysDeletedProgramSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysDeletedProgramSucceeds) {
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDefaultDirtyState();
@@ -532,7 +467,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysDeletedProgramSucceeds) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysWithInvalidModeFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysWithInvalidModeFails) {
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
@@ -547,7 +482,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysWithInvalidModeFails) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysInvalidCountFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysInvalidCountFails) {
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
 
@@ -585,7 +520,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysInvalidCountFails) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawArraysInstancedANGLEFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawArraysInstancedANGLEFails) {
   SetupTexture();
   SetupVertexBuffer();
   DoEnableVertexAttribArray(1);
@@ -600,7 +535,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysInstancedANGLEFails) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLENoAttributesFails) {
   SetupTexture();
 
@@ -613,7 +548,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLESimulatedAttrib0) {
   SetupTexture();
   SetupVertexBuffer();
@@ -638,7 +573,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLEMissingAttributesFails) {
   DoEnableVertexAttribArray(1);
 
@@ -650,7 +585,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLEMissingAttributesZeroCountSucceeds) {
   DoEnableVertexAttribArray(1);
 
@@ -662,7 +597,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLEValidAttributesSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
@@ -680,7 +615,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLEWithInvalidModeFails) {
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
@@ -696,7 +631,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLEInvalidPrimcountFails) {
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
@@ -710,7 +645,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
 }
 
 // Per-instance data is twice as large, but number of instances is half
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLELargeInstanceSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
@@ -731,7 +666,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
 }
 
 // Per-instance data is twice as large, but divisor is twice
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLELargeDivisorSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
@@ -751,7 +686,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest, DrawArraysInstancedANGLELargeFails) {
+TEST_F(GLES2DecoderGeometryInstancingTest, DrawArraysInstancedANGLELargeFails) {
   SetupTexture();
   SetupVertexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
@@ -778,7 +713,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest, DrawArraysInstancedANGLELargeFails) {
 }
 
 // Per-index data is twice as large, but number of indices is half
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLELargeIndexSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
@@ -798,7 +733,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawArraysInstancedANGLENoDivisor0Fails) {
   SetupTexture();
   SetupVertexBuffer();
@@ -818,7 +753,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsNoAttributesSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsNoAttributesSucceeds) {
   SetupTexture();
   SetupIndexBuffer();
   AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, 0);
@@ -835,7 +770,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsNoAttributesSucceeds) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsMissingAttributesFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsMissingAttributesFails) {
   SetupIndexBuffer();
   DoEnableVertexAttribArray(1);
 
@@ -848,7 +783,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsMissingAttributesFails) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        DrawElementsMissingAttributesZeroCountSucceeds) {
   SetupIndexBuffer();
   DoEnableVertexAttribArray(1);
@@ -862,7 +797,7 @@ TEST_P(GLES2DecoderWithShaderTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsExtraAttributesFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsExtraAttributesFails) {
   SetupIndexBuffer();
   DoEnableVertexAttribArray(6);
 
@@ -875,7 +810,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsExtraAttributesFails) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsValidAttributesSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsValidAttributesSucceeds) {
   SetupTexture();
   SetupVertexBuffer();
   SetupIndexBuffer();
@@ -895,7 +830,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsValidAttributesSucceeds) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsDeletedBufferFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsDeletedBufferFails) {
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
@@ -910,7 +845,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsDeletedBufferFails) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsDeletedProgramSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsDeletedProgramSucceeds) {
   SetupTexture();
   SetupIndexBuffer();
   AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, 0);
@@ -928,7 +863,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsDeletedProgramSucceeds) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsWithInvalidModeFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsWithInvalidModeFails) {
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
@@ -946,7 +881,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsWithInvalidModeFails) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsInvalidCountFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsInvalidCountFails) {
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
@@ -966,7 +901,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsInvalidCountFails) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsOutOfRangeIndicesFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsOutOfRangeIndicesFails) {
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
@@ -980,7 +915,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsOutOfRangeIndicesFails) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsOddOffsetForUint16Fails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsOddOffsetForUint16Fails) {
   SetupVertexBuffer();
   SetupIndexBuffer();
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
@@ -993,7 +928,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsOddOffsetForUint16Fails) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsInstancedANGLEFails) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsInstancedANGLEFails) {
   SetupTexture();
   SetupVertexBuffer();
   SetupIndexBuffer();
@@ -1010,7 +945,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsInstancedANGLEFails) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLENoAttributesFails) {
   SetupTexture();
   SetupIndexBuffer();
@@ -1025,7 +960,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLESimulatedAttrib0) {
   SetupTexture();
   SetupVertexBuffer();
@@ -1057,7 +992,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLEMissingAttributesFails) {
   SetupIndexBuffer();
   DoEnableVertexAttribArray(1);
@@ -1071,7 +1006,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLEMissingAttributesZeroCountSucceeds) {
   SetupIndexBuffer();
   DoEnableVertexAttribArray(1);
@@ -1085,7 +1020,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLEValidAttributesSucceeds) {
   SetupIndexBuffer();
   SetupTexture();
@@ -1110,7 +1045,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLEWithInvalidModeFails) {
   SetupIndexBuffer();
   SetupVertexBuffer();
@@ -1130,7 +1065,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
 }
 
 // Per-instance data is twice as large, but number of instances is half
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLELargeInstanceSucceeds) {
   SetupTexture();
   SetupIndexBuffer();
@@ -1160,7 +1095,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
 }
 
 // Per-instance data is twice as large, but divisor is twice
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLELargeDivisorSucceeds) {
   SetupTexture();
   SetupIndexBuffer();
@@ -1186,7 +1121,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLELargeFails) {
   SetupTexture();
   SetupIndexBuffer();
@@ -1216,7 +1151,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLEInvalidPrimcountFails) {
   SetupTexture();
   SetupIndexBuffer();
@@ -1238,7 +1173,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
 }
 
 // Per-index data is twice as large, but values of indices are smaller
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLELargeIndexSucceeds) {
   SetupTexture();
   SetupIndexBuffer();
@@ -1264,7 +1199,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderGeometryInstancingTest,
+TEST_F(GLES2DecoderGeometryInstancingTest,
        DrawElementsInstancedANGLENoDivisor0Fails) {
   SetupTexture();
   SetupIndexBuffer();
@@ -1286,7 +1221,7 @@ TEST_P(GLES2DecoderGeometryInstancingTest,
   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;
@@ -1313,7 +1248,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetVertexAttribPointervSucceeds) {
   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_);
@@ -1348,7 +1283,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetVertexAttribPointervBadArgsFails) {
   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;
@@ -1363,7 +1298,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformivSucceeds) {
             result->size);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) {
   GetUniformiv::Result* result =
       static_cast<GetUniformiv::Result*>(shared_memory_address_);
   result->size = 0;
@@ -1379,7 +1314,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) {
             result->size);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadProgramFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetUniformivBadProgramFails) {
   GetUniformiv::Result* result =
       static_cast<GetUniformiv::Result*>(shared_memory_address_);
   result->size = 0;
@@ -1421,7 +1356,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadProgramFails) {
   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;
@@ -1436,7 +1371,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadLocationFails) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadSharedMemoryFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetUniformivBadSharedMemoryFails) {
   GetUniformiv cmd;
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
@@ -1449,7 +1384,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadSharedMemoryFails) {
   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;
@@ -1464,7 +1399,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformfvSucceeds) {
             result->size);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) {
   GetUniformfv::Result* result =
       static_cast<GetUniformfv::Result*>(shared_memory_address_);
   result->size = 0;
@@ -1480,7 +1415,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) {
             result->size);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadProgramFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetUniformfvBadProgramFails) {
   GetUniformfv::Result* result =
       static_cast<GetUniformfv::Result*>(shared_memory_address_);
   result->size = 0;
@@ -1522,7 +1457,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadProgramFails) {
   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;
@@ -1537,7 +1472,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadLocationFails) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadSharedMemoryFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetUniformfvBadSharedMemoryFails) {
   GetUniformfv cmd;
   cmd.Init(client_program_id_,
            kUniform2FakeLocation,
@@ -1550,7 +1485,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadSharedMemoryFails) {
   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_);
@@ -1566,7 +1501,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersSucceeds) {
   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_);
@@ -1578,7 +1513,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersResultNotInitFail) {
   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_);
@@ -1592,7 +1527,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersBadProgramFails) {
   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_,
@@ -1605,7 +1540,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersBadSharedMemoryFails) {
   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;
@@ -1627,7 +1562,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatSucceeds) {
   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_);
@@ -1638,7 +1573,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatResultNotInitFails) {
   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;
@@ -1654,7 +1589,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatBadArgsFails) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        GetShaderPrecisionFormatBadSharedMemoryFails) {
   GetShaderPrecisionFormat cmd;
   cmd.Init(GL_VERTEX_SHADER, GL_HIGH_FLOAT,
@@ -1665,7 +1600,7 @@ TEST_P(GLES2DecoderWithShaderTest,
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) {
   const GLuint kUniformIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveUniform cmd;
@@ -1685,7 +1620,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) {
                       bucket->size()));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) {
   const GLuint kUniformIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveUniform cmd;
@@ -1697,7 +1632,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) {
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) {
   const GLuint kUniformIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveUniform cmd;
@@ -1719,7 +1654,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) {
 #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;
@@ -1732,7 +1667,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadIndexFails) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) {
   const GLuint kUniformIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveUniform cmd;
@@ -1744,7 +1679,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) {
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) {
+TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) {
   const GLuint kAttribIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveAttrib cmd;
@@ -1764,7 +1699,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) {
                       bucket->size()));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) {
   const GLuint kAttribIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveAttrib cmd;
@@ -1776,7 +1711,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) {
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) {
   const GLuint kAttribIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveAttrib cmd;
@@ -1798,7 +1733,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) {
 #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;
@@ -1811,7 +1746,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadIndexFails) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
+TEST_F(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
   const GLuint kAttribIndex = 1;
   const uint32 kBucketId = 123;
   GetActiveAttrib cmd;
@@ -1823,7 +1758,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
   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;
@@ -1852,7 +1787,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
+TEST_F(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
   const uint32 kBucketId = 123;
   GetShaderInfoLog cmd;
   cmd.Init(kInvalidClientId, kBucketId);
@@ -1860,7 +1795,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, GetIntegervCached) {
+TEST_F(GLES2DecoderTest, GetIntegervCached) {
   struct TestInfo {
     GLenum pname;
     GLint expected;
@@ -1892,7 +1827,7 @@ TEST_P(GLES2DecoderTest, GetIntegervCached) {
   }
 }
 
-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, _))
@@ -1903,7 +1838,7 @@ TEST_P(GLES2DecoderTest, CompileShaderValidArgs) {
   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));
@@ -1915,7 +1850,7 @@ TEST_P(GLES2DecoderTest, CompileShaderInvalidArgs) {
 #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;
@@ -1935,7 +1870,7 @@ TEST_P(GLES2DecoderTest, ShaderSourceAndGetShaderSourceValidArgs) {
                       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);
@@ -1961,7 +1896,7 @@ TEST_P(GLES2DecoderTest, ShaderSourceInvalidArgs) {
   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";
@@ -1981,7 +1916,7 @@ TEST_P(GLES2DecoderTest, ShaderSourceBucketAndGetShaderSourceValidArgs) {
                       bucket->size()));
 }
 
-TEST_P(GLES2DecoderTest, ShaderSourceBucketInvalidArgs) {
+TEST_F(GLES2DecoderTest, ShaderSourceBucketInvalidArgs) {
   const uint32 kBucketId = 123;
   const char kSource[] = "hello";
   const uint32 kSourceSize = sizeof(kSource) - 1;
@@ -1997,7 +1932,7 @@ TEST_P(GLES2DecoderTest, ShaderSourceBucketInvalidArgs) {
   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);
@@ -2007,7 +1942,7 @@ TEST_P(GLES2DecoderTest, ShaderSourceStripComments) {
   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);
@@ -2020,7 +1955,7 @@ TEST_P(GLES2DecoderTest, GenerateMipmapWrongFormatsFails) {
   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_);
@@ -2045,7 +1980,7 @@ TEST_P(GLES2DecoderTest, GenerateMipmapHandlesOutOfMemory) {
   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);
@@ -2067,7 +2002,7 @@ TEST_P(GLES2DecoderTest, GenerateMipmapClearsUnclearedTexture) {
 
 // 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,
@@ -2104,14 +2039,14 @@ TEST_P(GLES2DecoderManualInitTest, SetTextureFiltersBeforeGenerateMipmap) {
   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_)));
@@ -2121,7 +2056,7 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform1ivValidArgs) {
   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,
@@ -2129,7 +2064,7 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_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,
@@ -2137,7 +2072,7 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
+TEST_F(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
   EXPECT_CALL(
       *gl_,
@@ -2150,7 +2085,7 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
-TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidValidArgs) {
+TEST_F(GLES2DecoderWithShaderTest, Uniform1ivInvalidValidArgs) {
   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
   Uniform1iv cmd;
   cmd.Init(kUniform1FakeLocation,
@@ -2159,7 +2094,7 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidValidArgs) {
   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,
@@ -2168,7 +2103,7 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform1ivZeroCount) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, Uniform1iSamplerIsLmited) {
+TEST_F(GLES2DecoderWithShaderTest, Uniform1iSamplerIsLmited) {
   EXPECT_CALL(*gl_, Uniform1i(_, _)).Times(0);
   Uniform1i cmd;
   cmd.Init(
@@ -2178,7 +2113,7 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform1iSamplerIsLmited) {
   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 };
@@ -2189,7 +2124,7 @@ TEST_P(GLES2DecoderWithShaderTest, Uniform1ivSamplerIsLimited) {
   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
@@ -2203,7 +2138,7 @@ TEST_P(GLES2DecoderWithShaderTest, BindBufferToDifferentTargetFails) {
   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;
@@ -2212,7 +2147,7 @@ TEST_P(GLES2DecoderTest, ActiveTextureValidArgs) {
   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;
@@ -2224,7 +2159,7 @@ TEST_P(GLES2DecoderTest, ActiveTextureInvalidArgs) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, CheckFramebufferStatusWithNoBoundTarget) {
+TEST_F(GLES2DecoderTest, CheckFramebufferStatusWithNoBoundTarget) {
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(_))
       .Times(0);
   CheckFramebufferStatus::Result* result =
@@ -2236,7 +2171,7 @@ TEST_P(GLES2DecoderTest, CheckFramebufferStatusWithNoBoundTarget) {
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE), *result);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, BindAndDeleteFramebuffer) {
+TEST_F(GLES2DecoderWithShaderTest, BindAndDeleteFramebuffer) {
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDefaultDirtyState();
@@ -2255,7 +2190,7 @@ TEST_P(GLES2DecoderWithShaderTest, BindAndDeleteFramebuffer) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, FramebufferRenderbufferWithNoBoundTarget) {
+TEST_F(GLES2DecoderTest, FramebufferRenderbufferWithNoBoundTarget) {
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(_, _, _, _))
       .Times(0);
   FramebufferRenderbuffer cmd;
@@ -2266,7 +2201,7 @@ TEST_P(GLES2DecoderTest, FramebufferRenderbufferWithNoBoundTarget) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, FramebufferTexture2DWithNoBoundTarget) {
+TEST_F(GLES2DecoderTest, FramebufferTexture2DWithNoBoundTarget) {
   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _))
       .Times(0);
   FramebufferTexture2D cmd;
@@ -2277,7 +2212,7 @@ TEST_P(GLES2DecoderTest, FramebufferTexture2DWithNoBoundTarget) {
   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))
@@ -2293,7 +2228,7 @@ TEST_P(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithNoBoundTarget) {
   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())
@@ -2331,7 +2266,7 @@ TEST_P(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithRenderbuffer) {
   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())
@@ -2369,7 +2304,7 @@ TEST_P(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithTexture) {
   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))
@@ -2384,7 +2319,7 @@ TEST_P(GLES2DecoderTest, GetRenderbufferParameterivWithNoBoundTarget) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest, RenderbufferStorageWithNoBoundTarget) {
+TEST_F(GLES2DecoderTest, RenderbufferStorageWithNoBoundTarget) {
   EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _))
       .Times(0);
   RenderbufferStorage cmd;
@@ -2584,7 +2519,7 @@ void GLES2DecoderTest::CheckReadPixelsOutOfRange(
   }
 }
 
-TEST_P(GLES2DecoderTest, ReadPixels) {
+TEST_F(GLES2DecoderTest, ReadPixels) {
   const GLsizei kWidth = 5;
   const GLsizei kHeight = 3;
   const GLint kBytesPerPixel = 3;
@@ -2626,7 +2561,7 @@ TEST_P(GLES2DecoderTest, ReadPixels) {
   }
 }
 
-TEST_P(GLES2DecoderRGBBackbufferTest, ReadPixelsNoAlphaBackbuffer) {
+TEST_F(GLES2DecoderRGBBackbufferTest, ReadPixelsNoAlphaBackbuffer) {
   const GLsizei kWidth = 3;
   const GLsizei kHeight = 3;
   const GLint kBytesPerPixel = 4;
@@ -2674,7 +2609,7 @@ TEST_P(GLES2DecoderRGBBackbufferTest, ReadPixelsNoAlphaBackbuffer) {
   }
 }
 
-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
@@ -2691,7 +2626,7 @@ TEST_P(GLES2DecoderTest, ReadPixelsOutOfRange) {
   }
 }
 
-TEST_P(GLES2DecoderTest, ReadPixelsInvalidArgs) {
+TEST_F(GLES2DecoderTest, ReadPixelsInvalidArgs) {
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
   uint32 result_shm_id = kSharedMemoryId;
@@ -2740,7 +2675,7 @@ TEST_P(GLES2DecoderTest, ReadPixelsInvalidArgs) {
   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";
@@ -2783,7 +2718,7 @@ TEST_P(GLES2DecoderManualInitTest, ReadPixelsAsyncError) {
   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);
@@ -2797,7 +2732,7 @@ TEST_P(GLES2DecoderTest, BindAttribLocation) {
   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";
@@ -2826,7 +2761,7 @@ TEST_P(GLES2DecoderTest, BindAttribLocationInvalidArgs) {
   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";
@@ -2839,7 +2774,7 @@ TEST_P(GLES2DecoderTest, BindAttribLocationBucket) {
   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";
@@ -2859,7 +2794,7 @@ TEST_P(GLES2DecoderTest, BindAttribLocationBucketInvalidArgs) {
   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);
@@ -2886,7 +2821,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetAttribLocation) {
   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);
@@ -2944,7 +2879,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) {
   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;
@@ -2964,7 +2899,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationBucket) {
   EXPECT_EQ(-1, *result);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationBucketInvalidArgs) {
+TEST_F(GLES2DecoderWithShaderTest, GetAttribLocationBucketInvalidArgs) {
   const uint32 kBucketId = 123;
   typedef GetAttribLocationBucket::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
@@ -2992,7 +2927,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationBucketInvalidArgs) {
   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);
@@ -3019,7 +2954,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformLocation) {
   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);
@@ -3077,7 +3012,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationInvalidArgs) {
   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;
@@ -3097,7 +3032,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationBucket) {
   EXPECT_EQ(-1, *result);
 }
 
-TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationBucketInvalidArgs) {
+TEST_F(GLES2DecoderWithShaderTest, GetUniformLocationBucketInvalidArgs) {
   const uint32 kBucketId = 123;
   typedef GetUniformLocationBucket::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
@@ -3125,7 +3060,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationBucketInvalidArgs) {
   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_);
@@ -3180,7 +3115,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetMaxValueInBufferCHROMIUM) {
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, SharedIds) {
+TEST_F(GLES2DecoderTest, SharedIds) {
   GenSharedIdsCHROMIUM gen_cmd;
   RegisterSharedIdsCHROMIUM reg_cmd;
   DeleteSharedIdsCHROMIUM del_cmd;
@@ -3251,7 +3186,7 @@ TEST_P(GLES2DecoderTest, SharedIds) {
   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);
@@ -3262,7 +3197,7 @@ TEST_P(GLES2DecoderTest, GenSharedIdsCHROMIUMBadArgs) {
   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);
@@ -3273,7 +3208,7 @@ TEST_P(GLES2DecoderTest, RegisterSharedIdsCHROMIUMBadArgs) {
   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;
@@ -3286,7 +3221,7 @@ TEST_P(GLES2DecoderTest, RegisterSharedIdsCHROMIUMDuplicateIds) {
   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);
@@ -3297,7 +3232,7 @@ TEST_P(GLES2DecoderTest, DeleteSharedIdsCHROMIUMBadArgs) {
   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);
@@ -3317,7 +3252,7 @@ TEST_P(GLES2DecoderTest, TexSubImage2DValidArgs) {
   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);
@@ -3378,7 +3313,7 @@ TEST_P(GLES2DecoderTest, TexSubImage2DBadArgs) {
   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);
@@ -3395,7 +3330,7 @@ TEST_P(GLES2DecoderTest, CopyTexSubImage2DValidArgs) {
   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);
@@ -3428,15 +3363,7 @@ TEST_P(GLES2DecoderTest, CopyTexSubImage2DBadArgs) {
 
 // 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;
@@ -3453,7 +3380,6 @@ TEST_P(GLES2DecoderManualInitTest, FramebufferRenderbufferClearColor) {
   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();
@@ -3471,7 +3397,7 @@ TEST_P(GLES2DecoderManualInitTest, FramebufferRenderbufferClearColor) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearDepth) {
+TEST_F(GLES2DecoderTest, FramebufferRenderbufferClearDepth) {
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   ClearDepthf depth_cmd;
@@ -3502,7 +3428,7 @@ TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearDepth) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearStencil) {
+TEST_F(GLES2DecoderTest, FramebufferRenderbufferClearStencil) {
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   ClearStencil stencil_cmd;
@@ -3533,7 +3459,7 @@ TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearStencil) {
   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_));
@@ -3541,7 +3467,7 @@ TEST_P(GLES2DecoderTest, IsBuffer) {
   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);
@@ -3553,7 +3479,7 @@ TEST_P(GLES2DecoderTest, IsFramebuffer) {
   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))
@@ -3564,7 +3490,7 @@ TEST_P(GLES2DecoderTest, IsProgram) {
 
 }
 
-TEST_P(GLES2DecoderTest, IsRenderbuffer) {
+TEST_F(GLES2DecoderTest, IsRenderbuffer) {
   EXPECT_FALSE(DoIsRenderbuffer(client_renderbuffer_id_));
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
@@ -3573,14 +3499,14 @@ TEST_P(GLES2DecoderTest, IsRenderbuffer) {
   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_));
@@ -3589,7 +3515,7 @@ TEST_P(GLES2DecoderTest, IsTexture) {
 }
 
 #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;
@@ -3618,7 +3544,7 @@ TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearDepthStencil) {
 }
 #endif
 
-TEST_P(GLES2DecoderWithShaderTest, VertexAttribPointer) {
+TEST_F(GLES2DecoderWithShaderTest, VertexAttribPointer) {
   SetupVertexBuffer();
   static const GLenum types[] = {
     GL_BYTE,
@@ -3758,7 +3684,7 @@ TEST_P(GLES2DecoderWithShaderTest, VertexAttribPointer) {
 
 // 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));
@@ -3766,15 +3692,19 @@ TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMask) {
 
   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)
@@ -3808,7 +3738,7 @@ TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMask) {
 
 // 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();
@@ -3819,15 +3749,19 @@ TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferDepthMask) {
 
   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)
@@ -3858,7 +3792,7 @@ TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferDepthMask) {
 
 // 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)
@@ -3870,15 +3804,19 @@ TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferStencilMask) {
 
   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)
@@ -3908,7 +3846,7 @@ TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferStencilMask) {
 }
 
 // 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));
@@ -3922,15 +3860,19 @@ TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMaskFBO) {
   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)
@@ -3967,15 +3909,19 @@ TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMaskFBO) {
       .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)
@@ -3993,15 +3939,19 @@ TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMaskFBO) {
   // 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)
@@ -4010,98 +3960,7 @@ TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMaskFBO) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, CachedColorMask) {
-  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) {
+TEST_F(GLES2DecoderManualInitTest, ActualAlphaMatchesRequestedAlpha) {
   InitState init;
   init.gl_version = "3.0";
   init.has_alpha = true;
@@ -4129,7 +3988,7 @@ TEST_P(GLES2DecoderManualInitTest, ActualAlphaMatchesRequestedAlpha) {
   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;
@@ -4156,7 +4015,7 @@ TEST_P(GLES2DecoderManualInitTest, ActualAlphaDoesNotMatchRequestedAlpha) {
   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;
@@ -4184,7 +4043,7 @@ TEST_P(GLES2DecoderManualInitTest, ActualDepthMatchesRequestedDepth) {
   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;
@@ -4211,7 +4070,7 @@ TEST_P(GLES2DecoderManualInitTest, ActualDepthDoesNotMatchRequestedDepth) {
   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;
@@ -4239,7 +4098,7 @@ TEST_P(GLES2DecoderManualInitTest, ActualStencilMatchesRequestedStencil) {
   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;
@@ -4266,7 +4125,7 @@ TEST_P(GLES2DecoderManualInitTest, ActualStencilDoesNotMatchRequestedStencil) {
   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;
@@ -4282,15 +4141,20 @@ TEST_P(GLES2DecoderManualInitTest, DepthEnableWithDepth) {
   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)
@@ -4320,7 +4184,7 @@ TEST_P(GLES2DecoderManualInitTest, DepthEnableWithDepth) {
   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;
@@ -4335,15 +4199,19 @@ TEST_P(GLES2DecoderManualInitTest, DepthEnableWithoutRequestedDepth) {
   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)
@@ -4373,7 +4241,7 @@ TEST_P(GLES2DecoderManualInitTest, DepthEnableWithoutRequestedDepth) {
   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;
@@ -4389,15 +4257,19 @@ TEST_P(GLES2DecoderManualInitTest, StencilEnableWithStencil) {
   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)
@@ -4427,7 +4299,7 @@ TEST_P(GLES2DecoderManualInitTest, StencilEnableWithStencil) {
   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;
@@ -4442,15 +4314,19 @@ TEST_P(GLES2DecoderManualInitTest, StencilEnableWithoutRequestedStencil) {
   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)
@@ -4480,7 +4356,7 @@ TEST_P(GLES2DecoderManualInitTest, StencilEnableWithoutRequestedStencil) {
   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";
@@ -4524,7 +4400,7 @@ TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilReportsCorrectValues) {
   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";
@@ -4567,7 +4443,7 @@ TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilNoRequestedStencil) {
   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";
@@ -4634,7 +4510,7 @@ TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilRenderbufferDepth) {
   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";
@@ -4701,7 +4577,7 @@ TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilRenderbufferStencil) {
   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;
@@ -4737,7 +4613,7 @@ TEST_P(GLES2DecoderTest, GetMultipleIntegervCHROMIUMValidArgs) {
   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);
@@ -4831,7 +4707,7 @@ TEST_P(GLES2DecoderTest, GetMultipleIntegervCHROMIUMInvalidArgs) {
   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);
@@ -4873,7 +4749,7 @@ TEST_P(GLES2DecoderTest, TexImage2DRedefinitionSucceeds) {
   }
 }
 
-TEST_P(GLES2DecoderTest, TexImage2DGLError) {
+TEST_F(GLES2DecoderTest, TexImage2DGLError) {
   GLenum target = GL_TEXTURE_2D;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
@@ -4904,7 +4780,7 @@ TEST_P(GLES2DecoderTest, TexImage2DGLError) {
   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);
@@ -4926,7 +4802,7 @@ TEST_P(GLES2DecoderTest, BufferDataGLError) {
   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;
@@ -4954,7 +4830,7 @@ TEST_P(GLES2DecoderTest, CopyTexImage2DGLError) {
   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())
@@ -4974,7 +4850,7 @@ TEST_P(GLES2DecoderTest, FramebufferRenderbufferGLError) {
   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;
@@ -5000,7 +4876,7 @@ TEST_P(GLES2DecoderTest, FramebufferTexture2DGLError) {
   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())
@@ -5017,7 +4893,7 @@ TEST_P(GLES2DecoderTest, RenderbufferStorageGLError) {
   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(_, _, _, _))
@@ -5032,7 +4908,7 @@ TEST_P(GLES2DecoderTest, RenderbufferStorageBadArgs) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest,
+TEST_F(GLES2DecoderManualInitTest,
        RenderbufferStorageMultisampleCHROMIUMGLError) {
   InitState init;
   init.extensions = "GL_EXT_framebuffer_multisample";
@@ -5055,7 +4931,7 @@ TEST_P(GLES2DecoderManualInitTest,
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest,
+TEST_F(GLES2DecoderManualInitTest,
        RenderbufferStorageMultisampleCHROMIUMBadArgs) {
   InitState init;
   init.extensions = "GL_EXT_framebuffer_multisample";
@@ -5082,7 +4958,7 @@ TEST_P(GLES2DecoderManualInitTest,
   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";
@@ -5112,7 +4988,7 @@ TEST_P(GLES2DecoderManualInitTest, RenderbufferStorageMultisampleCHROMIUM) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest,
+TEST_F(GLES2DecoderManualInitTest,
        RenderbufferStorageMultisampleEXTNotSupported) {
   InitState init;
   init.extensions = "GL_EXT_framebuffer_multisample";
@@ -5131,90 +5007,65 @@ TEST_P(GLES2DecoderManualInitTest,
 }
 
 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());
-  }
-};
-
-TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
-       NotCompatibleWithRenderbufferStorageMultisampleCHROMIUM_EXT) {
-  Init("GL_EXT_multisampled_render_to_texture");
-  TestNotCompatibleWithRenderbufferStorageMultisampleCHROMIUM();
-}
+    : public GLES2DecoderTestWithExtensionsOnGLES2 {};
 
 TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
-       NotCompatibleWithRenderbufferStorageMultisampleCHROMIUM_IMG) {
-  Init("GL_IMG_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,
-       RenderbufferStorageMultisampleEXT_EXT) {
-  Init("GL_EXT_multisampled_render_to_texture");
-  TestRenderbufferStorageMultisampleEXT(
-      "GL_EXT_multisampled_render_to_texture");
+       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_IMG) {
-  Init("GL_IMG_multisampled_render_to_texture");
-  TestRenderbufferStorageMultisampleEXT(
-      "GL_IMG_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(GLES2DecoderTest, ReadPixelsGLError) {
+TEST_F(GLES2DecoderTest, ReadPixelsGLError) {
   GLenum kFormat = GL_RGBA;
   GLint x = 0;
   GLint y = 0;
@@ -5243,7 +5094,7 @@ TEST_P(GLES2DecoderTest, ReadPixelsGLError) {
   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,
@@ -5253,7 +5104,7 @@ TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsS3TC) {
   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,
@@ -5262,7 +5113,7 @@ TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsATC) {
   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,
@@ -5272,14 +5123,14 @@ TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsPVRTC) {
   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;
@@ -5318,7 +5169,7 @@ TEST_P(GLES2DecoderManualInitTest, GetNoCompressedTextureFormats) {
   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";
@@ -5348,7 +5199,7 @@ struct S3TCTestData {
 
 }  // anonymous namespace.
 
-TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
+TEST_F(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
   InitState init;
   init.extensions = "GL_EXT_texture_compression_s3tc";
   init.gl_version = "3.0";
@@ -5498,7 +5349,7 @@ TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
   }
 }
 
-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";
@@ -5566,7 +5417,7 @@ TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DETC1) {
   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);
@@ -5575,7 +5426,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) {
   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);
@@ -5594,7 +5445,7 @@ TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMInvalidArgs) {
   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";
@@ -5612,7 +5463,7 @@ TEST_P(GLES2DecoderManualInitTest, EGLImageExternalBindTexture) {
   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";
@@ -5641,7 +5492,7 @@ TEST_P(GLES2DecoderManualInitTest, EGLImageExternalGetBinding) {
   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";
@@ -5658,7 +5509,7 @@ TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureDefaults) {
   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";
@@ -5712,7 +5563,7 @@ TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureParam) {
   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";
@@ -5748,7 +5599,7 @@ TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureParamInvalid) {
   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";
@@ -5774,7 +5625,7 @@ TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTexImage2DError) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, BindGeneratesResourceFalse) {
+TEST_F(GLES2DecoderManualInitTest, BindGeneratesResourceFalse) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -5800,7 +5651,7 @@ TEST_P(GLES2DecoderManualInitTest, BindGeneratesResourceFalse) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, DefaultTextureZero) {
+TEST_F(GLES2DecoderManualInitTest, DefaultTextureZero) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -5818,7 +5669,7 @@ TEST_P(GLES2DecoderManualInitTest, DefaultTextureZero) {
   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;
@@ -5841,7 +5692,7 @@ TEST_P(GLES2DecoderManualInitTest, DefaultTextureBGR) {
 }
 
 // Test that default texture 0 is immutable.
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameterf) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexParameterf) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -5873,7 +5724,7 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameterf) {
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameteri) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexParameteri) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -5905,7 +5756,7 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameteri) {
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameterfv) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexParameterfv) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -5945,7 +5796,7 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameterfv) {
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameteriv) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexParameteriv) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -5985,7 +5836,7 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameteriv) {
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexImage2D) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexImage2D) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -6011,7 +5862,7 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexImage2D) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest, NoDefaultTexSubImage2D) {
+TEST_F(GLES2DecoderManualInitTest, NoDefaultTexSubImage2D) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -6038,7 +5889,7 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexSubImage2D) {
   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";
@@ -6056,7 +5907,7 @@ TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleBindTexture) {
   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";
@@ -6086,7 +5937,7 @@ TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleGetBinding) {
   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";
@@ -6103,7 +5954,7 @@ TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureDefaults) {
   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";
@@ -6158,7 +6009,7 @@ TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParam) {
   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";
@@ -6195,7 +6046,7 @@ TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParamInvalid) {
   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";
@@ -6222,29 +6073,21 @@ TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTexImage2DError) {
   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);
@@ -6270,7 +6113,7 @@ TEST_P(GLES2DecoderManualInitTest, TexSubImage2DClearsAfterTexImage2DNULL) {
   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);
@@ -6296,7 +6139,7 @@ TEST_P(GLES2DecoderTest, TexSubImage2DDoesNotClearAfterTexImage2DNULLThenData) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(
+TEST_F(
     GLES2DecoderManualInitTest,
     TexSubImage2DDoesNotClearAfterTexImage2DNULLThenDataWithTexImage2DIsFaster) {
   CommandLine command_line(0, NULL);
@@ -6352,7 +6195,7 @@ TEST_P(
   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,
@@ -6379,7 +6222,7 @@ TEST_P(GLES2DecoderTest, TexSubImage2DClearsAfterTexImage2DWithDataThenNULL) {
   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.
@@ -6411,7 +6254,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawArraysClearsAfterTexImage2DNULL) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawElementsClearsAfterTexImage2DNULL) {
+TEST_F(GLES2DecoderWithShaderTest, DrawElementsClearsAfterTexImage2DNULL) {
   SetupAllNeededVertexBuffers();
   SetupIndexBuffer();
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
@@ -6450,7 +6293,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawElementsClearsAfterTexImage2DNULL) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterTexImage2DNULLInFBO) {
+TEST_F(GLES2DecoderWithShaderTest, DrawClearsAfterTexImage2DNULLInFBO) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
@@ -6482,15 +6325,19 @@ TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterTexImage2DNULLInFBO) {
       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)
@@ -6508,7 +6355,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterTexImage2DNULLInFBO) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawWitFBOThatCantClearDoesNotDraw) {
+TEST_F(GLES2DecoderWithShaderTest, DrawWitFBOThatCantClearDoesNotDraw) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
@@ -6543,7 +6390,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawWitFBOThatCantClearDoesNotDraw) {
   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();
@@ -6567,7 +6414,7 @@ TEST_P(GLES2DecoderTest, CopyTexImage2DMarksTextureAsCleared) {
   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);
@@ -6583,7 +6430,7 @@ TEST_P(GLES2DecoderTest, CopyTexSubImage2DClearsUnclearedTexture) {
   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";
@@ -6610,7 +6457,7 @@ TEST_P(GLES2DecoderManualInitTest, CompressedImage2DMarksTextureAsCleared) {
   EXPECT_TRUE(texture_ref->texture()->SafeToRenderFrom());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnClear) {
+TEST_F(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnClear) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
@@ -6640,15 +6487,19 @@ TEST_P(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnClear) {
       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)
@@ -6660,7 +6511,7 @@ TEST_P(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnClear) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnReadPixels) {
+TEST_F(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnReadPixels) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
@@ -6713,7 +6564,7 @@ TEST_P(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnReadPixels) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderManualInitTest,
+TEST_F(GLES2DecoderManualInitTest,
        UnClearedAttachmentsGetClearedOnReadPixelsAndDrawBufferGetsRestored) {
   InitState init;
   init.extensions = "GL_EXT_framebuffer_multisample";
@@ -6739,22 +6590,15 @@ TEST_P(GLES2DecoderManualInitTest,
       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))
@@ -6777,7 +6621,7 @@ TEST_P(GLES2DecoderManualInitTest,
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterRenderbufferStorageInFBO) {
+TEST_F(GLES2DecoderWithShaderTest, DrawClearsAfterRenderbufferStorageInFBO) {
   SetupTexture();
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
@@ -6798,15 +6642,19 @@ TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterRenderbufferStorageInFBO) {
       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)
@@ -6817,15 +6665,7 @@ TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterRenderbufferStorageInFBO) {
   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,
@@ -6867,7 +6707,7 @@ TEST_P(GLES2DecoderManualInitTest, DrawArraysClearsAfterTexImage2DNULLCubemap) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest, TextureUsageAngleExtNotEnabledByDefault) {
+TEST_F(GLES2DecoderTest, TextureUsageAngleExtNotEnabledByDefault) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   TexParameteri cmd;
@@ -6878,7 +6718,7 @@ TEST_P(GLES2DecoderTest, TextureUsageAngleExtNotEnabledByDefault) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        DrawClearsAfterRenderbuffersWithMultipleAttachments) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
@@ -6920,15 +6760,19 @@ TEST_P(GLES2DecoderWithShaderTest,
       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)
@@ -6939,7 +6783,7 @@ TEST_P(GLES2DecoderWithShaderTest,
   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;
@@ -7012,12 +6856,12 @@ void GLES2DecoderWithShaderTest::CheckRenderbufferChangesMarkFBOAsNotComplete(
       bound_fbo, GL_FRAMEBUFFER, 0);
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        RenderbufferChangesMarkFBOAsNotCompleteBoundFBO) {
   CheckRenderbufferChangesMarkFBOAsNotComplete(true);
 }
 
-TEST_P(GLES2DecoderWithShaderTest,
+TEST_F(GLES2DecoderWithShaderTest,
        RenderbufferChangesMarkFBOAsNotCompleteUnboundFBO) {
   CheckRenderbufferChangesMarkFBOAsNotComplete(false);
 }
@@ -7106,16 +6950,16 @@ void GLES2DecoderWithShaderTest::CheckTextureChangesMarkFBOAsNotComplete(
       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;
@@ -7147,15 +6991,19 @@ TEST_P(GLES2DecoderWithShaderTest,
       .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)
@@ -7173,11 +7021,11 @@ TEST_P(GLES2DecoderWithShaderTest,
   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";
@@ -7364,7 +7212,7 @@ static void CheckBeginEndQueryBadMemoryFails(
   test->ResetDecoder();
 }
 
-TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryIdFails) {
+TEST_F(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryIdFails) {
   for (size_t i = 0; i < arraysize(kQueryTypes); ++i) {
     CheckBeginEndQueryBadMemoryFails(
         this, kNewClientId, kNewServiceId,
@@ -7373,7 +7221,7 @@ TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryIdFails) {
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryOffsetFails) {
+TEST_F(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryOffsetFails) {
   for (size_t i = 0; i < arraysize(kQueryTypes); ++i) {
     // Out-of-bounds.
     CheckBeginEndQueryBadMemoryFails(
@@ -7388,7 +7236,7 @@ TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryOffsetFails) {
   }
 }
 
-TEST_P(GLES2DecoderTest, BeginEndQueryEXTCommandsIssuedCHROMIUM) {
+TEST_F(GLES2DecoderTest, BeginEndQueryEXTCommandsIssuedCHROMIUM) {
   BeginQueryEXT begin_cmd;
 
   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
@@ -7414,7 +7262,7 @@ TEST_P(GLES2DecoderTest, BeginEndQueryEXTCommandsIssuedCHROMIUM) {
   EXPECT_FALSE(query->pending());
 }
 
-TEST_P(GLES2DecoderTest, BeginEndQueryEXTGetErrorQueryCHROMIUM) {
+TEST_F(GLES2DecoderTest, BeginEndQueryEXTGetErrorQueryCHROMIUM) {
   BeginQueryEXT begin_cmd;
 
   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
@@ -7448,7 +7296,7 @@ TEST_P(GLES2DecoderTest, BeginEndQueryEXTGetErrorQueryCHROMIUM) {
             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";
@@ -7507,7 +7355,7 @@ TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTCommandsCompletedCHROMIUM) {
   ResetDecoder();
 }
 
-TEST_P(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
+TEST_F(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
   Mailbox mailbox = Mailbox::Generate();
 
   memcpy(shared_memory_address_, mailbox.name, sizeof(mailbox.name));
@@ -7590,7 +7438,8 @@ TEST_P(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
   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));
@@ -7599,7 +7448,7 @@ TEST_P(GLES2DecoderTest, CanChangeSurface) {
   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[] = {
@@ -7625,7 +7474,7 @@ TEST_P(GLES2DecoderTest, IsEnabledReturnsCachedValue) {
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, DepthTextureBadArgs) {
+TEST_F(GLES2DecoderManualInitTest, DepthTextureBadArgs) {
   InitState init;
   init.extensions = "GL_ANGLE_depth_texture";
   init.gl_version = "opengl es 2.0";
@@ -7677,7 +7526,7 @@ TEST_P(GLES2DecoderManualInitTest, DepthTextureBadArgs) {
   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";
@@ -7697,7 +7546,7 @@ TEST_P(GLES2DecoderManualInitTest, GenerateMipmapDepthTexture) {
   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";
@@ -7719,10 +7568,6 @@ TEST_P(GLES2DecoderManualInitTest, DrawClearsDepthTexture) {
   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();
@@ -7747,14 +7592,19 @@ TEST_P(GLES2DecoderManualInitTest, DrawClearsDepthTexture) {
   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)
@@ -7773,7 +7623,7 @@ TEST_P(GLES2DecoderManualInitTest, DrawClearsDepthTexture) {
   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);
@@ -8002,112 +7852,112 @@ class GLES2DecoderEmulatedVertexArraysOESTest
 };
 
 // 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);
@@ -8154,7 +8004,7 @@ TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUM) {
   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);
 
@@ -8164,7 +8014,7 @@ TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUMCubeMapNotAllowed) {
   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);
 
@@ -8182,7 +8032,7 @@ TEST_P(GLES2DecoderTest, OrphanGLImageWithTexImage2D) {
   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);
@@ -8253,7 +8103,7 @@ class MockGLImage : public gfx::GLImage {
   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);
@@ -8377,7 +8227,7 @@ TEST_P(GLES2DecoderWithShaderTest, UseTexImage) {
   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";
@@ -8451,7 +8301,7 @@ TEST_P(GLES2DecoderManualInitTest, DrawWithGLImageExternal) {
   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";
@@ -8487,7 +8337,7 @@ TEST_P(GLES2DecoderManualInitTest, GpuMemoryManagerCHROMIUM) {
   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";
@@ -8734,7 +8584,7 @@ TEST_P(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
   manager = NULL;
 }
 
-TEST_P(GLES2DecoderManualInitTest, AsyncPixelTransferManager) {
+TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransferManager) {
   InitState init;
   init.extensions = "GL_CHROMIUM_async_pixel_transfers";
   init.gl_version = "3.0";
@@ -8838,7 +8688,7 @@ class SizeOnlyMemoryTracker : public MemoryTracker {
 
 }  // anonymous namespace.
 
-TEST_P(GLES2DecoderManualInitTest, MemoryTrackerInitialSize) {
+TEST_F(GLES2DecoderManualInitTest, MemoryTrackerInitialSize) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
@@ -8851,7 +8701,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerInitialSize) {
   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());
@@ -8882,7 +8732,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexImage2D) {
   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());
@@ -8902,7 +8752,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexStorage2DEXT) {
   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;
@@ -8942,7 +8792,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerCopyTexImage2D) {
   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());
@@ -8976,7 +8826,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerRenderbufferStorage) {
   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());
@@ -9009,7 +8859,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerBufferData) {
   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 =
@@ -9026,7 +8876,7 @@ TEST_P(GLES2DecoderTest, DrawBuffersEXTImmediateSuccceeds) {
   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 =
@@ -9040,7 +8890,7 @@ TEST_P(GLES2DecoderTest, DrawBuffersEXTImmediateFails) {
   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 =
@@ -9064,7 +8914,7 @@ TEST_P(GLES2DecoderTest, DrawBuffersEXTImmediateBackbuffer) {
   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);
@@ -9078,7 +8928,7 @@ TEST_P(GLES2DecoderManualInitTest, InvalidateFramebufferBinding) {
       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";
@@ -9121,7 +8971,7 @@ TEST_P(GLES2DecoderManualInitTest, DiscardFramebufferEXT) {
   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 };
@@ -9135,7 +8985,7 @@ TEST_P(GLES2DecoderTest, DiscardFramebufferEXTUnsupported) {
   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;
@@ -9164,7 +9014,7 @@ TEST_P(GLES2DecoderRestoreStateTest, NullPreviousStateBGR) {
   GetDecoder()->RestoreAllTextureUnitBindings(NULL);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, NullPreviousState) {
+TEST_F(GLES2DecoderRestoreStateTest, NullPreviousState) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -9189,7 +9039,7 @@ TEST_P(GLES2DecoderRestoreStateTest, NullPreviousState) {
   GetDecoder()->RestoreAllTextureUnitBindings(NULL);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, WithPreviousStateBGR) {
+TEST_F(GLES2DecoderRestoreStateTest, WithPreviousStateBGR) {
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
@@ -9214,7 +9064,7 @@ TEST_P(GLES2DecoderRestoreStateTest, WithPreviousStateBGR) {
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, WithPreviousState) {
+TEST_F(GLES2DecoderRestoreStateTest, WithPreviousState) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -9238,7 +9088,7 @@ TEST_P(GLES2DecoderRestoreStateTest, WithPreviousState) {
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, ActiveUnit1) {
+TEST_F(GLES2DecoderRestoreStateTest, ActiveUnit1) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -9269,7 +9119,7 @@ TEST_P(GLES2DecoderRestoreStateTest, ActiveUnit1) {
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, NonDefaultUnit0BGR) {
+TEST_F(GLES2DecoderRestoreStateTest, NonDefaultUnit0BGR) {
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
@@ -9308,7 +9158,7 @@ TEST_P(GLES2DecoderRestoreStateTest, NonDefaultUnit0BGR) {
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, NonDefaultUnit1BGR) {
+TEST_F(GLES2DecoderRestoreStateTest, NonDefaultUnit1BGR) {
   InitState init;
   init.gl_version = "3.0";
   init.bind_generates_resource = true;
@@ -9341,7 +9191,7 @@ TEST_P(GLES2DecoderRestoreStateTest, NonDefaultUnit1BGR) {
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, DefaultUnit0) {
+TEST_F(GLES2DecoderRestoreStateTest, DefaultUnit0) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -9378,7 +9228,7 @@ TEST_P(GLES2DecoderRestoreStateTest, DefaultUnit0) {
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
-TEST_P(GLES2DecoderRestoreStateTest, DefaultUnit1) {
+TEST_F(GLES2DecoderRestoreStateTest, DefaultUnit1) {
   InitState init;
   init.gl_version = "3.0";
   InitDecoder(init);
@@ -9423,7 +9273,7 @@ TEST_P(GLES2DecoderRestoreStateTest, DefaultUnit1) {
 
 // TODO(vmiura): Tests for RestoreGlobalState().
 
-TEST_P(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) {
+TEST_F(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
@@ -9469,7 +9319,7 @@ TEST_P(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) {
   }
 }
 
-TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES2) {
+TEST_F(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES2) {
   InitState init;
   init.extensions = "GL_OES_texture_float";
   init.gl_version = "opengl es 2.0";
@@ -9485,7 +9335,7 @@ TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES2) {
                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";
@@ -9503,7 +9353,7 @@ TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES3) {
                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";
@@ -9526,7 +9376,7 @@ TEST_P(GLES2DecoderManualInitTest, TexSubImage2DFloatOnGLES3) {
   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";
@@ -9552,7 +9402,7 @@ TEST_P(GLES2DecoderManualInitTest, TexSubImage2DFloatDoesClearOnGLES3) {
   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";
@@ -9575,7 +9425,7 @@ TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatConvertsFormatDesktop) {
                                     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";
@@ -9637,7 +9487,7 @@ TEST_P(GLES2DecoderManualInitTest, ReadFormatExtension) {
   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;
@@ -9695,46 +9545,8 @@ TEST_P(GLES2DecoderManualInitTest, NoReadFormatExtension) {
   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
@@ -9767,39 +9579,5 @@ TEST_P(GLES2DecoderManualInitTest, ContextStateCapabilityCaching) {
 
 // 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
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1.cc
index f851473..7da87dd 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1.cc
@@ -37,8 +37,6 @@ class GLES2DecoderTest1 : public GLES2DecoderTestBase {
   GLES2DecoderTest1() { }
 };
 
-INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest1, ::testing::Bool());
-
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::GenerateMipmap, 0>(
     bool valid) {
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
index 4587fc4..17cf9c5 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
@@ -14,7 +14,7 @@
 
 // TODO(gman): ActiveTexture
 
-TEST_P(GLES2DecoderTest1, AttachShaderValidArgs) {
+TEST_F(GLES2DecoderTest1, AttachShaderValidArgs) {
   EXPECT_CALL(*gl_, AttachShader(kServiceProgramId, kServiceShaderId));
   SpecializedSetup<cmds::AttachShader, 0>(true);
   cmds::AttachShader cmd;
@@ -26,7 +26,7 @@ TEST_P(GLES2DecoderTest1, AttachShaderValidArgs) {
 
 // TODO(gman): BindAttribLocationBucket
 
-TEST_P(GLES2DecoderTest1, BindBufferValidArgs) {
+TEST_F(GLES2DecoderTest1, BindBufferValidArgs) {
   EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, kServiceBufferId));
   SpecializedSetup<cmds::BindBuffer, 0>(true);
   cmds::BindBuffer cmd;
@@ -35,7 +35,7 @@ TEST_P(GLES2DecoderTest1, BindBufferValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BindBufferValidArgsNewId) {
+TEST_F(GLES2DecoderTest1, BindBufferValidArgsNewId) {
   EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, kNewServiceId));
   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
@@ -47,7 +47,7 @@ TEST_P(GLES2DecoderTest1, BindBufferValidArgsNewId) {
   EXPECT_TRUE(GetBuffer(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, BindBufferInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, BindBufferInvalidArgs0_0) {
   EXPECT_CALL(*gl_, BindBuffer(_, _)).Times(0);
   SpecializedSetup<cmds::BindBuffer, 0>(false);
   cmds::BindBuffer cmd;
@@ -56,7 +56,7 @@ TEST_P(GLES2DecoderTest1, BindBufferInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BindFramebufferValidArgs) {
+TEST_F(GLES2DecoderTest1, BindFramebufferValidArgs) {
   EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER, kServiceFramebufferId));
   SpecializedSetup<cmds::BindFramebuffer, 0>(true);
   cmds::BindFramebuffer cmd;
@@ -65,7 +65,7 @@ TEST_P(GLES2DecoderTest1, BindFramebufferValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BindFramebufferValidArgsNewId) {
+TEST_F(GLES2DecoderTest1, BindFramebufferValidArgsNewId) {
   EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER, kNewServiceId));
   EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
@@ -77,7 +77,7 @@ TEST_P(GLES2DecoderTest1, BindFramebufferValidArgsNewId) {
   EXPECT_TRUE(GetFramebuffer(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, BindFramebufferInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, BindFramebufferInvalidArgs0_0) {
   EXPECT_CALL(*gl_, BindFramebufferEXT(_, _)).Times(0);
   SpecializedSetup<cmds::BindFramebuffer, 0>(false);
   cmds::BindFramebuffer cmd;
@@ -86,7 +86,7 @@ TEST_P(GLES2DecoderTest1, BindFramebufferInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BindFramebufferInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, BindFramebufferInvalidArgs0_1) {
   EXPECT_CALL(*gl_, BindFramebufferEXT(_, _)).Times(0);
   SpecializedSetup<cmds::BindFramebuffer, 0>(false);
   cmds::BindFramebuffer cmd;
@@ -95,7 +95,7 @@ TEST_P(GLES2DecoderTest1, BindFramebufferInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BindRenderbufferValidArgs) {
+TEST_F(GLES2DecoderTest1, BindRenderbufferValidArgs) {
   EXPECT_CALL(*gl_,
               BindRenderbufferEXT(GL_RENDERBUFFER, kServiceRenderbufferId));
   SpecializedSetup<cmds::BindRenderbuffer, 0>(true);
@@ -105,7 +105,7 @@ TEST_P(GLES2DecoderTest1, BindRenderbufferValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BindRenderbufferValidArgsNewId) {
+TEST_F(GLES2DecoderTest1, BindRenderbufferValidArgsNewId) {
   EXPECT_CALL(*gl_, BindRenderbufferEXT(GL_RENDERBUFFER, kNewServiceId));
   EXPECT_CALL(*gl_, GenRenderbuffersEXT(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
@@ -117,7 +117,7 @@ TEST_P(GLES2DecoderTest1, BindRenderbufferValidArgsNewId) {
   EXPECT_TRUE(GetRenderbuffer(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, BindRenderbufferInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, BindRenderbufferInvalidArgs0_0) {
   EXPECT_CALL(*gl_, BindRenderbufferEXT(_, _)).Times(0);
   SpecializedSetup<cmds::BindRenderbuffer, 0>(false);
   cmds::BindRenderbuffer cmd;
@@ -126,7 +126,7 @@ TEST_P(GLES2DecoderTest1, BindRenderbufferInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BindTextureValidArgs) {
+TEST_F(GLES2DecoderTest1, BindTextureValidArgs) {
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kServiceTextureId));
   SpecializedSetup<cmds::BindTexture, 0>(true);
   cmds::BindTexture cmd;
@@ -135,7 +135,7 @@ TEST_P(GLES2DecoderTest1, BindTextureValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BindTextureValidArgsNewId) {
+TEST_F(GLES2DecoderTest1, BindTextureValidArgsNewId) {
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kNewServiceId));
   EXPECT_CALL(*gl_, GenTextures(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
@@ -147,7 +147,7 @@ TEST_P(GLES2DecoderTest1, BindTextureValidArgsNewId) {
   EXPECT_TRUE(GetTexture(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, BindTextureInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, BindTextureInvalidArgs0_0) {
   EXPECT_CALL(*gl_, BindTexture(_, _)).Times(0);
   SpecializedSetup<cmds::BindTexture, 0>(false);
   cmds::BindTexture cmd;
@@ -156,7 +156,7 @@ TEST_P(GLES2DecoderTest1, BindTextureInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BindTextureInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, BindTextureInvalidArgs0_1) {
   EXPECT_CALL(*gl_, BindTexture(_, _)).Times(0);
   SpecializedSetup<cmds::BindTexture, 0>(false);
   cmds::BindTexture cmd;
@@ -165,7 +165,7 @@ TEST_P(GLES2DecoderTest1, BindTextureInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendColorValidArgs) {
+TEST_F(GLES2DecoderTest1, BlendColorValidArgs) {
   EXPECT_CALL(*gl_, BlendColor(1, 2, 3, 4));
   SpecializedSetup<cmds::BlendColor, 0>(true);
   cmds::BlendColor cmd;
@@ -174,7 +174,7 @@ TEST_P(GLES2DecoderTest1, BlendColorValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendEquationValidArgs) {
+TEST_F(GLES2DecoderTest1, BlendEquationValidArgs) {
   EXPECT_CALL(*gl_, BlendEquation(GL_FUNC_SUBTRACT));
   SpecializedSetup<cmds::BlendEquation, 0>(true);
   cmds::BlendEquation cmd;
@@ -183,7 +183,7 @@ TEST_P(GLES2DecoderTest1, BlendEquationValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendEquationInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, BlendEquationInvalidArgs0_0) {
   EXPECT_CALL(*gl_, BlendEquation(_)).Times(0);
   SpecializedSetup<cmds::BlendEquation, 0>(false);
   cmds::BlendEquation cmd;
@@ -192,7 +192,7 @@ TEST_P(GLES2DecoderTest1, BlendEquationInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendEquationInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, BlendEquationInvalidArgs0_1) {
   EXPECT_CALL(*gl_, BlendEquation(_)).Times(0);
   SpecializedSetup<cmds::BlendEquation, 0>(false);
   cmds::BlendEquation cmd;
@@ -201,7 +201,7 @@ TEST_P(GLES2DecoderTest1, BlendEquationInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendEquationSeparateValidArgs) {
+TEST_F(GLES2DecoderTest1, BlendEquationSeparateValidArgs) {
   EXPECT_CALL(*gl_, BlendEquationSeparate(GL_FUNC_SUBTRACT, GL_FUNC_ADD));
   SpecializedSetup<cmds::BlendEquationSeparate, 0>(true);
   cmds::BlendEquationSeparate cmd;
@@ -210,7 +210,7 @@ TEST_P(GLES2DecoderTest1, BlendEquationSeparateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_0) {
   EXPECT_CALL(*gl_, BlendEquationSeparate(_, _)).Times(0);
   SpecializedSetup<cmds::BlendEquationSeparate, 0>(false);
   cmds::BlendEquationSeparate cmd;
@@ -219,7 +219,7 @@ TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_1) {
   EXPECT_CALL(*gl_, BlendEquationSeparate(_, _)).Times(0);
   SpecializedSetup<cmds::BlendEquationSeparate, 0>(false);
   cmds::BlendEquationSeparate cmd;
@@ -228,7 +228,7 @@ TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_0) {
   EXPECT_CALL(*gl_, BlendEquationSeparate(_, _)).Times(0);
   SpecializedSetup<cmds::BlendEquationSeparate, 0>(false);
   cmds::BlendEquationSeparate cmd;
@@ -237,7 +237,7 @@ TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_1) {
+TEST_F(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_1) {
   EXPECT_CALL(*gl_, BlendEquationSeparate(_, _)).Times(0);
   SpecializedSetup<cmds::BlendEquationSeparate, 0>(false);
   cmds::BlendEquationSeparate cmd;
@@ -246,7 +246,7 @@ TEST_P(GLES2DecoderTest1, BlendEquationSeparateInvalidArgs1_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendFuncValidArgs) {
+TEST_F(GLES2DecoderTest1, BlendFuncValidArgs) {
   EXPECT_CALL(*gl_, BlendFunc(GL_ZERO, GL_ZERO));
   SpecializedSetup<cmds::BlendFunc, 0>(true);
   cmds::BlendFunc cmd;
@@ -255,7 +255,7 @@ TEST_P(GLES2DecoderTest1, BlendFuncValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, BlendFuncSeparateValidArgs) {
+TEST_F(GLES2DecoderTest1, BlendFuncSeparateValidArgs) {
   EXPECT_CALL(*gl_, BlendFuncSeparate(GL_ZERO, GL_ZERO, GL_ZERO, GL_ZERO));
   SpecializedSetup<cmds::BlendFuncSeparate, 0>(true);
   cmds::BlendFuncSeparate cmd;
@@ -267,7 +267,7 @@ TEST_P(GLES2DecoderTest1, BlendFuncSeparateValidArgs) {
 
 // TODO(gman): BufferSubData
 
-TEST_P(GLES2DecoderTest1, CheckFramebufferStatusValidArgs) {
+TEST_F(GLES2DecoderTest1, CheckFramebufferStatusValidArgs) {
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER));
   SpecializedSetup<cmds::CheckFramebufferStatus, 0>(true);
   cmds::CheckFramebufferStatus cmd;
@@ -276,7 +276,7 @@ TEST_P(GLES2DecoderTest1, CheckFramebufferStatusValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgs0_0) {
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(_)).Times(0);
   SpecializedSetup<cmds::CheckFramebufferStatus, 0>(false);
   cmds::CheckFramebufferStatus cmd;
@@ -285,7 +285,7 @@ TEST_P(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgs0_1) {
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(_)).Times(0);
   SpecializedSetup<cmds::CheckFramebufferStatus, 0>(false);
   cmds::CheckFramebufferStatus cmd;
@@ -294,7 +294,7 @@ TEST_P(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgsBadSharedMemoryId) {
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER)).Times(0);
   SpecializedSetup<cmds::CheckFramebufferStatus, 0>(false);
   cmds::CheckFramebufferStatus cmd;
@@ -304,7 +304,7 @@ TEST_P(GLES2DecoderTest1, CheckFramebufferStatusInvalidArgsBadSharedMemoryId) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, ClearValidArgs) {
+TEST_F(GLES2DecoderTest1, ClearValidArgs) {
   EXPECT_CALL(*gl_, Clear(1));
   SpecializedSetup<cmds::Clear, 0>(true);
   cmds::Clear cmd;
@@ -313,7 +313,7 @@ TEST_P(GLES2DecoderTest1, ClearValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, ClearColorValidArgs) {
+TEST_F(GLES2DecoderTest1, ClearColorValidArgs) {
   EXPECT_CALL(*gl_, ClearColor(1, 2, 3, 4));
   SpecializedSetup<cmds::ClearColor, 0>(true);
   cmds::ClearColor cmd;
@@ -322,7 +322,7 @@ TEST_P(GLES2DecoderTest1, ClearColorValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, ClearDepthfValidArgs) {
+TEST_F(GLES2DecoderTest1, ClearDepthfValidArgs) {
   EXPECT_CALL(*gl_, ClearDepth(0.5f));
   SpecializedSetup<cmds::ClearDepthf, 0>(true);
   cmds::ClearDepthf cmd;
@@ -331,7 +331,7 @@ TEST_P(GLES2DecoderTest1, ClearDepthfValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, ClearStencilValidArgs) {
+TEST_F(GLES2DecoderTest1, ClearStencilValidArgs) {
   EXPECT_CALL(*gl_, ClearStencil(1));
   SpecializedSetup<cmds::ClearStencil, 0>(true);
   cmds::ClearStencil cmd;
@@ -340,7 +340,7 @@ TEST_P(GLES2DecoderTest1, ClearStencilValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, ColorMaskValidArgs) {
+TEST_F(GLES2DecoderTest1, ColorMaskValidArgs) {
   SpecializedSetup<cmds::ColorMask, 0>(true);
   cmds::ColorMask cmd;
   cmd.Init(true, true, true, true);
@@ -356,7 +356,7 @@ TEST_P(GLES2DecoderTest1, ColorMaskValidArgs) {
 // TODO(gman): CompressedTexSubImage2DBucket
 // TODO(gman): CopyTexImage2D
 
-TEST_P(GLES2DecoderTest1, CopyTexSubImage2DValidArgs) {
+TEST_F(GLES2DecoderTest1, CopyTexSubImage2DValidArgs) {
   EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 2, 3, 4, 5, 6, 7, 8));
   SpecializedSetup<cmds::CopyTexSubImage2D, 0>(true);
   cmds::CopyTexSubImage2D cmd;
@@ -365,7 +365,7 @@ TEST_P(GLES2DecoderTest1, CopyTexSubImage2DValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs0_0) {
   EXPECT_CALL(*gl_, CopyTexSubImage2D(_, _, _, _, _, _, _, _)).Times(0);
   SpecializedSetup<cmds::CopyTexSubImage2D, 0>(false);
   cmds::CopyTexSubImage2D cmd;
@@ -374,7 +374,7 @@ TEST_P(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs6_0) {
+TEST_F(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs6_0) {
   EXPECT_CALL(*gl_, CopyTexSubImage2D(_, _, _, _, _, _, _, _)).Times(0);
   SpecializedSetup<cmds::CopyTexSubImage2D, 0>(false);
   cmds::CopyTexSubImage2D cmd;
@@ -383,7 +383,7 @@ TEST_P(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs6_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs7_0) {
+TEST_F(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs7_0) {
   EXPECT_CALL(*gl_, CopyTexSubImage2D(_, _, _, _, _, _, _, _)).Times(0);
   SpecializedSetup<cmds::CopyTexSubImage2D, 0>(false);
   cmds::CopyTexSubImage2D cmd;
@@ -392,7 +392,7 @@ TEST_P(GLES2DecoderTest1, CopyTexSubImage2DInvalidArgs7_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, CreateProgramValidArgs) {
+TEST_F(GLES2DecoderTest1, CreateProgramValidArgs) {
   EXPECT_CALL(*gl_, CreateProgram()).WillOnce(Return(kNewServiceId));
   SpecializedSetup<cmds::CreateProgram, 0>(true);
   cmds::CreateProgram cmd;
@@ -402,7 +402,7 @@ TEST_P(GLES2DecoderTest1, CreateProgramValidArgs) {
   EXPECT_TRUE(GetProgram(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, CreateShaderValidArgs) {
+TEST_F(GLES2DecoderTest1, CreateShaderValidArgs) {
   EXPECT_CALL(*gl_, CreateShader(GL_VERTEX_SHADER))
       .WillOnce(Return(kNewServiceId));
   SpecializedSetup<cmds::CreateShader, 0>(true);
@@ -413,7 +413,7 @@ TEST_P(GLES2DecoderTest1, CreateShaderValidArgs) {
   EXPECT_TRUE(GetShader(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, CreateShaderInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, CreateShaderInvalidArgs0_0) {
   EXPECT_CALL(*gl_, CreateShader(_)).Times(0);
   SpecializedSetup<cmds::CreateShader, 0>(false);
   cmds::CreateShader cmd;
@@ -422,7 +422,7 @@ TEST_P(GLES2DecoderTest1, CreateShaderInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, CullFaceValidArgs) {
+TEST_F(GLES2DecoderTest1, CullFaceValidArgs) {
   EXPECT_CALL(*gl_, CullFace(GL_FRONT));
   SpecializedSetup<cmds::CullFace, 0>(true);
   cmds::CullFace cmd;
@@ -431,7 +431,7 @@ TEST_P(GLES2DecoderTest1, CullFaceValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DeleteBuffersValidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteBuffersValidArgs) {
   EXPECT_CALL(*gl_, DeleteBuffersARB(1, Pointee(kServiceBufferId))).Times(1);
   GetSharedMemoryAs<GLuint*>()[0] = client_buffer_id_;
   SpecializedSetup<cmds::DeleteBuffers, 0>(true);
@@ -442,7 +442,7 @@ TEST_P(GLES2DecoderTest1, DeleteBuffersValidArgs) {
   EXPECT_TRUE(GetBuffer(client_buffer_id_) == NULL);
 }
 
-TEST_P(GLES2DecoderTest1, DeleteBuffersInvalidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteBuffersInvalidArgs) {
   GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
   SpecializedSetup<cmds::DeleteBuffers, 0>(false);
   cmds::DeleteBuffers cmd;
@@ -450,7 +450,7 @@ TEST_P(GLES2DecoderTest1, DeleteBuffersInvalidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, DeleteBuffersImmediateValidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteBuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, DeleteBuffersARB(1, Pointee(kServiceBufferId))).Times(1);
   cmds::DeleteBuffersImmediate& cmd =
       *GetImmediateAs<cmds::DeleteBuffersImmediate>();
@@ -462,7 +462,7 @@ TEST_P(GLES2DecoderTest1, DeleteBuffersImmediateValidArgs) {
   EXPECT_TRUE(GetBuffer(client_buffer_id_) == NULL);
 }
 
-TEST_P(GLES2DecoderTest1, DeleteBuffersImmediateInvalidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteBuffersImmediateInvalidArgs) {
   cmds::DeleteBuffersImmediate& cmd =
       *GetImmediateAs<cmds::DeleteBuffersImmediate>();
   SpecializedSetup<cmds::DeleteBuffersImmediate, 0>(false);
@@ -471,7 +471,7 @@ TEST_P(GLES2DecoderTest1, DeleteBuffersImmediateInvalidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
-TEST_P(GLES2DecoderTest1, DeleteFramebuffersValidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteFramebuffersValidArgs) {
   EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, Pointee(kServiceFramebufferId)))
       .Times(1);
   GetSharedMemoryAs<GLuint*>()[0] = client_framebuffer_id_;
@@ -483,7 +483,7 @@ TEST_P(GLES2DecoderTest1, DeleteFramebuffersValidArgs) {
   EXPECT_TRUE(GetFramebuffer(client_framebuffer_id_) == NULL);
 }
 
-TEST_P(GLES2DecoderTest1, DeleteFramebuffersInvalidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteFramebuffersInvalidArgs) {
   GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
   SpecializedSetup<cmds::DeleteFramebuffers, 0>(false);
   cmds::DeleteFramebuffers cmd;
@@ -491,7 +491,7 @@ TEST_P(GLES2DecoderTest1, DeleteFramebuffersInvalidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, DeleteFramebuffersImmediateValidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteFramebuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, Pointee(kServiceFramebufferId)))
       .Times(1);
   cmds::DeleteFramebuffersImmediate& cmd =
@@ -504,7 +504,7 @@ TEST_P(GLES2DecoderTest1, DeleteFramebuffersImmediateValidArgs) {
   EXPECT_TRUE(GetFramebuffer(client_framebuffer_id_) == NULL);
 }
 
-TEST_P(GLES2DecoderTest1, DeleteFramebuffersImmediateInvalidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteFramebuffersImmediateInvalidArgs) {
   cmds::DeleteFramebuffersImmediate& cmd =
       *GetImmediateAs<cmds::DeleteFramebuffersImmediate>();
   SpecializedSetup<cmds::DeleteFramebuffersImmediate, 0>(false);
@@ -513,7 +513,7 @@ TEST_P(GLES2DecoderTest1, DeleteFramebuffersImmediateInvalidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
-TEST_P(GLES2DecoderTest1, DeleteProgramValidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteProgramValidArgs) {
   EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId));
   SpecializedSetup<cmds::DeleteProgram, 0>(true);
   cmds::DeleteProgram cmd;
@@ -522,7 +522,7 @@ TEST_P(GLES2DecoderTest1, DeleteProgramValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DeleteRenderbuffersValidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteRenderbuffersValidArgs) {
   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, Pointee(kServiceRenderbufferId)))
       .Times(1);
   GetSharedMemoryAs<GLuint*>()[0] = client_renderbuffer_id_;
@@ -534,7 +534,7 @@ TEST_P(GLES2DecoderTest1, DeleteRenderbuffersValidArgs) {
   EXPECT_TRUE(GetRenderbuffer(client_renderbuffer_id_) == NULL);
 }
 
-TEST_P(GLES2DecoderTest1, DeleteRenderbuffersInvalidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteRenderbuffersInvalidArgs) {
   GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
   SpecializedSetup<cmds::DeleteRenderbuffers, 0>(false);
   cmds::DeleteRenderbuffers cmd;
@@ -542,7 +542,7 @@ TEST_P(GLES2DecoderTest1, DeleteRenderbuffersInvalidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, DeleteRenderbuffersImmediateValidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteRenderbuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, Pointee(kServiceRenderbufferId)))
       .Times(1);
   cmds::DeleteRenderbuffersImmediate& cmd =
@@ -555,7 +555,7 @@ TEST_P(GLES2DecoderTest1, DeleteRenderbuffersImmediateValidArgs) {
   EXPECT_TRUE(GetRenderbuffer(client_renderbuffer_id_) == NULL);
 }
 
-TEST_P(GLES2DecoderTest1, DeleteRenderbuffersImmediateInvalidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteRenderbuffersImmediateInvalidArgs) {
   cmds::DeleteRenderbuffersImmediate& cmd =
       *GetImmediateAs<cmds::DeleteRenderbuffersImmediate>();
   SpecializedSetup<cmds::DeleteRenderbuffersImmediate, 0>(false);
@@ -564,7 +564,7 @@ TEST_P(GLES2DecoderTest1, DeleteRenderbuffersImmediateInvalidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
-TEST_P(GLES2DecoderTest1, DeleteShaderValidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteShaderValidArgs) {
   EXPECT_CALL(*gl_, DeleteShader(kServiceShaderId));
   SpecializedSetup<cmds::DeleteShader, 0>(true);
   cmds::DeleteShader cmd;
@@ -573,7 +573,7 @@ TEST_P(GLES2DecoderTest1, DeleteShaderValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DeleteTexturesValidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteTexturesValidArgs) {
   EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(kServiceTextureId))).Times(1);
   GetSharedMemoryAs<GLuint*>()[0] = client_texture_id_;
   SpecializedSetup<cmds::DeleteTextures, 0>(true);
@@ -584,7 +584,7 @@ TEST_P(GLES2DecoderTest1, DeleteTexturesValidArgs) {
   EXPECT_TRUE(GetTexture(client_texture_id_) == NULL);
 }
 
-TEST_P(GLES2DecoderTest1, DeleteTexturesInvalidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteTexturesInvalidArgs) {
   GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
   SpecializedSetup<cmds::DeleteTextures, 0>(false);
   cmds::DeleteTextures cmd;
@@ -592,7 +592,7 @@ TEST_P(GLES2DecoderTest1, DeleteTexturesInvalidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, DeleteTexturesImmediateValidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteTexturesImmediateValidArgs) {
   EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(kServiceTextureId))).Times(1);
   cmds::DeleteTexturesImmediate& cmd =
       *GetImmediateAs<cmds::DeleteTexturesImmediate>();
@@ -604,7 +604,7 @@ TEST_P(GLES2DecoderTest1, DeleteTexturesImmediateValidArgs) {
   EXPECT_TRUE(GetTexture(client_texture_id_) == NULL);
 }
 
-TEST_P(GLES2DecoderTest1, DeleteTexturesImmediateInvalidArgs) {
+TEST_F(GLES2DecoderTest1, DeleteTexturesImmediateInvalidArgs) {
   cmds::DeleteTexturesImmediate& cmd =
       *GetImmediateAs<cmds::DeleteTexturesImmediate>();
   SpecializedSetup<cmds::DeleteTexturesImmediate, 0>(false);
@@ -613,7 +613,7 @@ TEST_P(GLES2DecoderTest1, DeleteTexturesImmediateInvalidArgs) {
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 
-TEST_P(GLES2DecoderTest1, DepthFuncValidArgs) {
+TEST_F(GLES2DecoderTest1, DepthFuncValidArgs) {
   EXPECT_CALL(*gl_, DepthFunc(GL_NEVER));
   SpecializedSetup<cmds::DepthFunc, 0>(true);
   cmds::DepthFunc cmd;
@@ -622,7 +622,7 @@ TEST_P(GLES2DecoderTest1, DepthFuncValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DepthMaskValidArgs) {
+TEST_F(GLES2DecoderTest1, DepthMaskValidArgs) {
   SpecializedSetup<cmds::DepthMask, 0>(true);
   cmds::DepthMask cmd;
   cmd.Init(true);
@@ -630,7 +630,7 @@ TEST_P(GLES2DecoderTest1, DepthMaskValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DepthRangefValidArgs) {
+TEST_F(GLES2DecoderTest1, DepthRangefValidArgs) {
   EXPECT_CALL(*gl_, DepthRange(1, 2));
   SpecializedSetup<cmds::DepthRangef, 0>(true);
   cmds::DepthRangef cmd;
@@ -639,7 +639,7 @@ TEST_P(GLES2DecoderTest1, DepthRangefValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DetachShaderValidArgs) {
+TEST_F(GLES2DecoderTest1, DetachShaderValidArgs) {
   EXPECT_CALL(*gl_, DetachShader(kServiceProgramId, kServiceShaderId));
   SpecializedSetup<cmds::DetachShader, 0>(true);
   cmds::DetachShader cmd;
@@ -648,8 +648,8 @@ TEST_P(GLES2DecoderTest1, DetachShaderValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DisableValidArgs) {
-  SetupExpectationsForEnableDisable(GL_BLEND, false);
+TEST_F(GLES2DecoderTest1, DisableValidArgs) {
+  EXPECT_CALL(*gl_, Disable(GL_BLEND));
   SpecializedSetup<cmds::Disable, 0>(true);
   cmds::Disable cmd;
   cmd.Init(GL_BLEND);
@@ -657,7 +657,7 @@ TEST_P(GLES2DecoderTest1, DisableValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DisableInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, DisableInvalidArgs0_0) {
   EXPECT_CALL(*gl_, Disable(_)).Times(0);
   SpecializedSetup<cmds::Disable, 0>(false);
   cmds::Disable cmd;
@@ -666,7 +666,7 @@ TEST_P(GLES2DecoderTest1, DisableInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DisableInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, DisableInvalidArgs0_1) {
   EXPECT_CALL(*gl_, Disable(_)).Times(0);
   SpecializedSetup<cmds::Disable, 0>(false);
   cmds::Disable cmd;
@@ -675,7 +675,7 @@ TEST_P(GLES2DecoderTest1, DisableInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, DisableVertexAttribArrayValidArgs) {
+TEST_F(GLES2DecoderTest1, DisableVertexAttribArrayValidArgs) {
   EXPECT_CALL(*gl_, DisableVertexAttribArray(1));
   SpecializedSetup<cmds::DisableVertexAttribArray, 0>(true);
   cmds::DisableVertexAttribArray cmd;
@@ -687,8 +687,8 @@ TEST_P(GLES2DecoderTest1, DisableVertexAttribArrayValidArgs) {
 
 // TODO(gman): DrawElements
 
-TEST_P(GLES2DecoderTest1, EnableValidArgs) {
-  SetupExpectationsForEnableDisable(GL_BLEND, true);
+TEST_F(GLES2DecoderTest1, EnableValidArgs) {
+  EXPECT_CALL(*gl_, Enable(GL_BLEND));
   SpecializedSetup<cmds::Enable, 0>(true);
   cmds::Enable cmd;
   cmd.Init(GL_BLEND);
@@ -696,7 +696,7 @@ TEST_P(GLES2DecoderTest1, EnableValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, EnableInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, EnableInvalidArgs0_0) {
   EXPECT_CALL(*gl_, Enable(_)).Times(0);
   SpecializedSetup<cmds::Enable, 0>(false);
   cmds::Enable cmd;
@@ -705,7 +705,7 @@ TEST_P(GLES2DecoderTest1, EnableInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, EnableInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, EnableInvalidArgs0_1) {
   EXPECT_CALL(*gl_, Enable(_)).Times(0);
   SpecializedSetup<cmds::Enable, 0>(false);
   cmds::Enable cmd;
@@ -714,7 +714,7 @@ TEST_P(GLES2DecoderTest1, EnableInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, EnableVertexAttribArrayValidArgs) {
+TEST_F(GLES2DecoderTest1, EnableVertexAttribArrayValidArgs) {
   EXPECT_CALL(*gl_, EnableVertexAttribArray(1));
   SpecializedSetup<cmds::EnableVertexAttribArray, 0>(true);
   cmds::EnableVertexAttribArray cmd;
@@ -723,7 +723,7 @@ TEST_P(GLES2DecoderTest1, EnableVertexAttribArrayValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FinishValidArgs) {
+TEST_F(GLES2DecoderTest1, FinishValidArgs) {
   EXPECT_CALL(*gl_, Finish());
   SpecializedSetup<cmds::Finish, 0>(true);
   cmds::Finish cmd;
@@ -732,7 +732,7 @@ TEST_P(GLES2DecoderTest1, FinishValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FlushValidArgs) {
+TEST_F(GLES2DecoderTest1, FlushValidArgs) {
   EXPECT_CALL(*gl_, Flush());
   SpecializedSetup<cmds::Flush, 0>(true);
   cmds::Flush cmd;
@@ -741,7 +741,7 @@ TEST_P(GLES2DecoderTest1, FlushValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FramebufferRenderbufferValidArgs) {
+TEST_F(GLES2DecoderTest1, FramebufferRenderbufferValidArgs) {
   EXPECT_CALL(*gl_,
               FramebufferRenderbufferEXT(GL_FRAMEBUFFER,
                                          GL_COLOR_ATTACHMENT0,
@@ -757,7 +757,7 @@ TEST_P(GLES2DecoderTest1, FramebufferRenderbufferValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs0_0) {
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::FramebufferRenderbuffer, 0>(false);
   cmds::FramebufferRenderbuffer cmd;
@@ -769,7 +769,7 @@ TEST_P(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs0_1) {
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::FramebufferRenderbuffer, 0>(false);
   cmds::FramebufferRenderbuffer cmd;
@@ -781,7 +781,7 @@ TEST_P(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs2_0) {
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::FramebufferRenderbuffer, 0>(false);
   cmds::FramebufferRenderbuffer cmd;
@@ -793,7 +793,7 @@ TEST_P(GLES2DecoderTest1, FramebufferRenderbufferInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FramebufferTexture2DValidArgs) {
+TEST_F(GLES2DecoderTest1, FramebufferTexture2DValidArgs) {
   EXPECT_CALL(*gl_,
               FramebufferTexture2DEXT(GL_FRAMEBUFFER,
                                       GL_COLOR_ATTACHMENT0,
@@ -811,7 +811,7 @@ TEST_P(GLES2DecoderTest1, FramebufferTexture2DValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs0_0) {
   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _)).Times(0);
   SpecializedSetup<cmds::FramebufferTexture2D, 0>(false);
   cmds::FramebufferTexture2D cmd;
@@ -824,7 +824,7 @@ TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs0_1) {
   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _)).Times(0);
   SpecializedSetup<cmds::FramebufferTexture2D, 0>(false);
   cmds::FramebufferTexture2D cmd;
@@ -837,7 +837,7 @@ TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs2_0) {
   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _)).Times(0);
   SpecializedSetup<cmds::FramebufferTexture2D, 0>(false);
   cmds::FramebufferTexture2D cmd;
@@ -850,7 +850,7 @@ TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs4_0) {
+TEST_F(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs4_0) {
   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _)).Times(0);
   SpecializedSetup<cmds::FramebufferTexture2D, 0>(false);
   cmds::FramebufferTexture2D cmd;
@@ -863,7 +863,7 @@ TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs4_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FrontFaceValidArgs) {
+TEST_F(GLES2DecoderTest1, FrontFaceValidArgs) {
   EXPECT_CALL(*gl_, FrontFace(GL_CW));
   SpecializedSetup<cmds::FrontFace, 0>(true);
   cmds::FrontFace cmd;
@@ -872,7 +872,7 @@ TEST_P(GLES2DecoderTest1, FrontFaceValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GenBuffersValidArgs) {
+TEST_F(GLES2DecoderTest1, GenBuffersValidArgs) {
   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
@@ -884,7 +884,7 @@ TEST_P(GLES2DecoderTest1, GenBuffersValidArgs) {
   EXPECT_TRUE(GetBuffer(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, GenBuffersInvalidArgs) {
+TEST_F(GLES2DecoderTest1, GenBuffersInvalidArgs) {
   EXPECT_CALL(*gl_, GenBuffersARB(_, _)).Times(0);
   GetSharedMemoryAs<GLuint*>()[0] = client_buffer_id_;
   SpecializedSetup<cmds::GenBuffers, 0>(false);
@@ -893,7 +893,7 @@ TEST_P(GLES2DecoderTest1, GenBuffersInvalidArgs) {
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, GenBuffersImmediateValidArgs) {
+TEST_F(GLES2DecoderTest1, GenBuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   cmds::GenBuffersImmediate* cmd = GetImmediateAs<cmds::GenBuffersImmediate>();
@@ -905,7 +905,7 @@ TEST_P(GLES2DecoderTest1, GenBuffersImmediateValidArgs) {
   EXPECT_TRUE(GetBuffer(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, GenBuffersImmediateInvalidArgs) {
+TEST_F(GLES2DecoderTest1, GenBuffersImmediateInvalidArgs) {
   EXPECT_CALL(*gl_, GenBuffersARB(_, _)).Times(0);
   cmds::GenBuffersImmediate* cmd = GetImmediateAs<cmds::GenBuffersImmediate>();
   SpecializedSetup<cmds::GenBuffersImmediate, 0>(false);
@@ -914,7 +914,7 @@ TEST_P(GLES2DecoderTest1, GenBuffersImmediateInvalidArgs) {
             ExecuteImmediateCmd(*cmd, sizeof(&client_buffer_id_)));
 }
 
-TEST_P(GLES2DecoderTest1, GenerateMipmapValidArgs) {
+TEST_F(GLES2DecoderTest1, GenerateMipmapValidArgs) {
   EXPECT_CALL(*gl_, GenerateMipmapEXT(GL_TEXTURE_2D));
   SpecializedSetup<cmds::GenerateMipmap, 0>(true);
   cmds::GenerateMipmap cmd;
@@ -923,7 +923,7 @@ TEST_P(GLES2DecoderTest1, GenerateMipmapValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_0) {
   EXPECT_CALL(*gl_, GenerateMipmapEXT(_)).Times(0);
   SpecializedSetup<cmds::GenerateMipmap, 0>(false);
   cmds::GenerateMipmap cmd;
@@ -932,7 +932,7 @@ TEST_P(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_1) {
   EXPECT_CALL(*gl_, GenerateMipmapEXT(_)).Times(0);
   SpecializedSetup<cmds::GenerateMipmap, 0>(false);
   cmds::GenerateMipmap cmd;
@@ -941,7 +941,7 @@ TEST_P(GLES2DecoderTest1, GenerateMipmapInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GenFramebuffersValidArgs) {
+TEST_F(GLES2DecoderTest1, GenFramebuffersValidArgs) {
   EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
@@ -953,7 +953,7 @@ TEST_P(GLES2DecoderTest1, GenFramebuffersValidArgs) {
   EXPECT_TRUE(GetFramebuffer(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, GenFramebuffersInvalidArgs) {
+TEST_F(GLES2DecoderTest1, GenFramebuffersInvalidArgs) {
   EXPECT_CALL(*gl_, GenFramebuffersEXT(_, _)).Times(0);
   GetSharedMemoryAs<GLuint*>()[0] = client_framebuffer_id_;
   SpecializedSetup<cmds::GenFramebuffers, 0>(false);
@@ -962,7 +962,7 @@ TEST_P(GLES2DecoderTest1, GenFramebuffersInvalidArgs) {
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, GenFramebuffersImmediateValidArgs) {
+TEST_F(GLES2DecoderTest1, GenFramebuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   cmds::GenFramebuffersImmediate* cmd =
@@ -975,7 +975,7 @@ TEST_P(GLES2DecoderTest1, GenFramebuffersImmediateValidArgs) {
   EXPECT_TRUE(GetFramebuffer(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, GenFramebuffersImmediateInvalidArgs) {
+TEST_F(GLES2DecoderTest1, GenFramebuffersImmediateInvalidArgs) {
   EXPECT_CALL(*gl_, GenFramebuffersEXT(_, _)).Times(0);
   cmds::GenFramebuffersImmediate* cmd =
       GetImmediateAs<cmds::GenFramebuffersImmediate>();
@@ -985,7 +985,7 @@ TEST_P(GLES2DecoderTest1, GenFramebuffersImmediateInvalidArgs) {
             ExecuteImmediateCmd(*cmd, sizeof(&client_framebuffer_id_)));
 }
 
-TEST_P(GLES2DecoderTest1, GenRenderbuffersValidArgs) {
+TEST_F(GLES2DecoderTest1, GenRenderbuffersValidArgs) {
   EXPECT_CALL(*gl_, GenRenderbuffersEXT(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
@@ -997,7 +997,7 @@ TEST_P(GLES2DecoderTest1, GenRenderbuffersValidArgs) {
   EXPECT_TRUE(GetRenderbuffer(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, GenRenderbuffersInvalidArgs) {
+TEST_F(GLES2DecoderTest1, GenRenderbuffersInvalidArgs) {
   EXPECT_CALL(*gl_, GenRenderbuffersEXT(_, _)).Times(0);
   GetSharedMemoryAs<GLuint*>()[0] = client_renderbuffer_id_;
   SpecializedSetup<cmds::GenRenderbuffers, 0>(false);
@@ -1006,7 +1006,7 @@ TEST_P(GLES2DecoderTest1, GenRenderbuffersInvalidArgs) {
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, GenRenderbuffersImmediateValidArgs) {
+TEST_F(GLES2DecoderTest1, GenRenderbuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenRenderbuffersEXT(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   cmds::GenRenderbuffersImmediate* cmd =
@@ -1019,7 +1019,7 @@ TEST_P(GLES2DecoderTest1, GenRenderbuffersImmediateValidArgs) {
   EXPECT_TRUE(GetRenderbuffer(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, GenRenderbuffersImmediateInvalidArgs) {
+TEST_F(GLES2DecoderTest1, GenRenderbuffersImmediateInvalidArgs) {
   EXPECT_CALL(*gl_, GenRenderbuffersEXT(_, _)).Times(0);
   cmds::GenRenderbuffersImmediate* cmd =
       GetImmediateAs<cmds::GenRenderbuffersImmediate>();
@@ -1029,7 +1029,7 @@ TEST_P(GLES2DecoderTest1, GenRenderbuffersImmediateInvalidArgs) {
             ExecuteImmediateCmd(*cmd, sizeof(&client_renderbuffer_id_)));
 }
 
-TEST_P(GLES2DecoderTest1, GenTexturesValidArgs) {
+TEST_F(GLES2DecoderTest1, GenTexturesValidArgs) {
   EXPECT_CALL(*gl_, GenTextures(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
@@ -1041,7 +1041,7 @@ TEST_P(GLES2DecoderTest1, GenTexturesValidArgs) {
   EXPECT_TRUE(GetTexture(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, GenTexturesInvalidArgs) {
+TEST_F(GLES2DecoderTest1, GenTexturesInvalidArgs) {
   EXPECT_CALL(*gl_, GenTextures(_, _)).Times(0);
   GetSharedMemoryAs<GLuint*>()[0] = client_texture_id_;
   SpecializedSetup<cmds::GenTextures, 0>(false);
@@ -1050,7 +1050,7 @@ TEST_P(GLES2DecoderTest1, GenTexturesInvalidArgs) {
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, GenTexturesImmediateValidArgs) {
+TEST_F(GLES2DecoderTest1, GenTexturesImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenTextures(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   cmds::GenTexturesImmediate* cmd =
@@ -1063,7 +1063,7 @@ TEST_P(GLES2DecoderTest1, GenTexturesImmediateValidArgs) {
   EXPECT_TRUE(GetTexture(kNewClientId) != NULL);
 }
 
-TEST_P(GLES2DecoderTest1, GenTexturesImmediateInvalidArgs) {
+TEST_F(GLES2DecoderTest1, GenTexturesImmediateInvalidArgs) {
   EXPECT_CALL(*gl_, GenTextures(_, _)).Times(0);
   cmds::GenTexturesImmediate* cmd =
       GetImmediateAs<cmds::GenTexturesImmediate>();
@@ -1082,7 +1082,7 @@ TEST_P(GLES2DecoderTest1, GenTexturesImmediateInvalidArgs) {
 
 // TODO(gman): GetAttribLocationBucket
 
-TEST_P(GLES2DecoderTest1, GetBooleanvValidArgs) {
+TEST_F(GLES2DecoderTest1, GetBooleanvValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ -1100,7 +1100,7 @@ TEST_P(GLES2DecoderTest1, GetBooleanvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetBooleanvInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, GetBooleanvInvalidArgs0_0) {
   EXPECT_CALL(*gl_, GetBooleanv(_, _)).Times(0);
   SpecializedSetup<cmds::GetBooleanv, 0>(false);
   cmds::GetBooleanv::Result* result =
@@ -1113,7 +1113,7 @@ TEST_P(GLES2DecoderTest1, GetBooleanvInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetBooleanvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest1, GetBooleanvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, GetBooleanv(_, _)).Times(0);
   SpecializedSetup<cmds::GetBooleanv, 0>(false);
   cmds::GetBooleanv::Result* result =
@@ -1125,7 +1125,7 @@ TEST_P(GLES2DecoderTest1, GetBooleanvInvalidArgs1_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetBooleanvInvalidArgs1_1) {
+TEST_F(GLES2DecoderTest1, GetBooleanvInvalidArgs1_1) {
   EXPECT_CALL(*gl_, GetBooleanv(_, _)).Times(0);
   SpecializedSetup<cmds::GetBooleanv, 0>(false);
   cmds::GetBooleanv::Result* result =
@@ -1137,7 +1137,7 @@ TEST_P(GLES2DecoderTest1, GetBooleanvInvalidArgs1_1) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetBufferParameterivValidArgs) {
+TEST_F(GLES2DecoderTest1, GetBufferParameterivValidArgs) {
   SpecializedSetup<cmds::GetBufferParameteriv, 0>(true);
   typedef cmds::GetBufferParameteriv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1153,7 +1153,7 @@ TEST_P(GLES2DecoderTest1, GetBufferParameterivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, GetBufferParameterivInvalidArgs0_0) {
   EXPECT_CALL(*gl_, GetBufferParameteriv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetBufferParameteriv, 0>(false);
   cmds::GetBufferParameteriv::Result* result =
@@ -1169,7 +1169,7 @@ TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest1, GetBufferParameterivInvalidArgs1_0) {
   EXPECT_CALL(*gl_, GetBufferParameteriv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetBufferParameteriv, 0>(false);
   cmds::GetBufferParameteriv::Result* result =
@@ -1185,7 +1185,7 @@ TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest1, GetBufferParameterivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, GetBufferParameteriv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetBufferParameteriv, 0>(false);
   cmds::GetBufferParameteriv::Result* result =
@@ -1197,7 +1197,7 @@ TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs2_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest1, GetBufferParameterivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, GetBufferParameteriv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetBufferParameteriv, 0>(false);
   cmds::GetBufferParameteriv::Result* result =
@@ -1212,7 +1212,7 @@ TEST_P(GLES2DecoderTest1, GetBufferParameterivInvalidArgs2_1) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetErrorValidArgs) {
+TEST_F(GLES2DecoderTest1, GetErrorValidArgs) {
   EXPECT_CALL(*gl_, GetError());
   SpecializedSetup<cmds::GetError, 0>(true);
   cmds::GetError cmd;
@@ -1221,7 +1221,7 @@ TEST_P(GLES2DecoderTest1, GetErrorValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetErrorInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderTest1, GetErrorInvalidArgsBadSharedMemoryId) {
   EXPECT_CALL(*gl_, GetError()).Times(0);
   SpecializedSetup<cmds::GetError, 0>(false);
   cmds::GetError cmd;
@@ -1231,7 +1231,7 @@ TEST_P(GLES2DecoderTest1, GetErrorInvalidArgsBadSharedMemoryId) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, GetFloatvValidArgs) {
+TEST_F(GLES2DecoderTest1, GetFloatvValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ -1249,7 +1249,7 @@ TEST_P(GLES2DecoderTest1, GetFloatvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetFloatvInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, GetFloatvInvalidArgs0_0) {
   EXPECT_CALL(*gl_, GetFloatv(_, _)).Times(0);
   SpecializedSetup<cmds::GetFloatv, 0>(false);
   cmds::GetFloatv::Result* result =
@@ -1262,7 +1262,7 @@ TEST_P(GLES2DecoderTest1, GetFloatvInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetFloatvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest1, GetFloatvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, GetFloatv(_, _)).Times(0);
   SpecializedSetup<cmds::GetFloatv, 0>(false);
   cmds::GetFloatv::Result* result =
@@ -1274,7 +1274,7 @@ TEST_P(GLES2DecoderTest1, GetFloatvInvalidArgs1_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetFloatvInvalidArgs1_1) {
+TEST_F(GLES2DecoderTest1, GetFloatvInvalidArgs1_1) {
   EXPECT_CALL(*gl_, GetFloatv(_, _)).Times(0);
   SpecializedSetup<cmds::GetFloatv, 0>(false);
   cmds::GetFloatv::Result* result =
@@ -1286,7 +1286,7 @@ TEST_P(GLES2DecoderTest1, GetFloatvInvalidArgs1_1) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivValidArgs) {
+TEST_F(GLES2DecoderTest1, GetFramebufferAttachmentParameterivValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ -1314,7 +1314,7 @@ TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs0_0) {
   EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(_, _, _, _))
       .Times(0);
   SpecializedSetup<cmds::GetFramebufferAttachmentParameteriv, 0>(false);
@@ -1333,7 +1333,7 @@ TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs0_1) {
   EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(_, _, _, _))
       .Times(0);
   SpecializedSetup<cmds::GetFramebufferAttachmentParameteriv, 0>(false);
@@ -1352,7 +1352,7 @@ TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs3_0) {
+TEST_F(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs3_0) {
   EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(_, _, _, _))
       .Times(0);
   SpecializedSetup<cmds::GetFramebufferAttachmentParameteriv, 0>(false);
@@ -1370,7 +1370,7 @@ TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs3_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs3_1) {
+TEST_F(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs3_1) {
   EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(_, _, _, _))
       .Times(0);
   SpecializedSetup<cmds::GetFramebufferAttachmentParameteriv, 0>(false);
@@ -1388,7 +1388,7 @@ TEST_P(GLES2DecoderTest1, GetFramebufferAttachmentParameterivInvalidArgs3_1) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetIntegervValidArgs) {
+TEST_F(GLES2DecoderTest1, GetIntegervValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ -1406,7 +1406,7 @@ TEST_P(GLES2DecoderTest1, GetIntegervValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetIntegervInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, GetIntegervInvalidArgs0_0) {
   EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(0);
   SpecializedSetup<cmds::GetIntegerv, 0>(false);
   cmds::GetIntegerv::Result* result =
@@ -1419,7 +1419,7 @@ TEST_P(GLES2DecoderTest1, GetIntegervInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetIntegervInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest1, GetIntegervInvalidArgs1_0) {
   EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(0);
   SpecializedSetup<cmds::GetIntegerv, 0>(false);
   cmds::GetIntegerv::Result* result =
@@ -1431,7 +1431,7 @@ TEST_P(GLES2DecoderTest1, GetIntegervInvalidArgs1_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetIntegervInvalidArgs1_1) {
+TEST_F(GLES2DecoderTest1, GetIntegervInvalidArgs1_1) {
   EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(0);
   SpecializedSetup<cmds::GetIntegerv, 0>(false);
   cmds::GetIntegerv::Result* result =
@@ -1443,7 +1443,7 @@ TEST_P(GLES2DecoderTest1, GetIntegervInvalidArgs1_1) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetProgramivValidArgs) {
+TEST_F(GLES2DecoderTest1, GetProgramivValidArgs) {
   SpecializedSetup<cmds::GetProgramiv, 0>(true);
   typedef cmds::GetProgramiv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1459,7 +1459,7 @@ TEST_P(GLES2DecoderTest1, GetProgramivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetProgramivInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest1, GetProgramivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, GetProgramiv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetProgramiv, 0>(false);
   cmds::GetProgramiv::Result* result =
@@ -1471,7 +1471,7 @@ TEST_P(GLES2DecoderTest1, GetProgramivInvalidArgs2_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetProgramivInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest1, GetProgramivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, GetProgramiv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetProgramiv, 0>(false);
   cmds::GetProgramiv::Result* result =
@@ -1486,7 +1486,7 @@ TEST_P(GLES2DecoderTest1, GetProgramivInvalidArgs2_1) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetProgramInfoLogValidArgs) {
+TEST_F(GLES2DecoderTest1, GetProgramInfoLogValidArgs) {
   const char* kInfo = "hello";
   const uint32 kBucketId = 123;
   SpecializedSetup<cmds::GetProgramInfoLog, 0>(true);
@@ -1502,7 +1502,7 @@ TEST_P(GLES2DecoderTest1, GetProgramInfoLogValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetProgramInfoLogInvalidArgs) {
+TEST_F(GLES2DecoderTest1, GetProgramInfoLogInvalidArgs) {
   const uint32 kBucketId = 123;
   cmds::GetProgramInfoLog cmd;
   cmd.Init(kInvalidClientId, kBucketId);
@@ -1510,7 +1510,7 @@ TEST_P(GLES2DecoderTest1, GetProgramInfoLogInvalidArgs) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivValidArgs) {
+TEST_F(GLES2DecoderTest1, GetRenderbufferParameterivValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ -1535,7 +1535,7 @@ TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs0_0) {
   EXPECT_CALL(*gl_, GetRenderbufferParameterivEXT(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetRenderbufferParameteriv, 0>(false);
   cmds::GetRenderbufferParameteriv::Result* result =
@@ -1552,7 +1552,7 @@ TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, GetRenderbufferParameterivEXT(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetRenderbufferParameteriv, 0>(false);
   cmds::GetRenderbufferParameteriv::Result* result =
@@ -1566,7 +1566,7 @@ TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs2_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, GetRenderbufferParameterivEXT(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetRenderbufferParameteriv, 0>(false);
   cmds::GetRenderbufferParameteriv::Result* result =
@@ -1582,7 +1582,7 @@ TEST_P(GLES2DecoderTest1, GetRenderbufferParameterivInvalidArgs2_1) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetShaderivValidArgs) {
+TEST_F(GLES2DecoderTest1, GetShaderivValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ -1604,7 +1604,7 @@ TEST_P(GLES2DecoderTest1, GetShaderivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetShaderivInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest1, GetShaderivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, GetShaderiv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetShaderiv, 0>(false);
   cmds::GetShaderiv::Result* result =
@@ -1616,7 +1616,7 @@ TEST_P(GLES2DecoderTest1, GetShaderivInvalidArgs2_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetShaderivInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest1, GetShaderivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, GetShaderiv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetShaderiv, 0>(false);
   cmds::GetShaderiv::Result* result =
@@ -1636,7 +1636,7 @@ TEST_P(GLES2DecoderTest1, GetShaderivInvalidArgs2_1) {
 // TODO(gman): GetShaderSource
 // TODO(gman): GetString
 
-TEST_P(GLES2DecoderTest1, GetTexParameterfvValidArgs) {
+TEST_F(GLES2DecoderTest1, GetTexParameterfvValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ -1660,7 +1660,7 @@ TEST_P(GLES2DecoderTest1, GetTexParameterfvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, GetTexParameterfvInvalidArgs0_0) {
   EXPECT_CALL(*gl_, GetTexParameterfv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetTexParameterfv, 0>(false);
   cmds::GetTexParameterfv::Result* result =
@@ -1676,7 +1676,7 @@ TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest1, GetTexParameterfvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, GetTexParameterfv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetTexParameterfv, 0>(false);
   cmds::GetTexParameterfv::Result* result =
@@ -1692,7 +1692,7 @@ TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest1, GetTexParameterfvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, GetTexParameterfv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetTexParameterfv, 0>(false);
   cmds::GetTexParameterfv::Result* result =
@@ -1704,7 +1704,7 @@ TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs2_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest1, GetTexParameterfvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, GetTexParameterfv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetTexParameterfv, 0>(false);
   cmds::GetTexParameterfv::Result* result =
@@ -1719,7 +1719,7 @@ TEST_P(GLES2DecoderTest1, GetTexParameterfvInvalidArgs2_1) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetTexParameterivValidArgs) {
+TEST_F(GLES2DecoderTest1, GetTexParameterivValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
@@ -1743,7 +1743,7 @@ TEST_P(GLES2DecoderTest1, GetTexParameterivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, GetTexParameterivInvalidArgs0_0) {
   EXPECT_CALL(*gl_, GetTexParameteriv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetTexParameteriv, 0>(false);
   cmds::GetTexParameteriv::Result* result =
@@ -1759,7 +1759,7 @@ TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest1, GetTexParameterivInvalidArgs1_0) {
   EXPECT_CALL(*gl_, GetTexParameteriv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetTexParameteriv, 0>(false);
   cmds::GetTexParameteriv::Result* result =
@@ -1775,7 +1775,7 @@ TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest1, GetTexParameterivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, GetTexParameteriv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetTexParameteriv, 0>(false);
   cmds::GetTexParameteriv::Result* result =
@@ -1787,7 +1787,7 @@ TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs2_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest1, GetTexParameterivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, GetTexParameteriv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetTexParameteriv, 0>(false);
   cmds::GetTexParameteriv::Result* result =
@@ -1809,7 +1809,7 @@ TEST_P(GLES2DecoderTest1, GetTexParameterivInvalidArgs2_1) {
 
 // TODO(gman): GetUniformLocationBucket
 
-TEST_P(GLES2DecoderTest1, GetVertexAttribfvValidArgs) {
+TEST_F(GLES2DecoderTest1, GetVertexAttribfvValidArgs) {
   SpecializedSetup<cmds::GetVertexAttribfv, 0>(true);
   typedef cmds::GetVertexAttribfv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1826,7 +1826,7 @@ TEST_P(GLES2DecoderTest1, GetVertexAttribfvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetVertexAttribfvInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest1, GetVertexAttribfvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, GetVertexAttribfv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetVertexAttribfv, 0>(false);
   cmds::GetVertexAttribfv::Result* result =
@@ -1838,7 +1838,7 @@ TEST_P(GLES2DecoderTest1, GetVertexAttribfvInvalidArgs2_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetVertexAttribfvInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest1, GetVertexAttribfvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, GetVertexAttribfv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetVertexAttribfv, 0>(false);
   cmds::GetVertexAttribfv::Result* result =
@@ -1853,7 +1853,7 @@ TEST_P(GLES2DecoderTest1, GetVertexAttribfvInvalidArgs2_1) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetVertexAttribivValidArgs) {
+TEST_F(GLES2DecoderTest1, GetVertexAttribivValidArgs) {
   SpecializedSetup<cmds::GetVertexAttribiv, 0>(true);
   typedef cmds::GetVertexAttribiv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ -1870,7 +1870,7 @@ TEST_P(GLES2DecoderTest1, GetVertexAttribivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, GetVertexAttribivInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest1, GetVertexAttribivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, GetVertexAttribiv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetVertexAttribiv, 0>(false);
   cmds::GetVertexAttribiv::Result* result =
@@ -1882,7 +1882,7 @@ TEST_P(GLES2DecoderTest1, GetVertexAttribivInvalidArgs2_0) {
   EXPECT_EQ(0u, result->size);
 }
 
-TEST_P(GLES2DecoderTest1, GetVertexAttribivInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest1, GetVertexAttribivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, GetVertexAttribiv(_, _, _)).Times(0);
   SpecializedSetup<cmds::GetVertexAttribiv, 0>(false);
   cmds::GetVertexAttribiv::Result* result =
@@ -1898,7 +1898,7 @@ TEST_P(GLES2DecoderTest1, GetVertexAttribivInvalidArgs2_1) {
 }
 // TODO(gman): GetVertexAttribPointerv
 
-TEST_P(GLES2DecoderTest1, HintValidArgs) {
+TEST_F(GLES2DecoderTest1, HintValidArgs) {
   EXPECT_CALL(*gl_, Hint(GL_GENERATE_MIPMAP_HINT, GL_FASTEST));
   SpecializedSetup<cmds::Hint, 0>(true);
   cmds::Hint cmd;
@@ -1907,7 +1907,7 @@ TEST_P(GLES2DecoderTest1, HintValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, HintInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, HintInvalidArgs0_0) {
   EXPECT_CALL(*gl_, Hint(_, _)).Times(0);
   SpecializedSetup<cmds::Hint, 0>(false);
   cmds::Hint cmd;
@@ -1916,7 +1916,7 @@ TEST_P(GLES2DecoderTest1, HintInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, IsBufferValidArgs) {
+TEST_F(GLES2DecoderTest1, IsBufferValidArgs) {
   SpecializedSetup<cmds::IsBuffer, 0>(true);
   cmds::IsBuffer cmd;
   cmd.Init(client_buffer_id_, shared_memory_id_, shared_memory_offset_);
@@ -1924,7 +1924,7 @@ TEST_P(GLES2DecoderTest1, IsBufferValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, IsBufferInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderTest1, IsBufferInvalidArgsBadSharedMemoryId) {
   SpecializedSetup<cmds::IsBuffer, 0>(false);
   cmds::IsBuffer cmd;
   cmd.Init(client_buffer_id_, kInvalidSharedMemoryId, shared_memory_offset_);
@@ -1933,7 +1933,7 @@ TEST_P(GLES2DecoderTest1, IsBufferInvalidArgsBadSharedMemoryId) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, IsEnabledValidArgs) {
+TEST_F(GLES2DecoderTest1, IsEnabledValidArgs) {
   SpecializedSetup<cmds::IsEnabled, 0>(true);
   cmds::IsEnabled cmd;
   cmd.Init(GL_BLEND, shared_memory_id_, shared_memory_offset_);
@@ -1941,7 +1941,7 @@ TEST_P(GLES2DecoderTest1, IsEnabledValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, IsEnabledInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest1, IsEnabledInvalidArgs0_0) {
   EXPECT_CALL(*gl_, IsEnabled(_)).Times(0);
   SpecializedSetup<cmds::IsEnabled, 0>(false);
   cmds::IsEnabled cmd;
@@ -1950,7 +1950,7 @@ TEST_P(GLES2DecoderTest1, IsEnabledInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, IsEnabledInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest1, IsEnabledInvalidArgs0_1) {
   EXPECT_CALL(*gl_, IsEnabled(_)).Times(0);
   SpecializedSetup<cmds::IsEnabled, 0>(false);
   cmds::IsEnabled cmd;
@@ -1959,7 +1959,7 @@ TEST_P(GLES2DecoderTest1, IsEnabledInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, IsEnabledInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderTest1, IsEnabledInvalidArgsBadSharedMemoryId) {
   SpecializedSetup<cmds::IsEnabled, 0>(false);
   cmds::IsEnabled cmd;
   cmd.Init(GL_BLEND, kInvalidSharedMemoryId, shared_memory_offset_);
@@ -1968,7 +1968,7 @@ TEST_P(GLES2DecoderTest1, IsEnabledInvalidArgsBadSharedMemoryId) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, IsFramebufferValidArgs) {
+TEST_F(GLES2DecoderTest1, IsFramebufferValidArgs) {
   SpecializedSetup<cmds::IsFramebuffer, 0>(true);
   cmds::IsFramebuffer cmd;
   cmd.Init(client_framebuffer_id_, shared_memory_id_, shared_memory_offset_);
@@ -1976,7 +1976,7 @@ TEST_P(GLES2DecoderTest1, IsFramebufferValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, IsFramebufferInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderTest1, IsFramebufferInvalidArgsBadSharedMemoryId) {
   SpecializedSetup<cmds::IsFramebuffer, 0>(false);
   cmds::IsFramebuffer cmd;
   cmd.Init(
@@ -1987,7 +1987,7 @@ TEST_P(GLES2DecoderTest1, IsFramebufferInvalidArgsBadSharedMemoryId) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest1, IsProgramValidArgs) {
+TEST_F(GLES2DecoderTest1, IsProgramValidArgs) {
   SpecializedSetup<cmds::IsProgram, 0>(true);
   cmds::IsProgram cmd;
   cmd.Init(client_program_id_, shared_memory_id_, shared_memory_offset_);
@@ -1995,7 +1995,7 @@ TEST_P(GLES2DecoderTest1, IsProgramValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, IsProgramInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderTest1, IsProgramInvalidArgsBadSharedMemoryId) {
   SpecializedSetup<cmds::IsProgram, 0>(false);
   cmds::IsProgram cmd;
   cmd.Init(client_program_id_, kInvalidSharedMemoryId, shared_memory_offset_);
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
index b162d4d..93f3faf 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
@@ -225,8 +225,6 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
   }
 };
 
-INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest2, ::testing::Bool());
-
 template <>
 void GLES2DecoderTestBase::SpecializedSetup<cmds::GenQueriesEXT, 0>(
     bool valid) {
@@ -594,63 +592,63 @@ void GLES2DecoderTestBase::SpecializedSetup<cmds::TexParameterivImmediate, 0>(
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h"
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_INT) {
   TestAcceptedUniform(GL_INT, Program::kUniform1i);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC2) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC2) {
   TestAcceptedUniform(GL_INT_VEC2, Program::kUniform2i);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC3) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC3) {
   TestAcceptedUniform(GL_INT_VEC3, Program::kUniform3i);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC4) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_INT_VEC4) {
   TestAcceptedUniform(GL_INT_VEC4, Program::kUniform4i);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_BOOL) {
   TestAcceptedUniform(GL_BOOL, Program::kUniform1i | Program::kUniform1f);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC2) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC2) {
   TestAcceptedUniform(GL_BOOL_VEC2, Program::kUniform2i | Program::kUniform2f);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC3) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC3) {
   TestAcceptedUniform(GL_BOOL_VEC3, Program::kUniform3i | Program::kUniform3f);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC4) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_BOOL_VEC4) {
   TestAcceptedUniform(GL_BOOL_VEC4, Program::kUniform4i | Program::kUniform4f);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniformTypeFLOAT) {
+TEST_F(GLES2DecoderTest2, AcceptsUniformTypeFLOAT) {
   TestAcceptedUniform(GL_FLOAT, Program::kUniform1f);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC2) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC2) {
   TestAcceptedUniform(GL_FLOAT_VEC2, Program::kUniform2f);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC3) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC3) {
   TestAcceptedUniform(GL_FLOAT_VEC3, Program::kUniform3f);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC4) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_VEC4) {
   TestAcceptedUniform(GL_FLOAT_VEC4, Program::kUniform4f);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT2) {
   TestAcceptedUniform(GL_FLOAT_MAT2, Program::kUniformMatrix2f);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT3) {
   TestAcceptedUniform(GL_FLOAT_MAT3, Program::kUniformMatrix3f);
 }
 
-TEST_P(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4) {
+TEST_F(GLES2DecoderTest2, AcceptsUniform_GL_FLOAT_MAT4) {
   TestAcceptedUniform(GL_FLOAT_MAT4, Program::kUniformMatrix4f);
 }
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
index 209b1e6..49d9430 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
@@ -12,7 +12,7 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
 
-TEST_P(GLES2DecoderTest2, IsRenderbufferValidArgs) {
+TEST_F(GLES2DecoderTest2, IsRenderbufferValidArgs) {
   SpecializedSetup<cmds::IsRenderbuffer, 0>(true);
   cmds::IsRenderbuffer cmd;
   cmd.Init(client_renderbuffer_id_, shared_memory_id_, shared_memory_offset_);
@@ -20,7 +20,7 @@ TEST_P(GLES2DecoderTest2, IsRenderbufferValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, IsRenderbufferInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderTest2, IsRenderbufferInvalidArgsBadSharedMemoryId) {
   SpecializedSetup<cmds::IsRenderbuffer, 0>(false);
   cmds::IsRenderbuffer cmd;
   cmd.Init(
@@ -31,7 +31,7 @@ TEST_P(GLES2DecoderTest2, IsRenderbufferInvalidArgsBadSharedMemoryId) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, IsShaderValidArgs) {
+TEST_F(GLES2DecoderTest2, IsShaderValidArgs) {
   SpecializedSetup<cmds::IsShader, 0>(true);
   cmds::IsShader cmd;
   cmd.Init(client_shader_id_, shared_memory_id_, shared_memory_offset_);
@@ -39,7 +39,7 @@ TEST_P(GLES2DecoderTest2, IsShaderValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, IsShaderInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderTest2, IsShaderInvalidArgsBadSharedMemoryId) {
   SpecializedSetup<cmds::IsShader, 0>(false);
   cmds::IsShader cmd;
   cmd.Init(client_shader_id_, kInvalidSharedMemoryId, shared_memory_offset_);
@@ -48,7 +48,7 @@ TEST_P(GLES2DecoderTest2, IsShaderInvalidArgsBadSharedMemoryId) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, IsTextureValidArgs) {
+TEST_F(GLES2DecoderTest2, IsTextureValidArgs) {
   SpecializedSetup<cmds::IsTexture, 0>(true);
   cmds::IsTexture cmd;
   cmd.Init(client_texture_id_, shared_memory_id_, shared_memory_offset_);
@@ -56,7 +56,7 @@ TEST_P(GLES2DecoderTest2, IsTextureValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, IsTextureInvalidArgsBadSharedMemoryId) {
+TEST_F(GLES2DecoderTest2, IsTextureInvalidArgsBadSharedMemoryId) {
   SpecializedSetup<cmds::IsTexture, 0>(false);
   cmds::IsTexture cmd;
   cmd.Init(client_texture_id_, kInvalidSharedMemoryId, shared_memory_offset_);
@@ -65,7 +65,7 @@ TEST_P(GLES2DecoderTest2, IsTextureInvalidArgsBadSharedMemoryId) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, LineWidthValidArgs) {
+TEST_F(GLES2DecoderTest2, LineWidthValidArgs) {
   EXPECT_CALL(*gl_, LineWidth(0.5f));
   SpecializedSetup<cmds::LineWidth, 0>(true);
   cmds::LineWidth cmd;
@@ -74,7 +74,7 @@ TEST_P(GLES2DecoderTest2, LineWidthValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, LineWidthInvalidValue0_0) {
+TEST_F(GLES2DecoderTest2, LineWidthInvalidValue0_0) {
   SpecializedSetup<cmds::LineWidth, 0>(false);
   cmds::LineWidth cmd;
   cmd.Init(0.0f);
@@ -82,7 +82,7 @@ TEST_P(GLES2DecoderTest2, LineWidthInvalidValue0_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, LinkProgramValidArgs) {
+TEST_F(GLES2DecoderTest2, LinkProgramValidArgs) {
   EXPECT_CALL(*gl_, LinkProgram(kServiceProgramId));
   SpecializedSetup<cmds::LinkProgram, 0>(true);
   cmds::LinkProgram cmd;
@@ -92,7 +92,7 @@ TEST_P(GLES2DecoderTest2, LinkProgramValidArgs) {
 }
 // TODO(gman): PixelStorei
 
-TEST_P(GLES2DecoderTest2, PolygonOffsetValidArgs) {
+TEST_F(GLES2DecoderTest2, PolygonOffsetValidArgs) {
   EXPECT_CALL(*gl_, PolygonOffset(1, 2));
   SpecializedSetup<cmds::PolygonOffset, 0>(true);
   cmds::PolygonOffset cmd;
@@ -104,7 +104,7 @@ TEST_P(GLES2DecoderTest2, PolygonOffsetValidArgs) {
 
 // TODO(gman): ReleaseShaderCompiler
 
-TEST_P(GLES2DecoderTest2, RenderbufferStorageValidArgs) {
+TEST_F(GLES2DecoderTest2, RenderbufferStorageValidArgs) {
   SpecializedSetup<cmds::RenderbufferStorage, 0>(true);
   cmds::RenderbufferStorage cmd;
   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 3, 4);
@@ -112,7 +112,7 @@ TEST_P(GLES2DecoderTest2, RenderbufferStorageValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, RenderbufferStorageInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest2, RenderbufferStorageInvalidArgs0_0) {
   EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::RenderbufferStorage, 0>(false);
   cmds::RenderbufferStorage cmd;
@@ -121,7 +121,7 @@ TEST_P(GLES2DecoderTest2, RenderbufferStorageInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, RenderbufferStorageInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, RenderbufferStorageInvalidArgs2_0) {
   EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::RenderbufferStorage, 0>(false);
   cmds::RenderbufferStorage cmd;
@@ -130,7 +130,7 @@ TEST_P(GLES2DecoderTest2, RenderbufferStorageInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, RenderbufferStorageInvalidArgs3_0) {
+TEST_F(GLES2DecoderTest2, RenderbufferStorageInvalidArgs3_0) {
   EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::RenderbufferStorage, 0>(false);
   cmds::RenderbufferStorage cmd;
@@ -139,7 +139,7 @@ TEST_P(GLES2DecoderTest2, RenderbufferStorageInvalidArgs3_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, SampleCoverageValidArgs) {
+TEST_F(GLES2DecoderTest2, SampleCoverageValidArgs) {
   EXPECT_CALL(*gl_, SampleCoverage(1, true));
   SpecializedSetup<cmds::SampleCoverage, 0>(true);
   cmds::SampleCoverage cmd;
@@ -148,7 +148,7 @@ TEST_P(GLES2DecoderTest2, SampleCoverageValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, ScissorValidArgs) {
+TEST_F(GLES2DecoderTest2, ScissorValidArgs) {
   EXPECT_CALL(*gl_, Scissor(1, 2, 3, 4));
   SpecializedSetup<cmds::Scissor, 0>(true);
   cmds::Scissor cmd;
@@ -157,7 +157,7 @@ TEST_P(GLES2DecoderTest2, ScissorValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, ScissorInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, ScissorInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Scissor(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::Scissor, 0>(false);
   cmds::Scissor cmd;
@@ -166,7 +166,7 @@ TEST_P(GLES2DecoderTest2, ScissorInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, ScissorInvalidArgs3_0) {
+TEST_F(GLES2DecoderTest2, ScissorInvalidArgs3_0) {
   EXPECT_CALL(*gl_, Scissor(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::Scissor, 0>(false);
   cmds::Scissor cmd;
@@ -180,7 +180,7 @@ TEST_P(GLES2DecoderTest2, ScissorInvalidArgs3_0) {
 
 // TODO(gman): ShaderSourceBucket
 
-TEST_P(GLES2DecoderTest2, StencilFuncValidArgs) {
+TEST_F(GLES2DecoderTest2, StencilFuncValidArgs) {
   EXPECT_CALL(*gl_, StencilFunc(GL_NEVER, 2, 3));
   SpecializedSetup<cmds::StencilFunc, 0>(true);
   cmds::StencilFunc cmd;
@@ -189,7 +189,7 @@ TEST_P(GLES2DecoderTest2, StencilFuncValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, StencilFuncSeparateValidArgs) {
+TEST_F(GLES2DecoderTest2, StencilFuncSeparateValidArgs) {
   EXPECT_CALL(*gl_, StencilFuncSeparate(GL_FRONT, GL_NEVER, 3, 4));
   SpecializedSetup<cmds::StencilFuncSeparate, 0>(true);
   cmds::StencilFuncSeparate cmd;
@@ -198,7 +198,7 @@ TEST_P(GLES2DecoderTest2, StencilFuncSeparateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, StencilMaskValidArgs) {
+TEST_F(GLES2DecoderTest2, StencilMaskValidArgs) {
   SpecializedSetup<cmds::StencilMask, 0>(true);
   cmds::StencilMask cmd;
   cmd.Init(1);
@@ -206,7 +206,7 @@ TEST_P(GLES2DecoderTest2, StencilMaskValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, StencilMaskSeparateValidArgs) {
+TEST_F(GLES2DecoderTest2, StencilMaskSeparateValidArgs) {
   SpecializedSetup<cmds::StencilMaskSeparate, 0>(true);
   cmds::StencilMaskSeparate cmd;
   cmd.Init(GL_FRONT, 2);
@@ -214,7 +214,7 @@ TEST_P(GLES2DecoderTest2, StencilMaskSeparateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, StencilOpValidArgs) {
+TEST_F(GLES2DecoderTest2, StencilOpValidArgs) {
   EXPECT_CALL(*gl_, StencilOp(GL_KEEP, GL_INCR, GL_KEEP));
   SpecializedSetup<cmds::StencilOp, 0>(true);
   cmds::StencilOp cmd;
@@ -223,7 +223,7 @@ TEST_P(GLES2DecoderTest2, StencilOpValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, StencilOpSeparateValidArgs) {
+TEST_F(GLES2DecoderTest2, StencilOpSeparateValidArgs) {
   EXPECT_CALL(*gl_, StencilOpSeparate(GL_FRONT, GL_INCR, GL_KEEP, GL_KEEP));
   SpecializedSetup<cmds::StencilOpSeparate, 0>(true);
   cmds::StencilOpSeparate cmd;
@@ -233,7 +233,7 @@ TEST_P(GLES2DecoderTest2, StencilOpSeparateValidArgs) {
 }
 // TODO(gman): TexImage2D
 
-TEST_P(GLES2DecoderTest2, TexParameterfValidArgs) {
+TEST_F(GLES2DecoderTest2, TexParameterfValidArgs) {
   EXPECT_CALL(*gl_,
               TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
   SpecializedSetup<cmds::TexParameterf, 0>(true);
@@ -243,7 +243,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_0) {
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterf, 0>(false);
   cmds::TexParameterf cmd;
@@ -252,7 +252,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_1) {
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterf, 0>(false);
   cmds::TexParameterf cmd;
@@ -261,7 +261,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs1_0) {
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterf, 0>(false);
   cmds::TexParameterf cmd;
@@ -270,7 +270,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvValidArgs) {
+TEST_F(GLES2DecoderTest2, TexParameterfvValidArgs) {
   SpecializedSetup<cmds::TexParameterfv, 0>(true);
   cmds::TexParameterfv cmd;
   cmd.Init(GL_TEXTURE_2D,
@@ -287,7 +287,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_0) {
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfv, 0>(false);
   cmds::TexParameterfv cmd;
@@ -300,7 +300,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_1) {
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfv, 0>(false);
   cmds::TexParameterfv cmd;
@@ -313,7 +313,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfv, 0>(false);
   cmds::TexParameterfv cmd;
@@ -326,7 +326,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfv, 0>(false);
   cmds::TexParameterfv cmd;
@@ -335,7 +335,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs2_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfv, 0>(false);
   cmds::TexParameterfv cmd;
@@ -347,7 +347,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfvInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, TexParameterfvImmediateValidArgs) {
   cmds::TexParameterfvImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterfvImmediate>();
   SpecializedSetup<cmds::TexParameterfvImmediate, 0>(true);
@@ -364,7 +364,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_0) {
   cmds::TexParameterfvImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterfvImmediate>();
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
@@ -377,7 +377,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_1) {
   cmds::TexParameterfvImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterfvImmediate>();
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
@@ -390,7 +390,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs1_0) {
   cmds::TexParameterfvImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterfvImmediate>();
   EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
@@ -403,7 +403,7 @@ TEST_P(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameteriValidArgs) {
+TEST_F(GLES2DecoderTest2, TexParameteriValidArgs) {
   EXPECT_CALL(*gl_,
               TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
   SpecializedSetup<cmds::TexParameteri, 0>(true);
@@ -413,7 +413,7 @@ TEST_P(GLES2DecoderTest2, TexParameteriValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameteriInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs0_0) {
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteri, 0>(false);
   cmds::TexParameteri cmd;
@@ -422,7 +422,7 @@ TEST_P(GLES2DecoderTest2, TexParameteriInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameteriInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs0_1) {
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteri, 0>(false);
   cmds::TexParameteri cmd;
@@ -431,7 +431,7 @@ TEST_P(GLES2DecoderTest2, TexParameteriInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameteriInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs1_0) {
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteri, 0>(false);
   cmds::TexParameteri cmd;
@@ -440,7 +440,7 @@ TEST_P(GLES2DecoderTest2, TexParameteriInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivValidArgs) {
+TEST_F(GLES2DecoderTest2, TexParameterivValidArgs) {
   SpecializedSetup<cmds::TexParameteriv, 0>(true);
   cmds::TexParameteriv cmd;
   cmd.Init(GL_TEXTURE_2D,
@@ -457,7 +457,7 @@ TEST_P(GLES2DecoderTest2, TexParameterivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_0) {
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteriv, 0>(false);
   cmds::TexParameteriv cmd;
@@ -470,7 +470,7 @@ TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_1) {
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteriv, 0>(false);
   cmds::TexParameteriv cmd;
@@ -483,7 +483,7 @@ TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs1_0) {
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteriv, 0>(false);
   cmds::TexParameteriv cmd;
@@ -496,7 +496,7 @@ TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs1_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteriv, 0>(false);
   cmds::TexParameteriv cmd;
@@ -505,7 +505,7 @@ TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs2_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteriv, 0>(false);
   cmds::TexParameteriv cmd;
@@ -517,7 +517,7 @@ TEST_P(GLES2DecoderTest2, TexParameterivInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, TexParameterivImmediateValidArgs) {
   cmds::TexParameterivImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterivImmediate>();
   SpecializedSetup<cmds::TexParameterivImmediate, 0>(true);
@@ -534,7 +534,7 @@ TEST_P(GLES2DecoderTest2, TexParameterivImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_0) {
   cmds::TexParameterivImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterivImmediate>();
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
@@ -547,7 +547,7 @@ TEST_P(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_1) {
+TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_1) {
   cmds::TexParameterivImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterivImmediate>();
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
@@ -560,7 +560,7 @@ TEST_P(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_1) {
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs1_0) {
   cmds::TexParameterivImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterivImmediate>();
   EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
@@ -574,7 +574,7 @@ TEST_P(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs1_0) {
 }
 // TODO(gman): TexSubImage2D
 
-TEST_P(GLES2DecoderTest2, Uniform1fValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform1fValidArgs) {
   EXPECT_CALL(*gl_, Uniform1fv(1, 1, _));
   SpecializedSetup<cmds::Uniform1f, 0>(true);
   cmds::Uniform1f cmd;
@@ -583,7 +583,7 @@ TEST_P(GLES2DecoderTest2, Uniform1fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform1fvValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform1fvValidArgs) {
   EXPECT_CALL(
       *gl_,
       Uniform1fv(
@@ -595,7 +595,7 @@ TEST_P(GLES2DecoderTest2, Uniform1fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform1fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform1fv, 0>(false);
   cmds::Uniform1fv cmd;
@@ -604,7 +604,7 @@ TEST_P(GLES2DecoderTest2, Uniform1fvInvalidArgs1_0) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform1fvInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform1fv, 0>(false);
   cmds::Uniform1fv cmd;
@@ -612,7 +612,7 @@ TEST_P(GLES2DecoderTest2, Uniform1fvInvalidArgs2_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform1fvInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform1fv, 0>(false);
   cmds::Uniform1fv cmd;
@@ -620,7 +620,7 @@ TEST_P(GLES2DecoderTest2, Uniform1fvInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform1fvValidArgsCountTooLarge) {
+TEST_F(GLES2DecoderTest2, Uniform1fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_,
       Uniform1fv(
@@ -635,7 +635,7 @@ TEST_P(GLES2DecoderTest2, Uniform1fvValidArgsCountTooLarge) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform1fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform1fvImmediateValidArgs) {
   cmds::Uniform1fvImmediate& cmd = *GetImmediateAs<cmds::Uniform1fvImmediate>();
   EXPECT_CALL(
       *gl_,
@@ -652,7 +652,7 @@ TEST_P(GLES2DecoderTest2, Uniform1fvImmediateValidArgs) {
 // TODO(gman): Uniform1iv
 // TODO(gman): Uniform1ivImmediate
 
-TEST_P(GLES2DecoderTest2, Uniform2fValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform2fValidArgs) {
   EXPECT_CALL(*gl_, Uniform2fv(1, 1, _));
   SpecializedSetup<cmds::Uniform2f, 0>(true);
   cmds::Uniform2f cmd;
@@ -661,7 +661,7 @@ TEST_P(GLES2DecoderTest2, Uniform2fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2fvValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform2fvValidArgs) {
   EXPECT_CALL(
       *gl_,
       Uniform2fv(
@@ -673,7 +673,7 @@ TEST_P(GLES2DecoderTest2, Uniform2fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform2fv, 0>(false);
   cmds::Uniform2fv cmd;
@@ -682,7 +682,7 @@ TEST_P(GLES2DecoderTest2, Uniform2fvInvalidArgs1_0) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2fvInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform2fv, 0>(false);
   cmds::Uniform2fv cmd;
@@ -690,7 +690,7 @@ TEST_P(GLES2DecoderTest2, Uniform2fvInvalidArgs2_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2fvInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform2fv, 0>(false);
   cmds::Uniform2fv cmd;
@@ -698,7 +698,7 @@ TEST_P(GLES2DecoderTest2, Uniform2fvInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2fvValidArgsCountTooLarge) {
+TEST_F(GLES2DecoderTest2, Uniform2fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_,
       Uniform2fv(
@@ -713,7 +713,7 @@ TEST_P(GLES2DecoderTest2, Uniform2fvValidArgsCountTooLarge) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform2fvImmediateValidArgs) {
   cmds::Uniform2fvImmediate& cmd = *GetImmediateAs<cmds::Uniform2fvImmediate>();
   EXPECT_CALL(
       *gl_,
@@ -727,7 +727,7 @@ TEST_P(GLES2DecoderTest2, Uniform2fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2iValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform2iValidArgs) {
   EXPECT_CALL(*gl_, Uniform2iv(1, 1, _));
   SpecializedSetup<cmds::Uniform2i, 0>(true);
   cmds::Uniform2i cmd;
@@ -736,7 +736,7 @@ TEST_P(GLES2DecoderTest2, Uniform2iValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2ivValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform2ivValidArgs) {
   EXPECT_CALL(
       *gl_,
       Uniform2iv(1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
@@ -747,7 +747,7 @@ TEST_P(GLES2DecoderTest2, Uniform2ivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2ivInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform2iv, 0>(false);
   cmds::Uniform2iv cmd;
@@ -756,7 +756,7 @@ TEST_P(GLES2DecoderTest2, Uniform2ivInvalidArgs1_0) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2ivInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform2iv, 0>(false);
   cmds::Uniform2iv cmd;
@@ -764,7 +764,7 @@ TEST_P(GLES2DecoderTest2, Uniform2ivInvalidArgs2_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2ivInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform2iv, 0>(false);
   cmds::Uniform2iv cmd;
@@ -772,7 +772,7 @@ TEST_P(GLES2DecoderTest2, Uniform2ivInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2ivValidArgsCountTooLarge) {
+TEST_F(GLES2DecoderTest2, Uniform2ivValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_,
       Uniform2iv(3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
@@ -786,7 +786,7 @@ TEST_P(GLES2DecoderTest2, Uniform2ivValidArgsCountTooLarge) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform2ivImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform2ivImmediateValidArgs) {
   cmds::Uniform2ivImmediate& cmd = *GetImmediateAs<cmds::Uniform2ivImmediate>();
   EXPECT_CALL(
       *gl_,
@@ -800,7 +800,7 @@ TEST_P(GLES2DecoderTest2, Uniform2ivImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3fValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform3fValidArgs) {
   EXPECT_CALL(*gl_, Uniform3fv(1, 1, _));
   SpecializedSetup<cmds::Uniform3f, 0>(true);
   cmds::Uniform3f cmd;
@@ -809,7 +809,7 @@ TEST_P(GLES2DecoderTest2, Uniform3fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3fvValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform3fvValidArgs) {
   EXPECT_CALL(
       *gl_,
       Uniform3fv(
@@ -821,7 +821,7 @@ TEST_P(GLES2DecoderTest2, Uniform3fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform3fv, 0>(false);
   cmds::Uniform3fv cmd;
@@ -830,7 +830,7 @@ TEST_P(GLES2DecoderTest2, Uniform3fvInvalidArgs1_0) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3fvInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform3fv, 0>(false);
   cmds::Uniform3fv cmd;
@@ -838,7 +838,7 @@ TEST_P(GLES2DecoderTest2, Uniform3fvInvalidArgs2_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3fvInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform3fv, 0>(false);
   cmds::Uniform3fv cmd;
@@ -846,7 +846,7 @@ TEST_P(GLES2DecoderTest2, Uniform3fvInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3fvValidArgsCountTooLarge) {
+TEST_F(GLES2DecoderTest2, Uniform3fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_,
       Uniform3fv(
@@ -861,7 +861,7 @@ TEST_P(GLES2DecoderTest2, Uniform3fvValidArgsCountTooLarge) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform3fvImmediateValidArgs) {
   cmds::Uniform3fvImmediate& cmd = *GetImmediateAs<cmds::Uniform3fvImmediate>();
   EXPECT_CALL(
       *gl_,
@@ -875,7 +875,7 @@ TEST_P(GLES2DecoderTest2, Uniform3fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3iValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform3iValidArgs) {
   EXPECT_CALL(*gl_, Uniform3iv(1, 1, _));
   SpecializedSetup<cmds::Uniform3i, 0>(true);
   cmds::Uniform3i cmd;
@@ -884,7 +884,7 @@ TEST_P(GLES2DecoderTest2, Uniform3iValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3ivValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform3ivValidArgs) {
   EXPECT_CALL(
       *gl_,
       Uniform3iv(1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
@@ -895,7 +895,7 @@ TEST_P(GLES2DecoderTest2, Uniform3ivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3ivInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform3iv, 0>(false);
   cmds::Uniform3iv cmd;
@@ -904,7 +904,7 @@ TEST_P(GLES2DecoderTest2, Uniform3ivInvalidArgs1_0) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3ivInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform3iv, 0>(false);
   cmds::Uniform3iv cmd;
@@ -912,7 +912,7 @@ TEST_P(GLES2DecoderTest2, Uniform3ivInvalidArgs2_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3ivInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform3iv, 0>(false);
   cmds::Uniform3iv cmd;
@@ -920,7 +920,7 @@ TEST_P(GLES2DecoderTest2, Uniform3ivInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3ivValidArgsCountTooLarge) {
+TEST_F(GLES2DecoderTest2, Uniform3ivValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_,
       Uniform3iv(3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
@@ -934,7 +934,7 @@ TEST_P(GLES2DecoderTest2, Uniform3ivValidArgsCountTooLarge) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform3ivImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform3ivImmediateValidArgs) {
   cmds::Uniform3ivImmediate& cmd = *GetImmediateAs<cmds::Uniform3ivImmediate>();
   EXPECT_CALL(
       *gl_,
@@ -948,7 +948,7 @@ TEST_P(GLES2DecoderTest2, Uniform3ivImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4fValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform4fValidArgs) {
   EXPECT_CALL(*gl_, Uniform4fv(1, 1, _));
   SpecializedSetup<cmds::Uniform4f, 0>(true);
   cmds::Uniform4f cmd;
@@ -957,7 +957,7 @@ TEST_P(GLES2DecoderTest2, Uniform4fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4fvValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform4fvValidArgs) {
   EXPECT_CALL(
       *gl_,
       Uniform4fv(
@@ -969,7 +969,7 @@ TEST_P(GLES2DecoderTest2, Uniform4fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform4fv, 0>(false);
   cmds::Uniform4fv cmd;
@@ -978,7 +978,7 @@ TEST_P(GLES2DecoderTest2, Uniform4fvInvalidArgs1_0) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4fvInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform4fv, 0>(false);
   cmds::Uniform4fv cmd;
@@ -986,7 +986,7 @@ TEST_P(GLES2DecoderTest2, Uniform4fvInvalidArgs2_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4fvInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform4fv, 0>(false);
   cmds::Uniform4fv cmd;
@@ -994,7 +994,7 @@ TEST_P(GLES2DecoderTest2, Uniform4fvInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4fvValidArgsCountTooLarge) {
+TEST_F(GLES2DecoderTest2, Uniform4fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_,
       Uniform4fv(
@@ -1009,7 +1009,7 @@ TEST_P(GLES2DecoderTest2, Uniform4fvValidArgsCountTooLarge) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform4fvImmediateValidArgs) {
   cmds::Uniform4fvImmediate& cmd = *GetImmediateAs<cmds::Uniform4fvImmediate>();
   EXPECT_CALL(
       *gl_,
@@ -1023,7 +1023,7 @@ TEST_P(GLES2DecoderTest2, Uniform4fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4iValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform4iValidArgs) {
   EXPECT_CALL(*gl_, Uniform4iv(1, 1, _));
   SpecializedSetup<cmds::Uniform4i, 0>(true);
   cmds::Uniform4i cmd;
@@ -1032,7 +1032,7 @@ TEST_P(GLES2DecoderTest2, Uniform4iValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4ivValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform4ivValidArgs) {
   EXPECT_CALL(
       *gl_,
       Uniform4iv(1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
@@ -1043,7 +1043,7 @@ TEST_P(GLES2DecoderTest2, Uniform4ivValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4ivInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform4iv, 0>(false);
   cmds::Uniform4iv cmd;
@@ -1052,7 +1052,7 @@ TEST_P(GLES2DecoderTest2, Uniform4ivInvalidArgs1_0) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4ivInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform4iv, 0>(false);
   cmds::Uniform4iv cmd;
@@ -1060,7 +1060,7 @@ TEST_P(GLES2DecoderTest2, Uniform4ivInvalidArgs2_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4ivInvalidArgs2_1) {
+TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
   SpecializedSetup<cmds::Uniform4iv, 0>(false);
   cmds::Uniform4iv cmd;
@@ -1068,7 +1068,7 @@ TEST_P(GLES2DecoderTest2, Uniform4ivInvalidArgs2_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4ivValidArgsCountTooLarge) {
+TEST_F(GLES2DecoderTest2, Uniform4ivValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_,
       Uniform4iv(3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
@@ -1082,7 +1082,7 @@ TEST_P(GLES2DecoderTest2, Uniform4ivValidArgsCountTooLarge) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, Uniform4ivImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, Uniform4ivImmediateValidArgs) {
   cmds::Uniform4ivImmediate& cmd = *GetImmediateAs<cmds::Uniform4ivImmediate>();
   EXPECT_CALL(
       *gl_,
@@ -1096,7 +1096,7 @@ TEST_P(GLES2DecoderTest2, Uniform4ivImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvValidArgs) {
+TEST_F(GLES2DecoderTest2, UniformMatrix2fvValidArgs) {
   EXPECT_CALL(*gl_,
               UniformMatrix2fv(
                   1,
@@ -1110,7 +1110,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
   cmds::UniformMatrix2fv cmd;
@@ -1119,7 +1119,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs1_0) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
   cmds::UniformMatrix2fv cmd;
@@ -1128,7 +1128,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_0) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
   cmds::UniformMatrix2fv cmd;
@@ -1136,7 +1136,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_1) {
+TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_1) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
   cmds::UniformMatrix2fv cmd;
@@ -1144,7 +1144,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvValidArgsCountTooLarge) {
+TEST_F(GLES2DecoderTest2, UniformMatrix2fvValidArgsCountTooLarge) {
   EXPECT_CALL(*gl_,
               UniformMatrix2fv(
                   3,
@@ -1162,7 +1162,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvValidArgsCountTooLarge) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, UniformMatrix2fvImmediateValidArgs) {
   cmds::UniformMatrix2fvImmediate& cmd =
       *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
   EXPECT_CALL(
@@ -1178,7 +1178,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvImmediateInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix2fvImmediateInvalidArgs2_0) {
   cmds::UniformMatrix2fvImmediate& cmd =
       *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
@@ -1191,7 +1191,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvImmediateInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvValidArgs) {
+TEST_F(GLES2DecoderTest2, UniformMatrix3fvValidArgs) {
   EXPECT_CALL(*gl_,
               UniformMatrix3fv(
                   1,
@@ -1205,7 +1205,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
   cmds::UniformMatrix3fv cmd;
@@ -1214,7 +1214,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs1_0) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
   cmds::UniformMatrix3fv cmd;
@@ -1223,7 +1223,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_0) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
   cmds::UniformMatrix3fv cmd;
@@ -1231,7 +1231,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_1) {
+TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_1) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
   cmds::UniformMatrix3fv cmd;
@@ -1239,7 +1239,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvValidArgsCountTooLarge) {
+TEST_F(GLES2DecoderTest2, UniformMatrix3fvValidArgsCountTooLarge) {
   EXPECT_CALL(*gl_,
               UniformMatrix3fv(
                   3,
@@ -1257,7 +1257,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvValidArgsCountTooLarge) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, UniformMatrix3fvImmediateValidArgs) {
   cmds::UniformMatrix3fvImmediate& cmd =
       *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
   EXPECT_CALL(
@@ -1273,7 +1273,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvImmediateInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix3fvImmediateInvalidArgs2_0) {
   cmds::UniformMatrix3fvImmediate& cmd =
       *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
@@ -1286,7 +1286,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvImmediateInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvValidArgs) {
+TEST_F(GLES2DecoderTest2, UniformMatrix4fvValidArgs) {
   EXPECT_CALL(*gl_,
               UniformMatrix4fv(
                   1,
@@ -1300,7 +1300,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
   cmds::UniformMatrix4fv cmd;
@@ -1309,7 +1309,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs1_0) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
   cmds::UniformMatrix4fv cmd;
@@ -1318,7 +1318,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_0) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
   cmds::UniformMatrix4fv cmd;
@@ -1326,7 +1326,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_1) {
+TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_1) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
   cmds::UniformMatrix4fv cmd;
@@ -1334,7 +1334,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvValidArgsCountTooLarge) {
+TEST_F(GLES2DecoderTest2, UniformMatrix4fvValidArgsCountTooLarge) {
   EXPECT_CALL(*gl_,
               UniformMatrix4fv(
                   3,
@@ -1352,7 +1352,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvValidArgsCountTooLarge) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, UniformMatrix4fvImmediateValidArgs) {
   cmds::UniformMatrix4fvImmediate& cmd =
       *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
   EXPECT_CALL(
@@ -1368,7 +1368,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvImmediateInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, UniformMatrix4fvImmediateInvalidArgs2_0) {
   cmds::UniformMatrix4fvImmediate& cmd =
       *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
@@ -1381,7 +1381,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvImmediateInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UseProgramValidArgs) {
+TEST_F(GLES2DecoderTest2, UseProgramValidArgs) {
   EXPECT_CALL(*gl_, UseProgram(kServiceProgramId));
   SpecializedSetup<cmds::UseProgram, 0>(true);
   cmds::UseProgram cmd;
@@ -1390,7 +1390,7 @@ TEST_P(GLES2DecoderTest2, UseProgramValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UseProgramInvalidArgs0_0) {
+TEST_F(GLES2DecoderTest2, UseProgramInvalidArgs0_0) {
   EXPECT_CALL(*gl_, UseProgram(_)).Times(0);
   SpecializedSetup<cmds::UseProgram, 0>(false);
   cmds::UseProgram cmd;
@@ -1399,7 +1399,7 @@ TEST_P(GLES2DecoderTest2, UseProgramInvalidArgs0_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, ValidateProgramValidArgs) {
+TEST_F(GLES2DecoderTest2, ValidateProgramValidArgs) {
   EXPECT_CALL(*gl_, ValidateProgram(kServiceProgramId));
   SpecializedSetup<cmds::ValidateProgram, 0>(true);
   cmds::ValidateProgram cmd;
@@ -1408,7 +1408,7 @@ TEST_P(GLES2DecoderTest2, ValidateProgramValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib1fValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib1fValidArgs) {
   EXPECT_CALL(*gl_, VertexAttrib1f(1, 2));
   SpecializedSetup<cmds::VertexAttrib1f, 0>(true);
   cmds::VertexAttrib1f cmd;
@@ -1417,7 +1417,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib1fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib1fvValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib1fvValidArgs) {
   SpecializedSetup<cmds::VertexAttrib1fv, 0>(true);
   cmds::VertexAttrib1fv cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
@@ -1429,7 +1429,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib1fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, VertexAttrib1fv(_, _)).Times(0);
   SpecializedSetup<cmds::VertexAttrib1fv, 0>(false);
   cmds::VertexAttrib1fv cmd;
@@ -1438,7 +1438,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_1) {
+TEST_F(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_1) {
   EXPECT_CALL(*gl_, VertexAttrib1fv(_, _)).Times(0);
   SpecializedSetup<cmds::VertexAttrib1fv, 0>(false);
   cmds::VertexAttrib1fv cmd;
@@ -1447,7 +1447,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib1fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib1fvImmediateValidArgs) {
   cmds::VertexAttrib1fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib1fvImmediate>();
   SpecializedSetup<cmds::VertexAttrib1fvImmediate, 0>(true);
@@ -1462,7 +1462,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib1fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib2fValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib2fValidArgs) {
   EXPECT_CALL(*gl_, VertexAttrib2f(1, 2, 3));
   SpecializedSetup<cmds::VertexAttrib2f, 0>(true);
   cmds::VertexAttrib2f cmd;
@@ -1471,7 +1471,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib2fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib2fvValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib2fvValidArgs) {
   SpecializedSetup<cmds::VertexAttrib2fv, 0>(true);
   cmds::VertexAttrib2fv cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
@@ -1483,7 +1483,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib2fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, VertexAttrib2fv(_, _)).Times(0);
   SpecializedSetup<cmds::VertexAttrib2fv, 0>(false);
   cmds::VertexAttrib2fv cmd;
@@ -1492,7 +1492,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_1) {
+TEST_F(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_1) {
   EXPECT_CALL(*gl_, VertexAttrib2fv(_, _)).Times(0);
   SpecializedSetup<cmds::VertexAttrib2fv, 0>(false);
   cmds::VertexAttrib2fv cmd;
@@ -1501,7 +1501,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib2fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib2fvImmediateValidArgs) {
   cmds::VertexAttrib2fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib2fvImmediate>();
   SpecializedSetup<cmds::VertexAttrib2fvImmediate, 0>(true);
@@ -1516,7 +1516,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib2fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib3fValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib3fValidArgs) {
   EXPECT_CALL(*gl_, VertexAttrib3f(1, 2, 3, 4));
   SpecializedSetup<cmds::VertexAttrib3f, 0>(true);
   cmds::VertexAttrib3f cmd;
@@ -1525,7 +1525,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib3fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib3fvValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib3fvValidArgs) {
   SpecializedSetup<cmds::VertexAttrib3fv, 0>(true);
   cmds::VertexAttrib3fv cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
@@ -1537,7 +1537,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib3fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, VertexAttrib3fv(_, _)).Times(0);
   SpecializedSetup<cmds::VertexAttrib3fv, 0>(false);
   cmds::VertexAttrib3fv cmd;
@@ -1546,7 +1546,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_1) {
+TEST_F(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_1) {
   EXPECT_CALL(*gl_, VertexAttrib3fv(_, _)).Times(0);
   SpecializedSetup<cmds::VertexAttrib3fv, 0>(false);
   cmds::VertexAttrib3fv cmd;
@@ -1555,7 +1555,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib3fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib3fvImmediateValidArgs) {
   cmds::VertexAttrib3fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib3fvImmediate>();
   SpecializedSetup<cmds::VertexAttrib3fvImmediate, 0>(true);
@@ -1570,7 +1570,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib3fvImmediateValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib4fValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib4fValidArgs) {
   EXPECT_CALL(*gl_, VertexAttrib4f(1, 2, 3, 4, 5));
   SpecializedSetup<cmds::VertexAttrib4f, 0>(true);
   cmds::VertexAttrib4f cmd;
@@ -1579,7 +1579,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib4fValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib4fvValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib4fvValidArgs) {
   SpecializedSetup<cmds::VertexAttrib4fv, 0>(true);
   cmds::VertexAttrib4fv cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
@@ -1591,7 +1591,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib4fvValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_0) {
+TEST_F(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, VertexAttrib4fv(_, _)).Times(0);
   SpecializedSetup<cmds::VertexAttrib4fv, 0>(false);
   cmds::VertexAttrib4fv cmd;
@@ -1600,7 +1600,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_0) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_1) {
+TEST_F(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_1) {
   EXPECT_CALL(*gl_, VertexAttrib4fv(_, _)).Times(0);
   SpecializedSetup<cmds::VertexAttrib4fv, 0>(false);
   cmds::VertexAttrib4fv cmd;
@@ -1609,7 +1609,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_1) {
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
-TEST_P(GLES2DecoderTest2, VertexAttrib4fvImmediateValidArgs) {
+TEST_F(GLES2DecoderTest2, VertexAttrib4fvImmediateValidArgs) {
   cmds::VertexAttrib4fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib4fvImmediate>();
   SpecializedSetup<cmds::VertexAttrib4fvImmediate, 0>(true);
@@ -1625,7 +1625,7 @@ TEST_P(GLES2DecoderTest2, VertexAttrib4fvImmediateValidArgs) {
 }
 // TODO(gman): VertexAttribPointer
 
-TEST_P(GLES2DecoderTest2, ViewportValidArgs) {
+TEST_F(GLES2DecoderTest2, ViewportValidArgs) {
   EXPECT_CALL(*gl_, Viewport(1, 2, 3, 4));
   SpecializedSetup<cmds::Viewport, 0>(true);
   cmds::Viewport cmd;
@@ -1634,7 +1634,7 @@ TEST_P(GLES2DecoderTest2, ViewportValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, ViewportInvalidArgs2_0) {
+TEST_F(GLES2DecoderTest2, ViewportInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Viewport(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::Viewport, 0>(false);
   cmds::Viewport cmd;
@@ -1643,7 +1643,7 @@ TEST_P(GLES2DecoderTest2, ViewportInvalidArgs2_0) {
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, ViewportInvalidArgs3_0) {
+TEST_F(GLES2DecoderTest2, ViewportInvalidArgs3_0) {
   EXPECT_CALL(*gl_, Viewport(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::Viewport, 0>(false);
   cmds::Viewport cmd;
@@ -1668,7 +1668,7 @@ TEST_P(GLES2DecoderTest2, ViewportInvalidArgs3_0) {
 
 // TODO(gman): PushGroupMarkerEXT
 
-TEST_P(GLES2DecoderTest2, PopGroupMarkerEXTValidArgs) {
+TEST_F(GLES2DecoderTest2, PopGroupMarkerEXTValidArgs) {
   SpecializedSetup<cmds::PopGroupMarkerEXT, 0>(true);
   cmds::PopGroupMarkerEXT cmd;
   cmd.Init();
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc
index 3fadaf0..b41eed2 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3.cc
@@ -34,9 +34,7 @@ class GLES2DecoderTest3 : public GLES2DecoderTestBase {
   GLES2DecoderTest3() { }
 };
 
-INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest3, ::testing::Bool());
-
-TEST_P(GLES2DecoderTest3, TraceBeginCHROMIUM) {
+TEST_F(GLES2DecoderTest3, TraceBeginCHROMIUM) {
   const uint32 kBucketId = 123;
   const char kName[] = "test_command";
   SetBucketAsCString(kBucketId, kName);
@@ -46,7 +44,7 @@ TEST_P(GLES2DecoderTest3, TraceBeginCHROMIUM) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
 }
 
-TEST_P(GLES2DecoderTest3, TraceEndCHROMIUM) {
+TEST_F(GLES2DecoderTest3, TraceEndCHROMIUM) {
   // Test end fails if no begin.
   TraceEndCHROMIUM end_cmd;
   end_cmd.Init();
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
index 0b829f3..b1ed1df 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
@@ -53,15 +53,7 @@ GLES2DecoderTestBase::GLES2DecoderTestBase()
       client_vertex_shader_id_(121),
       client_fragment_shader_id_(122),
       client_query_id_(123),
-      client_vertexarray_id_(124),
-      ignore_cached_state_for_test_(GetParam()),
-      cached_color_mask_red_(true),
-      cached_color_mask_green_(true),
-      cached_color_mask_blue_(true),
-      cached_color_mask_alpha_(true),
-      cached_depth_mask_(true),
-      cached_stencil_front_mask_(0xFFFFFFFFU),
-      cached_stencil_back_mask_(0xFFFFFFFFU) {
+      client_vertexarray_id_(124) {
   memset(immediate_buffer_, 0xEE, sizeof(immediate_buffer_));
 }
 
@@ -94,8 +86,7 @@ GLES2DecoderTestBase::InitState::InitState()
       request_depth(false),
       request_stencil(false),
       bind_generates_resource(false),
-      lose_context_when_out_of_memory(false) {
-}
+      lose_context_when_out_of_memory(false) {}
 
 void GLES2DecoderTestBase::InitDecoder(const InitState& init) {
   InitDecoderWithCommandLine(init, NULL);
@@ -316,7 +307,6 @@ void GLES2DecoderTestBase::InitDecoderWithCommandLine(
   std::vector<int32> attribs(attributes, attributes + arraysize(attributes));
 
   decoder_.reset(GLES2Decoder::Create(group_.get()));
-  decoder_->SetIgnoreCachedStateForTest(ignore_cached_state_for_test_);
   decoder_->GetLogger()->set_log_synthesized_gl_errors(false);
   decoder_->Initialize(surface_,
                        context_,
@@ -565,7 +555,9 @@ void GLES2DecoderTestBase::SetupExpectationsForFramebufferClearingMulti(
     EXPECT_CALL(*gl_, ClearColor(0.0f, 0.0f, 0.0f, 0.0f))
         .Times(1)
         .RetiresOnSaturation();
-    SetupExpectationsForColorMask(true, true, true, true);
+    EXPECT_CALL(*gl_, ColorMask(true, true, true, true))
+        .Times(1)
+        .RetiresOnSaturation();
   }
   if ((clear_bits & GL_STENCIL_BUFFER_BIT) != 0) {
     EXPECT_CALL(*gl_, ClearStencil(0))
@@ -579,9 +571,13 @@ void GLES2DecoderTestBase::SetupExpectationsForFramebufferClearingMulti(
     EXPECT_CALL(*gl_, ClearDepth(1.0f))
         .Times(1)
         .RetiresOnSaturation();
-    SetupExpectationsForDepthMask(true);
+    EXPECT_CALL(*gl_, DepthMask(1))
+        .Times(1)
+        .RetiresOnSaturation();
   }
-  SetupExpectationsForEnableDisable(GL_SCISSOR_TEST, false);
+  EXPECT_CALL(*gl_, Disable(GL_SCISSOR_TEST))
+      .Times(1)
+      .RetiresOnSaturation();
   EXPECT_CALL(*gl_, Clear(clear_bits))
       .Times(1)
       .RetiresOnSaturation();
@@ -651,98 +647,6 @@ void GLES2DecoderTestBase::DoDeleteBuffer(
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
-void GLES2DecoderTestBase::SetupExpectationsForColorMask(bool red,
-                                                         bool green,
-                                                         bool blue,
-                                                         bool alpha) {
-  if (ignore_cached_state_for_test_ || cached_color_mask_red_ != red ||
-      cached_color_mask_green_ != green || cached_color_mask_blue_ != blue ||
-      cached_color_mask_alpha_ != alpha) {
-    cached_color_mask_red_ = red;
-    cached_color_mask_green_ = green;
-    cached_color_mask_blue_ = blue;
-    cached_color_mask_alpha_ = alpha;
-    EXPECT_CALL(*gl_, ColorMask(red, green, blue, alpha))
-        .Times(1)
-        .RetiresOnSaturation();
-  }
-}
-
-void GLES2DecoderTestBase::SetupExpectationsForDepthMask(bool mask) {
-  if (ignore_cached_state_for_test_ || cached_depth_mask_ != mask) {
-    cached_depth_mask_ = mask;
-    EXPECT_CALL(*gl_, DepthMask(mask)).Times(1).RetiresOnSaturation();
-  }
-}
-
-void GLES2DecoderTestBase::SetupExpectationsForEnableDisable(GLenum cap,
-                                                             bool enable) {
-  switch (cap) {
-    case GL_BLEND:
-      if (enable_flags_.cached_blend == enable &&
-          !ignore_cached_state_for_test_)
-        return;
-      enable_flags_.cached_blend = enable;
-      break;
-    case GL_CULL_FACE:
-      if (enable_flags_.cached_cull_face == enable &&
-          !ignore_cached_state_for_test_)
-        return;
-      enable_flags_.cached_cull_face = enable;
-      break;
-    case GL_DEPTH_TEST:
-      if (enable_flags_.cached_depth_test == enable &&
-          !ignore_cached_state_for_test_)
-        return;
-      enable_flags_.cached_depth_test = enable;
-      break;
-    case GL_DITHER:
-      if (enable_flags_.cached_dither == enable &&
-          !ignore_cached_state_for_test_)
-        return;
-      enable_flags_.cached_dither = enable;
-      break;
-    case GL_POLYGON_OFFSET_FILL:
-      if (enable_flags_.cached_polygon_offset_fill == enable &&
-          !ignore_cached_state_for_test_)
-        return;
-      enable_flags_.cached_polygon_offset_fill = enable;
-      break;
-    case GL_SAMPLE_ALPHA_TO_COVERAGE:
-      if (enable_flags_.cached_sample_alpha_to_coverage == enable &&
-          !ignore_cached_state_for_test_)
-        return;
-      enable_flags_.cached_sample_alpha_to_coverage = enable;
-      break;
-    case GL_SAMPLE_COVERAGE:
-      if (enable_flags_.cached_sample_coverage == enable &&
-          !ignore_cached_state_for_test_)
-        return;
-      enable_flags_.cached_sample_coverage = enable;
-      break;
-    case GL_SCISSOR_TEST:
-      if (enable_flags_.cached_scissor_test == enable &&
-          !ignore_cached_state_for_test_)
-        return;
-      enable_flags_.cached_scissor_test = enable;
-      break;
-    case GL_STENCIL_TEST:
-      if (enable_flags_.cached_stencil_test == enable &&
-          !ignore_cached_state_for_test_)
-        return;
-      enable_flags_.cached_stencil_test = enable;
-      break;
-    default:
-      NOTREACHED();
-      return;
-  }
-  if (enable) {
-    EXPECT_CALL(*gl_, Enable(cap)).Times(1).RetiresOnSaturation();
-  } else {
-    EXPECT_CALL(*gl_, Disable(cap)).Times(1).RetiresOnSaturation();
-  }
-}
-
 void GLES2DecoderTestBase::SetupExpectationsForApplyingDirtyState(
     bool framebuffer_is_rgb,
     bool framebuffer_has_depth,
@@ -752,60 +656,87 @@ void GLES2DecoderTestBase::SetupExpectationsForApplyingDirtyState(
     bool depth_enabled,
     GLuint front_stencil_mask,
     GLuint back_stencil_mask,
-    bool stencil_enabled) {
-  bool color_mask_red = (color_bits & 0x1000) != 0;
-  bool color_mask_green = (color_bits & 0x0100) != 0;
-  bool color_mask_blue = (color_bits & 0x0010) != 0;
-  bool color_mask_alpha = (color_bits & 0x0001) && !framebuffer_is_rgb;
-
-  SetupExpectationsForColorMask(
-      color_mask_red, color_mask_green, color_mask_blue, color_mask_alpha);
-  SetupExpectationsForDepthMask(depth_mask);
-
-  if (ignore_cached_state_for_test_ ||
-      cached_stencil_front_mask_ != front_stencil_mask) {
-    cached_stencil_front_mask_ = front_stencil_mask;
-    EXPECT_CALL(*gl_, StencilMaskSeparate(GL_FRONT, front_stencil_mask))
+    bool stencil_enabled,
+    bool cull_face_enabled,
+    bool scissor_test_enabled,
+    bool blend_enabled) {
+  EXPECT_CALL(*gl_, ColorMask(
+      (color_bits & 0x1000) != 0,
+      (color_bits & 0x0100) != 0,
+      (color_bits & 0x0010) != 0,
+      (color_bits & 0x0001) && !framebuffer_is_rgb))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, DepthMask(depth_mask))
+      .Times(1)
+      .RetiresOnSaturation();
+  if (framebuffer_has_depth && depth_enabled) {
+    EXPECT_CALL(*gl_, Enable(GL_DEPTH_TEST))
+        .Times(1)
+        .RetiresOnSaturation();
+  } else {
+    EXPECT_CALL(*gl_, Disable(GL_DEPTH_TEST))
         .Times(1)
         .RetiresOnSaturation();
   }
-
-  if (ignore_cached_state_for_test_ ||
-      cached_stencil_back_mask_ != back_stencil_mask) {
-    cached_stencil_back_mask_ = back_stencil_mask;
-    EXPECT_CALL(*gl_, StencilMaskSeparate(GL_BACK, back_stencil_mask))
+  EXPECT_CALL(*gl_, StencilMaskSeparate(GL_FRONT, front_stencil_mask))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, StencilMaskSeparate(GL_BACK, back_stencil_mask))
+      .Times(1)
+      .RetiresOnSaturation();
+  if (framebuffer_has_stencil && stencil_enabled) {
+    EXPECT_CALL(*gl_, Enable(GL_STENCIL_TEST))
+        .Times(1)
+        .RetiresOnSaturation();
+  } else {
+    EXPECT_CALL(*gl_, Disable(GL_STENCIL_TEST))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+  if (cull_face_enabled) {
+    EXPECT_CALL(*gl_, Enable(GL_CULL_FACE))
+        .Times(1)
+        .RetiresOnSaturation();
+  } else {
+    EXPECT_CALL(*gl_, Disable(GL_CULL_FACE))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+  if (scissor_test_enabled) {
+    EXPECT_CALL(*gl_, Enable(GL_SCISSOR_TEST))
+        .Times(1)
+        .RetiresOnSaturation();
+  } else {
+    EXPECT_CALL(*gl_, Disable(GL_SCISSOR_TEST))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+  if (blend_enabled) {
+    EXPECT_CALL(*gl_, Enable(GL_BLEND))
+        .Times(1)
+        .RetiresOnSaturation();
+  } else {
+    EXPECT_CALL(*gl_, Disable(GL_BLEND))
         .Times(1)
         .RetiresOnSaturation();
   }
-
-  SetupExpectationsForEnableDisable(GL_DEPTH_TEST,
-                                    framebuffer_has_depth && depth_enabled);
-  SetupExpectationsForEnableDisable(GL_STENCIL_TEST,
-                                    framebuffer_has_stencil && stencil_enabled);
 }
 
 void GLES2DecoderTestBase::SetupExpectationsForApplyingDefaultDirtyState() {
-  SetupExpectationsForApplyingDirtyState(false,   // Framebuffer is RGB
-                                         false,   // 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
-}
-
-GLES2DecoderTestBase::EnableFlags::EnableFlags()
-    : cached_blend(false),
-      cached_cull_face(false),
-      cached_depth_test(false),
-      cached_dither(true),
-      cached_polygon_offset_fill(false),
-      cached_sample_alpha_to_coverage(false),
-      cached_sample_coverage(false),
-      cached_scissor_test(false),
-      cached_stencil_test(false) {
+  SetupExpectationsForApplyingDirtyState(
+      false,   // Framebuffer is RGB
+      false,   // 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
 }
 
 void GLES2DecoderTestBase::DoBindFramebuffer(
@@ -1377,19 +1308,6 @@ void GLES2DecoderTestBase::SetupShader(
   EXPECT_EQ(error::kNoError, ExecuteCmd(link_cmd));
 }
 
-void GLES2DecoderTestBase::DoEnableDisable(GLenum cap, bool enable) {
-  SetupExpectationsForEnableDisable(cap, enable);
-  if (enable) {
-    cmds::Enable cmd;
-    cmd.Init(cap);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  } else {
-    cmds::Disable cmd;
-    cmd.Init(cap);
-    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  }
-}
-
 void GLES2DecoderTestBase::DoEnableVertexAttribArray(GLint index) {
   EXPECT_CALL(*gl_, EnableVertexAttribArray(index))
       .Times(1)
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
index 91ff2e1..52e7211 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
@@ -34,7 +34,7 @@ namespace gles2 {
 
 class MemoryTracker;
 
-class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
+class GLES2DecoderTestBase : public testing::Test {
  public:
   GLES2DecoderTestBase();
   virtual ~GLES2DecoderTestBase();
@@ -269,8 +269,6 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
       GLuint index, GLint size, GLenum type, GLsizei stride, GLuint offset);
   void DoVertexAttribDivisorANGLE(GLuint index, GLuint divisor);
 
-  void DoEnableDisable(GLenum cap, bool enable);
-
   void DoEnableVertexAttribArray(GLint index);
 
   void DoBufferData(GLenum target, GLsizei size);
@@ -332,13 +330,6 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
       GLclampf restore_depth,
       bool restore_scissor_test);
 
-  void SetupExpectationsForDepthMask(bool mask);
-  void SetupExpectationsForEnableDisable(GLenum cap, bool enable);
-  void SetupExpectationsForColorMask(bool red,
-                                     bool green,
-                                     bool blue,
-                                     bool alpha);
-
   void SetupExpectationsForApplyingDirtyState(
       bool framebuffer_is_rgb,
       bool framebuffer_has_depth,
@@ -348,7 +339,10 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
       bool depth_enabled,
       GLuint front_stencil_mask,
       GLuint back_stencil_mask,
-      bool stencil_enabled);
+      bool stencil_enabled,
+      bool cull_face_enabled,
+      bool scissor_test_enabled,
+      bool blend_enabled);
 
   void SetupExpectationsForApplyingDefaultDirtyState();
 
@@ -516,30 +510,6 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
 
   int8 immediate_buffer_[256];
 
-  const bool ignore_cached_state_for_test_;
-  bool cached_color_mask_red_;
-  bool cached_color_mask_green_;
-  bool cached_color_mask_blue_;
-  bool cached_color_mask_alpha_;
-  bool cached_depth_mask_;
-  uint32 cached_stencil_front_mask_;
-  uint32 cached_stencil_back_mask_;
-
-  struct EnableFlags {
-    EnableFlags();
-    bool cached_blend;
-    bool cached_cull_face;
-    bool cached_depth_test;
-    bool cached_dither;
-    bool cached_polygon_offset_fill;
-    bool cached_sample_alpha_to_coverage;
-    bool cached_sample_coverage;
-    bool cached_scissor_test;
-    bool cached_stencil_test;
-  };
-
-  EnableFlags enable_flags_;
-
  private:
   class MockCommandBufferEngine : public CommandBufferEngine {
    public: