libv8 4.5.95.5 → 5.0.71.48.0beta2

data/vendor/depot_tools/git-auto-svn

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-cache

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-cherry-pick-upload

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-cl

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-drover

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# Copyright 2015 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.
+
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-find-releases

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# Copyright 2014 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.
+
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-footers

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-freeze

@@ -5,4 +5,4 @@
 
 SCRIPT=git_freezer.py
 set -- freeze "$@"
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-gs

@@ -6,4 +6,4 @@ git grep -n -e "$@" -- "*.h" "*.hpp" "*.cpp" "*.c" "*.cc" "*.cpp" "*.inl"\
    "*.grd" "*.grdp" "*.idl" "*.m" "*.mm" "*.py" "*.sh" "*.cfg" "*.tac" "*.go"\
    "*SConscript" "SConscript*" "*.scons" "*.vcproj" "*.vsprops" "*.make"\
    "*.gyp" "*.gypi" "*.isolate" "*.java" "*.js" "*.html" "*.css" "*.ebuild" \
-   "*.pl" "*.pm" "*.yaml" "*.gn" "*.gni" "*.json"
+   "*.pl" "*.pm" "*.yaml" "*.gn" "*.gni" "*.json" "DEPS" "*/DEPS"

data/vendor/depot_tools/git-hyper-blame

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# Copyright 2016 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.
+
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-map

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh) | less -R
+. $(type -P python_runner.sh) | less -R

data/vendor/depot_tools/git-map-branches

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-mark-merge-base

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-nav-downstream

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-new-branch

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-number

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-rebase-update

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-rename-branch

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-reparent-branch

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-retry

@@ -5,4 +5,4 @@
 
 SCRIPT=git_retry.py
 set -- retry "$@"
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-squash-branch

@@ -3,4 +3,4 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-thaw

@@ -10,4 +10,4 @@
 
 SCRIPT=git_freezer.py
 set -- thaw "$@"
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-try

@@ -6,4 +6,4 @@
 # git_try.py - Commits a patch to the SVN try patch repo.
 #              It is highly recommended to use `git cl try` instead.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git-upstream-diff

@@ -6,4 +6,4 @@
 # git_upstream_diff.py -- Provide the diff between the current branch and its
 # upstream.
 
-. $(type -P python_git_runner.sh)
+. $(type -P python_runner.sh)

data/vendor/depot_tools/git_auto_svn.py

@@ -22,7 +22,8 @@ import subprocess2
 
 from git_common import run as run_git
 from git_common import run_stream_with_retcode as run_git_stream_with_retcode
-from git_common import set_config, root, ROOT
+from git_common import set_config, root, ROOT, current_branch
+from git_common import upstream as get_upstream
 from git_footers import get_footer_svn_id
 
 
@@ -57,7 +58,24 @@ def main(argv):
       description='Automatically set up git-svn for a repo mirrored from svn.')
   parser.parse_args(argv)
 
-  upstream = root()
+  upstreams = []
+  # Always configure the upstream trunk.
+  upstreams.append(root())
+  # Optionally configure whatever upstream branch might be currently checked
+  # out. This is needed for work on svn-based branches, otherwise git-svn gets
+  # very confused and tries to relate branch commits back to trunk, making a big
+  # mess of the codereview patches, and generating all kinds of spurious errors
+  # about the repo being in some sort of bad state.
+  curr_upstream = get_upstream(current_branch())
+  # There will be no upstream if the checkout is in detached HEAD.
+  if curr_upstream:
+    upstreams.append(curr_upstream)
+  for upstream in upstreams:
+    config_svn(upstream)
+  return 0
+
+
+def config_svn(upstream):
   svn_id = get_footer_svn_id(upstream)
   assert svn_id, 'No valid git-svn-id footer found on %s.' % upstream
   print 'Found git-svn-id footer %s on %s' % (svn_id, upstream)
@@ -86,14 +104,14 @@ def main(argv):
   assert svn_repo is not None, 'Unable to find svn repo for %s' % svn_id
   print 'Found upstream svn repo %s and path %s' % (svn_repo, svn_path)
 
-  set_config('svn-remote.svn.url', svn_repo)
-  set_config('svn-remote.svn.fetch',
-             '%s:refs/remotes/%s' % (svn_path, upstream))
+  run_git('config', '--local', '--replace-all', 'svn-remote.svn.url', svn_repo)
+  run_git('config', '--local', '--replace-all', 'svn-remote.svn.fetch',
+          '%s:refs/remotes/%s' % (svn_path, upstream),
+          'refs/remotes/%s$' % upstream)
   print 'Configured metadata, running "git svn fetch". This may take some time.'
   with run_git_stream_with_retcode('svn', 'fetch') as stdout:
     for line in stdout.xreadlines():
       print line.strip()
-  return 0
 
 
 if __name__ == '__main__':

data/vendor/depot_tools/git_cache.py

@@ -44,8 +44,9 @@ class RefsHeadsFailedToFetch(Exception):
 class Lockfile(object):
   """Class to represent a cross-platform process-specific lockfile."""
 
-  def __init__(self, path):
+  def __init__(self, path, timeout=0):
     self.path = os.path.abspath(path)
+    self.timeout = timeout
     self.lockfile = self.path + ".lock"
     self.pid = os.getpid()
 
@@ -91,16 +92,25 @@ class Lockfile(object):
   def lock(self):
     """Acquire the lock.
 
-    Note: This is a NON-BLOCKING FAIL-FAST operation.
-    Do. Or do not. There is no try.
+    This will block with a deadline of self.timeout seconds.
     """
-    try:
-      self._make_lockfile()
-    except OSError as e:
-      if e.errno == errno.EEXIST:
-        raise LockError("%s is already locked" % self.path)
-      else:
-        raise LockError("Failed to create %s (err %s)" % (self.path, e.errno))
+    elapsed = 0
+    while True:
+      try:
+        self._make_lockfile()
+        return
+      except OSError as e:
+        if elapsed < self.timeout:
+          sleep_time = max(10, min(3, self.timeout - elapsed))
+          logging.info('Could not create git cache lockfile; '
+                       'will retry after sleep(%d).', sleep_time);
+          elapsed += sleep_time
+          time.sleep(sleep_time)
+          continue
+        if e.errno == errno.EEXIST:
+          raise LockError("%s is already locked" % self.path)
+        else:
+          raise LockError("Failed to create %s (err %s)" % (self.path, e.errno))
 
   def unlock(self):
     """Release the lock."""
@@ -145,9 +155,24 @@ class Mirror(object):
     os.path.dirname(os.path.abspath(__file__)), 'gsutil.py')
   cachepath_lock = threading.Lock()
 
+  @staticmethod
+  def parse_fetch_spec(spec):
+    """Parses and canonicalizes a fetch spec.
+
+    Returns (fetchspec, value_regex), where value_regex can be used
+    with 'git config --replace-all'.
+    """
+    parts = spec.split(':', 1)
+    src = parts[0].lstrip('+').rstrip('/')
+    if not src.startswith('refs/'):
+      src = 'refs/heads/%s' % src
+    dest = parts[1].rstrip('/') if len(parts) > 1 else src
+    regex = r'\+%s:.*' % src.replace('*', r'\*')
+    return ('+%s:%s' % (src, dest), regex)
+
   def __init__(self, url, refs=None, print_func=None):
     self.url = url
-    self.refs = refs or []
+    self.fetch_specs = set([self.parse_fetch_spec(ref) for ref in (refs or [])])
     self.basedir = self.UrlToCacheDir(url)
     self.mirror_path = os.path.join(self.GetCachePath(), self.basedir)
     if print_func:
@@ -236,16 +261,9 @@ class Mirror(object):
     self.RunGit(['config', 'remote.origin.url', self.url], cwd=cwd)
     self.RunGit(['config', '--replace-all', 'remote.origin.fetch',
                  '+refs/heads/*:refs/heads/*', r'\+refs/heads/\*:.*'], cwd=cwd)
-    for ref in self.refs:
-      ref = ref.lstrip('+').rstrip('/')
-      if ref.startswith('refs/'):
-        refspec = '+%s:%s' % (ref, ref)
-        regex = r'\+%s:.*' % ref.replace('*', r'\*')
-      else:
-        refspec = '+refs/%s/*:refs/%s/*' % (ref, ref)
-        regex = r'\+refs/heads/%s:.*' % ref.replace('*', r'\*')
+    for spec, value_regex in self.fetch_specs:
       self.RunGit(
-          ['config', '--replace-all', 'remote.origin.fetch', refspec, regex],
+          ['config', '--replace-all', 'remote.origin.fetch', spec, value_regex],
           cwd=cwd)
 
   def bootstrap_repo(self, directory):
@@ -314,9 +332,27 @@ class Mirror(object):
   def exists(self):
     return os.path.isfile(os.path.join(self.mirror_path, 'config'))
 
+  def _preserve_fetchspec(self):
+    """Read and preserve remote.origin.fetch from an existing mirror.
+
+    This modifies self.fetch_specs.
+    """
+    if not self.exists():
+      return
+    try:
+      config_fetchspecs = subprocess.check_output(
+          [self.git_exe, 'config', '--get-all', 'remote.origin.fetch'],
+          cwd=self.mirror_path)
+      for fetchspec in config_fetchspecs.splitlines():
+        self.fetch_specs.add(self.parse_fetch_spec(fetchspec))
+    except subprocess.CalledProcessError:
+      logging.warn('Tried and failed to preserve remote.origin.fetch from the '
+                   'existing cache directory.  You may need to manually edit '
+                   '%s and "git cache fetch" again.'
+                   % os.path.join(self.mirror_path, 'config'))
+
   def _ensure_bootstrapped(self, depth, bootstrap, force=False):
     tempdir = None
-    config_file = os.path.join(self.mirror_path, 'config')
     pack_dir = os.path.join(self.mirror_path, 'objects', 'pack')
     pack_files = []
 
@@ -324,16 +360,19 @@ class Mirror(object):
       pack_files = [f for f in os.listdir(pack_dir) if f.endswith('.pack')]
 
     should_bootstrap = (force or
-                        not os.path.exists(config_file) or
+                        not self.exists() or
                         len(pack_files) > GC_AUTOPACKLIMIT)
     if should_bootstrap:
+      if self.exists():
+        # Re-bootstrapping an existing mirror; preserve existing fetch spec.
+        self._preserve_fetchspec()
       tempdir = tempfile.mkdtemp(
           prefix='_cache_tmp', suffix=self.basedir, dir=self.GetCachePath())
       bootstrapped = not depth and bootstrap and self.bootstrap_repo(tempdir)
       if bootstrapped:
         # Bootstrap succeeded; delete previous cache, if any.
         gclient_utils.rmtree(self.mirror_path)
-      elif not os.path.exists(config_file):
+      elif not self.exists():
         # Bootstrap failed, no previous cache; start with a bare git dir.
         self.RunGit(['init', '--bare'], cwd=tempdir)
       else:
@@ -372,13 +411,13 @@ class Mirror(object):
         logging.warn('Fetch of %s failed' % spec)
 
   def populate(self, depth=None, shallow=False, bootstrap=False,
-               verbose=False, ignore_lock=False):
+               verbose=False, ignore_lock=False, lock_timeout=0):
     assert self.GetCachePath()
     if shallow and not depth:
       depth = 10000
     gclient_utils.safe_makedirs(self.GetCachePath())
 
-    lockfile = Lockfile(self.mirror_path)
+    lockfile = Lockfile(self.mirror_path, lock_timeout)
     if not ignore_lock:
       lockfile.lock()
 
@@ -553,6 +592,7 @@ def CMDpopulate(parser, args):
       'shallow': options.shallow,
       'bootstrap': not options.no_bootstrap,
       'ignore_lock': options.ignore_locks,
+      'lock_timeout': options.timeout,
   }
   if options.depth:
     kwargs['depth'] = options.depth
@@ -563,6 +603,9 @@ def CMDpopulate(parser, args):
 def CMDfetch(parser, args):
   """Update mirror, and fetch in cwd."""
   parser.add_option('--all', action='store_true', help='Fetch all remotes')
+  parser.add_option('--no_bootstrap', '--no-bootstrap',
+                    action='store_true',
+                    help='Don\'t (re)bootstrap from Google Storage')
   options, args = parser.parse_args(args)
 
   # Figure out which remotes to fetch.  This mimics the behavior of regular
@@ -593,7 +636,8 @@ def CMDfetch(parser, args):
   git_dir = os.path.abspath(git_dir)
   if git_dir.startswith(cachepath):
     mirror = Mirror.FromPath(git_dir)
-    mirror.populate()
+    mirror.populate(
+        bootstrap=not options.no_bootstrap, lock_timeout=options.timeout)
     return 0
   for remote in remotes:
     remote_url = subprocess.check_output(
@@ -602,7 +646,8 @@ def CMDfetch(parser, args):
       mirror = Mirror.FromPath(remote_url)
       mirror.print = lambda *args: None
       print('Updating git cache...')
-      mirror.populate()
+      mirror.populate(
+          bootstrap=not options.no_bootstrap, lock_timeout=options.timeout)
     subprocess.check_call([Mirror.git_exe, 'fetch', remote])
   return 0
 
@@ -651,6 +696,8 @@ class OptionParser(optparse.OptionParser):
                     help='Increase verbosity (can be passed multiple times)')
     self.add_option('-q', '--quiet', action='store_true',
                     help='Suppress all extraneous output')
+    self.add_option('--timeout', type='int', default=0,
+                    help='Timeout for acquiring cache lock, in seconds')
 
   def parse_args(self, args=None, values=None):
     options, args = optparse.OptionParser.parse_args(self, args, values)

data/vendor/depot_tools/git_cl.py

@@ -5,7 +5,7 @@
 
 # Copyright (C) 2008 Evan Martin <martine@danga.com>
 
-"""A git-command for integrating reviews on Rietveld."""
+"""A git-command for integrating reviews on Rietveld and Gerrit."""
 
 from distutils.version import LooseVersion
 from multiprocessing.pool import ThreadPool
@@ -15,6 +15,7 @@ import glob
 import httplib
 import json
 import logging
+import multiprocessing
 import optparse
 import os
 import Queue
@@ -25,8 +26,10 @@ import tempfile
 import textwrap
 import time
 import traceback
+import urllib
 import urllib2
 import urlparse
+import uuid
 import webbrowser
 import zlib
 
@@ -39,13 +42,17 @@ from third_party import colorama
 from third_party import httplib2
 from third_party import upload
 import auth
-import breakpad  # pylint: disable=W0611
+from luci_hacks import trigger_luci_job as luci_trigger
 import clang_format
+import commit_queue
 import dart_format
+import setup_color
 import fix_encoding
 import gclient_utils
+import gerrit_util
+import git_cache
 import git_common
-from git_footers import get_footer_svn_id
+import git_footers
 import owners
 import owners_finder
 import presubmit_support
@@ -61,15 +68,11 @@ DEFAULT_SERVER = 'https://codereview.appspot.com'
 POSTUPSTREAM_HOOK_PATTERN = '.git/hooks/post-cl-%s'
 DESCRIPTION_BACKUP_FILE = '~/.git_cl_description_backup'
 GIT_INSTRUCTIONS_URL = 'http://code.google.com/p/chromium/wiki/UsingGit'
-CHANGE_ID = 'Change-Id:'
 REFS_THAT_ALIAS_TO_OTHER_REFS = {
     'refs/remotes/origin/lkgr': 'refs/remotes/origin/master',
     'refs/remotes/origin/lkcr': 'refs/remotes/origin/master',
 }
 
-# Buildbucket-related constants
-BUILDBUCKET_HOST = 'cr-buildbucket.appspot.com'
-
 # Valid extensions for files we want to lint.
 DEFAULT_LINT_REGEX = r"(.*\.cpp|.*\.cc|.*\.h)"
 DEFAULT_LINT_IGNORE_REGEX = r"$^"
@@ -93,9 +96,9 @@ def GetNoGitPagerEnv():
   return env
 
 
-def RunCommand(args, error_ok=False, error_message=None, **kwargs):
+def RunCommand(args, error_ok=False, error_message=None, shell=False, **kwargs):
   try:
-    return subprocess2.check_output(args, shell=False, **kwargs)
+    return subprocess2.check_output(args, shell=shell, **kwargs)
   except subprocess2.CalledProcessError as e:
     logging.debug('Failed running %s', args)
     if not error_ok:
@@ -156,7 +159,7 @@ def ask_for_data(prompt):
 
 
 def git_set_branch_value(key, value):
-  branch = Changelist().GetBranch()
+  branch = GetCurrentBranch()
   if not branch:
     return
 
@@ -168,7 +171,7 @@ def git_set_branch_value(key, value):
 
 
 def git_get_branch_default(key, default):
-  branch = Changelist().GetBranch()
+  branch = GetCurrentBranch()
   if branch:
     git_key = 'branch.%s.%s' % (branch, key)
     (_, stdout) = RunGitWithCode(['config', '--int', '--get', git_key])
@@ -217,6 +220,16 @@ def add_git_similarity(parser):
   parser.parse_args = Parse
 
 
