Cache more GL state both service and client side.

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 49 matching lines @@
 
 # Capabilites selected with glEnable
 _CAPABILITY_FLAGS = [
   {'name': 'blend'},
   {'name': 'cull_face'},
   {'name': 'depth_test', 'state_flag': 'clear_state_dirty_'},
   {'name': 'dither', 'default': True},
   {'name': 'polygon_offset_fill'},
   {'name': 'sample_alpha_to_coverage'},
   {'name': 'sample_coverage'},
-  {'name': 'scissor_test'},
+  {'name': 'scissor_test', 'state_flag': 'clear_state_dirty_'},
   {'name': 'stencil_test', 'state_flag': 'clear_state_dirty_'},
 ]
 
 _STATES = {
   'ClearColor': {
     'type': 'Normal',
     'func': 'ClearColor',
     'enum': 'GL_COLOR_CLEAR_VALUE',
     'states': [
       {'name': 'color_clear_red', 'type': 'GLfloat', 'default': '0.0f'},
@@ skipping 1123 matching lines @@
   },
   'ClearColor': {
     'type': 'StateSet',
     'state': 'ClearColor',
   },
   'ClearDepthf': {
     'type': 'StateSet',
     'state': 'ClearDepthf',
     'decoder_func': 'glClearDepth',
     'gl_test_func': 'glClearDepth',
+    'valid_args': {
+      '0': '0.5f'
+    },
   },
   'ColorMask': {
     'type': 'StateSet',
     'state': 'ColorMask',
     'no_gl': True,
     'expectation': False,
   },
   'ConsumeTextureCHROMIUM': {
     'decoder_func': 'DoConsumeTextureCHROMIUM',
     'type': 'PUT',
@@ skipping 44 matching lines @@
     'type': 'Create',
     'client_test': False,
   },
   'BlendColor': {
     'type': 'StateSet',
     'state': 'BlendColor',
   },
   'BlendEquation': {
     'type': 'StateSetRGBAlpha',
     'state': 'BlendEquation',
+    'valid_args': {
+      '0': 'GL_FUNC_SUBTRACT'
+    },
   },
   'BlendEquationSeparate': {
     'type': 'StateSet',
     'state': 'BlendEquation',
+    'valid_args': {
+      '0': 'GL_FUNC_SUBTRACT'
+    },
   },
   'BlendFunc': {
     'type': 'StateSetRGBAlpha',
     'state': 'BlendFunc',
   },
   'BlendFuncSeparate': {
     'type': 'StateSet',
     'state': 'BlendFunc',
   },
   'SampleCoverage': {'decoder_func': 'DoSampleCoverage'},
   'StencilFunc': {
-    'type': 'StencilFrontBack',
+    'type': 'StateSetFrontBack',
     'state': 'StencilFunc',
   },
   'StencilFuncSeparate': {
-    'type': 'StencilFrontBack',
+    'type': 'StateSetFrontBackSeparate',
     'state': 'StencilFunc',
   },
   'StencilOp': {
     'type': 'StateSetFrontBack',
     'state': 'StencilOp',
+    'valid_args': {
+      '1': 'GL_INCR'
+    },
   },
   'StencilOpSeparate': {
     'type': 'StateSetFrontBackSeparate',
     'state': 'StencilOp',
+    'valid_args': {
+      '1': 'GL_INCR'
+    },
   },
   'Hint': {'decoder_func': 'DoHint'},
   'CullFace': {'type': 'StateSet', 'state': 'CullFace'},
   'FrontFace': {'type': 'StateSet', 'state': 'FrontFace'},
   'DepthFunc': {'type': 'StateSet', 'state': 'DepthFunc'},
-  'LineWidth': {'type': 'StateSet', 'state': 'LineWidth'},
+  'LineWidth': {
+    'type': 'StateSet',
+    'state': 'LineWidth',
+    'valid_args': {
+      '0': '0.5f'
+    },
+  },
   'PolygonOffset': {
     'type': 'StateSet',
     'state': 'PolygonOffset',
   },
   'DeleteBuffers': {
     'type': 'DELn',
     'gl_test_func': 'glDeleteBuffersARB',
     'resource_type': 'Buffer',
     'resource_types': 'Buffers',
   },
@@ skipping 32 matching lines @@
   'DepthMask': {
     'type': 'StateSet',
     'state': 'DepthMask',
     'no_gl': True,
     'expectation': False,
   },
   'DetachShader': {'decoder_func': 'DoDetachShader'},
   'Disable': {
     'decoder_func': 'DoDisable',
     'impl_func': False,
+    'client_test': False,
   },
   'DisableVertexAttribArray': {
     'decoder_func': 'DoDisableVertexAttribArray',
     'impl_decl': False,
   },
   'DrawArrays': {
     'type': 'Manual',
     'cmd_args': 'GLenumDrawMode mode, GLint first, GLsizei count',
   },
   'DrawElements': {
     'type': 'Manual',
     'cmd_args': 'GLenumDrawMode mode, GLsizei count, '
                 'GLenumIndexType type, GLuint index_offset',
     'client_test': False
   },
   'Enable': {
     'decoder_func': 'DoEnable',
     'impl_func': False,
+    'client_test': False,
   },
   'EnableVertexAttribArray': {
     'decoder_func': 'DoEnableVertexAttribArray',
     'impl_decl': False,
   },
   'Finish': {
     'impl_func': False,
     'client_test': False,
     'decoder_func': 'DoFinish',
   },
@@ skipping 536 matching lines @@
     'client_test': False,
     'pepper_interface': 'ChromiumMapSub',
   },
   'UnmapTexSubImage2DCHROMIUM': {
     'gen_cmd': False,
     'extension': True,
     'chromium': True,
     'client_test': False,
     'pepper_interface': 'ChromiumMapSub',
   },
-  'UseProgram': {'decoder_func': 'DoUseProgram', 'unit_test': False},
+  'UseProgram': {
+    'decoder_func': 'DoUseProgram',
+    'impl_func': False,
+    'unit_test': False,
+  },
   'ValidateProgram': {'decoder_func': 'DoValidateProgram'},
   'VertexAttrib1f': {'decoder_func': 'DoVertexAttrib1f'},
   'VertexAttrib1fv': {
     'type': 'PUT',
     'data_type': 'GLfloat',
     'count': 1,
     'decoder_func': 'DoVertexAttrib1fv',
   },
   'VertexAttrib2f': {'decoder_func': 'DoVertexAttrib2f'},
   'VertexAttrib2fv': {
@@ skipping 893 matching lines @@
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteHandlerImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     state_name = func.GetInfo('state')
     state = _STATES[state_name]
     states = state['states']
     args = func.GetOriginalArgs()
+    code = []
     for ndx,item in enumerate(states):
-      file.Write("  state_.%s = %s;\n" % (item['name'], args[ndx].name))
+      code.append("state_.%s != %s" % (item['name'], args[ndx].name))
+    file.Write("  if (%s) {\n" % " ||\n      ".join(code))
+    for ndx,item in enumerate(states):
+      file.Write("    state_.%s = %s;\n" % (item['name'], args[ndx].name))
     if 'state_flag' in state:
-      file.Write("  %s = true;\n" % state['state_flag'])
+      file.Write("    %s = true;\n" % state['state_flag'])
     if not func.GetInfo("no_gl"):
-      file.Write("  %s(%s);\n" %
+      file.Write("    %s(%s);\n" %
                  (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+    file.Write("  }\n")
 
 
 class StateSetRGBAlphaHandler(TypeHandler):
   """Handler for commands that simply set state that have rgb/alpha."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteHandlerImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     state_name = func.GetInfo('state')
     state = _STATES[state_name]
     states = state['states']
     args = func.GetOriginalArgs()
     num_args = len(args)
-    for ndx, item in enumerate(states):
-      file.Write("  state_.%s = %s;\n" %
+    code = []
+    for ndx,item in enumerate(states):
+      code.append("state_.%s != %s" % (item['name'], args[ndx % num_args].name))
+    file.Write("  if (%s) {\n" % " ||\n      ".join(code))
+    for ndx,item in enumerate(states):
+      file.Write("    state_.%s = %s;\n" %
                  (item['name'], args[ndx % num_args].name))
     if 'state_flag' in state:
-      file.Write("  %s = true;\n" % state['state_flag'])
+      file.Write("    %s = true;\n" % state['state_flag'])
     if not func.GetInfo("no_gl"):
-      file.Write("  %s(%s);\n" %
+      file.Write("    %s(%s);\n" %
                  (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+    file.Write("  }\n")
 
 
 class StateSetFrontBackSeparateHandler(TypeHandler):
   """Handler for commands that simply set state that have front/back."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteHandlerImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     state_name = func.GetInfo('state')
     state = _STATES[state_name]
     states = state['states']
     args = func.GetOriginalArgs()
     face = args[0].name
     num_args = len(args)
+    file.Write("  bool changed = false;\n")
     for group_ndx, group in enumerate(Grouper(num_args - 1, states)):
       file.Write("  if (%s == %s || %s == GL_FRONT_AND_BACK) {\n" %
                  (face, ('GL_FRONT', 'GL_BACK')[group_ndx], face))
+      code = []
       for ndx, item in enumerate(group):
-        file.Write("    state_.%s = %s;\n" % (item['name'], args[ndx + 1].name))
+        code.append("state_.%s != %s" % (item['name'], args[ndx + 1].name))
+      file.Write("    changed |= %s;\n" % " ||\n        ".join(code))
       file.Write("  }\n")
+    file.Write("  if (changed) {\n")
+    for group_ndx, group in enumerate(Grouper(num_args - 1, states)):
+      file.Write("    if (%s == %s || %s == GL_FRONT_AND_BACK) {\n" %
+                 (face, ('GL_FRONT', 'GL_BACK')[group_ndx], face))
+      for ndx, item in enumerate(group):
+        file.Write("      state_.%s = %s;\n" %
+                   (item['name'], args[ndx + 1].name))
+      file.Write("    }\n")
     if 'state_flag' in state:
-      file.Write("  %s = true;\n" % state['state_flag'])
+      file.Write("    %s = true;\n" % state['state_flag'])
     if not func.GetInfo("no_gl"):
-      file.Write("  %s(%s);\n" %
+      file.Write("    %s(%s);\n" %
                  (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+    file.Write("  }\n")
 
 
 class StateSetFrontBackHandler(TypeHandler):
   """Handler for commands that simply set state that set both front/back."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteHandlerImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     state_name = func.GetInfo('state')
     state = _STATES[state_name]
     states = state['states']
     args = func.GetOriginalArgs()
-    face = args[0].name
     num_args = len(args)
+    code = []
     for group_ndx, group in enumerate(Grouper(num_args, states)):
       for ndx, item in enumerate(group):
-        file.Write("  state_.%s = %s;\n" % (item['name'], args[ndx].name))
+        code.append("state_.%s != %s" % (item['name'], args[ndx].name))
+    file.Write("  if (%s) {\n" % " ||\n      ".join(code))
+    for group_ndx, group in enumerate(Grouper(num_args, states)):
+      for ndx, item in enumerate(group):
+        file.Write("    state_.%s = %s;\n" % (item['name'], args[ndx].name))
     if 'state_flag' in state:
-      file.Write("  %s = true;\n" % state['state_flag'])
+      file.Write("    %s = true;\n" % state['state_flag'])
     if not func.GetInfo("no_gl"):
-      file.Write("  %s(%s);\n" %
+      file.Write("    %s(%s);\n" %
                  (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+    file.Write("  }\n")
+
 
 class CustomHandler(TypeHandler):
   """Handler for commands that are auto-generated but require minor tweaks."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
@@ skipping 425 matching lines @@
       file.Write("  GPU_CLIENT_SINGLE_THREAD_CHECK();\n")
       func.WriteDestinationInitalizationValidation(file)
       self.WriteClientGLCallLog(func, file)
       for arg in func.GetOriginalArgs():
         arg.WriteClientSideValidationCode(file, func)
 
       code = """  if (Is%(type)sReservedId(%(id)s)) {
     SetGLError(GL_INVALID_OPERATION, "%(name)s\", \"%(id)s reserved id");
     return;
   }
-  Bind%(type)sHelper(%(arg_string)s);
-  helper_->%(name)s(%(arg_string)s);
+  if (Bind%(type)sHelper(%(arg_string)s)) {
+    helper_->%(name)s(%(arg_string)s);
+  }
 }
 
 """
       name_arg = None
       if len(func.GetOriginalArgs()) == 1:
         # Bind functions that have no target (like BindVertexArrayOES)
         name_arg = func.GetOriginalArgs()[0]
       else:
         # Bind functions that have both a target and a name (like BindTexture)
         name_arg = func.GetOriginalArgs()[1]
 
       file.Write(code % {
           'name': func.name,
           'arg_string': func.MakeOriginalArgString(""),
           'id': name_arg.name,
           'type': name_arg.resource_type,
           'lc_type': name_arg.resource_type.lower(),
         })
 
+  def WriteGLES2ImplementationUnitTest(self, func, file):
+    """Overrriden from TypeHandler."""
+    code = """
+TEST_F(GLES2ImplementationTest, %(name)s) {
+  struct 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)));
+  ClearCommands();
+  gl_->%(name)s(%(args)s);
+  EXPECT_TRUE(NoCommandsWritten());
+}
+"""
+    cmd_arg_strings = []
+    for count, arg in enumerate(func.GetCmdArgs()):
+      cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
+      count += 1
+    gl_arg_strings = []
+    for count, arg in enumerate(func.GetOriginalArgs()):
+      gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
+    file.Write(code % {
+          'name': func.name,
+          'args': ", ".join(gl_arg_strings),
+          'cmd_args': ", ".join(cmd_arg_strings),
+        })
+
 
 class GENnHandler(TypeHandler):
   """Handler for glGen___ type functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def InitFunction(self, func):
     """Overrriden from TypeHandler."""
     pass
@@ skipping 2896 matching lines @@
       interface = PepperInterface(interface)
       self.pepper_interfaces.append(interface)
       self.interface_info[interface.GetName()] = interface
 
   def AddFunction(self, func):
     """Adds a function."""
     self.functions.append(func)
 
   def GetTypeHandler(self, name):
     """Gets a type info for the given type."""
-    if name in self._type_handlers:
-      return self._type_handlers[name]
+    if len(name):
+      if name in self._type_handlers:
+        return self._type_handlers[name]
+      else:
+        raise KeyError("no such type handler: %s" % name)
     return self._empty_type_handler
 
   def GetFunctionInfo(self, name):
     """Gets a type info for the given function name."""
     if name in self._function_info:
       return self._function_info[name]
     return self._empty_function_info
 
   def Log(self, msg):
     """Prints something if verbose is true."""
@@ skipping 153 matching lines @@
     file = CHeaderWriter(filename)
 
     for func in self.functions:
       if True:
       #gen_cmd = func.GetInfo('gen_cmd')
       #if gen_cmd == True or gen_cmd == None:
         func.WriteCmdHelper(file)
 
     file.Close()
 
-  def WriteContextStateHeader(self, filename):
-    """Writes the context state header."""
+  def WriteServiceContextStateHeader(self, filename):
+    """Writes the service context state header."""
     file = CHeaderWriter(
         filename,
         "// It is included by context_state.h\n")
     file.Write("struct EnableFlags {\n")
     file.Write("  EnableFlags();\n")
     for capability in _CAPABILITY_FLAGS:
       file.Write("  bool %s;\n" % capability['name'])
     file.Write("};\n\n")
 
     for state_name in sorted(_STATES.keys()):
       state = _STATES[state_name]
       for item in state['states']:
         file.Write("%s %s;\n" % (item['type'], item['name']))
     file.Write("\n")
 
     file.Close()
 
-  def WriteContextStateImpl(self, filename):
-    """Writes the context state implementation."""
+  def WriteClientContextStateHeader(self, filename):
+    """Writes the client context state header."""
+    file = CHeaderWriter(
+        filename,
+        "// It is included by client_context_state.h\n")
+    file.Write("struct EnableFlags {\n")
+    file.Write("  EnableFlags();\n")
+    for capability in _CAPABILITY_FLAGS:
+      file.Write("  bool %s;\n" % capability['name'])
+    file.Write("};\n\n")
+
+    file.Close()
+
+  def WriteContextStateGetters(self, file, class_name):
+    """Writes the state getters."""
+    for gl_type in ["GLint", "GLfloat"]:
+      file.Write("""
+bool %s::GetStateAs%s(
+    GLenum pname, %s* params, GLsizei* num_written) const {
+  switch (pname) {
+""" % (class_name, gl_type, gl_type))
+      for state_name in _STATES.keys():
+        state = _STATES[state_name]
+        if 'enum' in state:
+          file.Write("    case %s:\n" % state['enum'])
+          file.Write("      *num_written = %d;\n" % len(state['states']))
+          file.Write("      if (params) {\n")
+          for ndx,item in enumerate(state['states']):
+            file.Write("        params[%d] = static_cast<%s>(%s);\n" %
+                       (ndx, gl_type, item['name']))
+          file.Write("      }\n")
+          file.Write("      return true;\n")
+        else:
+          for item in state['states']:
+            file.Write("    case %s:\n" % item['enum'])
+            file.Write("      *num_written = 1;\n")
+            file.Write("      if (params) {\n")
+            file.Write("        params[0] = static_cast<%s>(%s);\n" %
+                       (gl_type, item['name']))
+            file.Write("      }\n")
+            file.Write("      return true;\n")
+      for capability in _CAPABILITY_FLAGS:
+            file.Write("    case GL_%s:\n" % capability['name'].upper())
+            file.Write("      *num_written = 1;\n")
+            file.Write("      if (params) {\n")
+            file.Write(
+                "        params[0] = static_cast<%s>(enable_flags.%s);\n" %
+                (gl_type, capability['name']))
+            file.Write("      }\n")
+            file.Write("      return true;\n")
+      file.Write("""    default:
+      return false;
+  }
+}
+""")
+
+  def WriteServiceContextStateImpl(self, filename):
+    """Writes the context state service implementation."""
     file = CHeaderWriter(
         filename,
         "// It is included by context_state.cc\n")
     code = []
     for capability in _CAPABILITY_FLAGS:
       code.append("%s(%s)" %
                   (capability['name'],
                    ('false', 'true')['default' in capability]))
     file.Write("ContextState::EnableFlags::EnableFlags()\n    : %s {\n}\n" %
                ",\n      ".join(code))
@@ skipping 29 matching lines @@
           file.Write(
               "  gl%s(%s, %s);\n" %
               (state['func'], ('GL_FRONT', 'GL_BACK')[ndx], ", ".join(args)))
       else:
         args = []
         for item in state['states']:
           args.append('%s' % item['name'])
         file.Write("  gl%s(%s);\n" % (state['func'], ", ".join(args)))
     file.Write("}\n")
 
+    file.Write("""bool ContextState::GetEnabled(GLenum cap) const {
+  switch (cap) {
+""")
+    for capability in _CAPABILITY_FLAGS:
+      file.Write("    case GL_%s:\n" % capability['name'].upper())
+      file.Write("      return enable_flags.%s;\n" % capability['name'])
+    file.Write("""    default:
+      GPU_NOTREACHED();
+      return false;
+  }
+}
+""")
+
+    self.WriteContextStateGetters(file, "ContextState")
+    file.Close()
+
+  def WriteClientContextStateImpl(self, filename):
+    """Writes the context state client side implementation."""
+    file = CHeaderWriter(
+        filename,
+        "// It is included by client_context_state.cc\n")
+    code = []
+    for capability in _CAPABILITY_FLAGS:
+      code.append("%s(%s)" %
+                  (capability['name'],
+                   ('false', 'true')['default' in capability]))
+    file.Write(
+      "ClientContextState::EnableFlags::EnableFlags()\n    : %s {\n}\n" %
+      ",\n      ".join(code))
+    file.Write("\n")
+
+    file.Write("""
+bool ClientContextState::SetCapabilityState(
+    GLenum cap, bool enabled, bool* changed) {
+  *changed = false;
+  switch (cap) {
+""")
+    for capability in _CAPABILITY_FLAGS:
+      file.Write("    case GL_%s:\n" % capability['name'].upper())
+      file.Write("""      if (enable_flags.%(name)s != enabled) {
+         *changed = true;
+         enable_flags.%(name)s = enabled;
+      }
+      return true;
+""" % capability)
+    file.Write("""    default:
+      return false;
+  }
+}
+""")
+    file.Write("""bool ClientContextState::GetEnabled(
+    GLenum cap, bool* enabled) const {
+  switch (cap) {
+""")
+    for capability in _CAPABILITY_FLAGS:
+      file.Write("    case GL_%s:\n" % capability['name'].upper())
+      file.Write("      *enabled = enable_flags.%s;\n" % capability['name'])
+      file.Write("      return true;\n")
+    file.Write("""    default:
+      return false;
+  }
+}
+""")
     file.Close()
 
   def WriteServiceImplementation(self, filename):
     """Writes the service decorder implementation."""
     file = CHeaderWriter(
         filename,
         "// It is included by gles2_cmd_decoder.cc\n")
 
     for func in self.functions:
       if True:
@@ skipping 16 matching lines @@
 """ % capability)
       else:
         file.Write("""      state_.enable_flags.%(name)s = enabled;
       return true;
 """ % capability)
     file.Write("""    default:
       NOTREACHED();
       return false;
   }
 }
-
-bool GLES2DecoderImpl::DoIsEnabled(GLenum cap) {
-  switch (cap) {
-""")
-    for capability in _CAPABILITY_FLAGS:
-      file.Write("    case GL_%s:\n" % capability['name'].upper())
-      file.Write("      return state_.enable_flags.%s;\n" %
-                 capability['name'])
-    file.Write("""    default:
-      NOTREACHED();
-      return false;
-  }
-}
-""")
-    for gl_type in ["GLint", "GLfloat"]:
-      file.Write("""
-bool GLES2DecoderImpl::GetStateAs%s(
-    GLenum pname, %s* params, GLsizei* num_written) {
-  switch (pname) {
-""" % (gl_type, gl_type))
-      for state_name in _STATES.keys():
-        state = _STATES[state_name]
-        if 'enum' in state:
-          file.Write("    case %s:\n" % state['enum'])
-          file.Write("      *num_written = %d;\n" % len(state['states']))
-          file.Write("      if (params) {\n")
-          for ndx,item in enumerate(state['states']):
-            file.Write("        params[%d] = static_cast<%s>(state_.%s);\n" %
-                       (ndx, gl_type, item['name']))
-          file.Write("      }\n")
-          file.Write("      return true;\n")
-        else:
-          for item in state['states']:
-            file.Write("    case %s:\n" % item['enum'])
-            file.Write("      *num_written = 1;\n")
-            file.Write("      if (params) {\n")
-            file.Write("        params[0] = static_cast<%s>(state_.%s);\n" %
-                       (gl_type, item['name']))
-            file.Write("      }\n")
-            file.Write("      return true;\n")
-      for capability in _CAPABILITY_FLAGS:
-            file.Write("    case GL_%s:\n" % capability['name'].upper())
-            file.Write("      *num_written = 1;\n")
-            file.Write("      if (params) {\n")
-            file.Write("        params[0] = static_cast<%s>("
-                       "state_.enable_flags.%s);\n" %
-                       (gl_type, capability['name']))
-            file.Write("      }\n")
-            file.Write("      return true;\n")
-      file.Write("""    default:
-      return false;
-  }
-}
 """)
     file.Close()
 
   def WriteServiceUnitTests(self, filename):
     """Writes the service decorder unit tests."""
     num_tests = len(self.functions)
     FUNCTIONS_PER_FILE = 98  # hard code this so it doesn't change.
     count = 0
     for test_num in range(0, num_tests, FUNCTIONS_PER_FILE):
       count += 1
@@ skipping 511 matching lines @@
     gen.WriteGLES2InterfaceStub("client/gles2_interface_stub_autogen.h")
     gen.WriteGLES2InterfaceStubImpl(
         "client/gles2_interface_stub_impl_autogen.h")
     gen.WriteGLES2ImplementationHeader("client/gles2_implementation_autogen.h")
     gen.WriteGLES2Implementation("client/gles2_implementation_impl_autogen.h")
     gen.WriteGLES2ImplementationUnitTests(
         "client/gles2_implementation_unittest_autogen.h")
     gen.WriteGLES2CLibImplementation("client/gles2_c_lib_autogen.h")
     gen.WriteCmdHelperHeader("client/gles2_cmd_helper_autogen.h")
     gen.WriteServiceImplementation("service/gles2_cmd_decoder_autogen.h")
-    gen.WriteContextStateHeader("service/context_state_autogen.h")
-    gen.WriteContextStateImpl("service/context_state_impl_autogen.h")
+    gen.WriteServiceContextStateHeader("service/context_state_autogen.h")
+    gen.WriteServiceContextStateImpl("service/context_state_impl_autogen.h")
+    gen.WriteClientContextStateHeader("client/client_context_state_autogen.h")
+    gen.WriteClientContextStateImpl(
+        "client/client_context_state_impl_autogen.h")
     gen.WriteServiceUnitTests("service/gles2_cmd_decoder_unittest_%d_autogen.h")
     gen.WriteServiceUtilsHeader("service/gles2_cmd_validation_autogen.h")
     gen.WriteServiceUtilsImplementation(
         "service/gles2_cmd_validation_implementation_autogen.h")
     gen.WriteCommonUtilsHeader("common/gles2_cmd_utils_autogen.h")
     gen.WriteCommonUtilsImpl("common/gles2_cmd_utils_implementation_autogen.h")
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))