Changes the code to use separate ids namspaces...

gpu/command_buffer/build_gles2_cmd_buffer.py

 #!/usr/bin/python
 #
 # Copyright (c) 2006-2009 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 os
 import os.path
@@ skipping 98 matching lines @@
 GL_APICALL void         GL_APIENTRY glGetTexParameteriv (GLenumTextureTarget target, GLenumTextureParameter pname, GLint* params);
 GL_APICALL void         GL_APIENTRY glGetUniformfv (GLidProgram program, GLint location, GLfloat* params);
 GL_APICALL void         GL_APIENTRY glGetUniformiv (GLidProgram program, GLint location, GLint* params);
 GL_APICALL GLint        GL_APIENTRY glGetUniformLocation (GLidProgram program, const char* name);
 GL_APICALL void         GL_APIENTRY glGetVertexAttribfv (GLuint index, GLenumVertexAttribute pname, GLfloat* params);
 GL_APICALL void         GL_APIENTRY glGetVertexAttribiv (GLuint index, GLenumVertexAttribute pname, GLint* params);
 GL_APICALL void         GL_APIENTRY glGetVertexAttribPointerv (GLuint index, GLenumVertexPointer pname, void** pointer);
 GL_APICALL void         GL_APIENTRY glHint (GLenumHintTarget target, GLenumHintMode mode);
 GL_APICALL GLboolean    GL_APIENTRY glIsBuffer (GLidBuffer buffer);
 GL_APICALL GLboolean    GL_APIENTRY glIsEnabled (GLenumCapability cap);
-GL_APICALL GLboolean    GL_APIENTRY glIsFramebuffer (GLuint framebuffer);
-GL_APICALL GLboolean    GL_APIENTRY glIsProgram (GLuint program);
-GL_APICALL GLboolean    GL_APIENTRY glIsRenderbuffer (GLuint renderbuffer);
-GL_APICALL GLboolean    GL_APIENTRY glIsShader (GLuint shader);
-GL_APICALL GLboolean    GL_APIENTRY glIsTexture (GLuint texture);
+GL_APICALL GLboolean    GL_APIENTRY glIsFramebuffer (GLidFramebuffer framebuffer);
+GL_APICALL GLboolean    GL_APIENTRY glIsProgram (GLidProgram program);
+GL_APICALL GLboolean    GL_APIENTRY glIsRenderbuffer (GLidRenderbuffer renderbuffer);
+GL_APICALL GLboolean    GL_APIENTRY glIsShader (GLidShader shader);
+GL_APICALL GLboolean    GL_APIENTRY glIsTexture (GLidTexture texture);
 GL_APICALL void         GL_APIENTRY glLineWidth (GLfloat width);
 GL_APICALL void         GL_APIENTRY glLinkProgram (GLidProgram program);
 GL_APICALL void         GL_APIENTRY glPixelStorei (GLenumPixelStore pname, GLintPixelStoreAlignment param);
 GL_APICALL void         GL_APIENTRY glPolygonOffset (GLfloat factor, GLfloat units);
 GL_APICALL void         GL_APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenumReadPixelFormat format, GLenumPixelType type, void* pixels);
 GL_APICALL void         GL_APIENTRY glReleaseShaderCompiler (void);
 GL_APICALL void         GL_APIENTRY glRenderbufferStorage (GLenumRenderBufferTarget target, GLenumRenderBufferFormat internalformat, GLsizei width, GLsizei height);
 GL_APICALL void         GL_APIENTRY glSampleCoverage (GLclampf value, GLboolean invert);
 GL_APICALL void         GL_APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
 GL_APICALL void         GL_APIENTRY glShaderBinary (GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length);
