automate more GL state handling

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
 import sys
 import re
 from optparse import OptionParser
 
 _SIZE_OF_UINT32 = 4
 _SIZE_OF_COMMAND_HEADER = 4
 _FIRST_SPECIFIC_COMMAND_ID = 256
 
@@ skipping 32 matching lines @@
   'GLuint': 'unsigned int',
   'GLfloat': 'float',
   'GLclampf': 'float',
   'GLvoid': 'void',
   'GLfixed': 'int',
   'GLclampx': 'int',
   'GLintptr': 'long int',
   'GLsizeiptr': 'long int',
 }
 
+# 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': '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'},
+      {'name': 'color_clear_green', 'type': 'GLfloat', 'default': '0.0f'},
+      {'name': 'color_clear_blue', 'type': 'GLfloat', 'default': '0.0f'},
+      {'name': 'color_clear_alpha', 'type': 'GLfloat', 'default': '0.0f'},
+    ],
+  },
+  'ClearDepthf': {
+    'type': 'Normal',
+    'func': 'ClearDepth',
+    'enum': 'GL_DEPTH_CLEAR_VALUE',
+    'states': [
+      {'name': 'depth_clear', 'type': 'GLclampf', 'default': '1.0f'},
+    ],
+  },
+  'ColorMask': {
+    'type': 'Normal',
+    'func': 'ColorMask',
+    'enum': 'GL_COLOR_WRITEMASK',
+    'states': [
+      {'name': 'color_mask_red', 'type': 'GLboolean', 'default': 'true'},
+      {'name': 'color_mask_green', 'type': 'GLboolean', 'default': 'true'},
+      {'name': 'color_mask_blue', 'type': 'GLboolean', 'default': 'true'},
+      {'name': 'color_mask_alpha', 'type': 'GLboolean', 'default': 'true'},
+    ],
+    'state_flag': 'clear_state_dirty_',
+  },
+  'ClearStencil': {
+    'type': 'Normal',
+    'func': 'ClearStencil',
+    'enum': 'GL_STENCIL_CLEAR_VALUE',
+    'states': [
+      {'name': 'stencil_clear', 'type': 'GLint', 'default': '0'},
+    ],
+  },
+  'BlendColor': {
+    'type': 'Normal',
+    'func': 'BlendColor',
+    'enum': 'GL_BLEND_COLOR',
+    'states': [
+      {'name': 'blend_color_red', 'type': 'GLfloat', 'default': '0.0f'},
+      {'name': 'blend_color_green', 'type': 'GLfloat', 'default': '0.0f'},
+      {'name': 'blend_color_blue', 'type': 'GLfloat', 'default': '0.0f'},
+      {'name': 'blend_color_alpha', 'type': 'GLfloat', 'default': '0.0f'},
+    ],
+  },
+  'BlendEquation': {
+    'type': 'SrcDst',
+    'func': 'BlendEquationSeparate',
+    'states': [
+      {
+        'name': 'blend_equation_rgb',
+        'type': 'GLenum',
+        'enum': 'GL_BLEND_EQUATION_RGB',
+        'default': 'GL_FUNC_ADD',
+      },
+      {
+        'name': 'blend_equation_alpha',
+        'type': 'GLenum',
+        'enum': 'GL_BLEND_EQUATION_ALPHA',
+        'default': 'GL_FUNC_ADD',
+      },
+    ],
+  },
+  'BlendFunc': {
+    'type': 'SrcDst',
+    'func': 'BlendFuncSeparate',
+    'states': [
+      {
+        'name': 'blend_source_rgb',
+        'type': 'GLenum',
+        'enum': 'GL_BLEND_SRC_RGB',
+        'default': 'GL_ONE',
+      },
+      {
+        'name': 'blend_dest_rgb',
+        'type': 'GLenum',
+        'enum': 'GL_BLEND_DST_RGB',
+        'default': 'GL_ZERO',
+      },
+      {
+        'name': 'blend_source_alpha',
+        'type': 'GLenum',
+        'enum': 'GL_BLEND_SRC_ALPHA',
+        'default': 'GL_ONE',
+      },
+      {
+        'name': 'blend_dest_alpha',
+        'type': 'GLenum',
+        'enum': 'GL_BLEND_DST_ALPHA',
+        'default': 'GL_ZERO',
+      },
+    ],
+  },
+  'PolygonOffset': {
+    'type': 'Normal',
+    'func': 'PolygonOffset',
+    'states': [
+      {
+        'name': 'polygon_offset_factor',
+        'type': 'GLfloat',
+        'enum': 'GL_POLYGON_OFFSET_FACTOR',
+        'default': '0.0f',
+      },
+      {
+        'name': 'polygon_offset_units',
+        'type': 'GLfloat',
+        'enum': 'GL_POLYGON_OFFSET_UNITS',
+        'default': '0.0f',
+      },
+    ],
+  },
+  'CullFace':  {
+    'type': 'Normal',
+    'func': 'CullFace',
+    'enum': 'GL_CULL_FACE_MODE',
+    'states': [
+      {
+        'name': 'cull_mode',
+        'type': 'GLenum',
+        'default': 'GL_BACK',
+      },
+    ],
+  },
+  'FrontFace': {
+    'type': 'Normal',
+    'func': 'FrontFace',
+    'enum': 'GL_FRONT_FACE',
+    'states': [{'name': 'front_face', 'type': 'GLenum', 'default': 'GL_CCW'}],
+  },
+  'DepthFunc': {
+    'type': 'Normal',
+    'func': 'DepthFunc',
+    'enum': 'GL_DEPTH_FUNC',
+    'states': [{'name': 'depth_func', 'type': 'GLenum', 'default': 'GL_LESS'}],
+  },
+  'DepthRange': {
+    'type': 'Normal',
+    'func': 'DepthRange',
+    'enum': 'GL_DEPTH_RANGE',
+    'states': [
+      {'name': 'z_near', 'type': 'GLclampf', 'default': '0.0f'},
+      {'name': 'z_far', 'type': 'GLclampf', 'default': '1.0f'},
+    ],
+  },
+  'SampleCoverage': {
+    'type': 'Normal',
+    'func': 'SampleCoverage',
+    'states': [
+      {
+        'name': 'sample_coverage_value',
+        'type': 'GLclampf',
+        'enum': 'GL_SAMPLE_COVERAGE_VALUE',
+        'default': '0.0f',
+      },
+      {
+        'name': 'sample_coverage_invert',
+        'type': 'GLboolean',
+        'enum': 'GL_SAMPLE_COVERAGE_INVERT',
+        'default': 'false',
+      },
+    ],
+  },
+  'StencilMask': {
+    'type': 'FrontBack',
+    'func': 'StencilMaskSeparate',
+    'state_flag': 'clear_state_dirty_',
+    'states': [
+      {
+        'name': 'stencil_front_writemask',
+        'type': 'GLuint',
+        'enum': 'GL_STENCIL_WRITEMASK',
+        'default': '0xFFFFFFFFU',
+      },
+      {
+        'name': 'stencil_back_writemask',
+        'type': 'GLuint',
+        'enum': 'GL_STENCIL_BACK_WRITEMASK',
+        'default': '0xFFFFFFFFU',
+      },
+    ],
+  },
+  'StencilOp': {
+    'type': 'FrontBack',
+    'func': 'StencilOpSeparate',
+    'states': [
+      {
+        'name': 'stencil_front_fail_op',
+        'type': 'GLenum',
+        'enum': 'GL_STENCIL_FAIL',
+        'default': 'GL_KEEP',
+      },
+      {
+        'name': 'stencil_front_z_fail_op',
+        'type': 'GLenum',
+        'enum': 'GL_STENCIL_PASS_DEPTH_FAIL',
+        'default': 'GL_KEEP',
+      },
+      {
+        'name': 'stencil_front_z_pass_op',
+        'type': 'GLenum',
+        'enum': 'GL_STENCIL_PASS_DEPTH_PASS',
+        'default': 'GL_KEEP',
+      },
+      {
+        'name': 'stencil_back_fail_op',
+        'type': 'GLenum',
+        'enum': 'GL_STENCIL_BACK_FAIL',
+        'default': 'GL_KEEP',
+      },
+      {
+        'name': 'stencil_back_z_fail_op',
+        'type': 'GLenum',
+        'enum': 'GL_STENCIL_BACK_PASS_DEPTH_FAIL',
+        'default': 'GL_KEEP',
+      },
+      {
+        'name': 'stencil_back_z_pass_op',
+        'type': 'GLenum',
+        'enum': 'GL_STENCIL_BACK_PASS_DEPTH_PASS',
+        'default': 'GL_KEEP',
+      },
+    ],
+  },
+  'StencilFunc': {
+    'type': 'FrontBack',
+    'func': 'StencilFuncSeparate',
+    'states': [
+      {
+        'name': 'stencil_front_func',
+        'type': 'GLenum',
+        'enum': 'GL_STENCIL_FUNC',
+        'default': 'GL_ALWAYS',
+      },
+      {
+        'name': 'stencil_front_ref',
+        'type': 'GLint',
+        'enum': 'GL_STENCIL_REF',
+        'default': '0',
+      },
+      {
+        'name': 'stencil_front_mask',
+        'type': 'GLuint',
+        'enum': 'GL_STENCIL_VALUE_MASK',
+        'default': '0xFFFFFFFFU',
+      },
+      {
+        'name': 'stencil_back_func',
+        'type': 'GLenum',
+        'enum': 'GL_STENCIL_BACK_FUNC',
+        'default': 'GL_ALWAYS',
+      },
+      {
+        'name': 'stencil_back_ref',
+        'type': 'GLint',
+        'enum': 'GL_STENCIL_BACK_REF',
+        'default': '0',
+      },
+      {
+        'name': 'stencil_back_mask',
+        'type': 'GLuint',
+        'enum': 'GL_STENCIL_BACK_VALUE_MASK',
+        'default': '0xFFFFFFFFU',
+      },
+    ],
+  },
+  # TODO: Consider implemenenting these states
+  # GL_GENERATE_MIPMAP_HINT
+  # GL_ACTIVE_TEXTURE,
+  # GL_PACK_ALIGNMENT,
+  # GL_UNPACK_ALIGNMENT
+  # GL_SAMPLE_BUFFERS,
+  # GL_SAMPLES
+  'LineWidth': {
+    'type': 'Normal',
+    'func': 'LineWidth',
+    'enum': 'GL_LINE_WIDTH',
+    'states': [{'name': 'line_width', 'type': 'GLfloat', 'default': '1.0f'}],
+  },
+  'DepthMask': {
+    'type': 'Normal',
+    'func': 'DepthMask',
+    'enum': 'GL_DEPTH_WRITEMASK',
+    'states': [
+      {'name': 'depth_mask', 'type': 'GLboolean', 'default': 'true'},
+    ],
+    'state_flag': 'clear_state_dirty_',
+  },
+  'Scissor': {
+    'type': 'Normal',
+    'func': 'Scissor',
+    'enum': 'GL_SCISSOR_BOX',
+    'states': [
+      # NOTE: These defaults reset at GLES2DecoderImpl::Initialization.
+      {
+        'name': 'scissor_x',
+        'type': 'GLfloat',
+        'default': '0.0f',
+        'expected': 'kViewportX',
+      },
+      {
+        'name': 'scissor_y',
+        'type': 'GLfloat',
+        'default': '0.0f',
+        'expected': 'kViewportY',
+      },
+      {
+        'name': 'scissor_width',
+        'type': 'GLfloat',
+        'default': '1.0f',
+        'expected': 'kViewportWidth',
+      },
+      {
+        'name': 'scissor_height',
+        'type': 'GLfloat',
+        'default': '1.0f',
+        'expected': 'kViewportHeight',
+      },
+    ],
+  },
+  'Viewport': {
+    'type': 'Normal',
+    'func': 'Viewport',
+    'enum': 'GL_VIEWPORT',
+    'states': [
+      # NOTE: These defaults reset at GLES2DecoderImpl::Initialization.
+      {
+        'name': 'viewport_x',
+        'type': 'GLfloat',
+        'default': '0.0f',
+        'expected': 'kViewportX',
+      },
+      {
+        'name': 'viewport_y',
+        'type': 'GLfloat',
+        'default': '0.0f',
+        'expected': 'kViewportY',
+      },
+      {
+        'name': 'viewport_width',
+        'type': 'GLfloat',
+        'default': '1.0f',
+        'expected': 'kViewportWidth',
+      },
+      {
+        'name': 'viewport_height',
+        'type': 'GLfloat',
+        'default': '1.0f',
+        'expected': 'kViewportHeight',
+      },
+    ],
+  },
+}
+
 # This is a list of enum names and their valid values. It is used to map
 # GLenum arguments to a specific set of valid values.
 _ENUM_LISTS = {
   'BlitFilter': {
     'type': 'GLenum',
     'valid': [
       'GL_NEAREST',
       'GL_LINEAR',
     ],
     'invalid': [
@@ skipping 41 matching lines @@
     ],
   },
   'CompressedTextureFormat': {
     'type': 'GLenum',
     'valid': [
     ],
   },
   'GLState': {
     'type': 'GLenum',
     'valid': [
+      # NOTE: State an Capability entries added later.
       'GL_ACTIVE_TEXTURE',
       'GL_ALIASED_LINE_WIDTH_RANGE',
       'GL_ALIASED_POINT_SIZE_RANGE',
       'GL_ALPHA_BITS',
       'GL_ARRAY_BUFFER_BINDING',
-      'GL_BLEND',
-      'GL_BLEND_COLOR',
-      'GL_BLEND_DST_ALPHA',
-      'GL_BLEND_DST_RGB',
-      'GL_BLEND_EQUATION_ALPHA',
-      'GL_BLEND_EQUATION_RGB',
-      'GL_BLEND_SRC_ALPHA',
-      'GL_BLEND_SRC_RGB',
       'GL_BLUE_BITS',
-      'GL_COLOR_CLEAR_VALUE',
-      'GL_COLOR_WRITEMASK',
       'GL_COMPRESSED_TEXTURE_FORMATS',
-      'GL_CULL_FACE',
-      'GL_CULL_FACE_MODE',
       'GL_CURRENT_PROGRAM',
       'GL_DEPTH_BITS',
-      'GL_DEPTH_CLEAR_VALUE',
-      'GL_DEPTH_FUNC',
       'GL_DEPTH_RANGE',
-      'GL_DEPTH_TEST',
-      'GL_DEPTH_WRITEMASK',
-      'GL_DITHER',
       'GL_ELEMENT_ARRAY_BUFFER_BINDING',
       'GL_FRAMEBUFFER_BINDING',
-      'GL_FRONT_FACE',
       'GL_GENERATE_MIPMAP_HINT',
       'GL_GREEN_BITS',
       'GL_IMPLEMENTATION_COLOR_READ_FORMAT',
       'GL_IMPLEMENTATION_COLOR_READ_TYPE',
-      'GL_LINE_WIDTH',
       'GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS',
       'GL_MAX_CUBE_MAP_TEXTURE_SIZE',
       'GL_MAX_FRAGMENT_UNIFORM_VECTORS',
       'GL_MAX_RENDERBUFFER_SIZE',
       'GL_MAX_TEXTURE_IMAGE_UNITS',
       'GL_MAX_TEXTURE_SIZE',
       'GL_MAX_VARYING_VECTORS',
       'GL_MAX_VERTEX_ATTRIBS',
       'GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS',
       'GL_MAX_VERTEX_UNIFORM_VECTORS',
       'GL_MAX_VIEWPORT_DIMS',
       'GL_NUM_COMPRESSED_TEXTURE_FORMATS',
       'GL_NUM_SHADER_BINARY_FORMATS',
       'GL_PACK_ALIGNMENT',
-      'GL_POLYGON_OFFSET_FACTOR',
-      'GL_POLYGON_OFFSET_FILL',
-      'GL_POLYGON_OFFSET_UNITS',
       'GL_RED_BITS',
       'GL_RENDERBUFFER_BINDING',
       'GL_SAMPLE_BUFFERS',
       'GL_SAMPLE_COVERAGE_INVERT',
       'GL_SAMPLE_COVERAGE_VALUE',
       'GL_SAMPLES',
       'GL_SCISSOR_BOX',
-      'GL_SCISSOR_TEST',
       'GL_SHADER_BINARY_FORMATS',
       'GL_SHADER_COMPILER',
-      'GL_STENCIL_BACK_FAIL',
-      'GL_STENCIL_BACK_FUNC',
-      'GL_STENCIL_BACK_PASS_DEPTH_FAIL',
-      'GL_STENCIL_BACK_PASS_DEPTH_PASS',
-      'GL_STENCIL_BACK_REF',
-      'GL_STENCIL_BACK_VALUE_MASK',
-      'GL_STENCIL_BACK_WRITEMASK',
+      'GL_SUBPIXEL_BITS',
       'GL_STENCIL_BITS',
-      'GL_STENCIL_CLEAR_VALUE',
-      'GL_STENCIL_FAIL',
-      'GL_STENCIL_FUNC',
-      'GL_STENCIL_PASS_DEPTH_FAIL',
-      'GL_STENCIL_PASS_DEPTH_PASS',
-      'GL_STENCIL_REF',
-      'GL_STENCIL_TEST',
-      'GL_STENCIL_VALUE_MASK',
-      'GL_STENCIL_WRITEMASK',
-      'GL_SUBPIXEL_BITS',
       'GL_TEXTURE_BINDING_2D',
       'GL_TEXTURE_BINDING_CUBE_MAP',
       'GL_UNPACK_ALIGNMENT',
       'GL_UNPACK_FLIP_Y_CHROMIUM',
       'GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM',
       'GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM',
       'GL_VIEWPORT',
     ],
     'invalid': [
       'GL_FOG_HINT',
@@ skipping 119 matching lines @@
       'GL_DST_ALPHA',
       'GL_ONE_MINUS_DST_ALPHA',
       'GL_CONSTANT_COLOR',
       'GL_ONE_MINUS_CONSTANT_COLOR',
       'GL_CONSTANT_ALPHA',
       'GL_ONE_MINUS_CONSTANT_ALPHA',
     ],
   },
   'Capability': {
     'type': 'GLenum',
-    'valid': [
-      'GL_DITHER',  # 1st one is a non-cached value so autogen unit tests work.
-      'GL_BLEND',
-      'GL_CULL_FACE',
-      'GL_DEPTH_TEST',
-      'GL_POLYGON_OFFSET_FILL',
-      'GL_SAMPLE_ALPHA_TO_COVERAGE',
-      'GL_SAMPLE_COVERAGE',
-      'GL_SCISSOR_TEST',
-      'GL_STENCIL_TEST',
-    ],
+    'valid': ["GL_%s" % cap['name'].upper() for cap in _CAPABILITY_FLAGS],
     'invalid': [
       'GL_CLIP_PLANE0',
       'GL_POINT_SPRITE',
     ],
   },
   'DrawMode': {
     'type': 'GLenum',
     'valid': [
       'GL_POINTS',
       'GL_LINE_STRIP',
@@ skipping 513 matching lines @@
     'gl_test_func': 'glCheckFramebufferStatusEXT',
     'error_value': 'GL_FRAMEBUFFER_UNSUPPORTED',
     'result': ['GLenum'],
   },
   'Clear': {
     'type': 'Manual',
     'cmd_args': 'GLbitfield mask'
   },
   'ClearColor': {
     'type': 'StateSet',
-    'states': [
-      {'name': 'color_clear_red'},
-      {'name': 'color_clear_green'},
-      {'name': 'color_clear_blue'},
-      {'name': 'color_clear_alpha'},
-    ],
+    'state': 'ClearColor',
   },
   'ClearDepthf': {
     'type': 'StateSet',
-    'states': [
-      {'name': 'depth_clear'},
-    ],
+    'state': 'ClearDepthf',
     'decoder_func': 'glClearDepth',
     'gl_test_func': 'glClearDepth',
   },
   'ColorMask': {
     'type': 'StateSet',
-    'states': [
-      {'name': 'color_mask_red'},
-      {'name': 'color_mask_green'},
-      {'name': 'color_mask_blue'},
-      {'name': 'color_mask_alpha'},
-    ],
-    'state_flag': 'clear_state_dirty_',
+    'state': 'ColorMask',
     'no_gl': True,
     'expectation': False,
   },
   'ConsumeTextureCHROMIUM': {
     'decoder_func': 'DoConsumeTextureCHROMIUM',
     'type': 'PUT',
     'data_type': 'GLbyte',
     'count': 64,
     'unit_test': False,
     'extension': True,
     'chromium': True,
   },
   'ClearStencil': {
     'type': 'StateSet',
-    'states': [
-      {'name': 'stencil_clear'},
-    ],
+    'state': 'ClearStencil',
   },
   'EnableFeatureCHROMIUM': {
     'type': 'Custom',
     'immediate': False,
     'decoder_func': 'DoEnableFeatureCHROMIUM',
     'expectation': False,
     'cmd_args': 'GLuint bucket_id, GLint* result',
     'result': ['GLint'],
     'extension': True,
     'chromium': True,
@@ skipping 20 matching lines @@
   'CreateProgram': {
     'type': 'Create',
     'client_test': False,
   },
   'CreateShader': {
     'type': 'Create',
     'client_test': False,
   },
   'BlendColor': {
     'type': 'StateSet',
-    'states': [
-      {'name': 'blend_color_red'},
-      {'name': 'blend_color_green'},
-      {'name': 'blend_color_blue'},
-      {'name': 'blend_color_alpha'},
-    ],
+    'state': 'BlendColor',
   },
-  'BlendEquation': {'decoder_func': 'DoBlendEquation'},
+  'BlendEquation': {
+    'type': 'StateSetRGBAlpha',
+    'state': 'BlendEquation',
+  },
   'BlendEquationSeparate': {
     'type': 'StateSet',
-    'states': [
-      {'name': 'blend_equation_rgb'},
-      {'name': 'blend_equation_alpha'},
-    ],
+    'state': 'BlendEquation',
   },
-  'BlendFunc': {'decoder_func': 'DoBlendFunc'},
+  'BlendFunc': {
+    'type': 'StateSetRGBAlpha',
+    'state': 'BlendFunc',
+  },
   'BlendFuncSeparate': {
     'type': 'StateSet',
-    'states': [
-      {'name': 'blend_source_rgb'},
-      {'name': 'blend_dest_rgb'},
-      {'name': 'blend_source_alpha'},
-      {'name': 'blend_dest_alpha'},
-    ],
+    'state': 'BlendFunc',
   },
   'SampleCoverage': {'decoder_func': 'DoSampleCoverage'},
-  'StencilFunc': {'decoder_func': 'DoStencilFunc'},
-  'StencilFuncSeparate': {'decoder_func': 'DoStencilFuncSeparate'},
-  'StencilOp': {'decoder_func': 'DoStencilOp'},
-  'StencilOpSeparate': {'decoder_func': 'DoStencilOpSeparate'},
+  'StencilFunc': {
+    'type': 'StencilFrontBack',
+    'state': 'StencilFunc',
+  },
+  'StencilFuncSeparate': {
+    'type': 'StencilFrontBack',
+    'state': 'StencilFunc',
+  },
+  'StencilOp': {
+    'type': 'StateSetFrontBack',
+    'state': 'StencilOp',
+  },
+  'StencilOpSeparate': {
+    'type': 'StateSetFrontBackSeparate',
+    'state': 'StencilOp',
+  },
   'Hint': {'decoder_func': 'DoHint'},
-  'CullFace': {'type': 'StateSet', 'states': [{'name': 'cull_mode'}]},
-  'FrontFace': {'type': 'StateSet', 'states': [{'name': 'front_face'}]},
-  'DepthFunc': {'type': 'StateSet', 'states': [{'name': 'depth_func'}]},
-  'LineWidth': {'type': 'StateSet', 'states': [{'name': 'line_width'}]},
+  'CullFace': {'type': 'StateSet', 'state': 'CullFace'},
+  'FrontFace': {'type': 'StateSet', 'state': 'FrontFace'},
+  'DepthFunc': {'type': 'StateSet', 'state': 'DepthFunc'},
+  'LineWidth': {'type': 'StateSet', 'state': 'LineWidth'},
   'PolygonOffset': {
     'type': 'StateSet',
-    'states': [
-      {'name': 'polygon_offset_factor'},
-      {'name': 'polygon_offset_units'},
-    ],
+    'state': 'PolygonOffset',
   },
   'DeleteBuffers': {
     'type': 'DELn',
     'gl_test_func': 'glDeleteBuffersARB',
     'resource_type': 'Buffer',
     'resource_types': 'Buffers',
   },
   'DeleteFramebuffers': {
     'type': 'DELn',
     'gl_test_func': 'glDeleteFramebuffersEXT',
@@ skipping 21 matching lines @@
     'type': 'DELn',
     'resource_type': 'Texture',
     'resource_types': 'Textures',
   },
   'DepthRangef': {
     'decoder_func': 'DoDepthRangef',
     'gl_test_func': 'glDepthRange',
   },
   'DepthMask': {
     'type': 'StateSet',
-    'states': [
-      {'name': 'depth_mask'},
-    ],
-    'state_flag': 'clear_state_dirty_',
+    'state': 'DepthMask',
     'no_gl': True,
     'expectation': False,
   },
   'DetachShader': {'decoder_func': 'DoDetachShader'},
   'Disable': {
     'decoder_func': 'DoDisable',
     'impl_func': False,
   },
   'DisableVertexAttribArray': {
     'decoder_func': 'DoDisableVertexAttribArray',
@@ skipping 412 matching lines @@
   },
   'ShaderSource': {
     'type': 'Manual',
     'immediate': True,
     'bucket': True,
     'needs_size': True,
     'client_test': False,
     'cmd_args':
         'GLuint shader, const char* data',
   },
-  'StencilMask': {'decoder_func': 'DoStencilMask', 'expectation': False},
+  'StencilMask': {
+    'type': 'StateSetFrontBack',
+    'state': 'StencilMask',
+    'no_gl': True,
+    'expectation': False,
+  },
   'StencilMaskSeparate': {
-    'decoder_func': 'DoStencilMaskSeparate',
+    'type': 'StateSetFrontBackSeparate',
+    'state': 'StencilMask',
+    'no_gl': True,
     'expectation': False,
   },
   'SwapBuffers': {
     'type': 'Custom',
     'impl_func': False,
     'unit_test': False,
     'client_test': False,
     'extension': True,
   },
   'TexImage2D': {
@@ skipping 360 matching lines @@
   },
   'ReleaseTexImage2DCHROMIUM': {
     'decoder_func': 'DoReleaseTexImage2DCHROMIUM',
     'unit_test': False,
     'extension': True,
     'chromium': True,
   },
 }
 
 
+def Grouper(n, iterable, fillvalue=None):
+  """Collect data into fixed-length chunks or blocks"""
+  args = [iter(iterable)] * n
+  return itertools.izip_longest(fillvalue=fillvalue, *args)
+
+
 def SplitWords(input_string):
   """Transforms a input_string into a list of lower-case components.
 
   Args:
     input_string: the input string.
 
   Returns:
     a list of lower-case words.
   """
   if input_string.find('_') > -1:
@@ skipping 252 matching lines @@
     """Writes the size test for a command."""
     file.Write("  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);\n")
 
   def WriteFormatTest(self, func, file):
     """Writes a format test for a command."""
     file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name)
     file.Write("  %s& cmd = *GetBufferAs<%s>();\n" % (func.name, func.name))
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     args = func.GetCmdArgs()
-    value = 11
-    for arg in args:
-      file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
-      value += 1
+    for value, arg in enumerate(args):
+      file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value + 11))
     file.Write(");\n")
