Merge webkit.org at r61121: Initial merge by git.

Change-Id: Icd6db395c62285be384d137164d95d7466c98760

4 files changed, 107 insertions, 32 deletions

diff --git a/WebKitTools/Scripts/webkitpy/common/checkout/changelog.py b/WebKitTools/Scripts/webkitpy/common/checkout/changelog.py
index 6220fbd..40657eb 100644
--- a/WebKitTools/Scripts/webkitpy/common/checkout/changelog.py
+++ b/WebKitTools/Scripts/webkitpy/common/checkout/changelog.py
@@ -36,6 +36,8 @@ import textwrap
 
 from webkitpy.common.system.deprecated_logging import log
 from webkitpy.common.config.committers import CommitterList
+from webkitpy.common.net.bugzilla import parse_bug_id
+
 
 def view_source_url(revision_number):
     # FIMXE: This doesn't really belong in this file, but we don't have a
@@ -88,6 +90,9 @@ class ChangeLogEntry(object):
     def contents(self):
         return self._contents
 
+    def bug_id(self):
+        return parse_bug_id(self._contents)
+
 
 # FIXME: Various methods on ChangeLog should move into ChangeLogEntry instead.
 class ChangeLog(object):
@@ -183,3 +188,8 @@ class ChangeLog(object):
         for line in fileinput.FileInput(self.path, inplace=1):
             # Trailing comma suppresses printing newline
             print line.replace("NOBODY (OOPS!)", reviewer.encode("utf-8")),
+
+    def set_short_description_and_bug_url(self, short_description, bug_url):
+        message = "%s\n        %s" % (short_description, bug_url)
+        for line in fileinput.FileInput(self.path, inplace=1):
+            print line.replace("Need a short description and bug URL (OOPS!)", message.encode("utf-8")),
diff --git a/WebKitTools/Scripts/webkitpy/common/checkout/changelog_unittest.py b/WebKitTools/Scripts/webkitpy/common/checkout/changelog_unittest.py
index 864428a..6aeb1f8 100644
--- a/WebKitTools/Scripts/webkitpy/common/checkout/changelog_unittest.py
+++ b/WebKitTools/Scripts/webkitpy/common/checkout/changelog_unittest.py
@@ -38,7 +38,7 @@ from StringIO import StringIO
 from webkitpy.common.checkout.changelog import *
 
 
