Check for and skip long paths when importing w3c tests.

third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer.py

 # Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 #
 # 1. Redistributions of source code must retain the above
 #    copyright notice, this list of conditions and the following
 #    disclaimer.
 # 2. Redistributions in binary form must reproduce the above
@@ skipping 69 matching lines @@
 from webkitpy.common.webkit_finder import WebKitFinder
 from webkitpy.common.system.executive import ScriptError
 from webkitpy.layout_tests.models.test_expectations import TestExpectationParser
 from webkitpy.w3c.test_parser import TestParser
 from webkitpy.w3c.test_converter import convert_for_webkit
 
 
 CHANGESET_NOT_AVAILABLE = 'Not Available'
 
 
+# Maximum length of import path starting from top of source repository.
+# This limit is here because the Windows builders cannot create paths that are
+# longer than the Windows max path length (260). See http://crbug.com/609871.
+MAX_PATH_LENGTH = 125
+
+
 _log = logging.getLogger(__name__)
 
 
 def main(_argv, _stdout, _stderr):
     options, args = parse_args()
     host = Host()
     dir_to_import = host.filesystem.normpath(os.path.abspath(args[0]))
     if len(args) == 1:
         top_of_repo = dir_to_import
     else:
@@ skipping 73 matching lines @@
         self.import_list = []
 
     def do_import(self):
         _log.info("Importing %s into %s", self.dir_to_import, self.destination_directory)
         self.find_importable_tests(self.dir_to_import)
         self.load_changeset()
         self.import_tests()
 
     def load_changeset(self):
         """Returns the current changeset from mercurial or "Not Available"."""
+        # TODO(qyearsley): Remove this, since mercurial isn't used for w3c repos any more, so this is not applicable.
         try:
             self.changeset = self.host.executive.run_command(['hg', 'tip']).split('changeset:')[1]
         except (OSError, ScriptError):
             self.changeset = CHANGESET_NOT_AVAILABLE
 
     def find_importable_tests(self, directory):
         paths_to_skip = self.find_paths_to_skip()
 
         for root, dirs, files in self.filesystem.walk(directory):
             cur_dir = root.replace(self.dir_above_repo + '/', '') + '/'
@@ skipping 144 matching lines @@
 
                 if self.filesystem.isdir(orig_filepath):
                     # FIXME: Figure out what is triggering this and what to do about it.
                     _log.error('%s refers to a directory' % orig_filepath)
                     continue
 
                 if not self.filesystem.exists(orig_filepath):
                     _log.warning('%s not found. Possible error in the test.', orig_filepath)
                     continue
 
+                if self.path_too_long(orig_filepath):
+                    _log.warning('%s skipped (longer than %d chars), to avoid hitting Windows max path length on builders.',

[Dirk Pranke, 2016/05/13 18:01:41]

I'd actually include the bug number in the message.

[qyearsley, 2016/05/13 21:45:19]

Done now.

+                                 orig_filepath, MAX_PATH_LENGTH)
+                    continue
+
                 new_filepath = self.filesystem.join(new_path, file_to_copy['dest'])
                 if 'reference_support_info' in file_to_copy.keys() and file_to_copy['reference_support_info'] != {}:
                     reference_support_info = file_to_copy['reference_support_info']
                 else:
                     reference_support_info = None
 
                 if not self.filesystem.exists(self.filesystem.dirname(new_filepath)):
                     if not self.import_in_place and not self.options.dry_run:
                         self.filesystem.maybe_make_directory(self.filesystem.dirname(new_filepath))
 
@@ skipping 39 matching lines @@
         _log.info('Imported %d reftests', total_imported_reftests)
         _log.info('Imported %d JS tests', total_imported_jstests)
         _log.info('Imported %d pixel/manual tests', total_imported_tests - total_imported_jstests - total_imported_reftests)
         _log.info('')
 
         if total_prefixed_properties:
             _log.info('Properties needing prefixes (by count):')
             for prefixed_property in sorted(total_prefixed_properties, key=lambda p: total_prefixed_properties[p]):
                 _log.info('  %s: %s', prefixed_property, total_prefixed_properties[prefixed_property])
 
+    def path_too_long(self, source_path):
+        """Checks whether a source path is too long to import.
+
+        Args:
+          Absolute path of file to be imported.
+        """
+        path_from_repo_base = os.path.relpath(source_path, self.top_of_repo)
+        return len(path_from_repo_base) > MAX_PATH_LENGTH
+
     def setup_destination_directory(self):
         """ Creates a destination directory that mirrors that of the source directory """
 
         new_subpath = self.dir_to_import[len(self.top_of_repo):]
 
         destination_directory = self.filesystem.join(self.destination_directory, new_subpath)
 
         if not self.filesystem.exists(destination_directory):
             self.filesystem.maybe_make_directory(destination_directory)
 
         _log.info('Tests will be imported into: %s', destination_directory)