Only generate GPU json data entries related to a given platform at build time.

gpu/config/process_json.py

 #!/usr/bin/env python
 # Copyright 2017 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.
 
 import json
 import os
 import platform
 import sys
 from optparse import OptionParser
@@ skipping 482 matching lines @@
   data_helper_file.write('%s,  // gl_reset_notification_strategy\n' %
                          gl_reset_notification_strategy)
   write_boolean_value(direct_rendering, 'direct_rendering', data_helper_file)
   write_version(gpu_count, 'gpu_count', data_helper_file)
   data_helper_file.write('};\n\n')
   # reference more data in entry
   data_file.write('&%s,  // more data\n' % var_name)
 
 
 def write_entry(entry, total_feature_set, feature_name_prefix,
-                  data_file, data_helper_file, data_exception_file):
+                data_file, data_helper_file, data_exception_file):
   data_file.write('{\n')
   # ID
   entry_id = entry['id']
   data_file.write('%d,  // id\n' % entry_id)
   data_file.write('"%s",\n' % entry['description']);
   # Features
   if 'features' in entry:
     features = entry['features']
     feature_set = get_feature_set(features, total_feature_set)
     data_file.write('arraysize(kFeatureListForEntry%d),  // features size\n' %
@@ skipping 61 matching lines @@
   if begin:
     file.write('#ifndef %s\n#define %s\n\n' % (token, token))
   else:
     file.write('\n#endif  // %s\n' % token)
 
 
 def process_json_file(json_filepath, list_tag,
                       feature_header_filename, total_features, feature_tag,
                       output_header_filepath, output_data_filepath,
                       output_helper_filepath, output_exception_filepath, path,
-                      export_tag, git_format):
+                      export_tag, git_format, os_filter):
   output_header_filename = os.path.basename(output_header_filepath)
   output_helper_filename = os.path.basename(output_helper_filepath)
   output_exception_filename = os.path.basename(output_exception_filepath)
   json_file = open(json_filepath, 'rb')
   json_data = json.load(json_file)
   json_file.close()
   data_file = open(output_data_filepath, 'wb')
   data_file.write(_LICENSE)
   data_file.write(_DO_NOT_EDIT_WARNING)
   data_file.write('#include "%s/%s"\n\n' % (path, output_header_filename))
   data_file.write('#include "%s/%s"\n' % (path, output_helper_filename))
   data_file.write('#include "%s/%s"\n\n' % (path, output_exception_filename))
   data_helper_file = open(output_helper_filepath, 'wb')
   data_helper_file.write(_LICENSE)
   data_helper_file.write(_DO_NOT_EDIT_WARNING)
   write_header_file_guard(data_helper_file, output_helper_filename, path, True)
   data_helper_file.write('#include "gpu/config/%s"\n\n' %
                          feature_header_filename)
   data_helper_file.write('namespace gpu {\n')
   data_exception_file = open(output_exception_filepath, 'wb')
   data_exception_file.write(_LICENSE)
   data_exception_file.write(_DO_NOT_EDIT_WARNING)
   write_header_file_guard(data_exception_file, output_exception_filename, path,
                           True)
   data_exception_file.write('namespace gpu {\n')
   data_file.write('namespace gpu {\n\n')
   data_file.write('const char k%sVersion[] = "%s";\n\n' %
                   (list_tag, json_data['version']))
-  entry_count = len(json_data['entries'])
-  data_file.write('const size_t k%sEntryCount = %d;\n' %
-                  (list_tag, entry_count))
-  data_file.write('const GpuControlList::Entry k%sEntries[%d] = {\n' %
-                  (list_tag, entry_count))
+  data_file.write('const GpuControlList::Entry k%sEntries[] = {\n' % list_tag)
   ids = []
-  for index in range(entry_count):
+  entry_count = 0
+  for index in range(len(json_data['entries'])):
     entry = json_data['entries'][index]
     entry_id = entry['id']
     assert entry_id not in ids
     ids.append(entry_id)
+    if os_filter != None and 'os' in entry and entry['os']['type'] != os_filter:
+      continue
+    entry_count += 1
     write_entry(entry, total_features, feature_tag,
                 data_file, data_helper_file, data_exception_file)
   data_file.write('};\n')
+  data_file.write('const size_t k%sEntryCount = %d;\n' %
+                  (list_tag, entry_count))
   data_file.write('}  // namespace gpu\n')
   data_file.close()
   data_helper_file.write('}  // namespace gpu\n')
   write_header_file_guard(data_helper_file, output_helper_filename, path, False)
   data_helper_file.close()
   data_exception_file.write('}  // namespace gpu\n')
   write_header_file_guard(data_exception_file, output_exception_filename, path,
                           False)
   data_exception_file.close()
   data_header_file = open(output_header_filepath, 'wb')
@@ skipping 13 matching lines @@
       '%sextern const GpuControlList::Entry k%sEntries[];\n' %
       (export_tag, list_tag))
   data_header_file.write('}  // namespace gpu\n')
   write_header_file_guard(data_header_file, output_header_filename, path, False)
   data_header_file.close()
   if git_format:
     format_files([output_header_filepath, output_data_filepath,
                   output_helper_filepath, output_exception_filepath])
 
 
