Update from https://crrev.com/306655

gpu/command_buffer/build_gles2_cmd_buffer.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """code generator for GLES2 command buffers."""
 
 import itertools
 import os
 import os.path
@@ skipping 670 matching lines @@
       'GL_TEXTURE_CUBE_MAP_NEGATIVE_X',
       'GL_TEXTURE_CUBE_MAP_POSITIVE_Y',
       'GL_TEXTURE_CUBE_MAP_NEGATIVE_Y',
       'GL_TEXTURE_CUBE_MAP_POSITIVE_Z',
       'GL_TEXTURE_CUBE_MAP_NEGATIVE_Z',
     ],
     'invalid': [
       'GL_PROXY_TEXTURE_CUBE_MAP',
     ]
   },
+  'Texture3DTarget': {
+    'type': 'GLenum',
+    'valid': [
+      'GL_TEXTURE_3D',
+      'GL_TEXTURE_2D_ARRAY',
+    ],
+    'invalid': [
+      'GL_TEXTURE_2D',
+    ]
+  },
   'TextureBindTarget': {
     'type': 'GLenum',
     'valid': [
       'GL_TEXTURE_2D',
       'GL_TEXTURE_CUBE_MAP',
     ],
     'invalid': [
       'GL_TEXTURE_1D',
       'GL_TEXTURE_3D',
     ],
@@ skipping 639 matching lines @@
 # shadowed:     True = the value is shadowed so no glGetXXX call will be made.
 # first_element_only: For PUT types, True if only the first element of an
 #               array is used and we end up calling the single value
 #               corresponding function. eg. TexParameteriv -> TexParameteri
 # extension:    Function is an extension to GL and should not be exposed to
 #               pepper unless pepper_interface is defined.
 # extension_flag: Function is an extension and should be enabled only when
 #               the corresponding feature info flag is enabled. Implies
 #               'extension': True.
 # not_shared:   For GENn types, True if objects can't be shared between contexts
+# unsafe:       True = no validation is implemented on the service side and the
+#               command is only available with --enable-unsafe-es3-apis.
 
 _FUNCTION_INFO = {
   'ActiveTexture': {
     'decoder_func': 'DoActiveTexture',
     'unit_test': False,
     'impl_func': False,
     'client_test': False,
   },
   'AttachShader': {'decoder_func': 'DoAttachShader'},
   'BindAttribLocation': {
@@ skipping 83 matching lines @@
     'decoder_func': 'DoConsumeTextureCHROMIUM',
     'impl_func': False,
     'type': 'PUT',
     'count': 64,  # GL_MAILBOX_SIZE_CHROMIUM
     'unit_test': False,
     'client_test': False,
     'extension': "CHROMIUM_texture_mailbox",
     'chromium': True,
     'trace_level': 1,
   },
+  'CopyBufferSubData': {
+    'unsafe': True,
+  },
   'CreateAndConsumeTextureCHROMIUM': {
     'decoder_func': 'DoCreateAndConsumeTextureCHROMIUM',
     'impl_func': False,
     'type': 'HandWritten',
     'data_transfer_methods': ['immediate'],
     'unit_test': False,
     'client_test': False,
     'extension': "CHROMIUM_texture_mailbox",
     'chromium': True,
   },
@@ skipping 281 matching lines @@
     'trace_level': 1,
   },
   'FramebufferTexture2DMultisampleEXT': {
     'decoder_func': 'DoFramebufferTexture2DMultisample',
     'gl_test_func': 'glFramebufferTexture2DMultisampleEXT',
     'expectation': False,
     'unit_test': False,
     'extension_flag': 'multisampled_render_to_texture',
     'trace_level': 1,
   },
+  'FramebufferTextureLayer': {
+    'decoder_func': 'DoFramebufferTextureLayer',
+    'unsafe': True,
+  },
   'GenerateMipmap': {
     'decoder_func': 'DoGenerateMipmap',
     'gl_test_func': 'glGenerateMipmapEXT',
   },
   'GenBuffers': {
     'type': 'GENn',
     'gl_test_func': 'glGenBuffersARB',
     'resource_type': 'Buffer',
     'resource_types': 'Buffers',
   },
@@ skipping 89 matching lines @@
     'decoder_func': 'DoGetFramebufferAttachmentParameteriv',
     'gl_test_func': 'glGetFramebufferAttachmentParameterivEXT',
     'result': ['SizedResult<GLint>'],
   },
   'GetIntegerv': {
     'type': 'GETn',
     'result': ['SizedResult<GLint>'],
     'decoder_func': 'DoGetIntegerv',
     'client_test': False,
   },
