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 98 matching lines @@
         idl_file_names.extend(resolve_cygpath(cygdrive_names))
         return idl_file_names
 
 
 def read_pickle_files(pickle_filenames):
     for pickle_filename in pickle_filenames:
         with open(pickle_filename) as pickle_file:
             yield pickle.load(pickle_file)
 
 
 def write_file(new_text, destination_filename, only_if_changed):

[ncarter (slow), 2016/05/13 18:59:32]

Just doing the following seems to fix the problem:

    destination_filename = os.path.normpath(os.path.join(os.getcwd(),
                                            destination_filename))

(note that os.path.abspath won't work -- it seems to fail when the
concatentation of cwd + arg is over the MAX_PATH limit.)

     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 = '\\\\?\\' + destination_filename
     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