-def process_software_rendering_list(script_dir, output_dir):
+def process_software_rendering_list(script_dir, output_dir, os_filter):
   total_features = load_software_rendering_list_features(
       os.path.join(script_dir, 'gpu_feature_type.h'))
   process_json_file(
       os.path.join(script_dir, 'software_rendering_list.json'),
       'SoftwareRenderingList',
       'gpu_feature_type.h',
       total_features,
       'GPU_FEATURE_TYPE_',
       os.path.join(output_dir, 'software_rendering_list_autogen.h'),
       os.path.join(output_dir, 'software_rendering_list_autogen.cc'),
       os.path.join(output_dir,
                    'software_rendering_list_arrays_and_structs_autogen.h'),
       os.path.join(output_dir, 'software_rendering_list_exceptions_autogen.h'),
       'gpu/config',
       'GPU_EXPORT ',
-      False)
+      False,
+      os_filter)
 
 
-def process_gpu_driver_bug_list(script_dir, output_dir):
+def process_gpu_driver_bug_list(script_dir, output_dir, os_filter):
   total_features = load_gpu_driver_bug_workarounds(
       os.path.join(script_dir, 'gpu_driver_bug_workaround_type.h'))
   process_json_file(
       os.path.join(script_dir, 'gpu_driver_bug_list.json'),
       'GpuDriverBugList',
       'gpu_driver_bug_workaround_type.h',
       total_features,
       '',
       os.path.join(output_dir, 'gpu_driver_bug_list_autogen.h'),
       os.path.join(output_dir, 'gpu_driver_bug_list_autogen.cc'),
       os.path.join(output_dir,
                    'gpu_driver_bug_list_arrays_and_structs_autogen.h'),
       os.path.join(output_dir, 'gpu_driver_bug_list_exceptions_autogen.h'),
       'gpu/config',
       'GPU_EXPORT ',
-      False)
+      False,
+      os_filter)
 
 
 def process_gpu_control_list_testing(script_dir, output_dir):
   total_features = ['test_feature_0', 'test_feature_1', 'test_feature_2']
   process_json_file(
       os.path.join(script_dir, 'gpu_control_list_testing.json'),
       'GpuControlListTesting',
       'gpu_control_list_testing_data.h',
       total_features,
       '',
       os.path.join(output_dir, 'gpu_control_list_testing_autogen.h'),
       os.path.join(output_dir, 'gpu_control_list_testing_autogen.cc'),
       os.path.join(output_dir,
                    'gpu_control_list_testing_arrays_and_structs_autogen.h'),
       os.path.join(output_dir, 'gpu_control_list_testing_exceptions_autogen.h'),
       'gpu/config',
       '',
-      True)
+      True,
+      None)
 
 
 def process_gpu_data_manager_testing(script_dir, output_dir):
   total_features = load_software_rendering_list_features(
       os.path.join(script_dir, 'gpu_feature_type.h'))
   process_json_file(
       os.path.join(output_dir, 'gpu_data_manager_testing.json'),
       'GpuDataManagerTesting',
       'gpu_feature_type.h',
       total_features,
       'GPU_FEATURE_TYPE_',
       os.path.join(output_dir, 'gpu_data_manager_testing_autogen.h'),
       os.path.join(output_dir, 'gpu_data_manager_testing_autogen.cc'),
       os.path.join(output_dir,
                    'gpu_data_manager_testing_arrays_and_structs_autogen.h'),
       os.path.join(output_dir, 'gpu_data_manager_testing_exceptions_autogen.h'),
       'content/browser/gpu',
       '',
-      True)
+      True,
+      None)
 
 
 def write_test_entry_enums(input_json_filepath, output_entry_enums_filepath,
                            path, list_tag):
   json_file = open(input_json_filepath, 'rb')
   json_data = json.load(json_file)
   json_file.close()
 
   output_entry_enums_filename = os.path.basename(output_entry_enums_filepath)
   enum_file = open(output_entry_enums_filepath, 'wb')
@@ skipping 20 matching lines @@
 
 def main(argv):
   parser = OptionParser()
   parser.add_option("--output-dir",
                     help="output directory for SoftwareRenderingList and "
                     "GpuDriverBugList data files. "
                     "If unspecified, these files are not generated.")
   parser.add_option("--skip-testing-data", action="store_false",
                     dest="generate_testing_data", default=True,
                     help="skip testing data generation.")
+  parser.add_option("--os-filter",
+                    help="only output entries applied to the specified os.")
   (options, args) = parser.parse_args(args=argv)
 
   script_dir = os.path.dirname(os.path.realpath(__file__))
 
   if options.output_dir != None:
-    process_software_rendering_list(script_dir, options.output_dir)
-    process_gpu_driver_bug_list(script_dir, options.output_dir)
+    process_software_rendering_list(
+        script_dir, options.output_dir, options.os_filter)
+    process_gpu_driver_bug_list(
+        script_dir, options.output_dir, options.os_filter)
 
   if options.generate_testing_data:
     # Testing data files are generated by calling the script manually.
     process_gpu_control_list_testing(script_dir, script_dir)
     write_test_entry_enums(
         os.path.join(script_dir, 'gpu_control_list_testing.json'),
         os.path.join(script_dir,
                      'gpu_control_list_testing_entry_enums_autogen.h'),
         'gpu/config',
         'GpuControlListTesting')
     chrome_root_dir = os.path.abspath(os.path.join(script_dir, '../../'))
     gpu_data_manager_dir = os.path.join(chrome_root_dir, 'content/browser/gpu')
     process_gpu_data_manager_testing(script_dir, gpu_data_manager_dir)
     write_test_entry_enums(
         os.path.join(gpu_data_manager_dir, 'gpu_data_manager_testing.json'),
         os.path.join(gpu_data_manager_dir,
                      'gpu_data_manager_testing_entry_enums_autogen.h'),
         'content/browser/gpu',
         'GpuDataManagerTesting')
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))