+  'GetInternalformativ': {
+    'type': 'GETn',
+    'result': ['SizedResult<GLint>'],
+    'unsafe': True,
+  },
   'GetMaxValueInBufferCHROMIUM': {
     'type': 'Is',
     'decoder_func': 'DoGetMaxValueInBufferCHROMIUM',
     'result': ['GLuint'],
     'unit_test': False,
     'client_test': False,
     'extension': True,
     'chromium': True,
     'impl_func': False,
   },
@@ skipping 318 matching lines @@
     'first_element_only': True,
   },
   'TexParameteriv': {
     'type': 'PUT',
     'data_value': 'GL_NEAREST',
     'count': 1,
     'decoder_func': 'DoTexParameteriv',
     'gl_test_func': 'glTexParameteri',
     'first_element_only': True,
   },
+  'TexStorage3D': {
+    'unsafe': True,
+  },
   'TexSubImage2D': {
     'type': 'Manual',
     'data_transfer_methods': ['shm'],
     'client_test': False,
     'cmd_args': 'GLenumTextureTarget target, GLint level, '
                 'GLint xoffset, GLint yoffset, '
                 'GLsizei width, GLsizei height, '
                 'GLenumTextureFormat format, GLenumPixelType type, '
                 'const void* pixels, GLboolean internal'
   },
   'Uniform1f': {'type': 'PUTXn', 'count': 1},
   'Uniform1fv': {
     'type': 'PUTn',
     'count': 1,
     'decoder_func': 'DoUniform1fv',
   },
   'Uniform1i': {'decoder_func': 'DoUniform1i', 'unit_test': False},
   'Uniform1iv': {
     'type': 'PUTn',
     'count': 1,
     'decoder_func': 'DoUniform1iv',
     'unit_test': False,
   },
+  'Uniform1ui': {
+    'type': 'PUTXn',
+    'count': 1,
+    'unsafe': True,
+  },
+  'Uniform1uiv': {
+    'type': 'PUTn',
+    'count': 1,
+    'unsafe': True,
+  },
   'Uniform2i': {'type': 'PUTXn', 'count': 2},
   'Uniform2f': {'type': 'PUTXn', 'count': 2},
   'Uniform2fv': {
     'type': 'PUTn',
     'count': 2,
     'decoder_func': 'DoUniform2fv',
   },
   'Uniform2iv': {
     'type': 'PUTn',
     'count': 2,
     'decoder_func': 'DoUniform2iv',
   },
+  'Uniform2ui': {
+    'type': 'PUTXn',
+    'count': 2,
+    'unsafe': True,
+  },
+  'Uniform2uiv': {
+    'type': 'PUTn',
+    'count': 2,
+    'unsafe': True,
+  },
   'Uniform3i': {'type': 'PUTXn', 'count': 3},
   'Uniform3f': {'type': 'PUTXn', 'count': 3},
   'Uniform3fv': {
     'type': 'PUTn',
     'count': 3,
     'decoder_func': 'DoUniform3fv',
   },
   'Uniform3iv': {
     'type': 'PUTn',
     'count': 3,
     'decoder_func': 'DoUniform3iv',
   },