@@ skipping 817 matching lines @@
 # needs_size:   If true a data_size field is added to the command.
 # data_type:    The type of data the command uses. For PUTn or PUT types.
 # count:        The number of units per element. For PUTn or PUT types.
 # unit_test:    If False no unit test will be generated.
 # expectation:  If False the unit test will have no expected calls.
 # gen_func:     Name of function that generates GL resource for corresponding
 #               bind function.
 
 _FUNCTION_INFO = {
   'ActiveTexture': {'decoder_func': 'DoActiveTexture', 'unit_test': False},
+  'AttachShader': {'decoder_func': 'DoAttachShader'},
   'BindAttribLocation': {'type': 'GLchar', 'bucket': True, 'needs_size': True},
   'BindBuffer': {
     'type': 'Bind',
     'impl_decl': False,
     'decoder_func': 'DoBindBuffer',
     'gen_func': 'GenBuffersARB',
   },
   'BindFramebuffer': {
     'type': 'Bind',
     'decoder_func': 'DoBindFramebuffer',
@@ skipping 35 matching lines @@
     'gl_test_func': 'glDeleteFramebuffersEXT',
   },
   'DeleteProgram': {'type': 'Custom', 'decoder_func': 'DoDeleteProgram'},
   'DeleteRenderbuffers': {
     'type': 'DELn',
     'gl_test_func': 'glDeleteRenderbuffersEXT',
   },
   'DeleteShader': {'type': 'Custom', 'decoder_func': 'DoDeleteShader'},
   'DeleteTextures': {'type': 'DELn'},
   'DepthRangef': {'decoder_func': 'glDepthRange'},
+  'DetachShader': {'decoder_func': 'DoDetachShader'},
   'DisableVertexAttribArray': {
     'decoder_func': 'DoDisableVertexAttribArray',
     'impl_decl': False,
   },
   'DrawArrays': {
     'decoder_func': 'DoDrawArrays',
     'unit_test': False,
     'impl_decl': False,
   },
   'DrawElements': {
@@ skipping 97 matching lines @@
   },
   'GetProgramiv': {
     'type': 'GETn',
     'decoder_func': 'DoGetProgramiv',
     'result': ['SizedResult<GLint>'],
   },
   'GetProgramInfoLog': {
     'type': 'STRn',
     'get_len_func': 'glGetProgramiv',
     'get_len_enum': 'GL_INFO_LOG_LENGTH',
-    },
+  },
   'GetRenderbufferParameteriv': {
     'type': 'GETn',
     'decoder_func': 'DoGetRenderbufferParameteriv',
     'gl_test_func': 'glGetRenderbufferParameterivEXT',
     'result': ['SizedResult<GLint>'],
   },
   'GetShaderiv': {
     'type': 'GETn',
     'decoder_func': 'DoGetShaderiv',
     'result': ['SizedResult<GLint>'],
@@ skipping 11 matching lines @@
       'void* result',
     'result': [
       'int32 success',
       'int32 min_range',
       'int32 max_range',
       'int32 precision',
     ],
   },
   'GetShaderSource': {
     'type': 'STRn',
-    'decoder_func': 'DoGetShaderSource',
     'get_len_func': 'DoGetShaderiv',
     'get_len_enum': 'GL_SHADER_SOURCE_LENGTH',
     'unit_test': False,
     },
   'GetString': {
       'type': 'Custom',
       'cmd_args': 'GLenumStringType name, uint32 bucket_id',
   },
   'GetTexParameterfv': {'type': 'GETn', 'result': ['SizedResult<GLfloat>']},
   'GetTexParameteriv': {'type': 'GETn', 'result': ['SizedResult<GLint>']},
@@ skipping 128 matching lines @@
   'Uniform2fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 2},
   'Uniform2iv': {'type': 'PUTn', 'data_type': 'GLint', 'count': 2},
   'Uniform3fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 3},
   'Uniform3iv': {'type': 'PUTn', 'data_type': 'GLint', 'count': 3},
   'Uniform4fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 4},
   'Uniform4iv': {'type': 'PUTn', 'data_type': 'GLint', 'count': 4},
   'UniformMatrix2fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 4},
   'UniformMatrix3fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 9},
   'UniformMatrix4fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 16},
   'UseProgram': {'decoder_func': 'DoUseProgram', 'unit_test': False},
+  'ValidateProgram': {'decoder_func': 'DoValidateProgram'},
   'VertexAttrib1fv': {'type': 'PUT', 'data_type': 'GLfloat', 'count': 1},
   'VertexAttrib2fv': {'type': 'PUT', 'data_type': 'GLfloat', 'count': 2},
   'VertexAttrib3fv': {'type': 'PUT', 'data_type': 'GLfloat', 'count': 3},
   'VertexAttrib4fv': {'type': 'PUT', 'data_type': 'GLfloat', 'count': 4},
   'VertexAttribPointer': {
       'type': 'Manual',
       'cmd_args': 'GLuint indx, GLint size, GLenum type, GLboolean normalized, '
                   'GLsizei stride, GLuint offset',
   },
 }