+def _get_properties_from_options(options):
+  properties = dict(x.split('=', 1) for x in options.properties)
+  for key, val in properties.iteritems():
+    try:
+      properties[key] = json.loads(val)
+    except ValueError:
+      pass  # If a value couldn't be evaluated, treat it as a string.
+  return properties
+
+
 def _prefix_master(master):
   """Convert user-specified master name to full master name.
 
@@ -231,8 +244,57 @@ def _prefix_master(master):
   return '%s%s' % (prefix, master)
 
 
-def trigger_try_jobs(auth_config, changelist, options, masters, category,
-                     override_properties=None):
+def _buildbucket_retry(operation_name, http, *args, **kwargs):
+  """Retries requests to buildbucket service and returns parsed json content."""
+  try_count = 0
+  while True:
+    response, content = http.request(*args, **kwargs)
+    try:
+      content_json = json.loads(content)
+    except ValueError:
+      content_json = None
+
+    # Buildbucket could return an error even if status==200.
+    if content_json and content_json.get('error'):
+      error = content_json.get('error')
+      if error.get('code') == 403:
+        raise BuildbucketResponseException(
+            'Access denied: %s' % error.get('message', ''))
+      msg = 'Error in response. Reason: %s. Message: %s.' % (
+          error.get('reason', ''), error.get('message', ''))
+      raise BuildbucketResponseException(msg)
+
+    if response.status == 200:
+      if not content_json:
+        raise BuildbucketResponseException(
+            'Buildbucket returns invalid json content: %s.\n'
+            'Please file bugs at http://crbug.com, label "Infra-BuildBucket".' %
+            content)
+      return content_json
+    if response.status < 500 or try_count >= 2:
+      raise httplib2.HttpLib2Error(content)
+
+    # status >= 500 means transient failures.
+    logging.debug('Transient errors when %s. Will retry.', operation_name)
+    time.sleep(0.5 + 1.5*try_count)
+    try_count += 1
+  assert False, 'unreachable'
+
+
+def trigger_luci_job(changelist, masters, options):
+  """Send a job to run on LUCI."""
+  issue_props = changelist.GetIssueProperties()
+  issue = changelist.GetIssue()
+  patchset = changelist.GetMostRecentPatchset()
+  for builders_and_tests in sorted(masters.itervalues()):
+    # TODO(hinoka et al): add support for other properties.
+    # Currently, this completely ignores testfilter and other properties.
+    for builder in sorted(builders_and_tests):
+      luci_trigger.trigger(
+          builder, 'HEAD', issue, patchset, issue_props['project'])
+
+
+def trigger_try_jobs(auth_config, changelist, options, masters, category):
   rietveld_url = settings.GetDefaultServerUrl()
   rietveld_host = urlparse.urlparse(rietveld_url).hostname
   authenticator = auth.get_authenticator_for_host(rietveld_host, auth_config)
@@ -241,10 +303,11 @@ def trigger_try_jobs(auth_config, changelist, options, masters, category,
   issue_props = changelist.GetIssueProperties()
   issue = changelist.GetIssue()
   patchset = changelist.GetMostRecentPatchset()
+  properties = _get_properties_from_options(options)
 
   buildbucket_put_url = (
       'https://{hostname}/_ah/api/buildbucket/v1/builds/batch'.format(
-          hostname=BUILDBUCKET_HOST))
+          hostname=options.buildbucket_host))
   buildset = 'patch/rietveld/{hostname}/{issue}/{patch}'.format(
       hostname=rietveld_host,
       issue=issue,
@@ -260,9 +323,10 @@ def trigger_try_jobs(auth_config, changelist, options, masters, category,
       print_text.append('  %s: %s' % (builder, tests))
       parameters = {
           'builder_name': builder,
-          'changes': [
-              {'author': {'email': issue_props['owner_email']}},
-          ],
+          'changes': [{
+              'author': {'email': issue_props['owner_email']},
+              'revision': options.revision,
+          }],
           'properties': {
               'category': category,
               'issue': issue,
@@ -271,19 +335,22 @@ def trigger_try_jobs(auth_config, changelist, options, masters, category,
               'patch_storage': 'rietveld',
               'patchset': patchset,
               'reason': options.name,
-              'revision': options.revision,
               'rietveld': rietveld_url,
-              'testfilter': tests,
           },
       }
-      if override_properties:
-        parameters['properties'].update(override_properties)
+      if 'presubmit' in builder.lower():
+        parameters['properties']['dry_run'] = 'true'
+      if tests:
+        parameters['properties']['testfilter'] = tests
+      if properties:
+        parameters['properties'].update(properties)
       if options.clobber:
         parameters['properties']['clobber'] = True
       batch_req_body['builds'].append(
           {
               'bucket': bucket,
               'parameters_json': json.dumps(parameters),
+              'client_operation_id': str(uuid.uuid4()),
               'tags': ['builder:%s' % builder,
                        'buildset:%s' % buildset,
                        'master:%s' % master,
@@ -291,42 +358,155 @@ def trigger_try_jobs(auth_config, changelist, options, masters, category,
           }
       )
 
-  for try_count in xrange(3):
-    response, content = http.request(
-        buildbucket_put_url,
-        'PUT',
-        body=json.dumps(batch_req_body),
-        headers={'Content-Type': 'application/json'},
-    )
-    content_json = None
-    try:
-      content_json = json.loads(content)
-    except ValueError:
-      pass
+  _buildbucket_retry(
+      'triggering tryjobs',
+      http,
+      buildbucket_put_url,
+      'PUT',
+      body=json.dumps(batch_req_body),
+      headers={'Content-Type': 'application/json'}
+  )
+  print_text.append('To see results here, run:        git cl try-results')
+  print_text.append('To see results in browser, run:  git cl web')
+  print '\n'.join(print_text)
 
-    # Buildbucket could return an error even if status==200.
-    if content_json and content_json.get('error'):
-      msg = 'Error in response. Code: %d. Reason: %s. Message: %s.' % (
-          content_json['error'].get('code', ''),
-          content_json['error'].get('reason', ''),
-          content_json['error'].get('message', ''))
-      raise BuildbucketResponseException(msg)
 
-    if response.status == 200:
-      if not content_json:
-        raise BuildbucketResponseException(
-            'Buildbucket returns invalid json content: %s.\n'
-            'Please file bugs at crbug.com, label "Infra-BuildBucket".' %
-            content)
+def fetch_try_jobs(auth_config, changelist, options):
+  """Fetches tryjobs from buildbucket.
+
+  Returns a map from build id to build info as json dictionary.
+  """
+  rietveld_url = settings.GetDefaultServerUrl()
+  rietveld_host = urlparse.urlparse(rietveld_url).hostname
+  authenticator = auth.get_authenticator_for_host(rietveld_host, auth_config)
+  if authenticator.has_cached_credentials():
+    http = authenticator.authorize(httplib2.Http())
+  else:
+    print ('Warning: Some results might be missing because %s' %
+           # Get the message on how to login.
+           auth.LoginRequiredError(rietveld_host).message)
+    http = httplib2.Http()
+
+  http.force_exception_to_status_code = True
+
+  buildset = 'patch/rietveld/{hostname}/{issue}/{patch}'.format(
+      hostname=rietveld_host,
+      issue=changelist.GetIssue(),
+      patch=options.patchset)
+  params = {'tag': 'buildset:%s' % buildset}
+
+  builds = {}
+  while True:
+    url = 'https://{hostname}/_ah/api/buildbucket/v1/search?{params}'.format(
+        hostname=options.buildbucket_host,
+        params=urllib.urlencode(params))
+    content = _buildbucket_retry('fetching tryjobs', http, url, 'GET')
+    for build in content.get('builds', []):
+      builds[build['id']] = build
+    if 'next_cursor' in content:
+      params['start_cursor'] = content['next_cursor']
+    else:
       break
-    if response.status < 500 or try_count >= 2:
-      raise httplib2.HttpLib2Error(content)
+  return builds
 
-    # status >= 500 means transient failures.
-    logging.debug('Transient errors when triggering tryjobs. Will retry.')
-    time.sleep(0.5 + 1.5*try_count)
 
-  print '\n'.join(print_text)
+def print_tryjobs(options, builds):
+  """Prints nicely result of fetch_try_jobs."""
+  if not builds:
+    print 'No tryjobs scheduled'
+    return
+
+  # Make a copy, because we'll be modifying builds dictionary.
+  builds = builds.copy()
+  builder_names_cache = {}
+
+  def get_builder(b):
+    try:
+      return builder_names_cache[b['id']]
+    except KeyError:
+      try:
+        parameters = json.loads(b['parameters_json'])
+        name = parameters['builder_name']
+      except (ValueError, KeyError) as error:
+        print 'WARNING: failed to get builder name for build %s: %s' % (
+              b['id'], error)
+        name = None
+      builder_names_cache[b['id']] = name
+      return name
+
+  def get_bucket(b):
+    bucket = b['bucket']
+    if bucket.startswith('master.'):
+      return bucket[len('master.'):]
+    return bucket
+
+  if options.print_master:
+    name_fmt = '%%-%ds %%-%ds' % (
+        max(len(str(get_bucket(b))) for b in builds.itervalues()),
+        max(len(str(get_builder(b))) for b in builds.itervalues()))
+    def get_name(b):
+      return name_fmt % (get_bucket(b), get_builder(b))
+  else:
+    name_fmt = '%%-%ds' % (
+        max(len(str(get_builder(b))) for b in builds.itervalues()))
+    def get_name(b):
+      return name_fmt % get_builder(b)
+
+  def sort_key(b):
+    return b['status'], b.get('result'), get_name(b), b.get('url')
+
+  def pop(title, f, color=None, **kwargs):
+    """Pop matching builds from `builds` dict and print them."""
+
+    if not options.color or color is None:
+      colorize = str
+    else:
+      colorize = lambda x: '%s%s%s' % (color, x, Fore.RESET)
+
+    result = []
+    for b in builds.values():
+      if all(b.get(k) == v for k, v in kwargs.iteritems()):
+        builds.pop(b['id'])
+        result.append(b)
+    if result:
+      print colorize(title)
+      for b in sorted(result, key=sort_key):
+        print ' ', colorize('\t'.join(map(str, f(b))))
+
+  total = len(builds)
+  pop(status='COMPLETED', result='SUCCESS',
+      title='Successes:', color=Fore.GREEN,
+      f=lambda b: (get_name(b), b.get('url')))
+  pop(status='COMPLETED', result='FAILURE', failure_reason='INFRA_FAILURE',
+      title='Infra Failures:', color=Fore.MAGENTA,
+      f=lambda b: (get_name(b), b.get('url')))
+  pop(status='COMPLETED', result='FAILURE', failure_reason='BUILD_FAILURE',
+      title='Failures:', color=Fore.RED,
+      f=lambda b: (get_name(b), b.get('url')))
+  pop(status='COMPLETED', result='CANCELED',
+      title='Canceled:', color=Fore.MAGENTA,
+      f=lambda b: (get_name(b),))
+  pop(status='COMPLETED', result='FAILURE',
+      failure_reason='INVALID_BUILD_DEFINITION',
+      title='Wrong master/builder name:', color=Fore.MAGENTA,
+      f=lambda b: (get_name(b),))
+  pop(status='COMPLETED', result='FAILURE',
+      title='Other failures:',
+      f=lambda b: (get_name(b), b.get('failure_reason'), b.get('url')))
+  pop(status='COMPLETED',
+      title='Other finished:',
+      f=lambda b: (get_name(b), b.get('result'), b.get('url')))
+  pop(status='STARTED',
+      title='Started:', color=Fore.YELLOW,
+      f=lambda b: (get_name(b), b.get('url')))
+  pop(status='SCHEDULED',
+      title='Scheduled:',
+      f=lambda b: (get_name(b), 'id=%s' % b['id']))
+  # The last section is just in case buildbucket API changes OR there is a bug.
+  pop(title='Other:',
+      f=lambda b: (get_name(b), 'id=%s' % b['id']))
+  assert len(builds) == 0
+  print 'Total: %d tryjobs' % total
 
 
 def MatchSvnGlob(url, base_url, glob_spec, allow_wildcards):
@@ -411,6 +591,8 @@ class Settings(object):
     self.viewvc_url = None
     self.updated = False
     self.is_gerrit = None
+    self.squash_gerrit_uploads = None
+    self.gerrit_skip_ensure_authenticated = None
     self.git_editor = None
     self.project = None
     self.force_https_commit_url = None
@@ -428,10 +610,6 @@ class Settings(object):
       cr_settings_file = FindCodereviewSettingsFile()
       if autoupdate != 'false' and cr_settings_file:
         LoadCodereviewSettingsFromFile(cr_settings_file)
-        # set updated to True to avoid infinite calling loop
-        # through DownloadHooks
-        self.updated = True
-        DownloadHooks(False)
       self.updated = True
 
   def GetDefaultServerUrl(self, error_ok=False):
@@ -457,6 +635,19 @@ class Settings(object):
       self.root = os.path.abspath(self.GetRelativeRoot())
     return self.root
 
+  def GetGitMirror(self, remote='origin'):
+    """If this checkout is from a local git mirror, return a Mirror object."""
+    local_url = RunGit(['config', '--get', 'remote.%s.url' % remote]).strip()
+    if not os.path.isdir(local_url):
+      return None
+    git_cache.Mirror.SetCachePath(os.path.dirname(local_url))
+    remote_url = git_cache.Mirror.CacheDirToUrl(local_url)
+    # Use the /dev/null print_func to avoid terminal spew in WaitForRealCommit.
+    mirror = git_cache.Mirror(remote_url, print_func = lambda *args: None)
+    if mirror.exists():
+      return mirror
+    return None
+
   def GetIsGitSvn(self):
     """Return true if this repo looks like it's using git-svn."""
     if self.is_git_svn is None:
@@ -554,6 +745,11 @@ class Settings(object):
   def GetBugPrefix(self):
     return self._GetRietveldConfig('bug-prefix', error_ok=True)
 
+  def GetIsSkipDependencyUpload(self, branch_name):
+    """Returns true if specified branch should skip dep uploads."""
+    return self._GetBranchConfig(branch_name, 'skip-deps-uploads',
+                                 error_ok=True)
+
   def GetRunPostUploadHook(self):
     run_post_upload_hook = self._GetRietveldConfig(
         'run-post-upload-hook', error_ok=True)
@@ -571,6 +767,23 @@ class Settings(object):
       self.is_gerrit = self._GetConfig('gerrit.host', error_ok=True)
     return self.is_gerrit
 
+  def GetSquashGerritUploads(self):
+    """Return true if uploads to Gerrit should be squashed by default."""
+    if self.squash_gerrit_uploads is None:
+      self.squash_gerrit_uploads = (
+          RunGit(['config', '--bool', 'gerrit.squash-uploads'],
+                 error_ok=True).strip() == 'true')
+    return self.squash_gerrit_uploads
+
+  def GetGerritSkipEnsureAuthenticated(self):
+    """Return True if EnsureAuthenticated should not be done for Gerrit
+    uploads."""
+    if self.gerrit_skip_ensure_authenticated is None:
+      self.gerrit_skip_ensure_authenticated = (
+          RunGit(['config', '--bool', 'gerrit.skip-ensure-authenticated'],
+                 error_ok=True).strip() == 'true')
+    return self.gerrit_skip_ensure_authenticated
+
   def GetGitEditor(self):
     """Return the editor specified in the git config, or None if none is."""
     if self.git_editor is None:
@@ -605,6 +818,9 @@ class Settings(object):
   def _GetRietveldConfig(self, param, **kwargs):
     return self._GetConfig('rietveld.' + param, **kwargs)
 
+  def _GetBranchConfig(self, branch_name, param, **kwargs):
+    return self._GetConfig('branch.' + branch_name + '.' + param, **kwargs)
+
   def _GetConfig(self, param, **kwargs):
     self.LazyUpdateIfNeeded()
     return RunGit(['config', param], **kwargs).strip()
@@ -612,23 +828,110 @@ class Settings(object):
 
 def ShortBranchName(branch):
   """Convert a name like 'refs/heads/foo' to just 'foo'."""
-  return branch.replace('refs/heads/', '')
+  return branch.replace('refs/heads/', '', 1)
+
+
+def GetCurrentBranchRef():
+  """Returns branch ref (e.g., refs/heads/master) or None."""
+  return RunGit(['symbolic-ref', 'HEAD'],
+                stderr=subprocess2.VOID, error_ok=True).strip() or None
+
+
+def GetCurrentBranch():
+  """Returns current branch or None.
+
+  For refs/heads/* branches, returns just last part. For others, full ref.
+  """
+  branchref = GetCurrentBranchRef()
+  if branchref:
+    return ShortBranchName(branchref)
+  return None
+
+
+class _CQState(object):
+  """Enum for states of CL with respect to Commit Queue."""
+  NONE = 'none'
+  DRY_RUN = 'dry_run'
+  COMMIT = 'commit'
+
+  ALL_STATES = [NONE, DRY_RUN, COMMIT]
+
+
+class _ParsedIssueNumberArgument(object):
+  def __init__(self, issue=None, patchset=None, hostname=None):
+    self.issue = issue
+    self.patchset = patchset
+    self.hostname = hostname
+
+  @property
+  def valid(self):
+    return self.issue is not None
+
+
+class _RietveldParsedIssueNumberArgument(_ParsedIssueNumberArgument):
+  def __init__(self, *args, **kwargs):
+    self.patch_url = kwargs.pop('patch_url', None)
+    super(_RietveldParsedIssueNumberArgument, self).__init__(*args, **kwargs)
+
+
+def ParseIssueNumberArgument(arg):
+  """Parses the issue argument and returns _ParsedIssueNumberArgument."""
+  fail_result = _ParsedIssueNumberArgument()
+
+  if arg.isdigit():
+    return _ParsedIssueNumberArgument(issue=int(arg))
+  if not arg.startswith('http'):
+    return fail_result
+  url = gclient_utils.UpgradeToHttps(arg)
+  try:
+    parsed_url = urlparse.urlparse(url)
+  except ValueError:
+    return fail_result
+  for cls in _CODEREVIEW_IMPLEMENTATIONS.itervalues():
+    tmp = cls.ParseIssueURL(parsed_url)
+    if tmp is not None:
+      return tmp
+  return fail_result
 
 
 class Changelist(object):
-  def __init__(self, branchref=None, issue=None, auth_config=None):
+  """Changelist works with one changelist in local branch.
+
+  Supports two codereview backends: Rietveld or Gerrit, selected at object
+  creation.
+
+  Notes:
+    * Not safe for concurrent multi-{thread,process} use.
+    * Caches values from current branch. Therefore, re-use after branch change
+      with care.
+  """
+
+  def __init__(self, branchref=None, issue=None, codereview=None, **kwargs):
+    """Create a new ChangeList instance.
+
+    If issue is given, the codereview must be given too.
+
+    If `codereview` is given, it must be 'rietveld' or 'gerrit'.
+    Otherwise, it's decided based on current configuration of the local branch,
+    with default being 'rietveld' for backwards compatibility.
+    See _load_codereview_impl for more details.
+
+    **kwargs will be passed directly to codereview implementation.
+    """
     # Poke settings so we get the "configure your server" message if necessary.
     global settings
     if not settings:
       # Happens when git_cl.py is used as a utility library.
       settings = Settings()
-    settings.GetDefaultServerUrl()
+
+    if issue:
+      assert codereview, 'codereview must be known, if issue is known'
+
     self.branchref = branchref
     if self.branchref:
       self.branch = ShortBranchName(self.branchref)
     else:
       self.branch = None
-    self.rietveld_server = None
     self.upstream_branch = None
     self.lookedup_issue = False
     self.issue = issue or None
@@ -638,14 +941,43 @@ class Changelist(object):
     self.patchset = None
     self.cc = None
     self.watchers = ()
-    self._auth_config = auth_config
-    self._props = None
     self._remote = None
-    self._rpc_server = None
 
-  @property
-  def auth_config(self):
-    return self._auth_config
+    self._codereview_impl = None
+    self._codereview = None
+    self._load_codereview_impl(codereview, **kwargs)
+    assert self._codereview_impl
+    assert self._codereview in _CODEREVIEW_IMPLEMENTATIONS
+
+  def _load_codereview_impl(self, codereview=None, **kwargs):
+    if codereview:
+      assert codereview in _CODEREVIEW_IMPLEMENTATIONS
+      cls = _CODEREVIEW_IMPLEMENTATIONS[codereview]
+      self._codereview = codereview
+      self._codereview_impl = cls(self, **kwargs)
+      return
+
+    # Automatic selection based on issue number set for a current branch.
+    # Rietveld takes precedence over Gerrit.
+    assert not self.issue
+    # Whether we find issue or not, we are doing the lookup.
+    self.lookedup_issue = True
+    for codereview, cls in _CODEREVIEW_IMPLEMENTATIONS.iteritems():
+      setting = cls.IssueSetting(self.GetBranch())
+      issue = RunGit(['config', setting], error_ok=True).strip()
+      if issue:
+        self._codereview = codereview
+        self._codereview_impl = cls(self, **kwargs)
+        self.issue = int(issue)
+        return
+
+    # No issue is set for this branch, so decide based on repo-wide settings.
+    return self._load_codereview_impl(
+        codereview='gerrit' if settings.GetIsGerrit() else 'rietveld',
+        **kwargs)
+
+  def IsGerrit(self):
+    return self._codereview == 'gerrit'
 
   def GetCCList(self):
     """Return the users cc'd on this CL.
@@ -673,8 +1005,7 @@ class Changelist(object):
   def GetBranch(self):
     """Returns the short branch name, e.g. 'master'."""
     if not self.branch:
-      branchref = RunGit(['symbolic-ref', 'HEAD'],
-                         stderr=subprocess2.VOID, error_ok=True).strip()
+      branchref = GetCurrentBranchRef()
       if not branchref:
         return None
       self.branchref = branchref
@@ -686,6 +1017,10 @@ class Changelist(object):
     self.GetBranch()  # Poke the lazy loader.
     return self.branchref
 
+  def ClearBranch(self):
+    """Clears cached branch data of this object."""
+    self.branch = self.branchref = None
+
   @staticmethod
   def FetchUpstreamTuple(branch):
     """Returns a tuple containing remote and remote ref,
@@ -718,11 +1053,12 @@ class Changelist(object):
             remote = 'origin'
             upstream_branch = 'refs/heads/trunk'
           else:
-            DieWithError("""Unable to determine default branch to diff against.
-Either pass complete "git diff"-style arguments, like
-  git cl upload origin/master
-or verify this branch is set up to track another (via the --track argument to
-"git checkout -b ...").""")
+            DieWithError(
+               'Unable to determine default branch to diff against.\n'
+               'Either pass complete "git diff"-style arguments, like\n'
+               '  git cl upload origin/master\n'
+               'or verify this branch is set up to track another \n'
+               '(via the --track argument to "git checkout -b ...").')
 
     return remote, upstream_branch
 
@@ -787,7 +1123,7 @@ or verify this branch is set up to track another (via the --track argument to
     if upstream_git_obj is None:
       if self.GetBranch() is None:
         print >> sys.stderr, (
-            'ERROR: unable to dertermine current branch (detached HEAD?)')
+            'ERROR: unable to determine current branch (detached HEAD?)')
       else:
         print >> sys.stderr, (
             'ERROR: no upstream branch')
