libv8 5.7.492.65.1 → 5.9.211.38.0beta0

data/vendor/depot_tools/gclient.bat

@@ -4,11 +4,12 @@
 :: found in the LICENSE file.
 setlocal
 
-:: This is required with cygwin only.
-PATH=%~dp0;%PATH%
-
 :: Synchronize the root directory before deferring control back to gclient.py.
 call "%~dp0update_depot_tools.bat" %*
 
+:: Ensure that "depot_tools" is somewhere in PATH so this tool can be used
+:: standalone, but allow other PATH manipulations to take priority.
+set PATH=%PATH%;%~dp0
+
 :: Defer control.
-"%~dp0python" "%~dp0gclient.py" %*
+python "%~dp0gclient.py" %*

data/vendor/depot_tools/gclient.py

@@ -64,7 +64,7 @@
 # Specifying a target OS
 #   An optional key named "target_os" may be added to a gclient file to specify
 #   one or more additional operating systems that should be considered when
-#   processing the deps_os dict of a DEPS file.
+#   processing the deps_os/hooks_os dict of a DEPS file.
 #
 #   Example:
 #     target_os = [ "android" ]
@@ -80,7 +80,7 @@ from __future__ import print_function
 
 __version__ = '0.7'
 
-import ast
+import collections
 import copy
 import json
 import logging
@@ -96,6 +96,7 @@ import urllib
 import urlparse
 
 import fix_encoding
+import gclient_eval
 import gclient_scm
 import gclient_utils
 import git_cache
@@ -104,75 +105,123 @@ import subcommand
 import subprocess2
 import setup_color
 
-CHROMIUM_SRC_URL = 'https://chromium.googlesource.com/chromium/src.git'
-
-
-def ast_dict_index(dnode, key):
-  """Search an ast.Dict for the argument key, and return its index."""
-  idx = [i for i in range(len(dnode.keys)) if (
-      type(dnode.keys[i]) is ast.Str and dnode.keys[i].s == key)]
-  if not idx:
-    return -1
-  elif len(idx) > 1:
-    raise gclient_utils.Error('Multiple dict entries with same key in AST')
-  return idx[-1]
-
-def ast2str(node, indent=0):
-  """Return a pretty-printed rendition of an ast.Node."""
-  t = type(node)
-  if t is ast.Module:
-    return '\n'.join([ast2str(x, indent) for x in node.body])
-  elif t is ast.Assign:
-    return (('  ' * indent) +
-            ' = '.join([ast2str(x) for x in node.targets] +
-                       [ast2str(node.value, indent)]) + '\n')
-  elif t is ast.Name:
-    return node.id
-  elif t is ast.List:
-    if not node.elts:
-      return '[]'
-    elif len(node.elts) == 1:
-      return '[' + ast2str(node.elts[0], indent) + ']'
-    return ('[\n' + ('  ' * (indent + 1)) +
-            (',\n' + ('  ' * (indent + 1))).join(
-                [ast2str(x, indent + 1) for x in node.elts]) +
-            '\n' + ('  ' * indent) + ']')
-  elif t is ast.Dict:
-    if not node.keys:
-      return '{}'
-    elif len(node.keys) == 1:
-      return '{%s: %s}' % (ast2str(node.keys[0]),
-                           ast2str(node.values[0], indent + 1))
-    return ('{\n' + ('  ' * (indent + 1)) +
-            (',\n' + ('  ' * (indent + 1))).join(
-                ['%s: %s' % (ast2str(node.keys[i]),
-                             ast2str(node.values[i], indent + 1))
-                 for i in range(len(node.keys))]) +
-            '\n' + ('  ' * indent) + '}')
-  elif t is ast.Str:
-    return "'%s'" % node.s
-  else:
-    raise gclient_utils.Error("Unexpected AST node at line %d, column %d: %s"
-                              % (node.lineno, node.col_offset, t))
 
+class GNException(Exception):
+  pass
 
-class GClientKeywords(object):
-  class FromImpl(object):
-    """Used to implement the From() syntax."""
 
-    def __init__(self, module_name, sub_target_name=None):
-      """module_name is the dep module we want to include from.  It can also be
-      the name of a subdirectory to include from.
+def ToGNString(value, allow_dicts = True):
+  """Returns a stringified GN equivalent of the Python value.
+
+  allow_dicts indicates if this function will allow converting dictionaries
+  to GN scopes. This is only possible at the top level, you can't nest a
+  GN scope in a list, so this should be set to False for recursive calls."""
+  if isinstance(value, basestring):
+    if value.find('\n') >= 0:
+      raise GNException("Trying to print a string with a newline in it.")
+    return '"' + \
+        value.replace('\\', '\\\\').replace('"', '\\"').replace('$', '\\$') + \
+        '"'
+
+  if isinstance(value, unicode):
+    return ToGNString(value.encode('utf-8'))
+
+  if isinstance(value, bool):
+    if value:
+      return "true"
+    return "false"
+
+  # NOTE: some type handling removed compared to chromium/src copy.
+
+  raise GNException("Unsupported type when printing to GN.")
+
+
+class Hook(object):
+  """Descriptor of command ran before/after sync or on demand."""
+
+  def __init__(self, action, pattern=None, name=None, cwd=None, condition=None,
+               variables=None):
+    """Constructor.
+
+    Arguments:
+      action (list of basestring): argv of the command to run
+      pattern (basestring regex): noop with git; deprecated
+      name (basestring): optional name; no effect on operation
+      cwd (basestring): working directory to use
+      condition (basestring): condition when to run the hook
+      variables (dict): variables for evaluating the condition
+    """
+    self._action = gclient_utils.freeze(action)
+    self._pattern = pattern
+    self._name = name
+    self._cwd = cwd
+    self._condition = condition
+    self._variables = variables
+
+  @staticmethod
+  def from_dict(d, variables=None):
+    """Creates a Hook instance from a dict like in the DEPS file."""
+    return Hook(
+        d['action'],
+        d.get('pattern'),
+        d.get('name'),
+        d.get('cwd'),
+        d.get('condition'),
+        variables=variables)
+
+  @property
+  def action(self):
+    return self._action
+
+  @property
+  def pattern(self):
+    return self._pattern
 
-      sub_target_name is an optional parameter if the module name in the other
-      DEPS file is different. E.g., you might want to map src/net to net."""
-      self.module_name = module_name
-      self.sub_target_name = sub_target_name
+  @property
+  def name(self):
+    return self._name
 
