libv8 5.7.492.65.1 → 5.9.211.38.0beta0

data/vendor/depot_tools/gclient_eval.py

@@ -0,0 +1,284 @@
+# Copyright 2017 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.
+
+import ast
+import collections
+
+from third_party import schema
+
+
+# See https://github.com/keleshev/schema for docs how to configure schema.
+_GCLIENT_DEPS_SCHEMA = {
+    schema.Optional(basestring): schema.Or(
+        None,
+        basestring,
+        {
+            # Repo and revision to check out under the path
+            # (same as if no dict was used).
+            'url': basestring,
+
+            # Optional condition string. The dep will only be processed
+            # if the condition evaluates to True.
+            schema.Optional('condition'): basestring,
+        },
+    ),
+}
+
+_GCLIENT_HOOKS_SCHEMA = [{
+    # Hook action: list of command-line arguments to invoke.
+    'action': [basestring],
+
+    # Name of the hook. Doesn't affect operation.
+    schema.Optional('name'): basestring,
+
+    # Hook pattern (regex). Originally intended to limit some hooks to run
+    # only when files matching the pattern have changed. In practice, with git,
+    # gclient runs all the hooks regardless of this field.
+    schema.Optional('pattern'): basestring,
+
+    # Working directory where to execute the hook.
+    schema.Optional('cwd'): basestring,
+
+    # Optional condition string. The hook will only be run
+    # if the condition evaluates to True.
+    schema.Optional('condition'): basestring,
+}]
+
+_GCLIENT_SCHEMA = schema.Schema({
+    # List of host names from which dependencies are allowed (whitelist).
+    # NOTE: when not present, all hosts are allowed.
+    # NOTE: scoped to current DEPS file, not recursive.
+    schema.Optional('allowed_hosts'): [schema.Optional(basestring)],
+
+    # Mapping from paths to repo and revision to check out under that path.
+    # Applying this mapping to the on-disk checkout is the main purpose
+    # of gclient, and also why the config file is called DEPS.
+    #
+    # The following functions are allowed:
+    #
+    #   Var(): allows variable substitution (either from 'vars' dict below,
+    #          or command-line override)
+    schema.Optional('deps'): _GCLIENT_DEPS_SCHEMA,
+
+    # Similar to 'deps' (see above) - also keyed by OS (e.g. 'linux').
+    # Also see 'target_os'.
+    schema.Optional('deps_os'): {
+        schema.Optional(basestring): _GCLIENT_DEPS_SCHEMA,
+    },
+
+    # Path to GN args file to write selected variables.
+    schema.Optional('gclient_gn_args_file'): basestring,
+
+    # Subset of variables to write to the GN args file (see above).
+    schema.Optional('gclient_gn_args'): [schema.Optional(basestring)],
+
+    # Hooks executed after gclient sync (unless suppressed), or explicitly
+    # on gclient hooks. See _GCLIENT_HOOKS_SCHEMA for details.
+    # Also see 'pre_deps_hooks'.
+    schema.Optional('hooks'): _GCLIENT_HOOKS_SCHEMA,
+
+    # Similar to 'hooks', also keyed by OS.
+    schema.Optional('hooks_os'): {
+        schema.Optional(basestring): _GCLIENT_HOOKS_SCHEMA
+    },
+
+    # Rules which #includes are allowed in the directory.
+    # Also see 'skip_child_includes' and 'specific_include_rules'.
+    schema.Optional('include_rules'): [schema.Optional(basestring)],
+
+    # Hooks executed before processing DEPS. See 'hooks' for more details.
+    schema.Optional('pre_deps_hooks'): _GCLIENT_HOOKS_SCHEMA,
+
+    # Recursion limit for nested DEPS.
+    schema.Optional('recursion'): int,
+
+    # Whitelists deps for which recursion should be enabled.
+    schema.Optional('recursedeps'): [
+        schema.Optional(schema.Or(
+            basestring,
+            (basestring, basestring),
+            [basestring, basestring]
+        )),
+    ],
+
+    # Blacklists directories for checking 'include_rules'.
+    schema.Optional('skip_child_includes'): [schema.Optional(basestring)],
+
+    # Mapping from paths to include rules specific for that path.
+    # See 'include_rules' for more details.
+    schema.Optional('specific_include_rules'): {
+        schema.Optional(basestring): [basestring]
+    },
+
+    # List of additional OS names to consider when selecting dependencies
+    # from deps_os.
+    schema.Optional('target_os'): [schema.Optional(basestring)],
+
+    # For recursed-upon sub-dependencies, check out their own dependencies
+    # relative to the paren't path, rather than relative to the .gclient file.
+    schema.Optional('use_relative_paths'): bool,
+
+    # Variables that can be referenced using Var() - see 'deps'.
+    schema.Optional('vars'): {schema.Optional(basestring): basestring},
+})
+
+
+def _gclient_eval(node_or_string, global_scope, filename='<unknown>'):
+  """Safely evaluates a single expression. Returns the result."""
+  _allowed_names = {'None': None, 'True': True, 'False': False}
+  if isinstance(node_or_string, basestring):
+    node_or_string = ast.parse(node_or_string, filename=filename, mode='eval')
+  if isinstance(node_or_string, ast.Expression):
+    node_or_string = node_or_string.body
+  def _convert(node):
+    if isinstance(node, ast.Str):
+      return node.s
+    elif isinstance(node, ast.Num):
+      return node.n
+    elif isinstance(node, ast.Tuple):
+      return tuple(map(_convert, node.elts))
+    elif isinstance(node, ast.List):
+      return list(map(_convert, node.elts))
+    elif isinstance(node, ast.Dict):
+      return collections.OrderedDict(
+          (_convert(k), _convert(v))
+          for k, v in zip(node.keys, node.values))
+    elif isinstance(node, ast.Name):
+      if node.id not in _allowed_names:
+        raise ValueError(
+            'invalid name %r (file %r, line %s)' % (
+                node.id, filename, getattr(node, 'lineno', '<unknown>')))
+      return _allowed_names[node.id]
+    elif isinstance(node, ast.Call):
+      if not isinstance(node.func, ast.Name):
+        raise ValueError(
+            'invalid call: func should be a name (file %r, line %s)' % (
+                filename, getattr(node, 'lineno', '<unknown>')))
+      if node.keywords or node.starargs or node.kwargs:
+        raise ValueError(
+            'invalid call: use only regular args (file %r, line %s)' % (
+                filename, getattr(node, 'lineno', '<unknown>')))
+      args = map(_convert, node.args)
+      return global_scope[node.func.id](*args)
+    elif isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
+      return _convert(node.left) + _convert(node.right)
+    elif isinstance(node, ast.BinOp) and isinstance(node.op, ast.Mod):
+      return _convert(node.left) % _convert(node.right)
+    else:
+      raise ValueError(
+          'unexpected AST node: %s %s (file %r, line %s)' % (
+              node, ast.dump(node), filename,
+              getattr(node, 'lineno', '<unknown>')))
+  return _convert(node_or_string)
+
+
+def Exec(content, global_scope, local_scope, filename='<unknown>'):
+  """Safely execs a set of assignments. Mutates |local_scope|."""
+  node_or_string = ast.parse(content, filename=filename, mode='exec')
+  if isinstance(node_or_string, ast.Expression):
+    node_or_string = node_or_string.body
+
+  def _visit_in_module(node):
+    if isinstance(node, ast.Assign):
+      if len(node.targets) != 1:
+        raise ValueError(
+            'invalid assignment: use exactly one target (file %r, line %s)' % (
+                filename, getattr(node, 'lineno', '<unknown>')))
+      target = node.targets[0]
+      if not isinstance(target, ast.Name):
+        raise ValueError(
+            'invalid assignment: target should be a name (file %r, line %s)' % (
+                filename, getattr(node, 'lineno', '<unknown>')))
+      value = _gclient_eval(node.value, global_scope, filename=filename)
+
+      if target.id in local_scope:
+        raise ValueError(
+            'invalid assignment: overrides var %r (file %r, line %s)' % (
+                target.id, filename, getattr(node, 'lineno', '<unknown>')))
+
+      local_scope[target.id] = value
+    else:
+      raise ValueError(
+          'unexpected AST node: %s %s (file %r, line %s)' % (
+              node, ast.dump(node), filename,
+              getattr(node, 'lineno', '<unknown>')))
+
+  if isinstance(node_or_string, ast.Module):
+    for stmt in node_or_string.body:
+      _visit_in_module(stmt)
+  else:
+    raise ValueError(
+        'unexpected AST node: %s %s (file %r, line %s)' % (
+            node_or_string,
+            ast.dump(node_or_string),
+            filename,
+            getattr(node_or_string, 'lineno', '<unknown>')))
+
+  _GCLIENT_SCHEMA.validate(local_scope)
+
+
+def EvaluateCondition(condition, variables, referenced_variables=None):
+  """Safely evaluates a boolean condition. Returns the result."""
+  if not referenced_variables:
+    referenced_variables = set()
+  _allowed_names = {'None': None, 'True': True, 'False': False}
+  main_node = ast.parse(condition, mode='eval')
+  if isinstance(main_node, ast.Expression):
+    main_node = main_node.body
+  def _convert(node):
+    if isinstance(node, ast.Str):
+      return node.s
+    elif isinstance(node, ast.Name):
+      if node.id in referenced_variables:
+        raise ValueError(
+            'invalid cyclic reference to %r (inside %r)' % (
+                node.id, condition))
+      elif node.id in _allowed_names:
+        return _allowed_names[node.id]
+      elif node.id in variables:
+        return EvaluateCondition(
+            variables[node.id],
+            variables,
+            referenced_variables.union([node.id]))
+      else:
+        raise ValueError(
+            'invalid name %r (inside %r)' % (node.id, condition))
+    elif isinstance(node, ast.BoolOp) and isinstance(node.op, ast.Or):
+      if len(node.values) != 2:
+        raise ValueError(
+            'invalid "or": exactly 2 operands required (inside %r)' % (
+                condition))
+      return _convert(node.values[0]) or _convert(node.values[1])
+    elif isinstance(node, ast.BoolOp) and isinstance(node.op, ast.And):
+      if len(node.values) != 2:
+        raise ValueError(
+            'invalid "and": exactly 2 operands required (inside %r)' % (
+                condition))
+      return _convert(node.values[0]) and _convert(node.values[1])
+    elif isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
+      return not _convert(node.operand)
+    elif isinstance(node, ast.Compare):
+      if len(node.ops) != 1:
+        raise ValueError(
+            'invalid compare: exactly 1 operator required (inside %r)' % (
+                condition))
+      if len(node.comparators) != 1:
+        raise ValueError(
+            'invalid compare: exactly 1 comparator required (inside %r)' % (
+                condition))
+
+      left = _convert(node.left)
+      right = _convert(node.comparators[0])
+
+      if isinstance(node.ops[0], ast.Eq):
+        return left == right
+
+      raise ValueError(
+          'unexpected operator: %s %s (inside %r)' % (
+              node.ops[0], ast.dump(node), condition))
+    else:
+      raise ValueError(
+          'unexpected AST node: %s %s (inside %r)' % (
+              node, ast.dump(node), condition))
+  return _convert(main_node)

