Remove unsafe mode to enable es3 api by default for WebGL2 and ES3 context

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 2357 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.
+# es3api:       ES3 API, which is valid in WebGL2 or ES3 context.
 # id_mapping:   A list of resource type names whose client side IDs need to be
-#               mapped to service side IDs.  This is only used for unsafe APIs.
+#               mapped to service side IDs.  This is only used for es3 APIs.
 
 _FUNCTION_INFO = {
   'ActiveTexture': {
     'decoder_func': 'DoActiveTexture',
     'unit_test': False,
     'impl_func': False,
     'client_test': False,
   },
   'ApplyScreenSpaceAntialiasingCHROMIUM': {
     'decoder_func': 'DoApplyScreenSpaceAntialiasingCHROMIUM',
@@ skipping 11 matching lines @@
   'BindBuffer': {
     'type': 'Bind',
     'decoder_func': 'DoBindBuffer',
     'gen_func': 'GenBuffersARB',
   },
   'BindBufferBase': {
     'type': 'Bind',
     'decoder_func': 'DoBindBufferBase',
     'gen_func': 'GenBuffersARB',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'BindBufferRange': {
     'type': 'Bind',
     'decoder_func': 'DoBindBufferRange',
     'gen_func': 'GenBuffersARB',
     'unit_test': False,
     'valid_args': {
       '3': '4',
       '4': '4'
     },
-    'unsafe': True,
+    'es3api': True,
   },
   'BindFramebuffer': {
     'type': 'Bind',
     'decoder_func': 'DoBindFramebuffer',
     'gl_test_func': 'glBindFramebufferEXT',
     'gen_func': 'GenFramebuffersEXT',
     'trace_level': 1,
   },
   'BindRenderbuffer': {
     'type': 'Bind',
     'decoder_func': 'DoBindRenderbuffer',
     'gl_test_func': 'glBindRenderbufferEXT',
     'gen_func': 'GenRenderbuffersEXT',
   },
   'BindSampler': {
     'type': 'Bind',
     'decoder_func': 'DoBindSampler',
-    'unsafe': True,
+    'es3api': True,
   },
   'BindTexture': {
     'type': 'Bind',
     'decoder_func': 'DoBindTexture',
     'gen_func': 'GenTextures',
     # TODO: remove this once client side caching works.
     'client_test': False,
     'unit_test': False,
     'trace_level': 2,
   },
   'BindTransformFeedback': {
     'type': 'Bind',
     'decoder_func': 'DoBindTransformFeedback',
-    'unsafe': True,
+    'es3api': True,
     'unit_test': False,
   },
   'BlitFramebufferCHROMIUM': {
     'decoder_func': 'DoBlitFramebufferCHROMIUM',
     'unit_test': False,
     'extension': 'chromium_framebuffer_multisample',
     'extension_flag': 'chromium_framebuffer_multisample',
     'pepper_interface': 'FramebufferBlit',
     'pepper_name': 'BlitFramebufferEXT',
     'defer_reads': True,
@@ skipping 25 matching lines @@
     'decoder_func': 'DoClear',
     'defer_draws': True,
     'trace_level': 2,
   },
   'ClearBufferiv': {
     'type': 'PUT',
     'use_count_func': True,
     'count': 4,
     'decoder_func': 'DoClearBufferiv',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
     'trace_level': 2,
   },
   'ClearBufferuiv': {
     'type': 'PUT',
     'count': 4,
     'decoder_func': 'DoClearBufferuiv',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
     'trace_level': 2,
   },
   'ClearBufferfv': {
     'type': 'PUT',
     'use_count_func': True,
     'count': 4,
     'decoder_func': 'DoClearBufferfv',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
     'trace_level': 2,
   },
   'ClearBufferfi': {
-    'unsafe': True,
+    'es3api': True,
     'decoder_func': 'DoClearBufferfi',
     'unit_test': False,
     'trace_level': 2,
   },
   'ClearColor': {
     'type': 'StateSet',
     'state': 'ClearColor',
   },
   'ClearDepthf': {
     'type': 'StateSet',
     'state': 'ClearDepthf',
     'decoder_func': 'glClearDepth',
     'gl_test_func': 'glClearDepth',
     'valid_args': {
       '0': '0.5f'
     },
   },
   'ClientWaitSync': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args': 'GLuint sync, GLbitfieldSyncFlushFlags flags, '
                 'GLuint64 timeout, GLenum* result',
-    'unsafe': True,
+    'es3api': True,
     'result': ['GLenum'],
     'trace_level': 2,
   },
   'ColorMask': {
     'type': 'StateSet',
     'state': 'ColorMask',
     'no_gl': True,
     'expectation': False,
   },
   'ConsumeTextureCHROMIUM': {
     'decoder_func': 'DoConsumeTextureCHROMIUM',
     'impl_func': False,
     'type': 'PUT',
     'count': 64,  # GL_MAILBOX_SIZE_CHROMIUM
     'unit_test': False,
     'client_test': False,
     'extension': "CHROMIUM_texture_mailbox",
     'trace_level': 2,
   },
   'CopyBufferSubData': {
     'decoder_func': 'DoCopyBufferSubData',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'CoverageModulationCHROMIUM': {
     'type': 'StateSet',
     'state': 'CoverageModulationCHROMIUM',
     'decoder_func': 'glCoverageModulationNV',
     'extension': 'CHROMIUM_framebuffer_mixed_samples',
     'extension_flag': 'chromium_framebuffer_mixed_samples',
   },
   'CreateAndConsumeTextureCHROMIUM': {
     'type': 'NoCommand',
@@ skipping 42 matching lines @@
   },
   'CopyTexSubImage2D': {
     'decoder_func': 'DoCopyTexSubImage2D',
     'defer_reads': True,
     'trace_level': 1,
   },
   'CompressedTexImage3D': {
     'type': 'Data',
     'data_transfer_methods': ['bucket', 'shm'],
     'decoder_func': 'DoCompressedTexImage3D',
-    'unsafe': True,
+    'es3api': True,
     'trace_level': 1,
   },
   'CompressedTexSubImage3D': {
     'type': 'Data',
     'data_transfer_methods': ['bucket', 'shm'],
     'decoder_func': 'DoCompressedTexSubImage3D',
-    'unsafe': True,
+    'es3api': True,
     'trace_level': 1,
   },
   'CopyTexSubImage3D': {
     'decoder_func': 'DoCopyTexSubImage3D',
     'unit_test': False,
     'defer_reads': True,
-    'unsafe': True,
+    'es3api': True,
     'trace_level': 1,
   },
   'CreateImageCHROMIUM': {
     'type': 'NoCommand',
     'cmd_args':
         'ClientBuffer buffer, GLsizei width, GLsizei height, '
         'GLenum internalformat',
     'result': ['GLuint'],
     'extension': "CHROMIUM_image",
     'trace_level': 1,
@@ skipping 117 matching lines @@
     'type': 'DELn',
     'gl_test_func': 'glDeleteRenderbuffersEXT',
     'resource_type': 'Renderbuffer',
     'resource_types': 'Renderbuffers',
     'trace_level': 2,
   },
   'DeleteSamplers': {
     'type': 'DELn',
     'resource_type': 'Sampler',
     'resource_types': 'Samplers',
-    'unsafe': True,
+    'es3api': True,
   },
   'DeleteShader': { 'type': 'Delete' },
   'DeleteSync': {
     'type': 'Delete',
     'cmd_args': 'GLuint sync',
     'resource_type': 'Sync',
-    'unsafe': True,
+    'es3api': True,
   },
   'DeleteTextures': {
     'type': 'DELn',
     'resource_type': 'Texture',
     'resource_types': 'Textures',
   },
   'DeleteTransformFeedbacks': {
     'type': 'DELn',
     'resource_type': 'TransformFeedback',
     'resource_types': 'TransformFeedbacks',
-    'unsafe': True,
+    'es3api': True,
     'unit_test': False,
   },
   'DepthRangef': {
     'decoder_func': 'DoDepthRangef',
     'gl_test_func': 'glDepthRange',
   },
   'DepthMask': {
     'type': 'StateSet',
     'state': 'DepthMask',
     'no_gl': True,
@@ skipping 20 matching lines @@
     'type': 'Custom',
     'impl_func': False,
     'cmd_args': 'GLenumDrawMode mode, GLsizei count, '
                 'GLenumIndexType type, GLuint index_offset',
     'client_test': False,
     'defer_draws': True,
     'trace_level': 2,
   },
   'DrawRangeElements': {
     'type': 'NoCommand',
-    'unsafe': True,
+    'es3api': True,
   },
   'Enable': {
     'decoder_func': 'DoEnable',
     'impl_func': False,
     'client_test': False,
   },
   'EnableVertexAttribArray': {
     'decoder_func': 'DoEnableVertexAttribArray',
     'impl_func': False,
   },
   'FenceSync': {
     'type': 'Create',
     'client_test': False,
     'decoder_func': 'DoFenceSync',
-    'unsafe': True,
+    'es3api': True,
     'trace_level': 1,
   },
   'Finish': {
     'impl_func': False,
     'client_test': False,
     'decoder_func': 'DoFinish',
     'defer_reads': True,
     'trace_level': 1,
   },
   'Flush': {
     'impl_func': False,
     'decoder_func': 'DoFlush',
     'trace_level': 1,
   },
   'FlushMappedBufferRange': {
     'decoder_func': 'DoFlushMappedBufferRange',
     'trace_level': 1,
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'FramebufferRenderbuffer': {
     'decoder_func': 'DoFramebufferRenderbuffer',
     'gl_test_func': 'glFramebufferRenderbufferEXT',
     'trace_level': 1,
   },
   'FramebufferTexture2D': {
     'decoder_func': 'DoFramebufferTexture2D',
     'gl_test_func': 'glFramebufferTexture2DEXT',
     'unit_test': False,
     'trace_level': 1,
   },
   'FramebufferTexture2DMultisampleEXT': {
     'decoder_func': 'DoFramebufferTexture2DMultisample',
     'gl_test_func': 'glFramebufferTexture2DMultisampleEXT',
     'unit_test': False,
     'extension': 'EXT_multisampled_render_to_texture',
     'extension_flag': 'multisampled_render_to_texture',
     'trace_level': 1,
   },
   'FramebufferTextureLayer': {
     'decoder_func': 'DoFramebufferTextureLayer',
-    'unsafe': True,
+    'es3api': True,
     'unit_test': False,
     'trace_level': 1,
   },
   'GenerateMipmap': {
     'decoder_func': 'DoGenerateMipmap',
     'gl_test_func': 'glGenerateMipmapEXT',
     'trace_level': 1,
   },
   'GenBuffers': {
     'type': 'GENn',
@@ skipping 14 matching lines @@
   'GenRenderbuffers': {
     'type': 'GENn', 'gl_test_func': 'glGenRenderbuffersEXT',
     'resource_type': 'Renderbuffer',
     'resource_types': 'Renderbuffers',
   },
   'GenSamplers': {
     'type': 'GENn',
     'gl_test_func': 'glGenSamplers',
     'resource_type': 'Sampler',
     'resource_types': 'Samplers',
-    'unsafe': True,
+    'es3api': True,
   },
   'GenTextures': {
     'type': 'GENn',
     'gl_test_func': 'glGenTextures',
     'resource_type': 'Texture',
     'resource_types': 'Textures',
   },
   'GenTransformFeedbacks': {
     'type': 'GENn',
     'gl_test_func': 'glGenTransformFeedbacks',
     'resource_type': 'TransformFeedback',
     'resource_types': 'TransformFeedbacks',
-    'unsafe': True,
+    'es3api': True,
   },
   'GetActiveAttrib': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, GLuint index, uint32_t name_bucket_id, '
         'void* result',
     'result': [
       'int32_t success',
       'int32_t size',
       'uint32_t type',
     ],
   },
   'GetActiveUniform': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, GLuint index, uint32_t name_bucket_id, '
         'void* result',
     'result': [
       'int32_t success',
       'int32_t size',
       'uint32_t type',
     ],
   },
   'GetActiveUniformBlockiv': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'result': ['SizedResult<GLint>'],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetActiveUniformBlockName': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, GLuint index, uint32_t name_bucket_id, '
         'void* result',
     'result': ['int32_t'],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetActiveUniformsiv': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, uint32_t indices_bucket_id, GLenum pname, '
         'GLint* params',
     'result': ['SizedResult<GLint>'],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetAttachedShaders': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args': 'GLidProgram program, void* result, uint32_t result_size',
     'result': ['SizedResult<GLuint>'],
   },
   'GetAttribLocation': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, uint32_t name_bucket_id, GLint* location',
     'result': ['GLint'],
     'error_return': -1,
   },
   'GetBufferSubDataAsyncCHROMIUM': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args': 'GLenumBufferTarget target, GLintptrNotNegative offset, '
                 'GLsizeiptr size, '
                 'uint32_t data_shm_id, uint32_t data_shm_offset',
-    'unsafe': True,
+    'es3api': True,
     'impl_func': False,
     'client_test': False,
     'trace_level': 1,
   },
   'GetFragDataIndexEXT': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, uint32_t name_bucket_id, GLint* index',
     'result': ['GLint'],
     'error_return': -1,
     'extension': 'EXT_blend_func_extended',
     'extension_flag': 'ext_blend_func_extended',
   },
   'GetFragDataLocation': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, uint32_t name_bucket_id, GLint* location',
     'result': ['GLint'],
     'error_return': -1,