-    def __str__(self):
-      return 'From(%s, %s)' % (repr(self.module_name),
-                               repr(self.sub_target_name))
+  def matches(self, file_list):
+    """Returns true if the pattern matches any of files in the list."""
+    if not self._pattern:
+      return True
+    pattern = re.compile(self._pattern)
+    return bool([f for f in file_list if pattern.search(f)])
+
+  def run(self, root):
+    """Executes the hook's command (provided the condition is met)."""
+    if (self._condition and
+        not gclient_eval.EvaluateCondition(self._condition, self._variables)):
+      return
+
+    cmd = list(self._action)
+    if cmd[0] == 'python':
+      # If the hook specified "python" as the first item, the action is a
+      # Python script.  Run it by starting a new copy of the same
+      # interpreter.
+      cmd[0] = sys.executable
 
+    cwd = root
+    if self._cwd:
+      cwd = os.path.join(cwd, self._cwd)
+    try:
+      start_time = time.time()
+      gclient_utils.CheckCallAndFilterAndHeader(
+          cmd, cwd=cwd, always=True)
+    except (gclient_utils.Error, subprocess2.CalledProcessError) as e:
+      # Use a discrete exit status code of 2 to indicate that a hook action
+      # failed.  Users of this script may wish to treat hook action failures
+      # differently from VC failures.
+      print('Error: %s' % str(e), file=sys.stderr)
+      sys.exit(2)
+    finally:
+      elapsed_time = time.time() - start_time
+      if elapsed_time > 10:
+        print("Hook '%s' took %.2f secs" % (
+            gclient_utils.CommandToStr(cmd), elapsed_time))
+
+
+class GClientKeywords(object):
   class VarImpl(object):
     def __init__(self, custom_vars, local_scope):
       self._custom_vars = custom_vars
@@ -191,13 +240,18 @@ class DependencySettings(GClientKeywords):
   """Immutable configuration settings."""
   def __init__(
       self, parent, url, managed, custom_deps, custom_vars,
-      custom_hooks, deps_file, should_process, relative):
+      custom_hooks, deps_file, should_process, relative,
+      condition, condition_value):
     GClientKeywords.__init__(self)
 
     # These are not mutable:
     self._parent = parent
     self._deps_file = deps_file
     self._url = url
+    # The condition as string (or None). Useful to keep e.g. for flatten.
+    self._condition = condition
+    # Boolean value of the condition. If there's no condition, just True.
+    self._condition_value = condition_value
     # 'managed' determines whether or not this dependency is synced/updated by
     # gclient after gclient checks it out initially.  The difference between
     # 'managed' and 'should_process' is that the user specifies 'managed' via
@@ -225,10 +279,10 @@ class DependencySettings(GClientKeywords):
       # urls are sometime incorrectly written as proto://host/path/@rev. Replace
       # it to proto://host/path@rev.
       self._url = self._url.replace('/@', '@')
-    elif not isinstance(self._url, (self.FromImpl, None.__class__)):
+    elif not isinstance(self._url, (None.__class__)):
       raise gclient_utils.Error(
-          ('dependency url must be either a string, None, '
-           'or From() instead of %s') % self._url.__class__.__name__)
+          ('dependency url must be either string or None, '
+           'instead of %s') % self._url.__class__.__name__)
     # Make any deps_file path platform-appropriate.
     for sep in ['/', '\\']:
       self._deps_file = self._deps_file.replace(sep, os.sep)
@@ -274,6 +328,14 @@ class DependencySettings(GClientKeywords):
   def url(self):
     return self._url
 
+  @property
+  def condition(self):
+    return self._condition
+
+  @property
+  def condition_value(self):
+    return self._condition_value
+
   @property
   def target_os(self):
     if self.local_target_os is not None:
@@ -294,11 +356,12 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
 
   def __init__(self, parent, name, url, managed, custom_deps,
                custom_vars, custom_hooks, deps_file, should_process,
-               relative):
+               relative, condition, condition_value):
     gclient_utils.WorkItem.__init__(self, name)
     DependencySettings.__init__(
         self, parent, url, managed, custom_deps, custom_vars,
-        custom_hooks, deps_file, should_process, relative)
+        custom_hooks, deps_file, should_process, relative,
+        condition, condition_value)
 
     # This is in both .gclient and DEPS files:
     self._deps_hooks = []
@@ -308,6 +371,13 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     # Calculates properties:
     self._parsed_url = None
     self._dependencies = []
+    # Keep track of original values, before post-processing (e.g. deps_os).
+    self._orig_dependencies = []
+    self._orig_deps_hooks = []
+    self._vars = {}
+    self._os_dependencies = {}
+    self._os_deps_hooks = {}
+
     # A cache of the files affected by the current operation, necessary for
     # hooks.
     self._file_list = []
@@ -316,6 +386,9 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     # hosts will be allowed. Non-empty set means whitelist of hosts.
     # allowed_hosts var is scoped to its DEPS file, and so it isn't recursive.
     self._allowed_hosts = frozenset()
+    # Spec for .gni output to write (if any).
+    self._gn_args_file = None
+    self._gn_args = []
     # If it is not set to True, the dependency wasn't processed for its child
     # dependency, i.e. its DEPS wasn't read.
     self._deps_parsed = False
@@ -376,9 +449,6 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     if self.parent and self.parent.parent and not self.parent.parent.parent:
       requirements |= set(i.name for i in self.root.dependencies if i.name)
 
-    if isinstance(self.url, self.FromImpl):
-      requirements.add(self.url.module_name)
-
     if self.name:
       requirements |= set(
           obj.name for obj in self.root.subtree(False)
@@ -448,10 +518,7 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     return True
 
   def LateOverride(self, url):
-    """Resolves the parsed url from url.
-
-    Manages From() keyword accordingly. Do not touch self.parsed_url nor
-    self.url because it may called with other urls due to From()."""
+    """Resolves the parsed url from url."""
     assert self.parsed_url == None or not self.should_process, self.parsed_url
     parsed_url = self.get_custom_deps(self.name, url)
     if parsed_url != url:
@@ -460,32 +527,6 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
           (self.name, url, parsed_url))
       return parsed_url
 