-    value = 11
     file.Write("  EXPECT_EQ(static_cast<uint32>(%s::kCmdId),\n" % func.name)
     file.Write("            cmd.header.command);\n")
     func.type_handler.WriteCmdSizeTest(func, file)
-    for arg in args:
+    for value, arg in enumerate(args):
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
-                 (arg.type, value, arg.name))
-      value += 1
+                 (arg.type, value + 11, arg.name))
     file.Write("  CheckBytesWrittenMatchesExpectedSize(\n")
     file.Write("      next_cmd, sizeof(cmd));\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteImmediateFormatTest(self, func, file):
     """Writes a format test for an immediate version of a command."""
     pass
 
   def WriteBucketFormatTest(self, func, file):
@@ skipping 73 matching lines @@
     file.Write("  return error::kNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteValidUnitTest(self, func, file, test, extra = {}):
     """Writes a valid unit test."""
     if func.GetInfo('expectation') == False:
       test = self._remove_expected_call_re.sub('', test)
     name = func.name
     arg_strings = []
-    count = 0
-    for arg in func.GetOriginalArgs():
+    for count, arg in enumerate(func.GetOriginalArgs()):
       arg_strings.append(arg.GetValidArg(func, count, 0))
-      count += 1
     gl_arg_strings = []
-    count = 0
-    for arg in func.GetOriginalArgs():
+    for count, arg in enumerate(func.GetOriginalArgs()):
       gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
-      count += 1
     gl_func_name = func.GetGLTestFunctionName()
     vars = {
       'test_name': 'GLES2DecoderTest%d' % file.file_num,
       'name':name,
       'gl_func_name': gl_func_name,
       'args': ", ".join(arg_strings),
       'gl_args': ", ".join(gl_arg_strings),
     }
     vars.update(extra)
     file.Write(test % vars)
 
   def WriteInvalidUnitTest(self, func, file, test, extra = {}):
     """Writes a invalid unit test."""
-    arg_index = 0
-    for arg in func.GetOriginalArgs():
+    for arg_index, arg in enumerate(func.GetOriginalArgs()):
       num_invalid_values = arg.GetNumInvalidValues(func)
       for value_index in range(0, num_invalid_values):
         arg_strings = []
         parse_result = "kNoError"
         gl_error = None
-        count = 0
-        for arg in func.GetOriginalArgs():
+        for count, arg in enumerate(func.GetOriginalArgs()):
           if count == arg_index:
             (arg_string, parse_result, gl_error) = arg.GetInvalidArg(
                 count, value_index)
           else:
             arg_string = arg.GetValidArg(func, count, 0)
           arg_strings.append(arg_string)
-          count += 1
         gl_arg_strings = []
-        count = 0
         for arg in func.GetOriginalArgs():
           gl_arg_strings.append("_")
-          count += 1
         gl_func_name = func.GetGLTestFunctionName()
         gl_error_test = ''
         if not gl_error == None:
           gl_error_test = '\n  EXPECT_EQ(%s, GetGLError());' % gl_error
 
         vars = {
           'test_name': 'GLES2DecoderTest%d' % file.file_num ,
           'name': func.name,
           'arg_index': arg_index,
           'value_index': value_index,
           'gl_func_name': gl_func_name,
           'args': ", ".join(arg_strings),
           'all_but_last_args': ", ".join(arg_strings[:-1]),
           'gl_args': ", ".join(gl_arg_strings),
           'parse_result': parse_result,
             'gl_error_test': gl_error_test,
         }
         vars.update(extra)
         file.Write(test % vars)
-      arg_index += 1
 
   def WriteServiceUnitTest(self, func, file):
     """Writes the service unit test for a command."""
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<%(name)s, 0>(true);
   %(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ skipping 125 matching lines @@
     %(name)s cmd;
   };
   Cmds expected;
   expected.cmd.Init(%(cmd_args)s);
 
   gl_->%(name)s(%(args)s);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
       cmd_arg_strings = []
-      count = 0
-      for arg in func.GetCmdArgs():
+      for count, arg in enumerate(func.GetCmdArgs()):
         cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
         count += 1
       gl_arg_strings = []
-      count = 0
-      for arg in func.GetOriginalArgs():
+      for count, arg in enumerate(func.GetOriginalArgs()):
         gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
-        count += 1
       file.Write(code % {
             'name': func.name,
             'args': ", ".join(gl_arg_strings),
             'cmd_args': ", ".join(cmd_arg_strings),
           })
     else:
       if client_test != False:
         file.Write("// TODO: Implement unit test for %s\n" % func.name)
 
   def WriteDestinationInitalizationValidation(self, func, file):
@@ skipping 61 matching lines @@
 
 
 class StateSetHandler(TypeHandler):
   """Handler for commands that simply set state."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteHandlerImplementation(self, func, file):
     """Overrriden from TypeHandler."""
-    states = func.GetInfo('states')
+    state_name = func.GetInfo('state')
+    state = _STATES[state_name]
+    states = state['states']
     args = func.GetOriginalArgs()
-    ndx = 0
-    for state in states:
+    for ndx,state in enumerate(states):
       file.Write("  state_.%s = %s;\n" % (state['name'], args[ndx].name))
-      ndx += 1
-    state_flag = func.GetInfo('state_flag')
-    if state_flag:
-      file.Write("  %s = true;\n" % state_flag)
+    if 'state_flag' in state:
+      file.Write("  %s = true;\n" % state['state_flag'])
     if not func.GetInfo("no_gl"):
       file.Write("  %s(%s);\n" %
                  (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
 
 
+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" %
+                 (item['name'], args[ndx % num_args].name))
+    if 'state_flag' in state:
+      file.Write("  %s = true;\n" % state['state_flag'])
+    if not func.GetInfo("no_gl"):
+      file.Write("  %s(%s);\n" %
+                 (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+
+
+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)
+    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'])
+    if not func.GetInfo("no_gl"):
+      file.Write("  %s(%s);\n" %
+                 (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+
+
+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)
+    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'])
+    if not func.GetInfo("no_gl"):
+      file.Write("  %s(%s);\n" %
+                 (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+
 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 1152 matching lines @@
   expected.cmd.Init(%(cmd_args)s, result1.id, result1.offset);
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, SizedResultHelper<Result::Type>(1)))
       .RetiresOnSaturation();
   gl_->%(name)s(%(args)s, &result);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(static_cast<Result::Type>(1), result);
 }
 """
     cmd_arg_strings = []
-    count = 0
-    for arg in func.GetCmdArgs()[0:-2]:
+    for count, arg in enumerate(func.GetCmdArgs()[0:-2]):
       cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
-      count += 1
     cmd_arg_strings[0] = '123'
     gl_arg_strings = []
-    count = 0
-    for arg in func.GetOriginalArgs()[0:-1]:
+    for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
-      count += 1
     gl_arg_strings[0] = '123'
     file.Write(code % {
           'name': func.name,
           'args': ", ".join(gl_arg_strings),
           'cmd_args': ", ".join(cmd_arg_strings),
         })
 
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
@@ skipping 11 matching lines @@
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
                 %(valid_pname)s),
             result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     gl_arg_strings = []
     valid_pname = ''
-    count = 0
-    for arg in func.GetOriginalArgs()[:-1]:
+    for count, arg in enumerate(func.GetOriginalArgs()[:-1]):
       arg_value = arg.GetValidGLArg(func, count, 0)
       gl_arg_strings.append(arg_value)
       if arg.name == 'pname':
         valid_pname = arg_value
-      count += 1
     if func.GetInfo('gl_test_func') == 'glGetIntegerv':
       gl_arg_strings.append("_")
     else:
       gl_arg_strings.append("result->GetData()")
 
     self.WriteValidUnitTest(func, file, valid_test, {
         'local_gl_args': ", ".join(gl_arg_strings),
         'valid_pname': valid_pname,
       })
 
@@ skipping 62 matching lines @@
   SpecializedSetup<%(name)s, 0>(true);
   %(data_type)s temp[%(data_count)s] = { %(data_value)s, };
   cmd.Init(%(gl_args)s, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     gl_arg_strings = []
     gl_any_strings = []
-    count = 0
-    for arg in func.GetOriginalArgs()[0:-1]:
+    for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
       gl_any_strings.append("_")
-      count += 1
     extra = {
       'data_type': func.GetInfo('data_type'),
       'data_count': func.GetInfo('count'),
       'data_value': func.GetInfo('data_value') or '0',
       'gl_args': ", ".join(gl_arg_strings),
       'gl_any_args': ", ".join(gl_any_strings),
     }
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
     invalid_test = """
@@ skipping 53 matching lines @@
   Cmds expected;
   for (int jj = 0; jj < %(count)d; ++jj) {
     expected.data[jj] = static_cast<%(type)s>(jj);
   }
   expected.cmd.Init(%(cmd_args)s, &expected.data[0]);
   gl_->%(name)s(%(args)s, &expected.data[0]);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
     cmd_arg_strings = []
-    count = 0
-    for arg in func.GetCmdArgs()[0:-2]:
+    for count, arg in enumerate(func.GetCmdArgs()[0:-2]):
       cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
-      count += 1
     gl_arg_strings = []
-    count = 0
-    for arg in func.GetOriginalArgs()[0:-1]:
+    for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
-      count += 1
     file.Write(code % {
           'name': func.name,
           'type': func.GetInfo('data_type'),
           'count': func.GetInfo('count'),
           'args': ", ".join(gl_arg_strings),
           'cmd_args': ", ".join(cmd_arg_strings),
         })
 
   def WriteImmediateCmdComputeSize(self, func, file):
     """Overrriden from TypeHandler."""
@@ skipping 72 matching lines @@
     file.Write("  const int kSomeBaseValueToTestWith = 51;\n")
     file.Write("  static %s data[] = {\n" % func.info.data_type)
     for v in range(0, func.info.count):
       file.Write("    static_cast<%s>(kSomeBaseValueToTestWith + %d),\n" %
                  (func.info.data_type, v))
     file.Write("  };\n")
     file.Write("  %s& cmd = *GetBufferAs<%s>();\n" % (func.name, func.name))
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     args = func.GetCmdArgs()
-    value = 11
-    for arg in args:
-      file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
-      value += 1
+    for value, arg in enumerate(args):
+      file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value + 11))
     file.Write(",\n      data);\n")
     args = func.GetCmdArgs()
-    value = 11
     file.Write("  EXPECT_EQ(static_cast<uint32>(%s::kCmdId),\n" % func.name)
     file.Write("            cmd.header.command);\n")
     file.Write("  EXPECT_EQ(sizeof(cmd) +\n")
     file.Write("            RoundSizeToMultipleOfEntries(sizeof(data)),\n")
     file.Write("            cmd.header.size * 4u);\n")
-    for arg in args:
+    for value, arg in enumerate(args):
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
-                 (arg.type, value, arg.name))
-      value += 1
+                 (arg.type, value + 11, arg.name))
     file.Write("  CheckBytesWrittenMatchesExpectedSize(\n")
     file.Write("      next_cmd, sizeof(cmd) +\n")
     file.Write("      RoundSizeToMultipleOfEntries(sizeof(data)));\n")
     file.Write("  // TODO(gman): Check that data was inserted;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
 class PUTnHandler(TypeHandler):
   """Handler for PUTn 'glUniform__v' type functions."""
@@ skipping 10 matching lines @@
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<%(name)s, 0>(true);
   %(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     gl_arg_strings = []
     arg_strings = []
-    count = 0
-    for arg in func.GetOriginalArgs():
+    for count, arg in enumerate(func.GetOriginalArgs()):
       # hardcoded to match unit tests.
       if count == 0:
         # the location of the second element of the 2nd uniform.
         # defined in GLES2DecoderBase::SetupShaderForUniform
         gl_arg_strings.append("3")
         arg_strings.append("ProgramManager::MakeFakeLocation(1, 1)")
       elif count == 1:
         # the number of elements that gl will be called with.
         gl_arg_strings.append("3")
         # the number of elements requested in the command.
         arg_strings.append("5")
       else:
         gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
         arg_strings.append(arg.GetValidArg(func, count, 0))
-      count += 1
     extra = {
       'gl_args': ", ".join(gl_arg_strings),
       'args': ", ".join(arg_strings),
     }
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
   def WriteImmediateServiceUnitTest(self, func, file):
     """Overridden from TypeHandler."""
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   %(name)s& cmd = *GetImmediateAs<%(name)s>();
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(%(gl_args)s,
           reinterpret_cast<%(data_type)s*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<%(name)s, 0>(true);
   %(data_type)s temp[%(data_count)s * 2] = { 0, };
   cmd.Init(%(args)s, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     gl_arg_strings = []
     gl_any_strings = []
     arg_strings = []
-    count = 0
-    for arg in func.GetOriginalArgs()[0:-1]:
+    for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
       gl_any_strings.append("_")
       arg_strings.append(arg.GetValidArg(func, count, 0))
-      count += 1
     extra = {
       'data_type': func.GetInfo('data_type'),
       'data_count': func.GetInfo('count'),
       'args': ", ".join(arg_strings),
       'gl_args': ", ".join(gl_arg_strings),
       'gl_any_args': ", ".join(gl_any_strings),
     }
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
     invalid_test = """
@@ skipping 61 matching lines @@
     for (int jj = 0; jj < %(count)d; ++jj) {
       expected.data[ii][jj] = static_cast<%(type)s>(ii * %(count)d + jj);
     }
   }
   expected.cmd.Init(%(cmd_args)s, &expected.data[0][0]);
   gl_->%(name)s(%(args)s, &expected.data[0][0]);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
     cmd_arg_strings = []
-    count = 0
-    for arg in func.GetCmdArgs()[0:-2]:
+    for count, arg in enumerate(func.GetCmdArgs()[0:-2]):
       cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
-      count += 1
     gl_arg_strings = []
-    count = 0
-    for arg in func.GetOriginalArgs()[0:-1]:
+    for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
-      count += 1
     file.Write(code % {
           'name': func.name,
           'type': func.GetInfo('data_type'),
           'count': func.GetInfo('count'),
           'args': ", ".join(gl_arg_strings),
           'cmd_args': ", ".join(cmd_arg_strings),
         })
 
   def WriteImmediateCmdComputeSize(self, func, file):
     """Overrriden from TypeHandler."""
@@ skipping 76 matching lines @@
                  (func.info.data_type, v))
     file.Write("  };\n")
     file.Write("  %s& cmd = *GetBufferAs<%s>();\n" % (func.name, func.name))
     file.Write("  const GLsizei kNumElements = 2;\n")
     file.Write("  const size_t kExpectedCmdSize =\n")
     file.Write("      sizeof(cmd) + kNumElements * sizeof(%s) * %d;\n" %
                (func.info.data_type, func.info.count))
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     args = func.GetCmdArgs()
-    value = 1
-    for arg in args:
-      file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value))
-      value += 1
+    for value, arg in enumerate(args):
+      file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value + 1))
     file.Write(",\n      data);\n")
     args = func.GetCmdArgs()