@@ -864,56 +1200,24 @@ or verify this branch is set up to track another (via the --track argument to
   def GetIssue(self):
     """Returns the issue number as a int or None if not set."""
     if self.issue is None and not self.lookedup_issue:
-      issue = RunGit(['config', self._IssueSetting()], error_ok=True).strip()
+      issue = RunGit(['config',
+                      self._codereview_impl.IssueSetting(self.GetBranch())],
+                     error_ok=True).strip()
       self.issue = int(issue) or None if issue else None
       self.lookedup_issue = True
     return self.issue
 
-  def GetRietveldServer(self):
-    if not self.rietveld_server:
-      # If we're on a branch then get the server potentially associated
-      # with that branch.
-      if self.GetIssue():
-        rietveld_server_config = self._RietveldServer()
-        if rietveld_server_config:
-          self.rietveld_server = gclient_utils.UpgradeToHttps(RunGit(
-              ['config', rietveld_server_config], error_ok=True).strip())
-      if not self.rietveld_server:
-        self.rietveld_server = settings.GetDefaultServerUrl()
-    return self.rietveld_server
-
   def GetIssueURL(self):
     """Get the URL for a particular issue."""
-    if not self.GetIssue():
+    issue = self.GetIssue()
+    if not issue:
       return None
-    return '%s/%s' % (self.GetRietveldServer(), self.GetIssue())
+    return '%s/%s' % (self._codereview_impl.GetCodereviewServer(), issue)
 
   def GetDescription(self, pretty=False):
     if not self.has_description:
       if self.GetIssue():
-        issue = self.GetIssue()
-        try:
-          self.description = self.RpcServer().get_description(issue).strip()
-        except urllib2.HTTPError as e:
-          if e.code == 404:
-            DieWithError(
-                ('\nWhile fetching the description for issue %d, received a '
-                 '404 (not found)\n'
-                 'error. It is likely that you deleted this '
-                 'issue on the server. If this is the\n'
-                 'case, please run\n\n'
-                 '    git cl issue 0\n\n'
-                 'to clear the association with the deleted issue. Then run '
-                 'this command again.') % issue)
-          else:
-            DieWithError(
-                '\nFailed to fetch issue description. HTTP error %d' % e.code)
-        except urllib2.URLError as e:
-          print >> sys.stderr, (
-              'Warning: Failed to retrieve CL description due to network '
-              'failure.')
-          self.description = ''
-
+        self.description = self._codereview_impl.FetchDescription()
       self.has_description = True
     if pretty:
       wrapper = textwrap.TextWrapper()
@@ -924,7 +1228,7 @@ or verify this branch is set up to track another (via the --track argument to
   def GetPatchset(self):
     """Returns the patchset number as a int or None if not set."""
     if self.patchset is None and not self.lookedup_patchset:
-      patchset = RunGit(['config', self._PatchsetSetting()],
+      patchset = RunGit(['config', self._codereview_impl.PatchsetSetting()],
                         error_ok=True).strip()
       self.patchset = int(patchset) or None if patchset else None
       self.lookedup_patchset = True
@@ -932,47 +1236,29 @@ or verify this branch is set up to track another (via the --track argument to
 
   def SetPatchset(self, patchset):
     """Set this branch's patchset.  If patchset=0, clears the patchset."""
+    patchset_setting = self._codereview_impl.PatchsetSetting()
     if patchset:
-      RunGit(['config', self._PatchsetSetting(), str(patchset)])
+      RunGit(['config', patchset_setting, str(patchset)])
       self.patchset = patchset
     else:
-      RunGit(['config', '--unset', self._PatchsetSetting()],
+      RunGit(['config', '--unset', patchset_setting],
              stderr=subprocess2.PIPE, error_ok=True)
       self.patchset = None
 
-  def GetMostRecentPatchset(self):
-    return self.GetIssueProperties()['patchsets'][-1]
-
-  def GetPatchSetDiff(self, issue, patchset):
-    return self.RpcServer().get(
-        '/download/issue%s_%s.diff' % (issue, patchset))
-
-  def GetIssueProperties(self):
-    if self._props is None:
-      issue = self.GetIssue()
-      if not issue:
-        self._props = {}
-      else:
-        self._props = self.RpcServer().get_issue_properties(issue, True)
-    return self._props
-
-  def GetApprovingReviewers(self):
-    return get_approving_reviewers(self.GetIssueProperties())
-
-  def AddComment(self, message):
-    return self.RpcServer().add_comment(self.GetIssue(), message)
-
-  def SetIssue(self, issue):
-    """Set this branch's issue.  If issue=0, clears the issue."""
+  def SetIssue(self, issue=None):
+    """Set this branch's issue.  If issue isn't given, clears the issue."""
+    issue_setting = self._codereview_impl.IssueSetting(self.GetBranch())
+    codereview_setting = self._codereview_impl.GetCodereviewServerSetting()
     if issue:
       self.issue = issue
-      RunGit(['config', self._IssueSetting(), str(issue)])
-      if self.rietveld_server:
-        RunGit(['config', self._RietveldServer(), self.rietveld_server])
+      RunGit(['config', issue_setting, str(issue)])
+      codereview_server = self._codereview_impl.GetCodereviewServer()
+      if codereview_server:
+        RunGit(['config', codereview_setting, codereview_server])
     else:
       current_issue = self.GetIssue()
       if current_issue:
-        RunGit(['config', '--unset', self._IssueSetting()])
+        RunGit(['config', '--unset', issue_setting])
       self.issue = None
       self.SetPatchset(None)
 
@@ -1022,6 +1308,343 @@ or verify this branch is set up to track another (via the --track argument to
         author,
         upstream=upstream_branch)
 
+  def UpdateDescription(self, description):
+    self.description = description
+    return self._codereview_impl.UpdateDescriptionRemote(description)
+
+  def RunHook(self, committing, may_prompt, verbose, change):
+    """Calls sys.exit() if the hook fails; returns a HookResults otherwise."""
+    try:
+      return presubmit_support.DoPresubmitChecks(change, committing,
+          verbose=verbose, output_stream=sys.stdout, input_stream=sys.stdin,
+          default_presubmit=None, may_prompt=may_prompt,
+          rietveld_obj=self._codereview_impl.GetRieveldObjForPresubmit(),
+          gerrit_obj=self._codereview_impl.GetGerritObjForPresubmit())
+    except presubmit_support.PresubmitFailure, e:
+      DieWithError(
+          ('%s\nMaybe your depot_tools is out of date?\n'
+           'If all fails, contact maruel@') % e)
+
+  def CMDPatchIssue(self, issue_arg, reject, nocommit, directory):
+    """Fetches and applies the issue patch from codereview to local branch."""
+    if isinstance(issue_arg, (int, long)) or issue_arg.isdigit():
+      parsed_issue_arg = _ParsedIssueNumberArgument(int(issue_arg))
+    else:
+      # Assume url.
+      parsed_issue_arg = self._codereview_impl.ParseIssueURL(
+          urlparse.urlparse(issue_arg))
+    if not parsed_issue_arg or not parsed_issue_arg.valid:
+      DieWithError('Failed to parse issue argument "%s". '
+                   'Must be an issue number or a valid URL.' % issue_arg)
+    return self._codereview_impl.CMDPatchWithParsedIssue(
+        parsed_issue_arg, reject, nocommit, directory)
+
+  def CMDUpload(self, options, git_diff_args, orig_args):
+    """Uploads a change to codereview."""
+    if git_diff_args:
+      # TODO(ukai): is it ok for gerrit case?
+      base_branch = git_diff_args[0]
+    else:
+      if self.GetBranch() is None:
+        DieWithError('Can\'t upload from detached HEAD state. Get on a branch!')
+
+      # Default to diffing against common ancestor of upstream branch
+      base_branch = self.GetCommonAncestorWithUpstream()
+      git_diff_args = [base_branch, 'HEAD']
+
+    # Make sure authenticated to codereview before running potentially expensive
+    # hooks.  It is a fast, best efforts check. Codereview still can reject the
+    # authentication during the actual upload.
+    self._codereview_impl.EnsureAuthenticated(force=options.force)
+
+    # Apply watchlists on upload.
+    change = self.GetChange(base_branch, None)
+    watchlist = watchlists.Watchlists(change.RepositoryRoot())
+    files = [f.LocalPath() for f in change.AffectedFiles()]
+    if not options.bypass_watchlists:
+      self.SetWatchers(watchlist.GetWatchersForPaths(files))
+
+    if not options.bypass_hooks:
+      if options.reviewers or options.tbr_owners:
+        # Set the reviewer list now so that presubmit checks can access it.
+        change_description = ChangeDescription(change.FullDescriptionText())
+        change_description.update_reviewers(options.reviewers,
+                                            options.tbr_owners,
+                                            change)
+        change.SetDescriptionText(change_description.description)
+      hook_results = self.RunHook(committing=False,
+                                may_prompt=not options.force,
+                                verbose=options.verbose,
+                                change=change)
+      if not hook_results.should_continue():
+        return 1
+      if not options.reviewers and hook_results.reviewers:
+        options.reviewers = hook_results.reviewers.split(',')
+
+    if self.GetIssue():
+      latest_patchset = self.GetMostRecentPatchset()
+      local_patchset = self.GetPatchset()
+      if (latest_patchset and local_patchset and
+          local_patchset != latest_patchset):
+        print ('The last upload made from this repository was patchset #%d but '
+               'the most recent patchset on the server is #%d.'
+               % (local_patchset, latest_patchset))
+        print ('Uploading will still work, but if you\'ve uploaded to this '
+               'issue from another machine or branch the patch you\'re '
+               'uploading now might not include those changes.')
+        ask_for_data('About to upload; enter to confirm.')
+
+    print_stats(options.similarity, options.find_copies, git_diff_args)
+    ret = self.CMDUploadChange(options, git_diff_args, change)
+    if not ret:
+      git_set_branch_value('last-upload-hash',
+                           RunGit(['rev-parse', 'HEAD']).strip())
+      # Run post upload hooks, if specified.
+      if settings.GetRunPostUploadHook():
+        presubmit_support.DoPostUploadExecuter(
+            change,
+            self,
+            settings.GetRoot(),
+            options.verbose,
+            sys.stdout)
+
+      # Upload all dependencies if specified.
+      if options.dependencies:
+        print
+        print '--dependencies has been specified.'
+        print 'All dependent local branches will be re-uploaded.'
+        print
+        # Remove the dependencies flag from args so that we do not end up in a
+        # loop.
+        orig_args.remove('--dependencies')
+        ret = upload_branch_deps(self, orig_args)
+    return ret
+
+  def SetCQState(self, new_state):
+    """Update the CQ state for latest patchset.
+
+    Issue must have been already uploaded and known.
+    """
+    assert new_state in _CQState.ALL_STATES
+    assert self.GetIssue()
+    return self._codereview_impl.SetCQState(new_state)
+
+  # Forward methods to codereview specific implementation.
+
+  def CloseIssue(self):
+    return self._codereview_impl.CloseIssue()
+
+  def GetStatus(self):
+    return self._codereview_impl.GetStatus()
+
+  def GetCodereviewServer(self):
+    return self._codereview_impl.GetCodereviewServer()
+
+  def GetApprovingReviewers(self):
+    return self._codereview_impl.GetApprovingReviewers()
+
+  def GetMostRecentPatchset(self):
+    return self._codereview_impl.GetMostRecentPatchset()
+
+  def __getattr__(self, attr):
+    # This is because lots of untested code accesses Rietveld-specific stuff
+    # directly, and it's hard to fix for sure. So, just let it work, and fix
+    # on a cases by case basis.
+    return getattr(self._codereview_impl, attr)
+
+
+class _ChangelistCodereviewBase(object):
+  """Abstract base class encapsulating codereview specifics of a changelist."""
+  def __init__(self, changelist):
+    self._changelist = changelist  # instance of Changelist
+
+  def __getattr__(self, attr):
+    # Forward methods to changelist.
+    # TODO(tandrii): maybe clean up _GerritChangelistImpl and
+    # _RietveldChangelistImpl to avoid this hack?
+    return getattr(self._changelist, attr)
+
+  def GetStatus(self):
+    """Apply a rough heuristic to give a simple summary of an issue's review
+    or CQ status, assuming adherence to a common workflow.
+
+    Returns None if no issue for this branch, or specific string keywords.
+    """
+    raise NotImplementedError()
+
+  def GetCodereviewServer(self):
+    """Returns server URL without end slash, like "https://codereview.com"."""
+    raise NotImplementedError()
+
+  def FetchDescription(self):
+    """Fetches and returns description from the codereview server."""
+    raise NotImplementedError()
+
+  def GetCodereviewServerSetting(self):
+    """Returns git config setting for the codereview server."""
+    raise NotImplementedError()
+
+  @classmethod
+  def IssueSetting(cls, branch):
+    return 'branch.%s.%s' % (branch, cls.IssueSettingSuffix())
+
+  @classmethod
+  def IssueSettingSuffix(cls):
+    """Returns name of git config setting which stores issue number for a given
+    branch."""
+    raise NotImplementedError()
+
+  def PatchsetSetting(self):
+    """Returns name of git config setting which stores issue number."""
+    raise NotImplementedError()
+
+  def GetRieveldObjForPresubmit(self):
+    # This is an unfortunate Rietveld-embeddedness in presubmit.
+    # For non-Rietveld codereviews, this probably should return a dummy object.
+    raise NotImplementedError()
+
+  def GetGerritObjForPresubmit(self):
+    # None is valid return value, otherwise presubmit_support.GerritAccessor.
+    return None
+
+  def UpdateDescriptionRemote(self, description):
+    """Update the description on codereview site."""
+    raise NotImplementedError()
+
+  def CloseIssue(self):
+    """Closes the issue."""
+    raise NotImplementedError()
+
+  def GetApprovingReviewers(self):
+    """Returns a list of reviewers approving the change.
+
+    Note: not necessarily committers.
+    """
+    raise NotImplementedError()
+
+  def GetMostRecentPatchset(self):
+    """Returns the most recent patchset number from the codereview site."""
+    raise NotImplementedError()
+
+  def CMDPatchWithParsedIssue(self, parsed_issue_arg, reject, nocommit,
+                              directory):
+    """Fetches and applies the issue.
+
+    Arguments:
+      parsed_issue_arg: instance of _ParsedIssueNumberArgument.
+      reject: if True, reject the failed patch instead of switching to 3-way
+        merge. Rietveld only.
+      nocommit: do not commit the patch, thus leave the tree dirty. Rietveld
+        only.
+      directory: switch to directory before applying the patch. Rietveld only.
+    """
+    raise NotImplementedError()
+
+  @staticmethod
+  def ParseIssueURL(parsed_url):
+    """Parses url and returns instance of _ParsedIssueNumberArgument or None if
+    failed."""
+    raise NotImplementedError()
+
+  def EnsureAuthenticated(self, force):
+    """Best effort check that user is authenticated with codereview server.
+
+    Arguments:
+      force: whether to skip confirmation questions.
+    """
+    raise NotImplementedError()
+
+  def CMDUploadChange(self, options, args, change):
+    """Uploads a change to codereview."""
+    raise NotImplementedError()
+
+  def SetCQState(self, new_state):
+    """Update the CQ state for latest patchset.
+
+    Issue must have been already uploaded and known.
+    """
+    raise NotImplementedError()
+
+
+class _RietveldChangelistImpl(_ChangelistCodereviewBase):
+  def __init__(self, changelist, auth_config=None, rietveld_server=None):
+    super(_RietveldChangelistImpl, self).__init__(changelist)
+    assert settings, 'must be initialized in _ChangelistCodereviewBase'
+    settings.GetDefaultServerUrl()
+
+    self._rietveld_server = rietveld_server
+    self._auth_config = auth_config
+    self._props = None
+    self._rpc_server = None
+
+  def GetCodereviewServer(self):
+    if not self._rietveld_server:
+      # If we're on a branch then get the server potentially associated
+      # with that branch.
+      if self.GetIssue():
+        rietveld_server_setting = self.GetCodereviewServerSetting()
+        if rietveld_server_setting:
+          self._rietveld_server = gclient_utils.UpgradeToHttps(RunGit(
+              ['config', rietveld_server_setting], error_ok=True).strip())
+      if not self._rietveld_server:
+        self._rietveld_server = settings.GetDefaultServerUrl()
+    return self._rietveld_server
+
+  def EnsureAuthenticated(self, force):
+    """Best effort check that user is authenticated with Rietveld server."""
+    if self._auth_config.use_oauth2:
+      authenticator = auth.get_authenticator_for_host(
+          self.GetCodereviewServer(), self._auth_config)
+      if not authenticator.has_cached_credentials():
+        raise auth.LoginRequiredError(self.GetCodereviewServer())
+
+  def FetchDescription(self):
+    issue = self.GetIssue()
+    assert issue
+    try:
+      return self.RpcServer().get_description(issue).strip()
+    except urllib2.HTTPError as e:
+      if e.code == 404:
+        DieWithError(
+            ('\nWhile fetching the description for issue %d, received a '
+             '404 (not found)\n'
+             'error. It is likely that you deleted this '
+             'issue on the server. If this is the\n'
+             'case, please run\n\n'
+             '    git cl issue 0\n\n'
+             'to clear the association with the deleted issue. Then run '
+             'this command again.') % issue)
+      else:
+        DieWithError(
+            '\nFailed to fetch issue description. HTTP error %d' % e.code)
+    except urllib2.URLError as e:
+      print >> sys.stderr, (
+          'Warning: Failed to retrieve CL description due to network '
+          'failure.')
+      return ''
+
+  def GetMostRecentPatchset(self):
+    return self.GetIssueProperties()['patchsets'][-1]
+
+  def GetPatchSetDiff(self, issue, patchset):
+    return self.RpcServer().get(
+        '/download/issue%s_%s.diff' % (issue, patchset))
+
+  def GetIssueProperties(self):
+    if self._props is None:
+      issue = self.GetIssue()
+      if not issue:
+        self._props = {}
+      else:
+        self._props = self.RpcServer().get_issue_properties(issue, True)
+    return self._props
+
+  def GetApprovingReviewers(self):
+    return get_approving_reviewers(self.GetIssueProperties())
+
+  def AddComment(self, message):
+    return self.RpcServer().add_comment(self.GetIssue(), message)
+
   def GetStatus(self):
     """Apply a rough heuristic to give a simple summary of an issue's review
     or CQ status, assuming adherence to a common workflow.
@@ -1046,7 +1669,7 @@ or verify this branch is set up to track another (via the --track argument to
     if props.get('closed'):
       # Issue is closed.
       return 'closed'
-    if props.get('commit'):
+    if props.get('commit') and not props.get('cq_dry_run', False):
       # Issue is in the commit queue.
       return 'commit'
 
@@ -1069,26 +1692,11 @@ or verify this branch is set up to track another (via the --track argument to
       return 'reply'
     return 'waiting'
 
-  def RunHook(self, committing, may_prompt, verbose, change):
-    """Calls sys.exit() if the hook fails; returns a HookResults otherwise."""
-
-    try:
-      return presubmit_support.DoPresubmitChecks(change, committing,
-          verbose=verbose, output_stream=sys.stdout, input_stream=sys.stdin,
-          default_presubmit=None, may_prompt=may_prompt,
-          rietveld_obj=self.RpcServer())
-    except presubmit_support.PresubmitFailure, e:
-      DieWithError(
-          ('%s\nMaybe your depot_tools is out of date?\n'
-           'If all fails, contact maruel@') % e)
-
-  def UpdateDescription(self, description):
-    self.description = description
+  def UpdateDescriptionRemote(self, description):
     return self.RpcServer().update_description(
         self.GetIssue(), self.description)
 
   def CloseIssue(self):
-    """Updates the description and closes the issue."""
     return self.RpcServer().close_issue(self.GetIssue())
 
   def SetFlag(self, flag, value):
@@ -1112,65 +1720,851 @@ or verify this branch is set up to track another (via the --track argument to
     """
     if not self._rpc_server:
       self._rpc_server = rietveld.CachingRietveld(
-          self.GetRietveldServer(),
+          self.GetCodereviewServer(),
           self._auth_config or auth.make_auth_config())
     return self._rpc_server
 
-  def _IssueSetting(self):
-    """Return the git setting that stores this change's issue."""
-    return 'branch.%s.rietveldissue' % self.GetBranch()
+  @classmethod
+  def IssueSettingSuffix(cls):
+    return 'rietveldissue'
 
-  def _PatchsetSetting(self):
+  def PatchsetSetting(self):
     """Return the git setting that stores this change's most recent patchset."""
     return 'branch.%s.rietveldpatchset' % self.GetBranch()
 
-  def _RietveldServer(self):
+  def GetCodereviewServerSetting(self):
     """Returns the git setting that stores this change's rietveld server."""
     branch = self.GetBranch()
     if branch:
       return 'branch.%s.rietveldserver' % branch
     return None
 
+  def GetRieveldObjForPresubmit(self):
+    return self.RpcServer()
 
-def GetCodereviewSettingsInteractively():
-  """Prompt the user for settings."""
-  # TODO(ukai): ask code review system is rietveld or gerrit?
-  server = settings.GetDefaultServerUrl(error_ok=True)
-  prompt = 'Rietveld server (host[:port])'
-  prompt += ' [%s]' % (server or DEFAULT_SERVER)
-  newserver = ask_for_data(prompt + ':')
-  if not server and not newserver:
-    newserver = DEFAULT_SERVER
-  if newserver:
-    newserver = gclient_utils.UpgradeToHttps(newserver)
-    if newserver != server:
-      RunGit(['config', 'rietveld.server', newserver])
+  def SetCQState(self, new_state):
+    props = self.GetIssueProperties()
+    if props.get('private'):
+      DieWithError('Cannot set-commit on private issue')
 
-  def SetProperty(initial, caption, name, is_url):
-    prompt = caption
-    if initial:
-      prompt += ' ("x" to clear) [%s]' % initial
-    new_val = ask_for_data(prompt + ':')
-    if new_val == 'x':
-      RunGit(['config', '--unset-all', 'rietveld.' + name], error_ok=True)
-    elif new_val:
-      if is_url:
-        new_val = gclient_utils.UpgradeToHttps(new_val)
-      if new_val != initial:
-        RunGit(['config', 'rietveld.' + name, new_val])
+    if new_state == _CQState.COMMIT:
+      self.SetFlag('commit', '1')
+    elif new_state == _CQState.NONE:
+      self.SetFlag('commit', '0')
+    else:
+      raise NotImplementedError()
+
+
+  def CMDPatchWithParsedIssue(self, parsed_issue_arg, reject, nocommit,
+                              directory):
+    # TODO(maruel): Use apply_issue.py
+
+    # PatchIssue should never be called with a dirty tree.  It is up to the
+    # caller to check this, but just in case we assert here since the
+    # consequences of the caller not checking this could be dire.
+    assert(not git_common.is_dirty_git_tree('apply'))
+    assert(parsed_issue_arg.valid)
+    self._changelist.issue = parsed_issue_arg.issue
+    if parsed_issue_arg.hostname:
+      self._rietveld_server = 'https://%s' % parsed_issue_arg.hostname
+
+    if (isinstance(parsed_issue_arg, _RietveldParsedIssueNumberArgument) and
+        parsed_issue_arg.patch_url):
+      assert parsed_issue_arg.patchset
+      patchset = parsed_issue_arg.patchset
+      patch_data = urllib2.urlopen(parsed_issue_arg.patch_url).read()
+    else:
+      patchset = parsed_issue_arg.patchset or self.GetMostRecentPatchset()
+      patch_data = self.GetPatchSetDiff(self.GetIssue(), patchset)
+
+    # Switch up to the top-level directory, if necessary, in preparation for
+    # applying the patch.
+    top = settings.GetRelativeRoot()
+    if top:
+      os.chdir(top)
+
+    # Git patches have a/ at the beginning of source paths.  We strip that out
+    # with a sed script rather than the -p flag to patch so we can feed either
+    # Git or svn-style patches into the same apply command.
+    # re.sub() should be used but flags=re.MULTILINE is only in python 2.7.
+    try:
+      patch_data = subprocess2.check_output(
+          ['sed', '-e', 's|^--- a/|--- |; s|^+++ b/|+++ |'], stdin=patch_data)
+    except subprocess2.CalledProcessError:
+      DieWithError('Git patch mungling failed.')
+    logging.info(patch_data)
+
+    # We use "git apply" to apply the patch instead of "patch" so that we can
+    # pick up file adds.
+    # The --index flag means: also insert into the index (so we catch adds).
+    cmd = ['git', 'apply', '--index', '-p0']
+    if directory:
+      cmd.extend(('--directory', directory))
+    if reject:
+      cmd.append('--reject')
+    elif IsGitVersionAtLeast('1.7.12'):
+      cmd.append('--3way')
+    try:
+      subprocess2.check_call(cmd, env=GetNoGitPagerEnv(),
+                             stdin=patch_data, stdout=subprocess2.VOID)
+    except subprocess2.CalledProcessError:
+      print 'Failed to apply the patch'
+      return 1
 
-  SetProperty(settings.GetDefaultCCList(), 'CC list', 'cc', False)
-  SetProperty(settings.GetDefaultPrivateFlag(),
-              'Private flag (rietveld only)', 'private', False)
-  SetProperty(settings.GetTreeStatusUrl(error_ok=True), 'Tree status URL',
-              'tree-status-url', False)
-  SetProperty(settings.GetViewVCUrl(), 'ViewVC URL', 'viewvc-url', True)
-  SetProperty(settings.GetBugPrefix(), 'Bug Prefix', 'bug-prefix', False)
-  SetProperty(settings.GetRunPostUploadHook(), 'Run Post Upload Hook',
-              'run-post-upload-hook', False)
+    # If we had an issue, commit the current state and register the issue.
+    if not nocommit:
+      RunGit(['commit', '-m', (self.GetDescription() + '\n\n' +
+                               'patch from issue %(i)s at patchset '
+                               '%(p)s (http://crrev.com/%(i)s#ps%(p)s)'
+                               % {'i': self.GetIssue(), 'p': patchset})])
+      self.SetIssue(self.GetIssue())
+      self.SetPatchset(patchset)
+      print "Committed patch locally."
+    else:
+      print "Patch applied to index."
+    return 0
+
+  @staticmethod
+  def ParseIssueURL(parsed_url):
+    if not parsed_url.scheme or not parsed_url.scheme.startswith('http'):
+      return None
+    # Typical url: https://domain/<issue_number>[/[other]]
+    match = re.match('/(\d+)(/.*)?$', parsed_url.path)
+    if match:
+      return _RietveldParsedIssueNumberArgument(
+          issue=int(match.group(1)),
+          hostname=parsed_url.netloc)
+    # Rietveld patch: https://domain/download/issue<number>_<patchset>.diff
+    match = re.match(r'/download/issue(\d+)_(\d+).diff$', parsed_url.path)
+    if match:
+      return _RietveldParsedIssueNumberArgument(
+          issue=int(match.group(1)),
+          patchset=int(match.group(2)),
+          hostname=parsed_url.netloc,
+          patch_url=gclient_utils.UpgradeToHttps(parsed_url.geturl()))
+    return None
+
+  def CMDUploadChange(self, options, args, change):
+    """Upload the patch to Rietveld."""
+    upload_args = ['--assume_yes']  # Don't ask about untracked files.
+    upload_args.extend(['--server', self.GetCodereviewServer()])
+    upload_args.extend(auth.auth_config_to_command_options(self._auth_config))
+    if options.emulate_svn_auto_props:
+      upload_args.append('--emulate_svn_auto_props')
+
+    change_desc = None
+
+    if options.email is not None:
+      upload_args.extend(['--email', options.email])
+
+    if self.GetIssue():
+      if options.title:
+        upload_args.extend(['--title', options.title])
+      if options.message:
+        upload_args.extend(['--message', options.message])
+      upload_args.extend(['--issue', str(self.GetIssue())])
+      print ('This branch is associated with issue %s. '
+             'Adding patch to that issue.' % self.GetIssue())
+    else:
+      if options.title:
+        upload_args.extend(['--title', options.title])
+      message = (options.title or options.message or
+                 CreateDescriptionFromLog(args))
+      change_desc = ChangeDescription(message)
+      if options.reviewers or options.tbr_owners:
+        change_desc.update_reviewers(options.reviewers,
+                                     options.tbr_owners,
+                                     change)
+      if not options.force:
+        change_desc.prompt()
+
+      if not change_desc.description:
+        print "Description is empty; aborting."
+        return 1
+
+      upload_args.extend(['--message', change_desc.description])
+      if change_desc.get_reviewers():
+        upload_args.append('--reviewers=%s' % ','.join(
+            change_desc.get_reviewers()))
+      if options.send_mail:
+        if not change_desc.get_reviewers():
+          DieWithError("Must specify reviewers to send email.")
+        upload_args.append('--send_mail')
+
+      # We check this before applying rietveld.private assuming that in
+      # rietveld.cc only addresses which we can send private CLs to are listed
+      # if rietveld.private is set, and so we should ignore rietveld.cc only
+      # when --private is specified explicitly on the command line.
+      if options.private:
+        logging.warn('rietveld.cc is ignored since private flag is specified.  '
+                     'You need to review and add them manually if necessary.')
+        cc = self.GetCCListWithoutDefault()
+      else:
+        cc = self.GetCCList()
+      cc = ','.join(filter(None, (cc, ','.join(options.cc))))
+      if cc:
+        upload_args.extend(['--cc', cc])
+
+    if options.private or settings.GetDefaultPrivateFlag() == "True":
+      upload_args.append('--private')
+
+    upload_args.extend(['--git_similarity', str(options.similarity)])
+    if not options.find_copies:
+      upload_args.extend(['--git_no_find_copies'])
+
+    # Include the upstream repo's URL in the change -- this is useful for
+    # projects that have their source spread across multiple repos.
+    remote_url = self.GetGitBaseUrlFromConfig()
+    if not remote_url:
+      if settings.GetIsGitSvn():
+        remote_url = self.GetGitSvnRemoteUrl()
+      else:
+        if self.GetRemoteUrl() and '/' in self.GetUpstreamBranch():
+          remote_url = '%s@%s' % (self.GetRemoteUrl(),
+                                  self.GetUpstreamBranch().split('/')[-1])
+    if remote_url:
+      upload_args.extend(['--base_url', remote_url])
+      remote, remote_branch = self.GetRemoteBranch()
+      target_ref = GetTargetRef(remote, remote_branch, options.target_branch,
+                                settings.GetPendingRefPrefix())
+      if target_ref:
+        upload_args.extend(['--target_ref', target_ref])
+
+      # Look for dependent patchsets. See crbug.com/480453 for more details.
+      remote, upstream_branch = self.FetchUpstreamTuple(self.GetBranch())
+      upstream_branch = ShortBranchName(upstream_branch)
+      if remote is '.':
+        # A local branch is being tracked.
+        local_branch = ShortBranchName(upstream_branch)
+        if settings.GetIsSkipDependencyUpload(local_branch):
+          print
+          print ('Skipping dependency patchset upload because git config '
+                 'branch.%s.skip-deps-uploads is set to True.' % local_branch)
+          print
+        else:
+          auth_config = auth.extract_auth_config_from_options(options)
+          branch_cl = Changelist(branchref=local_branch,
+                                 auth_config=auth_config)
+          branch_cl_issue_url = branch_cl.GetIssueURL()
+          branch_cl_issue = branch_cl.GetIssue()
+          branch_cl_patchset = branch_cl.GetPatchset()
+          if branch_cl_issue_url and branch_cl_issue and branch_cl_patchset:
+            upload_args.extend(
+                ['--depends_on_patchset', '%s:%s' % (
+                     branch_cl_issue, branch_cl_patchset)])
+            print(
+                '\n'
+                'The current branch (%s) is tracking a local branch (%s) with '
+                'an associated CL.\n'
+                'Adding %s/#ps%s as a dependency patchset.\n'
+                '\n' % (self.GetBranch(), local_branch, branch_cl_issue_url,
+                        branch_cl_patchset))
+
+    project = settings.GetProject()
+    if project:
+      upload_args.extend(['--project', project])
+
+    if options.cq_dry_run:
+      upload_args.extend(['--cq_dry_run'])
+
+    try:
+      upload_args = ['upload'] + upload_args + args
+      logging.info('upload.RealMain(%s)', upload_args)
+      issue, patchset = upload.RealMain(upload_args)
+      issue = int(issue)
+      patchset = int(patchset)
+    except KeyboardInterrupt:
+      sys.exit(1)
+    except:
+      # If we got an exception after the user typed a description for their
+      # change, back up the description before re-raising.
+      if change_desc:
+        backup_path = os.path.expanduser(DESCRIPTION_BACKUP_FILE)
+        print('\nGot exception while uploading -- saving description to %s\n' %
+              backup_path)
+        backup_file = open(backup_path, 'w')
+        backup_file.write(change_desc.description)
+        backup_file.close()
+      raise
+
+    if not self.GetIssue():
+      self.SetIssue(issue)
+    self.SetPatchset(patchset)
+
+    if options.use_commit_queue:
+      self.SetCQState(_CQState.COMMIT)
+    return 0
+
+
+class _GerritChangelistImpl(_ChangelistCodereviewBase):
+  def __init__(self, changelist, auth_config=None):
+    # auth_config is Rietveld thing, kept here to preserve interface only.
+    super(_GerritChangelistImpl, self).__init__(changelist)
+    self._change_id = None
+    # Lazily cached values.
+    self._gerrit_server = None  # e.g. https://chromium-review.googlesource.com
+    self._gerrit_host = None    # e.g. chromium-review.googlesource.com
+
+  def _GetGerritHost(self):
+    # Lazy load of configs.
+    self.GetCodereviewServer()
+    return self._gerrit_host
+
+  def _GetGitHost(self):
+    """Returns git host to be used when uploading change to Gerrit."""
+    return urlparse.urlparse(self.GetRemoteUrl()).netloc
+
+  def GetCodereviewServer(self):
+    if not self._gerrit_server:
+      # If we're on a branch then get the server potentially associated
+      # with that branch.
+      if self.GetIssue():
+        gerrit_server_setting = self.GetCodereviewServerSetting()
+        if gerrit_server_setting:
+          self._gerrit_server = RunGit(['config', gerrit_server_setting],
+                                       error_ok=True).strip()
+          if self._gerrit_server:
+            self._gerrit_host = urlparse.urlparse(self._gerrit_server).netloc
+      if not self._gerrit_server:
+        # We assume repo to be hosted on Gerrit, and hence Gerrit server
+        # has "-review" suffix for lowest level subdomain.
+        parts = self._GetGitHost().split('.')
+        parts[0] = parts[0] + '-review'
+        self._gerrit_host = '.'.join(parts)
+        self._gerrit_server = 'https://%s' % self._gerrit_host
+    return self._gerrit_server
+
+  @classmethod
+  def IssueSettingSuffix(cls):
+    return 'gerritissue'
+
+  def EnsureAuthenticated(self, force):
+    """Best effort check that user is authenticated with Gerrit server."""
+    if settings.GetGerritSkipEnsureAuthenticated():
+      # For projects with unusual authentication schemes.
+      # See http://crbug.com/603378.
+      return
+    # Lazy-loader to identify Gerrit and Git hosts.
+    if gerrit_util.GceAuthenticator.is_gce():
+      return
+    self.GetCodereviewServer()
+    git_host = self._GetGitHost()
+    assert self._gerrit_server and self._gerrit_host
+    cookie_auth = gerrit_util.CookiesAuthenticator()
+
+    gerrit_auth = cookie_auth.get_auth_header(self._gerrit_host)
+    git_auth = cookie_auth.get_auth_header(git_host)
+    if gerrit_auth and git_auth:
+      if gerrit_auth == git_auth:
+        return
+      print((
+          'WARNING: you have different credentials for Gerrit and git hosts.\n'
+          '         Check your %s or %s file for credentials of hosts:\n'
+          '           %s\n'
+          '           %s\n'
+          '         %s') %
+          (cookie_auth.get_gitcookies_path(), cookie_auth.get_netrc_path(),
+           git_host, self._gerrit_host,
+           cookie_auth.get_new_password_message(git_host)))
+      if not force:
+        ask_for_data('If you know what you are doing, press Enter to continue, '
+                     'Ctrl+C to abort.')
+      return
+    else:
+      missing = (
+          [] if gerrit_auth else [self._gerrit_host] +
+          [] if git_auth else [git_host])
+      DieWithError('Credentials for the following hosts are required:\n'
+                   '  %s\n'
+                   'These are read from %s (or legacy %s)\n'
+                   '%s' % (
+                     '\n  '.join(missing),
+                     cookie_auth.get_gitcookies_path(),
+                     cookie_auth.get_netrc_path(),
+                     cookie_auth.get_new_password_message(git_host)))
+
+
+  def PatchsetSetting(self):
+    """Return the git setting that stores this change's most recent patchset."""
+    return 'branch.%s.gerritpatchset' % self.GetBranch()
+
+  def GetCodereviewServerSetting(self):
+    """Returns the git setting that stores this change's Gerrit server."""
+    branch = self.GetBranch()
+    if branch:
+      return 'branch.%s.gerritserver' % branch
+    return None
+
+  def GetRieveldObjForPresubmit(self):
+    class ThisIsNotRietveldIssue(object):
+      def __nonzero__(self):
+        # This is a hack to make presubmit_support think that rietveld is not
+        # defined, yet still ensure that calls directly result in a decent
+        # exception message below.
+        return False
+
+      def __getattr__(self, attr):
+        print(
+            'You aren\'t using Rietveld at the moment, but Gerrit.\n'
+            'Using Rietveld in your PRESUBMIT scripts won\'t work.\n'
+            'Please, either change your PRESUBIT to not use rietveld_obj.%s,\n'
+            'or use Rietveld for codereview.\n'
+            'See also http://crbug.com/579160.' % attr)
+        raise NotImplementedError()
+    return ThisIsNotRietveldIssue()
+
+  def GetGerritObjForPresubmit(self):
+    return presubmit_support.GerritAccessor(self._GetGerritHost())
+
+  def GetStatus(self):
+    """Apply a rough heuristic to give a simple summary of an issue's review
+    or CQ status, assuming adherence to a common workflow.
+
+    Returns None if no issue for this branch, or one of the following keywords:
+      * 'error'    - error from review tool (including deleted issues)
+      * 'unsent'   - no reviewers added
+      * 'waiting'  - waiting for review
+      * 'reply'    - waiting for owner to reply to review
+      * 'not lgtm' - Code-Review -2 from at least one approved reviewer
+      * 'lgtm'     - Code-Review +2 from at least one approved reviewer
+      * 'commit'   - in the commit queue
+      * 'closed'   - abandoned
+    """
+    if not self.GetIssue():
+      return None
+
+    try:
+      data = self._GetChangeDetail(['DETAILED_LABELS', 'CURRENT_REVISION'])
+    except httplib.HTTPException:
+      return 'error'
+
+    if data['status'] == 'ABANDONED':
+      return 'closed'
+
+    cq_label = data['labels'].get('Commit-Queue', {})
+    if cq_label:
+      # Vote value is a stringified integer, which we expect from 0 to 2.
+      vote_value = cq_label.get('value', '0')
+      vote_text = cq_label.get('values', {}).get(vote_value, '')
+      if vote_text.lower() == 'commit':
+        return 'commit'
+
+    lgtm_label = data['labels'].get('Code-Review', {})
+    if lgtm_label:
+      if 'rejected' in lgtm_label:
+        return 'not lgtm'
+      if 'approved' in lgtm_label:
+        return 'lgtm'
+
+    if not data.get('reviewers', {}).get('REVIEWER', []):
+      return 'unsent'
+
+    messages = data.get('messages', [])
+    if messages:
+      owner = data['owner'].get('_account_id')
+      last_message_author = messages[-1].get('author', {}).get('_account_id')
+      if owner != last_message_author:
+        # Some reply from non-owner.
+        return 'reply'
+
+    return 'waiting'
+
+  def GetMostRecentPatchset(self):
+    data = self._GetChangeDetail(['CURRENT_REVISION'])
+    return data['revisions'][data['current_revision']]['_number']
+
+  def FetchDescription(self):
+    data = self._GetChangeDetail(['CURRENT_REVISION'])
+    current_rev = data['current_revision']
+    url = data['revisions'][current_rev]['fetch']['http']['url']
+    return gerrit_util.GetChangeDescriptionFromGitiles(url, current_rev)
+
+  def UpdateDescriptionRemote(self, description):
+    gerrit_util.SetCommitMessage(self._GetGerritHost(), self.GetIssue(),
+                                 description)
+
+  def CloseIssue(self):
+    gerrit_util.AbandonChange(self._GetGerritHost(), self.GetIssue(), msg='')
+
+  def GetApprovingReviewers(self):
+    """Returns a list of reviewers approving the change.
+
+    Note: not necessarily committers.
+    """
+    raise NotImplementedError()
+
+  def SubmitIssue(self, wait_for_merge=True):
+    gerrit_util.SubmitChange(self._GetGerritHost(), self.GetIssue(),
+                             wait_for_merge=wait_for_merge)
+
+  def _GetChangeDetail(self, options=None, issue=None):
+    options = options or []
+    issue = issue or self.GetIssue()
+    assert issue, 'issue required to query Gerrit'
+    return gerrit_util.GetChangeDetail(self._GetGerritHost(), str(issue),
+                                       options)
+
+  def CMDLand(self, force, bypass_hooks, verbose):
+    if git_common.is_dirty_git_tree('land'):
+      return 1
+    differs = True
+    last_upload = RunGit(['config',
+                          'branch.%s.gerritsquashhash' % self.GetBranch()],
+                         error_ok=True).strip()
+    # Note: git diff outputs nothing if there is no diff.
+    if not last_upload or RunGit(['diff', last_upload]).strip():
+      print('WARNING: some changes from local branch haven\'t been uploaded')
+    else:
+      detail = self._GetChangeDetail(['CURRENT_REVISION'])
+      if detail['current_revision'] == last_upload:
+        differs = False
+      else:
+        print('WARNING: local branch contents differ from latest uploaded '
+              'patchset')
+    if differs:
+      if not force:
+        ask_for_data(
+            'Do you want to submit latest Gerrit patchset and bypass hooks?')
+      print('WARNING: bypassing hooks and submitting latest uploaded patchset')
+    elif not bypass_hooks:
+      hook_results = self.RunHook(
+          committing=True,
+          may_prompt=not force,
+          verbose=verbose,
+          change=self.GetChange(self.GetCommonAncestorWithUpstream(), None))
+      if not hook_results.should_continue():
+        return 1
+
+    self.SubmitIssue(wait_for_merge=True)
+    print('Issue %s has been submitted.' % self.GetIssueURL())
+    return 0
+
+  def CMDPatchWithParsedIssue(self, parsed_issue_arg, reject, nocommit,
+                              directory):
+    assert not reject
+    assert not nocommit
+    assert not directory
+    assert parsed_issue_arg.valid
+
+    self._changelist.issue = parsed_issue_arg.issue
+
+    if parsed_issue_arg.hostname:
+      self._gerrit_host = parsed_issue_arg.hostname
+      self._gerrit_server = 'https://%s' % self._gerrit_host
+
+    detail = self._GetChangeDetail(['ALL_REVISIONS'])
+
+    if not parsed_issue_arg.patchset:
+      # Use current revision by default.
+      revision_info = detail['revisions'][detail['current_revision']]
+      patchset = int(revision_info['_number'])
+    else:
+      patchset = parsed_issue_arg.patchset
+      for revision_info in detail['revisions'].itervalues():
+        if int(revision_info['_number']) == parsed_issue_arg.patchset:
+          break
+      else:
+        DieWithError('Couldn\'t find patchset %i in issue %i' %
+                     (parsed_issue_arg.patchset, self.GetIssue()))
+
+    fetch_info = revision_info['fetch']['http']
+    RunGit(['fetch', fetch_info['url'], fetch_info['ref']])
+    RunGit(['cherry-pick', 'FETCH_HEAD'])
+    self.SetIssue(self.GetIssue())
+    self.SetPatchset(patchset)
+    print('Committed patch for issue %i pathset %i locally' %
+          (self.GetIssue(), self.GetPatchset()))
+    return 0
+
+  @staticmethod
+  def ParseIssueURL(parsed_url):
+    if not parsed_url.scheme or not parsed_url.scheme.startswith('http'):
+      return None
+    # Gerrit's new UI is https://domain/c/<issue_number>[/[patchset]]
+    # But current GWT UI is https://domain/#/c/<issue_number>[/[patchset]]
+    # Short urls like https://domain/<issue_number> can be used, but don't allow
+    # specifying the patchset (you'd 404), but we allow that here.
+    if parsed_url.path == '/':
+      part = parsed_url.fragment
+    else:
+      part = parsed_url.path
+    match = re.match('(/c)?/(\d+)(/(\d+)?/?)?$', part)
+    if match:
+      return _ParsedIssueNumberArgument(
+          issue=int(match.group(2)),
+          patchset=int(match.group(4)) if match.group(4) else None,
+          hostname=parsed_url.netloc)
+    return None
+
+  def CMDUploadChange(self, options, args, change):
+    """Upload the current branch to Gerrit."""
+    if options.squash and options.no_squash:
+      DieWithError('Can only use one of --squash or --no-squash')
+    options.squash = ((settings.GetSquashGerritUploads() or options.squash) and
+                      not options.no_squash)
+    # We assume the remote called "origin" is the one we want.
+    # It is probably not worthwhile to support different workflows.
+    gerrit_remote = 'origin'
+
+    remote, remote_branch = self.GetRemoteBranch()
+    branch = GetTargetRef(remote, remote_branch, options.target_branch,
+                          pending_prefix='')
+
+    if options.squash:
+      if not self.GetIssue():
+        # TODO(tandrii): deperecate this after 2016Q2.  Backwards compatibility
+        # with shadow branch, which used to contain change-id for a given
+        # branch, using which we can fetch actual issue number and set it as the
+        # property of the branch, which is the new way.
+        message = RunGitSilent([
+            'show', '--format=%B', '-s',
+            'refs/heads/git_cl_uploads/%s' % self.GetBranch()])
+        if message:
+          change_ids = git_footers.get_footer_change_id(message.strip())
+          if change_ids and len(change_ids) == 1:
+            details = self._GetChangeDetail(issue=change_ids[0])
+            if details:
+              print('WARNING: found old upload in branch git_cl_uploads/%s '
+                    'corresponding to issue %s' %
+                    (self.GetBranch(), details['_number']))
+              self.SetIssue(details['_number'])
+          if not self.GetIssue():
+            DieWithError(
+                '\n'  # For readability of the blob below.
+                'Found old upload in branch git_cl_uploads/%s, '
+                'but failed to find corresponding Gerrit issue.\n'
+                'If you know the issue number, set it manually first:\n'
+                '    git cl issue 123456\n'
+                'If you intended to upload this CL as new issue, '
+                'just delete or rename the old upload branch:\n'
+                '    git rename-branch git_cl_uploads/%s old_upload-%s\n'
+                'After that, please run git cl upload again.' %
+                tuple([self.GetBranch()] * 3))
+        # End of backwards compatability.
+
+      if self.GetIssue():
+        # Try to get the message from a previous upload.
+        message = self.GetDescription()
+        if not message:
+          DieWithError(
+              'failed to fetch description from current Gerrit issue %d\n'
+              '%s' % (self.GetIssue(), self.GetIssueURL()))
+        change_id = self._GetChangeDetail()['change_id']
+        while True:
+          footer_change_ids = git_footers.get_footer_change_id(message)
+          if footer_change_ids == [change_id]:
+            break
+          if not footer_change_ids:
+            message = git_footers.add_footer_change_id(message, change_id)
+            print('WARNING: appended missing Change-Id to issue description')
+            continue
+          # There is already a valid footer but with different or several ids.
+          # Doing this automatically is non-trivial as we don't want to lose
+          # existing other footers, yet we want to append just 1 desired
+          # Change-Id. Thus, just create a new footer, but let user verify the
+          # new description.
+          message = '%s\n\nChange-Id: %s' % (message, change_id)
+          print(
+              'WARNING: issue %s has Change-Id footer(s):\n'
+              '  %s\n'
+              'but issue has Change-Id %s, according to Gerrit.\n'
+              'Please, check the proposed correction to the description, '
+              'and edit it if necessary but keep the "Change-Id: %s" footer\n'
+              % (self.GetIssue(), '\n  '.join(footer_change_ids), change_id,
+                 change_id))
+          ask_for_data('Press enter to edit now, Ctrl+C to abort')
+          if not options.force:
+            change_desc = ChangeDescription(message)
+            change_desc.prompt()
+            message = change_desc.description
+            if not message:
+              DieWithError("Description is empty. Aborting...")
+          # Continue the while loop.
+        # Sanity check of this code - we should end up with proper message
+        # footer.
+        assert [change_id] == git_footers.get_footer_change_id(message)
+        change_desc = ChangeDescription(message)
+      else:
+        change_desc = ChangeDescription(
+            options.message or CreateDescriptionFromLog(args))
+        if not options.force:
+          change_desc.prompt()
+        if not change_desc.description:
+          DieWithError("Description is empty. Aborting...")
+        message = change_desc.description
+        change_ids = git_footers.get_footer_change_id(message)
+        if len(change_ids) > 1:
+          DieWithError('too many Change-Id footers, at most 1 allowed.')
+        if not change_ids:
+          # Generate the Change-Id automatically.
+          message = git_footers.add_footer_change_id(
+              message, GenerateGerritChangeId(message))
+          change_desc.set_description(message)
+          change_ids = git_footers.get_footer_change_id(message)
+          assert len(change_ids) == 1
+        change_id = change_ids[0]
+
+      remote, upstream_branch = self.FetchUpstreamTuple(self.GetBranch())
+      if remote is '.':
+        # If our upstream branch is local, we base our squashed commit on its
+        # squashed version.
+        upstream_branch_name = scm.GIT.ShortBranchName(upstream_branch)
+        # Check the squashed hash of the parent.
+        parent = RunGit(['config',
+                         'branch.%s.gerritsquashhash' % upstream_branch_name],
+                        error_ok=True).strip()
+        # Verify that the upstream branch has been uploaded too, otherwise
+        # Gerrit will create additional CLs when uploading.
+        if not parent or (RunGitSilent(['rev-parse', upstream_branch + ':']) !=
+                          RunGitSilent(['rev-parse', parent + ':'])):
+          # TODO(tandrii): remove "old depot_tools" part on April 12, 2016.
+          DieWithError(
+              'Upload upstream branch %s first.\n'
+              'Note: maybe you\'ve uploaded it with --no-squash or with an old '
+              'version of depot_tools. If so, then re-upload it with:\n'
+              '    git cl upload --squash\n' % upstream_branch_name)
+      else:
+        parent = self.GetCommonAncestorWithUpstream()
+
+      tree = RunGit(['rev-parse', 'HEAD:']).strip()
+      ref_to_push = RunGit(['commit-tree', tree, '-p', parent,
+                            '-m', message]).strip()
+    else:
+      change_desc = ChangeDescription(
+          options.message or CreateDescriptionFromLog(args))
+      if not change_desc.description:
+        DieWithError("Description is empty. Aborting...")
+
+      if not git_footers.get_footer_change_id(change_desc.description):
+        DownloadGerritHook(False)
+        change_desc.set_description(self._AddChangeIdToCommitMessage(options,
+                                                                     args))
+      ref_to_push = 'HEAD'
+      parent = '%s/%s' % (gerrit_remote, branch)
+      change_id = git_footers.get_footer_change_id(change_desc.description)[0]
+
+    assert change_desc
+    commits = RunGitSilent(['rev-list', '%s..%s' % (parent,
+                                                    ref_to_push)]).splitlines()
+    if len(commits) > 1:
+      print('WARNING: This will upload %d commits. Run the following command '
+            'to see which commits will be uploaded: ' % len(commits))
+      print('git log %s..%s' % (parent, ref_to_push))
+      print('You can also use `git squash-branch` to squash these into a '
+            'single commit.')
+      ask_for_data('About to upload; enter to confirm.')
+
+    if options.reviewers or options.tbr_owners:
+      change_desc.update_reviewers(options.reviewers, options.tbr_owners,
+                                   change)
+
+    # Extra options that can be specified at push time. Doc:
+    # https://gerrit-review.googlesource.com/Documentation/user-upload.html
+    refspec_opts = []
+    if options.title:
+      # Per doc, spaces must be converted to underscores, and Gerrit will do the
+      # reverse on its side.
+      if '_' in options.title:
+        print('WARNING: underscores in title will be converted to spaces.')
+      refspec_opts.append('m=' + options.title.replace(' ', '_'))
+
+    cc = self.GetCCList().split(',')
+    if options.cc:
+      cc.extend(options.cc)
+    cc = filter(None, cc)
+    if cc:
+      # refspec_opts.extend('cc=' + email.strip() for email in cc)
+      # TODO(tandrii): enable this back. http://crbug.com/604377
+      print('WARNING: Gerrit doesn\'t yet support cc-ing arbitrary emails.\n'
+            '         Ignoring cc-ed emails. See http://crbug.com/604377.')
+
+    if change_desc.get_reviewers():
+      refspec_opts.extend('r=' + email.strip()
+                          for email in change_desc.get_reviewers())
+
+
+    refspec_suffix = ''
+    if refspec_opts:
+      refspec_suffix = '%' + ','.join(refspec_opts)
+      assert ' ' not in refspec_suffix, (
+          'spaces not allowed in refspec: "%s"' % refspec_suffix)
+    refspec = '%s:refs/for/%s%s' % (ref_to_push, branch, refspec_suffix)
+
+    push_stdout = gclient_utils.CheckCallAndFilter(
+        ['git', 'push', gerrit_remote, refspec],
+        print_stdout=True,
+        # Flush after every line: useful for seeing progress when running as
+        # recipe.
+        filter_fn=lambda _: sys.stdout.flush())
+
+    if options.squash:
+      regex = re.compile(r'remote:\s+https?://[\w\-\.\/]*/(\d+)\s.*')
+      change_numbers = [m.group(1)
+                        for m in map(regex.match, push_stdout.splitlines())
+                        if m]
+      if len(change_numbers) != 1:
+        DieWithError(
+          ('Created|Updated %d issues on Gerrit, but only 1 expected.\n'
+           'Change-Id: %s') % (len(change_numbers), change_id))
+      self.SetIssue(change_numbers[0])
+      RunGit(['config', 'branch.%s.gerritsquashhash' % self.GetBranch(),
+              ref_to_push])
+    return 0
+
+  def _AddChangeIdToCommitMessage(self, options, args):
+    """Re-commits using the current message, assumes the commit hook is in
+    place.
+    """
+    log_desc = options.message or CreateDescriptionFromLog(args)
+    git_command = ['commit', '--amend', '-m', log_desc]
+    RunGit(git_command)
+    new_log_desc = CreateDescriptionFromLog(args)
+    if git_footers.get_footer_change_id(new_log_desc):
+      print 'git-cl: Added Change-Id to commit message.'
+      return new_log_desc
+    else:
+      print >> sys.stderr, 'ERROR: Gerrit commit-msg hook not available.'
+
+  def SetCQState(self, new_state):
+    """Sets the Commit-Queue label assuming canonical CQ config for Gerrit."""
+    # TODO(tandrii): maybe allow configurability in codereview.settings or by
+    # self-discovery of label config for this CL using REST API.
+    vote_map = {
+        _CQState.NONE:    0,
+        _CQState.DRY_RUN: 1,
+        _CQState.COMMIT : 2,
+    }
+    gerrit_util.SetReview(self._GetGerritHost(), self.GetIssue(),
+                          labels={'Commit-Queue': vote_map[new_state]})
+
+
+_CODEREVIEW_IMPLEMENTATIONS = {
+  'rietveld': _RietveldChangelistImpl,
+  'gerrit': _GerritChangelistImpl,
+}
+
+
+def _add_codereview_select_options(parser):
+  """Appends --gerrit and --rietveld options to force specific codereview."""
+  parser.codereview_group = optparse.OptionGroup(
+      parser, 'EXPERIMENTAL! Codereview override options')
+  parser.add_option_group(parser.codereview_group)
+  parser.codereview_group.add_option(
+      '--gerrit', action='store_true',
+      help='Force the use of Gerrit for codereview')
+  parser.codereview_group.add_option(
+      '--rietveld', action='store_true',
+      help='Force the use of Rietveld for codereview')
 
-  # TODO: configure a default branch to diff against, rather than this
-  # svn-based hackery.
+
+def _process_codereview_select_options(parser, options):
+  if options.gerrit and options.rietveld:
+    parser.error('Options --gerrit and --rietveld are mutually exclusive')
+  options.forced_codereview = None
+  if options.gerrit:
+    options.forced_codereview = 'gerrit'
+  elif options.rietveld:
+    options.forced_codereview = 'rietveld'
 
 
 class ChangeDescription(object):
@@ -1356,6 +2750,14 @@ def LoadCodereviewSettingsFromFile(fileobj):
   if 'GERRIT_HOST' in keyvals:
     RunGit(['config', 'gerrit.host', keyvals['GERRIT_HOST']])
 
+  if 'GERRIT_SQUASH_UPLOADS' in keyvals:
+    RunGit(['config', 'gerrit.squash-uploads',
+            keyvals['GERRIT_SQUASH_UPLOADS']])
+
+  if 'GERRIT_SKIP_ENSURE_AUTHENTICATED' in keyvals:
+    RunGit(['config', 'gerrit.skip-ensure-authenticated',
+            keyvals['GERRIT_SKIP_ENSURE_AUTHENTICATED']])
+
   if 'PUSH_URL_CONFIG' in keyvals and 'ORIGIN_URL_CONFIG' in keyvals:
     #should be of the form
     #PUSH_URL_CONFIG: url.ssh://gitrw.chromium.org.pushinsteadof
@@ -1377,8 +2779,13 @@ def hasSheBang(fname):
     return f.read(2).startswith('#!')
 
 
-def DownloadHooks(force):
-  """downloads hooks
+# TODO(bpastene) Remove once a cleaner fix to crbug.com/600473 presents itself.
+def DownloadHooks(*args, **kwargs):
+  pass
+
+
+def DownloadGerritHook(force):
+  """Download and install Gerrit commit-msg hook.
 
   Args:
     force: True to update hooks. False to install hooks if not present.
@@ -1392,6 +2799,10 @@ def DownloadHooks(force):
       if not force:
         return
     try:
+      print(
+          'WARNING: installing Gerrit commit-msg hook.\n'
+          '         This behavior of git cl will soon be disabled.\n'
+          '         See bug http://crbug.com/579176.')
       urlretrieve(src, dst)
       if not hasSheBang(dst):
         DieWithError('Not a script: %s\n'
@@ -1408,10 +2819,50 @@ def DownloadHooks(force):
                    'chmod +x .git/hooks/commit-msg' % src)
 
 
+
+def GetRietveldCodereviewSettingsInteractively():
+  """Prompt the user for settings."""
+  server = settings.GetDefaultServerUrl(error_ok=True)
+  prompt = 'Rietveld server (host[:port])'
+  prompt += ' [%s]' % (server or DEFAULT_SERVER)
+  newserver = ask_for_data(prompt + ':')
+  if not server and not newserver:
+    newserver = DEFAULT_SERVER
+  if newserver:
+    newserver = gclient_utils.UpgradeToHttps(newserver)
+    if newserver != server:
+      RunGit(['config', 'rietveld.server', newserver])
+
+  def SetProperty(initial, caption, name, is_url):
+    prompt = caption
+    if initial:
+      prompt += ' ("x" to clear) [%s]' % initial
+    new_val = ask_for_data(prompt + ':')
+    if new_val == 'x':
+      RunGit(['config', '--unset-all', 'rietveld.' + name], error_ok=True)
+    elif new_val:
+      if is_url:
+        new_val = gclient_utils.UpgradeToHttps(new_val)
+      if new_val != initial:
+        RunGit(['config', 'rietveld.' + name, new_val])
+
+  SetProperty(settings.GetDefaultCCList(), 'CC list', 'cc', False)
+  SetProperty(settings.GetDefaultPrivateFlag(),
+              'Private flag (rietveld only)', 'private', False)
+  SetProperty(settings.GetTreeStatusUrl(error_ok=True), 'Tree status URL',
+              'tree-status-url', False)
+  SetProperty(settings.GetViewVCUrl(), 'ViewVC URL', 'viewvc-url', True)
+  SetProperty(settings.GetBugPrefix(), 'Bug Prefix', 'bug-prefix', False)
+  SetProperty(settings.GetRunPostUploadHook(), 'Run Post Upload Hook',
+              'run-post-upload-hook', False)
+
 @subcommand.usage('[repo root containing codereview.settings]')
 def CMDconfig(parser, args):
   """Edits configuration for this tree."""
 
+  print('WARNING: git cl config works for Rietveld only.\n'
+        'For Gerrit, see http://crbug.com/603116.')
+  # TODO(tandrii): add Gerrit support as part of http://crbug.com/603116.
   parser.add_option('--activate-update', action='store_true',
                     help='activate auto-updating [rietveld] section in '
                          '.git/config')
@@ -1429,8 +2880,7 @@ def CMDconfig(parser, args):
     return
 
   if len(args) == 0:
-    GetCodereviewSettingsInteractively()
-    DownloadHooks(True)
+    GetRietveldCodereviewSettingsInteractively()
     return 0
 
   url = args[0]
@@ -1439,7 +2889,6 @@ def CMDconfig(parser, args):
 
   # Load code review settings and download hooks (if available).
   LoadCodereviewSettingsFromFile(urllib2.urlopen(url))
-  DownloadHooks(True)
   return 0
 
 
@@ -1484,7 +2933,7 @@ def fetch_cl_status(branch, auth_config=None):
 
 def get_cl_statuses(
     branches, fine_grained, max_processes=None, auth_config=None):
-  """Returns a blocking iterable of (branch, issue, color) for given branches.
+  """Returns a blocking iterable of (branch, issue, status) for given branches.
 
   If fine_grained is true, this will fetch CL statuses from the server.
   Otherwise, simply indicate if there's a matching url for the given branches.
@@ -1492,7 +2941,15 @@ def get_cl_statuses(
   If max_processes is specified, it is used as the maximum number of processes
   to spawn to fetch CL status from the server. Otherwise 1 process per branch is
   spawned.
+
+  See GetStatus() for a list of possible statuses.
   """
+  def fetch(branch):
+    if not branch:
+      return None
+
+    return fetch_cl_status(branch, auth_config=auth_config)
+
   # Silence upload.py otherwise it becomes unwieldly.
   upload.verbosity = 0
 
@@ -1500,7 +2957,7 @@ def get_cl_statuses(
     # Process one branch synchronously to work through authentication, then
     # spawn processes to process all the other branches in parallel.
     if branches:
-      fetch = lambda branch: fetch_cl_status(branch, auth_config=auth_config)
+
       yield fetch(branches[0])
 
       branches_to_fetch = branches[1:]
@@ -1508,13 +2965,28 @@ def get_cl_statuses(
           min(max_processes, len(branches_to_fetch))
               if max_processes is not None
               else len(branches_to_fetch))
-      for x in pool.imap_unordered(fetch, branches_to_fetch):
-        yield x
+
+      fetched_branches = set()
+      it = pool.imap_unordered(fetch, branches_to_fetch).__iter__()
+      while True:
+        try:
+          row = it.next(timeout=5)
+        except multiprocessing.TimeoutError:
+          break
+
+        fetched_branches.add(row[0])
+        yield row
+
+      # Add any branches that failed to fetch.
+      for b in set(branches_to_fetch) - fetched_branches:
+        cl = Changelist(branchref=b, auth_config=auth_config)
+        yield (b, cl.GetIssueURL() if b else None, 'error')
+
   else:
     # Do not use GetApprovingReviewers(), since it requires an HTTP request.
     for b in branches:
       cl = Changelist(branchref=b, auth_config=auth_config)
-      url = cl.GetIssueURL()
+      url = cl.GetIssueURL() if b else None
       yield (b, url, 'waiting' if url else 'error')
 
 
@@ -1583,8 +3055,10 @@ def upload_branch_deps(cl, args):
          '"git cl upload".')
   ask_for_data('[Press enter to continue or ctrl-C to quit]')
 
-  # Add a default patchset title to all upload calls.
-  args.extend(['-t', 'Updated patchset dependency'])
+  # Add a default patchset title to all upload calls in Rietveld.
+  if not cl.IsGerrit():
+    args.extend(['-t', 'Updated patchset dependency'])
+
   # Record all dependents that failed to upload.
   failures = {}
   # Go through all dependents, checkout the branch and upload.
@@ -1669,6 +3143,7 @@ def CMDstatus(parser, args):
   changes = (
       Changelist(branchref=b, auth_config=auth_config)
       for b in branches.splitlines())
+  # TODO(tandrii): refactor to use CLs list instead of branches list.
   branches = [c.GetBranch() for c in changes]
   alignment = max(5, max(len(b) for b in branches))
   print 'Branches associated with reviews:'
@@ -1686,7 +3161,7 @@ def CMDstatus(parser, args):
     issue_url, status = branch_statuses.pop(branch)
     color = color_for_status(status)
     reset = Fore.RESET
-    if not sys.stdout.isatty():
+    if not setup_color.IS_TTY:
       color = ''
       reset = ''
     status_str = '(%s)' % status if status else ''
@@ -1697,10 +3172,10 @@ def CMDstatus(parser, args):
   cl = Changelist(auth_config=auth_config)
   print
   print 'Current branch:',
+  print cl.GetBranch()
   if not cl.GetIssue():
-    print 'no issue assigned.'
+    print 'No issue assigned.'
     return 0
-  print cl.GetBranch()
   print 'Issue number: %s (%s)' % (cl.GetIssue(), cl.GetIssueURL())
   if not options.fast:
     print 'Issue description:'
@@ -1734,7 +3209,9 @@ def CMDissue(parser, args):
                     help='Lookup the branch(es) for the specified issues. If '
                          'no issues are specified, all branches with mapped '
                          'issues will be listed.')
+  _add_codereview_select_options(parser)
   options, args = parser.parse_args(args)
+  _process_codereview_select_options(parser, options)
 
   if options.reverse:
     branches = RunGit(['for-each-ref', 'refs/heads',
@@ -1753,13 +3230,13 @@ def CMDissue(parser, args):
       print 'Branch for issue number %s: %s' % (
           issue, ', '.join(issue_branch_map.get(int(issue)) or ('None',)))
   else:
-    cl = Changelist()
+    cl = Changelist(codereview=options.forced_codereview)
     if len(args) > 0:
       try:
         issue = int(args[0])
       except ValueError:
         DieWithError('Pass a number to set the issue or none to list it.\n'
-            'Maybe you want to run git cl status?')
+                     'Maybe you want to run git cl status?')
       cl.SetIssue(issue)
     print 'Issue number: %s (%s)' % (cl.GetIssue(), cl.GetIssueURL())
   return 0
@@ -1771,6 +3248,8 @@ def CMDcomments(parser, args):
                     help='comment to add to an issue')
   parser.add_option('-i', dest='issue',
                     help="review issue id (defaults to current issue)")
+  parser.add_option('-j', '--json-file',
+                    help='File to write JSON summary to')
   auth.add_auth_options(parser)
   options, args = parser.parse_args(args)
   auth_config = auth.extract_auth_config_from_options(options)
@@ -1782,18 +3261,28 @@ def CMDcomments(parser, args):
     except ValueError:
       DieWithError('A review issue id is expected to be a number')
 
-  cl = Changelist(issue=issue, auth_config=auth_config)
+  cl = Changelist(issue=issue, codereview='rietveld', auth_config=auth_config)
 
   if options.comment:
     cl.AddComment(options.comment)
     return 0
 
   data = cl.GetIssueProperties()
+  summary = []
   for message in sorted(data.get('messages', []), key=lambda x: x['date']):
+    summary.append({
+        'date': message['date'],
+        'lgtm': False,
+        'message': message['text'],
+        'not_lgtm': False,
+        'sender': message['sender'],
+    })
     if message['disapproval']:
       color = Fore.RED
+      summary[-1]['not lgtm'] = True
     elif message['approval']:
       color = Fore.GREEN
+      summary[-1]['lgtm'] = True
     elif message['sender'] == data['owner_email']:
       color = Fore.MAGENTA
     else:
@@ -1803,19 +3292,56 @@ def CMDcomments(parser, args):
         Fore.RESET)
     if message['text'].strip():
       print '\n'.join('  ' + l for l in message['text'].splitlines())
+  if options.json_file:
+    with open(options.json_file, 'wb') as f:
+      json.dump(summary, f)
   return 0
 
 
+@subcommand.usage('[codereview url or issue id]')
 def CMDdescription(parser, args):
   """Brings up the editor for the current CL's description."""
+  parser.add_option('-d', '--display', action='store_true',
+                    help='Display the description instead of opening an editor')
+  parser.add_option('-n', '--new-description',
+                    help='New description to set for this issue (- for stdin)')
+
+  _add_codereview_select_options(parser)
   auth.add_auth_options(parser)
-  options, _ = parser.parse_args(args)
+  options, args = parser.parse_args(args)
+  _process_codereview_select_options(parser, options)
+
+  target_issue = None
+  if len(args) > 0:
+    issue_arg = ParseIssueNumberArgument(args[0])
+    if not issue_arg.valid:
+      parser.print_help()
+      return 1
+    target_issue = issue_arg.issue
+
   auth_config = auth.extract_auth_config_from_options(options)
-  cl = Changelist(auth_config=auth_config)
+
+  cl = Changelist(
+      auth_config=auth_config, issue=target_issue,
+      codereview=options.forced_codereview)
+
   if not cl.GetIssue():
     DieWithError('This branch has no associated changelist.')
   description = ChangeDescription(cl.GetDescription())
-  description.prompt()
+
+  if options.display:
+    print description.description
+    return 0
+
+  if options.new_description:
+    text = options.new_description
+    if text == '-':
+      text = '\n'.join(l.rstrip() for l in sys.stdin)
+
+    description.set_description(text)
+  else:
+    description.prompt()
+
   if cl.GetDescription() != description.description:
     cl.UpdateDescription(description.description)
   return 0
@@ -1919,131 +3445,34 @@ def CMDpresubmit(parser, args):
   return 0
 
 
-def AddChangeIdToCommitMessage(options, args):
-  """Re-commits using the current message, assumes the commit hook is in
-  place.
-  """
-  log_desc = options.message or CreateDescriptionFromLog(args)
-  git_command = ['commit', '--amend', '-m', log_desc]
-  RunGit(git_command)
-  new_log_desc = CreateDescriptionFromLog(args)
-  if CHANGE_ID in new_log_desc:
-    print 'git-cl: Added Change-Id to commit message.'
-  else:
-    print >> sys.stderr, 'ERROR: Gerrit commit-msg hook not available.'
-
-
-def GerritUpload(options, args, cl, change):
-  """upload the current branch to gerrit."""
-  # We assume the remote called "origin" is the one we want.
-  # It is probably not worthwhile to support different workflows.
-  gerrit_remote = 'origin'
-
-  remote, remote_branch = cl.GetRemoteBranch()
-  branch = GetTargetRef(remote, remote_branch, options.target_branch,
-                        pending_prefix='')
-
-  change_desc = ChangeDescription(
-      options.message or CreateDescriptionFromLog(args))
-  if not change_desc.description:
-    print "Description is empty; aborting."
-    return 1
-
-  if options.squash:
-    # Try to get the message from a previous upload.
-    shadow_branch = 'refs/heads/git_cl_uploads/' + cl.GetBranch()
-    message = RunGitSilent(['show', '--format=%s\n\n%b', '-s', shadow_branch])
-    if not message:
-      if not options.force:
-        change_desc.prompt()
-
-      if CHANGE_ID not in change_desc.description:
-        # Run the commit-msg hook without modifying the head commit by writing
-        # the commit message to a temporary file and running the hook over it,
-        # then reading the file back in.
-        commit_msg_hook = os.path.join(settings.GetRoot(), '.git', 'hooks',
-                                       'commit-msg')
-        file_handle, msg_file = tempfile.mkstemp(text=True,
-                                                 prefix='commit_msg')
-        try:
-          try:
-            with os.fdopen(file_handle, 'w') as fileobj:
-              fileobj.write(change_desc.description)
-          finally:
-            os.close(file_handle)
-            RunCommand([commit_msg_hook, msg_file])
-            change_desc.set_description(gclient_utils.FileRead(msg_file))
-        finally:
-          os.remove(msg_file)
-
-      if not change_desc.description:
-        print "Description is empty; aborting."
-        return 1
-
-      message = change_desc.description
-
-    remote, upstream_branch = cl.FetchUpstreamTuple(cl.GetBranch())
-    if remote is '.':
-      # If our upstream branch is local, we base our squashed commit on its
-      # squashed version.
-      parent = ('refs/heads/git_cl_uploads/' +
-                scm.GIT.ShortBranchName(upstream_branch))
+def GenerateGerritChangeId(message):
+  """Returns Ixxxxxx...xxx change id.
 
-      # Verify that the upstream branch has been uploaded too, otherwise Gerrit
-      # will create additional CLs when uploading.
-      if (RunGitSilent(['rev-parse', upstream_branch + ':']) !=
-          RunGitSilent(['rev-parse', parent + ':'])):
-        print 'Upload upstream branch ' + upstream_branch + ' first.'
-        return 1
-    else:
-      parent = cl.GetCommonAncestorWithUpstream()
+  Works the same way as
+  https://gerrit-review.googlesource.com/tools/hooks/commit-msg
+  but can be called on demand on all platforms.
 
-    tree = RunGit(['rev-parse', 'HEAD:']).strip()
-    ref_to_push = RunGit(['commit-tree', tree, '-p', parent,
-                          '-m', message]).strip()
-  else:
-    if CHANGE_ID not in change_desc.description:
-      AddChangeIdToCommitMessage(options, args)
-    ref_to_push = 'HEAD'
-    parent = '%s/%s' % (gerrit_remote, branch)
-
-  commits = RunGitSilent(['rev-list', '%s..%s' % (parent,
-                                                  ref_to_push)]).splitlines()
-  if len(commits) > 1:
-    print('WARNING: This will upload %d commits. Run the following command '
-          'to see which commits will be uploaded: ' % len(commits))
-    print('git log %s..%s' % (parent, ref_to_push))
-    print('You can also use `git squash-branch` to squash these into a single '
-          'commit.')
-    ask_for_data('About to upload; enter to confirm.')
-
-  if options.reviewers or options.tbr_owners:
-    change_desc.update_reviewers(options.reviewers, options.tbr_owners, change)
-
-  receive_options = []
-  cc = cl.GetCCList().split(',')
-  if options.cc:
-    cc.extend(options.cc)
-  cc = filter(None, cc)
-  if cc:
-    receive_options += ['--cc=' + email for email in cc]
-  if change_desc.get_reviewers():
-    receive_options.extend(
-        '--reviewer=' + email for email in change_desc.get_reviewers())
-
-  git_command = ['push']
-  if receive_options:
-    git_command.append('--receive-pack=git receive-pack %s' %
-                       ' '.join(receive_options))
-  git_command += [gerrit_remote, ref_to_push + ':refs/for/' + branch]
-  RunGit(git_command)
-
-  if options.squash:
-    head = RunGit(['rev-parse', 'HEAD']).strip()
-    RunGit(['update-ref', '-m', 'Uploaded ' + head, shadow_branch, ref_to_push])
-
-  # TODO(ukai): parse Change-Id: and set issue number?
-  return 0
+  The basic idea is to generate git hash of a state of the tree, original commit
+  message, author/committer info and timestamps.
+  """
+  lines = []
+  tree_hash = RunGitSilent(['write-tree'])
+  lines.append('tree %s' % tree_hash.strip())
+  code, parent = RunGitWithCode(['rev-parse', 'HEAD~0'], suppress_stderr=False)
+  if code == 0:
+    lines.append('parent %s' % parent.strip())
+  author = RunGitSilent(['var', 'GIT_AUTHOR_IDENT'])
+  lines.append('author %s' % author.strip())
+  committer = RunGitSilent(['var', 'GIT_COMMITTER_IDENT'])
+  lines.append('committer %s' % committer.strip())
+  lines.append('')
+  # Note: Gerrit's commit-hook actually cleans message of some lines and
+  # whitespace. This code is not doing this, but it clearly won't decrease
+  # entropy.
+  lines.append(message)
+  change_hash = RunCommand(['git', 'hash-object', '-t', 'commit', '--stdin'],
+                           stdin='\n'.join(lines))
+  return 'I%s' % change_hash.strip()
 
 
 def GetTargetRef(remote, remote_branch, target_branch, pending_prefix):
@@ -2101,148 +3530,6 @@ def GetTargetRef(remote, remote_branch, target_branch, pending_prefix):
   return remote_branch
 
 
-def RietveldUpload(options, args, cl, change):
-  """upload the patch to rietveld."""
-  upload_args = ['--assume_yes']  # Don't ask about untracked files.
-  upload_args.extend(['--server', cl.GetRietveldServer()])
-  upload_args.extend(auth.auth_config_to_command_options(cl.auth_config))
-  if options.emulate_svn_auto_props:
-    upload_args.append('--emulate_svn_auto_props')
-
-  change_desc = None
-
-  if options.email is not None:
-    upload_args.extend(['--email', options.email])
-
-  if cl.GetIssue():
-    if options.title:
-      upload_args.extend(['--title', options.title])
-    if options.message:
-      upload_args.extend(['--message', options.message])
-    upload_args.extend(['--issue', str(cl.GetIssue())])
-    print ("This branch is associated with issue %s. "
-           "Adding patch to that issue." % cl.GetIssue())
-  else:
-    if options.title:
-      upload_args.extend(['--title', options.title])
-    message = options.title or options.message or CreateDescriptionFromLog(args)
-    change_desc = ChangeDescription(message)
-    if options.reviewers or options.tbr_owners:
-      change_desc.update_reviewers(options.reviewers,
-                                   options.tbr_owners,
-                                   change)
-    if not options.force:
-      change_desc.prompt()
-
-    if not change_desc.description:
-      print "Description is empty; aborting."
-      return 1
-
-    upload_args.extend(['--message', change_desc.description])
-    if change_desc.get_reviewers():
-      upload_args.append('--reviewers=' + ','.join(change_desc.get_reviewers()))
-    if options.send_mail:
-      if not change_desc.get_reviewers():
-        DieWithError("Must specify reviewers to send email.")
-      upload_args.append('--send_mail')
-
-    # We check this before applying rietveld.private assuming that in
-    # rietveld.cc only addresses which we can send private CLs to are listed
-    # if rietveld.private is set, and so we should ignore rietveld.cc only when
-    # --private is specified explicitly on the command line.
-    if options.private:
-      logging.warn('rietveld.cc is ignored since private flag is specified.  '
-                   'You need to review and add them manually if necessary.')
-      cc = cl.GetCCListWithoutDefault()
-    else:
-      cc = cl.GetCCList()
-    cc = ','.join(filter(None, (cc, ','.join(options.cc))))
-    if cc:
-      upload_args.extend(['--cc', cc])
-
-  if options.private or settings.GetDefaultPrivateFlag() == "True":
-    upload_args.append('--private')
-
-  upload_args.extend(['--git_similarity', str(options.similarity)])
-  if not options.find_copies:
-    upload_args.extend(['--git_no_find_copies'])
-
-  # Include the upstream repo's URL in the change -- this is useful for
-  # projects that have their source spread across multiple repos.
-  remote_url = cl.GetGitBaseUrlFromConfig()
-  if not remote_url:
-    if settings.GetIsGitSvn():
-      remote_url = cl.GetGitSvnRemoteUrl()
-    else:
-      if cl.GetRemoteUrl() and '/' in cl.GetUpstreamBranch():
-        remote_url = (cl.GetRemoteUrl() + '@'
-                      + cl.GetUpstreamBranch().split('/')[-1])
-  if remote_url:
-    upload_args.extend(['--base_url', remote_url])
-    remote, remote_branch = cl.GetRemoteBranch()
-    target_ref = GetTargetRef(remote, remote_branch, options.target_branch,
-                              settings.GetPendingRefPrefix())
-    if target_ref:
-      upload_args.extend(['--target_ref', target_ref])
-
-    # Look for dependent patchsets. See crbug.com/480453 for more details.
-    remote, upstream_branch = cl.FetchUpstreamTuple(cl.GetBranch())
-    upstream_branch = ShortBranchName(upstream_branch)
-    if remote is '.':
-      # A local branch is being tracked.
-      local_branch = ShortBranchName(upstream_branch)
-      auth_config = auth.extract_auth_config_from_options(options)
-      branch_cl = Changelist(branchref=local_branch, auth_config=auth_config)
-      branch_cl_issue_url = branch_cl.GetIssueURL()
-      branch_cl_issue = branch_cl.GetIssue()
-      branch_cl_patchset = branch_cl.GetPatchset()
-      if branch_cl_issue_url and branch_cl_issue and branch_cl_patchset:
-        upload_args.extend(
-            ['--depends_on_patchset', '%s:%s' % (
-                 branch_cl_issue, branch_cl_patchset)])
-        print
-        print ('The current branch (%s) is tracking a local branch (%s) with '
-               'an associated CL.') % (cl.GetBranch(), local_branch)
-        print 'Adding %s/#ps%s as a dependency patchset.' % (
-            branch_cl_issue_url, branch_cl_patchset)
-        print
-
-  project = settings.GetProject()
-  if project:
-    upload_args.extend(['--project', project])
-
-  if options.cq_dry_run:
-    upload_args.extend(['--cq_dry_run'])
-
-  try:
-    upload_args = ['upload'] + upload_args + args
-    logging.info('upload.RealMain(%s)', upload_args)
-    issue, patchset = upload.RealMain(upload_args)
-    issue = int(issue)
-    patchset = int(patchset)
-  except KeyboardInterrupt:
-    sys.exit(1)
-  except:
-    # If we got an exception after the user typed a description for their
-    # change, back up the description before re-raising.
-    if change_desc:
-      backup_path = os.path.expanduser(DESCRIPTION_BACKUP_FILE)
-      print '\nGot exception while uploading -- saving description to %s\n' \
-          % backup_path
-      backup_file = open(backup_path, 'w')
-      backup_file.write(change_desc.description)
-      backup_file.close()
-    raise
-
-  if not cl.GetIssue():
-    cl.SetIssue(issue)
-  cl.SetPatchset(patchset)
-
-  if options.use_commit_queue:
-    cl.SetFlag('commit', '1')
-  return 0
-
-
 def cleanup_list(l):
   """Fixes a list so that comma separated items are put as individual items.
 
@@ -2256,7 +3543,14 @@ def cleanup_list(l):
 
 @subcommand.usage('[args to "git diff"]')
 def CMDupload(parser, args):
-  """Uploads the current changelist to codereview."""
+  """Uploads the current changelist to codereview.
+
+  Can skip dependency patchset uploads for a branch by running:
+    git config branch.branch_name.skip-deps-uploads True
+  To unset run:
+    git config --unset branch.branch_name.skip-deps-uploads
+  Can also set the above globally by using the --global flag.
+  """
   parser.add_option('--bypass-hooks', action='store_true', dest='bypass_hooks',
                     help='bypass upload presubmit hook')
   parser.add_option('--bypass-watchlists', action='store_true',
@@ -2265,7 +3559,8 @@ def CMDupload(parser, args):
   parser.add_option('-f', action='store_true', dest='force',
                     help="force yes to questions (don't prompt)")
   parser.add_option('-m', dest='message', help='message for patchset')
-  parser.add_option('-t', dest='title', help='title for patchset')
+  parser.add_option('-t', dest='title',
+                    help='title for patchset (Rietveld only)')
   parser.add_option('-r', '--reviewers',
                     action='append', default=[],
                     help='reviewer email addresses')
@@ -2290,11 +3585,15 @@ def CMDupload(parser, args):
                          'Default: remote branch head, or master')
   parser.add_option('--squash', action='store_true',
                     help='Squash multiple commits into one (Gerrit only)')
+  parser.add_option('--no-squash', action='store_true',
+                    help='Don\'t squash multiple commits into one ' +
+                         '(Gerrit only)')
   parser.add_option('--email', default=None,
                     help='email address to use to connect to Rietveld')
   parser.add_option('--tbr-owners', dest='tbr_owners', action='store_true',
                     help='add a set of OWNERS to TBR')
-  parser.add_option('--cq-dry-run', dest='cq_dry_run', action='store_true',
+  parser.add_option('-d', '--cq-dry-run', dest='cq_dry_run',
+                    action='store_true',
                     help='Send the patchset to do a CQ dry run right after '
                          'upload.')
   parser.add_option('--dependencies', action='store_true',
@@ -2304,7 +3603,9 @@ def CMDupload(parser, args):
   orig_args = args
   add_git_similarity(parser)
   auth.add_auth_options(parser)
+  _add_codereview_select_options(parser)
   (options, args) = parser.parse_args(args)
+  _process_codereview_select_options(parser, options)
   auth_config = auth.extract_auth_config_from_options(options)
 
   if git_common.is_dirty_git_tree('upload'):
@@ -2313,90 +3614,11 @@ def CMDupload(parser, args):
   options.reviewers = cleanup_list(options.reviewers)
   options.cc = cleanup_list(options.cc)
 
-  cl = Changelist(auth_config=auth_config)
-  if args:
-    # TODO(ukai): is it ok for gerrit case?
-    base_branch = args[0]
-  else:
-    if cl.GetBranch() is None:
-      DieWithError('Can\'t upload from detached HEAD state. Get on a branch!')
-
-    # Default to diffing against common ancestor of upstream branch
-    base_branch = cl.GetCommonAncestorWithUpstream()
-    args = [base_branch, 'HEAD']
-
-  # Make sure authenticated to Rietveld before running expensive hooks. It is
-  # a fast, best efforts check. Rietveld still can reject the authentication
-  # during the actual upload.
-  if not settings.GetIsGerrit() and auth_config.use_oauth2:
-    authenticator = auth.get_authenticator_for_host(
-        cl.GetRietveldServer(), auth_config)
-    if not authenticator.has_cached_credentials():
-      raise auth.LoginRequiredError(cl.GetRietveldServer())
-
-  # Apply watchlists on upload.
-  change = cl.GetChange(base_branch, None)
-  watchlist = watchlists.Watchlists(change.RepositoryRoot())
-  files = [f.LocalPath() for f in change.AffectedFiles()]
-  if not options.bypass_watchlists:
-    cl.SetWatchers(watchlist.GetWatchersForPaths(files))
-
-  if not options.bypass_hooks:
-    if options.reviewers or options.tbr_owners:
-      # Set the reviewer list now so that presubmit checks can access it.
-      change_description = ChangeDescription(change.FullDescriptionText())
-      change_description.update_reviewers(options.reviewers,
-                                          options.tbr_owners,
-                                          change)
-      change.SetDescriptionText(change_description.description)
-    hook_results = cl.RunHook(committing=False,
-                              may_prompt=not options.force,
-                              verbose=options.verbose,
-                              change=change)
-    if not hook_results.should_continue():
-      return 1
-    if not options.reviewers and hook_results.reviewers:
-      options.reviewers = hook_results.reviewers.split(',')
-
-  if cl.GetIssue():
-    latest_patchset = cl.GetMostRecentPatchset()
-    local_patchset = cl.GetPatchset()
-    if latest_patchset and local_patchset and local_patchset != latest_patchset:
-      print ('The last upload made from this repository was patchset #%d but '
-            'the most recent patchset on the server is #%d.'
-            % (local_patchset, latest_patchset))
-      print ('Uploading will still work, but if you\'ve uploaded to this issue '
-            'from another machine or branch the patch you\'re uploading now '
-            'might not include those changes.')
-      ask_for_data('About to upload; enter to confirm.')
-
-  print_stats(options.similarity, options.find_copies, args)
-  if settings.GetIsGerrit():
-    return GerritUpload(options, args, cl, change)
-  ret = RietveldUpload(options, args, cl, change)
-  if not ret:
-    git_set_branch_value('last-upload-hash',
-                         RunGit(['rev-parse', 'HEAD']).strip())
-    # Run post upload hooks, if specified.
-    if settings.GetRunPostUploadHook():
-      presubmit_support.DoPostUploadExecuter(
-          change,
-          cl,
-          settings.GetRoot(),
-          options.verbose,
-          sys.stdout)
+  # For sanity of test expectations, do this otherwise lazy-loading *now*.
+  settings.GetIsGerrit()
 
-    # Upload all dependencies if specified.
-    if options.dependencies:
-      print
-      print '--dependencies has been specified.'
-      print 'All dependent local branches will be re-uploaded.'
-      print
-      # Remove the dependencies flag from args so that we do not end up in a
-      # loop.
-      orig_args.remove('--dependencies')
-      upload_branch_deps(cl, orig_args)
-  return ret
+  cl = Changelist(auth_config=auth_config, codereview=options.forced_codereview)
+  return cl.CMDUpload(options, args, orig_args)
 
 
 def IsSubmoduleMergeCommit(ref):
@@ -2410,10 +3632,14 @@ def IsSubmoduleMergeCommit(ref):
 def SendUpstream(parser, args, cmd):
   """Common code for CMDland and CmdDCommit
 
-  Squashes branch into a single commit.
-  Updates changelog with metadata (e.g. pointer to review).
-  Pushes/dcommits the code upstream.
-  Updates review and closes.
+  In case of Gerrit, uses Gerrit REST api to "submit" the issue, which pushes
+  upstream and closes the issue automatically and atomically.
+
+  Otherwise (in case of Rietveld):
+    Squashes branch into a single commit.
+    Updates changelog with metadata (e.g. pointer to review).
+    Pushes/dcommits the code upstream.
+    Updates review and closes.
   """
   parser.add_option('--bypass-hooks', action='store_true', dest='bypass_hooks',
                     help='bypass upload presubmit hook')
@@ -2432,6 +3658,24 @@ def SendUpstream(parser, args, cmd):
 
   cl = Changelist(auth_config=auth_config)
 
+  # TODO(tandrii): refactor this into _RietveldChangelistImpl method.
+  if cl.IsGerrit():
+    if options.message:
+      # This could be implemented, but it requires sending a new patch to
+      # Gerrit, as Gerrit unlike Rietveld versions messages with patchsets.
+      # Besides, Gerrit has the ability to change the commit message on submit
+      # automatically, thus there is no need to support this option (so far?).
+      parser.error('-m MESSAGE option is not supported for Gerrit.')
+    if options.contributor:
+      parser.error(
+          '-c CONTRIBUTOR option is not supported for Gerrit.\n'
+          'Before uploading a commit to Gerrit, ensure it\'s author field is '
+          'the contributor\'s "name <email>". If you can\'t upload such a '
+          'commit for review, contact your repository admin and request'
+          '"Forge-Author" permission.')
+    return cl._codereview_impl.CMDLand(options.force, options.bypass_hooks,
+                                       options.verbose)
+
   current = cl.GetBranch()
   remote, upstream_branch = cl.FetchUpstreamTuple(cl.GetBranch())
   if not settings.GetIsGitSvn() and remote == '.':
@@ -2516,12 +3760,6 @@ def SendUpstream(parser, args, cmd):
       print('Unable to determine tree status.  Please verify manually and '
             'use "git cl %s --bypass-hooks" to commit on a closed tree.' % cmd)
       return 1
-  else:
-    breakpad.SendStack(
-        'GitClHooksBypassedCommit',
-        'Issue %s/%s bypassed hook when committing (tree status was "%s")' %
-        (cl.GetRietveldServer(), cl.GetIssue(), GetTreeStatus()),
-        verbose=False)
 
   change_desc = ChangeDescription(options.message)
   if not change_desc.description and cl.GetIssue():
@@ -2545,8 +3783,10 @@ def SendUpstream(parser, args, cmd):
   commit_desc = ChangeDescription(change_desc.description)
   if cl.GetIssue():
     # Xcode won't linkify this URL unless there is a non-whitespace character
-    # after it. Add a period on a new line to circumvent this.
-    commit_desc.append_footer('Review URL: %s.' % cl.GetIssueURL())
+    # after it. Add a period on a new line to circumvent this. Also add a space
+    # before the period to make sure that Gitiles continues to correctly resolve
+    # the URL.
+    commit_desc.append_footer('Review URL: %s .' % cl.GetIssueURL())
   if options.contributor:
     commit_desc.append_footer('Patch from %s.' % options.contributor)
 
@@ -2603,19 +3843,21 @@ def SendUpstream(parser, args, cmd):
       RunGit(['cherry-pick', cherry_pick_commit])
     if cmd == 'land':
       remote, branch = cl.FetchUpstreamTuple(cl.GetBranch())
+      mirror = settings.GetGitMirror(remote)
+      pushurl = mirror.url if mirror else remote
       pending_prefix = settings.GetPendingRefPrefix()
       if not pending_prefix or branch.startswith(pending_prefix):
         # If not using refs/pending/heads/* at all, or target ref is already set
         # to pending, then push to the target ref directly.
         retcode, output = RunGitWithCode(
-            ['push', '--porcelain', remote, 'HEAD:%s' % branch])
+            ['push', '--porcelain', pushurl, 'HEAD:%s' % branch])
         pushed_to_pending = pending_prefix and branch.startswith(pending_prefix)
       else:
         # Cherry-pick the change on top of pending ref and then push it.
         assert branch.startswith('refs/'), branch
         assert pending_prefix[-1] == '/', pending_prefix
         pending_ref = pending_prefix + branch[len('refs/'):]
-        retcode, output = PushToGitPending(remote, pending_ref, branch)
+        retcode, output = PushToGitPending(pushurl, pending_ref, branch)
         pushed_to_pending = (retcode == 0)
       if retcode == 0:
         revision = RunGit(['rev-parse', 'HEAD']).strip()
@@ -2703,6 +3945,7 @@ def WaitForRealCommit(remote, pushed_commit, local_base_ref, real_ref):
   print '(If you are impatient, you may Ctrl-C once without harm)'
   target_tree = RunGit(['rev-parse', '%s:' % pushed_commit]).strip()
   current_rev = RunGit(['rev-parse', local_base_ref]).strip()
+  mirror = settings.GetGitMirror(remote)
 
   loop = 0
   while True:
@@ -2710,6 +3953,8 @@ def WaitForRealCommit(remote, pushed_commit, local_base_ref, real_ref):
     sys.stdout.flush()
     loop += 1
 
+    if mirror:
+      mirror.populate()
     RunGit(['retry', 'fetch', remote, real_ref], stderr=subprocess2.VOID)
     to_rev = RunGit(['rev-parse', 'FETCH_HEAD']).strip()
     commits = RunGit(['rev-list', '%s..%s' % (current_rev, to_rev)])
@@ -2793,7 +4038,7 @@ def IsFatalPushFailure(push_stdout):
 def CMDdcommit(parser, args):
   """Commits the current changelist via git-svn."""
   if not settings.GetIsGitSvn():
-    if get_footer_svn_id():
+    if git_footers.get_footer_svn_id():
       # If it looks like previous commits were mirrored with git-svn.
       message = """This repository appears to be a git-svn mirror, but no
 upstream SVN master is set. You probably need to run 'git auto-svn' once."""
@@ -2815,7 +4060,7 @@ proceed, please verify that the commit lands upstream as expected."""
 @subcommand.usage('[upstream branch to apply against]')
 def CMDland(parser, args):
   """Commits the current changelist via git."""
-  if settings.GetIsGitSvn() or get_footer_svn_id():
+  if settings.GetIsGitSvn() or git_footers.get_footer_svn_id():
     print('This appears to be an SVN repository.')
     print('Are you sure you didn\'t mean \'git cl dcommit\'?')
     print('(Ignore if this is the first commit after migrating from svn->git)')
@@ -2823,7 +4068,7 @@ def CMDland(parser, args):
   return SendUpstream(parser, args, 'land')
 
 
-@subcommand.usage('<patch url or issue id>')
+@subcommand.usage('<patch url or issue id or issue url>')
 def CMDpatch(parser, args):
   """Patches in a code review."""
   parser.add_option('-b', dest='newbranch',
@@ -2832,111 +4077,82 @@ def CMDpatch(parser, args):
                     help='with -b, clobber any existing branch')
   parser.add_option('-d', '--directory', action='store', metavar='DIR',
                     help='Change to the directory DIR immediately, '
-                         'before doing anything else.')
+                         'before doing anything else. Rietveld only.')
   parser.add_option('--reject', action='store_true',
                     help='failed patches spew .rej files rather than '
-                        'attempting a 3-way merge')
+                        'attempting a 3-way merge. Rietveld only.')
   parser.add_option('-n', '--no-commit', action='store_true', dest='nocommit',
-                    help="don't commit after patch applies")
+                    help='don\'t commit after patch applies. Rietveld only.')
+
+
+  group = optparse.OptionGroup(
+      parser,
+      'Options for continuing work on the current issue uploaded from a '
+      'different clone (e.g. different machine). Must be used independently '
+      'from the other options. No issue number should be specified, and the '
+      'branch must have an issue number associated with it')
+  group.add_option('--reapply', action='store_true', dest='reapply',
+                   help='Reset the branch and reapply the issue.\n'
+                        'CAUTION: This will undo any local changes in this '
+                        'branch')
+
+  group.add_option('--pull', action='store_true', dest='pull',
+                    help='Performs a pull before reapplying.')
+  parser.add_option_group(group)
+
   auth.add_auth_options(parser)
+  _add_codereview_select_options(parser)
   (options, args) = parser.parse_args(args)
+  _process_codereview_select_options(parser, options)
   auth_config = auth.extract_auth_config_from_options(options)
 
-  if len(args) != 1:
+  cl = Changelist(auth_config=auth_config, codereview=options.forced_codereview)
+
+  issue_arg = None
+  if options.reapply :
+    if len(args) > 0:
+      parser.error('--reapply implies no additional arguments.')
+
+    issue_arg = cl.GetIssue()
+    upstream = cl.GetUpstreamBranch()
+    if upstream == None:
+      parser.error('No upstream branch specified. Cannot reset branch')
+
+    RunGit(['reset', '--hard', upstream])
+    if options.pull:
+      RunGit(['pull'])
+  else:
+    if len(args) != 1:
+      parser.error('Must specify issue number or url')
+    issue_arg = args[0]
+
+  if not issue_arg:
     parser.print_help()
     return 1
-  issue_arg = args[0]
+
+  if cl.IsGerrit():
+    if options.reject:
+      parser.error('--reject is not supported with Gerrit codereview.')
+    if options.nocommit:
+      parser.error('--nocommit is not supported with Gerrit codereview.')
+    if options.directory:
+      parser.error('--directory is not supported with Gerrit codereview.')
 
   # We don't want uncommitted changes mixed up with the patch.
   if git_common.is_dirty_git_tree('patch'):
     return 1
 
-  # TODO(maruel): Use apply_issue.py
-  # TODO(ukai): use gerrit-cherry-pick for gerrit repository?
-
   if options.newbranch:
+    if options.reapply:
+      parser.error("--reapply excludes any option other than --pull")
     if options.force:
       RunGit(['branch', '-D', options.newbranch],
           stderr=subprocess2.PIPE, error_ok=True)
     RunGit(['checkout', '-b', options.newbranch,
             Changelist().GetUpstreamBranch()])
 
-  return PatchIssue(issue_arg, options.reject, options.nocommit,
-                    options.directory, auth_config)
-
-
-def PatchIssue(issue_arg, reject, nocommit, directory, auth_config):
-  # PatchIssue should never be called with a dirty tree.  It is up to the
-  # caller to check this, but just in case we assert here since the
-  # consequences of the caller not checking this could be dire.
-  assert(not git_common.is_dirty_git_tree('apply'))
-
-  if type(issue_arg) is int or issue_arg.isdigit():
-    # Input is an issue id.  Figure out the URL.
-    issue = int(issue_arg)
-    cl = Changelist(issue=issue, auth_config=auth_config)
-    patchset = cl.GetMostRecentPatchset()
-    patch_data = cl.GetPatchSetDiff(issue, patchset)
-  else:
-    # Assume it's a URL to the patch. Default to https.
-    issue_url = gclient_utils.UpgradeToHttps(issue_arg)
-    match = re.match(r'(.*?)/download/issue(\d+)_(\d+).diff', issue_url)
-    if not match:
-      DieWithError('Must pass an issue ID or full URL for '
-          '\'Download raw patch set\'')
-    issue = int(match.group(2))
-    cl = Changelist(issue=issue, auth_config=auth_config)
-    cl.rietveld_server = match.group(1)
-    patchset = int(match.group(3))
-    patch_data = urllib2.urlopen(issue_arg).read()
-
-  # Switch up to the top-level directory, if necessary, in preparation for
-  # applying the patch.
-  top = settings.GetRelativeRoot()
-  if top:
-    os.chdir(top)
-
-  # Git patches have a/ at the beginning of source paths.  We strip that out
-  # with a sed script rather than the -p flag to patch so we can feed either
-  # Git or svn-style patches into the same apply command.
-  # re.sub() should be used but flags=re.MULTILINE is only in python 2.7.
-  try:
-    patch_data = subprocess2.check_output(
-        ['sed', '-e', 's|^--- a/|--- |; s|^+++ b/|+++ |'], stdin=patch_data)
-  except subprocess2.CalledProcessError:
-    DieWithError('Git patch mungling failed.')
-  logging.info(patch_data)
-
-  # We use "git apply" to apply the patch instead of "patch" so that we can
-  # pick up file adds.
-  # The --index flag means: also insert into the index (so we catch adds).
-  cmd = ['git', 'apply', '--index', '-p0']
-  if directory:
-    cmd.extend(('--directory', directory))
-  if reject:
-    cmd.append('--reject')
-  elif IsGitVersionAtLeast('1.7.12'):
-    cmd.append('--3way')
-  try:
-    subprocess2.check_call(cmd, env=GetNoGitPagerEnv(),
-                           stdin=patch_data, stdout=subprocess2.VOID)
-  except subprocess2.CalledProcessError:
-    print 'Failed to apply the patch'
-    return 1
-
-  # If we had an issue, commit the current state and register the issue.
-  if not nocommit:
-    RunGit(['commit', '-m', (cl.GetDescription() + '\n\n' +
-                             'patch from issue %(i)s at patchset '
-                             '%(p)s (http://crrev.com/%(i)s#ps%(p)s)'
-                             % {'i': issue, 'p': patchset})])
-    cl = Changelist(auth_config=auth_config)
-    cl.SetIssue(issue)
-    cl.SetPatchset(patchset)
-    print "Committed patch locally."
-  else:
-    print "Patch applied to index."
-  return 0
+  return cl.CMDPatchIssue(issue_arg, options.reject, options.nocommit,
+                          options.directory)
 
 
 def CMDrebase(parser, args):
@@ -3022,7 +4238,7 @@ def CMDtree(parser, args):
 
 
 def CMDtry(parser, args):
-  """Triggers a try job through Rietveld."""
+  """Triggers try jobs through BuildBucket."""
   group = optparse.OptionGroup(parser, "Try job options")
   group.add_option(
       "-b", "--bot", action="append",
@@ -3034,6 +4250,7 @@ def CMDtry(parser, args):
   group.add_option(
       "-m", "--master", default='',
       help=("Specify a try master where to run the tries."))
+  group.add_option( "--luci", action='store_true')
   group.add_option(
       "-r", "--revision",
       help="Revision to use for the try job; default: the "
@@ -3047,16 +4264,32 @@ def CMDtry(parser, args):
       "--project",
       help="Override which project to use. Projects are defined "
            "server-side to define what default bot set to use")
+  group.add_option(
+      "-p", "--property", dest="properties", action="append", default=[],
+      help="Specify generic properties in the form -p key1=value1 -p "
+           "key2=value2 etc (buildbucket only). The value will be treated as "
+           "json if decodable, or as string otherwise.")
   group.add_option(
       "-n", "--name", help="Try job name; default to current branch name")
   group.add_option(
-      "--use-buildbucket", action="store_true", default=False,
-      help="Use buildbucket to trigger try jobs.")
+      "--use-rietveld", action="store_true", default=False,
+      help="Use Rietveld to trigger try jobs.")
+  group.add_option(
+      "--buildbucket-host", default='cr-buildbucket.appspot.com',
+      help="Host of buildbucket. The default host is %default.")
   parser.add_option_group(group)
   auth.add_auth_options(parser)
   options, args = parser.parse_args(args)
   auth_config = auth.extract_auth_config_from_options(options)
 
+  if options.use_rietveld and options.properties:
+    parser.error('Properties can only be specified with buildbucket')
+
+  # Make sure that all properties are prop=value pairs.
+  bad_params = [x for x in options.properties if '=' not in x]
+  if bad_params:
+    parser.error('Got properties with missing "=": %s' % bad_params)
+
   if args:
     parser.error('Unknown arguments: %s' % args)
 
@@ -3064,6 +4297,14 @@ def CMDtry(parser, args):
   if not cl.GetIssue():
     parser.error('Need to upload first')
 
+  if cl.IsGerrit():
+    parser.error(
+        'Not yet supported for Gerrit (http://crbug.com/599931).\n'
+        'If your project has Commit Queue, dry run is a workaround:\n'
+        '  git cl set-commit --dry-run')
+  # Code below assumes Rietveld issue.
+  # TODO(tandrii): actually implement for Gerrit http://crbug.com/599931.
+
   props = cl.GetIssueProperties()
   if props.get('closed'):
     parser.error('Cannot send tryjobs for a closed CL')
@@ -3107,6 +4348,24 @@ def CMDtry(parser, args):
           None,
           options.verbose,
           sys.stdout)
+
+      if not options.bot:
+        # Get try masters from cq.cfg if any.
+        # TODO(tandrii): some (but very few) projects store cq.cfg in different
+        # location.
+        cq_cfg = os.path.join(change.RepositoryRoot(),
+                              'infra', 'config', 'cq.cfg')
+        if os.path.exists(cq_cfg):
+          masters = {}
+          cq_masters = commit_queue.get_master_builder_map(
+              cq_cfg, include_experimental=False, include_triggered=False)
+          for master, builders in cq_masters.iteritems():
+            for builder in builders:
+              # Skip presubmit builders, because these will fail without LGTM.
+              masters.setdefault(master, {})[builder] = ['defaulttests']
+          if masters:
+            return masters
+
     if not options.bot:
       parser.error('No default try builder to try, use --bot')
 
@@ -3122,7 +4381,7 @@ def CMDtry(parser, args):
       elif ',' in bot:
         parser.error('Specify one bot per --bot flag')
       else:
-        builders_and_tests.setdefault(bot, []).append('defaulttests')
+        builders_and_tests.setdefault(bot, [])
 
     for bot, tests in new_style:
       builders_and_tests.setdefault(bot, []).extend(tests)
@@ -3149,7 +4408,9 @@ def CMDtry(parser, args):
         '\nWARNING Mismatch between local config and server. Did a previous '
         'upload fail?\ngit-cl try always uses latest patchset from rietveld. '
         'Continuing using\npatchset %s.\n' % patchset)
-  if options.use_buildbucket:
+  if options.luci:
+    trigger_luci_job(cl, masters, options)
+  elif not options.use_rietveld:
     try:
       trigger_try_jobs(auth_config, cl, options, masters, 'git_cl_try')
     except BuildbucketResponseException as ex:
@@ -3181,6 +4442,50 @@ def CMDtry(parser, args):
   return 0
 
 
+def CMDtry_results(parser, args):
+  group = optparse.OptionGroup(parser, "Try job results options")
+  group.add_option(
+      "-p", "--patchset", type=int, help="patchset number if not current.")
+  group.add_option(
+      "--print-master", action='store_true', help="print master name as well.")
+  group.add_option(
+      "--color", action='store_true', default=setup_color.IS_TTY,
+      help="force color output, useful when piping output.")
+  group.add_option(
+      "--buildbucket-host", default='cr-buildbucket.appspot.com',
+      help="Host of buildbucket. The default host is %default.")
+  parser.add_option_group(group)
+  auth.add_auth_options(parser)
+  options, args = parser.parse_args(args)
+  if args:
+    parser.error('Unrecognized args: %s' % ' '.join(args))
+
+  auth_config = auth.extract_auth_config_from_options(options)
+  cl = Changelist(auth_config=auth_config)
+  if not cl.GetIssue():
+    parser.error('Need to upload first')
+
+  if not options.patchset:
+    options.patchset = cl.GetMostRecentPatchset()
+    if options.patchset and options.patchset != cl.GetPatchset():
+      print(
+          '\nWARNING Mismatch between local config and server. Did a previous '
+          'upload fail?\ngit-cl try always uses latest patchset from rietveld. '
+          'Continuing using\npatchset %s.\n' % options.patchset)
+  try:
+    jobs = fetch_try_jobs(auth_config, cl, options)
+  except BuildbucketResponseException as ex:
+    print 'Buildbucket error: %s' % ex
+    return 1
+  except Exception as e:
+    stacktrace = (''.join(traceback.format_stack()) + traceback.format_exc())
+    print 'ERROR: Exception when trying to fetch tryjobs: %s\n%s' % (
+        e, stacktrace)
+    return 1
+  print_tryjobs(options, jobs)
+  return 0
+
+
 @subcommand.usage('[new upstream branch]')
 def CMDupstream(parser, args):
   """Prints or sets the name of the upstream branch, if any."""
@@ -3220,16 +4525,28 @@ def CMDweb(parser, args):
 
 def CMDset_commit(parser, args):
   """Sets the commit bit to trigger the Commit Queue."""
+  parser.add_option('-d', '--dry-run', action='store_true',
+                    help='trigger in dry run mode')
+  parser.add_option('-c', '--clear', action='store_true',
+                    help='stop CQ run, if any')
   auth.add_auth_options(parser)
   options, args = parser.parse_args(args)
   auth_config = auth.extract_auth_config_from_options(options)
   if args:
     parser.error('Unrecognized args: %s' % ' '.join(args))
+  if options.dry_run and options.clear:
+    parser.error('Make up your mind: both --dry-run and --clear not allowed')
+
   cl = Changelist(auth_config=auth_config)
-  props = cl.GetIssueProperties()
-  if props.get('private'):
-    parser.error('Cannot set commit on private issue')
-  cl.SetFlag('commit', '1')
+  if options.clear:
+    state = _CQState.CLEAR
+  elif options.dry_run:
+    state = _CQState.DRY_RUN
+  else:
+    state = _CQState.COMMIT
+  if not cl.GetIssue():
+    parser.error('Must upload the issue first')
+  cl.SetCQState(state)
   return 0
 
 
@@ -3256,7 +4573,7 @@ def CMDdiff(parser, args):
     parser.error('Unrecognized args: %s' % ' '.join(args))
 
   # Uncommitted (staged and unstaged) changes will be destroyed by
-  # "git reset --hard" if there are merging conflicts in PatchIssue().
+  # "git reset --hard" if there are merging conflicts in CMDPatchIssue().
   # Staged changes would be committed along with the patch from last
   # upload, hence counted toward the "last upload" side in the final
   # diff output, and this is not what we want.
@@ -3273,9 +4590,11 @@ def CMDdiff(parser, args):
 
   # Create a new branch based on the merge-base
   RunGit(['checkout', '-q', '-b', TMP_BRANCH, base_branch])
+  # Clear cached branch in cl object, to avoid overwriting original CL branch
+  # properties.
+  cl.ClearBranch()
   try:
-    # Patch in the latest changes from rietveld.
-    rtn = PatchIssue(issue, False, False, None, auth_config)
+    rtn = cl.CMDPatchIssue(issue, reject=False, nocommit=False, directory=None)
     if rtn != 0:
       RunGit(['reset', '--hard'])
       return rtn
@@ -3321,7 +4640,7 @@ def CMDowners(parser, args):
       disable_color=options.no_color).run()
 
 