+  'Uniform3ui': {
+    'type': 'PUTXn',
+    'count': 3,
+    'unsafe': True,
+  },
+  'Uniform3uiv': {
+    'type': 'PUTn',
+    'count': 3,
+    'unsafe': True,
+  },
   'Uniform4i': {'type': 'PUTXn', 'count': 4},
   'Uniform4f': {'type': 'PUTXn', 'count': 4},
   'Uniform4fv': {
     'type': 'PUTn',
     'count': 4,
     'decoder_func': 'DoUniform4fv',
   },
   'Uniform4iv': {
     'type': 'PUTn',
     'count': 4,
     'decoder_func': 'DoUniform4iv',
   },
+  'Uniform4ui': {
+    'type': 'PUTXn',
+    'count': 4,
+    'unsafe': True,
+  },
+  'Uniform4uiv': {
+    'type': 'PUTn',
+    'count': 4,
+    'unsafe': True,
+  },
   'UniformMatrix2fv': {
     'type': 'PUTn',
     'count': 4,
     'decoder_func': 'DoUniformMatrix2fv',
   },
+  'UniformMatrix2x3fv': {
+    'type': 'PUTn',
+    'count': 6,
+    'unsafe': True,
+  },
+  'UniformMatrix2x4fv': {
+    'type': 'PUTn',
+    'count': 8,
+    'unsafe': True,
+  },
   'UniformMatrix3fv': {
     'type': 'PUTn',
     'count': 9,
     'decoder_func': 'DoUniformMatrix3fv',
   },
+  'UniformMatrix3x2fv': {
+    'type': 'PUTn',
+    'count': 6,
+    'unsafe': True,
+  },
+  'UniformMatrix3x4fv': {
+    'type': 'PUTn',
+    'count': 12,
+    'unsafe': True,
+  },
   'UniformMatrix4fv': {
     'type': 'PUTn',
     'count': 16,
     'decoder_func': 'DoUniformMatrix4fv',
   },
+  'UniformMatrix4x2fv': {
+    'type': 'PUTn',
+    'count': 8,
+    'unsafe': True,
+  },
+  'UniformMatrix4x3fv': {
+    'type': 'PUTn',
+    'count': 12,
+    'unsafe': True,
+  },
   'UnmapBufferCHROMIUM': {
     'gen_cmd': False,
     'extension': True,
     'chromium': True,
     'client_test': False,
   },
   'UnmapBufferSubDataCHROMIUM': {
     'gen_cmd': False,
     'extension': True,
     'chromium': True,
@@ skipping 29 matching lines @@
     'type': 'PUT',
     'count': 3,
     'decoder_func': 'DoVertexAttrib3fv',
   },
   'VertexAttrib4f': {'decoder_func': 'DoVertexAttrib4f'},
   'VertexAttrib4fv': {
     'type': 'PUT',
     'count': 4,
     'decoder_func': 'DoVertexAttrib4fv',
   },