-    value = 1
     file.Write("  EXPECT_EQ(static_cast<uint32>(%s::kCmdId),\n" % func.name)
     file.Write("            cmd.header.command);\n")
     file.Write("  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);\n")
-    for arg in args:
+    for value, arg in enumerate(args):
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
-                 (arg.type, value, arg.name))
-      value += 1
+                 (arg.type, value + 1, arg.name))
     file.Write("  CheckBytesWrittenMatchesExpectedSize(\n")
     file.Write("      next_cmd, sizeof(cmd) +\n")
     file.Write("      RoundSizeToMultipleOfEntries(sizeof(data)));\n")
     file.Write("  // TODO(gman): Check that data was inserted;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
 class PUTXnHandler(TypeHandler):
   """Handler for glUniform?f functions."""
@@ skipping 127 matching lines @@
           "typed_args": func.MakeTypedOriginalArgString(""),
           "args": func.MakeOriginalArgString(""),
         })
 
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
     init_code = []
     check_code = []
     all_but_last_arg = func.GetCmdArgs()[:-1]
-    value = 11
-    for arg in all_but_last_arg:
-      init_code.append("      static_cast<%s>(%d)," % (arg.type, value))
-      value += 1
-    value = 11
-    for arg in all_but_last_arg:
+    for value, arg in enumerate(all_but_last_arg):
+      init_code.append("      static_cast<%s>(%d)," % (arg.type, value + 11))
+    for value, arg in enumerate(all_but_last_arg):
       check_code.append("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);" %
-                        (arg.type, value, arg.name))
-      value += 1
+                        (arg.type, value + 11, arg.name))
     code = """
 TEST_F(GLES2FormatTest, %(func_name)s) {
   %(func_name)s& cmd = *GetBufferAs<%(func_name)s>();
   static const char* const test_str = \"test string\";
   void* next_cmd = cmd.Set(
       &cmd,
 %(init_code)s
       test_str,
       strlen(test_str));
   EXPECT_EQ(static_cast<uint32>(%(func_name)s::kCmdId),
@@ skipping 1436 matching lines @@
       'GETn': GETnHandler(),
       'GLchar': GLcharHandler(),
       'GLcharN': GLcharNHandler(),
       'HandWritten': HandWrittenHandler(),
       'Is': IsHandler(),
       'Manual': ManualHandler(),
       'PUT': PUTHandler(),
       'PUTn': PUTnHandler(),
       'PUTXn': PUTXnHandler(),
       'StateSet': StateSetHandler(),
+      'StateSetRGBAlpha': StateSetRGBAlphaHandler(),
+      'StateSetFrontBack': StateSetFrontBackHandler(),
+      'StateSetFrontBackSeparate': StateSetFrontBackSeparateHandler(),
       'STRn': STRnHandler(),
       'Todo': TodoHandler(),
     }
 
     for func_name in _FUNCTION_INFO:
       info = _FUNCTION_INFO[func_name]
       type = ''
       if 'type' in info:
         type = info['type']
       self._function_info[func_name] = FunctionInfo(info,
@@ skipping 177 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."""
+    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."""
+    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))
+    file.Write("\n")
+
+    file.Write("void ContextState::Initialize() {\n")
+    for state_name in sorted(_STATES.keys()):
+      state = _STATES[state_name]
+      for item in state['states']:
+        file.Write("  %s = %s;\n" % (item['name'], item['default']))
+    file.Write("}\n\n");
+
+    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:
       #gen_cmd = func.GetInfo('gen_cmd')
       #if gen_cmd == True or gen_cmd == None:
         func.WriteServiceImplementation(file)
 
+    file.Write("""
+bool GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
+  switch (cap) {
+""")
+    for capability in _CAPABILITY_FLAGS:
+      file.Write("    case GL_%s:\n" % capability['name'].upper())
+      if 'state_flag' in capability:
+        file.Write("""      if (state_.enable_flags.%(name)s != enabled) {
+        state_.enable_flags.%(name)s = enabled;
+        %(state_flag)s = true;
+      }
+      return false;
+""" % 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;
+  }
+}
+
+void GLES2DecoderImpl::InitCapabilities() {
+""")
+    for capability in _CAPABILITY_FLAGS:
+      file.Write("  EnableDisable(GL_%s, state_.enable_flags.%s);\n" %
+                 (capability['name'].upper(), capability['name']))
+    file.Write("""}
+
+void GLES2DecoderImpl::InitState() {
+""")
+
+    # We need to sort the keys so the expectations match
+    for state_name in sorted(_STATES.keys()):
+      state = _STATES[state_name]
+      if state['type'] == 'FrontBack':
+        num_states = len(state['states'])
+        for ndx, group in enumerate(Grouper(num_states / 2, state['states'])):
+          args = []
+          for item in group:
+            args.append('state_.%s' % item['name'])
+          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('state_.%s' % item['name'])
+        file.Write("  gl%s(%s);\n" % (state['func'], ", ".join(args)))
+    file.Write("""}
+
+bool GLES2DecoderImpl::GetState(
+    GLenum pname, GLint* params, GLsizei* num_written) {
+  switch (pname) {
+""")
+    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] = state_.%s;\n" % (ndx, 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] = state_.%s;\n" % 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] = state_.enable_flags.%s;\n" %
+                     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
       name = filename % count
       file = CHeaderWriter(
           name,
           "// It is included by gles2_cmd_decoder_unittest_%d.cc\n" % count)
       file.SetFileNum(count)
       end = test_num + FUNCTIONS_PER_FILE
       if end > num_tests:
         end = num_tests
       for idx in range(test_num, end):
         func = self.functions[idx]
         if True:
         #gen_cmd = func.GetInfo('gen_cmd')
         #if gen_cmd == True or gen_cmd == None:
           if func.GetInfo('unit_test') == False:
             file.Write("// TODO(gman): %s\n" % func.name)
           else:
             func.WriteServiceUnitTest(file)
 
       file.Close()
