Remove constant values from command buffer commands

Some named GL types have only one possible value. Remove the variables
for these from the command buffer commands. Validate the argument in the
client. In order to detect that an argument is constant, the named type
type info object must contain one valid value and a new 'is_complete'
property must be 'True'.

Add an enum constant in the command buffer command C++ class for each
constant value. This way the hand-written decoder code can access the
value as if it was passed through the command buffer.

BUG=369969

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

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

19 files changed, 862 insertions, 741 deletions

diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index 8f6cf77..94c39d6 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -507,9 +507,16 @@ _STATES = {
   },
 }
 
-# This is a list of enum names and their valid values. It is used to map
-# GLenum arguments to a specific set of valid values.
-_ENUM_LISTS = {
+# Named type info object represents a named type that is used in OpenGL call
+# arguments.  Each named type defines a set of valid OpenGL call arguments.  The
+# named types are used in 'cmd_buffer_functions.txt'.
+# type: The actual GL type of the named type.
+# valid: The list of values that are valid for both the client and the service.
+# invalid: Examples of invalid values for the type. At least these values
+#          should be tested to be invalid.
+# is_complete: The list of valid values of type are final and will not be
+#              modified during runtime.
+_NAMED_TYPE_INFO = {
   'BlitFilter': {
     'type': 'GLenum',
     'valid': [
@@ -1152,6 +1159,7 @@ _ENUM_LISTS = {
   },
   'TextureBorder': {
     'type': 'GLint',
+    'is_complete': True,
     'valid': [
       '0',
     ],
@@ -1174,6 +1182,7 @@ _ENUM_LISTS = {
   },
   'ZeroOnly': {
     'type': 'GLint',
+    'is_complete': True,
     'valid': [
       '0',
     ],
@@ -1183,6 +1192,7 @@ _ENUM_LISTS = {
   },
   'FalseOnly': {
     'type': 'GLboolean',
+    'is_complete': True,
     'valid': [
       'false',
     ],
@@ -2733,6 +2743,12 @@ class TypeHandler(object):
     args = func.GetCmdArgs()
     for arg in args:
       file.Write("  %s %s;\n" % (arg.cmd_type, arg.name))
+
+    consts = func.GetCmdConstants()
+    for const in consts:
+      file.Write("  static const %s %s = %s;\n" %
+                 (const.cmd_type, const.name, const.GetConstantValue()))
+
     file.Write("};\n")
     file.Write("\n")
 
@@ -2901,16 +2917,18 @@ COMPILE_ASSERT(offsetof(%(cmd_name)s::Result, %(field_name)s) == %(offset)d,
       file.Write("    return error;\n")
 
   def WriteValidUnitTest(self, func, file, test, extra = {}):
-    """Writes a valid unit test."""
+    """Writes a valid unit test for the service implementation."""
     if func.GetInfo('expectation') == False:
       test = self._remove_expected_call_re.sub('', test)
     name = func.name
-    arg_strings = []
-    for count, arg in enumerate(func.GetOriginalArgs()):
-      arg_strings.append(arg.GetValidArg(func, count, 0))
-    gl_arg_strings = []
-    for count, arg in enumerate(func.GetOriginalArgs()):
-      gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
+    arg_strings = [
+      arg.GetValidArg(func) \
+      for arg in func.GetOriginalArgs() if not arg.IsConstant()
+    ]
+    gl_arg_strings = [
+      arg.GetValidGLArg(func) \
+      for arg in func.GetOriginalArgs()
+    ]
     gl_func_name = func.GetGLTestFunctionName()
     vars = {
       'test_name': 'GLES2DecoderTest%d' % file.file_num,
@@ -2927,19 +2945,26 @@ COMPILE_ASSERT(offsetof(%(cmd_name)s::Result, %(field_name)s) == %(offset)d,
     file.Write(test % vars)
 
   def WriteInvalidUnitTest(self, func, file, test, extra = {}):
-    """Writes a invalid unit test."""
-    for arg_index, arg in enumerate(func.GetOriginalArgs()):
-      num_invalid_values = arg.GetNumInvalidValues(func)
+    """Writes an invalid unit test for the service implementation."""
+    for invalid_arg_index, invalid_arg in enumerate(func.GetOriginalArgs()):
+      # Service implementation does not test constants, as they are not part of
+      # the call in the service side.
+      if invalid_arg.IsConstant():
+        continue
+
+      num_invalid_values = invalid_arg.GetNumInvalidValues(func)
       for value_index in range(0, num_invalid_values):
         arg_strings = []
         parse_result = "kNoError"
         gl_error = None
-        for count, arg in enumerate(func.GetOriginalArgs()):
-          if count == arg_index:
+        for arg in func.GetOriginalArgs():
+          if arg.IsConstant():
+            continue
+          if invalid_arg is arg:
             (arg_string, parse_result, gl_error) = arg.GetInvalidArg(
-                count, value_index)
+                value_index)
           else:
-            arg_string = arg.GetValidArg(func, count, 0)
+            arg_string = arg.GetValidArg(func)
           arg_strings.append(arg_string)
         gl_arg_strings = []
         for arg in func.GetOriginalArgs():
@@ -2952,7 +2977,7 @@ COMPILE_ASSERT(offsetof(%(cmd_name)s::Result, %(field_name)s) == %(offset)d,
         vars = {
           'test_name': 'GLES2DecoderTest%d' % file.file_num ,
           'name': func.name,
-          'arg_index': arg_index,
+          'arg_index': invalid_arg_index,
           'value_index': value_index,
           'gl_func_name': gl_func_name,
           'args': ", ".join(arg_strings),
@@ -3111,7 +3136,7 @@ TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
       for arg in func.GetOriginalArgs():
         arg.WriteClientSideValidationCode(file, func)
       file.Write("  helper_->%s(%s);\n" %
-                 (func.name, func.MakeOriginalArgString("")))
+                 (func.name, func.MakeHelperArgString("")))
       file.Write("  CheckGLError();\n")
       self.WriteClientGLReturnLog(func, file)
       file.Write("}\n")
@@ -3157,18 +3182,46 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
-      cmd_arg_strings = []
-      for count, arg in enumerate(func.GetCmdArgs()):
-        cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
-        count += 1
-      gl_arg_strings = []
-      for count, arg in enumerate(func.GetOriginalArgs()):
-        gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
+      cmd_arg_strings = [
+        arg.GetValidClientSideCmdArg(func) for arg in func.GetCmdArgs()
+      ]
+
+      gl_arg_strings = [
+        arg.GetValidClientSideArg(func) for arg in func.GetOriginalArgs()
+      ]
+
       file.Write(code % {
             'name': func.name,
             'args': ", ".join(gl_arg_strings),
             'cmd_args': ", ".join(cmd_arg_strings),
           })
+
+      # Test constants for invalid values, as they are not tested by the
+      # service.
+      constants = [arg for arg in func.GetOriginalArgs() if arg.IsConstant()]
+      if constants:
+        code = """
+TEST_F(GLES2ImplementationTest, %(name)sInvalidConstantArg%(invalid_index)d) {
+  gl_->%(name)s(%(args)s);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(%(gl_error)s, CheckError());
+}
+"""
+        for invalid_arg in constants:
+          gl_arg_strings = []
+          invalid = invalid_arg.GetInvalidArg(func)
+          for arg in func.GetOriginalArgs():
+            if arg is invalid_arg:
+              gl_arg_strings.append(invalid[0])
+            else:
+              gl_arg_strings.append(arg.GetValidClientSideArg(func))
+
+          file.Write(code % {
+            'name': func.name,
+            'invalid_index': func.GetOriginalArgs().index(invalid_arg),
+            'args': ", ".join(gl_arg_strings),
+            'gl_error': invalid[2],
+          })
     else:
       if client_test != False:
         file.Write("// TODO: Implement unit test for %s\n" % func.name)
@@ -3302,9 +3355,11 @@ TEST_P(%(test_name)s, %(name)sInvalidValue%(ndx)d_%(check_ndx)d) {
 }
 """
           name = func.name
-          arg_strings = []
-          for count, arg in enumerate(func.GetOriginalArgs()):
-            arg_strings.append(arg.GetValidArg(func, count, 0))
+          arg_strings = [
+            arg.GetValidArg(func) \
+            for arg in func.GetOriginalArgs() if not arg.IsConstant()
+          ]
+
           arg_strings[ndx] = range_check['test_value']
           vars = {
             'test_name': 'GLES2DecoderTest%d' % file.file_num,
@@ -3820,8 +3875,8 @@ TEST_P(%(test_name)s, %(name)sValidArgsNewId) {
 }
 """
       self.WriteValidUnitTest(func, file, valid_test, {
-          'first_arg': func.GetOriginalArgs()[0].GetValidArg(func, 0, 0),
-          'first_gl_arg': func.GetOriginalArgs()[0].GetValidGLArg(func, 0, 0),
+          'first_arg': func.GetOriginalArgs()[0].GetValidArg(func),
+          'first_gl_arg': func.GetOriginalArgs()[0].GetValidGLArg(func),
           'resource_type': func.GetOriginalArgs()[1].resource_type,
           'gl_gen_func_name': func.GetInfo("gen_func"),
       })
@@ -3903,13 +3958,13 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
   EXPECT_TRUE(NoCommandsWritten());
 }
 """
-    cmd_arg_strings = []
-    for count, arg in enumerate(func.GetCmdArgs()):
-      cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
-      count += 1
-    gl_arg_strings = []
-    for count, arg in enumerate(func.GetOriginalArgs()):
-      gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
+    cmd_arg_strings = [
+      arg.GetValidClientSideCmdArg(func) for arg in func.GetCmdArgs()
+    ]
+    gl_arg_strings = [
+      arg.GetValidClientSideArg(func) for arg in func.GetOriginalArgs()
+    ]
+
     file.Write(code % {
           'name': func.name,
           'args': ", ".join(gl_arg_strings),
@@ -4594,7 +4649,9 @@ class GETnHandler(TypeHandler):
       arg_string = (
           ", ".join(["%s" % arg.name for arg in all_but_last_args]))
       all_arg_string = (
-          ", ".join(["%s" % arg.name for arg in func.GetOriginalArgs()]))
+          ", ".join([
+            "%s" % arg.name
+              for arg in func.GetOriginalArgs() if not arg.IsConstant()]))
       self.WriteTraceEvent(func, file)
       code = """  if (%(func_name)sHelper(%(all_arg_string)s)) {
     return;
@@ -4643,14 +4700,18 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
   EXPECT_EQ(static_cast<Result::Type>(1), result);
 }
 """
-    cmd_arg_strings = []
-    for count, arg in enumerate(func.GetCmdArgs()[0:-2]):
-      cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
-    cmd_arg_strings[0] = '123'
-    gl_arg_strings = []
-    for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
-      gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
-    gl_arg_strings[0] = '123'
+    first_cmd_arg = func.GetCmdArgs()[0].GetValidNonCachedClientSideCmdArg(func)
+    if not first_cmd_arg:
+      return
+
+    first_gl_arg = func.GetCmdArgs()[0].GetValidNonCachedClientSideArg(func)
+    cmd_arg_strings = [first_cmd_arg]
+    for arg in func.GetCmdArgs()[1:-2]:
+      cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func))
+    gl_arg_strings = [first_gl_arg]
+    for arg in func.GetOriginalArgs()[1:-1]:
+      gl_arg_strings.append(arg.GetValidClientSideArg(func))
+
     file.Write(code % {
           'name': func.name,
           'args': ", ".join(gl_arg_strings),
@@ -4681,8 +4742,8 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
 """
     gl_arg_strings = []
     valid_pname = ''
-    for count, arg in enumerate(func.GetOriginalArgs()[:-1]):
-      arg_value = arg.GetValidGLArg(func, count, 0)
+    for arg in func.GetOriginalArgs()[:-1]:
+      arg_value = arg.GetValidGLArg(func)
       gl_arg_strings.append(arg_value)
       if arg.name == 'pname':
         valid_pname = arg_value
@@ -4745,9 +4806,9 @@ class PUTHandler(ArrayArgTypeHandler):
     """Writes the service unit test for a command."""
     expected_call = "EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));"
     if func.GetInfo("first_element_only"):
-      gl_arg_strings = []
-      for count, arg in enumerate(func.GetOriginalArgs()):
-        gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
+      gl_arg_strings = [
+        arg.GetValidGLArg(func) for arg in func.GetOriginalArgs()
+      ]
       gl_arg_strings[-1] = "*" + gl_arg_strings[-1]
       expected_call = ("EXPECT_CALL(*gl_, %%(gl_func_name)s(%s));" %
           ", ".join(gl_arg_strings))
@@ -4798,11 +4859,11 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
-    gl_arg_strings = []
-    gl_any_strings = []
-    for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
-      gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
-      gl_any_strings.append("_")
+    gl_arg_strings = [
+      arg.GetValidGLArg(func) for arg in func.GetOriginalArgs()[0:-1]
+    ]
+    gl_any_strings = ["_"] * len(gl_arg_strings)
+
     extra = {
       'data_ref': ("*" if func.GetInfo('first_element_only') else ""),
       'data_type': self.GetArrayType(func),
@@ -4885,12 +4946,13 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
-    cmd_arg_strings = []
-    for count, arg in enumerate(func.GetCmdArgs()[0:-2]):
-      cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
-    gl_arg_strings = []
-    for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
-      gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
+    cmd_arg_strings = [
+      arg.GetValidClientSideCmdArg(func) for arg in func.GetCmdArgs()[0:-2]
+    ]
+    gl_arg_strings = [
+      arg.GetValidClientSideArg(func) for arg in func.GetOriginalArgs()[0:-1]
+    ]
+
     file.Write(code % {
           'name': func.name,
           'type': self.GetArrayType(func),
@@ -5040,8 +5102,9 @@ TEST_P(%(test_name)s, %(name)sValidArgsCountTooLarge) {
         # the number of elements requested in the command.
         arg_strings.append("5")
       else:
-        gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
-        arg_strings.append(arg.GetValidArg(func, count, 0))
+        gl_arg_strings.append(arg.GetValidGLArg(func))
+        if not arg.IsConstant():
+          arg_strings.append(arg.GetValidArg(func))
     extra = {
       'gl_args': ", ".join(gl_arg_strings),
       'args': ", ".join(arg_strings),
@@ -5068,10 +5131,11 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
     gl_arg_strings = []
     gl_any_strings = []
     arg_strings = []
-    for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
-      gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
+    for arg in func.GetOriginalArgs()[0:-1]:
+      gl_arg_strings.append(arg.GetValidGLArg(func))
       gl_any_strings.append("_")
-      arg_strings.append(arg.GetValidArg(func, count, 0))
+      if not arg.IsConstant():
+        arg_strings.append(arg.GetValidArg(func))
     extra = {
       'data_type': self.GetArrayType(func),
       'data_count': self.GetArrayCount(func),
@@ -5128,7 +5192,7 @@ TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
     for arg in func.GetOriginalArgs():
       arg.WriteClientSideValidationCode(file, func)
     file.Write("  helper_->%sImmediate(%s);\n" %
-               (func.name, func.MakeOriginalArgString("")))
+               (func.name, func.MakeInitString("")))
     file.Write("  CheckGLError();\n")
     file.Write("}\n")
     file.Write("\n")
@@ -5154,15 +5218,16 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
-    cmd_arg_strings = []
-    for count, arg in enumerate(func.GetCmdArgs()[0:-2]):
-      cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
+    cmd_arg_strings = [
+      arg.GetValidClientSideCmdArg(func) for arg in func.GetCmdArgs()[0:-2]
+    ]
     gl_arg_strings = []
     count_param = 0
-    for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
-      gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
+    for arg in func.GetOriginalArgs()[0:-1]:
+      valid_value = arg.GetValidClientSideArg(func)
+      gl_arg_strings.append(valid_value)
       if arg.name == "count":
-        count_param = int(arg.GetValidClientSideArg(func, count, 0))
+        count_param = int(valid_value)
     file.Write(code % {
           'name': func.name,
           'type': self.GetArrayType(func),
@@ -5172,6 +5237,50 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
           'count_param': count_param,
         })
 
+    # Test constants for invalid values, as they are not tested by the
+    # service.
+    constants = [
+      arg for arg in func.GetOriginalArgs()[0:-1] if arg.IsConstant()
+    ]
+    if not constants:
+      return
+
+    code = """
+TEST_F(GLES2ImplementationTest, %(name)sInvalidConstantArg%(invalid_index)d) {
+  %(type)s data[%(count_param)d][%(count)d] = {{0}};
+  for (int ii = 0; ii < %(count_param)d; ++ii) {
+    for (int jj = 0; jj < %(count)d; ++jj) {
+      data[ii][jj] = static_cast<%(type)s>(ii * %(count)d + jj);
+    }
+  }
+  gl_->%(name)s(%(args)s, &data[0][0]);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(%(gl_error)s, CheckError());
+}
+"""
+    for invalid_arg in constants:
+      gl_arg_strings = []
+      invalid = invalid_arg.GetInvalidArg(func)
+      for arg in func.GetOriginalArgs()[0:-1]:
+        if arg is invalid_arg:
+          gl_arg_strings.append(invalid[0])
+        else:
+          valid_value = arg.GetValidClientSideArg(func)
+          gl_arg_strings.append(valid_value)
+          if arg.name == "count":
+            count_param = int(valid_value)
+
+      file.Write(code % {
+        'name': func.name,
+        'invalid_index': func.GetOriginalArgs().index(invalid_arg),
+        'type': self.GetArrayType(func),
+        'count': self.GetArrayCount(func),
+        'args': ", ".join(gl_arg_strings),
+        'gl_error': invalid[2],
+        'count_param': count_param,
+      })
+
+
   def WriteImmediateCmdComputeSize(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  static uint32_t ComputeDataSize(GLsizei count) {\n")
@@ -5239,17 +5348,17 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
 """
     file.Write(code % {
           "name": func.name,
-          "typed_args": func.MakeTypedOriginalArgString(""),
-          "args": func.MakeOriginalArgString(""),
+          "typed_args": func.MakeTypedInitString(""),
+          "args": func.MakeInitString("")
         })
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
     args = func.GetCmdArgs()
     count_param = 0
-    for value, arg in enumerate(args):
+    for arg in args:
       if arg.name == "count":
-        count_param = int(arg.GetValidClientSideArg(func, value, 0))
+        count_param = int(arg.GetValidClientSideCmdArg(func))
     file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name)
     file.Write("  const int kSomeBaseValueToTestWith = 51;\n")
     file.Write("  static %s data[] = {\n" % self.GetArrayType(func))
@@ -5322,7 +5431,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
 }
 """
     args = func.GetOriginalArgs()
-    local_args = "%s, 1, _" % args[0].GetValidGLArg(func, 0, 0)
+    local_args = "%s, 1, _" % args[0].GetValidGLArg(func)
     self.WriteValidUnitTest(func, file, valid_test, {
         'name': func.name,
         'count': self.GetArrayCount(func),
@@ -5382,7 +5491,7 @@ class GLcharHandler(CustomHandler):
 
 """
     file.Write(code % {
-          "typed_args": func.MakeTypedOriginalArgString("_"),
+          "typed_args": func.MakeTypedArgString("_"),
           "set_code": "\n".join(set_code),
           "last_arg": last_arg.name
         })
@@ -5391,9 +5500,9 @@ class GLcharHandler(CustomHandler):
     """Overrriden from TypeHandler."""
     last_arg = func.GetLastOriginalArg()
     file.Write("  void* Set(void* cmd%s, uint32_t _data_size) {\n" %
-               func.MakeTypedOriginalArgString("_", True))
+               func.MakeTypedCmdArgString("_", True))
     file.Write("    static_cast<ValueType*>(cmd)->Init(%s, _data_size);\n" %
-               func.MakeOriginalArgString("_"))
+               func.MakeCmdArgString("_"))
     file.Write("    return NextImmediateCmdAddress<ValueType>("
                "cmd, _data_size);\n")
     file.Write("  }\n")
@@ -5740,7 +5849,7 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
 }
 """
     args = func.GetOriginalArgs()
-    id_name = args[0].GetValidGLArg(func, 0, 0)
+    id_name = args[0].GetValidGLArg(func)
     get_len_func = func.GetInfo('get_len_func')
     get_len_enum = func.GetInfo('get_len_enum')
     sub = {
@@ -5748,8 +5857,8 @@ TEST_P(%(test_name)s, %(name)sValidArgs) {
         'get_len_func': get_len_func,
         'get_len_enum': get_len_enum,
         'gl_args': '%s, strlen(kInfo) + 1, _, _' %
-             args[0].GetValidGLArg(func, 0, 0),
-        'args': '%s, kBucketId' % args[0].GetValidArg(func, 0, 0),
+             args[0].GetValidGLArg(func),
+        'args': '%s, kBucketId' % args[0].GetValidArg(func),
         'expect_len_code': '',
     }
     if get_len_func and get_len_func[0:2] == 'gl':
@@ -5776,6 +5885,41 @@ TEST_P(%(test_name)s, %(name)sInvalidArgs) {
     """Overrriden from TypeHandler."""
     pass
 
+class NamedType(object):
+  """A class that represents a type of an argument in a client function.
+
+  A type of an argument that is to be passed through in the command buffer
+  command. Currently used only for the arguments that are specificly named in
+  the 'cmd_buffer_functions.txt' file, mostly enums.
+  """
+
+  def __init__(self, info):
+    assert not 'is_complete' in info or info['is_complete'] == True
+    self.info = info
+    self.valid = info['valid']
+    if 'invalid' in info:
+      self.invalid = info['invalid']
+    else:
+      self.invalid = []
+
+  def GetType(self):
+    return self.info['type']
+
+  def GetInvalidValues(self):
+    return self.invalid
+
+  def GetValidValues(self):
+    return self.valid
+
+  def IsConstant(self):
+    if not 'is_complete' in self.info:
+      return False
+
+    return len(self.GetValidValues()) == 1
+
+  def GetConstantValue(self):
+    return self.GetValidValues()[0]
+
 class Argument(object):
   """A class that represents a function argument."""
 
@@ -5806,41 +5950,73 @@ class Argument(object):
     """Returns true if argument is a pointer."""
     return False
 
+  def IsConstant(self):
+    """Returns true if the argument has only one valid value."""
+    return False
+
   def AddCmdArgs(self, args):
     """Adds command arguments for this argument to the given list."""
-    return args.append(self)
+    if not self.IsConstant():
+      return args.append(self)
 
   def AddInitArgs(self, args):
     """Adds init arguments for this argument to the given list."""
-    return args.append(self)
+    if not self.IsConstant():
+      return args.append(self)
 
-  def GetValidArg(self, func, offset, index):
+  def GetValidArg(self, func):
     """Gets a valid value for this argument."""
-    valid_arg = func.GetValidArg(offset)
+    valid_arg = func.GetValidArg(self)
     if valid_arg != None:
       return valid_arg
-    return str(offset + 1)
 
-  def GetValidClientSideArg(self, func, offset, index):
-    """Gets a valid value for this argument."""
-    return str(offset + 1)
+    index = func.GetOriginalArgs().index(self)
+    return str(index + 1)
 
-  def GetValidClientSideCmdArg(self, func, offset, index):
+  def GetValidClientSideArg(self, func):
     """Gets a valid value for this argument."""
-    return str(offset + 1)
+    valid_arg = func.GetValidArg(self)
+    if valid_arg != None:
+      return valid_arg
 
-  def GetValidGLArg(self, func, offset, index):
-    """Gets a valid GL value for this argument."""
-    valid_arg = func.GetValidArg(offset)
+    index = func.GetOriginalArgs().index(self)
+    return str(index + 1)
+
+  def GetValidClientSideCmdArg(self, func):
+    """Gets a valid value for this argument."""
+    valid_arg = func.GetValidArg(self)
     if valid_arg != None:
       return valid_arg
-    return str(offset + 1)
+    try:
+      index = func.GetOriginalArgs().index(self)
+      return str(index + 1)
+    except ValueError:
+      pass
+    index = func.GetCmdArgs().index(self)
+    return str(index + 1)
+
+  def GetValidGLArg(self, func):
+    """Gets a valid GL value for this argument."""
+    return self.GetValidArg(func)
+
+  def GetValidNonCachedClientSideArg(self, func):
+    """Returns a valid value for this argument in a GL call.
+    Using the value will produce a command buffer service invocation.
+    Returns None if there is no such value."""
+    return '123'
+
+  def GetValidNonCachedClientSideCmdArg(self, func):
+    """Returns a valid value for this argument in a command buffer command.
+    Calling the GL function with the value returned by
+    GetValidNonCachedClientSideArg will result in a command buffer command
+    that contains the value returned by this function. """
+    return '123'
 
   def GetNumInvalidValues(self, func):
     """returns the number of invalid values to be tested."""
     return 0
 
-  def GetInvalidArg(self, offset, index):
+  def GetInvalidArg(self, index):
     """returns an invalid value and expected parse result by index."""
     return ("---ERROR0---", "---ERROR2---", None)
 
@@ -5899,19 +6075,19 @@ class BoolArgument(Argument):
   def __init__(self, name, type):
     Argument.__init__(self, name, 'GLboolean')
 
-  def GetValidArg(self, func, offset, index):
+  def GetValidArg(self, func):
     """Gets a valid value for this argument."""
     return 'true'
 
-  def GetValidClientSideArg(self, func, offset, index):
+  def GetValidClientSideArg(self, func):
     """Gets a valid value for this argument."""
     return 'true'
 
-  def GetValidClientSideCmdArg(self, func, offset, index):
+  def GetValidClientSideCmdArg(self, func):
     """Gets a valid value for this argument."""
     return 'true'
 
-  def GetValidGLArg(self, func, offset, index):
+  def GetValidGLArg(self, func):
     """Gets a valid GL value for this argument."""
     return 'true'
 
@@ -5928,11 +6104,6 @@ class UniformLocationArgument(Argument):
 """
     file.Write(code % (self.type, self.name, self.type, self.name))
 
-  def GetValidArg(self, func, offset, index):
-    """Gets a valid value for this argument."""
-    return "%d" % (offset + 1)
-
-
 class DataSizeArgument(Argument):
   """class for data_size which Bucket commands do not need."""
 
@@ -5955,7 +6126,7 @@ class SizeArgument(Argument):
       return 0
     return 1
 
-  def GetInvalidArg(self, offset, index):
+  def GetInvalidArg(self, index):
     """overridden from Argument."""
     return ("-1", "kNoError", "GL_INVALID_VALUE")
 
@@ -5984,7 +6155,7 @@ class SizeNotNegativeArgument(SizeArgument):
   def __init__(self, name, type, gl_type):
     SizeArgument.__init__(self, name, gl_type)
 
-  def GetInvalidArg(self, offset, index):
+  def GetInvalidArg(self, index):
     """overridden from SizeArgument."""
     return ("-1", "kOutOfBounds", "GL_NO_ERROR")
 
@@ -6003,11 +6174,19 @@ class EnumBaseArgument(Argument):
     self.gl_error = gl_error
     name = type[len(gl_type):]
     self.type_name = name
-    self.enum_info = _ENUM_LISTS[name]
+    self.named_type = NamedType(_NAMED_TYPE_INFO[name])
+
+  def IsConstant(self):
+    return self.named_type.IsConstant()
+
+  def GetConstantValue(self):
+    return self.named_type.GetConstantValue()
 
   def WriteValidationCode(self, file, func):
+    if self.named_type.IsConstant():
+      return
     file.Write("  if (!validators_->%s.IsValid(%s)) {\n" %
-        (ToUnderscore(self.type_name), self.name))
+               (ToUnderscore(self.type_name), self.name))
     if self.gl_error == "GL_INVALID_ENUM":
       file.Write(
           "    LOCAL_SET_GL_ERROR_INVALID_ENUM(\"gl%s\", %s, \"%s\");\n" %
@@ -6019,41 +6198,67 @@ class EnumBaseArgument(Argument):
     file.Write("    return error::kNoError;\n")
     file.Write("  }\n")
 
-  def GetValidArg(self, func, offset, index):
-    valid_arg = func.GetValidArg(offset)
+  def WriteClientSideValidationCode(self, file, func):
+    if not self.named_type.IsConstant():
+      return
+    file.Write("  if (%s != %s) {" % (self.name,
+                                      self.GetConstantValue()))
+    file.Write(
+      "    SetGLError(%s, \"gl%s\", \"%s %s\");\n" %
+      (self.gl_error, func.original_name, self.name, self.gl_error))
+    if func.return_type == "void":
+      file.Write("    return;\n")
+    else:
+      file.Write("    return %s;\n" % func.GetErrorReturnString())
+    file.Write("  }\n")
+
+  def GetValidArg(self, func):
+    valid_arg = func.GetValidArg(self)
     if valid_arg != None:
       return valid_arg
-    if 'valid' in self.enum_info:
-      valid = self.enum_info['valid']
+    valid = self.named_type.GetValidValues()
+    if valid:
       num_valid = len(valid)
-      if index >= num_valid:
-        index = num_valid - 1
-      return valid[index]
-    return str(offset + 1)
+      return valid[0]
+
+    index = func.GetOriginalArgs().index(self)
+    return str(index + 1)
 
-  def GetValidClientSideArg(self, func, offset, index):
+  def GetValidClientSideArg(self, func):
     """Gets a valid value for this argument."""
-    return self.GetValidArg(func, offset, index)
+    return self.GetValidArg(func)
 
-  def GetValidClientSideCmdArg(self, func, offset, index):
+  def GetValidClientSideCmdArg(self, func):
     """Gets a valid value for this argument."""
-    return self.GetValidArg(func, offset, index)
+    valid_arg = func.GetValidArg(self)
+    if valid_arg != None:
+      return valid_arg
+
+    valid = self.named_type.GetValidValues()
+    if valid:
+      num_valid = len(valid)
+      return valid[0]
+
+    try:
+      index = func.GetOriginalArgs().index(self)
+      return str(index + 1)
+    except ValueError:
+      pass
+    index = func.GetCmdArgs().index(self)
+    return str(index + 1)
 
-  def GetValidGLArg(self, func, offset, index):
+  def GetValidGLArg(self, func):
     """Gets a valid value for this argument."""
-    return self.GetValidArg(func, offset, index)
+    return self.GetValidArg(func)
 
   def GetNumInvalidValues(self, func):
     """returns the number of invalid values to be tested."""
-    if 'invalid' in self.enum_info:
-      invalid = self.enum_info['invalid']
-      return len(invalid)
-    return 0
+    return len(self.named_type.GetInvalidValues())
 
-  def GetInvalidArg(self, offset, index):
+  def GetInvalidArg(self, index):
     """returns an invalid value by index."""
-    if 'invalid' in self.enum_info:
-      invalid = self.enum_info['invalid']
+    invalid = self.named_type.GetInvalidValues()
+    if invalid:
       num_invalid = len(invalid)
       if index >= num_invalid:
         index = num_invalid - 1
@@ -6194,11 +6399,11 @@ class PointerArgument(Argument):
     assert match
     return match.groupdict()['element_type']
 
-  def GetValidArg(self, func, offset, index):
+  def GetValidArg(self, func):
     """Overridden from Argument."""
     return "shared_memory_id_, shared_memory_offset_"
 
-  def GetValidGLArg(self, func, offset, index):
+  def GetValidGLArg(self, func):
     """Overridden from Argument."""
     return "reinterpret_cast<%s>(shared_memory_address_)" % self.type
 
@@ -6206,7 +6411,7 @@ class PointerArgument(Argument):
     """Overridden from Argument."""
     return 2
 
-  def GetInvalidArg(self, offset, index):
+  def GetInvalidArg(self, index):
     """Overridden from Argument."""
     if index == 0:
       return ("kInvalidSharedMemoryId, 0", "kOutOfBounds", None)
@@ -6285,10 +6490,10 @@ class InputStringBucketArgument(Argument):
         'name': self.name,
       })
 
-  def GetValidArg(self, func, offset, index):
+  def GetValidArg(self, func):
     return "kNameBucketId"
 
-  def GetValidGLArg(self, func, offset, index):
+  def GetValidGLArg(self, func):
     return "_"
 
 
@@ -6320,10 +6525,10 @@ class ResourceIdArgument(Argument):
     """Overridden from Argument."""
     file.Write("  %s %s = c.%s;\n" % (self.type, self.name, self.name))
 
-  def GetValidArg(self, func, offset, index):
+  def GetValidArg(self, func):
     return "client_%s_id_" % self.resource_type.lower()
 
-  def GetValidGLArg(self, func, offset, index):
+  def GetValidGLArg(self, func):
     return "kService%sId" % self.resource_type
 
 
@@ -6342,10 +6547,10 @@ class ResourceIdBindArgument(Argument):
 """
     file.Write(code % {'type': self.type, 'name': self.name})
 
-  def GetValidArg(self, func, offset, index):
+  def GetValidArg(self, func):
     return "client_%s_id_" % self.resource_type.lower()
 
-  def GetValidGLArg(self, func, offset, index):
+  def GetValidGLArg(self, func):
     return "kService%sId" % self.resource_type
 
 
@@ -6362,17 +6567,17 @@ class ResourceIdZeroArgument(Argument):
     """Overridden from Argument."""
     file.Write("  %s %s = c.%s;\n" % (self.type, self.name, self.name))
 
-  def GetValidArg(self, func, offset, index):
+  def GetValidArg(self, func):
     return "client_%s_id_" % self.resource_type.lower()
 
-  def GetValidGLArg(self, func, offset, index):
+  def GetValidGLArg(self, func):
     return "kService%sId" % self.resource_type
 
   def GetNumInvalidValues(self, func):
     """returns the number of invalid values to be tested."""
     return 1
 
-  def GetInvalidArg(self, offset, index):
+  def GetInvalidArg(self, index):
     """returns an invalid value by index."""
     return ("kInvalidClientId", "kNoError", "GL_INVALID_VALUE")
 
@@ -6477,8 +6682,14 @@ class Function(object):
       return self.info[name]
     return default
 
-  def GetValidArg(self, index):
-    """Gets a valid arg from the function info if one exists."""
+  def GetValidArg(self, arg):
+    """Gets a valid argument value for the parameter arg from the function info
+    if one exists."""
+    try:
+      index = self.GetOriginalArgs().index(arg)
+    except ValueError:
+      return None
+
     valid_args = self.GetInfo('valid_args')
     if valid_args and str(index) in valid_args:
       return valid_args[str(index)]
@@ -6501,6 +6712,15 @@ class Function(object):
   def InAnyPepperExtension(self):
     return self.IsCoreGLFunction() or self.GetInfo('pepper_interface')
 
+  def GetErrorReturnString(self):
+    if self.GetInfo("error_return"):
+      return self.GetInfo("error_return")
+    elif self.return_type == "GLboolean":
+      return "GL_FALSE"
+    elif "*" in self.return_type:
+      return "NULL"
+    return "0"
+
   def GetGLFunctionName(self):
     """Gets the function to call to execute GL for this command."""
     if self.GetInfo('decoder_func'):
@@ -6529,6 +6749,10 @@ class Function(object):
     """Clears the command args for this function."""
     self.cmd_args = []
 
+  def GetCmdConstants(self):
+    """Gets the constants for this function."""
+    return [arg for arg in self.args_for_cmds if arg.IsConstant()]
+
   def GetInitArgs(self):
     """Gets the init args for this function."""
     return self.init_args
@@ -6562,6 +6786,25 @@ class Function(object):
         ["%s%s" % (prefix, arg.name) for arg in args])
     return self.__MaybePrependComma(arg_string, add_comma)
 
+  def MakeTypedHelperArgString(self, prefix, add_comma = False):
+    """Gets a list of typed GL arguments after removing unneeded arguments."""
+    args = self.GetOriginalArgs()
+    arg_string = ", ".join(
+        ["%s %s%s" % (
+          arg.type,
+          prefix,
+          arg.name,
+        ) for arg in args if not arg.IsConstant()])
+    return self.__MaybePrependComma(arg_string, add_comma)
+
+  def MakeHelperArgString(self, prefix, add_comma = False, separator = ", "):
+    """Gets a list of GL arguments after removing unneeded arguments."""
+    args = self.GetOriginalArgs()
+    arg_string = separator.join(
+        ["%s%s" % (prefix, arg.name)
+         for arg in args if not arg.IsConstant()])
+    return self.__MaybePrependComma(arg_string, add_comma)
+
   def MakeTypedPepperArgString(self, prefix):
     """Gets a list of arguments as they need to be for Pepper."""
     if self.GetInfo("pepper_args"):
@@ -7659,53 +7902,58 @@ extern const NameToFunc g_gles2_function_table[] = {
   def WriteServiceUtilsHeader(self, filename):
     """Writes the gles2 auto generated utility header."""
     file = CHeaderWriter(filename)
-    for enum in sorted(_ENUM_LISTS.keys()):
+    for name in sorted(_NAMED_TYPE_INFO.keys()):
+      named_type = NamedType(_NAMED_TYPE_INFO[name])
+      if named_type.IsConstant():
+        continue
       file.Write("ValueValidator<%s> %s;\n" %
-                 (_ENUM_LISTS[enum]['type'], ToUnderscore(enum)))
+                 (named_type.GetType(), ToUnderscore(name)))
     file.Write("\n")
     file.Close()
 
   def WriteServiceUtilsImplementation(self, filename):
     """Writes the gles2 auto generated utility implementation."""
     file = CHeaderWriter(filename)
-    enums = sorted(_ENUM_LISTS.keys())
-    for enum in enums:
-      if len(_ENUM_LISTS[enum]['valid']) > 0:
+    names = sorted(_NAMED_TYPE_INFO.keys())
+    for name in names:
+      named_type = NamedType(_NAMED_TYPE_INFO[name])
+      if named_type.IsConstant():
+        continue
+      if named_type.GetValidValues():
         file.Write("static const %s valid_%s_table[] = {\n" %
-                   (_ENUM_LISTS[enum]['type'], ToUnderscore(enum)))
-        for value in _ENUM_LISTS[enum]['valid']:
+                   (named_type.GetType(), ToUnderscore(name)))
+        for value in named_type.GetValidValues():
           file.Write("  %s,\n" % value)
         file.Write("};\n")
         file.Write("\n")
-    file.Write("Validators::Validators()\n")
-    pre = ': '
-    post = ','
-    for count, enum in enumerate(enums):
-      if count + 1 == len(enums):
-        post = ' {'
-      if len(_ENUM_LISTS[enum]['valid']) > 0:
-        code = """    %(pre)s%(name)s(
-          valid_%(name)s_table, arraysize(valid_%(name)s_table))%(post)s
-"""
+    file.Write("Validators::Validators()")
+    pre = '    : '
+    for count, name in enumerate(names):
+      named_type = NamedType(_NAMED_TYPE_INFO[name])
+      if named_type.IsConstant():
+        continue
+      if named_type.GetValidValues():
+        code = """%(pre)s%(name)s(
+          valid_%(name)s_table, arraysize(valid_%(name)s_table))"""
       else:
-        code = """    %(pre)s%(name)s()%(post)s
-"""
+        code = "%(pre)s%(name)s()"
       file.Write(code % {
-          'name': ToUnderscore(enum),
-          'pre': pre,
-          'post': post,
-        })
-      pre = '  '
+        'name': ToUnderscore(name),
+        'pre': pre,
+      })
+      pre = ',\n    '
+    file.Write(" {\n");
     file.Write("}\n\n");
     file.Close()
 
   def WriteCommonUtilsHeader(self, filename):
     """Writes the gles2 common utility header."""
     file = CHeaderWriter(filename)
-    enums = sorted(_ENUM_LISTS.keys())
-    for enum in enums:
-      if _ENUM_LISTS[enum]['type'] == 'GLenum':
-        file.Write("static std::string GetString%s(uint32_t value);\n" % enum)
+    type_infos = sorted(_NAMED_TYPE_INFO.keys())
+    for type_info in type_infos:
+      if _NAMED_TYPE_INFO[type_info]['type'] == 'GLenum':
+        file.Write("static std::string GetString%s(uint32_t value);\n" %
+                   type_info)
     file.Write("\n")
     file.Close()
 
@@ -7740,14 +7988,14 @@ const size_t GLES2Util::enum_to_string_table_len_ =
 
 """)
 
-    enums = sorted(_ENUM_LISTS.keys())
+    enums = sorted(_NAMED_TYPE_INFO.keys())
     for enum in enums:
-      if _ENUM_LISTS[enum]['type'] == 'GLenum':
+      if _NAMED_TYPE_INFO[enum]['type'] == 'GLenum':
         file.Write("std::string GLES2Util::GetString%s(uint32_t value) {\n" %
                    enum)
-        if len(_ENUM_LISTS[enum]['valid']) > 0:
+        if len(_NAMED_TYPE_INFO[enum]['valid']) > 0:
           file.Write("  static const EnumToString string_table[] = {\n")
-          for value in _ENUM_LISTS[enum]['valid']:
+          for value in _NAMED_TYPE_INFO[enum]['valid']:
             file.Write('    { %s, "%s" },\n' % (value, value))
           file.Write("""  };
   return GLES2Util::GetQualifiedEnumString(
@@ -7862,14 +8110,7 @@ const size_t GLES2Util::enum_to_string_table_len_ =
         file.Write("\n")
       else:
         file.Write(" else {\n")
-        error_return = "0"
-        if func.GetInfo("error_return"):
-          error_return = func.GetInfo("error_return")
-        elif func.return_type == "GLboolean":
-          error_return = "GL_FALSE"
-        elif "*" in func.return_type:
-          error_return = "NULL"
-        file.Write("    return %s;\n" % error_return)
+        file.Write("    return %s;\n" % func.GetErrorReturnString())
         file.Write("  }\n")
       file.Write("}\n\n")
 
@@ -7975,14 +8216,15 @@ def main(argv):
   for state_name in sorted(_STATES.keys()):
     state = _STATES[state_name]
     if 'enum' in state:
-      _ENUM_LISTS['GLState']['valid'].append(state['enum'])
+      _NAMED_TYPE_INFO['GLState']['valid'].append(state['enum'])
     else:
       for item in state['states']:
         if 'extension_flag' in item:
           continue
-        _ENUM_LISTS['GLState']['valid'].append(item['enum'])
+        _NAMED_TYPE_INFO['GLState']['valid'].append(item['enum'])
   for capability in _CAPABILITY_FLAGS:
-    _ENUM_LISTS['GLState']['valid'].append("GL_%s" % capability['name'].upper())
+    _NAMED_TYPE_INFO['GLState']['valid'].append("GL_%s" %
+                                                capability['name'].upper())
 
   # This script lives under gpu/command_buffer, cd to base directory.
   os.chdir(os.path.dirname(__file__) + "/../..")
diff --git a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
index 9868fd8..360983a 100644
--- a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
+++ b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
@@ -198,7 +198,6 @@ void CompressedTexImage2D(GLenum target,
                           GLenum internalformat,
                           GLsizei width,
                           GLsizei height,
-                          GLint border,
                           GLsizei imageSize,
                           uint32_t data_shm_id,
                           uint32_t data_shm_offset) {
@@ -210,7 +209,6 @@ void CompressedTexImage2D(GLenum target,
             internalformat,
             width,
             height,
-            border,
             imageSize,
             data_shm_id,
             data_shm_offset);
@@ -222,12 +220,11 @@ void CompressedTexImage2DBucket(GLenum target,
                                 GLenum internalformat,
                                 GLsizei width,
                                 GLsizei height,
-                                GLint border,
                                 GLuint bucket_id) {
   gles2::cmds::CompressedTexImage2DBucket* c =
       GetCmdSpace<gles2::cmds::CompressedTexImage2DBucket>();
   if (c) {
-    c->Init(target, level, internalformat, width, height, border, bucket_id);
+    c->Init(target, level, internalformat, width, height, bucket_id);
   }
 }
 
@@ -278,11 +275,10 @@ void CopyTexImage2D(GLenum target,
                     GLint x,
                     GLint y,
                     GLsizei width,
-                    GLsizei height,
-                    GLint border) {
+                    GLsizei height) {
   gles2::cmds::CopyTexImage2D* c = GetCmdSpace<gles2::cmds::CopyTexImage2D>();
   if (c) {
-    c->Init(target, level, internalformat, x, y, width, height, border);
+    c->Init(target, level, internalformat, x, y, width, height);
   }
 }
 
@@ -517,12 +513,11 @@ void FramebufferRenderbuffer(GLenum target,
 void FramebufferTexture2D(GLenum target,
                           GLenum attachment,
                           GLenum textarget,
-                          GLuint texture,
-                          GLint level) {
+                          GLuint texture) {
   gles2::cmds::FramebufferTexture2D* c =
       GetCmdSpace<gles2::cmds::FramebufferTexture2D>();
   if (c) {
-    c->Init(target, attachment, textarget, texture, level);
+    c->Init(target, attachment, textarget, texture);
   }
 }
 
@@ -1096,7 +1091,6 @@ void TexImage2D(GLenum target,
                 GLint internalformat,
                 GLsizei width,
                 GLsizei height,
-                GLint border,
                 GLenum format,
                 GLenum type,
                 uint32_t pixels_shm_id,
@@ -1108,7 +1102,6 @@ void TexImage2D(GLenum target,
             internalformat,
             width,
             height,
-            border,
             format,
             type,
             pixels_shm_id,
@@ -1407,19 +1400,17 @@ void Uniform4ivImmediate(GLint location, GLsizei count, const GLint* v) {
 
 void UniformMatrix2fv(GLint location,
                       GLsizei count,
-                      GLboolean transpose,
                       uint32_t value_shm_id,
                       uint32_t value_shm_offset) {
   gles2::cmds::UniformMatrix2fv* c =
       GetCmdSpace<gles2::cmds::UniformMatrix2fv>();
   if (c) {
-    c->Init(location, count, transpose, value_shm_id, value_shm_offset);
+    c->Init(location, count, value_shm_id, value_shm_offset);
   }
 }
 
 void UniformMatrix2fvImmediate(GLint location,
                                GLsizei count,
-                               GLboolean transpose,
                                const GLfloat* value) {
   const uint32_t size =
       gles2::cmds::UniformMatrix2fvImmediate::ComputeSize(count);
@@ -1427,25 +1418,23 @@ void UniformMatrix2fvImmediate(GLint location,
       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix2fvImmediate>(
           size);
   if (c) {
-    c->Init(location, count, transpose, value);
+    c->Init(location, count, value);
   }
 }
 
 void UniformMatrix3fv(GLint location,
                       GLsizei count,
-                      GLboolean transpose,
                       uint32_t value_shm_id,
                       uint32_t value_shm_offset) {
   gles2::cmds::UniformMatrix3fv* c =
       GetCmdSpace<gles2::cmds::UniformMatrix3fv>();
   if (c) {
-    c->Init(location, count, transpose, value_shm_id, value_shm_offset);
+    c->Init(location, count, value_shm_id, value_shm_offset);
   }
 }
 
 void UniformMatrix3fvImmediate(GLint location,
                                GLsizei count,
-                               GLboolean transpose,
                                const GLfloat* value) {
   const uint32_t size =
       gles2::cmds::UniformMatrix3fvImmediate::ComputeSize(count);
@@ -1453,25 +1442,23 @@ void UniformMatrix3fvImmediate(GLint location,
       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix3fvImmediate>(
           size);
   if (c) {
-    c->Init(location, count, transpose, value);
+    c->Init(location, count, value);
   }
 }
 
 void UniformMatrix4fv(GLint location,
                       GLsizei count,
-                      GLboolean transpose,
                       uint32_t value_shm_id,
                       uint32_t value_shm_offset) {
   gles2::cmds::UniformMatrix4fv* c =
       GetCmdSpace<gles2::cmds::UniformMatrix4fv>();
   if (c) {
-    c->Init(location, count, transpose, value_shm_id, value_shm_offset);
+    c->Init(location, count, value_shm_id, value_shm_offset);
   }
 }
 
 void UniformMatrix4fvImmediate(GLint location,
                                GLsizei count,
-                               GLboolean transpose,
                                const GLfloat* value) {
   const uint32_t size =
       gles2::cmds::UniformMatrix4fvImmediate::ComputeSize(count);
@@ -1479,7 +1466,7 @@ void UniformMatrix4fvImmediate(GLint location,
       GetImmediateCmdSpaceTotalSize<gles2::cmds::UniformMatrix4fvImmediate>(
           size);
   if (c) {
-    c->Init(location, count, transpose, value);
+    c->Init(location, count, value);
   }
 }
 
@@ -1667,12 +1654,11 @@ void FramebufferTexture2DMultisampleEXT(GLenum target,
                                         GLenum attachment,
                                         GLenum textarget,
                                         GLuint texture,
-                                        GLint level,
                                         GLsizei samples) {
   gles2::cmds::FramebufferTexture2DMultisampleEXT* c =
       GetCmdSpace<gles2::cmds::FramebufferTexture2DMultisampleEXT>();
   if (c) {
-    c->Init(target, attachment, textarget, texture, level, samples);
+    c->Init(target, attachment, textarget, texture, samples);
   }
 }
 
@@ -2144,7 +2130,6 @@ void AsyncTexImage2DCHROMIUM(GLenum target,
                              GLint internalformat,
                              GLsizei width,
                              GLsizei height,
-                             GLint border,
                              GLenum format,
                              GLenum type,
                              uint32_t pixels_shm_id,
@@ -2160,7 +2145,6 @@ void AsyncTexImage2DCHROMIUM(GLenum target,
             internalformat,
             width,
             height,
-            border,
             format,
             type,
             pixels_shm_id,
diff --git a/gpu/command_buffer/client/gles2_implementation.cc b/gpu/command_buffer/client/gles2_implementation.cc
index 6d5edd2..866b88b 100644
--- a/gpu/command_buffer/client/gles2_implementation.cc
+++ b/gpu/command_buffer/client/gles2_implementation.cc
@@ -1616,6 +1616,10 @@ void GLES2Implementation::CompressedTexImage2D(
     SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D", "dimension < 0");
     return;
   }
+  if (border != 0) {
+    SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D", "border != 0");
+    return;
+  }
   if (height == 0 || width == 0) {
     return;
   }
@@ -1628,7 +1632,7 @@ void GLES2Implementation::CompressedTexImage2D(
         "glCompressedTexImage2D", offset, image_size);
     if (buffer && buffer->shm_id() != -1) {
       helper_->CompressedTexImage2D(
-          target, level, internalformat, width, height, border, image_size,
+          target, level, internalformat, width, height, image_size,
           buffer->shm_id(), buffer->shm_offset() + offset);
       buffer->set_last_usage_token(helper_->InsertToken());
     }
@@ -1636,7 +1640,7 @@ void GLES2Implementation::CompressedTexImage2D(
   }
   SetBucketContents(kResultBucketId, data, image_size);
   helper_->CompressedTexImage2DBucket(
-      target, level, internalformat, width, height, border, kResultBucketId);
+      target, level, internalformat, width, height, kResultBucketId);
   // Free the bucket. This is not required but it does free up the memory.
   // and we don't have to wait for the result so from the client's perspective
   // it's cheap.
@@ -1738,6 +1742,10 @@ void GLES2Implementation::TexImage2D(
     SetGLError(GL_INVALID_VALUE, "glTexImage2D", "dimension < 0");
     return;
   }
+  if (border != 0) {
+    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "border != 0");
+    return;
+  }
   uint32 size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
@@ -1756,7 +1764,7 @@ void GLES2Implementation::TexImage2D(
         "glTexImage2D", offset, size);
     if (buffer && buffer->shm_id() != -1) {
       helper_->TexImage2D(
-          target, level, internalformat, width, height, border, format, type,
+          target, level, internalformat, width, height, format, type,
           buffer->shm_id(), buffer->shm_offset() + offset);
       buffer->set_last_usage_token(helper_->InsertToken());
       CheckGLError();
@@ -1767,7 +1775,7 @@ void GLES2Implementation::TexImage2D(
   // If there's no data just issue TexImage2D
   if (!pixels) {
     helper_->TexImage2D(
-       target, level, internalformat, width, height, border, format, type,
+       target, level, internalformat, width, height, format, type,
        0, 0);
     CheckGLError();
     return;
@@ -1807,7 +1815,7 @@ void GLES2Implementation::TexImage2D(
         pixels, height, unpadded_row_size, src_padded_row_size, unpack_flip_y_,
         buffer.address(), padded_row_size);
     helper_->TexImage2D(
-        target, level, internalformat, width, height, border, format, type,
+        target, level, internalformat, width, height, format, type,
         buffer.shm_id(), buffer.offset());
     CheckGLError();
     return;
@@ -1815,7 +1823,7 @@ void GLES2Implementation::TexImage2D(
 
   // No, so send it using TexSubImage2D.
   helper_->TexImage2D(
-     target, level, internalformat, width, height, border, format, type,
+     target, level, internalformat, width, height, format, type,
      0, 0);
   TexSubImage2DImpl(
       target, level, 0, 0, width, height, format, type, unpadded_row_size,
@@ -3831,6 +3839,10 @@ void GLES2Implementation::AsyncTexImage2DCHROMIUM(
     SetGLError(GL_INVALID_VALUE, "glTexImage2D", "dimension < 0");
     return;
   }
+  if (border != 0) {
+    SetGLError(GL_INVALID_VALUE, "glTexImage2D", "border != 0");
+    return;
+  }
   uint32 size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
@@ -3844,7 +3856,7 @@ void GLES2Implementation::AsyncTexImage2DCHROMIUM(
   // If there's no data/buffer just issue the AsyncTexImage2D
   if (!pixels && !bound_pixel_unpack_transfer_buffer_id_) {
     helper_->AsyncTexImage2DCHROMIUM(
-       target, level, internalformat, width, height, border, format, type,
+       target, level, internalformat, width, height, format, type,
        0, 0, 0, 0, 0);
     return;
   }
@@ -3866,7 +3878,7 @@ void GLES2Implementation::AsyncTexImage2DCHROMIUM(
     uint32 async_token = NextAsyncUploadToken();
     buffer->set_last_async_upload_token(async_token);
     helper_->AsyncTexImage2DCHROMIUM(
-        target, level, internalformat, width, height, border, format, type,
+        target, level, internalformat, width, height, format, type,
         buffer->shm_id(), buffer->shm_offset() + offset,
         async_token,
         async_upload_sync_shm_id_, async_upload_sync_shm_offset_);
diff --git a/gpu/command_buffer/client/gles2_implementation_impl_autogen.h b/gpu/command_buffer/client/gles2_implementation_impl_autogen.h
index 88cf0f4..6ec777c 100644
--- a/gpu/command_buffer/client/gles2_implementation_impl_autogen.h
+++ b/gpu/command_buffer/client/gles2_implementation_impl_autogen.h
@@ -232,8 +232,11 @@ void GLES2Implementation::CopyTexImage2D(GLenum target,
     SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "height < 0");
     return;
   }
-  helper_->CopyTexImage2D(
-      target, level, internalformat, x, y, width, height, border);
+  if (border != 0) {
+    SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "border GL_INVALID_VALUE");
+    return;
+  }
+  helper_->CopyTexImage2D(target, level, internalformat, x, y, width, height);
   CheckGLError();
 }
 
@@ -462,7 +465,12 @@ void GLES2Implementation::FramebufferTexture2D(GLenum target,
                      << GLES2Util::GetStringAttachment(attachment) << ", "
                      << GLES2Util::GetStringTextureTarget(textarget) << ", "
                      << texture << ", " << level << ")");
-  helper_->FramebufferTexture2D(target, attachment, textarget, texture, level);
+  if (level != 0) {
+    SetGLError(
+        GL_INVALID_VALUE, "glFramebufferTexture2D", "level GL_INVALID_VALUE");
+    return;
+  }
+  helper_->FramebufferTexture2D(target, attachment, textarget, texture);
   CheckGLError();
 }
 
@@ -1488,7 +1496,12 @@ void GLES2Implementation::UniformMatrix2fv(GLint location,
     SetGLError(GL_INVALID_VALUE, "glUniformMatrix2fv", "count < 0");
     return;
   }
-  helper_->UniformMatrix2fvImmediate(location, count, transpose, value);
+  if (transpose != false) {
+    SetGLError(
+        GL_INVALID_VALUE, "glUniformMatrix2fv", "transpose GL_INVALID_VALUE");
+    return;
+  }
+  helper_->UniformMatrix2fvImmediate(location, count, value);
   CheckGLError();
 }
 
@@ -1515,7 +1528,12 @@ void GLES2Implementation::UniformMatrix3fv(GLint location,
     SetGLError(GL_INVALID_VALUE, "glUniformMatrix3fv", "count < 0");
     return;
   }
-  helper_->UniformMatrix3fvImmediate(location, count, transpose, value);
+  if (transpose != false) {
+    SetGLError(
+        GL_INVALID_VALUE, "glUniformMatrix3fv", "transpose GL_INVALID_VALUE");
+    return;
+  }
+  helper_->UniformMatrix3fvImmediate(location, count, value);
   CheckGLError();
 }
 
@@ -1545,7 +1563,12 @@ void GLES2Implementation::UniformMatrix4fv(GLint location,
     SetGLError(GL_INVALID_VALUE, "glUniformMatrix4fv", "count < 0");
     return;
   }
-  helper_->UniformMatrix4fvImmediate(location, count, transpose, value);
+  if (transpose != false) {
+    SetGLError(
+        GL_INVALID_VALUE, "glUniformMatrix4fv", "transpose GL_INVALID_VALUE");
+    return;
+  }
+  helper_->UniformMatrix4fvImmediate(location, count, value);
   CheckGLError();
 }
 
@@ -1767,6 +1790,12 @@ void GLES2Implementation::FramebufferTexture2DMultisampleEXT(GLenum target,
                      << GLES2Util::GetStringAttachment(attachment) << ", "
                      << GLES2Util::GetStringTextureTarget(textarget) << ", "
                      << texture << ", " << level << ", " << samples << ")");
+  if (level != 0) {
+    SetGLError(GL_INVALID_VALUE,
+               "glFramebufferTexture2DMultisampleEXT",
+               "level GL_INVALID_VALUE");
+    return;
+  }
   if (samples < 0) {
     SetGLError(GL_INVALID_VALUE,
                "glFramebufferTexture2DMultisampleEXT",
@@ -1774,7 +1803,7 @@ void GLES2Implementation::FramebufferTexture2DMultisampleEXT(GLenum target,
     return;
   }
   helper_->FramebufferTexture2DMultisampleEXT(
-      target, attachment, textarget, texture, level, samples);
+      target, attachment, textarget, texture, samples);
   CheckGLError();
 }
 
diff --git a/gpu/command_buffer/client/gles2_implementation_unittest.cc b/gpu/command_buffer/client/gles2_implementation_unittest.cc
index b76caa2..f7fbca4 100644
--- a/gpu/command_buffer/client/gles2_implementation_unittest.cc
+++ b/gpu/command_buffer/client/gles2_implementation_unittest.cc
@@ -2309,7 +2309,7 @@ TEST_F(GLES2ImplementationTest, TexImage2D) {
 
   Cmds expected;
   expected.tex_image_2d.Init(
-      kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
+      kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset);
   expected.set_token.Init(GetNextToken());
   gl_->TexImage2D(
@@ -2326,7 +2326,7 @@ TEST_F(GLES2ImplementationTest, TexImage2D) {
   ExpectedMemoryInfo mem2 = GetExpectedMemory(sizeof(pixels));
   Cmds2 expected2;
   expected2.tex_image_2d.Init(
-      kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
+      kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       mem2.id, mem2.offset);
   expected2.set_token.Init(GetNextToken());
   const void* commands2 = GetPut();
@@ -2381,7 +2381,7 @@ TEST_F(GLES2ImplementationTest, TexImage2D2Writes) {
 
   Cmds expected;
   expected.tex_image_2d.Init(
-      kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
+      kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       0, 0);
   expected.tex_sub_image_2d1.Init(
       kTarget, kLevel, 0, 0, kWidth, kHeight / 2, kFormat, kType,
@@ -2414,7 +2414,7 @@ TEST_F(GLES2ImplementationTest, TexImage2D2Writes) {
   ExpectedMemoryInfo mem3 = GetExpectedMemory(half_size);
   ExpectedMemoryInfo mem4 = GetExpectedMemory(half_size);
   expected.tex_image_2d.Init(
-      kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
+      kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
       0, 0);
   expected.tex_sub_image_2d1.Init(
       kTarget, kLevel, 0, kHeight / 2, kWidth, kHeight / 2, kFormat, kType,
@@ -2478,7 +2478,7 @@ TEST_F(GLES2ImplementationTest, TexSubImage2DFlipY) {
   Cmds expected;
   expected.pixel_store_i1.Init(GL_UNPACK_ALIGNMENT, kPixelStoreUnpackAlignment);
   expected.tex_image_2d.Init(
-      kTarget, kLevel, kFormat, kTextureWidth, kTextureHeight, kBorder, kFormat,
+      kTarget, kLevel, kFormat, kTextureWidth, kTextureHeight, kFormat,
       kType, 0, 0);
   expected.pixel_store_i2.Init(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
   expected.tex_sub_image_2d1.Init(kTarget, kLevel, kSubImageXOffset,
@@ -2590,7 +2590,7 @@ TEST_F(GLES2ImplementationTest, SubImageUnpack) {
           texSubImageExpected.pixel_store_i2.Init(
               GL_UNPACK_FLIP_Y_CHROMIUM, flip_y);
           texSubImageExpected.tex_image_2d.Init(
-              GL_TEXTURE_2D, kLevel, kFormat, kTexWidth, kTexHeight, kBorder,
+              GL_TEXTURE_2D, kLevel, kFormat, kTexWidth, kTexHeight,
               kFormat, kType, 0, 0);
           texSubImageExpected.tex_sub_image_2d.Init(
               GL_TEXTURE_2D, kLevel, kTexSubXOffset, kTexSubYOffset,
@@ -2608,7 +2608,7 @@ TEST_F(GLES2ImplementationTest, SubImageUnpack) {
               GL_UNPACK_FLIP_Y_CHROMIUM, flip_y);
           texImageExpected.tex_image_2d.Init(
               GL_TEXTURE_2D, kLevel, kFormat, kSrcSubImageWidth,
-              kSrcSubImageHeight, kBorder, kFormat, kType, mem.id, mem.offset);
+              kSrcSubImageHeight, kFormat, kType, mem.id, mem.offset);
           EXPECT_EQ(0, memcmp(
               &texImageExpected, commands, sizeof(texImageExpected)));
         }
@@ -2631,6 +2631,93 @@ TEST_F(GLES2ImplementationTest, SubImageUnpack) {
   }
 }
 
+// Test texture related calls with invalid arguments.
+TEST_F(GLES2ImplementationTest, TextureInvalidArguments) {
+  struct Cmds {
+    cmds::TexImage2D tex_image_2d;
+    cmd::SetToken set_token;
+  };
+  const GLenum kTarget = GL_TEXTURE_2D;
+  const GLint kLevel = 0;
+  const GLenum kFormat = GL_RGB;
+  const GLsizei kWidth = 3;
+  const GLsizei kHeight = 4;
+  const GLint kBorder = 0;
+  const GLint kInvalidBorder = 1;
+  const GLenum kType = GL_UNSIGNED_BYTE;
+  const GLint kPixelStoreUnpackAlignment = 4;
+  static uint8 pixels[] = {
+    11, 12, 13, 13, 14, 15, 15, 16, 17, 101, 102, 103,
+    21, 22, 23, 23, 24, 25, 25, 26, 27, 201, 202, 203,
+    31, 32, 33, 33, 34, 35, 35, 36, 37, 123, 124, 125,
+    41, 42, 43, 43, 44, 45, 45, 46, 47,
+  };
+
+  // Verify that something works.
+
+  ExpectedMemoryInfo mem1 = GetExpectedMemory(sizeof(pixels));
+
+  Cmds expected;
+  expected.tex_image_2d.Init(
+      kTarget, kLevel, kFormat, kWidth, kHeight, kFormat, kType,
+      mem1.id, mem1.offset);
+  expected.set_token.Init(GetNextToken());
+  gl_->TexImage2D(
+      kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
+      pixels);
+  EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+  EXPECT_TRUE(CheckRect(
+      kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment, false,
+      pixels, mem1.ptr));
+
+  ClearCommands();
+
+  // Use invalid border.
+  gl_->TexImage2D(
+      kTarget, kLevel, kFormat, kWidth, kHeight, kInvalidBorder, kFormat, kType,
+      pixels);
+
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_VALUE, CheckError());
+
+  ClearCommands();
+
+  gl_->AsyncTexImage2DCHROMIUM(
+      kTarget, kLevel, kFormat, kWidth, kHeight, kInvalidBorder, kFormat, kType,
+      NULL);
+
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_VALUE, CheckError());
+
+  ClearCommands();
+
+  // Checking for CompressedTexImage2D argument validation is a bit tricky due
+  // to (runtime-detected) compression formats. Try to infer the error with an
+  // aux check.
+  const GLenum kCompressedFormat = GL_ETC1_RGB8_OES;
+  gl_->CompressedTexImage2D(
+      kTarget, kLevel, kCompressedFormat, kWidth, kHeight, kBorder,
+      arraysize(pixels), pixels);
+
+  // In the above, kCompressedFormat and arraysize(pixels) are possibly wrong
+  // values. First ensure that these do not cause failures at the client. If
+  // this check ever fails, it probably means that client checks more than at
+  // the time of writing of this test. In this case, more code needs to be
+  // written for this test.
+  EXPECT_FALSE(NoCommandsWritten());
+
+  ClearCommands();
+
+  // Changing border to invalid border should make the call fail at the client
+  // checks.
+  gl_->CompressedTexImage2D(
+      kTarget, kLevel, kCompressedFormat, kWidth, kHeight, kInvalidBorder,
+      arraysize(pixels), pixels);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_VALUE, CheckError());
+}
+
+
 // Binds can not be cached with bind_generates_resource = false because
 // our id might not be valid. More specifically if you bind on contextA then
 // delete on contextB the resource is still bound on contextA but GetInterger
diff --git a/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h b/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h
index e6bd8a1..7b6d70b 100644
--- a/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h
+++ b/gpu/command_buffer/client/gles2_implementation_unittest_autogen.h
@@ -168,9 +168,9 @@ TEST_F(GLES2ImplementationTest, ClearDepthf) {
     cmds::ClearDepthf cmd;
   };
   Cmds expected;
-  expected.cmd.Init(1);
+  expected.cmd.Init(0.5f);
 
-  gl_->ClearDepthf(1);
+  gl_->ClearDepthf(0.5f);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
@@ -214,12 +214,18 @@ TEST_F(GLES2ImplementationTest, CopyTexImage2D) {
     cmds::CopyTexImage2D cmd;
   };
   Cmds expected;
-  expected.cmd.Init(GL_TEXTURE_2D, 2, GL_ALPHA, 4, 5, 6, 7, 0);
+  expected.cmd.Init(GL_TEXTURE_2D, 2, GL_ALPHA, 4, 5, 6, 7);
 
   gl_->CopyTexImage2D(GL_TEXTURE_2D, 2, GL_ALPHA, 4, 5, 6, 7, 0);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
+TEST_F(GLES2ImplementationTest, CopyTexImage2DInvalidConstantArg7) {
+  gl_->CopyTexImage2D(GL_TEXTURE_2D, 2, GL_ALPHA, 4, 5, 6, 7, 1);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_VALUE, CheckError());
+}
+
 TEST_F(GLES2ImplementationTest, CopyTexSubImage2D) {
   struct Cmds {
     cmds::CopyTexSubImage2D cmd;
@@ -425,13 +431,20 @@ TEST_F(GLES2ImplementationTest, FramebufferTexture2D) {
     cmds::FramebufferTexture2D cmd;
   };
   Cmds expected;
-  expected.cmd.Init(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 4, 0);
+  expected.cmd.Init(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 4);
 
   gl_->FramebufferTexture2D(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 4, 0);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
+TEST_F(GLES2ImplementationTest, FramebufferTexture2DInvalidConstantArg4) {
+  gl_->FramebufferTexture2D(
+      GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 4, 1);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_VALUE, CheckError());
+}
+
 TEST_F(GLES2ImplementationTest, FrontFace) {
   struct Cmds {
     cmds::FrontFace cmd;
@@ -899,9 +912,9 @@ TEST_F(GLES2ImplementationTest, LineWidth) {
     cmds::LineWidth cmd;
   };
   Cmds expected;
-  expected.cmd.Init(1);
+  expected.cmd.Init(0.5f);
 
-  gl_->LineWidth(1);
+  gl_->LineWidth(0.5f);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
@@ -1053,9 +1066,9 @@ TEST_F(GLES2ImplementationTest, TexParameterf) {
     cmds::TexParameterf cmd;
   };
   Cmds expected;
-  expected.cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 3);
+  expected.cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
-  gl_->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 3);
+  gl_->TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
@@ -1080,9 +1093,9 @@ TEST_F(GLES2ImplementationTest, TexParameteri) {
     cmds::TexParameteri cmd;
   };
   Cmds expected;
-  expected.cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 3);
+  expected.cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
-  gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 3);
+  gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
@@ -1347,11 +1360,23 @@ TEST_F(GLES2ImplementationTest, UniformMatrix2fv) {
       data[ii][jj] = static_cast<GLfloat>(ii * 4 + jj);
     }
   }
-  expected.cmd.Init(1, 2, false, &data[0][0]);
+  expected.cmd.Init(1, 2, &data[0][0]);
   gl_->UniformMatrix2fv(1, 2, false, &data[0][0]);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
+TEST_F(GLES2ImplementationTest, UniformMatrix2fvInvalidConstantArg2) {
+  GLfloat data[2][4] = {{0}};
+  for (int ii = 0; ii < 2; ++ii) {
+    for (int jj = 0; jj < 4; ++jj) {
+      data[ii][jj] = static_cast<GLfloat>(ii * 4 + jj);
+    }
+  }
+  gl_->UniformMatrix2fv(1, 2, true, &data[0][0]);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_VALUE, CheckError());
+}
+
 TEST_F(GLES2ImplementationTest, UniformMatrix3fv) {
   GLfloat data[2][9] = {{0}};
   struct Cmds {
@@ -1365,11 +1390,23 @@ TEST_F(GLES2ImplementationTest, UniformMatrix3fv) {
       data[ii][jj] = static_cast<GLfloat>(ii * 9 + jj);
     }
   }
-  expected.cmd.Init(1, 2, false, &data[0][0]);
+  expected.cmd.Init(1, 2, &data[0][0]);
   gl_->UniformMatrix3fv(1, 2, false, &data[0][0]);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
+TEST_F(GLES2ImplementationTest, UniformMatrix3fvInvalidConstantArg2) {
+  GLfloat data[2][9] = {{0}};
+  for (int ii = 0; ii < 2; ++ii) {
+    for (int jj = 0; jj < 9; ++jj) {
+      data[ii][jj] = static_cast<GLfloat>(ii * 9 + jj);
+    }
+  }
+  gl_->UniformMatrix3fv(1, 2, true, &data[0][0]);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_VALUE, CheckError());
+}
+
 TEST_F(GLES2ImplementationTest, UniformMatrix4fv) {
   GLfloat data[2][16] = {{0}};
   struct Cmds {
@@ -1383,11 +1420,23 @@ TEST_F(GLES2ImplementationTest, UniformMatrix4fv) {
       data[ii][jj] = static_cast<GLfloat>(ii * 16 + jj);
     }
   }
-  expected.cmd.Init(1, 2, false, &data[0][0]);
+  expected.cmd.Init(1, 2, &data[0][0]);
   gl_->UniformMatrix4fv(1, 2, false, &data[0][0]);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
+TEST_F(GLES2ImplementationTest, UniformMatrix4fvInvalidConstantArg2) {
+  GLfloat data[2][16] = {{0}};
+  for (int ii = 0; ii < 2; ++ii) {
+    for (int jj = 0; jj < 16; ++jj) {
+      data[ii][jj] = static_cast<GLfloat>(ii * 16 + jj);
+    }
+  }
+  gl_->UniformMatrix4fv(1, 2, true, &data[0][0]);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_VALUE, CheckError());
+}
+
 TEST_F(GLES2ImplementationTest, UseProgram) {
   struct Cmds {
     cmds::UseProgram cmd;
@@ -1571,14 +1620,21 @@ TEST_F(GLES2ImplementationTest, FramebufferTexture2DMultisampleEXT) {
     cmds::FramebufferTexture2DMultisampleEXT cmd;
   };
   Cmds expected;
-  expected.cmd.Init(
-      GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 4, 0, 6);
+  expected.cmd.Init(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 4, 6);
 
   gl_->FramebufferTexture2DMultisampleEXT(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 4, 0, 6);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
+TEST_F(GLES2ImplementationTest,
+       FramebufferTexture2DMultisampleEXTInvalidConstantArg4) {
+  gl_->FramebufferTexture2DMultisampleEXT(
+      GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 4, 1, 6);
+  EXPECT_TRUE(NoCommandsWritten());
+  EXPECT_EQ(GL_INVALID_VALUE, CheckError());
+}
+
 TEST_F(GLES2ImplementationTest, TexStorage2DEXT) {
   struct Cmds {
     cmds::TexStorage2DEXT cmd;
diff --git a/gpu/command_buffer/common/gles2_cmd_format_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
index 9461628..be63e8f 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
@@ -932,7 +932,6 @@ struct CompressedTexImage2D {
             GLenum _internalformat,
             GLsizei _width,
             GLsizei _height,
-            GLint _border,
             GLsizei _imageSize,
             uint32_t _data_shm_id,
             uint32_t _data_shm_offset) {
@@ -942,7 +941,6 @@ struct CompressedTexImage2D {
     internalformat = _internalformat;
     width = _width;
     height = _height;
-    border = _border;
     imageSize = _imageSize;
     data_shm_id = _data_shm_id;
     data_shm_offset = _data_shm_offset;
@@ -954,7 +952,6 @@ struct CompressedTexImage2D {
             GLenum _internalformat,
             GLsizei _width,
             GLsizei _height,
-            GLint _border,
             GLsizei _imageSize,
             uint32_t _data_shm_id,
             uint32_t _data_shm_offset) {
@@ -963,7 +960,6 @@ struct CompressedTexImage2D {
                                        _internalformat,
                                        _width,
                                        _height,
-                                       _border,
                                        _imageSize,
                                        _data_shm_id,
                                        _data_shm_offset);
@@ -976,14 +972,14 @@ struct CompressedTexImage2D {
   uint32_t internalformat;
   int32_t width;
   int32_t height;
-  int32_t border;
   int32_t imageSize;
   uint32_t data_shm_id;
   uint32_t data_shm_offset;
+  static const int32_t border = 0;
 };
 
-COMPILE_ASSERT(sizeof(CompressedTexImage2D) == 40,
-               Sizeof_CompressedTexImage2D_is_not_40);
+COMPILE_ASSERT(sizeof(CompressedTexImage2D) == 36,
+               Sizeof_CompressedTexImage2D_is_not_36);
 COMPILE_ASSERT(offsetof(CompressedTexImage2D, header) == 0,
                OffsetOf_CompressedTexImage2D_header_not_0);
 COMPILE_ASSERT(offsetof(CompressedTexImage2D, target) == 4,
@@ -996,14 +992,12 @@ COMPILE_ASSERT(offsetof(CompressedTexImage2D, width) == 16,
                OffsetOf_CompressedTexImage2D_width_not_16);
 COMPILE_ASSERT(offsetof(CompressedTexImage2D, height) == 20,
                OffsetOf_CompressedTexImage2D_height_not_20);
-COMPILE_ASSERT(offsetof(CompressedTexImage2D, border) == 24,
-               OffsetOf_CompressedTexImage2D_border_not_24);
-COMPILE_ASSERT(offsetof(CompressedTexImage2D, imageSize) == 28,
-               OffsetOf_CompressedTexImage2D_imageSize_not_28);
-COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_id) == 32,
-               OffsetOf_CompressedTexImage2D_data_shm_id_not_32);
-COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_offset) == 36,
-               OffsetOf_CompressedTexImage2D_data_shm_offset_not_36);
+COMPILE_ASSERT(offsetof(CompressedTexImage2D, imageSize) == 24,
+               OffsetOf_CompressedTexImage2D_imageSize_not_24);
+COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_id) == 28,
+               OffsetOf_CompressedTexImage2D_data_shm_id_not_28);
+COMPILE_ASSERT(offsetof(CompressedTexImage2D, data_shm_offset) == 32,
+               OffsetOf_CompressedTexImage2D_data_shm_offset_not_32);
 
 struct CompressedTexImage2DBucket {
   typedef CompressedTexImage2DBucket ValueType;
@@ -1022,7 +1016,6 @@ struct CompressedTexImage2DBucket {
             GLenum _internalformat,
             GLsizei _width,
             GLsizei _height,
-            GLint _border,
             GLuint _bucket_id) {
     SetHeader();
     target = _target;
@@ -1030,7 +1023,6 @@ struct CompressedTexImage2DBucket {
     internalformat = _internalformat;
     width = _width;
     height = _height;
-    border = _border;
     bucket_id = _bucket_id;
   }
 
@@ -1040,10 +1032,9 @@ struct CompressedTexImage2DBucket {
             GLenum _internalformat,
             GLsizei _width,
             GLsizei _height,
-            GLint _border,
             GLuint _bucket_id) {
-    static_cast<ValueType*>(cmd)->Init(
-        _target, _level, _internalformat, _width, _height, _border, _bucket_id);
+    static_cast<ValueType*>(cmd)
+        ->Init(_target, _level, _internalformat, _width, _height, _bucket_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
@@ -1053,12 +1044,12 @@ struct CompressedTexImage2DBucket {
   uint32_t internalformat;
   int32_t width;
   int32_t height;
-  int32_t border;
   uint32_t bucket_id;
+  static const int32_t border = 0;
 };
 
-COMPILE_ASSERT(sizeof(CompressedTexImage2DBucket) == 32,
-               Sizeof_CompressedTexImage2DBucket_is_not_32);
+COMPILE_ASSERT(sizeof(CompressedTexImage2DBucket) == 28,
+               Sizeof_CompressedTexImage2DBucket_is_not_28);
 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, header) == 0,
                OffsetOf_CompressedTexImage2DBucket_header_not_0);
 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, target) == 4,
@@ -1071,10 +1062,8 @@ COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, width) == 16,
                OffsetOf_CompressedTexImage2DBucket_width_not_16);
 COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, height) == 20,
                OffsetOf_CompressedTexImage2DBucket_height_not_20);
-COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, border) == 24,
-               OffsetOf_CompressedTexImage2DBucket_border_not_24);
-COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, bucket_id) == 28,
-               OffsetOf_CompressedTexImage2DBucket_bucket_id_not_28);
+COMPILE_ASSERT(offsetof(CompressedTexImage2DBucket, bucket_id) == 24,
+               OffsetOf_CompressedTexImage2DBucket_bucket_id_not_24);
 
 struct CompressedTexSubImage2D {
   typedef CompressedTexSubImage2D ValueType;
@@ -1274,8 +1263,7 @@ struct CopyTexImage2D {
             GLint _x,
             GLint _y,
             GLsizei _width,
-            GLsizei _height,
-            GLint _border) {
+            GLsizei _height) {
     SetHeader();
     target = _target;
     level = _level;
@@ -1284,7 +1272,6 @@ struct CopyTexImage2D {
     y = _y;
     width = _width;
     height = _height;
-    border = _border;
   }
 
   void* Set(void* cmd,
@@ -1294,10 +1281,9 @@ struct CopyTexImage2D {
             GLint _x,
             GLint _y,
             GLsizei _width,
-            GLsizei _height,
-            GLint _border) {
-    static_cast<ValueType*>(cmd)->Init(
-        _target, _level, _internalformat, _x, _y, _width, _height, _border);
+            GLsizei _height) {
+    static_cast<ValueType*>(cmd)
+        ->Init(_target, _level, _internalformat, _x, _y, _width, _height);
     return NextCmdAddress<ValueType>(cmd);
   }
 
@@ -1309,10 +1295,10 @@ struct CopyTexImage2D {
   int32_t y;
   int32_t width;
   int32_t height;
-  int32_t border;
+  static const int32_t border = 0;
 };
 
-COMPILE_ASSERT(sizeof(CopyTexImage2D) == 36, Sizeof_CopyTexImage2D_is_not_36);
+COMPILE_ASSERT(sizeof(CopyTexImage2D) == 32, Sizeof_CopyTexImage2D_is_not_32);
 COMPILE_ASSERT(offsetof(CopyTexImage2D, header) == 0,
                OffsetOf_CopyTexImage2D_header_not_0);
 COMPILE_ASSERT(offsetof(CopyTexImage2D, target) == 4,
@@ -1329,8 +1315,6 @@ COMPILE_ASSERT(offsetof(CopyTexImage2D, width) == 24,
                OffsetOf_CopyTexImage2D_width_not_24);
 COMPILE_ASSERT(offsetof(CopyTexImage2D, height) == 28,
                OffsetOf_CopyTexImage2D_height_not_28);
-COMPILE_ASSERT(offsetof(CopyTexImage2D, border) == 32,
-               OffsetOf_CopyTexImage2D_border_not_32);
 
 struct CopyTexSubImage2D {
   typedef CopyTexSubImage2D ValueType;
@@ -2389,24 +2373,21 @@ struct FramebufferTexture2D {
   void Init(GLenum _target,
             GLenum _attachment,
             GLenum _textarget,
-            GLuint _texture,
-            GLint _level) {
+            GLuint _texture) {
     SetHeader();
     target = _target;
     attachment = _attachment;
     textarget = _textarget;
     texture = _texture;
-    level = _level;
   }
 
   void* Set(void* cmd,
             GLenum _target,
             GLenum _attachment,
             GLenum _textarget,
-            GLuint _texture,
-            GLint _level) {
+            GLuint _texture) {
     static_cast<ValueType*>(cmd)
-        ->Init(_target, _attachment, _textarget, _texture, _level);
+        ->Init(_target, _attachment, _textarget, _texture);
     return NextCmdAddress<ValueType>(cmd);
   }
 
@@ -2415,11 +2396,11 @@ struct FramebufferTexture2D {
   uint32_t attachment;
   uint32_t textarget;
   uint32_t texture;
-  int32_t level;
+  static const int32_t level = 0;
 };
 
-COMPILE_ASSERT(sizeof(FramebufferTexture2D) == 24,
-               Sizeof_FramebufferTexture2D_is_not_24);
+COMPILE_ASSERT(sizeof(FramebufferTexture2D) == 20,
+               Sizeof_FramebufferTexture2D_is_not_20);
 COMPILE_ASSERT(offsetof(FramebufferTexture2D, header) == 0,
                OffsetOf_FramebufferTexture2D_header_not_0);
 COMPILE_ASSERT(offsetof(FramebufferTexture2D, target) == 4,
@@ -2430,8 +2411,6 @@ COMPILE_ASSERT(offsetof(FramebufferTexture2D, textarget) == 12,
                OffsetOf_FramebufferTexture2D_textarget_not_12);
 COMPILE_ASSERT(offsetof(FramebufferTexture2D, texture) == 16,
                OffsetOf_FramebufferTexture2D_texture_not_16);
-COMPILE_ASSERT(offsetof(FramebufferTexture2D, level) == 20,
-               OffsetOf_FramebufferTexture2D_level_not_20);
 
 struct FrontFace {
   typedef FrontFace ValueType;
@@ -5278,7 +5257,6 @@ struct TexImage2D {
             GLint _internalformat,
             GLsizei _width,
             GLsizei _height,
-            GLint _border,
             GLenum _format,
             GLenum _type,
             uint32_t _pixels_shm_id,
@@ -5289,7 +5267,6 @@ struct TexImage2D {
     internalformat = _internalformat;
     width = _width;
     height = _height;
-    border = _border;
     format = _format;
     type = _type;
     pixels_shm_id = _pixels_shm_id;
@@ -5302,7 +5279,6 @@ struct TexImage2D {
             GLint _internalformat,
             GLsizei _width,
             GLsizei _height,
-            GLint _border,
             GLenum _format,
             GLenum _type,
             uint32_t _pixels_shm_id,
@@ -5312,7 +5288,6 @@ struct TexImage2D {
                                        _internalformat,
                                        _width,
                                        _height,
-                                       _border,
                                        _format,
                                        _type,
                                        _pixels_shm_id,
@@ -5326,14 +5301,14 @@ struct TexImage2D {
   int32_t internalformat;
   int32_t width;
   int32_t height;
-  int32_t border;
   uint32_t format;
   uint32_t type;
   uint32_t pixels_shm_id;
   uint32_t pixels_shm_offset;
+  static const int32_t border = 0;
 };
 
-COMPILE_ASSERT(sizeof(TexImage2D) == 44, Sizeof_TexImage2D_is_not_44);
+COMPILE_ASSERT(sizeof(TexImage2D) == 40, Sizeof_TexImage2D_is_not_40);
 COMPILE_ASSERT(offsetof(TexImage2D, header) == 0,
                OffsetOf_TexImage2D_header_not_0);
 COMPILE_ASSERT(offsetof(TexImage2D, target) == 4,
@@ -5346,16 +5321,14 @@ COMPILE_ASSERT(offsetof(TexImage2D, width) == 16,
                OffsetOf_TexImage2D_width_not_16);
 COMPILE_ASSERT(offsetof(TexImage2D, height) == 20,
                OffsetOf_TexImage2D_height_not_20);
-COMPILE_ASSERT(offsetof(TexImage2D, border) == 24,
-               OffsetOf_TexImage2D_border_not_24);
-COMPILE_ASSERT(offsetof(TexImage2D, format) == 28,
-               OffsetOf_TexImage2D_format_not_28);
-COMPILE_ASSERT(offsetof(TexImage2D, type) == 32,
-               OffsetOf_TexImage2D_type_not_32);
-COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_id) == 36,
-               OffsetOf_TexImage2D_pixels_shm_id_not_36);
-COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_offset) == 40,
-               OffsetOf_TexImage2D_pixels_shm_offset_not_40);
+COMPILE_ASSERT(offsetof(TexImage2D, format) == 24,
+               OffsetOf_TexImage2D_format_not_24);
+COMPILE_ASSERT(offsetof(TexImage2D, type) == 28,
+               OffsetOf_TexImage2D_type_not_28);
+COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_id) == 32,
+               OffsetOf_TexImage2D_pixels_shm_id_not_32);
+COMPILE_ASSERT(offsetof(TexImage2D, pixels_shm_offset) == 36,
+               OffsetOf_TexImage2D_pixels_shm_offset_not_36);
 
 struct TexParameterf {
   typedef TexParameterf ValueType;
@@ -6856,13 +6829,11 @@ struct UniformMatrix2fv {
 
   void Init(GLint _location,
             GLsizei _count,
-            GLboolean _transpose,
             uint32_t _value_shm_id,
             uint32_t _value_shm_offset) {
     SetHeader();
     location = _location;
     count = _count;
-    transpose = _transpose;
     value_shm_id = _value_shm_id;
     value_shm_offset = _value_shm_offset;
   }
@@ -6870,36 +6841,33 @@ struct UniformMatrix2fv {
   void* Set(void* cmd,
             GLint _location,
             GLsizei _count,
-            GLboolean _transpose,
             uint32_t _value_shm_id,
             uint32_t _value_shm_offset) {
     static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _transpose, _value_shm_id, _value_shm_offset);
+        ->Init(_location, _count, _value_shm_id, _value_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   int32_t location;
   int32_t count;
-  uint32_t transpose;
   uint32_t value_shm_id;
   uint32_t value_shm_offset;
+  static const uint32_t transpose = false;
 };
 
-COMPILE_ASSERT(sizeof(UniformMatrix2fv) == 24,
-               Sizeof_UniformMatrix2fv_is_not_24);
+COMPILE_ASSERT(sizeof(UniformMatrix2fv) == 20,
+               Sizeof_UniformMatrix2fv_is_not_20);
 COMPILE_ASSERT(offsetof(UniformMatrix2fv, header) == 0,
                OffsetOf_UniformMatrix2fv_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix2fv, location) == 4,
                OffsetOf_UniformMatrix2fv_location_not_4);
 COMPILE_ASSERT(offsetof(UniformMatrix2fv, count) == 8,
                OffsetOf_UniformMatrix2fv_count_not_8);
-COMPILE_ASSERT(offsetof(UniformMatrix2fv, transpose) == 12,
-               OffsetOf_UniformMatrix2fv_transpose_not_12);
-COMPILE_ASSERT(offsetof(UniformMatrix2fv, value_shm_id) == 16,
-               OffsetOf_UniformMatrix2fv_value_shm_id_not_16);
-COMPILE_ASSERT(offsetof(UniformMatrix2fv, value_shm_offset) == 20,
-               OffsetOf_UniformMatrix2fv_value_shm_offset_not_20);
+COMPILE_ASSERT(offsetof(UniformMatrix2fv, value_shm_id) == 12,
+               OffsetOf_UniformMatrix2fv_value_shm_id_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix2fv, value_shm_offset) == 16,
+               OffsetOf_UniformMatrix2fv_value_shm_offset_not_16);
 
 struct UniformMatrix2fvImmediate {
   typedef UniformMatrix2fvImmediate ValueType;
@@ -6920,23 +6888,15 @@ struct UniformMatrix2fvImmediate {
     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
   }
 
-  void Init(GLint _location,
-            GLsizei _count,
-            GLboolean _transpose,
-            const GLfloat* _value) {
+  void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
     SetHeader(_count);
     location = _location;
     count = _count;
-    transpose = _transpose;
     memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
   }
 
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            GLboolean _transpose,
-            const GLfloat* _value) {
-    static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
     const uint32_t size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
@@ -6944,19 +6904,17 @@ struct UniformMatrix2fvImmediate {
   gpu::CommandHeader header;
   int32_t location;
   int32_t count;
-  uint32_t transpose;
+  static const uint32_t transpose = false;
 };
 
-COMPILE_ASSERT(sizeof(UniformMatrix2fvImmediate) == 16,
-               Sizeof_UniformMatrix2fvImmediate_is_not_16);
+COMPILE_ASSERT(sizeof(UniformMatrix2fvImmediate) == 12,
+               Sizeof_UniformMatrix2fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, header) == 0,
                OffsetOf_UniformMatrix2fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, location) == 4,
                OffsetOf_UniformMatrix2fvImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, count) == 8,
                OffsetOf_UniformMatrix2fvImmediate_count_not_8);
-COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, transpose) == 12,
-               OffsetOf_UniformMatrix2fvImmediate_transpose_not_12);
 
 struct UniformMatrix3fv {
   typedef UniformMatrix3fv ValueType;
@@ -6972,13 +6930,11 @@ struct UniformMatrix3fv {
 
   void Init(GLint _location,
             GLsizei _count,
-            GLboolean _transpose,
             uint32_t _value_shm_id,
             uint32_t _value_shm_offset) {
     SetHeader();
     location = _location;
     count = _count;
-    transpose = _transpose;
     value_shm_id = _value_shm_id;
     value_shm_offset = _value_shm_offset;
   }
@@ -6986,36 +6942,33 @@ struct UniformMatrix3fv {
   void* Set(void* cmd,
             GLint _location,
             GLsizei _count,
-            GLboolean _transpose,
             uint32_t _value_shm_id,
             uint32_t _value_shm_offset) {
     static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _transpose, _value_shm_id, _value_shm_offset);
+        ->Init(_location, _count, _value_shm_id, _value_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   int32_t location;
   int32_t count;
-  uint32_t transpose;
   uint32_t value_shm_id;
   uint32_t value_shm_offset;
+  static const uint32_t transpose = false;
 };
 
-COMPILE_ASSERT(sizeof(UniformMatrix3fv) == 24,
-               Sizeof_UniformMatrix3fv_is_not_24);
+COMPILE_ASSERT(sizeof(UniformMatrix3fv) == 20,
+               Sizeof_UniformMatrix3fv_is_not_20);
 COMPILE_ASSERT(offsetof(UniformMatrix3fv, header) == 0,
                OffsetOf_UniformMatrix3fv_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix3fv, location) == 4,
                OffsetOf_UniformMatrix3fv_location_not_4);
 COMPILE_ASSERT(offsetof(UniformMatrix3fv, count) == 8,
                OffsetOf_UniformMatrix3fv_count_not_8);
-COMPILE_ASSERT(offsetof(UniformMatrix3fv, transpose) == 12,
-               OffsetOf_UniformMatrix3fv_transpose_not_12);
-COMPILE_ASSERT(offsetof(UniformMatrix3fv, value_shm_id) == 16,
-               OffsetOf_UniformMatrix3fv_value_shm_id_not_16);
-COMPILE_ASSERT(offsetof(UniformMatrix3fv, value_shm_offset) == 20,
-               OffsetOf_UniformMatrix3fv_value_shm_offset_not_20);
+COMPILE_ASSERT(offsetof(UniformMatrix3fv, value_shm_id) == 12,
+               OffsetOf_UniformMatrix3fv_value_shm_id_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix3fv, value_shm_offset) == 16,
+               OffsetOf_UniformMatrix3fv_value_shm_offset_not_16);
 
 struct UniformMatrix3fvImmediate {
   typedef UniformMatrix3fvImmediate ValueType;
@@ -7036,23 +6989,15 @@ struct UniformMatrix3fvImmediate {
     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
   }
 
-  void Init(GLint _location,
-            GLsizei _count,
-            GLboolean _transpose,
-            const GLfloat* _value) {
+  void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
     SetHeader(_count);
     location = _location;
     count = _count;
-    transpose = _transpose;
     memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
   }
 
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            GLboolean _transpose,
-            const GLfloat* _value) {
-    static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
     const uint32_t size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
@@ -7060,19 +7005,17 @@ struct UniformMatrix3fvImmediate {
   gpu::CommandHeader header;
   int32_t location;
   int32_t count;
-  uint32_t transpose;
+  static const uint32_t transpose = false;
 };
 
-COMPILE_ASSERT(sizeof(UniformMatrix3fvImmediate) == 16,
-               Sizeof_UniformMatrix3fvImmediate_is_not_16);
+COMPILE_ASSERT(sizeof(UniformMatrix3fvImmediate) == 12,
+               Sizeof_UniformMatrix3fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, header) == 0,
                OffsetOf_UniformMatrix3fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, location) == 4,
                OffsetOf_UniformMatrix3fvImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, count) == 8,
                OffsetOf_UniformMatrix3fvImmediate_count_not_8);
-COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, transpose) == 12,
-               OffsetOf_UniformMatrix3fvImmediate_transpose_not_12);
 
 struct UniformMatrix4fv {
   typedef UniformMatrix4fv ValueType;
@@ -7088,13 +7031,11 @@ struct UniformMatrix4fv {
 
   void Init(GLint _location,
             GLsizei _count,
-            GLboolean _transpose,
             uint32_t _value_shm_id,
             uint32_t _value_shm_offset) {
     SetHeader();
     location = _location;
     count = _count;
-    transpose = _transpose;
     value_shm_id = _value_shm_id;
     value_shm_offset = _value_shm_offset;
   }
@@ -7102,36 +7043,33 @@ struct UniformMatrix4fv {
   void* Set(void* cmd,
             GLint _location,
             GLsizei _count,
-            GLboolean _transpose,
             uint32_t _value_shm_id,
             uint32_t _value_shm_offset) {
     static_cast<ValueType*>(cmd)
-        ->Init(_location, _count, _transpose, _value_shm_id, _value_shm_offset);
+        ->Init(_location, _count, _value_shm_id, _value_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
   int32_t location;
   int32_t count;
-  uint32_t transpose;
   uint32_t value_shm_id;
   uint32_t value_shm_offset;
+  static const uint32_t transpose = false;
 };
 
-COMPILE_ASSERT(sizeof(UniformMatrix4fv) == 24,
-               Sizeof_UniformMatrix4fv_is_not_24);
+COMPILE_ASSERT(sizeof(UniformMatrix4fv) == 20,
+               Sizeof_UniformMatrix4fv_is_not_20);
 COMPILE_ASSERT(offsetof(UniformMatrix4fv, header) == 0,
                OffsetOf_UniformMatrix4fv_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix4fv, location) == 4,
                OffsetOf_UniformMatrix4fv_location_not_4);
 COMPILE_ASSERT(offsetof(UniformMatrix4fv, count) == 8,
                OffsetOf_UniformMatrix4fv_count_not_8);
-COMPILE_ASSERT(offsetof(UniformMatrix4fv, transpose) == 12,
-               OffsetOf_UniformMatrix4fv_transpose_not_12);
-COMPILE_ASSERT(offsetof(UniformMatrix4fv, value_shm_id) == 16,
-               OffsetOf_UniformMatrix4fv_value_shm_id_not_16);
-COMPILE_ASSERT(offsetof(UniformMatrix4fv, value_shm_offset) == 20,
-               OffsetOf_UniformMatrix4fv_value_shm_offset_not_20);
+COMPILE_ASSERT(offsetof(UniformMatrix4fv, value_shm_id) == 12,
+               OffsetOf_UniformMatrix4fv_value_shm_id_not_12);
+COMPILE_ASSERT(offsetof(UniformMatrix4fv, value_shm_offset) == 16,
+               OffsetOf_UniformMatrix4fv_value_shm_offset_not_16);
 
 struct UniformMatrix4fvImmediate {
   typedef UniformMatrix4fvImmediate ValueType;
@@ -7152,23 +7090,15 @@ struct UniformMatrix4fvImmediate {
     header.SetCmdByTotalSize<ValueType>(ComputeSize(count));
   }
 
-  void Init(GLint _location,
-            GLsizei _count,
-            GLboolean _transpose,
-            const GLfloat* _value) {
+  void Init(GLint _location, GLsizei _count, const GLfloat* _value) {
     SetHeader(_count);
     location = _location;
     count = _count;
-    transpose = _transpose;
     memcpy(ImmediateDataAddress(this), _value, ComputeDataSize(_count));
   }
 
-  void* Set(void* cmd,
-            GLint _location,
-            GLsizei _count,
-            GLboolean _transpose,
-            const GLfloat* _value) {
-    static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
+  void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _value) {
+    static_cast<ValueType*>(cmd)->Init(_location, _count, _value);
     const uint32_t size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
@@ -7176,19 +7106,17 @@ struct UniformMatrix4fvImmediate {
   gpu::CommandHeader header;
   int32_t location;
   int32_t count;
-  uint32_t transpose;
+  static const uint32_t transpose = false;
 };
 
-COMPILE_ASSERT(sizeof(UniformMatrix4fvImmediate) == 16,
-               Sizeof_UniformMatrix4fvImmediate_is_not_16);
+COMPILE_ASSERT(sizeof(UniformMatrix4fvImmediate) == 12,
+               Sizeof_UniformMatrix4fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, header) == 0,
                OffsetOf_UniformMatrix4fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, location) == 4,
                OffsetOf_UniformMatrix4fvImmediate_location_not_4);
 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, count) == 8,
                OffsetOf_UniformMatrix4fvImmediate_count_not_8);
-COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, transpose) == 12,
-               OffsetOf_UniformMatrix4fvImmediate_transpose_not_12);
 
 struct UseProgram {
   typedef UseProgram ValueType;
@@ -8111,14 +8039,12 @@ struct FramebufferTexture2DMultisampleEXT {
             GLenum _attachment,
             GLenum _textarget,
             GLuint _texture,
-            GLint _level,
             GLsizei _samples) {
     SetHeader();
     target = _target;
     attachment = _attachment;
     textarget = _textarget;
     texture = _texture;
-    level = _level;
     samples = _samples;
   }
 
@@ -8127,10 +8053,9 @@ struct FramebufferTexture2DMultisampleEXT {
             GLenum _attachment,
             GLenum _textarget,
             GLuint _texture,
-            GLint _level,
             GLsizei _samples) {
     static_cast<ValueType*>(cmd)
-        ->Init(_target, _attachment, _textarget, _texture, _level, _samples);
+        ->Init(_target, _attachment, _textarget, _texture, _samples);
     return NextCmdAddress<ValueType>(cmd);
   }
 
@@ -8139,12 +8064,12 @@ struct FramebufferTexture2DMultisampleEXT {
   uint32_t attachment;
   uint32_t textarget;
   uint32_t texture;
-  int32_t level;
   int32_t samples;
+  static const int32_t level = 0;
 };
 
-COMPILE_ASSERT(sizeof(FramebufferTexture2DMultisampleEXT) == 28,
-               Sizeof_FramebufferTexture2DMultisampleEXT_is_not_28);
+COMPILE_ASSERT(sizeof(FramebufferTexture2DMultisampleEXT) == 24,
+               Sizeof_FramebufferTexture2DMultisampleEXT_is_not_24);
 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, header) == 0,
                OffsetOf_FramebufferTexture2DMultisampleEXT_header_not_0);
 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, target) == 4,
@@ -8155,10 +8080,8 @@ COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, textarget) == 12,
                OffsetOf_FramebufferTexture2DMultisampleEXT_textarget_not_12);
 COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, texture) == 16,
                OffsetOf_FramebufferTexture2DMultisampleEXT_texture_not_16);
-COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, level) == 20,
-               OffsetOf_FramebufferTexture2DMultisampleEXT_level_not_20);
-COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, samples) == 24,
-               OffsetOf_FramebufferTexture2DMultisampleEXT_samples_not_24);
+COMPILE_ASSERT(offsetof(FramebufferTexture2DMultisampleEXT, samples) == 20,
+               OffsetOf_FramebufferTexture2DMultisampleEXT_samples_not_20);
 
 struct TexStorage2DEXT {
   typedef TexStorage2DEXT ValueType;
@@ -10257,7 +10180,6 @@ struct AsyncTexImage2DCHROMIUM {
             GLint _internalformat,
             GLsizei _width,
             GLsizei _height,
-            GLint _border,
             GLenum _format,
             GLenum _type,
             uint32_t _pixels_shm_id,
@@ -10271,7 +10193,6 @@ struct AsyncTexImage2DCHROMIUM {
     internalformat = _internalformat;
     width = _width;
     height = _height;
-    border = _border;
     format = _format;
     type = _type;
     pixels_shm_id = _pixels_shm_id;
@@ -10287,7 +10208,6 @@ struct AsyncTexImage2DCHROMIUM {
             GLint _internalformat,
             GLsizei _width,
             GLsizei _height,
-            GLint _border,
             GLenum _format,
             GLenum _type,
             uint32_t _pixels_shm_id,
@@ -10300,7 +10220,6 @@ struct AsyncTexImage2DCHROMIUM {
                                        _internalformat,
                                        _width,
                                        _height,
-                                       _border,
                                        _format,
                                        _type,
                                        _pixels_shm_id,
@@ -10317,7 +10236,6 @@ struct AsyncTexImage2DCHROMIUM {
   int32_t internalformat;
   int32_t width;
   int32_t height;
-  int32_t border;
   uint32_t format;
   uint32_t type;
   uint32_t pixels_shm_id;
@@ -10325,10 +10243,11 @@ struct AsyncTexImage2DCHROMIUM {
   uint32_t async_upload_token;
   uint32_t sync_data_shm_id;
   uint32_t sync_data_shm_offset;
+  static const int32_t border = 0;
 };
 
-COMPILE_ASSERT(sizeof(AsyncTexImage2DCHROMIUM) == 56,
-               Sizeof_AsyncTexImage2DCHROMIUM_is_not_56);
+COMPILE_ASSERT(sizeof(AsyncTexImage2DCHROMIUM) == 52,
+               Sizeof_AsyncTexImage2DCHROMIUM_is_not_52);
 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, header) == 0,
                OffsetOf_AsyncTexImage2DCHROMIUM_header_not_0);
 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, target) == 4,
@@ -10341,22 +10260,20 @@ COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, width) == 16,
                OffsetOf_AsyncTexImage2DCHROMIUM_width_not_16);
 COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, height) == 20,
                OffsetOf_AsyncTexImage2DCHROMIUM_height_not_20);
-COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, border) == 24,
-               OffsetOf_AsyncTexImage2DCHROMIUM_border_not_24);
-COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, format) == 28,
-               OffsetOf_AsyncTexImage2DCHROMIUM_format_not_28);
-COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, type) == 32,
-               OffsetOf_AsyncTexImage2DCHROMIUM_type_not_32);
-COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_id) == 36,
-               OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_id_not_36);
-COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_offset) == 40,
-               OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_offset_not_40);
-COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, async_upload_token) == 44,
-               OffsetOf_AsyncTexImage2DCHROMIUM_async_upload_token_not_44);
-COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_id) == 48,
-               OffsetOf_AsyncTexImage2DCHROMIUM_sync_data_shm_id_not_48);
-COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_offset) == 52,
-               OffsetOf_AsyncTexImage2DCHROMIUM_sync_data_shm_offset_not_52);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, format) == 24,
+               OffsetOf_AsyncTexImage2DCHROMIUM_format_not_24);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, type) == 28,
+               OffsetOf_AsyncTexImage2DCHROMIUM_type_not_28);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_id) == 32,
+               OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_id_not_32);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, pixels_shm_offset) == 36,
+               OffsetOf_AsyncTexImage2DCHROMIUM_pixels_shm_offset_not_36);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, async_upload_token) == 40,
+               OffsetOf_AsyncTexImage2DCHROMIUM_async_upload_token_not_40);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_id) == 44,
+               OffsetOf_AsyncTexImage2DCHROMIUM_sync_data_shm_id_not_44);
+COMPILE_ASSERT(offsetof(AsyncTexImage2DCHROMIUM, sync_data_shm_offset) == 48,
+               OffsetOf_AsyncTexImage2DCHROMIUM_sync_data_shm_offset_not_48);
 
 struct WaitAsyncTexImage2DCHROMIUM {
   typedef WaitAsyncTexImage2DCHROMIUM ValueType;
diff --git a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
index 115137d..b76aa29 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
@@ -321,10 +321,9 @@ TEST_F(GLES2FormatTest, CompressedTexImage2D) {
                            static_cast<GLenum>(13),
                            static_cast<GLsizei>(14),
                            static_cast<GLsizei>(15),
-                           static_cast<GLint>(16),
-                           static_cast<GLsizei>(17),
-                           static_cast<uint32_t>(18),
-                           static_cast<uint32_t>(19));
+                           static_cast<GLsizei>(16),
+                           static_cast<uint32_t>(17),
+                           static_cast<uint32_t>(18));
   EXPECT_EQ(static_cast<uint32_t>(cmds::CompressedTexImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
@@ -333,10 +332,9 @@ TEST_F(GLES2FormatTest, CompressedTexImage2D) {
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
-  EXPECT_EQ(static_cast<GLint>(16), cmd.border);
-  EXPECT_EQ(static_cast<GLsizei>(17), cmd.imageSize);
-  EXPECT_EQ(static_cast<uint32_t>(18), cmd.data_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(19), cmd.data_shm_offset);
+  EXPECT_EQ(static_cast<GLsizei>(16), cmd.imageSize);
+  EXPECT_EQ(static_cast<uint32_t>(17), cmd.data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(18), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -349,8 +347,7 @@ TEST_F(GLES2FormatTest, CompressedTexImage2DBucket) {
                            static_cast<GLenum>(13),
                            static_cast<GLsizei>(14),
                            static_cast<GLsizei>(15),
-                           static_cast<GLint>(16),
-                           static_cast<GLuint>(17));
+                           static_cast<GLuint>(16));
   EXPECT_EQ(static_cast<uint32_t>(cmds::CompressedTexImage2DBucket::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
@@ -359,8 +356,7 @@ TEST_F(GLES2FormatTest, CompressedTexImage2DBucket) {
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
-  EXPECT_EQ(static_cast<GLint>(16), cmd.border);
-  EXPECT_EQ(static_cast<GLuint>(17), cmd.bucket_id);
+  EXPECT_EQ(static_cast<GLuint>(16), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -429,8 +425,7 @@ TEST_F(GLES2FormatTest, CopyTexImage2D) {
                            static_cast<GLint>(14),
                            static_cast<GLint>(15),
                            static_cast<GLsizei>(16),
-                           static_cast<GLsizei>(17),
-                           static_cast<GLint>(18));
+                           static_cast<GLsizei>(17));
   EXPECT_EQ(static_cast<uint32_t>(cmds::CopyTexImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
@@ -441,7 +436,6 @@ TEST_F(GLES2FormatTest, CopyTexImage2D) {
   EXPECT_EQ(static_cast<GLint>(15), cmd.y);
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(17), cmd.height);
-  EXPECT_EQ(static_cast<GLint>(18), cmd.border);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -807,8 +801,7 @@ TEST_F(GLES2FormatTest, FramebufferTexture2D) {
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
                            static_cast<GLenum>(13),
-                           static_cast<GLuint>(14),
-                           static_cast<GLint>(15));
+                           static_cast<GLuint>(14));
   EXPECT_EQ(static_cast<uint32_t>(cmds::FramebufferTexture2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
@@ -816,7 +809,6 @@ TEST_F(GLES2FormatTest, FramebufferTexture2D) {
   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
-  EXPECT_EQ(static_cast<GLint>(15), cmd.level);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1743,11 +1735,10 @@ TEST_F(GLES2FormatTest, TexImage2D) {
                            static_cast<GLint>(13),
                            static_cast<GLsizei>(14),
                            static_cast<GLsizei>(15),
-                           static_cast<GLint>(16),
+                           static_cast<GLenum>(16),
                            static_cast<GLenum>(17),
-                           static_cast<GLenum>(18),
-                           static_cast<uint32_t>(19),
-                           static_cast<uint32_t>(20));
+                           static_cast<uint32_t>(18),
+                           static_cast<uint32_t>(19));
   EXPECT_EQ(static_cast<uint32_t>(cmds::TexImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
@@ -1756,11 +1747,10 @@ TEST_F(GLES2FormatTest, TexImage2D) {
   EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
-  EXPECT_EQ(static_cast<GLint>(16), cmd.border);
-  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
-  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
-  EXPECT_EQ(static_cast<uint32_t>(19), cmd.pixels_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(20), cmd.pixels_shm_offset);
+  EXPECT_EQ(static_cast<GLenum>(16), cmd.format);
+  EXPECT_EQ(static_cast<GLenum>(17), cmd.type);
+  EXPECT_EQ(static_cast<uint32_t>(18), cmd.pixels_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(19), cmd.pixels_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2358,17 +2348,15 @@ TEST_F(GLES2FormatTest, UniformMatrix2fv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<GLboolean>(13),
-                           static_cast<uint32_t>(14),
-                           static_cast<uint32_t>(15));
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
   EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix2fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(15), cmd.value_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.value_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2389,17 +2377,13 @@ TEST_F(GLES2FormatTest, UniformMatrix2fvImmediate) {
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(1),
-                           static_cast<GLsizei>(2),
-                           static_cast<GLboolean>(3),
-                           data);
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
   EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix2fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
-  EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
@@ -2410,17 +2394,15 @@ TEST_F(GLES2FormatTest, UniformMatrix3fv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<GLboolean>(13),
-                           static_cast<uint32_t>(14),
-                           static_cast<uint32_t>(15));
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
   EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix3fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(15), cmd.value_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.value_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2451,17 +2433,13 @@ TEST_F(GLES2FormatTest, UniformMatrix3fvImmediate) {
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 9;
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(1),
-                           static_cast<GLsizei>(2),
-                           static_cast<GLboolean>(3),
-                           data);
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
   EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix3fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
-  EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
@@ -2472,17 +2450,15 @@ TEST_F(GLES2FormatTest, UniformMatrix4fv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<GLboolean>(13),
-                           static_cast<uint32_t>(14),
-                           static_cast<uint32_t>(15));
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
   EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix4fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
-  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(15), cmd.value_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.value_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2527,17 +2503,13 @@ TEST_F(GLES2FormatTest, UniformMatrix4fvImmediate) {
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 16;
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(1),
-                           static_cast<GLsizei>(2),
-                           static_cast<GLboolean>(3),
-                           data);
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
   EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix4fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
-  EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
@@ -2881,8 +2853,7 @@ TEST_F(GLES2FormatTest, FramebufferTexture2DMultisampleEXT) {
                            static_cast<GLenum>(12),
                            static_cast<GLenum>(13),
                            static_cast<GLuint>(14),
-                           static_cast<GLint>(15),
-                           static_cast<GLsizei>(16));
+                           static_cast<GLsizei>(15));
   EXPECT_EQ(
       static_cast<uint32_t>(cmds::FramebufferTexture2DMultisampleEXT::kCmdId),
       cmd.header.command);
@@ -2891,8 +2862,7 @@ TEST_F(GLES2FormatTest, FramebufferTexture2DMultisampleEXT) {
   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
-  EXPECT_EQ(static_cast<GLint>(15), cmd.level);
-  EXPECT_EQ(static_cast<GLsizei>(16), cmd.samples);
+  EXPECT_EQ(static_cast<GLsizei>(15), cmd.samples);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3753,14 +3723,13 @@ TEST_F(GLES2FormatTest, AsyncTexImage2DCHROMIUM) {
                            static_cast<GLint>(13),
                            static_cast<GLsizei>(14),
                            static_cast<GLsizei>(15),
-                           static_cast<GLint>(16),
+                           static_cast<GLenum>(16),
                            static_cast<GLenum>(17),
-                           static_cast<GLenum>(18),
+                           static_cast<uint32_t>(18),
                            static_cast<uint32_t>(19),
                            static_cast<uint32_t>(20),
                            static_cast<uint32_t>(21),
-                           static_cast<uint32_t>(22),
-                           static_cast<uint32_t>(23));
+                           static_cast<uint32_t>(22));
   EXPECT_EQ(static_cast<uint32_t>(cmds::AsyncTexImage2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
@@ -3769,14 +3738,13 @@ TEST_F(GLES2FormatTest, AsyncTexImage2DCHROMIUM) {
   EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
-  EXPECT_EQ(static_cast<GLint>(16), cmd.border);
-  EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
-  EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
-  EXPECT_EQ(static_cast<uint32_t>(19), cmd.pixels_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(20), cmd.pixels_shm_offset);
-  EXPECT_EQ(static_cast<uint32_t>(21), cmd.async_upload_token);
-  EXPECT_EQ(static_cast<uint32_t>(22), cmd.sync_data_shm_id);
-  EXPECT_EQ(static_cast<uint32_t>(23), cmd.sync_data_shm_offset);
+  EXPECT_EQ(static_cast<GLenum>(16), cmd.format);
+  EXPECT_EQ(static_cast<GLenum>(17), cmd.type);
+  EXPECT_EQ(static_cast<uint32_t>(18), cmd.pixels_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(19), cmd.pixels_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(20), cmd.async_upload_token);
+  EXPECT_EQ(static_cast<uint32_t>(21), cmd.sync_data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(22), cmd.sync_data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
index 6220afc..d339636 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
@@ -401,11 +401,6 @@ error::Error GLES2DecoderImpl::HandleCopyTexImage2D(
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopyTexImage2D", "height < 0");
     return error::kNoError;
   }
-  if (!validators_->texture_border.IsValid(border)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glCopyTexImage2D", "border GL_INVALID_VALUE");
-    return error::kNoError;
-  }
   DoCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
   return error::kNoError;
 }
@@ -763,11 +758,6 @@ error::Error GLES2DecoderImpl::HandleFramebufferTexture2D(
         "glFramebufferTexture2D", textarget, "textarget");
     return error::kNoError;
   }
-  if (!validators_->zero_only.IsValid(level)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glFramebufferTexture2D", "level GL_INVALID_VALUE");
-    return error::kNoError;
-  }
   DoFramebufferTexture2D(target, attachment, textarget, texture, level);
   return error::kNoError;
 }
@@ -2383,11 +2373,6 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix2fv(
   }
   const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
       c.value_shm_id, c.value_shm_offset, data_size);
-  if (!validators_->false_only.IsValid(transpose)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glUniformMatrix2fv", "transpose GL_INVALID_VALUE");
-    return error::kNoError;
-  }
   if (value == NULL) {
     return error::kOutOfBounds;
   }
@@ -2410,11 +2395,6 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix2fvImmediate(
   }
   const GLfloat* value =
       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
-  if (!validators_->false_only.IsValid(transpose)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glUniformMatrix2fv", "transpose GL_INVALID_VALUE");
-    return error::kNoError;
-  }
   if (value == NULL) {
     return error::kOutOfBounds;
   }
@@ -2434,11 +2414,6 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix3fv(
   }
   const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
       c.value_shm_id, c.value_shm_offset, data_size);
-  if (!validators_->false_only.IsValid(transpose)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glUniformMatrix3fv", "transpose GL_INVALID_VALUE");
-    return error::kNoError;
-  }
   if (value == NULL) {
     return error::kOutOfBounds;
   }
@@ -2461,11 +2436,6 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix3fvImmediate(
   }
   const GLfloat* value =
       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
-  if (!validators_->false_only.IsValid(transpose)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glUniformMatrix3fv", "transpose GL_INVALID_VALUE");
-    return error::kNoError;
-  }
   if (value == NULL) {
     return error::kOutOfBounds;
   }
@@ -2485,11 +2455,6 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix4fv(
   }
   const GLfloat* value = GetSharedMemoryAs<const GLfloat*>(
       c.value_shm_id, c.value_shm_offset, data_size);
-  if (!validators_->false_only.IsValid(transpose)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glUniformMatrix4fv", "transpose GL_INVALID_VALUE");
-    return error::kNoError;
-  }
   if (value == NULL) {
     return error::kOutOfBounds;
   }
@@ -2512,11 +2477,6 @@ error::Error GLES2DecoderImpl::HandleUniformMatrix4fvImmediate(
   }
   const GLfloat* value =
       GetImmediateDataAs<const GLfloat*>(c, data_size, immediate_data_size);
-  if (!validators_->false_only.IsValid(transpose)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glUniformMatrix4fv", "transpose GL_INVALID_VALUE");
-    return error::kNoError;
-  }
   if (value == NULL) {
     return error::kOutOfBounds;
   }
@@ -2883,12 +2843,6 @@ error::Error GLES2DecoderImpl::HandleFramebufferTexture2DMultisampleEXT(
         "glFramebufferTexture2DMultisampleEXT", textarget, "textarget");
     return error::kNoError;
   }
-  if (!validators_->zero_only.IsValid(level)) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
-                       "glFramebufferTexture2DMultisampleEXT",
-                       "level GL_INVALID_VALUE");
-    return error::kNoError;
-  }
   if (samples < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                        "glFramebufferTexture2DMultisampleEXT",
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
index f3f93217..8c51b03 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
@@ -1067,7 +1067,6 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexImage2D) {
            GL_RGBA,
            4,
            4,
-           0,
            GL_RGBA,
            GL_UNSIGNED_BYTE,
            kSharedMemoryId,
@@ -1128,7 +1127,7 @@ TEST_P(GLES2DecoderManualInitTest, MemoryTrackerCopyTexImage2D) {
       .Times(1)
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
-  cmd.Init(target, level, internal_format, 0, 0, width, height, border);
+  cmd.Init(target, level, internal_format, 0, 0, width, height);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
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 ebe62fb..cdbf351d 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
@@ -802,11 +802,8 @@ TEST_P(GLES2DecoderTest1, FramebufferTexture2DValidArgs) {
                                       0));
   SpecializedSetup<cmds::FramebufferTexture2D, 0>(true);
   cmds::FramebufferTexture2D cmd;
-  cmd.Init(GL_FRAMEBUFFER,
-           GL_COLOR_ATTACHMENT0,
-           GL_TEXTURE_2D,
-           client_texture_id_,
-           0);
+  cmd.Init(
+      GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
@@ -818,8 +815,7 @@ TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs0_0) {
   cmd.Init(GL_DRAW_FRAMEBUFFER,
            GL_COLOR_ATTACHMENT0,
            GL_TEXTURE_2D,
-           client_texture_id_,
-           0);
+           client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
@@ -831,8 +827,7 @@ TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs0_1) {
   cmd.Init(GL_READ_FRAMEBUFFER,
            GL_COLOR_ATTACHMENT0,
            GL_TEXTURE_2D,
-           client_texture_id_,
-           0);
+           client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
@@ -844,25 +839,11 @@ TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs2_0) {
   cmd.Init(GL_FRAMEBUFFER,
            GL_COLOR_ATTACHMENT0,
            GL_PROXY_TEXTURE_CUBE_MAP,
-           client_texture_id_,
-           0);
+           client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest1, FramebufferTexture2DInvalidArgs4_0) {
-  EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _)).Times(0);
-  SpecializedSetup<cmds::FramebufferTexture2D, 0>(false);
-  cmds::FramebufferTexture2D cmd;
-  cmd.Init(GL_FRAMEBUFFER,
-           GL_COLOR_ATTACHMENT0,
-           GL_TEXTURE_2D,
-           client_texture_id_,
-           1);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest1, FrontFaceValidArgs) {
   EXPECT_CALL(*gl_, FrontFace(GL_CW));
   SpecializedSetup<cmds::FrontFace, 0>(true);
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
index b162d4d..a16b298 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2.cc
@@ -199,7 +199,7 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
     {
       valid_uniform = accepts_apis & Program::kUniformMatrix2f;
       cmds::UniformMatrix2fv cmd;
-      cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
@@ -208,7 +208,7 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
     {
       valid_uniform = accepts_apis & Program::kUniformMatrix3f;
       cmds::UniformMatrix3fv cmd;
-      cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
@@ -217,7 +217,7 @@ class GLES2DecoderTest2 : public GLES2DecoderTestBase {
     {
       valid_uniform = accepts_apis & Program::kUniformMatrix4f;
       cmds::UniformMatrix4fv cmd;
-      cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
+      cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
       EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
       EXPECT_EQ(valid_uniform ? GL_NO_ERROR : GL_INVALID_OPERATION,
                 GetGLError());
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
index 209b1e6..4a46d7d 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
@@ -1105,7 +1105,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvValidArgs) {
                   reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<cmds::UniformMatrix2fv, 0>(true);
   cmds::UniformMatrix2fv cmd;
-  cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
@@ -1114,25 +1114,16 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
   cmds::UniformMatrix2fv cmd;
-  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
-  cmds::UniformMatrix2fv cmd;
-  cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_0) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
   cmds::UniformMatrix2fv cmd;
-  cmd.Init(1, 2, false, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
@@ -1140,7 +1131,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_1) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix2fv, 0>(false);
   cmds::UniformMatrix2fv cmd;
-  cmd.Init(1, 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
@@ -1155,7 +1146,6 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvValidArgsCountTooLarge) {
   cmds::UniformMatrix2fv cmd;
   cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
            5,
-           false,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ -1173,24 +1163,11 @@ TEST_P(GLES2DecoderTest2, UniformMatrix2fvImmediateValidArgs) {
   GLfloat temp[4 * 2] = {
       0,
   };
-  cmd.Init(1, 2, false, &temp[0]);
+  cmd.Init(1, 2, &temp[0]);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix2fvImmediateInvalidArgs2_0) {
-  cmds::UniformMatrix2fvImmediate& cmd =
-      *GetImmediateAs<cmds::UniformMatrix2fvImmediate>();
-  EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix2fvImmediate, 0>(false);
-  GLfloat temp[4 * 2] = {
-      0,
-  };
-  cmd.Init(1, 2, true, &temp[0]);
-  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
-  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, UniformMatrix3fvValidArgs) {
   EXPECT_CALL(*gl_,
               UniformMatrix3fv(
@@ -1200,7 +1177,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvValidArgs) {
                   reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<cmds::UniformMatrix3fv, 0>(true);
   cmds::UniformMatrix3fv cmd;
-  cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
@@ -1209,25 +1186,16 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
   cmds::UniformMatrix3fv cmd;
-  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
-  cmds::UniformMatrix3fv cmd;
-  cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_0) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
   cmds::UniformMatrix3fv cmd;
-  cmd.Init(1, 2, false, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
@@ -1235,7 +1203,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_1) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix3fv, 0>(false);
   cmds::UniformMatrix3fv cmd;
-  cmd.Init(1, 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
@@ -1250,7 +1218,6 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvValidArgsCountTooLarge) {
   cmds::UniformMatrix3fv cmd;
   cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
            5,
-           false,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ -1268,24 +1235,11 @@ TEST_P(GLES2DecoderTest2, UniformMatrix3fvImmediateValidArgs) {
   GLfloat temp[9 * 2] = {
       0,
   };
-  cmd.Init(1, 2, false, &temp[0]);
+  cmd.Init(1, 2, &temp[0]);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix3fvImmediateInvalidArgs2_0) {
-  cmds::UniformMatrix3fvImmediate& cmd =
-      *GetImmediateAs<cmds::UniformMatrix3fvImmediate>();
-  EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix3fvImmediate, 0>(false);
-  GLfloat temp[9 * 2] = {
-      0,
-  };
-  cmd.Init(1, 2, true, &temp[0]);
-  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
-  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, UniformMatrix4fvValidArgs) {
   EXPECT_CALL(*gl_,
               UniformMatrix4fv(
@@ -1295,7 +1249,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvValidArgs) {
                   reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<cmds::UniformMatrix4fv, 0>(true);
   cmds::UniformMatrix4fv cmd;
-  cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
@@ -1304,25 +1258,16 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
   cmds::UniformMatrix4fv cmd;
-  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
-  cmds::UniformMatrix4fv cmd;
-  cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_0) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
   cmds::UniformMatrix4fv cmd;
-  cmd.Init(1, 2, false, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
@@ -1330,7 +1275,7 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_1) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<cmds::UniformMatrix4fv, 0>(false);
   cmds::UniformMatrix4fv cmd;
-  cmd.Init(1, 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
@@ -1345,7 +1290,6 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvValidArgsCountTooLarge) {
   cmds::UniformMatrix4fv cmd;
   cmd.Init(ProgramManager::MakeFakeLocation(1, 1),
            5,
-           false,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ -1363,24 +1307,11 @@ TEST_P(GLES2DecoderTest2, UniformMatrix4fvImmediateValidArgs) {
   GLfloat temp[16 * 2] = {
       0,
   };
-  cmd.Init(1, 2, false, &temp[0]);
+  cmd.Init(1, 2, &temp[0]);
   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
-TEST_P(GLES2DecoderTest2, UniformMatrix4fvImmediateInvalidArgs2_0) {
-  cmds::UniformMatrix4fvImmediate& cmd =
-      *GetImmediateAs<cmds::UniformMatrix4fvImmediate>();
-  EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
-  SpecializedSetup<cmds::UniformMatrix4fvImmediate, 0>(false);
-  GLfloat temp[16 * 2] = {
-      0,
-  };
-  cmd.Init(1, 2, true, &temp[0]);
-  EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
-  EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
-}
-
 TEST_P(GLES2DecoderTest2, UseProgramValidArgs) {
   EXPECT_CALL(*gl_, UseProgram(kServiceProgramId));
   SpecializedSetup<cmds::UseProgram, 0>(true);
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_async_pixel.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_async_pixel.cc
index 445c86f..d32870d 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_async_pixel.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_async_pixel.cc
@@ -80,7 +80,6 @@ TEST_P(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
                     GL_RGBA,
                     8,
                     8,
-                    0,
                     GL_RGBA,
                     GL_UNSIGNED_BYTE,
                     kSharedMemoryId,
@@ -341,7 +340,6 @@ TEST_P(GLES2DecoderManualInitTest, AsyncPixelTransferManager) {
                     GL_RGBA,
                     8,
                     8,
-                    0,
                     GL_RGBA,
                     GL_UNSIGNED_BYTE,
                     kSharedMemoryId,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
index 0b829f3..ec98832 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
@@ -913,7 +913,7 @@ void GLES2DecoderTestBase::DoTexImage2D(
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   cmds::TexImage2D cmd;
-  cmd.Init(target, level, internal_format, width, height, border, format,
+  cmd.Init(target, level, internal_format, width, height, format,
            type, shared_memory_id, shared_memory_offset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
@@ -935,7 +935,7 @@ void GLES2DecoderTestBase::DoTexImage2DConvertInternalFormat(
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   cmds::TexImage2D cmd;
-  cmd.Init(target, level, requested_internal_format, width, height, border,
+  cmd.Init(target, level, requested_internal_format, width, height,
            format, type, shared_memory_id, shared_memory_offset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
@@ -958,7 +958,7 @@ void GLES2DecoderTestBase::DoCompressedTexImage2D(
   bucket->SetSize(size);
   cmds::CompressedTexImage2DBucket cmd;
   cmd.Init(
-      target, level, format, width, height, border,
+      target, level, format, width, height,
       bucket_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
@@ -996,7 +996,7 @@ void GLES2DecoderTestBase::DoFramebufferTexture2D(
       .WillOnce(Return(error))
       .RetiresOnSaturation();
   cmds::FramebufferTexture2D cmd;
-  cmd.Init(target, attachment, textarget, texture_client_id, level);
+  cmd.Init(target, attachment, textarget, texture_client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc
index edffc8f..571573a 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_framebuffers.cc
@@ -122,8 +122,7 @@ TEST_P(GLES2DecoderTest, FramebufferTexture2DWithNoBoundTarget) {
   cmd.Init(GL_FRAMEBUFFER,
            GL_COLOR_ATTACHMENT0,
            GL_TEXTURE_2D,
-           client_texture_id_,
-           0);
+           client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
@@ -218,8 +217,7 @@ TEST_P(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithTexture) {
   fbtex_cmd.Init(GL_FRAMEBUFFER,
                  GL_COLOR_ATTACHMENT0,
                  GL_TEXTURE_2D,
-                 client_texture_id_,
-                 0);
+                 client_texture_id_);
   cmd.Init(GL_FRAMEBUFFER,
            GL_COLOR_ATTACHMENT0,
            GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
@@ -1329,8 +1327,7 @@ TEST_P(GLES2DecoderTest, FramebufferTexture2DGLError) {
   fbtex_cmd.Init(GL_FRAMEBUFFER,
                  GL_COLOR_ATTACHMENT0,
                  GL_TEXTURE_2D,
-                 client_texture_id_,
-                 0);
+                 client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(fbtex_cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
@@ -1805,7 +1802,6 @@ TEST_P(GLES2DecoderWithShaderTest, CopyTexImageWithInCompleteFBOFails) {
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
-  GLint border = 0;
   SetupTexture();
   DoBindRenderbuffer(
       GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
@@ -1823,7 +1819,7 @@ TEST_P(GLES2DecoderWithShaderTest, CopyTexImageWithInCompleteFBOFails) {
       .Times(0)
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
-  cmd.Init(target, level, internal_format, 0, 0, width, height, border);
+  cmd.Init(target, level, internal_format, 0, 0, width, height);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_FRAMEBUFFER_OPERATION, GetGLError());
 }
@@ -1961,7 +1957,7 @@ void GLES2DecoderWithShaderTest::CheckTextureChangesMarkFBOAsNotComplete(
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
-  cmd.Init(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 1, 1, 0);
+  cmd.Init(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_FALSE(framebuffer_manager->IsComplete(framebuffer));
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
index a9af8a1..a0a5624 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_textures.cc
@@ -505,7 +505,6 @@ TEST_P(GLES2DecoderTest, TexImage2DRedefinitionSucceeds) {
                GL_RGBA,
                kWidth,
                kHeight,
-               0,
                GL_RGBA,
                GL_UNSIGNED_BYTE,
                kSharedMemoryId,
@@ -526,7 +525,6 @@ TEST_P(GLES2DecoderTest, TexImage2DRedefinitionSucceeds) {
                GL_RGBA,
                kWidth,
                kHeight,
-               0,
                GL_RGBA,
                GL_UNSIGNED_BYTE,
                0,
@@ -601,7 +599,6 @@ TEST_P(GLES2DecoderTest, TexImage2DGLError) {
            internal_format,
            width,
            height,
-           border,
            format,
            type,
            kSharedMemoryId,
@@ -634,7 +631,7 @@ TEST_P(GLES2DecoderTest, CopyTexImage2DGLError) {
       .Times(1)
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
-  cmd.Init(target, level, internal_format, 0, 0, width, height, border);
+  cmd.Init(target, level, internal_format, 0, 0, width, height);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
@@ -655,7 +652,6 @@ TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DBucketBadBucket) {
            GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
            4,
            4,
-           0,
            kBadBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   CompressedTexSubImage2DBucket cmd2;
@@ -715,7 +711,7 @@ TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
     // test bad width.
-    cmd.Init(GL_TEXTURE_2D, 0, test.format, 5, 4, 0, kBucketId);
+    cmd.Init(GL_TEXTURE_2D, 0, test.format, 5, 4, kBucketId);
     bucket->SetSize(test.block_size * 2);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
@@ -726,7 +722,7 @@ TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
     // test too bad height.
-    cmd.Init(GL_TEXTURE_2D, 0, test.format, 4, 5, 0, kBucketId);
+    cmd.Init(GL_TEXTURE_2D, 0, test.format, 4, 5, kBucketId);
     bucket->SetSize(test.block_size * 2);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
@@ -742,13 +738,13 @@ TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
     // test size too large.
-    cmd.Init(GL_TEXTURE_2D, 0, test.format, 4, 4, 0, kBucketId);
+    cmd.Init(GL_TEXTURE_2D, 0, test.format, 4, 4, kBucketId);
     bucket->SetSize(test.block_size * 2);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 
     // test size too small.
-    cmd.Init(GL_TEXTURE_2D, 0, test.format, 4, 4, 0, kBucketId);
+    cmd.Init(GL_TEXTURE_2D, 0, test.format, 4, 4, kBucketId);
     bucket->SetSize(test.block_size / 2);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
     EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
@@ -862,13 +858,13 @@ TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DETC1) {
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // test size too large.
-  cmd.Init(GL_TEXTURE_2D, 0, kFormat, 4, 4, 0, kBucketId);
+  cmd.Init(GL_TEXTURE_2D, 0, kFormat, 4, 4, kBucketId);
   bucket->SetSize(kBlockSize * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 
   // test size too small.
-  cmd.Init(GL_TEXTURE_2D, 0, kFormat, 4, 4, 0, kBucketId);
+  cmd.Init(GL_TEXTURE_2D, 0, kFormat, 4, 4, kBucketId);
   bucket->SetSize(kBlockSize / 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
@@ -1071,7 +1067,6 @@ TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTexImage2DError) {
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
-  GLint border = 0;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
@@ -1082,7 +1077,6 @@ TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTexImage2DError) {
            internal_format,
            width,
            height,
-           border,
            format,
            type,
            kSharedMemoryId,
@@ -1295,7 +1289,6 @@ TEST_P(GLES2DecoderManualInitTest, NoDefaultTexImage2D) {
             GL_RGBA,
             2,
             2,
-            0,
             GL_RGBA,
             GL_UNSIGNED_BYTE,
             kSharedMemoryId,
@@ -1491,7 +1484,6 @@ TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTexImage2DError) {
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
-  GLint border = 0;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
   DoBindTexture(
@@ -1503,7 +1495,6 @@ TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTexImage2DError) {
            internal_format,
            width,
            height,
-           border,
            format,
            type,
            kSharedMemoryId,
@@ -1661,7 +1652,6 @@ TEST_P(
              GL_RGBA,
              2,
              2,
-             0,
              GL_RGBA,
              GL_UNSIGNED_BYTE,
              kSharedMemoryId,
@@ -1726,7 +1716,7 @@ TEST_P(GLES2DecoderTest, TexSubImage2DClearsAfterTexImage2DWithDataThenNULL) {
   // Put in no data.
   TexImage2D tex_cmd;
   tex_cmd.Init(
-      GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
+      GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
   // It won't actually call TexImage2D, just mark it as uncleared.
   EXPECT_EQ(error::kNoError, ExecuteCmd(tex_cmd));
   // Next call to TexSubImage2d should clear.
@@ -1785,7 +1775,7 @@ TEST_P(GLES2DecoderTest, CopyTexImage2DMarksTextureAsCleared) {
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
-  cmd.Init(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 1, 0);
+  cmd.Init(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 
   EXPECT_TRUE(texture->SafeToRenderFrom());
@@ -1840,7 +1830,6 @@ TEST_P(GLES2DecoderManualInitTest, CompressedImage2DMarksTextureAsCleared) {
            GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
            4,
            4,
-           0,
            8,
            kSharedMemoryId,
            kSharedMemoryOffset);
@@ -1960,7 +1949,6 @@ TEST_P(GLES2DecoderManualInitTest, DepthTextureBadArgs) {
                GL_DEPTH_COMPONENT,
                1,
                1,
-               0,
                GL_DEPTH_COMPONENT,
                GL_UNSIGNED_INT,
                kSharedMemoryId,
@@ -1973,7 +1961,6 @@ TEST_P(GLES2DecoderManualInitTest, DepthTextureBadArgs) {
                GL_DEPTH_COMPONENT,
                1,
                1,
-               0,
                GL_DEPTH_COMPONENT,
                GL_UNSIGNED_INT,
                0,
@@ -2011,7 +1998,7 @@ TEST_P(GLES2DecoderManualInitTest, DepthTextureBadArgs) {
 
   // Check that trying to CopyTexImage2D fails
   CopyTexImage2D copy_tex_cmd;
-  copy_tex_cmd.Init(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0, 0, 1, 1, 0);
+  copy_tex_cmd.Init(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0, 0, 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(copy_tex_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
@@ -2286,8 +2273,7 @@ TEST_P(GLES2DecoderWithShaderTest, UseTexImage) {
   fbtex_cmd.Init(GL_FRAMEBUFFER,
                  GL_COLOR_ATTACHMENT0,
                  GL_TEXTURE_2D,
-                 client_texture_id_,
-                 0);
+                 client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(fbtex_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
index 06f7afb..cbdf48f 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
@@ -25,7 +25,6 @@ ValueValidator<GLenum> dst_blend_factor;
 ValueValidator<GLenum> equation;
 ValueValidator<GLenum> face_mode;
 ValueValidator<GLenum> face_type;
-ValueValidator<GLboolean> false_only;
 ValueValidator<GLenum> frame_buffer_parameter;
 ValueValidator<GLenum> frame_buffer_target;
 ValueValidator<GLenum> g_l_state;
@@ -55,7 +54,6 @@ ValueValidator<GLenum> src_blend_factor;
 ValueValidator<GLenum> stencil_op;
 ValueValidator<GLenum> string_type;
 ValueValidator<GLenum> texture_bind_target;
-ValueValidator<GLint> texture_border;
 ValueValidator<GLenum> texture_format;
 ValueValidator<GLenum> texture_internal_format;
 ValueValidator<GLenum> texture_internal_format_storage;
@@ -70,6 +68,5 @@ ValueValidator<GLint> vertex_attrib_size;
 ValueValidator<GLenum> vertex_attrib_type;
 ValueValidator<GLenum> vertex_attribute;
 ValueValidator<GLenum> vertex_pointer;
-ValueValidator<GLint> zero_only;
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_VALIDATION_AUTOGEN_H_
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
index a297112..5db1bc3 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
@@ -73,10 +73,6 @@ static const GLenum valid_face_type_table[] = {
     GL_FRONT, GL_BACK, GL_FRONT_AND_BACK,
 };
 
-static const GLboolean valid_false_only_table[] = {
-    false,
-};
-
 static const GLenum valid_frame_buffer_parameter_table[] = {
     GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
     GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
@@ -323,10 +319,6 @@ static const GLenum valid_texture_bind_target_table[] = {
     GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP,
 };
 
-static const GLint valid_texture_border_table[] = {
-    0,
-};
-
 static const GLenum valid_texture_format_table[] = {
     GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA,
 };
@@ -393,10 +385,6 @@ static const GLenum valid_vertex_pointer_table[] = {
     GL_VERTEX_ATTRIB_ARRAY_POINTER,
 };
 
-static const GLint valid_zero_only_table[] = {
-    0,
-};
-
 Validators::Validators()
     : attachment(valid_attachment_table, arraysize(valid_attachment_table)),
       backbuffer_attachment(valid_backbuffer_attachment_table,
@@ -418,7 +406,6 @@ Validators::Validators()
       equation(valid_equation_table, arraysize(valid_equation_table)),
       face_mode(valid_face_mode_table, arraysize(valid_face_mode_table)),
       face_type(valid_face_type_table, arraysize(valid_face_type_table)),
-      false_only(valid_false_only_table, arraysize(valid_false_only_table)),
       frame_buffer_parameter(valid_frame_buffer_parameter_table,
                              arraysize(valid_frame_buffer_parameter_table)),
       frame_buffer_target(valid_frame_buffer_target_table,
@@ -467,8 +454,6 @@ Validators::Validators()
       string_type(valid_string_type_table, arraysize(valid_string_type_table)),
       texture_bind_target(valid_texture_bind_target_table,
                           arraysize(valid_texture_bind_target_table)),
-      texture_border(valid_texture_border_table,
-                     arraysize(valid_texture_border_table)),
       texture_format(valid_texture_format_table,
                      arraysize(valid_texture_format_table)),
       texture_internal_format(valid_texture_internal_format_table,
@@ -497,8 +482,7 @@ Validators::Validators()
       vertex_attribute(valid_vertex_attribute_table,
                        arraysize(valid_vertex_attribute_table)),
       vertex_pointer(valid_vertex_pointer_table,
-                     arraysize(valid_vertex_pointer_table)),
-      zero_only(valid_zero_only_table, arraysize(valid_zero_only_table)) {
+                     arraysize(valid_vertex_pointer_table)) {
 }
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_VALIDATION_IMPLEMENTATION_AUTOGEN_H_