Rename WebKitFinder -> BlinkFinder.

third_party/WebKit/Tools/Scripts/webkitpy/w3c/deps_updater.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.
 
 """Fetches a copy of the latest state of a W3C test repository and commits.
 
 If this script is given the argument --auto-update, it will also attempt to
 upload a CL, triggery try jobs, and make any changes that are required for
 new failing tests before committing.
 """
 
 import logging
 import argparse
 import json
 
 from webkitpy.common.net.git_cl import GitCL
-from webkitpy.common.webkit_finder import WebKitFinder
+from webkitpy.common.blink_finder import BlinkFinder
 from webkitpy.layout_tests.models.test_expectations import TestExpectations, TestExpectationParser
 
 # Import destination directories (under LayoutTests/imported/).
 WPT_DEST_NAME = 'wpt'
 CSS_DEST_NAME = 'csswg-test'
 
 # Our mirrors of the official w3c repos, which we pull from.
 WPT_REPO_URL = 'https://chromium.googlesource.com/external/w3c/web-platform-tests.git'
 CSS_REPO_URL = 'https://chromium.googlesource.com/external/w3c/csswg-test.git'
 
 
 _log = logging.getLogger(__file__)
 
 
 class DepsUpdater(object):
 
     def __init__(self, host):
         self.host = host
         self.executive = host.executive
         self.fs = host.filesystem
-        self.finder = WebKitFinder(self.fs)
+        self.finder = BlinkFinder(self.fs)
         self.verbose = False
         self.git_cl = None
 
     def main(self, argv=None):
         options = self.parse_args(argv)
         self.verbose = options.verbose
         log_level = logging.DEBUG if self.verbose else logging.INFO
         logging.basicConfig(level=log_level, format='%(message)s')
 
         if not self.checkout_is_okay(options.allow_local_commits):
@@ skipping 43 matching lines @@
         git_diff_retcode, _ = self.run(['git', 'diff', '--quiet', 'HEAD'], exit_on_failure=False)
         if git_diff_retcode:
             _log.warning('Checkout is dirty; aborting.')
             return False
 
         local_commits = self.run(['git', 'log', '--oneline', 'origin/master..HEAD'])[1]
         if local_commits and not allow_local_commits:
             _log.warning('Checkout has local commits; aborting. Use --allow-local-commits to allow this.')
             return False
 
-        if self.fs.exists(self.path_from_webkit_base(WPT_DEST_NAME)):
+        if self.fs.exists(self.path_from_blink_base(WPT_DEST_NAME)):
             _log.warning('WebKit/%s exists; aborting.', WPT_DEST_NAME)
             return False
 