-    if isinstance(url, self.FromImpl):
-      # Requires tree traversal.
-      ref = [
-          dep for dep in self.root.subtree(True) if url.module_name == dep.name
-      ]
-      if not ref:
-        raise gclient_utils.Error('Failed to find one reference to %s. %s' % (
-            url.module_name, ref))
-      # It may happen that len(ref) > 1 but it's no big deal.
-      ref = ref[0]
-      sub_target = url.sub_target_name or self.name
-      found_deps = [d for d in ref.dependencies if d.name == sub_target]
-      if len(found_deps) != 1:
-        raise gclient_utils.Error(
-            'Couldn\'t find %s in %s, referenced by %s (parent: %s)\n%s' % (
-                sub_target, ref.name, self.name, self.parent.name,
-                str(self.root)))
-
-      # Call LateOverride() again.
-      found_dep = found_deps[0]
-      parsed_url = found_dep.LateOverride(found_dep.url)
-      logging.info(
-          'Dependency(%s).LateOverride(%s) -> %s (From)' %
-          (self.name, url, parsed_url))
-      return parsed_url
-
     if isinstance(url, basestring):
       parsed_url = urlparse.urlparse(url)
       if (not parsed_url[0] and
@@ -519,48 +560,111 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     """Returns a new "deps" structure that is the deps sent in updated
     with information from deps_os (the deps_os section of the DEPS
     file) that matches the list of target os."""
-    os_overrides = {}
-    for the_target_os in target_os_list:
-      the_target_os_deps = deps_os.get(the_target_os, {})
-      for os_dep_key, os_dep_value in the_target_os_deps.iteritems():
-        overrides = os_overrides.setdefault(os_dep_key, [])
-        overrides.append((the_target_os, os_dep_value))
-
-    # If any os didn't specify a value (we have fewer value entries
-    # than in the os list), then it wants to use the default value.
-    for os_dep_key, os_dep_value in os_overrides.iteritems():
-      if len(os_dep_value) != len(target_os_list):
-        # Record the default value too so that we don't accidentally
-        # set it to None or miss a conflicting DEPS.
-        if os_dep_key in deps:
-          os_dep_value.append(('default', deps[os_dep_key]))
-
-    target_os_deps = {}
-    for os_dep_key, os_dep_value in os_overrides.iteritems():
-      # os_dep_value is a list of (os, value) pairs.
-      possible_values = set(x[1] for x in os_dep_value if x[1] is not None)
-      if not possible_values:
-        target_os_deps[os_dep_key] = None
-      else:
-        if len(possible_values) > 1:
-          # It would be possible to abort here but it would be
-          # unfortunate if we end up preventing any kind of checkout.
-          logging.error('Conflicting dependencies for %s: %s. (target_os=%s)',
-                        os_dep_key, os_dep_value, target_os_list)
-        # Sorting to get the same result every time in case of conflicts.
-        target_os_deps[os_dep_key] = sorted(possible_values)[0]
-
     new_deps = deps.copy()
-    new_deps.update(target_os_deps)
+    for dep_os, os_deps in deps_os.iteritems():
+      for key, value in os_deps.iteritems():
+        if value is None:
+          # Make this condition very visible, so it's not a silent failure.
+          # It's unclear how to support None override in deps_os.
+          logging.error('Ignoring %r:%r in %r deps_os', key, value, dep_os)
+          continue
+
+        # Normalize value to be a dict which contains |should_process| metadata.
+        if isinstance(value, basestring):
+          value = {'url': value}
+        assert isinstance(value, collections.Mapping), (key, value)
+        value['should_process'] = dep_os in target_os_list
+
+        # Handle collisions/overrides.
+        if key in new_deps and new_deps[key] != value:
+          # Normalize the existing new_deps entry.
+          if isinstance(new_deps[key], basestring):
+            new_deps[key] = {'url': new_deps[key]}
+          assert isinstance(new_deps[key],
+                            collections.Mapping), (key, new_deps[key])
+
+          # It's OK if the "override" sets the key to the same value.
+          # This is mostly for legacy reasons to keep existing DEPS files
+          # working. Often mac/ios and unix/android will do this.
+          if value['url'] != new_deps[key]['url']:
+            raise gclient_utils.Error(
+                ('Value from deps_os (%r; %r: %r) conflicts with existing deps '
+                 'entry (%r).') % (dep_os, key, value, new_deps[key]))
+
+          # We'd otherwise overwrite |should_process| metadata, but a dep should
+          # be processed if _any_ of its references call for that.
+          value['should_process'] = (
+              value['should_process'] or
+              new_deps[key].get('should_process', True))
+
+        new_deps[key] = value
+
     return new_deps
 
+  def _postprocess_deps(self, deps, rel_prefix):
+    """Performs post-processing of deps compared to what's in the DEPS file."""
+    # Make sure the dict is mutable, e.g. in case it's frozen.
+    deps = dict(deps)
+
+    # If a line is in custom_deps, but not in the solution, we want to append
+    # this line to the solution.
+    for d in self.custom_deps:
+      if d not in deps:
+        deps[d] = self.custom_deps[d]
+
+    if rel_prefix:
+      logging.warning('use_relative_paths enabled.')
+      rel_deps = {}
+      for d, url in deps.items():
+        # normpath is required to allow DEPS to use .. in their
+        # dependency local path.
+        rel_deps[os.path.normpath(os.path.join(rel_prefix, d))] = url
+      logging.warning('Updating deps by prepending %s.', rel_prefix)
+      deps = rel_deps
+
+    return deps
+
+  def _deps_to_objects(self, deps, use_relative_paths):
+    """Convert a deps dict to a dict of Dependency objects."""
+    deps_to_add = []
+    for name, dep_value in deps.iteritems():
+      should_process = self.recursion_limit and self.should_process
+      deps_file = self.deps_file
+      if self.recursedeps is not None:
+        ent = self.recursedeps.get(name)
+        if ent is not None:
+          deps_file = ent['deps_file']
+      if dep_value is None:
+        continue
+      condition = None
+      condition_value = True
+      if isinstance(dep_value, basestring):
+        url = dep_value
+      else:
+        # This should be guaranteed by schema checking in gclient_eval.
+        assert isinstance(dep_value, collections.Mapping)
+        url = dep_value['url']
+        # Take into account should_process metadata set by MergeWithOsDeps.
+        should_process = (should_process and
+                          dep_value.get('should_process', True))
+        condition = dep_value.get('condition')
+      if condition:
+        condition_value = gclient_eval.EvaluateCondition(
+            condition, self.get_vars())
+        should_process = should_process and condition_value
+      deps_to_add.append(Dependency(
+          self, name, url, None, None, self.custom_vars, None,
+          deps_file, should_process, use_relative_paths, condition,
+          condition_value))
+    deps_to_add.sort(key=lambda x: x.name)
+    return deps_to_add
+
   def ParseDepsFile(self):
     """Parses the DEPS file for this dependency."""
     assert not self.deps_parsed
     assert not self.dependencies
 
     deps_content = None
-    use_strict = False
 
     # First try to locate the configured deps file.  If it's missing, fallback
     # to DEPS.
@@ -581,66 +685,42 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     if os.path.isfile(filepath):
       deps_content = gclient_utils.FileRead(filepath)
       logging.debug('ParseDepsFile(%s) read:\n%s', self.name, deps_content)
-      use_strict = 'use strict' in deps_content.splitlines()[0]
 
     local_scope = {}
     if deps_content:
       # One thing is unintuitive, vars = {} must happen before Var() use.
       var = self.VarImpl(self.custom_vars, local_scope)
-      if use_strict:
-        logging.info(
-          'ParseDepsFile(%s): Strict Mode Enabled', self.name)
-        global_scope = {
-          '__builtins__': {'None': None},
-          'Var': var.Lookup,
-          'deps_os': {},
-        }
-      else:
-        global_scope = {
-          'From': self.FromImpl,
-          'Var': var.Lookup,
-          'deps_os': {},
-        }
+      global_scope = {
+        'Var': var.Lookup,
+        'deps_os': {},
+      }
       # Eval the content.
       try:
-        exec(deps_content, global_scope, local_scope)
+        if self._get_option('validate_syntax', False):
+          gclient_eval.Exec(deps_content, global_scope, local_scope, filepath)
+        else:
+          exec(deps_content, global_scope, local_scope)
       except SyntaxError as e:
         gclient_utils.SyntaxErrorToError(filepath, e)
-      if use_strict:
-        for key, val in local_scope.iteritems():
-          if not isinstance(val, (dict, list, tuple, str)):
-            raise gclient_utils.Error(
-              'ParseDepsFile(%s): Strict mode disallows %r -> %r' %
-              (self.name, key, val))
 
-    deps = local_scope.get('deps', {})
-    if 'recursion' in local_scope:
-      self.recursion_override = local_scope.get('recursion')
-      logging.warning(
-          'Setting %s recursion to %d.', self.name, self.recursion_limit)
-    self.recursedeps = None
-    if 'recursedeps' in local_scope:
-      self.recursedeps = {}
-      for ent in local_scope['recursedeps']:
-        if isinstance(ent, basestring):
-          self.recursedeps[ent] = {"deps_file": self.deps_file}
-        else:  # (depname, depsfilename)
-          self.recursedeps[ent[0]] = {"deps_file": ent[1]}
-      logging.warning('Found recursedeps %r.', repr(self.recursedeps))
-    # If present, save 'target_os' in the local_target_os property.
-    if 'target_os' in local_scope:
-      self.local_target_os = local_scope['target_os']
-    # load os specific dependencies if defined.  these dependencies may
-    # override or extend the values defined by the 'deps' member.
-    target_os_list = self.target_os
-    if 'deps_os' in local_scope and target_os_list:
-      deps = self.MergeWithOsDeps(deps, local_scope['deps_os'], target_os_list)
+    if 'allowed_hosts' in local_scope:
+      try:
+        self._allowed_hosts = frozenset(local_scope.get('allowed_hosts'))
+      except TypeError:  # raised if non-iterable
+        pass
+      if not self._allowed_hosts:
+        logging.warning("allowed_hosts is specified but empty %s",
+                        self._allowed_hosts)
+        raise gclient_utils.Error(
+            'ParseDepsFile(%s): allowed_hosts must be absent '
+            'or a non-empty iterable' % self.name)
 
-    # If a line is in custom_deps, but not in the solution, we want to append
-    # this line to the solution.
-    for d in self.custom_deps:
-      if d not in deps:
-        deps[d] = self.custom_deps[d]
+    self._gn_args_file = local_scope.get('gclient_gn_args_file')
+    self._gn_args = local_scope.get('gclient_gn_args', [])
+
+    # Since we heavily post-process things, freeze ones which should
+    # reflect original state of DEPS.
+    self._vars = gclient_utils.freeze(local_scope.get('vars', {}))
 
     # If use_relative_paths is set in the DEPS file, regenerate
     # the dictionary using paths relative to the directory containing
@@ -656,18 +736,24 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
       rel_prefix = self.name
     elif self._relative:
       rel_prefix = os.path.dirname(self.name)
-    if rel_prefix:
-      logging.warning('use_relative_paths enabled.')
-      rel_deps = {}
-      for d, url in deps.items():
-        # normpath is required to allow DEPS to use .. in their
-        # dependency local path.
-        rel_deps[os.path.normpath(os.path.join(rel_prefix, d))] = url
-      logging.warning('Updating deps by prepending %s.', rel_prefix)
-      deps = rel_deps
 
-      # Update recursedeps if it's set.
-      if self.recursedeps is not None:
+    deps = local_scope.get('deps', {})
+    orig_deps = gclient_utils.freeze(deps)
+    if 'recursion' in local_scope:
+      self.recursion_override = local_scope.get('recursion')
+      logging.warning(
+          'Setting %s recursion to %d.', self.name, self.recursion_limit)
+    self.recursedeps = None
+    if 'recursedeps' in local_scope:
+      self.recursedeps = {}
+      for ent in local_scope['recursedeps']:
+        if isinstance(ent, basestring):
+          self.recursedeps[ent] = {"deps_file": self.deps_file}
+        else:  # (depname, depsfilename)
+          self.recursedeps[ent[0]] = {"deps_file": ent[1]}
+      logging.warning('Found recursedeps %r.', repr(self.recursedeps))
+
+      if rel_prefix:
         logging.warning('Updating recursedeps by prepending %s.', rel_prefix)
         rel_deps = {}
         for depname, options in self.recursedeps.iteritems():
@@ -675,32 +761,24 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
               os.path.normpath(os.path.join(rel_prefix, depname))] = options
         self.recursedeps = rel_deps
 