-    'unsafe': True,
+    'es3api': True,
   },
   'GetBooleanv': {
     'type': 'GETn',
     'result': ['SizedResult<GLboolean>'],
     'decoder_func': 'DoGetBooleanv',
     'gl_test_func': 'glGetIntegerv',
   },
   'GetBufferParameteri64v': {
     'type': 'GETn',
     'result': ['SizedResult<GLint64>'],
     'decoder_func': 'DoGetBufferParameteri64v',
     'expectation': False,
     'shadowed': True,
-    'unsafe': True,
+    'es3api': True,
   },
   'GetBufferParameteriv': {
     'type': 'GETn',
     'result': ['SizedResult<GLint>'],
     'decoder_func': 'DoGetBufferParameteriv',
     'expectation': False,
     'shadowed': True,
   },
   'GetError': {
     'type': 'Is',
@@ skipping 18 matching lines @@
     'type': 'NoCommand',
     'extension': True,
     'trace_level': 1,
   },
   'GetInteger64v': {
     'type': 'GETn',
     'result': ['SizedResult<GLint64>'],
     'client_test': False,
     'decoder_func': 'DoGetInteger64v',
     'gl_test_func': 'glGetIntegerv',
-    'unsafe': True
+    'es3api': True
   },
   'GetIntegerv': {
     'type': 'GETn',
     'result': ['SizedResult<GLint>'],
     'decoder_func': 'DoGetIntegerv',
     'client_test': False,
   },
   'GetInteger64i_v': {
     'type': 'GETn',
     'result': ['SizedResult<GLint64>'],
     'decoder_func': 'DoGetInteger64i_v',
     'shadowed': True,
     'client_test': False,
     'unit_test': False,
-    'unsafe': True
+    'es3api': True
   },
   'GetIntegeri_v': {
     'type': 'GETn',
     'result': ['SizedResult<GLint>'],
     'decoder_func': 'DoGetIntegeri_v',
     'shadowed': True,
     'client_test': False,
     'unit_test': False,
-    'unsafe': True
+    'es3api': True
   },
   'GetInternalformativ': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'result': ['SizedResult<GLint>'],
     'cmd_args':
         'GLenumRenderBufferTarget target, GLenumRenderBufferFormat format, '
         'GLenumInternalFormatParameter pname, GLint* params',