+  'VertexAttribI4i': {
+    'unsafe': True,
+  },
+  'VertexAttribI4iv': {
+    'type': 'PUT',
+    'count': 4,
+    'unsafe': True,
+  },
+  'VertexAttribI4ui': {
+    'unsafe': True,
+  },
+  'VertexAttribI4uiv': {
+    'type': 'PUT',
+    'count': 4,
+    'unsafe': True,
+  },
+  'VertexAttribIPointer': {
+    'type': 'Manual',
+    'cmd_args': 'GLuint indx, GLintVertexAttribSize size, '
+                'GLenumVertexAttribType type, GLsizei stride, '
+                'GLuint offset',
+    'client_test': False,
+    'unsafe': True,
+  },
   'VertexAttribPointer': {
-      'type': 'Manual',
-      'cmd_args': 'GLuint indx, GLintVertexAttribSize size, '
-                  'GLenumVertexAttribType type, GLboolean normalized, '
-                  'GLsizei stride, GLuint offset',
-      'client_test': False,
+    'type': 'Manual',
+    'cmd_args': 'GLuint indx, GLintVertexAttribSize size, '
+                'GLenumVertexAttribType type, GLboolean normalized, '
+                'GLsizei stride, GLuint offset',
+    'client_test': False,
   },
   'Scissor': {
     'type': 'StateSet',
     'state': 'Scissor',
   },
   'Viewport': {
     'decoder_func': 'DoViewport',
   },
   'ResizeCHROMIUM': {
-      'type': 'Custom',
-      'impl_func': False,
-      'unit_test': False,
-      'extension': True,
-      'chromium': True,
+    'type': 'Custom',
+    'impl_func': False,
+    'unit_test': False,
+    'extension': True,
+    'chromium': True,
   },
   'GetRequestableExtensionsCHROMIUM': {
     'type': 'Custom',
     'impl_func': False,
     'cmd_args': 'uint32_t bucket_id',
     'extension': True,
     'chromium': True,
   },
   'RequestExtensionCHROMIUM': {
     'type': 'Custom',
@@ skipping 617 matching lines @@
 
   def WriteBucketHandlerImplementation (self, func, file):
     """Writes the handler impl for the bucket version of a command."""
     file.Write("  %s(%s);\n" %
                (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
 
   def WriteServiceHandlerFunctionHeader(self, func, file):
     """Writes function header for service implementation handlers."""
     file.Write("""error::Error GLES2DecoderImpl::Handle%(name)s(
         uint32_t immediate_data_size, const void* cmd_data) {
-      const gles2::cmds::%(name)s& c =
+      """ % {'name': func.name})
+    if func.IsUnsafe():
+      file.Write("""if (!unsafe_es3_apis_enabled())
+          return error::kUnknownCommand;
+        """)
+    file.Write("""const gles2::cmds::%(name)s& c =
           *static_cast<const gles2::cmds::%(name)s*>(cmd_data);
       (void)c;
       """ % {'name': func.name})
 
   def WriteServiceImplementation(self, func, file):
     """Writes the service implementation for a command."""
     self.WriteServiceHandlerFunctionHeader(func, file)
     self.WriteHandlerExtensionCheck(func, file)
     self.WriteHandlerDeferReadWrite(func, file);
     if len(func.GetOriginalArgs()) > 0:
@@ skipping 141 matching lines @@
 
   def WriteServiceUnitTest(self, func, file, *extras):
     """Writes the service unit test for a command."""
 
     if func.name == 'Enable':
       valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   SetupExpectationsForEnableDisable(%(gl_args)s, true);
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
-  cmd.Init(%(args)s);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-"""
+  cmd.Init(%(args)s);"""
     elif func.name == 'Disable':
       valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   SetupExpectationsForEnableDisable(%(gl_args)s, false);
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
-  cmd.Init(%(args)s);
-  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
-}
-"""
+  cmd.Init(%(args)s);"""
     else:
       valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
-  cmd.Init(%(args)s);
+  cmd.Init(%(args)s);"""
+    if func.IsUnsafe():
+      valid_test += """
+  decoder_->set_unsafe_es3_apis_enabled(true);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+  decoder_->set_unsafe_es3_apis_enabled(false);
+  EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
+}
+"""
+    else:
+      valid_test += """
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     self.WriteValidUnitTest(func, file, valid_test, *extras)
 
-    invalid_test = """
+    if not func.IsUnsafe():
+      invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));%(gl_error_test)s
 }
 """
-    self.WriteInvalidUnitTest(func, file, invalid_test, *extras)
+      self.WriteInvalidUnitTest(func, file, invalid_test, *extras)
 
   def WriteImmediateServiceUnitTest(self, func, file, *extras):
     """Writes the service unit test for an immediate command."""
     file.Write("// TODO(gman): %s\n" % func.name)
 
   def WriteImmediateValidationCode(self, func, file):
     """Writes the validation code for an immediate version of a command."""
     pass
 
   def WriteBucketServiceUnitTest(self, func, file, *extras):
@@ skipping 1720 matching lines @@
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   SpecializedSetup<cmds::%(name)s, 0>(true);
   typedef cmds::%(name)s::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(local_gl_args)s));
   result->size = 0;
   cmds::%(name)s cmd;
-  cmd.Init(%(args)s);
+  cmd.Init(%(args)s);"""
+    if func.IsUnsafe():
+      valid_test += """
+  decoder_->set_unsafe_es3_apis_enabled(true);"""
+    valid_test += """
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
                 %(valid_pname)s),
             result->GetNumResults());
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
+    if func.IsUnsafe():
+      valid_test += """
+  decoder_->set_unsafe_es3_apis_enabled(false);
+  EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));"""
+    valid_test += """
 }
 """
     gl_arg_strings = []
     valid_pname = ''
     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
     if func.GetInfo('gl_test_func') == 'glGetIntegerv':
       gl_arg_strings.append("_")
     else:
       gl_arg_strings.append("result->GetData()")
 
     self.WriteValidUnitTest(func, file, valid_test, {
         'local_gl_args': ", ".join(gl_arg_strings),
         'valid_pname': valid_pname,
       }, *extras)
 
-    invalid_test = """
+    if not func.IsUnsafe():
+      invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s::Result* result =
       static_cast<cmds::%(name)s::Result*>(shared_memory_address_);
   result->size = 0;
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));
   EXPECT_EQ(0u, result->size);%(gl_error_test)s
 }
 """
-    self.WriteInvalidUnitTest(func, file, invalid_test, *extras)
+      self.WriteInvalidUnitTest(func, file, invalid_test, *extras)
 
 class ArrayArgTypeHandler(TypeHandler):
   """Base class for type handlers that handle args that are arrays"""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def GetArrayType(self, func):
     """Returns the type of the element in the element array being PUT to."""
     for arg in func.GetOriginalArgs():
@@ skipping 62 matching lines @@
     """Writes the service unit test for a command."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(true);
   %(data_type)s temp[%(data_count)s] = { %(data_value)s, };
   cmd.Init(%(gl_args)s, &temp[0]);
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(%(gl_args)s, %(data_ref)sreinterpret_cast<
-          %(data_type)s*>(ImmediateDataAddress(&cmd))));
+          %(data_type)s*>(ImmediateDataAddress(&cmd))));"""
+    if func.IsUnsafe():
+      valid_test += """
+  decoder_->set_unsafe_es3_apis_enabled(true);"""
+    valid_test += """
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
+    if func.IsUnsafe():
+      valid_test += """
+  decoder_->set_unsafe_es3_apis_enabled(false);
+  EXPECT_EQ(error::kUnknownCommand,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));"""
+    valid_test += """
 }
 """
     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),
@@ skipping 245 matching lines @@
     """Overridden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(%(gl_args)s,
           reinterpret_cast<%(data_type)s*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   %(data_type)s temp[%(data_count)s * 2] = { 0, };
-  cmd.Init(%(args)s, &temp[0]);
+  cmd.Init(%(args)s, &temp[0]);"""
+    if func.IsUnsafe():
+      valid_test += """
+  decoder_->set_unsafe_es3_apis_enabled(true);"""
+    valid_test += """
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
+    if func.IsUnsafe():
+      valid_test += """
+  decoder_->set_unsafe_es3_apis_enabled(false);
+  EXPECT_EQ(error::kUnknownCommand,
+            ExecuteImmediateCmd(cmd, sizeof(temp)));"""
+    valid_test += """
 }
 """
     gl_arg_strings = []
     gl_any_strings = []
     arg_strings = []
     for arg in func.GetOriginalArgs()[0:-1]:
       gl_arg_strings.append(arg.GetValidGLArg(func))
       gl_any_strings.append("_")
       if not arg.IsConstant():
         arg_strings.append(arg.GetValidArg(func))
@@ skipping 253 matching lines @@
     file.Write("\n")
 
 
 class PUTXnHandler(ArrayArgTypeHandler):
   """Handler for glUniform?f functions."""
   def __init__(self):
     ArrayArgTypeHandler.__init__(self)
 
   def WriteHandlerImplementation(self, func, file):
     """Overrriden from TypeHandler."""
-    code = """  %(type)s temp[%(count)s] = { %(values)s};
+    code = """  %(type)s temp[%(count)s] = { %(values)s};"""
+    if func.IsUnsafe():
+      code += """
+  gl%(name)sv(%(location)s, 1, &temp[0]);
+"""
+    else:
+      code += """
   Do%(name)sv(%(location)s, 1, &temp[0]);
 """
     values = ""
     args = func.GetOriginalArgs()
     count = int(self.GetArrayCount(func))
     num_args = len(args)
     for ii in range(count):
       values += "%s, " % args[len(args) - count + ii].name
 
     file.Write(code % {
         'name': func.name,
         'count': self.GetArrayCount(func),
         'type': self.GetArrayType(func),
         'location': args[0].name,
         'args': func.MakeOriginalArgString(""),
         'values': values,
       })
 
   def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(name)sv(%(local_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
-  cmd.Init(%(args)s);
+  cmd.Init(%(args)s);"""
+    if func.IsUnsafe():
+      valid_test += """
+  decoder_->set_unsafe_es3_apis_enabled(true);"""
+    valid_test += """
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
+    if func.IsUnsafe():
+      valid_test += """
+  decoder_->set_unsafe_es3_apis_enabled(false);
+  EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));"""
+    valid_test += """
 }
 """
     args = func.GetOriginalArgs()
     local_args = "%s, 1, _" % args[0].GetValidGLArg(func)
     self.WriteValidUnitTest(func, file, valid_test, {
         'name': func.name,
         'count': self.GetArrayCount(func),
         'local_args': local_args,
       }, *extras)
 
@@ skipping 733 matching lines @@
     self.type_name = 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 func.IsUnsafe():
+      return
     if self.named_type.IsConstant():
       return
     file.Write("  if (!validators_->%s.IsValid(%s)) {\n" %
                (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" %
           (func.original_name, self.name, self.name))
     else:
       file.Write(
@@ skipping 458 matching lines @@
 
     if self.return_arg:
       self.init_args.append(self.return_arg)
 
     self.type_handler.InitFunction(self)
 
   def IsImmediate(self):
     """Returns whether the function is immediate data function or not."""
     return False
 
+  def IsUnsafe(self):
+    """Returns whether the function has service side validation or not."""
+    return self.GetInfo('unsafe', False)
+
   def GetInfo(self, name, default = None):
     """Returns a value from the function info for this function."""
     if name in self.info:
       return self.info[name]
     return default
 
   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)]
     return None
 
   def AddInfo(self, name, value):
     """Adds an info."""
     self.info[name] = value
 
   def IsExtension(self):
     return self.GetInfo('extension') or self.GetInfo('extension_flag')
 
   def IsCoreGLFunction(self):
     return (not self.IsExtension() and
-            not self.GetInfo('pepper_interface'))
+            not self.GetInfo('pepper_interface') and
+            not self.IsUnsafe())
 
   def InPepperInterface(self, interface):
     ext = self.GetInfo('pepper_interface')
     if not interface.GetName():
       return self.IsCoreGLFunction()
     return ext == interface.GetName()
 
   def InAnyPepperExtension(self):
     return self.IsCoreGLFunction() or self.GetInfo('pepper_interface')
 
@@ skipping 1406 matching lines @@
     file.Write("\n")
     file.Close()
     self.generated_cpp_filenames.append(file.filename)
 
   def WriteCommonUtilsImpl(self, filename):
     """Writes the gles2 common utility header."""
     enum_re = re.compile(r'\#define\s+(GL_[a-zA-Z0-9_]+)\s+([0-9A-Fa-fx]+)')
     dict = {}
     for fname in ['third_party/khronos/GLES2/gl2.h',
                   'third_party/khronos/GLES2/gl2ext.h',
+                  'third_party/khronos/GLES3/gl3.h',
                   'gpu/GLES2/gl2chromium.h',
                   'gpu/GLES2/gl2extchromium.h']:
       lines = open(fname).readlines()
       for line in lines:
         m = enum_re.match(line)
         if m:
           name = m.group(1)
           value = m.group(2)
           if len(value) <= 10:
             if not value in dict:
@@ skipping 379 matching lines @@
   Format(gen.generated_cpp_filenames)
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))