-
-    if 'allowed_hosts' in local_scope:
-      try:
-        self._allowed_hosts = frozenset(local_scope.get('allowed_hosts'))
-      except TypeError:  # raised if non-iterable
-        pass
-      if not self._allowed_hosts:
-        logging.warning("allowed_hosts is specified but empty %s",
-                        self._allowed_hosts)
-        raise gclient_utils.Error(
-            'ParseDepsFile(%s): allowed_hosts must be absent '
-            'or a non-empty iterable' % self.name)
-
-    # Convert the deps into real Dependency.
-    deps_to_add = []
-    for name, url in deps.iteritems():
-      should_process = self.recursion_limit and self.should_process
-      deps_file = self.deps_file
-      if self.recursedeps is not None:
-        ent = self.recursedeps.get(name)
-        if ent is not None:
-          deps_file = ent['deps_file']
-      deps_to_add.append(Dependency(
-          self, name, url, None, None, self.custom_vars, None,
-          deps_file, should_process, use_relative_paths))
-    deps_to_add.sort(key=lambda x: x.name)
+    # If present, save 'target_os' in the local_target_os property.
+    if 'target_os' in local_scope:
+      self.local_target_os = local_scope['target_os']
+    # load os specific dependencies if defined.  these dependencies may
+    # override or extend the values defined by the 'deps' member.
+    target_os_list = self.target_os
+    if 'deps_os' in local_scope:
+      for dep_os, os_deps in local_scope['deps_os'].iteritems():
+        self._os_dependencies[dep_os] = self._deps_to_objects(
+            self._postprocess_deps(os_deps, rel_prefix), use_relative_paths)
+      if target_os_list:
+        deps = self.MergeWithOsDeps(
+            deps, local_scope['deps_os'], target_os_list)
+
+    deps_to_add = self._deps_to_objects(
+        self._postprocess_deps(deps, rel_prefix), use_relative_paths)
+    orig_deps_to_add = self._deps_to_objects(
+        self._postprocess_deps(orig_deps, rel_prefix), use_relative_paths)
 
     # override named sets of hooks by the custom hooks
     hooks_to_run = []
