Modify scm.GIT.GetUpstreamBranch to behave like git-cl.

scm.py

 # Copyright (c) 2006-2009 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.
 
 """SCM-specific utility classes."""
 
 import glob
 import os
 import re
 import shutil
@@ skipping 184 matching lines @@
           if url in svn_refs:
             svn_branch = svn_refs[url]
             proc.stdout.close()  # Cut pipe.
             break
     return svn_branch
 
   @staticmethod
   def FetchUpstreamTuple(cwd):
     """Returns a tuple containg remote and remote ref,
        e.g. 'origin', 'refs/heads/master'
+       Tries to be intelligent and understand git-svn.
     """
     remote = '.'
     branch = GIT.GetBranch(cwd)
     upstream_branch = None
     upstream_branch = GIT.Capture(
         ['config', 'branch.%s.merge' % branch], in_directory=cwd,
         error_ok=True)[0].strip()
     if upstream_branch:
       remote = GIT.Capture(
           ['config', 'branch.%s.remote' % branch],
           in_directory=cwd, error_ok=True)[0].strip()
     else:
       # Fall back on trying a git-svn upstream branch.
       if GIT.IsGitSvn(cwd):
         upstream_branch = GIT.GetSVNBranch(cwd)
+      # Fall back on origin/master if it exits.
+      elif GIT.Capture(['branch', '-r'], in_directory=cwd
+                      )[0].split().count('origin/master'):
+        remote = 'origin'
+        upstream_branch = 'refs/heads/master'
+      else:
+        remote = None
+        upstream_branch = None
     return remote, upstream_branch
 
   @staticmethod
-  def GetUpstream(cwd):
+  def GetUpstreamBranch(cwd):
     """Gets the current branch's upstream branch."""
     remote, upstream_branch = GIT.FetchUpstreamTuple(cwd)
     if remote != '.':
       upstream_branch = upstream_branch.replace('heads', 'remotes/' + remote)
     return upstream_branch
 
   @staticmethod
   def GenerateDiff(cwd, branch=None, branch_head='HEAD', full_move=False,
                    files=None):
     """Diffs against the upstream branch or optionally another branch.
 
     full_move means that move or copy operations should completely recreate the
     files, usually in the prospect to apply the patch for a try job."""
     if not branch:
-      branch = GIT.GetUpstream(cwd)
+      branch = GIT.GetUpstreamBranch(cwd)
     command = ['diff', '-p', '--no-prefix', branch + "..." + branch_head]
     if not full_move:
       command.append('-C')
     # TODO(maruel): --binary support.
     if files:
       command.append('--')
       command.extend(files)
     diff = GIT.Capture(command, cwd)[0].splitlines(True)
     for i in range(len(diff)):
       # In the case of added files, replace /dev/null with the path to the
       # file being added.
       if diff[i].startswith('--- /dev/null'):
         diff[i] = '--- %s' % diff[i+1][4:]
     return ''.join(diff)
 
   @staticmethod
   def GetDifferentFiles(cwd, branch=None, branch_head='HEAD'):
     """Returns the list of modified files between two branches."""
     if not branch:
-      branch = GIT.GetUpstream(cwd)
+      branch = GIT.GetUpstreamBranch(cwd)
     command = ['diff', '--name-only', branch + "..." + branch_head]
     return GIT.Capture(command, cwd)[0].splitlines(False)
 
   @staticmethod
   def GetPatchName(cwd):
     """Constructs a name for this patch."""
     short_sha = GIT.Capture(['rev-parse', '--short=4', 'HEAD'], cwd)[0].strip()
     return "%s-%s" % (GIT.GetBranch(cwd), short_sha)
 
   @staticmethod
@@ skipping 509 matching lines @@
     if not SVN.current_version:
       SVN.current_version = SVN.Capture(['--version']).split()[2]
     current_version_list = map(only_int, SVN.current_version.split('.'))
     for min_ver in map(int, min_version.split('.')):
       ver = current_version_list.pop(0)
       if ver < min_ver:
         return (False, SVN.current_version)
       elif ver > min_ver:
         return (True, SVN.current_version)
     return (True, SVN.current_version)