Rename Host.scm -> Host.git.

third_party/WebKit/Tools/Scripts/webkitpy/tool/commands/auto_rebaseline.py

 # Copyright 2016 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.
 
 """A command to download new baselines for NeedsRebaseline tests.
 
 This command checks the list of tests with NeedsRebaseline expectations,
 and downloads the latest baselines for those tests from the results archived
 by the continuous builders.
 """
@@ skipping 44 matching lines @@
                 (
                     [^@]+   # Username preceding @
                     @
                     [^@>]+  # Domain terminated by @ or >, some lines have an additional @ fragment after the email.
                 )
                 .*?([^ ]*)  # Test file name
                 \ \[        # Single space followed by opening [ for expectation specifier
                 [^[]*$      # Prevents matching previous [ for version specifiers instead of expectation specifiers
             ''', re.VERBOSE)
 
-    def bot_revision_data(self, scm):
+    def bot_revision_data(self, git):
         revisions = []
         for builder_name in self._release_builders():
             result = self._tool.buildbot.fetch_results(Build(builder_name))
             if result.run_was_interrupted():
                 _log.error("Can't rebaseline because the latest run on %s exited early.", result.builder_name())
                 return []
             revisions.append({
                 "builder": result.builder_name(),
-                "revision": result.chromium_revision(scm),
+                "revision": result.chromium_revision(git),
             })
         return revisions
 
     @staticmethod
     def _strip_comments(line):
         comment_index = line.find("#")
         if comment_index == -1:
             comment_index = len(line)
         return re.sub(r"\s+", " ", line[:comment_index].strip())
 
     def tests_to_rebaseline(self, tool, min_revision, print_revisions):
         port = tool.port_factory.get()
         expectations_file_path = port.path_to_generic_test_expectations_file()
 
         tests = set()
         revision = None
         commit = None
         author = None
         bugs = set()
         has_any_needs_rebaseline_lines = False
 
-        for line in tool.scm().blame(expectations_file_path).split("\n"):
+        for line in tool.git().blame(expectations_file_path).split("\n"):
             line = self._strip_comments(line)
             if "NeedsRebaseline" not in line:
                 continue
 
             has_any_needs_rebaseline_lines = True
 
             parsed_line = self._blame_regex.match(line)
             if not parsed_line:
                 # Deal gracefully with inability to parse blame info for a line in TestExpectations.
                 # Parsing could fail if for example during local debugging the developer modifies
                 # TestExpectations and does not commit.
                 _log.info("Couldn't find blame info for expectations line, skipping [line=%s].", line)
                 continue
 
             commit_hash = parsed_line.group(1)
-            commit_position = tool.scm().commit_position_from_git_commit(commit_hash)
+            commit_position = tool.git().commit_position_from_git_commit(commit_hash)
 
             test = parsed_line.group(3)
             if print_revisions:
                 _log.info("%s is waiting for r%s", test, commit_position)
 
             if not commit_position or commit_position > min_revision:
                 continue
 
             if revision and commit_position != revision:
                 continue
@@ skipping 80 matching lines @@
         blink_tree_status_url = "http://chromium-status.appspot.com/status"
         status = urllib2.urlopen(blink_tree_status_url).read().lower()
         if 'closed' in status or status == "0":
             return 'closed'
         elif 'open' in status or status == "1":
             return 'open'
         return 'unknown'
 
     def execute(self, options, args, tool):
         self._tool = tool
-        if tool.scm().executable_name == "svn":
+        if tool.git().executable_name == "svn":
             _log.error("Auto rebaseline only works with a git checkout.")
             return
 
-        if not options.dry_run and tool.scm().has_working_directory_changes():
+        if not options.dry_run and tool.git().has_working_directory_changes():
             _log.error("Cannot proceed with working directory changes. Clean working directory first.")
             return
 
-        revision_data = self.bot_revision_data(tool.scm())
+        revision_data = self.bot_revision_data(tool.git())
         if not revision_data:
             return
 
         min_revision = int(min([item["revision"] for item in revision_data]))
         tests, revision, commit, author, bugs, _ = self.tests_to_rebaseline(
             tool, min_revision, print_revisions=options.verbose)
 
         if options.verbose:
             _log.info("Min revision across all bots is %s.", min_revision)
             for item in revision_data:
@@ skipping 10 matching lines @@
         _log.info('Rebaselining %s for r%s by %s.', list(tests), revision, author)
 
         test_prefix_list, _ = self.get_test_prefix_list(tests)
 
         did_switch_branches = False
         did_finish = False
         old_branch_name_or_ref = ''
         rebaseline_branch_name = self.AUTO_REBASELINE_BRANCH_NAME
         try:
             # Save the current branch name and check out a clean branch for the patch.
-            old_branch_name_or_ref = tool.scm().current_branch_or_ref()
+            old_branch_name_or_ref = tool.git().current_branch_or_ref()
             if old_branch_name_or_ref == self.AUTO_REBASELINE_BRANCH_NAME:
                 rebaseline_branch_name = self.AUTO_REBASELINE_ALT_BRANCH_NAME
             if not options.dry_run:
-                tool.scm().delete_branch(rebaseline_branch_name)
-                tool.scm().create_clean_branch(rebaseline_branch_name)
+                tool.git().delete_branch(rebaseline_branch_name)
+                tool.git().create_clean_branch(rebaseline_branch_name)
                 did_switch_branches = True
 
             if test_prefix_list:
                 self.rebaseline(options, test_prefix_list)
 
             if options.dry_run:
                 return
 
-            tool.scm().commit_locally_with_message(
+            tool.git().commit_locally_with_message(
                 self.commit_message(author, revision, commit, bugs))
 
             # FIXME: It would be nice if we could dcommit the patch without uploading, but still
             # go through all the precommit hooks. For rebaselines with lots of files, uploading
             # takes a long time and sometimes fails, but we don't want to commit if, e.g. the
             # tree is closed.
             did_finish = self._run_git_cl_command(options, ['upload', '-f'])
 
             if did_finish:
                 # Uploading can take a very long time. Do another pull to make sure TestExpectations is up to date,
                 # so the dcommit can go through.
                 # FIXME: Log the pull and dcommit stdout/stderr to the log-server.
                 tool.executive.run_command(['git', 'pull'])
 
                 self._run_git_cl_command(options, ['land', '-f', '-v'])
         except OSError:
             traceback.print_exc(file=sys.stderr)
         finally:
             if did_switch_branches:
                 if did_finish:
                     # Close the issue if dcommit failed.
                     issue_already_closed = tool.executive.run_command(
                         ['git', 'config', 'branch.%s.rietveldissue' % rebaseline_branch_name],
                         return_exit_code=True)
                     if not issue_already_closed:
                         self._run_git_cl_command(options, ['set_close'])
 
-                tool.scm().ensure_cleanly_tracking_remote_master()
+                tool.git().ensure_cleanly_tracking_remote_master()
                 if old_branch_name_or_ref:
-                    tool.scm().checkout_branch(old_branch_name_or_ref)
-                tool.scm().delete_branch(rebaseline_branch_name)
+                    tool.git().checkout_branch(old_branch_name_or_ref)
+                tool.git().delete_branch(rebaseline_branch_name)