Reland: Generate separate files for union type containers

third_party/WebKit/Source/bindings/scripts/utilities.py

 # Copyright 2014 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.
 
 """Utility functions (file reading, simple IDL parsing by regexes) for IDL build.
 
 Design doc: http://www.chromium.org/developers/design-documents/idl-build
 """
 
 import os
 import cPickle as pickle
+import platform
 import re
 import shlex
 import string
 import subprocess
 
 
 KNOWN_COMPONENTS = frozenset(['core', 'modules'])
 KNOWN_COMPONENTS_WITH_TESTING = frozenset(['core', 'modules', 'testing'])
 
 
@@ skipping 59 matching lines @@
 
     @property
     def typedefs(self):
         return {}
 
     @property
     def union_types(self):
         return set()
 
     @property
-    def include_path_for_union_types(self):
+    def include_path_for_union_types(self, name):
         return None
 
 
 class ComponentInfoProviderCore(ComponentInfoProvider):
     def __init__(self, interfaces_info, component_info):
         super(ComponentInfoProviderCore, self).__init__()
         self._interfaces_info = interfaces_info
         self._component_info = component_info
 
     @property
     def interfaces_info(self):
         return self._interfaces_info
 
     @property
     def component_info(self):
         return self._component_info
 
     @property
     def enumerations(self):
         return self._component_info['enumerations']
 
     @property
     def typedefs(self):
         return self._component_info['typedefs']
 
     @property
     def union_types(self):
         return self._component_info['union_types']
 
-    @property
-    def include_path_for_union_types(self):
-        return 'bindings/core/v8/UnionTypesCore.h'
+    def include_path_for_union_types(self, name):
+        return 'bindings/core/v8/%s.h' % name
 
     @property
     def specifier_for_export(self):
         return 'CORE_EXPORT '
 
     @property
     def include_path_for_export(self):
         return 'core/CoreExport.h'
 
 
@@ skipping 24 matching lines @@
         typedefs = self._component_info_core['typedefs'].copy()
         typedefs.update(self._component_info_modules['typedefs'])
         return typedefs
 
     @property
     def union_types(self):
         # Remove duplicate union types from component_info_modules to avoid
         # generating multiple container generation.
         return self._component_info_modules['union_types'] - self._component_info_core['union_types']
 
-    @property
-    def include_path_for_union_types(self):
-        return 'bindings/modules/v8/UnionTypesModules.h'
+    def include_path_for_union_types(self, name):
+        core_union_type_names = [union_type.name for union_type
+                                 in self._component_info_core['union_types']]
+        if name in core_union_type_names:
+            return 'bindings/core/v8/%s.h' % name
+        return 'bindings/modules/v8/%s.h' % name
 
     @property
     def specifier_for_export(self):
         return 'MODULES_EXPORT '
 
     @property
     def include_path_for_export(self):
         return 'modules/ModulesExport.h'
 
 
@@ skipping 106 matching lines @@
 
 
 def write_file(new_text, destination_filename, only_if_changed):
     if only_if_changed and os.path.isfile(destination_filename):
         with open(destination_filename) as destination_file:
             if destination_file.read() == new_text:
                 return
     destination_dirname = os.path.dirname(destination_filename)
     if not os.path.exists(destination_dirname):
         os.makedirs(destination_dirname)
+    # Workaround for http://crbug.com/611437
+    # TODO(bashi): Remove this hack once we resolve too-long generated file
+    # names.
+    if platform.system() == 'Windows':
+        # http://stackoverflow.com/questions/14075465
+        destination_filename = '\\\\?\\' + (
+            os.path.abspath(os.path.join(os.getcwd(), destination_filename)))

[Dirk Pranke, 2016/05/13 15:20:43]

Do we know for sure that GN, ninja, and any other tools (compilers, linkers,
etc.) that might need to access this file will actually work?

Frankly, I'm not sure that any hack that doesn't solve the problem of keeping
the filenames < 260 chars will work reliably.

[Nico, 2016/05/13 15:21:31]

+1

     with open(destination_filename, 'w') as destination_file:
         destination_file.write(new_text)
 
 
 def write_pickle_file(pickle_filename, data, only_if_changed):
     if only_if_changed and os.path.isfile(pickle_filename):
         with open(pickle_filename) as pickle_file:
             try:
                 if pickle.load(pickle_file) == data:
                     return
@@ skipping 70 matching lines @@
     extended_attributes_string = match.group(1)
     match = re.search(r'[^=]\bExposed\(([^)]*)\)', file_contents)
     if not match:
         return None
     arguments = []
     for argument in map(string.strip, match.group(1).split(',')):
         exposed, runtime_enabled = argument.split()
         arguments.append({'exposed': exposed, 'runtime_enabled': runtime_enabled})
 
     return arguments