@@ -708,6 +786,20 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     for hook in local_scope.get('hooks', []):
       if hook.get('name', '') not in hook_names_to_suppress:
         hooks_to_run.append(hook)
+    orig_hooks = gclient_utils.freeze(hooks_to_run)
+    if 'hooks_os' in local_scope and target_os_list:
+      hooks_os = local_scope['hooks_os']
+
+      # Keep original contents of hooks_os for flatten.
+      for hook_os, os_hooks in hooks_os.iteritems():
+        self._os_deps_hooks[hook_os] = [
+            Hook.from_dict(hook, variables=self.get_vars())
+            for hook in os_hooks]
+
+      # Specifically append these to ensure that hooks_os run after hooks.
+      for the_target_os in target_os_list:
+        the_target_os_hooks = hooks_os.get(the_target_os, [])
+        hooks_to_run.extend(the_target_os_hooks)
 
     # add the replacements and any additions
     for hook in self.custom_hooks:
@@ -715,18 +807,34 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
         hooks_to_run.append(hook)
 
     if self.recursion_limit:
-      self._pre_deps_hooks = [self.GetHookAction(hook, []) for hook in
-                              local_scope.get('pre_deps_hooks', [])]
+      self._pre_deps_hooks = [
+          Hook.from_dict(hook, variables=self.get_vars()) for hook in
+          local_scope.get('pre_deps_hooks', [])]
 
-    self.add_dependencies_and_close(deps_to_add, hooks_to_run)
+    self.add_dependencies_and_close(
+        deps_to_add, hooks_to_run, orig_deps_to_add=orig_deps_to_add,
+        orig_hooks=orig_hooks)
     logging.info('ParseDepsFile(%s) done' % self.name)
 
-  def add_dependencies_and_close(self, deps_to_add, hooks):
+  def _get_option(self, attr, default):
+    obj = self
+    while not hasattr(obj, '_options'):
+      obj = obj.parent
+    return getattr(obj._options, attr, default)
+
+  def add_dependencies_and_close(
+      self, deps_to_add, hooks, orig_deps_to_add=None, orig_hooks=None):
     """Adds the dependencies, hooks and mark the parsing as done."""
     for dep in deps_to_add:
       if dep.verify_validity():
         self.add_dependency(dep)
-    self._mark_as_parsed(hooks)
+    for dep in (orig_deps_to_add if orig_deps_to_add is not None
+                else deps_to_add):
+      self.add_orig_dependency(dep)
+    self._mark_as_parsed(
+        [Hook.from_dict(h, variables=self.get_vars()) for h in hooks],
+        orig_hooks=[Hook.from_dict(h, variables=self.get_vars())
+                    for h in (orig_hooks if orig_hooks is not None else hooks)])
 
   def findDepsFromNotAllowedHosts(self):
     """Returns a list of depenecies from not allowed hosts.
@@ -757,10 +865,13 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     # When running runhooks, there's no need to consult the SCM.
     # All known hooks are expected to run unconditionally regardless of working
     # copy state, so skip the SCM status check.
-    run_scm = command not in ('runhooks', 'recurse', None)
+    run_scm = command not in (
+        'flatten', 'runhooks', 'recurse', 'validate', None)
     parsed_url = self.LateOverride(self.url)
     file_list = [] if not options.nohooks else None
     revision_override = revision_overrides.pop(self.name, None)
+    if not revision_override and parsed_url:
+      revision_override = revision_overrides.get(parsed_url.split('@')[0], None)
     if run_scm and parsed_url:
       # Create a shallow copy to mutate revision.
       options = copy.copy(options)
@@ -789,6 +900,8 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
 
     # Always parse the DEPS file.
     self.ParseDepsFile()
+    if self._gn_args_file and command == 'update':
+      self.WriteGNArgsFile()
     self._run_is_done(file_list or [], parsed_url)
     if command in ('update', 'revert') and not options.noprehooks:
       self.RunPreDepsHooks()
@@ -796,7 +909,8 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     if self.recursion_limit:
       # Parse the dependencies of this dependency.
       for s in self.dependencies:
-        work_queue.enqueue(s)
+        if s.should_process:
+          work_queue.enqueue(s)
 
     if command == 'recurse':
       # Skip file only checkout.
@@ -854,6 +968,12 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
         else:
           print('Skipped missing %s' % cwd, file=sys.stderr)
 
+  def WriteGNArgsFile(self):
+    lines = ['# Generated from %r' % self.deps_file]
+    for arg in self._gn_args:
+      lines.append('%s = %s' % (arg, ToGNString(self.get_vars()[arg])))
+    with open(os.path.join(self.root.root_dir, self._gn_args_file), 'w') as f:
+      f.write('\n'.join(lines))
 
   @gclient_utils.lockedmethod
   def _run_is_done(self, file_list, parsed_url):
@@ -862,22 +982,6 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     self._parsed_url = parsed_url
     self._processed = True
 
-  @staticmethod
-  def GetHookAction(hook_dict, matching_file_list):
-    """Turns a parsed 'hook' dict into an executable command."""
-    logging.debug(hook_dict)
-    logging.debug(matching_file_list)
-    command = hook_dict['action'][:]
-    if command[0] == 'python':
-      # If the hook specified "python" as the first item, the action is a
-      # Python script.  Run it by starting a new copy of the same
-      # interpreter.
-      command[0] = sys.executable
-    if '$matching_files' in command:
-      splice_index = command.index('$matching_files')
-      command[splice_index:splice_index + 1] = matching_file_list
-    return command
-
   def GetHooks(self, options):
     """Evaluates all hooks, and return them in a flat list.
 
@@ -896,18 +1000,11 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
       if (options.force or
           gclient_scm.GetScmName(self.parsed_url) in ('git', None) or
           os.path.isdir(os.path.join(self.root.root_dir, self.name, '.git'))):
-        for hook_dict in self.deps_hooks:
-          result.append(self.GetHookAction(hook_dict, []))
+        result.extend(self.deps_hooks)
       else:
-        # Run hooks on the basis of whether the files from the gclient operation
-        # match each hook's pattern.
-        for hook_dict in self.deps_hooks:
-          pattern = re.compile(hook_dict['pattern'])
-          matching_file_list = [
-              f for f in self.file_list_and_children if pattern.search(f)
-          ]
-          if matching_file_list:
-            result.append(self.GetHookAction(hook_dict, matching_file_list))
+        for hook in self.deps_hooks:
+          if hook.matches(self.file_list_and_children):
+            result.append(hook)
     for s in self.dependencies:
       result.extend(s.GetHooks(options))
     return result
@@ -916,21 +1013,7 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     assert self.hooks_ran == False
     self._hooks_ran = True
     for hook in self.GetHooks(options):
-      try:
-        start_time = time.time()
-        gclient_utils.CheckCallAndFilterAndHeader(
-            hook, cwd=self.root.root_dir, always=True)
-      except (gclient_utils.Error, subprocess2.CalledProcessError) as e:
-        # Use a discrete exit status code of 2 to indicate that a hook action
-        # failed.  Users of this script may wish to treat hook action failures
-        # differently from VC failures.
-        print('Error: %s' % str(e), file=sys.stderr)
-        sys.exit(2)
-      finally:
-        elapsed_time = time.time() - start_time
-        if elapsed_time > 10:
-          print("Hook '%s' took %.2f secs" % (
-              gclient_utils.CommandToStr(hook), elapsed_time))
+      hook.run(self.root.root_dir)
 
   def RunPreDepsHooks(self):
     assert self.processed
@@ -941,22 +1024,7 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
       assert not s.processed
     self._pre_deps_hooks_ran = True
     for hook in self.pre_deps_hooks:
-      try:
-        start_time = time.time()
-        gclient_utils.CheckCallAndFilterAndHeader(
-            hook, cwd=self.root.root_dir, always=True)
-      except (gclient_utils.Error, subprocess2.CalledProcessError) as e:
-        # Use a discrete exit status code of 2 to indicate that a hook action
-        # failed.  Users of this script may wish to treat hook action failures
-        # differently from VC failures.
-        print('Error: %s' % str(e), file=sys.stderr)
-        sys.exit(2)
-      finally:
-        elapsed_time = time.time() - start_time
-        if elapsed_time > 10:
-          print("Hook '%s' took %.2f secs" % (
-              gclient_utils.CommandToStr(hook), elapsed_time))
-
+      hook.run(self.root.root_dir)
 
   def subtree(self, include_all):
     """Breadth first recursion excluding root node."""
@@ -968,21 +1036,18 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
       for i in d.subtree(include_all):
         yield i
 
-  def depth_first_tree(self):
-    """Depth-first recursion including the root node."""
-    yield self
-    for i in self.dependencies:
-      for j in i.depth_first_tree():
-        if j.should_process:
-          yield j
-
   @gclient_utils.lockedmethod
   def add_dependency(self, new_dep):
     self._dependencies.append(new_dep)
 
   @gclient_utils.lockedmethod
-  def _mark_as_parsed(self, new_hooks):
+  def add_orig_dependency(self, new_dep):
+    self._orig_dependencies.append(new_dep)
+
+  @gclient_utils.lockedmethod
+  def _mark_as_parsed(self, new_hooks, orig_hooks=None):
     self._deps_hooks.extend(new_hooks)
+    self._orig_deps_hooks.extend(orig_hooks or new_hooks)
     self._deps_parsed = True
 
   @property
@@ -990,11 +1055,31 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
   def dependencies(self):
     return tuple(self._dependencies)
 
+  @property
+  @gclient_utils.lockedmethod
+  def orig_dependencies(self):
+    return tuple(self._orig_dependencies)
+
+  @property
+  @gclient_utils.lockedmethod
+  def os_dependencies(self):
+    return dict(self._os_dependencies)
+
   @property
   @gclient_utils.lockedmethod
   def deps_hooks(self):
     return tuple(self._deps_hooks)
 
+  @property
+  @gclient_utils.lockedmethod
+  def orig_deps_hooks(self):
+    return tuple(self._orig_deps_hooks)
+
+  @property
+  @gclient_utils.lockedmethod
+  def os_deps_hooks(self):
+    return dict(self._os_deps_hooks)
+
   @property
   @gclient_utils.lockedmethod
   def pre_deps_hooks(self):
@@ -1075,15 +1160,26 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
   def __repr__(self):
     return '%s: %s' % (self.name, self.url)
 
-  def hierarchy(self):
+  def hierarchy(self, include_url=True):
     """Returns a human-readable hierarchical reference to a Dependency."""
-    out = '%s(%s)' % (self.name, self.url)
+    def format_name(d):
+      if include_url:
+        return '%s(%s)' % (d.name, d.url)
+      return d.name
+    out = format_name(self)
     i = self.parent
     while i and i.name:
-      out = '%s(%s) -> %s' % (i.name, i.url, out)
+      out = '%s -> %s' % (format_name(i), out)
       i = i.parent
     return out
 