@@ skipping 830 matching lines @@
 
 TEST_F(%(test_name)s, %(name)sValidArgsNewId) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(first_gl_arg)s, kNewServiceId));
   EXPECT_CALL(*gl_, %(gl_gen_func_name)s(1, _))
      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   SpecializedSetup<%(name)s, 0>();
   %(name)s cmd;
   cmd.Init(%(first_arg)s, kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(GetServiceId(kNewClientId), kNewServiceId);
-  EXPECT_TRUE(Get%(resource_type)sInfo(kNewServiceId) != NULL);
+  EXPECT_TRUE(Get%(resource_type)sInfo(kNewClientId) != NULL);
 }
 """
     gen_func_names = {
     }
     self.WriteValidUnitTest(func, file, valid_test, {
         'first_arg': func.GetOriginalArgs()[0].GetValidArg(0, 0),
         'first_gl_arg': func.GetOriginalArgs()[0].GetValidGLArg(0, 0),
         'resource_type': func.GetOriginalArgs()[1].resource_type,
         'gl_gen_func_name': func.GetInfo("gen_func"),
     })
@@ skipping 14 matching lines @@
     impl_func = func.GetInfo('impl_func')
     impl_decl = func.GetInfo('impl_decl')
     if (func.can_auto_generate and
         (impl_func == None or impl_func == True) and
         (impl_decl == None or impl_decl == True)):
       file.Write("%s %s(%s) {\n" %
                  (func.return_type, func.original_name,
                   func.MakeTypedOriginalArgString("")))
       for arg in func.GetOriginalArgs():
         arg.WriteClientSideValidationCode(file)
-      code = """  if (IsReservedId(%(id)s)) {
+      code = """  if (Is%(type)sReservedId(%(id)s)) {
     SetGLError(GL_INVALID_OPERATION);
     return;
   }
   if (%(id)s != 0) {
-    id_allocator_.MarkAsUsed(%(id)s);
+    %(lc_type)s_id_allocator_.MarkAsUsed(%(id)s);
   }
   helper_->%(name)s(%(arg_string)s);
 }
 
 """
       file.Write(code % {
           'name': func.name,
           'arg_string': func.MakeOriginalArgString(""),
           'id': func.GetOriginalArgs()[1].name,
+          'type': func.GetOriginalArgs()[1].resource_type,
+          'lc_type': func.GetOriginalArgs()[1].resource_type.lower(),
         })
     else:
       self.WriteGLES2ImplementationDeclaration(func, file)
 
 
 class GENnHandler(TypeHandler):
   """Handler for glGen___ type functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def InitFunction(self, func):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteGetDataSizeCode(self, func, file):
     """Overrriden from TypeHandler."""
     code = """  uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
 """
     file.Write(code)
 
   def WriteHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
-    file.Write("  if (!GenGLObjects<GL%sHelper>(n, %s)) {\n"
+    file.Write("  if (!%sHelper(n, %s)) {\n"
                "    return error::kInvalidArguments;\n"
                "  }\n" %
                (func.name, func.GetLastOriginalArg().name))
 
   def WriteImmediateHandlerImplementation(self, func, file):
     """Overrriden from TypeHandler."""
-    file.Write("  if (!GenGLObjects<GL%sHelper>(n, %s)) {\n"
+    file.Write("  if (!%sHelper(n, %s)) {\n"
                "    return error::kInvalidArguments;\n"
                "  }\n" %
                (func.original_name, func.GetLastOriginalArg().name))
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
-    file.Write("%s %s(%s) {\n" %
-               (func.return_type, func.original_name,
-                func.MakeTypedOriginalArgString("")))
-    file.Write("  MakeIds(%s);\n" % func.MakeOriginalArgString(""))
-    file.Write("  helper_->%sImmediate(%s);\n" %
-               (func.name, func.MakeOriginalArgString("")))
-    file.Write("}\n")
-    file.Write("\n")
+    code = """%(return_type)s %(name)s(%(typed_args)s) {
+  MakeIds(&%(resource_type)s_id_allocator_, %(args)s);
+  helper_->%(name)sImmediate(%(args)s);
+}
+
+"""
+    file.Write(code % {
+        'return_type': func.return_type,
+        'name': func.original_name,
+        'typed_args': func.MakeTypedOriginalArgString(""),
+        'args': func.MakeOriginalArgString(""),
+        'resource_type': func.name[3:-1].lower()
+      })
 
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
   SpecializedSetup<%(name)s, 0>();
   %(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(GetServiceId(kNewClientId), kNewServiceId);
+  EXPECT_TRUE(Get%(resource_name)sInfo(kNewClientId) != NULL);
 }
 """
-    self.WriteValidUnitTest(func, file, valid_test)
+    self.WriteValidUnitTest(func, file, valid_test,  {
+        'resource_name': func.name[3:-1],
+      })
     invalid_test = """
 TEST_F(%(test_name)s, %(name)sInvalidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
   GetSharedMemoryAs<GLuint*>()[0] = client_%(resource_name)s_id_;
   SpecializedSetup<%(name)s, 0>();
   %(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
 }
 """
     self.WriteValidUnitTest(func, file, invalid_test, {
           'resource_name': func.GetOriginalArgs()[1].name[0:-1]
         })
 
   def WriteImmediateServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   %(name)s& cmd = *GetImmediateAs<%(name)s>();
   GLuint temp = kNewClientId;
   SpecializedSetup<%(name)s, 0>();
   cmd.Init(1, &temp);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(GetServiceId(kNewClientId), kNewServiceId);
+  EXPECT_TRUE(Get%(resource_name)sInfo(kNewClientId) != NULL);
 }
 """
-    self.WriteValidUnitTest(func, file, valid_test)
+    self.WriteValidUnitTest(func, file, valid_test, {
+        'resource_name': func.original_name[3:-1],
+      })
     invalid_test = """
 TEST_F(%(test_name)s, %(name)sInvalidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
   %(name)s& cmd = *GetImmediateAs<%(name)s>();
   SpecializedSetup<%(name)s, 0>();
   cmd.Init(1, &client_%(resource_name)s_id_);
   EXPECT_EQ(error::kInvalidArguments,
             ExecuteImmediateCmd(cmd, sizeof(&client_%(resource_name)s_id_)));
 }
 """
@@ skipping 112 matching lines @@
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s))
       .WillOnce(Return(kNewServiceId));
   SpecializedSetup<%(name)s, 0>();
   %(name)s cmd;
   cmd.Init(%(args)s%(comma)skNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(GetServiceId(kNewClientId), kNewServiceId);
+  EXPECT_TRUE(Get%(resource_type)sInfo(kNewClientId) != NULL);
 }
 """
     comma = ""
     if len(func.GetOriginalArgs()):
       comma =", "
     self.WriteValidUnitTest(func, file, valid_test, {
           'comma': comma,
+          'resource_type': func.name[6:],
         })
     invalid_test = """
 TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<%(name)s, 0>();
   %(name)s cmd;
   cmd.Init(%(args)s%(comma)skNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, file, invalid_test, {
           'comma': comma,
         })
 
   def WriteHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  uint32 client_id = c.client_id;\n")
-    file.Write("  %sHelper(%s);\n" %
+    file.Write("  if (!%sHelper(%s)) {\n" %
                (func.name, func.MakeCmdArgString("")))
+    file.Write("    return error::kInvalidArguments;\n")
+    file.Write("  }\n")
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("%s %s(%s) {\n" %
                (func.return_type, func.original_name,
                 func.MakeTypedOriginalArgString("")))
     file.Write("  GLuint client_id;\n")
-    file.Write("  MakeIds(1, &client_id);\n")
+    file.Write("  MakeIds(&program_and_shader_id_allocator_, 1, &client_id);\n")
     file.Write("  helper_->%s(%s);\n" %
                (func.name, func.MakeCmdArgString("")))
     file.Write("  return client_id;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
 class DELnHandler(TypeHandler):
   """Handler for glDelete___ type functions."""
 
@@ skipping 16 matching lines @@
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(1, Pointee(kService%(upper_resource_name)sId)))
       .Times(1);
   GetSharedMemoryAs<GLuint*>()[0] = client_%(resource_name)s_id_;
   SpecializedSetup<%(name)s, 0>();
   %(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(GetServiceId(kNewClientId), 0u);
+  EXPECT_TRUE(
+      Get%(upper_resource_name)sInfo(client_%(resource_name)s_id_) == NULL);
 }
 """
     self.WriteValidUnitTest(func, file, valid_test, {
           'resource_name': func.GetOriginalArgs()[1].name[0:-1],
           'upper_resource_name':
               func.GetOriginalArgs()[1].name[0:-1].capitalize(),
         })
     invalid_test = """
 TEST_F(%(test_name)s, %(name)sInvalidArgs) {
-  EXPECT_CALL(*gl_, %(gl_func_name)s(1, Pointee(0)))
-      .Times(1);
   GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
   SpecializedSetup<%(name)s, 0>();
   %(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 """
     self.WriteValidUnitTest(func, file, invalid_test)
 
   def WriteImmediateServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(1, Pointee(kService%(upper_resource_name)sId)))
       .Times(1);
   %(name)s& cmd = *GetImmediateAs<%(name)s>();
   SpecializedSetup<%(name)s, 0>();
   cmd.Init(1, &client_%(resource_name)s_id_);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(client_%(resource_name)s_id_)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_EQ(GetServiceId(kNewClientId), 0u);