-        if self.fs.exists(self.path_from_webkit_base(CSS_DEST_NAME)):
+        if self.fs.exists(self.path_from_blink_base(CSS_DEST_NAME)):
             _log.warning('WebKit/%s repo exists; aborting.', CSS_DEST_NAME)
             return False
 
         return True
 
     def _copy_resources(self):
         """Copies resources from LayoutTests/resources to wpt and vice versa.
 
         There are resources from our repository that we use instead of the
         upstream versions. Conversely, there are also some resources that
@@ skipping 14 matching lines @@
         resources_to_copy_to_wpt = [
             ('testharnessreport.js', 'resources'),
             ('WebIDLParser.js', 'resources'),
             ('vendor-prefix.js', 'common'),
         ]
         resources_to_copy_from_wpt = [
             ('idlharness.js', 'resources'),
             ('testharness.js', 'resources'),
         ]
         for filename, wpt_subdir in resources_to_copy_to_wpt:
-            source = self.path_from_webkit_base('LayoutTests', 'resources', filename)
-            destination = self.path_from_webkit_base('LayoutTests', 'imported', WPT_DEST_NAME, wpt_subdir, filename)
+            source = self.path_from_blink_base('LayoutTests', 'resources', filename)
+            destination = self.path_from_blink_base('LayoutTests', 'imported', WPT_DEST_NAME, wpt_subdir, filename)
             self.copyfile(source, destination)
             self.run(['git', 'add', destination])
         for filename, wpt_subdir in resources_to_copy_from_wpt:
-            source = self.path_from_webkit_base('LayoutTests', 'imported', WPT_DEST_NAME, wpt_subdir, filename)
-            destination = self.path_from_webkit_base('LayoutTests', 'resources', filename)
+            source = self.path_from_blink_base('LayoutTests', 'imported', WPT_DEST_NAME, wpt_subdir, filename)
+            destination = self.path_from_blink_base('LayoutTests', 'resources', filename)
             self.copyfile(source, destination)
             self.run(['git', 'add', destination])
 
     def _generate_manifest(self, original_repo_path, dest_path):
         """Generate MANIFEST.json for imported tests.
 
         Run 'manifest' command if it exists in original_repo_path, and
         add generated MANIFEST.json to dest_path.
         """
         manifest_command = self.fs.join(original_repo_path, 'manifest')
         if not self.fs.exists(manifest_command):
             # Do nothing for csswg-test.
             return
         _log.info('Generating MANIFEST.json')
         self.run([manifest_command, '--tests-root', dest_path])
         self.run(['git', 'add', self.fs.join(dest_path, 'MANIFEST.json')])
 
     def update(self, dest_dir_name, url, keep_w3c_repos_around, revision):
         """Updates an imported repository.
 
         Args:
             dest_dir_name: The destination directory name.
             url: URL of the git repository.
             revision: Commit hash or None.
 
         Returns:
             A string for the commit description "<destination>@<commitish>".
         """
-        temp_repo_path = self.path_from_webkit_base(dest_dir_name)
+        temp_repo_path = self.path_from_blink_base(dest_dir_name)
         _log.info('Cloning %s into %s.', url, temp_repo_path)
         self.run(['git', 'clone', url, temp_repo_path])
 
         if revision is not None:
             _log.info('Checking out %s', revision)
             self.run(['git', 'checkout', revision], cwd=temp_repo_path)
         self.run(['git', 'submodule', 'update', '--init', '--recursive'], cwd=temp_repo_path)
 
         _log.info('Noting the revision we are importing.')
         _, show_ref_output = self.run(['git', 'show-ref', 'origin/master'], cwd=temp_repo_path)
         master_commitish = show_ref_output.split()[0]
 
         _log.info('Cleaning out tests from LayoutTests/imported/%s.', dest_dir_name)
-        dest_path = self.path_from_webkit_base('LayoutTests', 'imported', dest_dir_name)
+        dest_path = self.path_from_blink_base('LayoutTests', 'imported', dest_dir_name)
         files_to_delete = self.fs.files_under(dest_path, file_filter=self.is_not_baseline)
         for subpath in files_to_delete:
             self.remove('LayoutTests', 'imported', subpath)
 
         _log.info('Importing the tests.')
-        src_repo = self.path_from_webkit_base(dest_dir_name)
-        import_path = self.path_from_webkit_base('Tools', 'Scripts', 'import-w3c-tests')
+        src_repo = self.path_from_blink_base(dest_dir_name)
+        import_path = self.path_from_blink_base('Tools', 'Scripts', 'import-w3c-tests')
         self.run([self.host.executable, import_path, '-d', 'imported', src_repo])
 
         self.run(['git', 'add', '--all', 'LayoutTests/imported/%s' % dest_dir_name])
 
         _log.info('Deleting any orphaned baselines.')
         previous_baselines = self.fs.files_under(dest_path, file_filter=self.is_baseline)
         for subpath in previous_baselines:
             full_path = self.fs.join(dest_path, subpath)
             if self.fs.glob(full_path.replace('-expected.txt', '*')) == [full_path]:
                 self.fs.remove(full_path)
 
         self._generate_manifest(temp_repo_path, dest_path)
         if not keep_w3c_repos_around:
             _log.info('Deleting temp repo directory %s.', temp_repo_path)
             self.rmtree(temp_repo_path)
 
         _log.info('Updating TestExpectations for any removed or renamed tests.')
         self.update_all_test_expectations_files(self._list_deleted_tests(), self._list_renamed_tests())
 
         return '%s@%s' % (dest_dir_name, master_commitish)
 
     def commit_changes_if_needed(self, chromium_commitish, import_commitish):
         if self.run(['git', 'diff', '--quiet', 'HEAD'], exit_on_failure=False)[0]:
             _log.info('Committing changes.')
             commit_msg = ('Import %s\n'
                           '\n'
                           'Using update-w3c-deps in Chromium %s.\n'
                           % (import_commitish, chromium_commitish))
-            path_to_commit_msg = self.path_from_webkit_base('commit_msg')
+            path_to_commit_msg = self.path_from_blink_base('commit_msg')
             _log.debug('cat > %s <<EOF', path_to_commit_msg)
             _log.debug(commit_msg)
             _log.debug('EOF')
             self.fs.write_text_file(path_to_commit_msg, commit_msg)
             self.run(['git', 'commit', '-a', '-F', path_to_commit_msg])
             self.remove(path_to_commit_msg)
             _log.info('Done: changes imported and committed.')
             return True
         else:
             _log.info('Done: no changes to import.')
             return False
 
     # Callback for FileSystem.files_under; not all arguments used - pylint: disable=unused-argument
     def is_baseline(self, fs, dirname, basename):
         return basename.endswith('-expected.txt')
 
     def is_not_baseline(self, fs, dirname, basename):
         return not self.is_baseline(fs, dirname, basename)
 
     def run(self, cmd, exit_on_failure=True, cwd=None):
         _log.debug('Running command: %s', ' '.join(cmd))
 
-        cwd = cwd or self.finder.webkit_base()
+        cwd = cwd or self.finder.blink_base()
         proc = self.executive.popen(cmd, stdout=self.executive.PIPE, stderr=self.executive.PIPE, cwd=cwd)
         out, err = proc.communicate()
         if proc.returncode or self.verbose:
             _log.info('# ret> %d', proc.returncode)
             if out:
                 for line in out.splitlines():
                     _log.info('# out> %s', line)
             if err:
                 for line in err.splitlines():
                     _log.info('# err> %s', line)
         if exit_on_failure and proc.returncode:
             self.host.exit(proc.returncode)
         return proc.returncode, out
 
     def check_run(self, command):
         return_code, out = self.run(command)
         if return_code:
             raise Exception('%s failed with exit code %d.' % ' '.join(command), return_code)
         return out
 
     def copyfile(self, source, destination):
         _log.debug('cp %s %s', source, destination)
         self.fs.copyfile(source, destination)
 
     def remove(self, *comps):
-        dest = self.path_from_webkit_base(*comps)
+        dest = self.path_from_blink_base(*comps)
         _log.debug('rm %s', dest)
         self.fs.remove(dest)
 
     def rmtree(self, *comps):
-        dest = self.path_from_webkit_base(*comps)
+        dest = self.path_from_blink_base(*comps)
         _log.debug('rm -fr %s', dest)
         self.fs.rmtree(dest)
 
-    def path_from_webkit_base(self, *comps):
-        return self.finder.path_from_webkit_base(*comps)
+    def path_from_blink_base(self, *comps):
+        return self.finder.path_from_blink_base(*comps)
 
     def do_auto_update(self):
         """Attempts to upload a CL, make any required adjustments, and commit.
 
         This function assumes that the imported repo has already been updated,
         and that change has been committed. There may be newly-failing tests,
         so before being able to commit these new changes, we may need to update
         TestExpectations or download new baselines.
 
         Returns:
@@ skipping 36 matching lines @@
             'upload',
             '-f',
             '--rietveld',
             '-m',
             commit_message,
         ] + ['--cc=' + email for email in cc_list])
 
     def get_directory_owners_to_cc(self):
         """Returns a list of email addresses to CC for the current import."""
         _log.info('Gathering directory owners emails to CC.')
-        directory_owners_file_path = self.finder.path_from_webkit_base(
+        directory_owners_file_path = self.finder.path_from_blink_base(
             'Tools', 'Scripts', 'webkitpy', 'w3c', 'directory_owners.json')
         with open(directory_owners_file_path) as data_file:
             directory_to_owner = self.parse_directory_owners(json.load(data_file))
         out = self.check_run(['git', 'diff', 'origin/master', '--name-only'])
         changed_files = out.splitlines()
         return self.generate_email_list(changed_files, directory_to_owner)
 
     @staticmethod
     def parse_directory_owners(decoded_data_file):
         directory_dict = {}
@@ skipping 19 matching lines @@
             if test_path is None:
                 continue
             test_dir = self.fs.dirname(test_path)
             if test_dir in directory_to_owner:
                 email_addresses.add(directory_to_owner[test_dir])
         return sorted(email_addresses)
 
     def fetch_new_expectations_and_baselines(self):
         """Adds new expectations and downloads baselines based on try job results, then commits and uploads the change."""
         _log.info('Adding test expectations lines to LayoutTests/TestExpectations.')
-        script_path = self.path_from_webkit_base('Tools', 'Scripts', 'update-w3c-test-expectations')
+        script_path = self.path_from_blink_base('Tools', 'Scripts', 'update-w3c-test-expectations')
         self.run([self.host.executable, script_path, '--verbose'])
         message = 'Modify TestExpectations or download new baselines for tests.'
         self.check_run(['git', 'commit', '-a', '-m', message])
         self.git_cl.run(['upload', '-m', message, '--rietveld'])
 
     def update_all_test_expectations_files(self, deleted_tests, renamed_tests):
         """Updates all test expectations files for tests that have been deleted or renamed."""
         port = self.host.port_factory.get()
         for path, file_contents in port.all_expectations_dict().iteritems():
 
@@ skipping 36 matching lines @@
         """Returns a dict mapping source to dest name for layout tests that have been renamed."""
         out = self.check_run(['git', 'diff', 'origin/master', '-M100%', '--diff-filter=R', '--name-status'])
         renamed_tests = {}
         for line in out.splitlines():
             _, source_path, dest_path = line.split()
             source_test = self.finder.layout_test_name(source_path)
             dest_test = self.finder.layout_test_name(dest_path)
             if source_test and dest_test:
                 renamed_tests[source_test] = dest_test
         return renamed_tests