+    file = CHeaderWriter(
+        filename % 0,
+        "// It is included by gles2_cmd_decoder_unittest_base.cc\n")
+    file.Write(
+"""void GLES2DecoderTestBase::SetupInitCapabilitiesExpectations() {
+""")
+    for capability in _CAPABILITY_FLAGS:
+      file.Write("  ExpectEnableDisable(GL_%s, %s);\n" %
+                 (capability['name'].upper(),
+                  ('false', 'true')['default' in capability]))
+    file.Write("""}
+
+void GLES2DecoderTestBase::SetupInitStateExpectations() {
+""")
+
+    # We need to sort the keys so the expectations match
+    for state_name in sorted(_STATES.keys()):
+      state = _STATES[state_name]
+      if state['type'] == 'FrontBack':
+        num_states = len(state['states'])
+        for ndx, group in enumerate(Grouper(num_states / 2, state['states'])):
+          args = []
+          for item in group:
+            if 'expected' in item:
+              args.append(item['expected'])
+            else:
+              args.append(item['default'])
+          file.Write(
+              "  EXPECT_CALL(*gl_, %s(%s, %s))\n" %
+              (state['func'], ('GL_FRONT', 'GL_BACK')[ndx], ", ".join(args)))
+          file.Write("      .Times(1)\n")
+          file.Write("      .RetiresOnSaturation();\n")
+      else:
+        args = []
+        for item in state['states']:
+          if 'expected' in item:
+            args.append(item['expected'])
+          else:
+            args.append(item['default'])
+        file.Write("  EXPECT_CALL(*gl_, %s(%s))\n" %
+                   (state['func'], ", ".join(args)))
+        file.Write("      .Times(1)\n")
+        file.Write("      .RetiresOnSaturation();\n")
+    file.Write("""}
+""")
+    file.Close()
 
 
   def WriteGLES2CLibImplementation(self, filename):
     """Writes the GLES2 c lib implementation."""
     file = CHeaderWriter(
         filename,
         "// These functions emulate GLES2 over command buffers.\n")
 
     for func in self.original_functions:
       func.WriteGLES2CLibImplementation(file)
