Add new git port to merge_to_branch script.

tools/push-to-trunk/common_includes.py

 #!/usr/bin/env python
 # Copyright 2013 the V8 project authors. 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
@@ skipping 328 matching lines @@
   def Land(self):
     self.step.GitSVNDCommit()
 
   def CLLand(self):
     self.step.GitDCommit()
 
   def Tag(self, tag):
     self.step.GitSVNTag(tag)
 
 
+class GitReadOnlyMixin(VCInterface):
+  def Pull(self):
+    self.step.GitPull()
+
+  def Fetch(self):
+    self.step.Git("fetch")
+
+  def GetTags(self):
+     return self.step.Git("tag").strip().splitlines()
+
+  def GetBranches(self):
+    # Get relevant remote branches, e.g. "origin/branch-heads/3.25".
+    branches = filter(
+        lambda s: re.match(r"^origin/branch\-heads/\d+\.\d+$", s),
+        self.step.GitRemotes())
+    # Remove 'origin/branch-heads/' prefix.
+    return map(lambda s: s[20:], branches)
+
+  def RemoteMasterBranch(self):
+    return "origin/master"
+
+  def RemoteCandidateBranch(self):
+    return "origin/candidates"
+
+  def RemoteBranch(self, name):
+    return "origin/branch-heads/%s" % name
+
+
+class GitReadSvnWriteInterface(GitReadOnlyMixin, GitSvnInterface):
+  pass
+
+
+VC_INTERFACES = {
+  "git_svn": GitSvnInterface,
+  "git_read_svn_write": GitReadSvnWriteInterface,
+}
+
 
 class Step(GitRecipesMixin):
   def __init__(self, text, number, config, state, options, handler):
     self._text = text
     self._number = number
     self._config = config
     self._state = state
     self._options = options
     self._side_effect_handler = handler
-    self.vc = GitSvnInterface()
+    self.vc = VC_INTERFACES[options.vc_port]()
     self.vc.InjectStep(self)
 
     # The testing configuration might set a different default cwd.
     self.default_cwd = self._config.get("DEFAULT_CWD") or DEFAULT_CWD
 
     assert self._number >= 0
     assert self._config is not None
     assert self._state is not None
     assert self._side_effect_handler is not None
 
@@ skipping 364 matching lines @@
                               "success, this will overwrite the reviewer "
                               "option."))
     parser.add_argument("--svn",
                         help=("Optional full svn checkout for the commit."
                               "The folder needs to be the svn root."))
     parser.add_argument("--svn-config",
                         help=("Optional folder used as svn --config-dir."))
     parser.add_argument("-s", "--step",
         help="Specify the step where to start work. Default: 0.",
         default=0, type=int)
+    parser.add_argument("--vc-port",

[tandrii(chromium), 2014/09/25 15:53:52]

why "port" and not "interface"? Is it less typing? :)
Or, alternatively, why VC_INTERFACES and not VC_PORTS above?

+                        help=("Choose VC port out of git_svn|"
+                              "git_read_svn_write."))
     self._PrepareOptions(parser)
 
     if args is None:  # pragma: no cover
       options = parser.parse_args()
     else:
       options = parser.parse_args(args)
 
     # Process common options.
     if options.step < 0:  # pragma: no cover
       print "Bad step number %d" % options.step
@@ skipping 16 matching lines @@
     # Derived options.
     options.requires_editor = not options.force
     options.wait_for_lgtm = not options.force
     options.force_readline_defaults = not options.manual
     options.force_upload = not options.manual
 
     # Process script specific options.
     if not self._ProcessOptions(options):
       parser.print_help()
       return None
+
+    if not options.vc_port:
+      options.vc_port = "git_svn"
     return options
 
   def RunSteps(self, step_classes, args=None):
     options = self.MakeOptions(args)
     if not options:
       return 1
 
     state_file = "%s-state.json" % self._config["PERSISTFILE_BASENAME"]
     if options.step == 0 and os.path.exists(state_file):
       os.remove(state_file)
 
     steps = []
     for (number, step_class) in enumerate(step_classes):
       steps.append(MakeStep(step_class, number, self._state, self._config,
                             options, self._side_effect_handler))
     for step in steps[options.step:]:
       if step.Run():
         return 0
     return 0
 
   def Run(self, args=None):
     return self.RunSteps(self._Steps(), args)