data/vendor/depot_tools/gclient_utils.py

@@ -5,10 +5,12 @@
 """Generic utils."""
 
 import codecs
+import collections
 import contextlib
 import cStringIO
 import datetime
 import logging
+import operator
 import os
 import pipes
 import platform
@@ -611,8 +613,9 @@ def FindGclientRoot(from_dir, filename='.gclient'):
       # might have failed. In that case, we cannot verify that the .gclient
       # is the one we want to use. In order to not to cause too much trouble,
       # just issue a warning and return the path anyway.
-      print >> sys.stderr, ("%s file in parent directory %s might not be the "
-          "file you want to use" % (filename, path))
+      print >> sys.stderr, ("%s missing, %s file in parent directory %s might "
+          "not be the file you want to use." %
+          (entries_filename, filename, path))
       return path
     scope = {}
     try:
@@ -813,8 +816,7 @@ class ExecutionQueue(object):
   """Runs a set of WorkItem that have interdependencies and were WorkItem are
   added as they are processed.
 
-  In gclient's case, Dependencies sometime needs to be run out of order due to
-  From() keyword. This class manages that all the required dependencies are run
+  This class manages that all the required dependencies are run
   before running each one.
 
   Methods of this class are thread safe.
@@ -1237,3 +1239,67 @@ def FindExecutable(executable):
         if os.path.isfile(alt_target) and os.access(alt_target, os.X_OK):
           return alt_target
   return None
+
+
+def freeze(obj):
+  """Takes a generic object ``obj``, and returns an immutable version of it.
+
+  Supported types:
+    * dict / OrderedDict -> FrozenDict
+    * list -> tuple
+    * set -> frozenset
+    * any object with a working __hash__ implementation (assumes that hashable
+      means immutable)
+
+  Will raise TypeError if you pass an object which is not hashable.
+  """
+  if isinstance(obj, dict):
+    return FrozenDict((freeze(k), freeze(v)) for k, v in obj.iteritems())
+  elif isinstance(obj, (list, tuple)):
+    return tuple(freeze(i) for i in obj)
+  elif isinstance(obj, set):
+    return frozenset(freeze(i) for i in obj)
+  else:
+    hash(obj)
+    return obj
+
+
+class FrozenDict(collections.Mapping):
+  """An immutable OrderedDict.
+
+  Modified From: http://stackoverflow.com/a/2704866
+  """
+  def __init__(self, *args, **kwargs):
+    self._d = collections.OrderedDict(*args, **kwargs)
+
+    # Calculate the hash immediately so that we know all the items are
+    # hashable too.
+    self._hash = reduce(operator.xor,
+                        (hash(i) for i in enumerate(self._d.iteritems())), 0)
+
+  def __eq__(self, other):
+    if not isinstance(other, collections.Mapping):
+      return NotImplemented
+    if self is other:
+      return True
+    if len(self) != len(other):
+      return False
+    for k, v in self.iteritems():
+      if k not in other or other[k] != v:
+        return False
+    return True
+
+  def __iter__(self):
+    return iter(self._d)
+
+  def __len__(self):
+    return len(self._d)
+
+  def __getitem__(self, key):
+    return self._d[key]
+
+  def __hash__(self):
+    return self._hash
+
+  def __repr__(self):
+    return 'FrozenDict(%r)' % (self._d.items(),)

data/vendor/depot_tools/gerrit_client.py

@@ -63,6 +63,31 @@ def CMDbranch(parser, args):
   write_result(result, opt)
 
 
+@subcommand.usage('[args ...]')
+def CMDchanges(parser, args):
+  parser.add_option('-p', '--param', dest='params', action='append',
+                    help='repeatable query parameter, format: -p key=value')
+  parser.add_option('-o', '--o-param', dest='o_params', action='append',
+                    help='gerrit output parameters, e.g. ALL_REVISIONS')
+  parser.add_option('--limit', dest='limit', type=int,
+                    help='maximum number of results to return')
+  parser.add_option('--start', dest='start', type=int,
+                    help='how many changes to skip '
+                         '(starting with the most recent)')
+
+  (opt, args) = parser.parse_args(args)
+
+  result = gerrit_util.QueryChanges(
+      urlparse.urlparse(opt.host).netloc,
+      list(tuple(p.split('=', 1)) for p in opt.params),
+      start=opt.start,        # Default: None
+      limit=opt.limit,        # Default: None
+      o_params=opt.o_params,  # Default: None
+  )
+  logging.info('Change query returned %d changes.', len(result))
+  write_result(result, opt)
+
+
 class OptionParser(optparse.OptionParser):
   """Creates the option parse and add --verbose support."""
   def __init__(self, *args, **kwargs):
@@ -102,4 +127,4 @@ if __name__ == '__main__':
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
-    sys.exit(1)
+    sys.exit(1)

data/vendor/depot_tools/gerrit_util.py

@@ -50,13 +50,13 @@ class GerritAuthenticationError(GerritError):
   """Exception class for authentication errors during Gerrit communication."""
 
 
-def _QueryString(param_dict, first_param=None):
+def _QueryString(params, first_param=None):
   """Encodes query parameters in the key:val[+key:val...] format specified here:
 
   https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#list-changes
   """
   q = [urllib.quote(first_param)] if first_param else []
-  q.extend(['%s:%s' % (key, val) for key, val in param_dict.iteritems()])
+  q.extend(['%s:%s' % (key, val) for key, val in params])
   return '+'.join(q)
 
 
@@ -98,6 +98,15 @@ class CookiesAuthenticator(Authenticator):
     self.netrc = self._get_netrc()
     self.gitcookies = self._get_gitcookies()
 
+  @classmethod
+  def get_new_password_url(cls, host):
+    assert not host.startswith('http')
+    # Assume *.googlesource.com pattern.
+    parts = host.split('.')
+    if not parts[0].endswith('-review'):
+      parts[0] += '-review'
+    return 'https://%s/new-password' % ('.'.join(parts))
+
   @classmethod
   def get_new_password_message(cls, host):
     assert not host.startswith('http')
@@ -323,18 +332,15 @@ def CreateHttpConn(host, path, reqtype='GET', headers=None, body=None):
   return conn
 
 
-def ReadHttpResponse(conn, expect_status=200, ignore_404=True):
+def ReadHttpResponse(conn, accept_statuses=frozenset([200])):
   """Reads an http response from a connection into a string buffer.
 
   Args:
     conn: An Http object created by CreateHttpConn above.