-    'unsafe': True,
+    'es3api': True,
   },
   'GetMaxValueInBufferCHROMIUM': {
     'type': 'Is',
     'decoder_func': 'DoGetMaxValueInBufferCHROMIUM',
     'result': ['GLuint'],
     'unit_test': False,
     'client_test': False,
     'extension': True,
     'impl_func': False,
   },
@@ skipping 22 matching lines @@
   'GetRenderbufferParameteriv': {
     'type': 'GETn',
     'decoder_func': 'DoGetRenderbufferParameteriv',
     'gl_test_func': 'glGetRenderbufferParameterivEXT',
     'result': ['SizedResult<GLint>'],
   },
   'GetSamplerParameterfv': {
     'type': 'GETn',
     'decoder_func': 'DoGetSamplerParameterfv',
     'result': ['SizedResult<GLfloat>'],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetSamplerParameteriv': {
     'type': 'GETn',
     'decoder_func': 'DoGetSamplerParameteriv',
     'result': ['SizedResult<GLint>'],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetShaderiv': {
     'type': 'GETn',
     'decoder_func': 'DoGetShaderiv',
     'result': ['SizedResult<GLint>'],
   },
   'GetShaderInfoLog': {
     'type': 'STRn',
     'get_len_func': 'glGetShaderiv',
     'get_len_enum': 'GL_INFO_LOG_LENGTH',
@@ skipping 19 matching lines @@
     'unit_test': False,
     'client_test': False,
   },
   'GetString': {
     'type': 'Custom',
     'client_test': False,
     'cmd_args': 'GLenumStringType name, uint32_t bucket_id',
   },
   'GetStringi': {
     'type': 'NoCommand',
-    'unsafe': True,
+    'es3api': True,
   },
   'GetSynciv': {
     'type': 'GETn',
     'cmd_args': 'GLuint sync, GLenumSyncParameter pname, void* values',
     'result': ['SizedResult<GLint>'],
     'id_mapping': ['Sync'],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetTexParameterfv': {
     'type': 'GETn',
     'decoder_func': 'DoGetTexParameterfv',
     'result': ['SizedResult<GLfloat>']
   },
   'GetTexParameteriv': {
     'type': 'GETn',
     'decoder_func': 'DoGetTexParameteriv',
     'result': ['SizedResult<GLint>']
   },
   'GetTranslatedShaderSourceANGLE': {
     'type': 'STRn',
     'get_len_func': 'DoGetShaderiv',
     'get_len_enum': 'GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE',
     'unit_test': False,
     'extension': True,
   },
   'GetUniformBlockIndex': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, uint32_t name_bucket_id, GLuint* index',
     'result': ['GLuint'],
     'error_return': 'GL_INVALID_INDEX',
-    'unsafe': True,
+    'es3api': True,
   },
   'GetUniformBlocksCHROMIUM': {
     'type': 'Custom',
     'impl_func': False,
     'extension': True,
     'client_test': False,
     'cmd_args': 'GLidProgram program, uint32_t bucket_id',
     'result': ['uint32_t'],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetUniformsES3CHROMIUM': {
     'type': 'Custom',
     'impl_func': False,
     'extension': True,
     'client_test': False,
     'cmd_args': 'GLidProgram program, uint32_t bucket_id',
     'result': ['uint32_t'],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetTransformFeedbackVarying': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, GLuint index, uint32_t name_bucket_id, '
         'void* result',
     'result': [
       'int32_t success',
       'int32_t size',
       'uint32_t type',
     ],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetTransformFeedbackVaryingsCHROMIUM': {
     'type': 'Custom',
     'impl_func': False,
     'extension': True,
     'client_test': False,
     'cmd_args': 'GLidProgram program, uint32_t bucket_id',
     'result': ['uint32_t'],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetUniformfv': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'result': ['SizedResult<GLfloat>'],
   },
   'GetUniformiv': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'result': ['SizedResult<GLint>'],
   },
   'GetUniformuiv': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'result': ['SizedResult<GLuint>'],
-    'unsafe': True,
+    'es3api': True,
   },
   'GetUniformIndices': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'result': ['SizedResult<GLuint>'],
     'cmd_args': 'GLidProgram program, uint32_t names_bucket_id, '
                 'GLuint* indices',
-    'unsafe': True,
+    'es3api': True,
   },
   'GetUniformLocation': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, uint32_t name_bucket_id, GLint* location',
     'result': ['GLint'],
     'error_return': -1, # http://www.opengl.org/sdk/docs/man/xhtml/glGetUniformLocation.xml
   },
   'GetVertexAttribfv': {
@@ skipping 12 matching lines @@
     'expectation': False,
     'client_test': False,
   },
   'GetVertexAttribIiv': {
     'type': 'GETn',
     'result': ['SizedResult<GLint>'],
     'impl_func': False,
     'decoder_func': 'DoGetVertexAttribIiv',
     'expectation': False,
     'client_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'GetVertexAttribIuiv': {
     'type': 'GETn',
     'result': ['SizedResult<GLuint>'],
     'impl_func': False,
     'decoder_func': 'DoGetVertexAttribIuiv',
     'expectation': False,
     'client_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'GetVertexAttribPointerv': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'result': ['SizedResult<GLuint>'],
     'client_test': False,
   },
   'InvalidateFramebuffer': {
     'type': 'PUTn',
     'count': 1,
     'decoder_func': 'DoInvalidateFramebuffer',
     'client_test': False,
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'InvalidateSubFramebuffer': {
     'type': 'PUTn',
     'count': 1,
     'decoder_func': 'DoInvalidateSubFramebuffer',
     'client_test': False,
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'IsBuffer': {
     'type': 'Is',
     'decoder_func': 'DoIsBuffer',
     'expectation': False,
   },
   'IsEnabled': {
     'type': 'Is',
     'decoder_func': 'DoIsEnabled',
     'client_test': False,
@@ skipping 17 matching lines @@
   },
   'IsShader': {
     'type': 'Is',
     'decoder_func': 'DoIsShader',
     'expectation': False,
   },
   'IsSampler': {
     'type': 'Is',
     'decoder_func': 'DoIsSampler',
     'expectation': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'IsSync': {
     'type': 'Is',
     'id_mapping': [ 'Sync' ],
     'cmd_args': 'GLuint sync',
     'decoder_func': 'DoIsSync',
     'expectation': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'IsTexture': {
     'type': 'Is',
     'decoder_func': 'DoIsTexture',
     'expectation': False,
   },
   'IsTransformFeedback': {
     'type': 'Is',
     'decoder_func': 'DoIsTransformFeedback',
     'expectation': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'GetLastFlushIdCHROMIUM': {
     'type': 'NoCommand',
     'impl_func': False,
     'result': ['GLuint'],
     'extension': True,
   },
   'LinkProgram': {
     'decoder_func': 'DoLinkProgram',
     'impl_func':  False,
@@ skipping 16 matching lines @@
     'pepper_interface': 'ChromiumMapSub',
     'trace_level': 1,
   },
   'MapBufferRange': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args': 'GLenumBufferTarget target, GLintptrNotNegative offset, '
                 'GLsizeiptr size, GLbitfieldMapBufferAccess access, '
                 'uint32_t data_shm_id, uint32_t data_shm_offset, '
                 'uint32_t result_shm_id, uint32_t result_shm_offset',
-    'unsafe': True,
+    'es3api': True,
     'result': ['uint32_t'],
     'trace_level': 1,
   },
   'PauseTransformFeedback': {
     'decoder_func': 'DoPauseTransformFeedback',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'PixelStorei': {
     'type': 'Custom',
     'impl_func': False,
   },
   'PostSubBufferCHROMIUM': {
     'type': 'Custom',
     'impl_func': False,
     'client_test': False,
     'extension': True,
@@ skipping 40 matching lines @@
     'cmd_comment':
         '// GL_EXT_multisampled_render_to_texture\n',
     'decoder_func': 'DoRenderbufferStorageMultisampleEXT',
     'gl_test_func': 'glRenderbufferStorageMultisampleEXT',
     'unit_test': False,
     'extension': 'EXT_multisampled_render_to_texture',
     'extension_flag': 'multisampled_render_to_texture',
     'trace_level': 1,
   },
   'ReadBuffer': {
-    'unsafe': True,
+    'es3api': True,
     'decoder_func': 'DoReadBuffer',
     'trace_level': 1,
   },
   'ReadPixels': {
     'cmd_comment':
         '// ReadPixels has the result separated from the pixel buffer so that\n'
         '// it is easier to specify the result going to some specific place\n'
         '// that exactly fits the rectangle of pixels.\n',
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
@@ skipping 14 matching lines @@
     'defer_reads': True,
     'trace_level': 1,
   },
   'ReleaseShaderCompiler': {
     'decoder_func': 'DoReleaseShaderCompiler',
     'unit_test': False,
   },
   'ResumeTransformFeedback': {
     'decoder_func': 'DoResumeTransformFeedback',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'SamplerParameterf': {
     'valid_args': {
       '2': 'GL_NEAREST'
     },
     'decoder_func': 'DoSamplerParameterf',
-    'unsafe': True,
+    'es3api': True,
   },
   'SamplerParameterfv': {
     'type': 'PUT',
     'data_value': 'GL_NEAREST',
     'count': 1,
     'gl_test_func': 'glSamplerParameterf',
     'decoder_func': 'DoSamplerParameterfv',
     'first_element_only': True,
-    'unsafe': True,
+    'es3api': True,
   },
   'SamplerParameteri': {
     'valid_args': {
       '2': 'GL_NEAREST'
     },
     'decoder_func': 'DoSamplerParameteri',
-    'unsafe': True,
+    'es3api': True,
   },
   'SamplerParameteriv': {
     'type': 'PUT',
     'data_value': 'GL_NEAREST',
     'count': 1,
     'gl_test_func': 'glSamplerParameteri',
     'decoder_func': 'DoSamplerParameteriv',
     'first_element_only': True,
-    'unsafe': True,
+    'es3api': True,
   },
   'ShaderBinary': {
     'type': 'Custom',
     'client_test': False,
   },
   'ShaderSource': {
     'type': 'PUTSTR',
     'decoder_func': 'DoShaderSource',
     'expectation': False,
     'data_transfer_methods': ['bucket'],
@@ skipping 41 matching lines @@
     'impl_func': False,
     'data_transfer_methods': ['shm'],
     'client_test': False,
     'trace_level': 2,
   },
   'TexImage3D': {
     'type': 'Custom',
     'impl_func': False,
     'data_transfer_methods': ['shm'],
     'client_test': False,
-    'unsafe': True,
+    'es3api': True,
     'trace_level': 2,
   },
   'TexParameterf': {
     'decoder_func': 'DoTexParameterf',
     'valid_args': {
       '2': 'GL_NEAREST'
     },
   },
   'TexParameteri': {
     'decoder_func': 'DoTexParameteri',
@@ skipping 11 matching lines @@
   },
   'TexParameteriv': {
     'type': 'PUT',
     'data_value': 'GL_NEAREST',
     'count': 1,
     'decoder_func': 'DoTexParameteriv',
     'gl_test_func': 'glTexParameteri',
     'first_element_only': True,
   },
   'TexStorage3D': {
-    'unsafe': True,
+    'es3api': True,
     'unit_test': False,
     'decoder_func': 'DoTexStorage3D',
     'trace_level': 2,
   },
   'TexSubImage2D': {
     'type': 'Custom',
     'impl_func': False,
     'data_transfer_methods': ['shm'],
     'client_test': False,
     'trace_level': 2,
     'cmd_args': 'GLenumTextureTarget target, GLint level, '
                 'GLint xoffset, GLint yoffset, '
                 'GLsizei width, GLsizei height, '
                 'GLenumTextureFormat format, GLenumPixelType type, '
                 'const void* pixels, GLboolean internal'
   },
   'TexSubImage3D': {
     'type': 'Custom',
     'impl_func': False,
     'data_transfer_methods': ['shm'],
     'client_test': False,
     'trace_level': 2,
     'cmd_args': 'GLenumTextureTarget target, GLint level, '
                 'GLint xoffset, GLint yoffset, GLint zoffset, '
                 'GLsizei width, GLsizei height, GLsizei depth, '
                 'GLenumTextureFormat format, GLenumPixelType type, '
                 'const void* pixels, GLboolean internal',
-    'unsafe': True,
+    'es3api': True,
   },
   'TransformFeedbackVaryings': {
     'type': 'PUTSTR',
     'data_transfer_methods': ['bucket'],
     'decoder_func': 'DoTransformFeedbackVaryings',
     'cmd_args':
         'GLuint program, const char** varyings, GLenum buffermode',
     'expectation': False,
-    'unsafe': True,
+    'es3api': True,
   },
   '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,
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'Uniform1uiv': {
     'type': 'PUTn',
     'count': 1,
     'decoder_func': 'DoUniform1uiv',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': 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,
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'Uniform2uiv': {
     'type': 'PUTn',
     'count': 2,
     'decoder_func': 'DoUniform2uiv',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': 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,
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'Uniform3uiv': {
     'type': 'PUTn',
     'count': 3,
     'decoder_func': 'DoUniform3uiv',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': 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,
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'Uniform4uiv': {
     'type': 'PUTn',
     'count': 4,
     'decoder_func': 'DoUniform4uiv',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'UniformMatrix2fv': {
     'type': 'PUTn',
     'count': 4,
     'decoder_func': 'DoUniformMatrix2fv',
     'unit_test': False,
   },
   'UniformMatrix2x3fv': {
     'type': 'PUTn',
     'count': 6,
     'decoder_func': 'DoUniformMatrix2x3fv',
-    'unsafe': True,
+    'es3api': True,
   },
   'UniformMatrix2x4fv': {
     'type': 'PUTn',
     'count': 8,
     'decoder_func': 'DoUniformMatrix2x4fv',
-    'unsafe': True,
+    'es3api': True,
   },
   'UniformMatrix3fv': {
     'type': 'PUTn',
     'count': 9,
     'decoder_func': 'DoUniformMatrix3fv',
     'unit_test': False,
   },
   'UniformMatrix3x2fv': {
     'type': 'PUTn',
     'count': 6,
     'decoder_func': 'DoUniformMatrix3x2fv',
-    'unsafe': True,
+    'es3api': True,
   },
   'UniformMatrix3x4fv': {
     'type': 'PUTn',
     'count': 12,
     'decoder_func': 'DoUniformMatrix3x4fv',
-    'unsafe': True,
+    'es3api': True,
   },
   'UniformMatrix4fv': {
     'type': 'PUTn',
     'count': 16,
     'decoder_func': 'DoUniformMatrix4fv',
     'unit_test': False,
   },
   'UniformMatrix4fvStreamTextureMatrixCHROMIUM': {
     'type': 'PUT',
     'count': 16,
     'decoder_func': 'DoUniformMatrix4fvStreamTextureMatrixCHROMIUM',
     'extension': "CHROMIUM_uniform_stream_texture_matrix",
     'unit_test': False,
     'client_test': False,
   },
   'UniformMatrix4x2fv': {
     'type': 'PUTn',
     'count': 8,
     'decoder_func': 'DoUniformMatrix4x2fv',
-    'unsafe': True,
+    'es3api': True,
   },
   'UniformMatrix4x3fv': {
     'type': 'PUTn',
     'count': 12,
     'decoder_func': 'DoUniformMatrix4x3fv',
-    'unsafe': True,
+    'es3api': True,
   },
   'UniformBlockBinding': {
     'type': 'Custom',
     'impl_func': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'UnmapBufferCHROMIUM': {
     'type': 'NoCommand',
     'extension': "CHROMIUM_pixel_transfer_buffer_object",
     'trace_level': 1,
   },
   'UnmapBufferSubDataCHROMIUM': {
     'type': 'NoCommand',
     'extension': 'CHROMIUM_map_sub',
     'pepper_interface': 'ChromiumMapSub',
     'trace_level': 1,
   },
   'UnmapBuffer': {
     'type': 'Custom',
-    'unsafe': True,
+    'es3api': True,
     'trace_level': 1,
   },
   'UnmapTexSubImage2DCHROMIUM': {
     'type': 'NoCommand',
     'extension': "CHROMIUM_sub_image",
     'pepper_interface': 'ChromiumMapSub',
     'trace_level': 1,
   },
   'UseProgram': {
     'type': 'Bind',
@@ skipping 18 matching lines @@
     'count': 3,
     'decoder_func': 'DoVertexAttrib3fv',
   },
   'VertexAttrib4f': {'decoder_func': 'DoVertexAttrib4f'},
   'VertexAttrib4fv': {
     'type': 'PUT',
     'count': 4,
     'decoder_func': 'DoVertexAttrib4fv',
   },
   'VertexAttribI4i': {
-    'unsafe': True,
+    'es3api': True,
     'decoder_func': 'DoVertexAttribI4i',
   },
   'VertexAttribI4iv': {
     'type': 'PUT',
     'count': 4,
-    'unsafe': True,
+    'es3api': True,
     'decoder_func': 'DoVertexAttribI4iv',
   },
   'VertexAttribI4ui': {
-    'unsafe': True,
+    'es3api': True,
     'decoder_func': 'DoVertexAttribI4ui',
   },
   'VertexAttribI4uiv': {
     'type': 'PUT',
     'count': 4,
-    'unsafe': True,
+    'es3api': True,
     'decoder_func': 'DoVertexAttribI4uiv',
   },
   'VertexAttribIPointer': {
     'type': 'Custom',
     'impl_func': False,
     'cmd_args': 'GLuint indx, GLintVertexAttribSize size, '
                 'GLenumVertexAttribIType type, GLsizei stride, '
                 'GLuint offset',
     'client_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'VertexAttribPointer': {
     'type': 'Custom',
     'impl_func': False,
     'cmd_args': 'GLuint indx, GLintVertexAttribSize size, '
                 'GLenumVertexAttribType type, GLboolean normalized, '
                 'GLsizei stride, GLuint offset',
     'client_test': False,
   },
   'WaitSync': {
     'type': 'Custom',
     'cmd_args': 'GLuint sync, GLbitfieldSyncFlushFlags flags, '
                 'GLuint64 timeout',
     'impl_func': False,
     'client_test': False,
-    'unsafe': True,
+    'es3api': True,
     'trace_level': 1,
   },
   'Scissor': {
     'type': 'StateSet',
     'state': 'Scissor',
   },
   'Viewport': {
     'decoder_func': 'DoViewport',
   },
   'ResizeCHROMIUM': {
@@ skipping 108 matching lines @@
     'impl_func': False,
     'cmd_args': 'GLenumQueryTarget target, GLidQuery id, void* sync_data',
     'data_transfer_methods': ['shm'],
     'gl_test_func': 'glBeginQuery',
     'pepper_interface': 'Query',
     'extension': "occlusion_query_EXT",
   },
   'BeginTransformFeedback': {
     'decoder_func': 'DoBeginTransformFeedback',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'EndQueryEXT': {
     'type': 'Custom',
     'impl_func': False,
     'cmd_args': 'GLenumQueryTarget target, GLuint submit_count',
     'gl_test_func': 'glEndnQuery',
     'client_test': False,
     'pepper_interface': 'Query',
     'extension': "occlusion_query_EXT",
   },
   'EndTransformFeedback': {
     'decoder_func': 'DoEndTransformFeedback',
     'unit_test': False,
-    'unsafe': True,
+    'es3api': True,
   },
   'FlushDriverCachesCHROMIUM': {
     'decoder_func': 'DoFlushDriverCachesCHROMIUM',
     'unit_test': False,
     'extension': True,
     'trace_level': 1,
   },
   'GetQueryivEXT': {
     'type': 'NoCommand',
     'gl_test_func': 'glGetQueryiv',
@@ skipping 619 matching lines @@
         f.write((check.strip() + "\n") % {
               'cmd_name': func.name,
               'field_name': name,
               'offset': offset,
             })
         offset += _SIZE_OF_UINT32
     f.write("\n")
 
   def WriteHandlerImplementation(self, func, f):
     """Writes the handler implementation for this command."""
-    if func.IsUnsafe() and func.GetInfo('id_mapping'):
+    if func.IsES3API() and func.GetInfo('id_mapping'):
       code_no_gen = """  if (!group_->Get%(type)sServiceId(
         %(var)s, &%(service_var)s)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "%(func)s", "invalid %(var)s id");
     return error::kNoError;
   }
 """
       code_gen = """  if (!group_->Get%(type)sServiceId(
         %(var)s, &%(service_var)s)) {
     if (!group_->bind_generates_resource()) {
       LOCAL_SET_GL_ERROR(
@@ skipping 78 matching lines @@
   def WriteImmediateFormatTest(self, func, f):
     """Writes a format test for an immediate version of a command."""
     pass
 
   def WriteGetDataSizeCode(self, func, f):
     """Writes the code to set data_size used in validation"""
     pass
 
   def __WriteIdMapping(self, func, f):
     """Writes client side / service side ID mapping."""
-    if not func.IsUnsafe() or not func.GetInfo('id_mapping'):
+    if not func.IsES3API() or not func.GetInfo('id_mapping'):
       return
     for id_type in func.GetInfo('id_mapping'):
       f.write("  group_->Get%sServiceId(%s, &%s);\n" %
                  (id_type, id_type.lower(), id_type.lower()))
 
   def WriteImmediateHandlerImplementation (self, func, f):
     """Writes the handler impl for the immediate version of a command."""
     self.__WriteIdMapping(func, f)
     f.write("  %s(%s);\n" %
                (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
 
   def WriteBucketHandlerImplementation (self, func, f):
     """Writes the handler impl for the bucket version of a command."""
     self.__WriteIdMapping(func, f)
     f.write("  %s(%s);\n" %
                (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
 
   def WriteServiceHandlerFunctionHeader(self, func, f):
     """Writes function header for service implementation handlers."""
     f.write("""error::Error GLES2DecoderImpl::Handle%(name)s(
         uint32_t immediate_data_size, const volatile void* cmd_data) {
       """ % {'name': func.name})
-    if func.IsUnsafe():
-      f.write("""if (!unsafe_es3_apis_enabled())
+    if func.IsES3API():
+      f.write("""if (!es3_apis_enabled())
           return error::kUnknownCommand;
         """)
     if func.GetCmdArgs():
       f.write("""const volatile gles2::cmds::%(name)s& c =
             *static_cast<const volatile gles2::cmds::%(name)s*>(cmd_data);
         """ % {'name': func.name})
 
   def WriteServiceHandlerArgGetCode(self, func, f):
     """Writes the argument unpack code for service handlers."""
     if len(func.GetOriginalArgs()) > 0:
@@ skipping 145 matching lines @@
     for extra in extras:
       vars.update(extra)
     old_test = ""
     while (old_test != test):
       old_test = test
       test = test % vars
     f.write(test % vars)
 
   def WriteInvalidUnitTest(self, func, f, test, *extras):
     """Writes an invalid unit test for the service implementation."""
-    if func.IsUnsafe():
+    if func.IsES3API():
       return
     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 = []
@@ skipping 48 matching lines @@
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   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);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_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, f, valid_test, *extras)
 
-    if not func.IsUnsafe():
+    if not func.IsES3API():
       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, f, invalid_test, *extras)
@@ skipping 627 matching lines @@
   def WriteServiceUnitTest(self, func, f, *extras):
     """Overrriden from TypeHandler."""
 
     if len(func.GetOriginalArgs()) == 1:
       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);"""
-      if func.IsUnsafe():
+      if func.IsES3API():
         valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_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());
 }
 """
       if func.GetInfo("gen_func"):
@@ skipping 14 matching lines @@
           'resource_type': func.GetOriginalArgs()[0].resource_type,
           'gl_gen_func_name': func.GetInfo("gen_func"),
       }, *extras)
     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);"""
-      if func.IsUnsafe():
+      if func.IsES3API():
         valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_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());
 }
 """
       if func.GetInfo("gen_func"):
         valid_test += """
 TEST_P(%(test_name)s, %(name)sValidArgsNewId) {
   EXPECT_CALL(*gl_,
               %(gl_func_name)s(%(gl_args_with_new_id)s));
   EXPECT_CALL(*gl_, %(gl_gen_func_name)s(1, _))
      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args_with_new_id)s);"""
-        if func.IsUnsafe():
+        if func.IsES3API():
           valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(Get%(resource_type)s(kNewClientId) != NULL);
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_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());
   EXPECT_TRUE(Get%(resource_type)s(kNewClientId) != NULL);
 }
 """
@@ skipping 65 matching lines @@
     code = """
 TEST_F(GLES2ImplementationTest, %(name)s) {
   struct Cmds {
     cmds::%(name)s cmd;
   };
   Cmds expected;
   expected.cmd.Init(%(cmd_args)s);
 
   gl_->%(name)s(%(args)s);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));"""
-    if not func.IsUnsafe():
+    if not func.IsES3API():
       code += """
   ClearCommands();
   gl_->%(name)s(%(args)s);
   EXPECT_TRUE(NoCommandsWritten());"""
     code += """
 }
 """
     cmd_arg_strings = [
       arg.GetValidClientSideCmdArg(func) for arg in func.GetCmdArgs()
     ]
@@ skipping 118 matching lines @@
 
   def WriteImmediateServiceUnitTest(self, func, f, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   cmds::%(name)s* cmd = GetImmediateAs<cmds::%(name)s>();
   GLuint temp = kNewClientId;
   SpecializedSetup<cmds::%(name)s, 0>(true);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_es3_apis_enabled(true);"""
     valid_test += """
   cmd->Init(1, &temp);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(*cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(Get%(resource_name)s(kNewClientId) != NULL);
 }
 """
     self.WriteValidUnitTest(func, f, valid_test, {
         'resource_name': func.GetInfo('resource_type'),
       }, *extras)
     duplicate_id_test = """
 TEST_P(%(test_name)s, %(name)sDuplicateOrNullIds) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
   cmds::%(name)s* cmd = GetImmediateAs<cmds::%(name)s>();
   GLuint temp[3] = {kNewClientId, kNewClientId + 1, kNewClientId};
   SpecializedSetup<cmds::%(name)s, 1>(true);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       duplicate_id_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_es3_apis_enabled(true);"""
     duplicate_id_test += """
   cmd->Init(3, temp);
   EXPECT_EQ(error::kInvalidArguments,
             ExecuteImmediateCmd(*cmd, sizeof(temp)));
   EXPECT_TRUE(Get%(resource_name)s(kNewClientId) == NULL);
   EXPECT_TRUE(Get%(resource_name)s(kNewClientId + 1) == NULL);
   GLuint null_id[2] = {kNewClientId, 0};
   cmd->Init(2, null_id);
   EXPECT_EQ(error::kInvalidArguments,
             ExecuteImmediateCmd(*cmd, sizeof(temp)));
   EXPECT_TRUE(Get%(resource_name)s(kNewClientId) == NULL);
 }
     """
     self.WriteValidUnitTest(func, f, duplicate_id_test, {
         'resource_name': func.GetInfo('resource_type'),
       }, *extras)
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
   cmds::%(name)s* cmd = GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmd->Init(1, &client_%(resource_name)s_id_);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       invalid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kInvalidArguments,
             ExecuteImmediateCmd(*cmd, sizeof(&client_%(resource_name)s_id_)));
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
 }
 """
     else:
       invalid_test += """
   EXPECT_EQ(error::kInvalidArguments,
             ExecuteImmediateCmd(*cmd, sizeof(&client_%(resource_name)s_id_)));
 }
 """
     self.WriteValidUnitTest(func, f, invalid_test, {
           'resource_name': func.GetInfo('resource_type').lower(),
@@ skipping 106 matching lines @@
 
   def WriteServiceUnitTest(self, func, f, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   %(id_type_cast)sEXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s))
       .WillOnce(Return(%(const_service_id)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s%(comma)skNewClientId);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_es3_apis_enabled(true);"""
     valid_test += """
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
   %(return_type)s service_id = 0;
   EXPECT_TRUE(Get%(resource_type)sServiceId(kNewClientId, &service_id));
   EXPECT_EQ(%(const_service_id)s, service_id);
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 """
     else:
       valid_test += """
   EXPECT_TRUE(Get%(resource_type)s(kNewClientId));
 }
 """
     comma = ""
     cmd_arg_count = 0
@@ skipping 24 matching lines @@
   cmd.Init(%(args)s%(comma)skNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, f, invalid_test, {
           'comma': comma,
         }, *extras)
 
   def WriteHandlerImplementation (self, func, f):
     """Overrriden from TypeHandler."""
-    if func.IsUnsafe():
+    if func.IsES3API():
       code = """  uint32_t client_id = c.client_id;
   %(return_type)s service_id = 0;
   if (group_->Get%(resource_name)sServiceId(client_id, &service_id)) {
     return error::kInvalidArguments;
   }
   service_id = %(gl_func_name)s(%(gl_args)s);
   if (service_id) {
     group_->Add%(resource_name)sId(client_id, service_id);
   }
 """
@@ skipping 45 matching lines @@
 
   def WritePassthroughServiceImplementation(self, func, f):
     """Overrriden from TypeHandler."""
     pass
 
 class DeleteHandler(TypeHandler):
   """Handler for glDelete___ single resource type functions."""
 
   def WriteServiceImplementation(self, func, f):
     """Overrriden from TypeHandler."""
-    if func.IsUnsafe():
+    if func.IsES3API():
       TypeHandler.WriteServiceImplementation(self, func, f)
     # HandleDeleteShader and HandleDeleteProgram are manually written.
     pass
 
   def WriteGLES2Implementation(self, func, f):
     """Overrriden from TypeHandler."""
     f.write("%s GLES2Implementation::%s(%s) {\n" %
                (func.return_type, func.original_name,
                 func.MakeTypedOriginalArgString("")))
     f.write("  GPU_CLIENT_SINGLE_THREAD_CHECK();\n")
@@ skipping 86 matching lines @@
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(1, Pointee(kService%(upper_resource_name)sId)))
       .Times(1);
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmd.Init(1, &client_%(resource_name)s_id_);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_es3_apis_enabled(true);"""
     valid_test += """
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(client_%(resource_name)s_id_)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(
       Get%(upper_resource_name)s(client_%(resource_name)s_id_) == NULL);
 }
 """
     self.WriteValidUnitTest(func, f, valid_test, {
           'resource_name': func.GetInfo('resource_type').lower(),
           'upper_resource_name': func.GetInfo('resource_type'),
         }, *extras)
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(false);
   GLuint temp = kInvalidClientId;
   cmd.Init(1, &temp);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       invalid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 """
     else:
       invalid_test += """
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 """
@@ skipping 364 matching lines @@
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillRepeatedly(Return(GL_NO_ERROR));
   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(%(cmd_args)s);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_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());"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));"""
     valid_test += """
 }
 """
     gl_arg_strings = []
     cmd_arg_strings = []
     valid_pname = ''
     for arg in func.GetOriginalArgs()[:-1]:
       if arg.name == 'length':
         gl_arg_value = 'nullptr'
@@ skipping 20 matching lines @@
       gl_arg_strings.append("result->GetData()")
     cmd_arg_strings.append("shared_memory_id_")
     cmd_arg_strings.append("shared_memory_offset_")
 
     self.WriteValidUnitTest(func, f, valid_test, {
         'local_gl_args': ", ".join(gl_arg_strings),
         'cmd_args': ", ".join(cmd_arg_strings),
         'valid_pname': valid_pname,
       }, *extras)
 
-    if not func.IsUnsafe():
+    if not func.IsES3API():
       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));
@@ skipping 70 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_client_args)s, &temp[0]);
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(%(gl_args)s, %(expectation)s));"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_es3_apis_enabled(true);"""
     valid_test += """
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand,
             ExecuteImmediateCmd(cmd, sizeof(temp)));"""
     valid_test += """
 }
 """
     gl_client_arg_strings = [
       arg.GetValidArg(func) for arg in func.GetOriginalArgs()[0:-1]
     ]
     gl_arg_strings = [
       arg.GetValidGLArg(func) for arg in func.GetOriginalArgs()[0:-1]
@@ skipping 12 matching lines @@
       'data_value': func.GetInfo('data_value') or '0',
       'gl_client_args': ", ".join(gl_client_arg_strings),
       'gl_args': ", ".join(gl_arg_strings),
       'gl_any_args': ", ".join(gl_any_strings),
     }
     self.WriteValidUnitTest(func, f, valid_test, extra, *extras)
 
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       invalid_test += """
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_any_args)s, _)).Times(1);
 """
     else:
       invalid_test += """
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_any_args)s, _)).Times(0);
 """
     invalid_test += """
   SpecializedSetup<cmds::%(name)s, 0>(false);
   %(data_type)s temp[%(data_count)s] = { %(data_value)s, };
   cmd.Init(%(all_but_last_args)s, &temp[0]);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       invalid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::%(parse_result)s,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
 }
 """
     else:
       invalid_test += """
   EXPECT_EQ(error::%(parse_result)s,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   %(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, f, invalid_test, extra, *extras)
@@ skipping 253 matching lines @@
     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 * 2] = { 0, };
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(%(gl_args)s,
           PointsToArray(temp, %(data_count)s)));
   cmd.Init(%(args)s, &temp[0]);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_es3_apis_enabled(true);"""
     valid_test += """
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_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))
@@ skipping 505 matching lines @@
     test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = { kSource0 };
   const char kValidStrEnd = 0;
   SetBucketAsCStrings(kBucketId, 1, kSource, 1, kValidStrEnd);
   cmds::%(name)s cmd;
   cmd.Init(%(cmd_args)s);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       test += """
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 """
     test += """
 }
 """
     self.WriteValidUnitTest(func, f, test, {
         'cmd_args': ", ".join(cmd_args),
         'gl_args': ", ".join(gl_args),
       }, *extras)
 
     test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = { kSource0 };
   const char kValidStrEnd = 0;
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   cmds::%(name)s cmd;
   // Test no bucket.
   cmd.Init(%(cmd_args)s);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   // Test invalid client.
   SetBucketAsCStrings(kBucketId, 1, kSource, 1, kValidStrEnd);
   cmd.Init(%(cmd_args_with_invalid_id)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 """
     self.WriteValidUnitTest(func, f, test, {
         'cmd_args': ", ".join(cmd_args),
         'cmd_args_with_invalid_id': ", ".join(cmd_args_with_invalid_id),
       }, *extras)
 
     test = """
 TEST_P(%(test_name)s, %(name)sInvalidHeader) {
   const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = { kSource0 };
   const char kValidStrEnd = 0;
   const GLsizei kCount = static_cast<GLsizei>(arraysize(kSource));
   const GLsizei kTests[] = {
       kCount + 1,
       0,
       std::numeric_limits<GLsizei>::max(),
       -1,
   };
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
     SetBucketAsCStrings(kBucketId, 1, kSource, kTests[ii], kValidStrEnd);
     cmds::%(name)s cmd;
     cmd.Init(%(cmd_args)s);
     EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
   }
 }
 """
     self.WriteValidUnitTest(func, f, test, {
         'cmd_args': ", ".join(cmd_args),
       }, *extras)
 
     test = """
 TEST_P(%(test_name)s, %(name)sInvalidStringEnding) {
   const uint32_t kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = { kSource0 };
   const char kInvalidStrEnd = '*';
   SetBucketAsCStrings(kBucketId, 1, kSource, 1, kInvalidStrEnd);
   cmds::%(name)s cmd;
   cmd.Init(%(cmd_args)s);
-  decoder_->set_unsafe_es3_apis_enabled(true);
+  decoder_->set_es3_apis_enabled(true);
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
 }
 """
     self.WriteValidUnitTest(func, f, test, {
         'cmd_args': ", ".join(cmd_args),
       }, *extras)
 
 
 class PUTXnHandler(ArrayArgTypeHandler):
   """Handler for glUniform?f functions."""
