Upgrade PixelStorei to ES3/WebGL2.

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 396 matching lines @@
         'name': 'pack_alignment',
         'type': 'GLint',
         'enum': 'GL_PACK_ALIGNMENT',
         'default': '4'
       },
       {
         'name': 'unpack_alignment',
         'type': 'GLint',
         'enum': 'GL_UNPACK_ALIGNMENT',
         'default': '4'
+      },
+      {
+        'name': 'pack_row_length',
+        'type': 'GLint',
+        'enum': 'GL_PACK_ROW_LENGTH',
+        'default': '0',
+        'es3': True
+      },
+      {
+        'name': 'pack_skip_pixels',
+        'type': 'GLint',
+        'enum': 'GL_PACK_SKIP_PIXELS',
+        'default': '0',
+        'es3': True
+      },
+      {
+        'name': 'pack_skip_rows',
+        'type': 'GLint',
+        'enum': 'GL_PACK_SKIP_ROWS',
+        'default': '0',
+        'es3': True
+      },
+      {
+        'name': 'unpack_row_length',
+        'type': 'GLint',
+        'enum': 'GL_UNPACK_ROW_LENGTH',
+        'default': '0',
+        'es3': True
+      },
+      {
+        'name': 'unpack_image_height',
+        'type': 'GLint',
+        'enum': 'GL_UNPACK_IMAGE_HEIGHT',
+        'default': '0',
+        'es3': True
+      },
+      {
+        'name': 'unpack_skip_pixels',
+        'type': 'GLint',
+        'enum': 'GL_UNPACK_SKIP_PIXELS',
+        'default': '0',
+        'es3': True
+      },
+      {
+        'name': 'unpack_skip_rows',
+        'type': 'GLint',
+        'enum': 'GL_UNPACK_SKIP_ROWS',
+        'default': '0',
+        'es3': True
+      },
+      {
+        'name': 'unpack_skip_images',
+        'type': 'GLint',
+        'enum': 'GL_UNPACK_SKIP_IMAGES',
+        'default': '0',
+        'es3': True
       }
     ],
   },
   # TODO: Consider implemenenting these states
   # GL_ACTIVE_TEXTURE
   'LineWidth': {
     'type': 'Normal',
     'func': 'LineWidth',
     'enum': 'GL_LINE_WIDTH',
     'states': [
@@ skipping 9739 matching lines @@
               if test_prev:
                 f.write(")\n")
               f.write(
                   "  gl%s(%s, %s);\n" %
                   (state['func'], ('GL_FRONT', 'GL_BACK')[ndx],
                    ", ".join(args)))
           elif state['type'] == 'NamedParameter':
             for item in state['states']:
               item_name = CachedStateName(item)
 
+              if 'es3' in item:
+                assert item['es3']
+                f.write("  if (feature_info_->IsES3Capable()) {\n");
               if 'extension_flag' in item:
                 f.write("  if (feature_info_->feature_flags().%s) {\n  " %
                            item['extension_flag'])
               if test_prev:
                 if isinstance(item['default'], list):
                   f.write("  if (memcmp(prev_state->%s, %s, "
                              "sizeof(%s) * %d)) {\n" %
                              (item_name, item_name, item['type'],
                               len(item['default'])))
                 else:
                   f.write("  if (prev_state->%s != %s) {\n  " %
                              (item_name, item_name))
               if 'gl_version_flag' in item:
                 item_name = item['gl_version_flag']
                 inverted = ''
                 if item_name[0] == '!':
                   inverted = '!'
                   item_name = item_name[1:]
                 f.write("  if (%sfeature_info_->gl_version_info().%s) {\n" %
                            (inverted, item_name))
               f.write("  gl%s(%s, %s);\n" %
                          (state['func'],
                           (item['enum_set']
                              if 'enum_set' in item else item['enum']),
                           item['name']))
-              if 'gl_version_flag' in item:
+              if 'gl_version_flag' in item or 'es3' in item:
                 f.write("  }\n")
               if test_prev:
                 if 'extension_flag' in item:
                   f.write("  ")
                 f.write("  }")
               if 'extension_flag' in item:
                 f.write("  }")
           else:
             if 'extension_flag' in state:
               f.write("  if (feature_info_->feature_flags().%s)\n  " %
@@ skipping 176 matching lines @@
       f.write("  if (es3_capable) {")
       for capability in _CAPABILITY_FLAGS:
         capability_es3 = 'es3' in capability and capability['es3'] == True
         if capability_es3:
           f.write("    ExpectEnableDisable(GL_%s, %s);\n" %
                      (capability['name'].upper(),
                       ('false', 'true')['default' in capability]))
       f.write("""  }
 }
 
-void GLES2DecoderTestBase::SetupInitStateExpectations() {
+void GLES2DecoderTestBase::SetupInitStateExpectations(bool es3_capable) {
 """)
       # 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'])
             f.write(
                 "  EXPECT_CALL(*gl_, %s(%s, %s))\n" %
                 (state['func'], ('GL_FRONT', 'GL_BACK')[ndx], ", ".join(args)))
             f.write("      .Times(1)\n")
             f.write("      .RetiresOnSaturation();\n")
         elif state['type'] == 'NamedParameter':
           for item in state['states']:
             if 'extension_flag' in item:
               f.write("  if (group_->feature_info()->feature_flags().%s) {\n" %
                          item['extension_flag'])
               f.write("  ")
+            if 'es3' in item:
+              assert item['es3']
+              f.write("  if (es3_capable) {\n")
+              f.write("  ")
             expect_value = item['default']
             if isinstance(expect_value, list):
               # TODO: Currently we do not check array values.
               expect_value = "_"
 
             f.write(
                 "  EXPECT_CALL(*gl_, %s(%s, %s))\n" %
                 (state['func'],
                  (item['enum_set']
                              if 'enum_set' in item else item['enum']),
                  expect_value))
             f.write("      .Times(1)\n")
             f.write("      .RetiresOnSaturation();\n")
-            if 'extension_flag' in item:
+            if 'extension_flag' in item or 'es3' in item:
               f.write("  }\n")
         else:
           if 'extension_flag' in state:
             f.write("  if (group_->feature_info()->feature_flags().%s) {\n" %
                        state['extension_flag'])
             f.write("  ")
           args = []
           for item in state['states']:
             if 'expected' in item:
               args.append(item['expected'])
@@ skipping 314 matching lines @@
 
 """)
 
       enums = sorted(_NAMED_TYPE_INFO.keys())
       for enum in enums:
         if _NAMED_TYPE_INFO[enum]['type'] == 'GLenum':
           f.write("std::string GLES2Util::GetString%s(uint32_t value) {\n" %
                      enum)
           valid_list = _NAMED_TYPE_INFO[enum]['valid']
           if 'valid_es3' in _NAMED_TYPE_INFO[enum]:
-            valid_list = valid_list + _NAMED_TYPE_INFO[enum]['valid_es3']
+            for es3_enum in _NAMED_TYPE_INFO[enum]['valid_es3']:
+              if not es3_enum in valid_list:
+                valid_list.append(es3_enum)
           assert len(valid_list) == len(set(valid_list))
           if len(valid_list) > 0:
             f.write("  static const EnumToString string_table[] = {\n")
             for value in valid_list:
               f.write('    { %s, "%s" },\n' % (value, value))
             f.write("""  };
   return GLES2Util::GetQualifiedEnumString(
       string_table, arraysize(string_table), value);
 }
 
@@ skipping 220 matching lines @@
       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
   gl_state_valid = _NAMED_TYPE_INFO['GLState']['valid']
+  gl_state_valid_es3 = _NAMED_TYPE_INFO['GLState']['valid_es3']
   for state_name in sorted(_STATES.keys()):
     state = _STATES[state_name]
     if 'extension_flag' in state:
       continue
     if 'enum' in state:
       if not state['enum'] in gl_state_valid:
         gl_state_valid.append(state['enum'])
     else:
       for item in state['states']:
         if 'extension_flag' in item:
           continue
-        if not item['enum'] in gl_state_valid:
-          gl_state_valid.append(item['enum'])
+        if 'es3' in item:
+          assert item['es3']
+          if not item['enum'] in gl_state_valid_es3:
+            gl_state_valid_es3.append(item['enum'])
+        else:
+          if not item['enum'] in gl_state_valid:
+            gl_state_valid.append(item['enum'])
   for capability in _CAPABILITY_FLAGS:
     valid_value = "GL_%s" % capability['name'].upper()
     if not valid_value in gl_state_valid:
       gl_state_valid.append(valid_value)
 
   # This script lives under gpu/command_buffer, cd to base directory.
   os.chdir(os.path.dirname(__file__) + "/../..")
   base_dir = os.getcwd()
   gen = GLGenerator(options.verbose)
   gen.ParseGLH("gpu/command_buffer/cmd_buffer_functions.txt")
@@ skipping 69 matching lines @@
   Format(gen.generated_cpp_filenames)
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))