Remove usage of TestParser from test_copier.py.

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 18 matching lines @@
 
 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
 
 from webkitpy.common.webkit_finder import WebKitFinder
 from webkitpy.layout_tests.models.test_expectations import TestExpectationParser
-from webkitpy.w3c.test_parser import TestParser
 
 _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:
@@ skipping 36 matching lines @@
         """Walks through the source directory to find what tests should be imported.
 
         This function sets self.import_list, which contains information about how many
         tests are being imported, and their source and destination paths.
         """
         paths_to_skip = self.find_paths_to_skip()
 
         for root, dirs, files in self.filesystem.walk(self.source_repo_path):
             cur_dir = root.replace(self.dir_above_repo + '/', '') + '/'
             _log.debug('Scanning %s...', cur_dir)
-            total_tests = 0
-            reftests = 0
-            jstests = 0
 
             # Files in 'tools' are not for browser testing, so we skip them.
             # See: http://web-platform-tests.org/writing-tests/general-guidelines.html#tools
             dirs_to_skip = ('.git', 'test-plan', 'tools')
 
-            # We copy all files in 'support', including HTML without metadata.
-            # See: http://web-platform-tests.org/writing-tests/general-guidelines.html#support-files
-            dirs_to_include = ('resources', 'support')
-
             if dirs:
                 for name in dirs_to_skip:
                     if name in dirs:
                         dirs.remove(name)
 
                 for path in paths_to_skip:
                     path_base = path.replace(self.dest_dir_name + '/', '')
                     path_base = path_base.replace(cur_dir, '')
                     path_full = self.filesystem.join(root, path_base)
                     if path_base in dirs:
@@ skipping 22 matching lines @@
                     _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
 
-                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
-
-                    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})
+                copy_list.append({'src': path_full, 'dest': filename})
 
             if copy_list:
                 # Only add this directory to the list if there's something to import
-                self.import_list.append({'dirname': root, 'copy_list': copy_list,
-                                         'reftests': reftests, 'jstests': jstests, 'total_tests': total_tests})
+                self.import_list.append({'dirname': root, 'copy_list': copy_list})
 
     def find_paths_to_skip(self):
         paths_to_skip = set()
         port = self.host.port_factory.get()
         w3c_import_expectations_path = self.webkit_finder.path_from_webkit_base('LayoutTests', 'W3CImportExpectations')
         w3c_import_expectations = self.filesystem.read_text_file(w3c_import_expectations_path)
         parser = TestExpectationParser(port, all_tests=(), is_lint_mode=False)
         expectation_lines = parser.parse(w3c_import_expectations_path, w3c_import_expectations)
         for line in expectation_lines:
             if 'SKIP' in line.expectations:
                 if line.specifiers:
                     _log.warning('W3CImportExpectations:%s should not have any specifiers', line.line_numbers)
                     continue
                 paths_to_skip.add(line.name)
         return paths_to_skip
 
     def import_tests(self):
         """Reads |self.import_list|, and converts and copies files to their destination."""
-        total_imported_tests = 0
-        total_imported_reftests = 0
-        total_imported_jstests = 0
-
         for dir_to_copy in self.import_list:
-            total_imported_tests += dir_to_copy['total_tests']
-            total_imported_reftests += dir_to_copy['reftests']
-            total_imported_jstests += dir_to_copy['jstests']
-
             if not dir_to_copy['copy_list']:
                 continue
 
             orig_path = dir_to_copy['dirname']
 
             relative_dir = self.filesystem.relpath(orig_path, self.source_repo_path)
             dest_dir = self.filesystem.join(self.destination_directory, relative_dir)
 
             if not self.filesystem.exists(dest_dir):
                 self.filesystem.maybe_make_directory(dest_dir)
 
             copied_files = []
 
             for file_to_copy in dir_to_copy['copy_list']:
                 copied_file = self.copy_file(file_to_copy, dest_dir)
                 if copied_file:
                     copied_files.append(copied_file)
 
         _log.info('')
         _log.info('Import complete')
         _log.info('')
-        _log.info('IMPORTED %d TOTAL TESTS', total_imported_tests)
-        _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 self._prefixed_properties:
             _log.info('Properties needing prefixes (by count):')
             for prefixed_property in sorted(self._prefixed_properties, key=lambda p: self._prefixed_properties[p]):
                 _log.info('  %s: %s', prefixed_property, self._prefixed_properties[prefixed_property])
 
     def copy_file(self, file_to_copy, dest_dir):
         """Converts and copies a file, if it should be copied.
 
         Args:
@@ skipping 28 matching lines @@
         # In other words, there's no sense in overwriting identical files, but
         # there's no harm in copying the identical thing.
         _log.debug('  copying %s', relpath)
 
         if not self.import_in_place:
             self.filesystem.copyfile(source_path, dest_path)
             if self.filesystem.read_binary_file(source_path)[:2] == '#!':
                 self.filesystem.make_executable(dest_path)
 
         return dest_path.replace(self._webkit_root, '')