Fix git try --upstream_branch breakage due to removal of |file_list| param.

trychange.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 """Client-side script to send a try job to the try server. It communicates to
 the try server by either writting to a svn repository or by directly connecting
 to the server by HTTP.
 """
 
@@ skipping 75 matching lines @@
 
 def Escape(name):
   """Escapes characters that could interfere with the file system or try job
   parsing.
   """
   return re.sub(r'[^\w#-]', '_', name)
 
 
 class SCM(object):
   """Simplistic base class to implement one function: ProcessOptions."""
-  def __init__(self, options, path):
+  def __init__(self, options, path, file_list):
     items = path.split('@')
     assert len(items) <= 2
     self.checkout_root = items[0]
     items.append(None)
     self.diff_against = items[1]
     self.options = options
     # Lazy-load file list from the SCM unless files were specified in options.
     self._files = None
     self._file_tuples = None
-    if self.options.files:
-      self._files = self.options.files
+    if file_list:
+      self._files = file_list
       self._file_tuples = [('M', f) for f in self.files]
     self.options.files = None
     self.codereview_settings = None
     self.codereview_settings_file = 'codereview.settings'
     self.gclient_root = None
 
   def GetFileNames(self):
     """Return the list of files in the diff."""
     return self.files
 
@@ skipping 311 matching lines @@
 
 
 def PrintSuccess(options):
   if not options.dry_run:
     text = 'Patch \'%s\' sent to try server' % options.name
     if options.bot:
       text += ': %s' % ', '.join(options.bot)
     print(text)
 
 
-def GuessVCS(options, path):
+def GuessVCS(options, path, file_list):
   """Helper to guess the version control system.
 
   NOTE: Very similar to upload.GuessVCS. Doesn't look for hg since we don't
   support it yet.
 
   This examines the path directory, guesses which SCM we're using, and
   returns an instance of the appropriate class.  Exit with an error if we can't
   figure it out.
 
   Returns:
     A SCM instance. Exits if the SCM can't be guessed.
   """
   __pychecker__ = 'no-returnvalues'
   real_path = path.split('@')[0]
   logging.info("GuessVCS(%s)" % path)
   # Subversion has a .svn in all working directories.
   if os.path.isdir(os.path.join(real_path, '.svn')):
-    return SVN(options, path)
+    return SVN(options, path, file_list)
 
   # Git has a command to test if you're in a git tree.
   # Try running it, but don't die if we don't have git installed.
   try:
     subprocess2.check_output(
         ['git', 'rev-parse', '--is-inside-work-tree'], cwd=real_path,
         stderr=subprocess2.VOID)
-    return GIT(options, path)
+    return GIT(options, path, file_list)
   except subprocess2.CalledProcessError, e:
     if e.returncode != errno.ENOENT and e.returncode != 128:
       # ENOENT == 2 = they don't have git installed.
       # 128 = git error code when not in a repo.
       logging.warning('Unexpected error code: %s' % e.returncode)
       raise
   raise NoTryServerAccess("Could not guess version control system. "
                           "Are you in a working copy directory?")
 
 
@@ skipping 16 matching lines @@
               change,
               swallow_exception,
               prog=None,
               extra_epilog=None):
   """
   Args:
     argv: Arguments and options.
     change: Change instance corresponding to the CL.
     swallow_exception: Whether we raise or swallow exceptions.
   """
-  file_list = []
-  if change:
-    file_list = [f.LocalPath() for f in change.AffectedFiles()]
-
   # Parse argv
   parser = optparse.OptionParser(usage=USAGE,
                                  version=__version__,
                                  prog=prog)
   epilog = EPILOG % { 'prog': prog }
   if extra_epilog:
     epilog += extra_epilog
   parser.epilog = epilog
   # Remove epilog formatting
   parser.format_epilog = lambda x: parser.epilog
@@ skipping 46 matching lines @@
                    help="Add a gtest_filter to a test. Use multiple times to "
                         "specify filters for different tests. (i.e. "
                         "--testfilter base_unittests:ThreadTest.* "
                         "--testfilter ui_tests) If you specify any testfilters "
                         "the test results will not be reported in rietveld and "
                         "only tests with filters will run.")
 
   parser.add_option_group(group)
 
   group = optparse.OptionGroup(parser, "Patch to run")
-  group.add_option("-f", "--file", default=file_list, dest="files",
+  group.add_option("-f", "--file", default=[], dest="files",
                    metavar="FILE", action="append",
                    help="Use many times to list the files to include in the "
                         "try, relative to the repository root")
   group.add_option("--diff",
                    help="File containing the diff to try")
   group.add_option("--url",
                    help="Url where to grab a patch, e.g. "
                         "http://example.com/x.diff")
   group.add_option("-R", "--rietveld_url", default="codereview.appspot.com",
                    metavar="URL",
@@ skipping 89 matching lines @@
       if options.issue or options.patchset:
         parser.error('Cannot use both --issue and use a review number url')
       options.issue = int(match.group(2))
       options.rietveld_url = match.group(1)
 
   try:
     changed_files = None
     # Always include os.getcwd() in the checkout settings.
     checkouts = []
     path = os.getcwd()
+
+    file_list = []
+    if options.files:
+      file_list = options.files
+    elif change:
+      file_list = [f.LocalPath() for f in change.AffectedFiles()]
+
     if options.upstream_branch:
       path += '@' + options.upstream_branch
-    checkouts.append(GuessVCS(options, path))
+      # Clear file list so that the correct list will be retrieved from the
+      # upstream branch.
+      file_list = []
+    checkouts.append(GuessVCS(options, path, file_list))
     checkouts[0].AutomagicalSettings()
     for item in options.sub_rep:
       checkout = GuessVCS(options, os.path.join(checkouts[0].checkout_root,
-                                                item))
+                                                item), file_list)
       if checkout.checkout_root in [c.checkout_root for c in checkouts]:
         parser.error('Specified the root %s two times.' %
                      checkout.checkout_root)
       checkouts.append(checkout)
 
     can_http = options.port and options.host
     can_svn = options.svn_repo
     # If there was no transport selected yet, now we must have enough data to
     # select one.
     if not options.send_patch and not (can_http or can_svn):
@@ skipping 104 matching lines @@
     return 1
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, e
     return 1
   return 0
 
 
 if __name__ == "__main__":
   fix_encoding.fix_encoding()
   sys.exit(TryChange(None, None, False))