-    expect_status: Success is indicated by this status in the response.
-    ignore_404: For many requests, gerrit-on-borg will return 404 if the request
-                doesn't match the database contents.  In most such cases, we
-                want the API to return None rather than raise an Exception.
+    accept_statuses: Treat any of these statuses as success. Default: [200]
+                     Common additions include 204, 400, and 404.
   Returns: A string buffer containing the connection's reply.
   """
-
   sleep_time = 0.5
   for idx in range(TRY_LIMIT):
     response, contents = conn.request(**conn.req_params)
@@ -345,12 +351,14 @@ def ReadHttpResponse(conn, expect_status=200, ignore_404=True):
         www_authenticate):
       auth_match = re.search('realm="([^"]+)"', www_authenticate, re.I)
       host = auth_match.group(1) if auth_match else conn.req_host
-      reason = ('Authentication failed. Please make sure your .netrc file '
+      reason = ('Authentication failed. Please make sure your .gitcookies file '
                 'has credentials for %s' % host)
       raise GerritAuthenticationError(response.status, reason)
 
     # If response.status < 500 then the result is final; break retry loop.
-    if response.status < 500:
+    # If the response is 404, it might be because of replication lag, so
+    # keep trying anyway.
+    if response.status < 500 and response.status != 404:
       LOGGER.debug('got response %d for %s %s', response.status,
                    conn.req_params['method'], conn.req_params['uri'])
       break
@@ -359,24 +367,25 @@ def ReadHttpResponse(conn, expect_status=200, ignore_404=True):
     LOGGER.warn('A transient error occurred while querying %s:\n'
                 '%s %s %s\n'
                 '%s %d %s',
-                conn.host, conn.req_params['method'], conn.req_params['uri'],
+                conn.req_host, conn.req_params['method'],
+                conn.req_params['uri'],
                 http_version, http_version, response.status, response.reason)
     if TRY_LIMIT - idx > 1:
       LOGGER.warn('... will retry %d more times.', TRY_LIMIT - idx - 1)
       time.sleep(sleep_time)
       sleep_time = sleep_time * 2
-  if ignore_404 and response.status == 404:
-    return StringIO()
-  if response.status != expect_status:
+  if response.status not in accept_statuses:
+    if response.status in (401, 403):
+      print('Your Gerrit credentials might be misconfigured. Try: \n'
+            '  git cl creds-check')
     reason = '%s: %s' % (response.reason, contents)
     raise GerritError(response.status, reason)
   return StringIO(contents)
 
 
-def ReadHttpJsonResponse(conn, expect_status=200, ignore_404=True):
+def ReadHttpJsonResponse(conn, accept_statuses=frozenset([200])):
   """Parses an https response as json."""
-  fh = ReadHttpResponse(
-      conn, expect_status=expect_status, ignore_404=ignore_404)
+  fh = ReadHttpResponse(conn, accept_statuses)
   # The first line of the response should always be: )]}'
   s = fh.readline()
   if s and s.rstrip() != ")]}'":
@@ -387,14 +396,15 @@ def ReadHttpJsonResponse(conn, expect_status=200, ignore_404=True):
   return json.loads(s)
 
 
-def QueryChanges(host, param_dict, first_param=None, limit=None, o_params=None,
+def QueryChanges(host, params, first_param=None, limit=None, o_params=None,
                  start=None):
   """
   Queries a gerrit-on-borg server for changes matching query terms.
 
   Args:
-    param_dict: A dictionary of search parameters, as documented here:
-        http://gerrit-documentation.googlecode.com/svn/Documentation/2.6/user-search.html
+    params: A list of key:value pairs for search parameters, as documented
+        here (e.g. ('is', 'owner') for a parameter 'is:owner'):
+        https://gerrit-review.googlesource.com/Documentation/user-search.html#search-operators
     first_param: A change identifier
     limit: Maximum number of results to return.
     start: how many changes to skip (starting with the most recent)
@@ -404,20 +414,19 @@ def QueryChanges(host, param_dict, first_param=None, limit=None, o_params=None,
     A list of json-decoded query results.
   """
   # Note that no attempt is made to escape special characters; YMMV.
-  if not param_dict and not first_param:
+  if not params and not first_param:
     raise RuntimeError('QueryChanges requires search parameters')
-  path = 'changes/?q=%s' % _QueryString(param_dict, first_param)
+  path = 'changes/?q=%s' % _QueryString(params, first_param)
   if start:
     path = '%s&start=%s' % (path, start)
   if limit:
     path = '%s&n=%d' % (path, limit)
   if o_params:
     path = '%s&%s' % (path, '&'.join(['o=%s' % p for p in o_params]))
-  # Don't ignore 404; a query should always return a list, even if it's empty.
-  return ReadHttpJsonResponse(CreateHttpConn(host, path), ignore_404=False)
+  return ReadHttpJsonResponse(CreateHttpConn(host, path))
 
 
-def GenerateAllChanges(host, param_dict, first_param=None, limit=500,
+def GenerateAllChanges(host, params, first_param=None, limit=500,
                        o_params=None, start=None):
   """
   Queries a gerrit-on-borg server for all the changes matching the query terms.
@@ -430,7 +439,7 @@ def GenerateAllChanges(host, param_dict, first_param=None, limit=500,
   limit.
 
   Args:
-    param_dict, first_param: Refer to QueryChanges().
+    params, first_param: Refer to QueryChanges().
     limit: Maximum number of requested changes per query.
     o_params: Refer to QueryChanges().
     start: Refer to QueryChanges().
@@ -458,7 +467,7 @@ def GenerateAllChanges(host, param_dict, first_param=None, limit=500,
     #   > E get's updated. New order: EABCDFGH
     #   query[3..6] => CDF   # C is a dup
     #   query[6..9] => GH    # E is missed.
-    page = QueryChanges(host, param_dict, first_param, limit, o_params,
+    page = QueryChanges(host, params, first_param, limit, o_params,
                         cur_start)
     for cl in at_most_once(page):
       yield cl
@@ -475,20 +484,20 @@ def GenerateAllChanges(host, param_dict, first_param=None, limit=500,
   # If we paged through, query again the first page which in most circumstances
   # will fetch all changes that were modified while this function was run.
   if start != cur_start:
-    page = QueryChanges(host, param_dict, first_param, limit, o_params, start)
+    page = QueryChanges(host, params, first_param, limit, o_params, start)
     for cl in at_most_once(page):
       yield cl
 
 
-def MultiQueryChanges(host, param_dict, change_list, limit=None, o_params=None,
+def MultiQueryChanges(host, params, change_list, limit=None, o_params=None,
                       start=None):
   """Initiate a query composed of multiple sets of query parameters."""
   if not change_list:
     raise RuntimeError(
         "MultiQueryChanges requires a list of change numbers/id's")
   q = ['q=%s' % '+OR+'.join([urllib.quote(str(x)) for x in change_list])]
-  if param_dict:
-    q.append(_QueryString(param_dict))
+  if params:
+    q.append(_QueryString(params))
   if limit:
     q.append('n=%d' % limit)
   if start:
@@ -497,7 +506,7 @@ def MultiQueryChanges(host, param_dict, change_list, limit=None, o_params=None,
     q.extend(['o=%s' % p for p in o_params])
   path = 'changes/?%s' % '&'.join(q)
   try:
-    result = ReadHttpJsonResponse(CreateHttpConn(host, path), ignore_404=False)
+    result = ReadHttpJsonResponse(CreateHttpConn(host, path))
   except GerritError as e:
     msg = '%s:\n%s' % (e.message, path)
     raise GerritError(e.http_status, msg)
@@ -525,13 +534,12 @@ def GetChange(host, change):
   return ReadHttpJsonResponse(CreateHttpConn(host, path))
 
 
-def GetChangeDetail(host, change, o_params=None, ignore_404=True):
+def GetChangeDetail(host, change, o_params=None):
   """Query a gerrit server for extended information about a single change."""
-  # TODO(tandrii): cahnge ignore_404 to False by default.
   path = 'changes/%s/detail' % change
   if o_params:
     path += '?%s' % '&'.join(['o=%s' % p for p in o_params])
-  return ReadHttpJsonResponse(CreateHttpConn(host, path), ignore_404=ignore_404)
+  return ReadHttpJsonResponse(CreateHttpConn(host, path))
 
 
 def GetChangeCommit(host, change, revision='current'):
@@ -542,12 +550,12 @@ def GetChangeCommit(host, change, revision='current'):
 
 def GetChangeCurrentRevision(host, change):
   """Get information about the latest revision for a given change."""
-  return QueryChanges(host, {}, change, o_params=('CURRENT_REVISION',))
+  return QueryChanges(host, [], change, o_params=('CURRENT_REVISION',))
 
 
 def GetChangeRevisions(host, change):
   """Get information about all revisions associated with a change."""
-  return QueryChanges(host, {}, change, o_params=('ALL_REVISIONS',))
+  return QueryChanges(host, [], change, o_params=('ALL_REVISIONS',))
 
 
 def GetChangeReview(host, change, revision=None):
@@ -563,12 +571,18 @@ def GetChangeReview(host, change, revision=None):
   return ReadHttpJsonResponse(CreateHttpConn(host, path))
 
 
+def GetChangeComments(host, change):
+  """Get the line- and file-level comments on a change."""
+  path = 'changes/%s/comments' % change
+  return ReadHttpJsonResponse(CreateHttpConn(host, path))
+
+
 def AbandonChange(host, change, msg=''):
   """Abandon a gerrit change."""
   path = 'changes/%s/abandon' % change
   body = {'message': msg} if msg else {}
   conn = CreateHttpConn(host, path, reqtype='POST', body=body)
-  return ReadHttpJsonResponse(conn, ignore_404=False)
+  return ReadHttpJsonResponse(conn)
 
 
 def RestoreChange(host, change, msg=''):
@@ -576,7 +590,7 @@ def RestoreChange(host, change, msg=''):
   path = 'changes/%s/restore' % change
   body = {'message': msg} if msg else {}
   conn = CreateHttpConn(host, path, reqtype='POST', body=body)
-  return ReadHttpJsonResponse(conn, ignore_404=False)
+  return ReadHttpJsonResponse(conn)
 
 
 def SubmitChange(host, change, wait_for_merge=True):
@@ -584,75 +598,41 @@ def SubmitChange(host, change, wait_for_merge=True):
   path = 'changes/%s/submit' % change
   body = {'wait_for_merge': wait_for_merge}
   conn = CreateHttpConn(host, path, reqtype='POST', body=body)
-  return ReadHttpJsonResponse(conn, ignore_404=False)
+  return ReadHttpJsonResponse(conn)
 
 
 def HasPendingChangeEdit(host, change):
   conn = CreateHttpConn(host, 'changes/%s/edit' % change)
   try:
-    ReadHttpResponse(conn, ignore_404=False)
+    ReadHttpResponse(conn)
   except GerritError as e:
-    # On success, gerrit returns status 204; anything else is an error.
-    if e.http_status != 204:
-      raise
-    return False
-  else:
-    return True
+    # 204 No Content means no pending change.
+    if e.http_status == 204:
+      return False
+    raise
+  return True
 
 
 def DeletePendingChangeEdit(host, change):
   conn = CreateHttpConn(host, 'changes/%s/edit' % change, reqtype='DELETE')
-  try:
-    ReadHttpResponse(conn, ignore_404=False)
-  except GerritError as e:
-    # On success, gerrit returns status 204; if the edit was already deleted it
-    # returns 404.  Anything else is an error.
-    if e.http_status not in (204, 404):
-      raise
+  # On success, gerrit returns status 204; if the edit was already deleted it
+  # returns 404.  Anything else is an error.
+  ReadHttpResponse(conn, accept_statuses=[204, 404])
 
 
 def SetCommitMessage(host, change, description, notify='ALL'):
   """Updates a commit message."""
+  assert notify in ('ALL', 'NONE')
+  path = 'changes/%s/message' % change
+  body = {'message': description}
+  conn = CreateHttpConn(host, path, reqtype='PUT', body=body)
   try:
-    assert notify in ('ALL', 'NONE')
-    # First, edit the commit message in a draft.
-    path = 'changes/%s/edit:message' % change
-    body = {'message': description}
-    conn = CreateHttpConn(host, path, reqtype='PUT', body=body)
-    try:
-      ReadHttpResponse(conn, ignore_404=False)
-    except GerritError as e:
-      # On success, gerrit returns status 204; anything else is an error.
-      if e.http_status != 204:
-        raise
-    else:
-      raise GerritError(
-          'Unexpectedly received a 200 http status while editing message in '
-          'change %s' % change)
-
-    # And then publish it.
-    path = 'changes/%s/edit:publish' % change
-    conn = CreateHttpConn(host, path, reqtype='POST', body={'notify': notify})
-    try:
-      ReadHttpResponse(conn, ignore_404=False)
-    except GerritError as e:
-      # On success, gerrit returns status 204; anything else is an error.
-      if e.http_status != 204:
-        raise
-    else:
-      raise GerritError(
-          'Unexpectedly received a 200 http status while publishing message '
-          'change in %s' % change)
-  except (GerritError, KeyboardInterrupt) as e:
-    # Something went wrong with one of the two calls, so we want to clean up
-    # after ourselves before returning.
-    try:
-      DeletePendingChangeEdit(host, change)
-    except GerritError:
-      LOGGER.error('Encountered error while cleaning up after failed attempt '
-                   'to set the CL description. You may have to delete the '
-                   'pending change edit yourself in the web UI.')
-    raise e
+    ReadHttpResponse(conn, accept_statuses=[200, 204])
+  except GerritError as e:
+    raise GerritError(
+        e.http_status,
+        'Received unexpected http status while editing message '
+        'in change %s' % change)
 
 
 def GetReviewers(host, change):
@@ -667,32 +647,46 @@ def GetReview(host, change, revision):
   return ReadHttpJsonResponse(CreateHttpConn(host, path))
 
 
-def AddReviewers(host, change, add=None, is_reviewer=True, notify=True):
+def AddReviewers(host, change, reviewers=None, ccs=None, notify=True,
+                 accept_statuses=frozenset([200, 400, 422])):
   """Add reviewers to a change."""
-  errors = None
-  if not add:
+  if not reviewers and not ccs:
     return None
-  if isinstance(add, basestring):
-    add = (add,)
-  path = 'changes/%s/reviewers' % change
-  for r in add:
-    state = 'REVIEWER' if is_reviewer else 'CC'
-    notify = 'ALL' if notify else 'NONE'
-    body = {
-      'reviewer': r,
-      'state': state,
-      'notify': notify,
-    }
-    try:
-      conn = CreateHttpConn(host, path, reqtype='POST', body=body)
-      _ = ReadHttpJsonResponse(conn, ignore_404=False)
-    except GerritError as e:
-      if e.http_status == 422:  # "Unprocessable Entity"
-        LOGGER.warn('Note: "%s" not added as a %s' % (r, state.lower()))
-        errors = True
-      else:
-        raise
-  return errors
+  if not change:
+    return None
+  reviewers = frozenset(reviewers or [])
+  ccs = frozenset(ccs or [])
+  path = 'changes/%s/revisions/current/review' % change
+
+  body = {
+    'reviewers': [],
+    'notify': 'ALL' if notify else 'NONE',
+  }
+  for r in sorted(reviewers | ccs):
+    state = 'REVIEWER' if r in reviewers else 'CC'
+    body['reviewers'].append({
+     'reviewer': r,
+     'state': state,
+     'notify': 'NONE',  # We handled `notify` argument above.
+   })
+
+  conn = CreateHttpConn(host, path, reqtype='POST', body=body)
+  # Gerrit will return 400 if one or more of the requested reviewers are
+  # unprocessable. We read the response object to see which were rejected,
+  # warn about them, and retry with the remainder.
+  resp = ReadHttpJsonResponse(conn, accept_statuses=accept_statuses)
+
+  errored = set()
+  for result in resp.get('reviewers', {}).itervalues():
+    r = result.get('input')
+    state = 'REVIEWER' if r in reviewers else 'CC'
+    if result.get('error'):
+      errored.add(r)
+      LOGGER.warn('Note: "%s" not added as a %s' % (r, state.lower()))
+  if errored:
+    # Try again, adding only those that didn't fail, and only accepting 200.
+    AddReviewers(host, change, reviewers=(reviewers-errored),
+                 ccs=(ccs-errored), notify=notify, accept_statuses=[200])
 
 
 def RemoveReviewers(host, change, remove=None):
@@ -705,18 +699,15 @@ def RemoveReviewers(host, change, remove=None):
     path = 'changes/%s/reviewers/%s' % (change, r)
     conn = CreateHttpConn(host, path, reqtype='DELETE')
     try:
-      ReadHttpResponse(conn, ignore_404=False)
+      ReadHttpResponse(conn, accept_statuses=[204])
     except GerritError as e:
-      # On success, gerrit returns status 204; anything else is an error.
-      if e.http_status != 204:
-        raise
-    else:
       raise GerritError(
-          'Unexpectedly received a 200 http status while deleting reviewer "%s"'
-          ' from change %s' % (r, change))
+          e.http_status,
+          'Received unexpected http status while deleting reviewer "%s" '
+          'from change %s' % (r, change))
 
 
-def SetReview(host, change, msg=None, labels=None, notify=None):
+def SetReview(host, change, msg=None, labels=None, notify=None, ready=None):
   """Set labels and/or add a message to a code review."""
   if not msg and not labels:
     return
@@ -727,7 +718,9 @@ def SetReview(host, change, msg=None, labels=None, notify=None):
   if labels:
     body['labels'] = labels
   if notify:
-    body['notify'] = notify
+    body['notify'] = 'ALL' if notify else 'NONE'
+  if ready:
+    body['ready'] = True
   conn = CreateHttpConn(host, path, reqtype='POST', body=body)
   response = ReadHttpJsonResponse(conn)
   if labels:
@@ -794,7 +787,7 @@ def CreateGerritBranch(host, project, branch, commit):
   path = 'projects/%s/branches/%s' % (project, branch)
   body = {'revision': commit}
   conn = CreateHttpConn(host, path, reqtype='PUT', body=body)
-  response = ReadHttpJsonResponse(conn)
+  response = ReadHttpJsonResponse(conn, accept_statuses=[201])
   if response:
     return response
   raise GerritError(200, 'Unable to create gerrit branch')