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

third_party/WebKit/Tools/Scripts/webkitpy/common/checkout/scm/git.py

 # Copyright (c) 2009, 2010, 2011 Google Inc. All rights reserved.
 # Copyright (c) 2009 Apple 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
@@ skipping 168 matching lines @@
         return True
 
     def display_name(self):
         return "git"
 
     def most_recent_log_matching(self, grep_str, path):
         # We use '--grep=' + foo rather than '--grep', foo because
         # git 1.7.0.4 (and earlier) didn't support the separate arg.
         return self._run_git(['log', '-1', '--grep=' + grep_str, '--date=iso', self.find_checkout_root(path)])
 
-    def svn_revision(self, path):
-        git_log = self.most_recent_log_matching('git-svn-id:', path)
-        match = re.search("^\s*git-svn-id:.*@(?P<svn_revision>\d+)\ ", git_log, re.MULTILINE)
+    def _commit_position_from_git_log(self, git_log):
+        match = re.search("^\s*Cr-Commit-Position:.*@\{#(?P<commit_position>\d+)\}", git_log, re.MULTILINE)
         if not match:
             return ""
-        return str(match.group('svn_revision'))
+        return str(match.group('commit_position'))
+
+    def commit_position(self, path):
+        git_log = self.most_recent_log_matching('Cr-Commit-Position:', path)
+        return self._commit_position_from_git_log(git_log)
 
     def timestamp_of_revision(self, path, revision):
-        git_log = self.most_recent_log_matching('git-svn-id:.*@%s' % revision, path)
+        git_log = self.most_recent_log_matching('Cr-Commit-Position:.*@\{%s\}' % revision, path)
         match = re.search("^Date:\s*(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}) ([+-])(\d{2})(\d{2})$", git_log, re.MULTILINE)
         if not match:
             return ""
 
         # Manually modify the timezone since Git doesn't have an option to show it in UTC.
         # Git also truncates milliseconds but we're going to ignore that for now.
         time_with_timezone = datetime.datetime(int(match.group(1)), int(match.group(2)), int(match.group(3)),
                                                int(match.group(4)), int(match.group(5)), int(match.group(6)), 0)
 
         sign = 1 if match.group(7) == '+' else -1
         time_without_timezone = time_with_timezone - datetime.timedelta(hours=sign * int(match.group(8)), minutes=int(match.group(9)))
         return time_without_timezone.strftime('%Y-%m-%dT%H:%M:%SZ')
 
-    def _prepend_svn_revision(self, diff):
-        revision = self._head_svn_revision()
-        if not revision:
-            return diff
-
-        return "Subversion Revision: " + revision + '\n' + diff
-
     def create_patch(self, git_commit=None, changed_files=None):
         """Returns a byte array (str()) representing the patch file.
         Patch files are effectively binary since they may contain
         files of multiple different encodings."""
 
         # Put code changes at the top of the patch and layout tests
         # at the bottom, this makes for easier reviewing.
         config_path = self._filesystem.dirname(self._filesystem.path_to_module('webkitpy.common.config'))
         order_file = self._filesystem.join(config_path, 'orderfile')
         order = ""
         if self._filesystem.exists(order_file):
             order = "-O%s" % order_file
 
         command = [self.executable_name, 'diff', '--binary', '--no-color', "--no-ext-diff", "--full-index", "--no-renames", order, self._merge_base(git_commit), "--"]
         if changed_files:
             command += changed_files
-        return self._prepend_svn_revision(self._run(command, decode_output=False, cwd=self.checkout_root))
+        return self._run(command, decode_output=False, cwd=self.checkout_root)
 
     @memoized
-    def svn_revision_from_git_commit(self, git_commit):
-        # git svn find-rev always exits 0, even when the revision or commit is not found.
-        try:
-            return int(self._run_git(['svn', 'find-rev', git_commit]).rstrip())
-        except ValueError, e:
-            return None
+    def commit_position_from_git_commit(self, git_commit):
+        git_log = self.git_commit_detail(git_commit)
+        return self._commit_position_from_git_log(git_log)
 
     def checkout_branch(self, name):
         self._run_git(['checkout', '-q', name])
 
     def create_clean_branch(self, name):
         self._run_git(['checkout', '-q', '-b', name, self._remote_branch_ref()])
 
     def blame(self, path):
         return self._run_git(['blame', path])
 
     # Git-specific methods:
     def _branch_ref_exists(self, branch_ref):
         return self._run_git(['show-ref', '--quiet', '--verify', branch_ref], return_exit_code=True) == 0
 
     def delete_branch(self, branch_name):
         if self._branch_ref_exists('refs/heads/' + branch_name):
             self._run_git(['branch', '-D', branch_name])
 
     def _remote_merge_base(self):
         return self._run_git(['merge-base', self._remote_branch_ref(), 'HEAD']).strip()
 
     def _remote_branch_ref(self):
         # Use references so that we can avoid collisions, e.g. we don't want to operate on refs/heads/trunk if it exists.
-        remote_branch_refs = self.read_git_config('svn-remote.svn.fetch', cwd=self.checkout_root, executive=self._executive)
-        if not remote_branch_refs:
-            remote_master_ref = 'refs/remotes/origin/master'
-            if not self._branch_ref_exists(remote_master_ref):
-                raise ScriptError(message="Can't find a branch to diff against. svn-remote.svn.fetch is not in the git config and %s does not exist" % remote_master_ref)
-            return remote_master_ref
-
-        # FIXME: What's the right behavior when there are multiple svn-remotes listed?
-        # For now, just use the first one.
-        first_remote_branch_ref = remote_branch_refs.split('\n')[0]
-        return first_remote_branch_ref.split(':')[1]
+        remote_master_ref = 'refs/remotes/origin/master'
+        if not self._branch_ref_exists(remote_master_ref):
+            raise ScriptError(message="Can't find a branch to diff against. %s does not exist" % remote_master_ref)
+        return remote_master_ref
 
     def commit_locally_with_message(self, message, commit_all_working_directory_changes=True):
         command = ['commit', '-F', '-']
         if commit_all_working_directory_changes:
             command.insert(1, '--all')
         self._run_git(command, input=message)
 
     # These methods are git specific and are meant to provide support for the Git oriented workflow
     # that Blink is moving towards, hence there are no equivalent methods in the SVN class.
 
@@ skipping 30 matching lines @@
         if self.current_branch() != self._branch_tracking_remote_master():
             return False
         if len(self._local_commits(self._branch_tracking_remote_master())) > 0:
             return False
         return True
 
     def ensure_cleanly_tracking_remote_master(self):
         self._discard_working_directory_changes()
         self._run_git(['checkout', '-q', self._branch_tracking_remote_master()])
         self._discard_local_commits()