@@ skipping 76 matching lines @@
       if len(_ENUM_LISTS[enum]['valid']) > 0:
         file.Write("static %s valid_%s_table[] = {\n" %
                    (_ENUM_LISTS[enum]['type'], ToUnderscore(enum)))
         for value in _ENUM_LISTS[enum]['valid']:
           file.Write("  %s,\n" % value)
         file.Write("};\n")
         file.Write("\n")
     file.Write("Validators::Validators()\n")
     pre = ': '
     post = ','
-    count = 0
-    for enum in enums:
-      count += 1
-      if count == len(enums):
+    for count, enum in enumerate(enums):
+      if count + 1 == len(enums):
         post = ' {'
       if len(_ENUM_LISTS[enum]['valid']) > 0:
         code = """    %(pre)s%(name)s(
           valid_%(name)s_table, arraysize(valid_%(name)s_table))%(post)s
 """
       else:
         code = """    %(pre)s%(name)s()%(post)s
 """
       file.Write(code % {
           'name': ToUnderscore(enum),
@@ skipping 284 matching lines @@
   parser.add_option(
       "--output-dir",
       help="base directory for resulting files, under chrome/src. default is "
       "empty. Use this if you want the result stored under gen.")
   parser.add_option(
       "-v", "--verbose", action="store_true",
       help="prints more output.")
 
   (options, args) = parser.parse_args(args=argv)
 
+  # Add in states and capabilites to GLState
+  for state_name in sorted(_STATES.keys()):
+    state = _STATES[state_name]
+    if 'enum' in state:
+      _ENUM_LISTS['GLState']['valid'].append(state['enum'])
+    else:
+      for item in state['states']:
+        _ENUM_LISTS['GLState']['valid'].append(item['enum'])
+  for capability in _CAPABILITY_FLAGS:
+    _ENUM_LISTS['GLState']['valid'].append("GL_%s" % capability['name'].upper())
+
   # This script lives under gpu/command_buffer, cd to base directory.
   os.chdir(os.path.dirname(__file__) + "/../..")
 
   gen = GLGenerator(options.verbose)
   gen.ParseGLH("common/GLES2/gl2.h")
 
   # Support generating files under gen/
   if options.output_dir != None:
     os.chdir(options.output_dir)
 
@@ skipping 23 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.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:]))