@@ skipping 20 matching lines @@
       })
 
   def WriteServiceUnitTest(self, func, f, *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);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_es3_apis_enabled(true);"""
     valid_test += """
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_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, f, valid_test, {
         'name': func.name,
         'count': self.GetArrayCount(func),
         'local_args': local_args,
@@ skipping 177 matching lines @@
     func.passthrough_service_doer_args.append(Argument('result', 'uint32_t*'))
 
   def WriteServiceUnitTest(self, func, f, *extras):
     """Overrriden from TypeHandler."""
     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%(comma)sshared_memory_id_, shared_memory_offset_);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_es3_apis_enabled(true);"""
     valid_test += """
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       valid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(false);
+  decoder_->set_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));"""
     valid_test += """
 }
 """
     comma = ""
     if len(func.GetOriginalArgs()):
       comma =", "
     self.WriteValidUnitTest(func, f, valid_test, {
           'comma': comma,
         }, *extras)
 
     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%(comma)sshared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, f, invalid_test, {
           'comma': comma,
         }, *extras)
 
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgsBadSharedMemoryId) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       invalid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_es3_apis_enabled(true);"""
     invalid_test += """
   cmds::%(name)s cmd;
   cmd.Init(%(args)s%(comma)skInvalidSharedMemoryId, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   cmd.Init(%(args)s%(comma)sshared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));"""
-    if func.IsUnsafe():
+    if func.IsES3API():
       invalid_test += """
-  decoder_->set_unsafe_es3_apis_enabled(true);"""
+  decoder_->set_es3_apis_enabled(true);"""
     invalid_test += """
 }
 """
     self.WriteValidUnitTest(func, f, invalid_test, {
           'comma': comma,
         }, *extras)
 
   def WriteServiceImplementation(self, func, f):
     """Overrriden from TypeHandler."""
     self.WriteServiceHandlerFunctionHeader(func, f)
@@ skipping 1116 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):
+  def IsES3API(self):
     """Returns whether the function has service side validation or not."""
-    return self.GetInfo('unsafe', False)
+    return self.GetInfo('es3api', 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."""
@@ skipping 10 matching lines @@
   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') and
-            not self.IsUnsafe())
+            not self.IsES3API())
 
   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 1867 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:]))