+  def get_vars(self):
+    """Returns a dictionary of effective variable values
+    (DEPS file contents with applied custom_vars overrides)."""
+    result = dict(self._vars)
+    result.update(self.custom_vars or {})
+    return result
+
 
 class GClient(Dependency):
   """Object that represent a gclient checkout. A tree of Dependency(), one per
@@ -1136,7 +1232,7 @@ solutions = [
     # are processed.
     self._recursion_limit = 2
     Dependency.__init__(self, None, None, None, True, None, None, None,
-                        'unused', True, None)
+                        'unused', True, None, None, True)
     self._options = options
     if options.deps_os:
       enforced_os = options.deps_os.split(',')
@@ -1225,7 +1321,9 @@ it or fix the checkout.
             s.get('custom_hooks', []),
             s.get('deps_file', 'DEPS'),
             True,
-            None))
+            None,
+            None,
+            True))
       except KeyError:
         raise gclient_utils.Error('Invalid .gclient file. Solution is '
                                   'incomplete: %s' % s)
@@ -1309,7 +1407,7 @@ it or fix the checkout.
       exec(gclient_utils.FileRead(filename), scope)
     except SyntaxError as e:
       gclient_utils.SyntaxErrorToError(filename, e)
-    return scope['entries']
+    return scope.get('entries', {})
 
   def _EnforceRevisions(self):
     """Checks for revision overrides."""
@@ -1346,7 +1444,8 @@ it or fix the checkout.
     revision_overrides = {}
     # It's unnecessary to check for revision overrides for 'recurse'.
     # Save a few seconds by not calling _EnforceRevisions() in that case.
-    if command not in ('diff', 'recurse', 'runhooks', 'status', 'revert'):
+    if command not in ('diff', 'recurse', 'runhooks', 'status', 'revert',
+                       'validate'):
       self._CheckConfig()
       revision_overrides = self._EnforceRevisions()
     pm = None
@@ -1354,13 +1453,14 @@ it or fix the checkout.
     if (setup_color.IS_TTY and not self._options.verbose and progress):
       if command in ('update', 'revert'):
         pm = Progress('Syncing projects', 1)
-      elif command == 'recurse':
+      elif command in ('recurse', 'validate'):
         pm = Progress(' '.join(args), 1)
     work_queue = gclient_utils.ExecutionQueue(
         self._options.jobs, pm, ignore_requirements=ignore_requirements,
         verbose=self._options.verbose)
     for s in self.dependencies:
-      work_queue.enqueue(s)
+      if s.should_process:
+        work_queue.enqueue(s)
     work_queue.flush(revision_overrides, command, args, options=self._options)
     if revision_overrides:
       print('Please fix your script, having invalid --revision flags will soon '
@@ -1472,7 +1572,8 @@ it or fix the checkout.
     work_queue = gclient_utils.ExecutionQueue(
         self._options.jobs, None, False, verbose=self._options.verbose)
     for s in self.dependencies:
-      work_queue.enqueue(s)
+      if s.should_process:
+        work_queue.enqueue(s)
     work_queue.flush({}, None, [], options=self._options)
 
     def GetURLAndRev(dep):
@@ -1616,6 +1717,292 @@ def CMDfetch(parser, args):
       '--jobs=%d' % options.jobs, '--scm=git', 'git', 'fetch'] + args)
 
 
+class Flattener(object):
+  """Flattens a gclient solution."""
+
+  def __init__(self, client, pin_all_deps=False):
+    """Constructor.
+
+    Arguments:
+      client (GClient): client to flatten
+      pin_all_deps (bool): whether to pin all deps, even if they're not pinned
+          in DEPS
+    """
+    self._client = client
+
+    self._deps_string = None
+
+    self._allowed_hosts = set()
+    self._deps = {}
+    self._deps_os = {}
+    self._hooks = []
+    self._hooks_os = {}
+    self._pre_deps_hooks = []
+    self._vars = {}
+
+    self._flatten(pin_all_deps=pin_all_deps)
+
+  @property
+  def deps_string(self):
+    assert self._deps_string is not None
+    return self._deps_string
+
+  def _flatten(self, pin_all_deps=False):
+    """Runs the flattener. Saves resulting DEPS string.
+
+    Arguments:
+      pin_all_deps (bool): whether to pin all deps, even if they're not pinned
+          in DEPS
+    """
+    for solution in self._client.dependencies:
+      self._flatten_solution(solution)
+
+    if pin_all_deps:
+      for dep in self._deps.itervalues():
+        if dep.parsed_url is None:
+          continue
+        url, revision = gclient_utils.SplitUrlRevision(dep.parsed_url)
+        if revision and gclient_utils.IsGitSha(revision):
+          continue
+        scm = gclient_scm.CreateSCM(
+            dep.parsed_url, self._client.root_dir, dep.name, dep.outbuf)
+        dep._parsed_url = dep._url = '%s@%s' % (
+            url, scm.revinfo(self._client._options, [], None))
+
+    self._deps_string = '\n'.join(
+        _GNSettingsToLines(
+            self._client.dependencies[0]._gn_args_file,
+            self._client.dependencies[0]._gn_args) +
+        _AllowedHostsToLines(self._allowed_hosts) +
+        _DepsToLines(self._deps) +
+        _DepsOsToLines(self._deps_os) +
+        _HooksToLines('hooks', self._hooks) +
+        _HooksToLines('pre_deps_hooks', self._pre_deps_hooks) +
+        _HooksOsToLines(self._hooks_os) +
+        _VarsToLines(self._vars) +
+        [''])  # Ensure newline at end of file.
+
+  def _flatten_solution(self, solution):
+    """Visits a solution in order to flatten it (see CMDflatten).
+
+    Arguments:
+      solution (Dependency): one of top-level solutions in .gclient
+    """
+    self._flatten_dep(solution)
+    self._flatten_recurse(solution)
+
+  def _flatten_dep(self, dep):
+    """Visits a dependency in order to flatten it (see CMDflatten).
+
+    Arguments:
+      dep (Dependency): dependency to process
+    """
+    self._allowed_hosts.update(dep.allowed_hosts)
+
+    assert dep.name not in self._deps
+    self._deps[dep.name] = dep
+
+    for key, value in dep.get_vars().iteritems():
+      assert key not in self._vars
+      self._vars[key] = (dep, value)
+
+    self._hooks.extend([(dep, hook) for hook in dep.orig_deps_hooks])
+    self._pre_deps_hooks.extend([(dep, hook) for hook in dep.pre_deps_hooks])
+
+    for hook_os, os_hooks in dep.os_deps_hooks.iteritems():
+      self._hooks_os.setdefault(hook_os, []).extend(
+          [(dep, hook) for hook in os_hooks])
+
+    self._add_deps_os(dep)
+
+    deps_by_name = dict((d.name, d) for d in dep.dependencies)
+    for recurse_dep_name in (dep.recursedeps or []):
+      self._flatten_recurse(deps_by_name[recurse_dep_name])
+
+  def _flatten_recurse(self, dep):
+    """Helper for flatten that recurses into |dep|'s dependencies.
+
+    Arguments:
+      dep (Dependency): dependency to process
+    """
+    self._add_deps_os(dep)
+
+    for sub_dep in dep.orig_dependencies:
+      self._flatten_dep(sub_dep)
+
+  def _add_deps_os(self, dep):
+    """Helper for flatten that collects deps_os from |dep|.
+
+    Arguments:
+      dep (Dependency): dependency to process
+    """
+    for dep_os, os_deps in dep.os_dependencies.iteritems():
+      for os_dep in os_deps:
+        self._deps_os.setdefault(dep_os, {})[os_dep.name] = os_dep
+
+
+def CMDflatten(parser, args):
+  """Flattens the solutions into a single DEPS file."""
+  parser.add_option('--output-deps', help='Path to the output DEPS file')
+  parser.add_option(
+      '--pin-all-deps', action='store_true',
+      help=('Pin all deps, even if not pinned in DEPS. CAVEAT: only does so '
+            'for checked out deps, NOT deps_os.'))
+  options, args = parser.parse_args(args)
+
+  options.nohooks = True
+  client = GClient.LoadCurrentConfig(options)
+
+  # Only print progress if we're writing to a file. Otherwise, progress updates
+  # could obscure intended output.
+  code = client.RunOnDeps('flatten', args, progress=options.output_deps)
+  if code != 0:
+    return code
+
+  flattener = Flattener(client, pin_all_deps=options.pin_all_deps)
+
+  if options.output_deps:
+    with open(options.output_deps, 'w') as f:
+      f.write(flattener.deps_string)
+  else:
+    print(flattener.deps_string)
+
+  return 0
+
+
+def _GNSettingsToLines(gn_args_file, gn_args):
+  s = []
+  if gn_args_file:
+    s.extend([
+        'gclient_gn_args_file = "%s"' % gn_args_file,
+        'gclient_gn_args = %r' % gn_args,
+    ])
+  return s
+
+
+def _AllowedHostsToLines(allowed_hosts):
+  """Converts |allowed_hosts| set to list of lines for output."""
+  if not allowed_hosts:
+    return []
+  s = ['allowed_hosts = [']
+  for h in sorted(allowed_hosts):
+    s.append('  "%s",' % h)
+  s.extend([']', ''])
+  return s
+
+
+def _DepsToLines(deps):
+  """Converts |deps| dict to list of lines for output."""
+  if not deps:
+    return []
+  s = ['deps = {']
+  for name, dep in sorted(deps.iteritems()):
+    condition_part = (['    "condition": "%s",' % dep.condition]
+                      if dep.condition else [])
+    s.extend([
+        '  # %s' % dep.hierarchy(include_url=False),
+        '  "%s": {' % (name,),
+        '    "url": "%s",' % (dep.url,),
+    ] + condition_part + [
+        '  },',
+        '',
+    ])
+  s.extend(['}', ''])
+  return s
+
+
+def _DepsOsToLines(deps_os):
+  """Converts |deps_os| dict to list of lines for output."""
+  if not deps_os:
+    return []
+  s = ['deps_os = {']
+  for dep_os, os_deps in sorted(deps_os.iteritems()):
+    s.append('  "%s": {' % dep_os)
+    for name, dep in sorted(os_deps.iteritems()):
+      condition_part = (['      "condition": "%s",' % dep.condition]
+                        if dep.condition else [])
+      s.extend([
+          '    # %s' % dep.hierarchy(include_url=False),
+          '    "%s": {' % (name,),
+          '      "url": "%s",' % (dep.url,),
+      ] + condition_part + [
+          '    },',
+          '',
+      ])
+    s.extend(['  },', ''])
+  s.extend(['}', ''])
+  return s
+
+
+def _HooksToLines(name, hooks):
+  """Converts |hooks| list to list of lines for output."""
+  if not hooks:
+    return []
+  s = ['%s = [' % name]
+  for dep, hook in hooks:
+    s.extend([
+        '  # %s' % dep.hierarchy(include_url=False),
+        '  {',
+    ])
+    if hook.name is not None:
+      s.append('    "name": "%s",' % hook.name)
+    if hook.pattern is not None:
+      s.append('    "pattern": "%s",' % hook.pattern)
+    s.extend(
+        # Hooks run in the parent directory of their dep.
+        ['    "cwd": "%s",' % os.path.normpath(os.path.dirname(dep.name))] +
+        ['    "action": ['] +
+        ['        "%s",' % arg for arg in hook.action] +
+        ['    ]', '  },', '']
+    )
+  s.extend([']', ''])
+  return s
+
+
+def _HooksOsToLines(hooks_os):
+  """Converts |hooks| list to list of lines for output."""
+  if not hooks_os:
+    return []
+  s = ['hooks_os = {']
+  for hook_os, os_hooks in hooks_os.iteritems():
+    s.append('  "%s": [' % hook_os)
+    for dep, hook in os_hooks:
+      s.extend([
+          '    # %s' % dep.hierarchy(include_url=False),
+          '    {',
+      ])
+      if hook.name is not None:
+        s.append('      "name": "%s",' % hook.name)
+      if hook.pattern is not None:
+        s.append('      "pattern": "%s",' % hook.pattern)
+      s.extend(
+          # Hooks run in the parent directory of their dep.
+          ['      "cwd": "%s",' % os.path.normpath(os.path.dirname(dep.name))] +
+          ['      "action": ['] +
+          ['          "%s",' % arg for arg in hook.action] +
+          ['      ]', '    },', '']
+      )
+    s.extend(['  ],', ''])
+  s.extend(['}', ''])
+  return s
+
+
+def _VarsToLines(variables):
+  """Converts |variables| dict to list of lines for output."""
+  if not variables:
+    return []
+  s = ['vars = {']
+  for key, tup in sorted(variables.iteritems()):
+    dep, value = tup
+    s.extend([
+        '  # %s' % dep.hierarchy(include_url=False),
+        '  "%s": %r,' % (key, value),
+        '',
+    ])
+  s.extend(['}', ''])
+  return s
+
+
 def CMDgrep(parser, args):
   """Greps through git repos managed by gclient.
 
