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

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

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

17 files changed, 1821 insertions, 1191 deletions

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