-class ChangeLogsTest(unittest.TestCase):
+class ChangeLogTest(unittest.TestCase):
 
     _example_entry = u'''2009-08-17  Peter Kasting  <pkasting@google.com>
 
@@ -131,6 +131,18 @@ class ChangeLogsTest(unittest.TestCase):
         os.remove(changelog_path)
         self.assertEquals(actual_contents, expected_contents)
 
+    def test_set_short_description_and_bug_url(self):
+        changelog_contents = u"%s\n%s" % (self._new_entry_boilerplate, self._example_changelog)
+        changelog_path = self._write_tmp_file_with_contents(changelog_contents.encode("utf-8"))
+        short_description = "A short description"
+        bug_url = "http://example.com/b/2344"
+        ChangeLog(changelog_path).set_short_description_and_bug_url(short_description, bug_url)
+        actual_contents = self._read_file_contents(changelog_path, "utf-8")
+        expected_message = "%s\n        %s" % (short_description, bug_url)
+        expected_contents = changelog_contents.replace("Need a short description and bug URL (OOPS!)", expected_message)
+        os.remove(changelog_path)
+        self.assertEquals(actual_contents, expected_contents)
+
     _revert_message = """        Unreviewed, rolling out r12345.
         http://trac.webkit.org/changeset/12345
         http://example.com/123
diff --git a/WebKitTools/Scripts/webkitpy/common/checkout/scm.py b/WebKitTools/Scripts/webkitpy/common/checkout/scm.py
index eea76be..fc4c6fd 100644
--- a/WebKitTools/Scripts/webkitpy/common/checkout/scm.py
+++ b/WebKitTools/Scripts/webkitpy/common/checkout/scm.py
@@ -240,7 +240,7 @@ class SCM:
     def supports_local_commits():
         raise NotImplementedError, "subclasses must implement"
 
-    def svn_merge_base():
+    def remote_merge_base():
         raise NotImplementedError, "subclasses must implement"
 
     def commit_locally_with_message(self, message):
@@ -465,11 +465,11 @@ class Git(SCM):
 
     def discard_local_commits(self):
         # FIXME: This should probably use cwd=self.checkout_root
-        self.run(['git', 'reset', '--hard', self.svn_branch_name()])
+        self.run(['git', 'reset', '--hard', self.remote_branch_ref()])
     
     def local_commits(self):
         # FIXME: This should probably use cwd=self.checkout_root
-        return self.run(['git', 'log', '--pretty=oneline', 'HEAD...' + self.svn_branch_name()]).splitlines()
+        return self.run(['git', 'log', '--pretty=oneline', 'HEAD...' + self.remote_branch_ref()]).splitlines()
 
     def rebase_in_progress(self):
         return os.path.exists(os.path.join(self.checkout_root, '.git/rebase-apply'))
@@ -507,7 +507,7 @@ class Git(SCM):
             return git_commit
 
         if self.should_squash(squash):
-            return self.svn_merge_base()
+            return self.remote_merge_base()
 
         # FIXME: Non-squash behavior should match commit_with_message. It raises an error
         # if there are working copy changes and --squash or --no-squash wasn't passed in.
@@ -602,14 +602,14 @@ class Git(SCM):
                 if num_local_commits > 1 or (num_local_commits > 0 and not self.working_directory_is_clean()):
                     raise ScriptError(message=self._get_squash_error_message(num_local_commits))
 
-        if squash and self._svn_branch_has_extra_commits():
+        if squash and self._remote_branch_has_extra_commits():
             raise ScriptError(message="Cannot use --squash when HEAD is not fully merged/rebased to %s. "
-                                      "This branch needs to be synced first." % self.svn_branch_name())
+                                      "This branch needs to be synced first." % self.remote_branch_ref())
 
         return squash
 
-    def _svn_branch_has_extra_commits(self):
-        return len(run_command(['git', 'rev-list', '--max-count=1', self.svn_branch_name(), '^HEAD']))
+    def _remote_branch_has_extra_commits(self):
+        return len(run_command(['git', 'rev-list', '--max-count=1', self.remote_branch_ref(), '^HEAD']))
 
     def commit_with_message(self, message, username=None, git_commit=None, squash=None):
         # Username is ignored during Git commits.
@@ -624,7 +624,7 @@ class Git(SCM):
 
         squash = self.should_squash(squash)
         if squash:
-            self.run(['git', 'reset', '--soft', self.svn_branch_name()])
+            self.run(['git', 'reset', '--soft', self.remote_branch_ref()])
             self.commit_locally_with_message(message)
         elif not self.working_directory_is_clean():
             if not len(self.local_commits()):
@@ -650,8 +650,8 @@ class Git(SCM):
 
         # We want to squash all this branch's commits into one commit with the proper description.
         # We do this by doing a "merge --squash" into a new commit branch, then dcommitting that.
-        MERGE_BRANCH = 'webkit-patch-land'
-        self.delete_branch(MERGE_BRANCH)
+        MERGE_BRANCH_NAME = 'webkit-patch-land'
+        self.delete_branch(MERGE_BRANCH_NAME)
 
         # We might be in a directory that's present in this branch but not in the
         # trunk.  Move up to the top of the tree so that git commands that expect a
@@ -662,7 +662,7 @@ class Git(SCM):
         # We wrap in a try...finally block so if anything goes wrong, we clean up the branches.
         commit_succeeded = True
         try:
-            self.run(['git', 'checkout', '-q', '-b', MERGE_BRANCH, self.svn_branch_name()])
+            self.run(['git', 'checkout', '-q', '-b', MERGE_BRANCH_NAME, self.remote_branch_ref()])
 
             for commit in commit_ids:
                 # We're on a different branch now, so convert "head" to the branch name.
@@ -681,7 +681,7 @@ class Git(SCM):
             # And then swap back to the original branch and clean up.
             self.clean_working_directory()
             self.run(['git', 'checkout', '-q', branch_name])
-            self.delete_branch(MERGE_BRANCH)
+            self.delete_branch(MERGE_BRANCH_NAME)
 
         return output
 
@@ -693,18 +693,31 @@ class Git(SCM):
         return self.run(['git', 'svn', 'log', '--limit=1'])
 
     # 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):
-        if self.run(['git', 'show-ref', '--quiet', '--verify', 'refs/heads/' + branch], return_exit_code=True) == 0:
-            self.run(['git', 'branch', '-D', branch])
+    def delete_branch(self, branch_name):
+        if self._branch_ref_exists('refs/heads/' + branch_name):
+            self.run(['git', 'branch', '-D', branch_name])
 
-    def svn_merge_base(self):
-        return self.run(['git', 'merge-base', self.svn_branch_name(), 'HEAD']).strip()
+    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.
 
-    def svn_branch_name(self):
         # FIXME: This should so something like: Git.read_git_config('svn-remote.svn.fetch').split(':')[1]
         # but that doesn't work if the git repo is tracking multiple svn branches.
-        return 'trunk'
+        remote_branch_refs = [
+            'refs/remotes/trunk',  # A git-svn checkout as per http://trac.webkit.org/wiki/UsingGitWithWebKit.
+            'refs/remotes/origin/master',  # A git clone of git://git.webkit.org/WebKit.git that is not tracking svn.
+        ]
+
+        for ref in remote_branch_refs:
+            if self._branch_ref_exists(ref):
+                return ref
+
+        raise ScriptError(message="Can't find a branch to diff against. %s branches do not exist." % " and ".join(remote_branch_refs))
 
     def commit_locally_with_message(self, message):
         self.run(['git', 'commit', '--all', '-F', '-'], input=message)
@@ -726,7 +739,7 @@ class Git(SCM):
     # A B     : [A, B]  (different from git diff, which would use "rev-list A..B")
     def commit_ids_from_commitish_arguments(self, args):
         if not len(args):
-            args.append('%s..HEAD' % self.svn_branch_name())
+            args.append('%s..HEAD' % self.remote_branch_ref())
 
         commit_ids = []
         for commitish in args:
diff --git a/WebKitTools/Scripts/webkitpy/common/checkout/scm_unittest.py b/WebKitTools/Scripts/webkitpy/common/checkout/scm_unittest.py
index 8eea4d8..36a1d1c 100644
--- a/WebKitTools/Scripts/webkitpy/common/checkout/scm_unittest.py
+++ b/WebKitTools/Scripts/webkitpy/common/checkout/scm_unittest.py
@@ -635,25 +635,63 @@ Q1dTBx0AAAB42itg4GlgYJjGwMDDyODMxMDw34GBgQEAJPQDJA==
 
 class GitTest(SCMTest):
 
-    def _setup_git_clone_of_svn_repository(self):
+    def setUp(self):
+        """Sets up fresh git repository with one commit. Then setups a second git
+        repo that tracks the first one."""
+        self.original_dir = os.getcwd()
+
+        self.untracking_checkout_path = tempfile.mkdtemp(suffix="git_test_checkout2")
+        run_command(['git', 'init', self.untracking_checkout_path])
+
+        os.chdir(self.untracking_checkout_path)
+        write_into_file_at_path('foo_file', 'foo')
+        run_command(['git', 'add', 'foo_file'])
+        run_command(['git', 'commit', '-am', 'dummy commit'])
+        self.untracking_scm = detect_scm_system(self.untracking_checkout_path)
+
+        self.tracking_git_checkout_path = tempfile.mkdtemp(suffix="git_test_checkout")
+        run_command(['git', 'clone', '--quiet', self.untracking_checkout_path, self.tracking_git_checkout_path])
+        os.chdir(self.tracking_git_checkout_path)
+        self.tracking_scm = detect_scm_system(self.tracking_git_checkout_path)
+
+    def tearDown(self):
+        # Change back to a valid directory so that later calls to os.getcwd() do not fail.
+        os.chdir(self.original_dir)
+        run_command(['rm', '-rf', self.tracking_git_checkout_path])
+        run_command(['rm', '-rf', self.untracking_checkout_path])
+
+    def test_remote_branch_ref(self):
+        self.assertEqual(self.tracking_scm.remote_branch_ref(), 'refs/remotes/origin/master')
+
+        os.chdir(self.untracking_checkout_path)
+        self.assertRaises(ScriptError, self.untracking_scm.remote_branch_ref)
+
+
+class GitSVNTest(SCMTest):
+
+    def _setup_git_checkout(self):
         self.git_checkout_path = tempfile.mkdtemp(suffix="git_test_checkout")
         # --quiet doesn't make git svn silent, so we use run_silent to redirect output
         run_silent(['git', 'svn', 'clone', '-T', 'trunk', self.svn_repo_url, self.git_checkout_path])
+        os.chdir(self.git_checkout_path)
 
-    def _tear_down_git_clone_of_svn_repository(self):
+    def _tear_down_git_checkout(self):
+        # Change back to a valid directory so that later calls to os.getcwd() do not fail.
+        os.chdir(self.original_dir)
         run_command(['rm', '-rf', self.git_checkout_path])
 
     def setUp(self):
+        self.original_dir = os.getcwd()
+
         SVNTestRepository.setup(self)
-        self._setup_git_clone_of_svn_repository()
-        os.chdir(self.git_checkout_path)
+        self._setup_git_checkout()
         self.scm = detect_scm_system(self.git_checkout_path)
         # For historical reasons, we test some checkout code here too.
         self.checkout = Checkout(self.scm)
 
     def tearDown(self):
         SVNTestRepository.tear_down(self)
-        self._tear_down_git_clone_of_svn_repository()
+        self._tear_down_git_checkout()
 
     def test_detection(self):
         scm = detect_scm_system(self.git_checkout_path)
@@ -683,25 +721,24 @@ class GitTest(SCMTest):
         self.assertEqual(len(self.scm.local_commits()), 0)
 
     def test_delete_branch(self):
-        old_branch = run_command(['git', 'symbolic-ref', 'HEAD']).strip()
         new_branch = 'foo'
 
         run_command(['git', 'checkout', '-b', new_branch])
         self.assertEqual(run_command(['git', 'symbolic-ref', 'HEAD']).strip(), 'refs/heads/' + new_branch)
 
-        run_command(['git', 'checkout', old_branch])
+        run_command(['git', 'checkout', '-b', 'bar'])
         self.scm.delete_branch(new_branch)
 
         self.assertFalse(re.search(r'foo', run_command(['git', 'branch'])))
 
-    def test_svn_merge_base(self):
+    def test_remote_merge_base(self):
         # Diff to merge-base should include working-copy changes,
         # which the diff to svn_branch.. doesn't.
         test_file = os.path.join(self.git_checkout_path, 'test_file')
         write_into_file_at_path(test_file, 'foo')
 
-        diff_to_common_base = _git_diff(self.scm.svn_branch_name() + '..')
-        diff_to_merge_base = _git_diff(self.scm.svn_merge_base())
+        diff_to_common_base = _git_diff(self.scm.remote_branch_ref() + '..')
+        diff_to_merge_base = _git_diff(self.scm.remote_merge_base())
 
         self.assertFalse(re.search(r'foo', diff_to_common_base))
         self.assertTrue(re.search(r'foo', diff_to_merge_base))
@@ -888,6 +925,9 @@ class GitTest(SCMTest):
         scm = detect_scm_system(self.git_checkout_path)
         self.assertRaises(ScriptError, scm.commit_with_message, "another test commit", squash=True)
 
+    def test_remote_branch_ref(self):
+        self.assertEqual(self.scm.remote_branch_ref(), 'refs/remotes/trunk')
+
     def test_reverse_diff(self):
         self._shared_test_reverse_diff()