+  EXPECT_TRUE(
+      Get%(upper_resource_name)sInfo(client_%(resource_name)s_id_) == NULL);
 }
 """
     self.WriteValidUnitTest(func, file, valid_test, {
           'resource_name': func.GetOriginalArgs()[1].name[0:-1],
           'upper_resource_name':
               func.GetOriginalArgs()[1].name[0:-1].capitalize(),
         })
     invalid_test = """
 TEST_F(%(test_name)s, %(name)sInvalidArgs) {
-  EXPECT_CALL(*gl_, %(gl_func_name)s(1, Pointee(0)))
-      .Times(1);
   %(name)s& cmd = *GetImmediateAs<%(name)s>();
   SpecializedSetup<%(name)s, 0>();
   GLuint temp = kInvalidClientId;
   cmd.Init(1, &temp);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 """
     self.WriteValidUnitTest(func, file, invalid_test)
 
   def WriteHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
-    file.Write("  DeleteGLObjects<GL%sHelper>(n, %s);\n" %
+    file.Write("  %sHelper(n, %s);\n" %
                (func.name, func.GetLastOriginalArg().name))
 
   def WriteImmediateHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
-    file.Write("  DeleteGLObjects<GL%sHelper>(n, %s);\n" %
+    file.Write("  %sHelper(n, %s);\n" %
                (func.original_name, func.GetLastOriginalArg().name))
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     impl_decl = func.GetInfo('impl_decl')
     if impl_decl == None or impl_decl == True:
       file.Write("%s %s(%s) {\n" %
                  (func.return_type, func.original_name,
                   func.MakeTypedOriginalArgString("")))
-      file.Write("  FreeIds(%s);\n" % func.MakeOriginalArgString(""))
+      file.Write("  FreeIds(&%s_id_allocator_, %s);\n" %
+         (func.name[6:-1].lower(), func.MakeOriginalArgString("")))
       file.Write("  helper_->%sImmediate(%s);\n" %
                  (func.name, func.MakeOriginalArgString("")))
       file.Write("}\n")
       file.Write("\n")
 
   def WriteImmediateCmdComputeSize(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  static uint32 ComputeDataSize(GLsizei n) {\n")
     file.Write(
         "    return static_cast<uint32>(sizeof(GLuint) * n);  // NOLINT\n")
@@ skipping 898 matching lines @@
   %(name)s cmd;
   cmd.Init(kInvalidClientId, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 """
     self.WriteValidUnitTest(func, file, invalid_test)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
-    file.Write(
-        "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
-    file.Write(
-        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
-    args = func.GetCmdArgs()
-    id_arg = args[0]
-    bucket_arg = args[1]
-    id_arg.WriteGetCode(file)
-    bucket_arg.WriteGetCode(file)
-    id_arg.WriteValidationCode(file)
-    file.Write("  GLint len = 0;\n")
-    file.Write("  %s(%s, %s, &len);\n" % (
-        func.GetInfo('get_len_func'), id_arg.name,
-        func.GetInfo('get_len_enum')))
-    file.Write("  Bucket* bucket = CreateBucket(%s);\n" % bucket_arg.name)
-    file.Write("  bucket->SetSize(len + 1);\n");
-    file.Write(
-        "  %s(%s, len + 1, &len, bucket->GetDataAs<GLchar*>(0, len + 1));\n" %
-        (func.GetGLFunctionName(), id_arg.name))
-    file.Write("  return error::kNoError;\n")
-    file.Write("}\n")
-    file.Write("\n")
+    pass
 
 
 class FunctionInfo(object):
   """Holds info about a function."""
 
   def __init__(self, info, type_handler):
     for key in info:
       setattr(self, key, info[key])
     self.type_handler = type_handler
     if not 'type' in info:
@@ skipping 339 matching lines @@
   """A class that represents a resource id argument to a function."""
 
   def __init__(self, name, type):
     match = re.match("(GLid\w+)", type)
     self.resource_type = match.group(1)[4:]
     type = type.replace(match.group(1), "GLuint")
     Argument.__init__(self, name, type)
 
   def WriteGetCode(self, file):
     """Overridden from Argument."""
-    file.Write("  %s %s;\n" % (self.type, self.name))
-    file.Write("  if (!id_manager()->GetServiceId(c.%s, &%s)) {\n" %
-               (self.name, self.name))
-    file.Write("    SetGLError(GL_INVALID_VALUE);\n")
-    file.Write("    return error::kNoError;\n")
-    file.Write("  }\n")
+    file.Write("  %s %s = c.%s;\n" % (self.type, self.name, self.name))
 
   def GetValidArg(self, offset, index):
     return "client_%s_id_" % self.resource_type.lower()
 
   def GetValidGLArg(self, offset, index):
     return "kService%sId" % self.resource_type
 
 
 class ResourceIdBindArgument(Argument):
   """Represents a resource id argument to a bind function."""
 
   def __init__(self, name, type):
     match = re.match("(GLidBind\w+)", type)
     self.resource_type = match.group(1)[8:]
     type = type.replace(match.group(1), "GLuint")
     Argument.__init__(self, name, type)
 
   def WriteGetCode(self, file):
     """Overridden from Argument."""
     code = """  %(type)s %(name)s = c.%(name)s;
 """
     file.Write(code % {'type': self.type, 'name': self.name})
 
   def GetValidArg(self, offset, index):
     return "client_%s_id_" % self.resource_type.lower()
 
   def GetValidGLArg(self, offset, index):
     return "kService%sId" % self.resource_type
 
-  def GetNumInvalidValues(self, func):
-    """returns the number of invalid values to be tested."""
-    return 1
-
-  def GetInvalidArg(self, offset, index):
-    """returns an invalid value by index."""
-    if self.resource_type == "Texture":
-      return ("client_buffer_id_", "kNoError", "GL_INVALID_OPERATION")
-    return ("client_texture_id_", "kNoError", "GL_INVALID_OPERATION")
-
 
 class ResourceIdZeroArgument(Argument):
   """Represents a resource id argument to a function that can be zero."""
 
   def __init__(self, name, type):
     match = re.match("(GLidZero\w+)", type)
     self.resource_type = match.group(1)[8:]
     type = type.replace(match.group(1), "GLuint")
     Argument.__init__(self, name, type)
 
   def WriteGetCode(self, file):
     """Overridden from Argument."""
     file.Write("  %s %s = c.%s;\n" % (self.type, self.name, self.name))
-    file.Write("  if (%s != 0 && !id_manager()->GetServiceId(%s, &%s)) {\n" %
-               (self.name, self.name, self.name))
-    file.Write("    SetGLError(GL_INVALID_VALUE);\n")
-    file.Write("    return error::kNoError;\n")
-    file.Write("  }\n")
 
   def GetValidArg(self, offset, index):
     return "client_%s_id_" % self.resource_type.lower()
 
   def GetValidGLArg(self, offset, index):
     return "kService%sId" % self.resource_type
 
   def GetNumInvalidValues(self, func):
     """returns the number of invalid values to be tested."""
     return 1
 
   def GetInvalidArg(self, offset, index):
     """returns an invalid value by index."""
-    if self.resource_type == "Texture":
-      return ("client_buffer_id_", "kNoError", "GL_INVALID_OPERATION")
-    return ("client_texture_id_", "kNoError", "GL_INVALID_OPERATION")
+    return ("kInvalidClientId", "kNoError", "GL_INVALID_VALUE")
 
 
 class Function(object):
   """A class that represents a function."""
 
   def __init__(self, original_name, name, info, return_type, original_args,
                args_for_cmds, cmd_args, init_args, num_pointer_args):
     self.name = name
     self.original_name = original_name
     self.info = info
@@ skipping 732 matching lines @@
 
   if options.generate_docs:
     gen.WriteDocs("docs/gles2_cmd_format_docs_autogen.h")
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     sys.exit(1)
 
 if __name__ == '__main__':
   main(sys.argv[1:])