@@ -1862,6 +2249,12 @@ def CMDsync(parser, args):
                     help='DEPRECATED: This is a no-op.')
   parser.add_option('-m', '--manually_grab_svn_rev', action='store_true',
                     help='DEPRECATED: This is a no-op.')
+  # TODO(phajdan.jr): Remove validation options once default (crbug/570091).
+  parser.add_option('--validate-syntax', action='store_true', default=True,
+                    help='Validate the .gclient and DEPS syntax')
+  parser.add_option('--disable-syntax-validation', action='store_false',
+                    dest='validate_syntax',
+                    help='Disable validation of .gclient and DEPS syntax.')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
 
@@ -1892,6 +2285,19 @@ def CMDsync(parser, args):
 CMDupdate = CMDsync
 
 
+def CMDvalidate(parser, args):
+  """Validates the .gclient and DEPS syntax."""
+  options, args = parser.parse_args(args)
+  options.validate_syntax = True
+  client = GClient.LoadCurrentConfig(options)
+  rv = client.RunOnDeps('validate', args)
+  if rv == 0:
+    print('validate: SUCCESS')
+  else:
+    print('validate: FAILURE')
+  return rv
+
+
 def CMDdiff(parser, args):
   """Displays local diff for every dependencies."""
   parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
@@ -1985,18 +2391,6 @@ def CMDrevinfo(parser, args):
   return 0
 
 
-def CMDhookinfo(parser, args):
-  """Outputs the hooks that would be run by `gclient runhooks`."""
-  (options, args) = parser.parse_args(args)
-  options.force = True
-  client = GClient.LoadCurrentConfig(options)
-  if not client:
-    raise gclient_utils.Error('client not configured; see \'gclient config\'')
-  client.RunOnDeps(None, [])
-  print('; '.join(' '.join(hook) for hook in client.GetHooks(options)))
-  return 0
-
-
 def CMDverify(parser, args):
   """Verifies the DEPS file deps are only from allowed_hosts."""
   (options, args) = parser.parse_args(args)