-def BuildGitDiffCmd(diff_type, upstream_commit, args, extensions):
+def BuildGitDiffCmd(diff_type, upstream_commit, args):
   """Generates a diff command."""
   # Generate diff for the current branch's changes.
   diff_cmd = ['diff', '--no-ext-diff', '--no-prefix', diff_type,
@@ -3329,22 +4648,22 @@ def BuildGitDiffCmd(diff_type, upstream_commit, args, extensions):
 
   if args:
     for arg in args:
-      if os.path.isdir(arg):
-        diff_cmd.extend(os.path.join(arg, '*' + ext) for ext in extensions)
-      elif os.path.isfile(arg):
+      if os.path.isdir(arg) or os.path.isfile(arg):
         diff_cmd.append(arg)
       else:
         DieWithError('Argument "%s" is not a file or a directory' % arg)
-  else:
-    diff_cmd.extend('*' + ext for ext in extensions)
 
   return diff_cmd
 
+def MatchingFileType(file_name, extensions):
+  """Returns true if the file name ends with one of the given extensions."""
+  return bool([ext for ext in extensions if file_name.lower().endswith(ext)])
 
 @subcommand.usage('[files or directories to diff]')
 def CMDformat(parser, args):
   """Runs auto-formatting tools (clang-format etc.) on the diff."""
   CLANG_EXTS = ['.cc', '.cpp', '.h', '.mm', '.proto', '.java']
+  GN_EXTS = ['.gn', '.gni']
   parser.add_option('--full', action='store_true',
                     help='Reformat the full content of all touched files')
   parser.add_option('--dry-run', action='store_true',
@@ -3376,75 +4695,73 @@ def CMDformat(parser, args):
     DieWithError('Could not find base commit for this branch. '
                  'Are you in detached state?')
 
-  if opts.full:
-    # Only list the names of modified files.
-    diff_type = '--name-only'
-  else:
-    # Only generate context-less patches.
-    diff_type = '-U0'
+  changed_files_cmd = BuildGitDiffCmd('--name-only', upstream_commit, args)
+  diff_output = RunGit(changed_files_cmd)
+  diff_files = diff_output.splitlines()
+  # Filter out files deleted by this CL
+  diff_files = [x for x in diff_files if os.path.isfile(x)]
 
-  diff_cmd = BuildGitDiffCmd(diff_type, upstream_commit, args, CLANG_EXTS)
-  diff_output = RunGit(diff_cmd)
+  clang_diff_files = [x for x in diff_files if MatchingFileType(x, CLANG_EXTS)]
+  python_diff_files = [x for x in diff_files if MatchingFileType(x, ['.py'])]
+  dart_diff_files = [x for x in diff_files if MatchingFileType(x, ['.dart'])]
+  gn_diff_files = [x for x in diff_files if MatchingFileType(x, GN_EXTS)]
 
   top_dir = os.path.normpath(
       RunGit(["rev-parse", "--show-toplevel"]).rstrip('\n'))
 
-  # Locate the clang-format binary in the checkout
-  try:
-    clang_format_tool = clang_format.FindClangFormatToolInChromiumTree()
-  except clang_format.NotFoundError, e:
-    DieWithError(e)
-
   # Set to 2 to signal to CheckPatchFormatted() that this patch isn't
   # formatted. This is used to block during the presubmit.
   return_value = 0
 
-  if opts.full:
-    # diff_output is a list of files to send to clang-format.
-    files = diff_output.splitlines()
-    if files:
+  if clang_diff_files:
+    # Locate the clang-format binary in the checkout
+    try:
+      clang_format_tool = clang_format.FindClangFormatToolInChromiumTree()
+    except clang_format.NotFoundError, e:
+      DieWithError(e)
+
+    if opts.full:
       cmd = [clang_format_tool]
       if not opts.dry_run and not opts.diff:
         cmd.append('-i')
-      stdout = RunCommand(cmd + files, cwd=top_dir)
+      stdout = RunCommand(cmd + clang_diff_files, cwd=top_dir)
       if opts.diff:
         sys.stdout.write(stdout)
-  else:
-    env = os.environ.copy()
-    env['PATH'] = str(os.path.dirname(clang_format_tool))
-    # diff_output is a patch to send to clang-format-diff.py
-    try:
-      script = clang_format.FindClangFormatScriptInChromiumTree(
-          'clang-format-diff.py')
-    except clang_format.NotFoundError, e:
-      DieWithError(e)
+    else:
+      env = os.environ.copy()
+      env['PATH'] = str(os.path.dirname(clang_format_tool))
+      try:
+        script = clang_format.FindClangFormatScriptInChromiumTree(
+            'clang-format-diff.py')
+      except clang_format.NotFoundError, e:
+        DieWithError(e)
 
-    cmd = [sys.executable, script, '-p0']
-    if not opts.dry_run and not opts.diff:
-      cmd.append('-i')
+      cmd = [sys.executable, script, '-p0']
+      if not opts.dry_run and not opts.diff:
+        cmd.append('-i')
 
-    stdout = RunCommand(cmd, stdin=diff_output, cwd=top_dir, env=env)
-    if opts.diff:
-      sys.stdout.write(stdout)
-    if opts.dry_run and len(stdout) > 0:
-      return_value = 2
+      diff_cmd = BuildGitDiffCmd('-U0', upstream_commit, clang_diff_files)
+      diff_output = RunGit(diff_cmd)
+
+      stdout = RunCommand(cmd, stdin=diff_output, cwd=top_dir, env=env)
+      if opts.diff:
+        sys.stdout.write(stdout)
+      if opts.dry_run and len(stdout) > 0:
+        return_value = 2
 
   # Similar code to above, but using yapf on .py files rather than clang-format
   # on C/C++ files
   if opts.python:
-    diff_cmd = BuildGitDiffCmd(diff_type, upstream_commit, args, ['.py'])
-    diff_output = RunGit(diff_cmd)
     yapf_tool = gclient_utils.FindExecutable('yapf')
     if yapf_tool is None:
       DieWithError('yapf not found in PATH')
 
     if opts.full:
-      files = diff_output.splitlines()
-      if files:
+      if python_diff_files:
         cmd = [yapf_tool]
         if not opts.dry_run and not opts.diff:
           cmd.append('-i')
-        stdout = RunCommand(cmd + files, cwd=top_dir)
+        stdout = RunCommand(cmd + python_diff_files, cwd=top_dir)
         if opts.diff:
           sys.stdout.write(stdout)
     else:
@@ -3452,29 +4769,83 @@ def CMDformat(parser, args):
       # https://github.com/google/yapf/issues/154
       DieWithError('--python currently only works with --full')
 
-  # Build a diff command that only operates on dart files. dart's formatter
-  # does not have the nice property of only operating on modified chunks, so
-  # hard code full.
-  dart_diff_cmd = BuildGitDiffCmd('--name-only', upstream_commit,
-                                  args, ['.dart'])
-  dart_diff_output = RunGit(dart_diff_cmd)
-  if dart_diff_output:
+  # Dart's formatter does not have the nice property of only operating on
+  # modified chunks, so hard code full.
+  if dart_diff_files:
     try:
       command = [dart_format.FindDartFmtToolInChromiumTree()]
       if not opts.dry_run and not opts.diff:
         command.append('-w')
-      command.extend(dart_diff_output.splitlines())
+      command.extend(dart_diff_files)
 
-      stdout = RunCommand(command, cwd=top_dir, env=env)
+      stdout = RunCommand(command, cwd=top_dir)
       if opts.dry_run and stdout:
         return_value = 2
     except dart_format.NotFoundError as e:
-      print ('Unable to check dart code formatting. Dart SDK is not in ' +
-             'this checkout.')
+      print ('Warning: Unable to check Dart code formatting. Dart SDK not ' +
+             'found in this checkout. Files in other languages are still ' +
+             'formatted.')
+
+  # Format GN build files. Always run on full build files for canonical form.
+  if gn_diff_files:
+    cmd = ['gn', 'format']
+    if not opts.dry_run and not opts.diff:
+      cmd.append('--in-place')
+    for gn_diff_file in gn_diff_files:
+      stdout = RunCommand(cmd + [gn_diff_file],
+                          shell=sys.platform == 'win32',
+                          cwd=top_dir)
+      if opts.diff:
+        sys.stdout.write(stdout)
 
   return return_value
 
 
+@subcommand.usage('<codereview url or issue id>')
+def CMDcheckout(parser, args):
+  """Checks out a branch associated with a given Rietveld or Gerrit issue."""
+  _, args = parser.parse_args(args)
+
+  if len(args) != 1:
+    parser.print_help()
+    return 1
+
+  issue_arg = ParseIssueNumberArgument(args[0])
+  if not issue_arg.valid:
+    parser.print_help()
+    return 1
+  target_issue = str(issue_arg.issue)
+
+  def find_issues(issueprefix):
+    output = RunGit(['config', '--local', '--get-regexp',
+                     r'branch\..*\.%s' % issueprefix],
+                     error_ok=True)
+    for key, issue in [x.split() for x in output.splitlines()]:
+      if issue == target_issue:
+        yield re.sub(r'branch\.(.*)\.%s' % issueprefix, r'\1', key)
+
+  branches = []
+  for cls in _CODEREVIEW_IMPLEMENTATIONS.values():
+    branches.extend(find_issues(cls.IssueSettingSuffix()))
+  if len(branches) == 0:
+    print 'No branch found for issue %s.' % target_issue
+    return 1
+  if len(branches) == 1:
+    RunGit(['checkout', branches[0]])
+  else:
+    print 'Multiple branches match issue %s:' % target_issue
+    for i in range(len(branches)):
+      print '%d: %s' % (i, branches[i])
+    which = raw_input('Choose by index: ')
+    try:
+      RunGit(['checkout', branches[int(which)]])
+    except (IndexError, ValueError):
+      print 'Invalid selection, not checking out any branch.'
+      return 1
+
+  return 0
+
+
 def CMDlol(parser, args):
   # This command is intentionally undocumented.
   print zlib.decompress(base64.b64decode(
@@ -3531,7 +4902,7 @@ if __name__ == '__main__':
   # These affect sys.stdout so do it outside of main() to simplify mocks in
   # unit testing.
   fix_encoding.fix_encoding()
-  colorama.init()
+  setup_color.init()
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt: