wpt-import: Work on third_party/WebKit/LayoutTests instead of third_party/WebKit.

third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer.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:
  1. Upload a CL.
  2. Trigger try jobs and wait for them to complete.
  3. Make any changes that are required for new failing tests.
@@ skipping 49 matching lines @@
 
         _log.debug('Noting the current Chromium commit.')
         _, show_ref_output = self.run(['git', 'show-ref', 'HEAD'])
         chromium_commit = show_ref_output.split()[0]
 
         dest_dir_name = WPT_DEST_NAME
         repo_url = WPT_REPO_URL
 
         # TODO(qyearsley): Simplify this to use LocalWPT.fetch when csswg-test
         # is merged into web-platform-tests (crbug.com/706118).
-        temp_repo_path = self.finder.path_from_webkit_base(dest_dir_name)
+        temp_repo_path = self.finder.path_from_layout_tests(dest_dir_name)
         _log.info('Cloning repo: %s', repo_url)
         _log.info('Local path: %s', temp_repo_path)
         self.run(['git', 'clone', repo_url, temp_repo_path])
 
         if not options.ignore_exportable_commits:
             commits = self.exportable_but_not_exported_commits(temp_repo_path)
             if commits:
                 # If there are exportable commits, then there's no more work
                 # to do for now. This isn't really an error case; we expect
                 # to hit this case some of the time.
@@ skipping 51 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.finder.path_from_webkit_base(WPT_DEST_NAME)):
-            _log.warning('WebKit/%s exists; aborting.', WPT_DEST_NAME)
+        temp_repo_path = self.finder.path_from_layout_tests(WPT_DEST_NAME)
+        if self.fs.exists(temp_repo_path):
+            _log.warning('%s exists; aborting.', temp_repo_path)
             return False
 
         return True
 
     def exportable_but_not_exported_commits(self, wpt_path):
         """Checks for commits that might be overwritten by importing.
 
         Args:
             wpt_path: The path to a local checkout of web-platform-tests.
 
         Returns:
             A list of commits in the Chromium repo that are exportable
             but not yet exported to the web-platform-tests repo.
         """
         local_wpt = LocalWPT(self.host, path=wpt_path)
         assert self.host.filesystem.exists(wpt_path)
         _, chromium_commit = local_wpt.most_recent_chromium_commit()
         return exportable_commits_since(chromium_commit.sha, self.host, local_wpt)
 
     def clean_up_temp_repo(self, temp_repo_path):
         _log.info('Deleting temp repo directory %s.', temp_repo_path)
-        self.rmtree(temp_repo_path)
+        self.fs.rmtree(temp_repo_path)
 
     def _copy_resources(self):
         """Copies resources from wpt to LayoutTests/resources.
 
         We copy idlharness.js and testharness.js in wpt to LayoutTests/resources
         in order to use them in non-imported tests.
 
         If this method is changed, the lists of files expected to be identical
         in LayoutTests/PRESUBMIT.py should also be changed.
         """
@@ skipping 65 matching lines @@
         return '%s@%s' % (dest_dir_name, master_commitish)
 
     def _clear_out_dest_path(self, dest_path):
         _log.info('Cleaning out tests from %s.', dest_path)
         should_remove = lambda fs, dirname, basename: (
             not self.is_baseline(basename) and
             # See http://crbug.com/702283 for context.
             basename != 'OWNERS')
         files_to_delete = self.fs.files_under(dest_path, file_filter=should_remove)
         for subpath in files_to_delete:
-            self.remove('LayoutTests', 'external', subpath)
+            self.remove(self.finder.path_from_layout_tests('external', subpath))
 
     def _commit_changes(self, commit_message):
         _log.info('Committing changes.')
         self.run(['git', 'commit', '--all', '-F', '-'], stdin=commit_message)
 
     def _has_changes(self):
         return_code, _ = self.run(['git', 'diff', '--quiet', 'HEAD'], exit_on_failure=False)
         return return_code == 1
 
     def _commit_message(self, chromium_commit, import_commit):
@@ skipping 17 matching lines @@
 
     @staticmethod
     def is_baseline(basename):
         # TODO(qyearsley): Find a better, centralized place for this.
         # Also, the name for this method should be is_text_baseline.
         return basename.endswith('-expected.txt')
 
     def run(self, cmd, exit_on_failure=True, cwd=None, stdin=''):
         _log.debug('Running command: %s', ' '.join(cmd))
 
-        cwd = cwd or self.finder.webkit_base()
+        cwd = cwd or self.finder.path_from_layout_tests()
         proc = self.executive.popen(cmd, stdout=self.executive.PIPE, stderr=self.executive.PIPE, stdin=self.executive.PIPE, cwd=cwd)
         out, err = proc.communicate(stdin)
         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.finder.path_from_webkit_base(*comps)
+    def remove(self, dest):
         _log.debug('rm %s', dest)
         self.fs.remove(dest)
 
-    def rmtree(self, *comps):
-        dest = self.finder.path_from_webkit_base(*comps)
-        _log.debug('rm -fr %s', dest)
-        self.fs.rmtree(dest)
-
     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:
             True if successfully committed, False otherwise.
@@ skipping 145 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