Use chromium revision instead of blink svn revision when rebaselining layout tests.

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

 # Copyright (c) 2010 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 317 matching lines @@
         self._builder_data = {}
 
     def builder_data(self):
         if not self._builder_data:
             for builder_name in self._release_builders():
                 builder = self._tool.buildbot.builder_with_name(builder_name)
                 builder_results = builder.latest_layout_test_results()
                 if builder_results:
                     self._builder_data[builder_name] = builder_results
                 else:
-                    _log.warning("No result for builder '%s'" % builder_name)
+                    raise Exception("No result for builder %s." % builder_name)
         return self._builder_data
 
     # The release builders cycle much faster than the debug ones and cover all the platforms.
     def _release_builders(self):
         release_builders = []
         for builder_name in builders.all_builder_names():
             if builder_name.find('ASAN') != -1:
                 continue
             port = self._tool.port_factory.get_from_builder_name(builder_name)
             if port.test_configuration().build_type == 'release':
@@ skipping 332 matching lines @@
             ])
 
     def bot_revision_data(self):
         revisions = []
         for result in self.builder_data().values():
             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.blink_revision(),
+                "revision": result.chromium_revision(),
             })
         return revisions
 
     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"):
             comment_index = line.find("#")
             if comment_index == -1:
                 comment_index = len(line)
             line_without_comments = re.sub(r"\s+", " ", line[:comment_index].strip())
 
             if "NeedsRebaseline" not in line_without_comments:
                 continue
 
             has_any_needs_rebaseline_lines = True
 
             parsed_line = re.match("^(\S*)[^(]*\((\S*).*?([^ ]*)\ \[[^[]*$", line_without_comments)
 
             commit_hash = parsed_line.group(1)
-            svn_revision = tool.scm().svn_revision_from_git_commit(commit_hash)
+            commit_position = tool.scm().commit_position_from_git_commit(commit_hash)
 
             test = parsed_line.group(3)
             if print_revisions:
-                _log.info("%s is waiting for r%s" % (test, svn_revision))
+                _log.info("%s is waiting for r%s" % (test, commit_position))
 
-            if not svn_revision or svn_revision > min_revision:
+            if not commit_position or commit_position > min_revision:
                 continue
 
-            if revision and svn_revision != revision:
+            if revision and commit_position != revision:
                 continue
 
             if not revision:
-                revision = svn_revision
+                revision = commit_position
+                commit = commit_hash
                 author = parsed_line.group(2)
 
             bugs.update(re.findall("crbug\.com\/(\d+)", line_without_comments))
             tests.add(test)
 
             if len(tests) >= self.MAX_LINES_TO_REBASELINE:
                 _log.info("Too many tests to rebaseline in one patch. Doing the first %d." % self.MAX_LINES_TO_REBASELINE)
                 break
 
-        return tests, revision, author, bugs, has_any_needs_rebaseline_lines
+        return tests, revision, commit, author, bugs, has_any_needs_rebaseline_lines
 
-    def link_to_patch(self, revision):
-        return "http://src.chromium.org/viewvc/blink?view=revision&revision=" + str(revision)
+    def link_to_patch(self, commit):
+        return "https://chromium.googlesource.com/chromium/src/+/" + commit
 
-    def commit_message(self, author, revision, bugs):
+    def commit_message(self, author, revision, commit, bugs):
         bug_string = ""
         if bugs:
             bug_string = "BUG=%s\n" % ",".join(bugs)
 
         return """Auto-rebaseline for r%s
 
 %s
 
 %sTBR=%s
-""" % (revision, self.link_to_patch(revision), bug_string, author)
+""" % (revision, self.link_to_patch(commit), bug_string, author)
 
     def get_test_prefix_list(self, tests):
         test_prefix_list = {}
         lines_to_remove = {}
 
         for builder_name in self._release_builders():
             port_name = builders.port_name_for_builder_name(builder_name)
             port = self._tool.port_factory.get(port_name)
             expectations = TestExpectations(port, include_overrides=True)
             for test in expectations.get_needs_rebaseline_failures():
@@ skipping 48 matching lines @@
 
         if tool.scm().has_working_directory_changes():
             _log.error("Cannot proceed with working directory changes. Clean working directory first.")
             return
 
         revision_data = self.bot_revision_data()
         if not revision_data:
             return
 
         min_revision = int(min([item["revision"] for item in revision_data]))
-        tests, revision, author, bugs, has_any_needs_rebaseline_lines = self.tests_to_rebaseline(tool, min_revision, print_revisions=options.verbose)
+        tests, revision, commit, author, bugs, has_any_needs_rebaseline_lines = 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:
                 _log.info("%s: r%s" % (item["builder"], item["revision"]))
 
         if not tests:
             _log.debug('No tests to rebaseline.')
             return
 
         if self.tree_status() == 'closed':
             _log.info('Cannot proceed. Tree is closed.')
             return
 
         _log.info('Rebaselining %s for r%s by %s.' % (list(tests), revision, author))
 
         test_prefix_list, lines_to_remove = self.get_test_prefix_list(tests)
 
         did_finish = False
         old_branch_name_or_ref = ''
         rebaseline_branch_name = self.AUTO_REBASELINE_BRANCH_NAME
         try:
-            # Setup git-svn for dcommit if necessary.
-            if tool.executive.run_command(
-                    ['git', 'config', '--local', '--get-regexp', r'^svn-remote\.'],
-                    return_exit_code=True):
-                tool.executive.run_command(['git', 'auto-svn'])
-
             # Save the current branch name and checkout a clean branch for the patch.
             old_branch_name_or_ref = _get_branch_name_or_ref(tool)
             if old_branch_name_or_ref == self.AUTO_REBASELINE_BRANCH_NAME:
                 rebaseline_branch_name = self.AUTO_REBASELINE_ALT_BRANCH_NAME
             tool.scm().delete_branch(rebaseline_branch_name)
             tool.scm().create_clean_branch(rebaseline_branch_name)
 
             # If the tests are passing everywhere, then this list will be empty. We don't need
             # to rebaseline, but we'll still need to update TestExpectations.
             if test_prefix_list:
                 self._rebaseline(options, test_prefix_list)
 
-            tool.scm().commit_locally_with_message(self.commit_message(author, revision, bugs))
+            tool.scm().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.
@@ skipping 91 matching lines @@
                 self._tool.scm().checkout_branch(old_branch_name_or_ref)
         else:
             self._log_queue.put(self.QUIT_LOG)
         log_thread.join()
 
     def execute(self, options, args, tool):
         self._verbose = options.verbose
         while True:
             self._do_one_rebaseline()
             time.sleep(self.SLEEP_TIME_IN_SECONDS)