Initialize destinations variables before calling GL functions...

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 2127 matching lines @@
                   func.MakeTypedOriginalArgString("")))
       for arg in func.GetOriginalArgs():
         arg.WriteClientSideValidationCode(file, func)
       file.Write("  helper_->%s(%s);\n" %
                  (func.name, func.MakeOriginalArgString("")))
       file.Write("}\n")
       file.Write("\n")
     else:
       self.WriteGLES2ImplementationDeclaration(func, file)
 
+  def WriteDestinationInitalizationValidation(self, func, file):
+    """Writes the client side destintion initialization validation."""
+    for arg in func.GetOriginalArgs():
+      arg.WriteDestinationInitalizationValidation(file, func)
+
   def WriteImmediateCmdComputeSize(self, func, file):
     """Writes the size computation code for the immediate version of a cmd."""
     file.Write("  static uint32 ComputeSize(uint32 size_in_bytes) {\n")
     file.Write("    return static_cast<uint32>(\n")
     file.Write("        sizeof(ValueType) +  // NOLINT\n")
     file.Write("        RoundSizeToMultipleOfEntries(size_in_bytes));\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdSetHeader(self, func, file):
@@ skipping 1835 matching lines @@
 
   cmd_type_map_ = {
     'GLenum': 'uint32',
     'GLint': 'int32',
     'GLintptr': 'int32',
     'GLsizei': 'int32',
     'GLsizeiptr': 'int32',
     'GLfloat': 'float',
     'GLclampf': 'float',
   }
+  need_validation_ = ['GLsizei*', 'GLboolean*', 'GLenum*', 'GLint*']
 
   def __init__(self, name, type):
     self.name = name
     self.type = type
 
     if type in self.cmd_type_map_:
       self.cmd_type = self.cmd_type_map_[type]
     else:
       self.cmd_type = 'uint32'
 
@@ skipping 29 matching lines @@
                (self.type, self.name, self.type, self.name))
 
   def WriteValidationCode(self, file, func):
     """Writes the validation code for an argument."""
     pass
 
   def WriteClientSideValidationCode(self, file, func):
     """Writes the validation code for an argument."""
     pass
 
+  def WriteDestinationInitalizationValidation(self, file, func):
+    """Writes the client side destintion initialization validation."""
+    pass
+
+  def WriteDestinationInitalizationValidatationIfNeeded(self, file, func):
+    """Writes the client side destintion initialization validation if needed."""
+    parts = self.type.split(" ")
+    if len(parts) > 1:
+      return
+    if parts[0] in self.need_validation_:
+      file.Write("  GL_CLIENT_VALIDATE_DESTINATION_INITALIZATION(%s, %s);\n" %
+          (self.type[:-1], self.name))
+
+
   def WriteGetAddress(self, file):
     """Writes the code to get the address this argument refers to."""
     pass
 
   def GetImmediateVersion(self):
     """Gets the immediate version of this argument."""
     return self
 
   def GetBucketVersion(self):
     """Gets the bucket version of this argument."""
@@ skipping 164 matching lines @@
   def WriteValidationCode(self, file, func):
     """Overridden from Argument."""
     file.Write("  if (%s == NULL) {\n" % self.name)
     file.Write("    return error::kOutOfBounds;\n")
     file.Write("  }\n")
 
   def GetImmediateVersion(self):
     """Overridden from Argument."""
     return None
 
+  def WriteDestinationInitalizationValidation(self, file, func):
+    """Overridden from Argument."""
+    self.WriteDestinationInitalizationValidatationIfNeeded(file, func)
+
 
 class BucketPointerArgument(Argument):
   """A class that represents an bucket argument to a function."""
 
   def __init__(self, name, type):
     Argument.__init__(self, name, type)
 
   def AddCmdArgs(self, args):
     """Overridden from Argument."""
     pass
 
   def WriteGetCode(self, file):
     """Overridden from Argument."""
     file.Write(
       "  %s %s = bucket->GetData(0, data_size);\n" %
       (self.type, self.name))
 
   def WriteValidationCode(self, file, func):
     """Overridden from Argument."""
     pass
 
   def GetImmediateVersion(self):
     """Overridden from Argument."""
     return None
 
+  def WriteDestinationInitalizationValidation(self, file, func):
+    """Overridden from Argument."""
+    self.WriteDestinationInitalizationValidatationIfNeeded(file, func)
+
 
 class PointerArgument(Argument):
   """A class that represents a pointer argument to a function."""
 
   def __init__(self, name, type):
     Argument.__init__(self, name, type)
 
   def IsPointer(self):
     """Returns true if argument is a pointer."""
     return True
@@ skipping 50 matching lines @@
   def GetImmediateVersion(self):
     """Overridden from Argument."""
     return ImmediatePointerArgument(self.name, self.type)
 
   def GetBucketVersion(self):
     """Overridden from Argument."""
     if self.type == "const char*":
       return InputStringBucketArgument(self.name, self.type)
     return BucketPointerArgument(self.name, self.type)
 
+  def WriteDestinationInitalizationValidation(self, file, func):
+    """Overridden from Argument."""
+    self.WriteDestinationInitalizationValidatationIfNeeded(file, func)
+
 
 class InputStringBucketArgument(Argument):
   """An string input argument where the string is passed in a bucket."""
 
   def __init__(self, name, type):
     Argument.__init__(self, name + "_bucket_id", "uint32")
 
   def WriteGetCode(self, file):
     """Overridden from Argument."""
     code = """
@@ skipping 301 matching lines @@
     self.type_handler.WriteServiceImplementation(self, file)
 
   def WriteServiceUnitTest(self, file):
     """Writes the service implementation for a command."""
     self.type_handler.WriteServiceUnitTest(self, file)
 
   def WriteGLES2ImplementationHeader(self, file):
     """Writes the GLES2 Implemention declaration."""
     self.type_handler.WriteGLES2ImplementationHeader(self, file)
 
+  def WriteDestinationInitalizationValidation(self, file):
+    """Writes the client side destintion initialization validation."""
+    self.type_handler.WriteDestinationInitalizationValidation(self, file)
+
   def WriteFormatTest(self, file):
     """Writes the cmd's format test."""
     self.type_handler.WriteFormatTest(self, file)
 
 
 class ImmediateFunction(Function):
   """A class that represnets an immediate function command."""
 
   def __init__(self, func):
     new_args = []
@@ skipping 467 matching lines @@
   def WriteGLES2CLibImplementation(self, filename):
     """Writes the GLES2 c lib implementation."""
     file = CHeaderWriter(
         filename,
         "// These functions emluate GLES2 over command buffers.\n")
 
     for func in self.original_functions:
       file.Write("%s GLES2%s(%s) {\n" %
                  (func.return_type, func.name,
                   func.MakeTypedOriginalArgString("")))
+      func.WriteDestinationInitalizationValidation(file)
       comma = ""
       if len(func.GetOriginalArgs()):
         comma = " << "
       file.Write(
           '  GPU_CLIENT_LOG("%s" << "("%s%s << ")");\n' %
           (func.original_name, comma, func.MakeOriginalArgString(
               "", separator=' << ", " << ')))
       result_string = "%s result = " % func.return_type
       return_string = (
           '  GPU_CLIENT_LOG("return:" << result)\n  return result;\n')
@@ skipping 193 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:])