Remove long path check in test import process.

third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_copier.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 15 matching lines @@
 # SUCH DAMAGE.
 
 """Logic for converting and copying files from a W3C repo.
 
 This module is responsible for modifying and copying a subset of the tests from
 a local W3C repository source directory into a destination directory.
 """
 
 import logging
 import mimetypes
-import os
 import re
 
 from webkitpy.common.webkit_finder import WebKitFinder
 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
 
-# Maximum length of import path relative to the upstream repository base.
-# This limit is here because the Windows builders cannot create paths that are
-# longer than the Windows max path length (260). If the absolute path to the
-# destination directory is up to 100 characters on Windows, then that would
-# give us 160 characters from the base of the upstream repo.
-# See: http://crbug.com/609871.
-MAX_PATH_LENGTH = 160
-
 _log = logging.getLogger(__name__)
 
 
 class TestCopier(object):
 
     def __init__(self, host, source_repo_path, dest_dir_name='external'):
         """Initializes variables to prepare for copying and converting files.
 
         Args:
             host: An instance of Host.
             source_repo_path: Path to the local checkout of a
-            web-platform-tests or csswg-test repository.
+                web-platform-tests or csswg-test repository.
             dest_dir_name: The name of the directory under the layout tests
                 directory where imported tests should be copied to.
                 TODO(qyearsley): This can be made into a constant.
         """
         self.host = host
 
         assert self.host.filesystem.exists(source_repo_path)
         self.source_repo_path = source_repo_path
         self.dest_dir_name = dest_dir_name
 
@@ skipping 76 matching lines @@
 
                 if filename.startswith('.') or filename.endswith('.pl'):
                     _log.debug('Skipping: %s', path_full)
                     _log.debug('  Reason: Hidden files and perl scripts are not necessary.')
                     continue
                 if filename == 'OWNERS' or filename == 'reftest.list':
                     # See http://crbug.com/584660 and http://crbug.com/582838.
                     _log.debug('Skipping: %s', path_full)
                     _log.debug('  Reason: This file may cause Chromium presubmit to fail.')
                     continue
-                if self.path_too_long(path_full):
-                    _log.warning('Skipping: %s', path_full)
-                    _log.warning('  Reason: Long path. Max length %d; see http://crbug.com/609871.', MAX_PATH_LENGTH)
-                    continue
 
                 mimetype = mimetypes.guess_type(path_full)
                 if ('html' not in str(mimetype[0]) and
                         'application/xhtml+xml' not in str(mimetype[0]) and
                         'application/xml' not in str(mimetype[0])):
                     copy_list.append({'src': path_full, 'dest': filename})
                     continue
 
                 if self.filesystem.basename(root) in dirs_to_include:
                     copy_list.append({'src': path_full, 'dest': filename})
                     continue
 
                 test_parser = TestParser(path_full, self.host)
                 test_info = test_parser.analyze_test()
                 if test_info is None:
                     copy_list.append({'src': path_full, 'dest': filename})
                     continue
 
                 if 'reference' in test_info.keys():
                     ref_path_full = test_info['reference']
                     if not self.filesystem.exists(ref_path_full):
                         _log.warning('Skipping: %s', path_full)
                         _log.warning('  Reason: Ref file "%s" was not found.', ref_path_full)
                         continue
 
-                    if self.is_wpt:
-                        if self.path_too_long(ref_path_full):
-                            _log.warning('Skipping: %s', path_full)
-                            _log.warning('  Reason: Ref file path length would be too long: %s.', ref_path_full)
-                            _log.warning('  Max length %d; see http://crbug.com/609871.', MAX_PATH_LENGTH)
-                            continue
-                        # For WPT, we don't need to rename the reference file to
-                        # WebKit style name.
-                        # We don't ask to copy ref_path_full here because this
-                        # filesystem walk will find the reference file, and copy
-                        # it as a non-test file.
-                    else:
+                    if not self.is_wpt:
+                        # For csswg-test, we still need to add a ref file
+                        # using WebKit naming conventions. See crbug.com/268729.
+                        # FIXME: Remove this when csswg-test is merged into wpt.
                         test_basename = self.filesystem.basename(test_info['test'])
-                        # Add the ref file, following WebKit style.
-                        # FIXME: Ideally we'd support reading the metadata
-                        # directly rather than relying on a naming convention.
-                        # Using a naming convention creates duplicate copies of the
-                        # reference files (http://crrev.com/268729).
                         ref_file = self.filesystem.splitext(test_basename)[0] + '-expected'
-                        # Make sure to use the extension from the *reference*, not
-                        # from the test, because at least flexbox tests use XHTML
-                        # references but HTML tests.
                         ref_file += self.filesystem.splitext(ref_path_full)[1]
-
-                        if self.path_too_long(path_full.replace(filename, ref_file)):
-                            _log.warning('Skipping: %s', path_full)
-                            _log.warning('  Reason: Ref file path length would be too long: %s.', ref_file)
-                            _log.warning('  Max length %d; see http://crbug.com/609871.', MAX_PATH_LENGTH)
-                            continue
-                        copy_list.append({'src': test_info['reference'], 'dest': ref_file,
-                                          'reference_support_info': test_info['reference_support_info']})
+                        copy_list.append({
+                            'src': test_info['reference'],
+                            'dest': ref_file,
+                            'reference_support_info': test_info['reference_support_info'],
+                        })
 
                     reftests += 1
                     total_tests += 1
                     copy_list.append({'src': test_info['test'], 'dest': filename})
 
                 elif 'jstest' in test_info.keys():
                     jstests += 1
                     total_tests += 1
                     copy_list.append({'src': path_full, 'dest': filename, 'is_jstest': True})
 
@@ skipping 123 matching lines @@
             return False
 
         # Conversion is not necessary for any tests in wpt now; see http://crbug.com/654081.
         # Note, we want to move away from converting files, see http://crbug.com/663773.
         if re.search(r'[/\\]external[/\\]wpt[/\\]', dest_dir):
             return False
 
         # Only HTML, XHTML and CSS files should be converted.
         mimetype, _ = mimetypes.guess_type(source_path)
         return mimetype in ('text/html', 'application/xhtml+xml', 'text/css')
-
-    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.
-
-        Returns:
-            True if the path is too long to import, False if it's OK.
-        """
-        path_from_repo_base = os.path.relpath(source_path, self.source_repo_path)
-        return len(path_from_repo_base) > MAX_PATH_LENGTH