libv8 6.3.292.48.1 → 6.7.288.46.0

data/vendor/depot_tools/detect_host_arch.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+# 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.
+
+"""Outputs host CPU architecture in format recognized by gyp."""
+
+import platform
+import re
+import sys
+
+
+def HostArch():
+  """Returns the host architecture with a predictable string."""
+  host_arch = platform.machine()
+
+  # Convert machine type to format recognized by gyp.
+  if re.match(r'i.86', host_arch) or host_arch == 'i86pc':
+    host_arch = 'x86'
+  elif host_arch in ['x86_64', 'amd64']:
+    host_arch = 'x64'
+  elif host_arch.startswith('arm'):
+    host_arch = 'arm'
+  elif host_arch.startswith('aarch64'):
+    host_arch = 'arm64'
+  elif host_arch.startswith('mips'):
+    host_arch = 'mips'
+  elif host_arch.startswith('ppc'):
+    host_arch = 'ppc'
+  elif host_arch.startswith('s390'):
+    host_arch = 's390'
+
+
+  # platform.machine is based on running kernel. It's possible to use 64-bit
+  # kernel with 32-bit userland, e.g. to give linker slightly more memory.
+  # Distinguish between different userland bitness by querying
+  # the python binary.
+  if host_arch == 'x64' and platform.architecture()[0] == '32bit':
+    host_arch = 'x86'
+  if host_arch == 'arm64' and platform.architecture()[0] == '32bit':
+    host_arch = 'arm'
+
+  return host_arch
+
+def DoMain(_):
+  """Hook to be called from gyp without starting a separate python
+  interpreter."""
+  return HostArch()
+
+if __name__ == '__main__':
+  print DoMain([])

data/vendor/depot_tools/download_from_google_storage.py

@@ -21,6 +21,11 @@ import time
 import subprocess2
 
 
+# Env vars that tempdir can be gotten from; minimally, this
+# needs to match python's tempfile module and match normal
+# unix standards.
+_TEMPDIR_ENV_VARS = ('TMPDIR', 'TEMP', 'TMP')
+
 GSUTIL_DEFAULT_PATH = os.path.join(
     os.path.dirname(os.path.abspath(__file__)), 'gsutil.py')
 # Maps sys.platform to what we actually want to call them.
@@ -29,6 +34,8 @@ PLATFORM_MAPPING = {
     'darwin': 'mac',
     'linux2': 'linux',
     'win32': 'win',
+    'aix6': 'aix',
+    'aix7': 'aix',
 }
 
 
@@ -54,13 +61,18 @@ def GetNormalizedPlatform():
 # Common utilities
 class Gsutil(object):
   """Call gsutil with some predefined settings.  This is a convenience object,
-  and is also immutable."""
+  and is also immutable.
+
+  HACK: This object is used directly by the external script
+    `<depot_tools>/win_toolchain/get_toolchain_if_necessary.py`
+  """
 
   MAX_TRIES = 5
   RETRY_BASE_DELAY = 5.0
   RETRY_DELAY_MULTIPLE = 1.3
+  VPYTHON = 'vpython.bat' if GetNormalizedPlatform() == 'win32' else 'vpython'
 
-  def __init__(self, path, boto_path=None, timeout=None, version='4.26'):
+  def __init__(self, path, boto_path=None, timeout=None, version='4.28'):
     if not os.path.exists(path):
       raise FileNotFoundError('GSUtil not found in %s' % path)
     self.path = path
@@ -77,15 +89,18 @@ class Gsutil(object):
       env['AWS_CREDENTIAL_FILE'] = self.boto_path
       env['BOTO_CONFIG'] = self.boto_path
 
+    if PLATFORM_MAPPING[sys.platform] != 'win':
+      env.update((x, "/tmp") for x in _TEMPDIR_ENV_VARS)
+
     return env
 
   def call(self, *args):
-    cmd = [sys.executable, self.path, '--force-version', self.version]
+    cmd = [self.VPYTHON, self.path, '--force-version', self.version]
     cmd.extend(args)
     return subprocess2.call(cmd, env=self.get_sub_env(), timeout=self.timeout)
 
   def check_call(self, *args):
-    cmd = [sys.executable, self.path, '--force-version', self.version]
+    cmd = [self.VPYTHON, self.path, '--force-version', self.version]
     cmd.extend(args)
     ((out, err), code) = subprocess2.communicate(
         cmd,
@@ -143,9 +158,8 @@ def get_sha1(filename):
 
 # Download-specific code starts here
 
-def enumerate_work_queue(input_filename, work_queue, directory,
-                         recursive, ignore_errors, output, sha1_file,
-                         auto_platform):
+def enumerate_input(input_filename, directory, recursive, ignore_errors, output,
+                    sha1_file, auto_platform):
   if sha1_file:
     if not os.path.exists(input_filename):
       if not ignore_errors:
@@ -154,18 +168,17 @@ def enumerate_work_queue(input_filename, work_queue, directory,
     with open(input_filename, 'rb') as f:
       sha1_match = re.match('^([A-Za-z0-9]{40})$', f.read(1024).rstrip())
       if sha1_match:
-        work_queue.put((sha1_match.groups(1)[0], output))
-        return 1
+        yield (sha1_match.groups(1)[0], output)
+        return
     if not ignore_errors:
       raise InvalidFileError('No sha1 sum found in %s.' % input_filename)
     print >> sys.stderr, 'No sha1 sum found in %s.' % input_filename
-    return 0
+    return
 
   if not directory:
-    work_queue.put((input_filename, output))
-    return 1
+    yield (input_filename, output)
+    return
 
-  work_queue_size = 0
   for root, dirs, files in os.walk(input_filename):
     if not recursive:
       for item in dirs[:]:
@@ -194,14 +207,11 @@ def enumerate_work_queue(input_filename, work_queue, directory,
         with open(full_path, 'rb') as f:
           sha1_match = re.match('^([A-Za-z0-9]{40})$', f.read(1024).rstrip())
         if sha1_match:
-          work_queue.put(
-              (sha1_match.groups(1)[0], full_path.replace('.sha1', '')))
-          work_queue_size += 1
+          yield (sha1_match.groups(1)[0], full_path.replace('.sha1', ''))
         else:
           if not ignore_errors:
             raise InvalidFileError('No sha1 sum found in %s.' % filename)
           print >> sys.stderr, 'No sha1 sum found in %s.' % filename
-  return work_queue_size
 
 
 def _validate_tar_file(tar, prefix):
@@ -209,13 +219,15 @@ def _validate_tar_file(tar, prefix):
     """Returns false if the tarinfo is something we explicitly forbid."""
     if tarinfo.issym() or tarinfo.islnk():
       return False
-    if '..' in tarinfo.name or not tarinfo.name.startswith(prefix):
+    if ('../' in tarinfo.name or
+        '..\\' in tarinfo.name or
+        not tarinfo.name.startswith(prefix)):
       return False
     return True
   return all(map(_validate, tar.getmembers()))
 
 def _downloader_worker_thread(thread_num, q, force, base_url,
-                              gsutil, out_q, ret_codes, verbose, extract,
+                              gsutil, out_q, ret_codes, _verbose, extract,
                               delete=True):
   while True:
     input_sha1_sum, output_filename = q.get()
@@ -228,7 +240,7 @@ def _downloader_worker_thread(thread_num, q, force, base_url,
                   thread_num, output_filename))
         ret_codes.put((1, '%s is not a tar.gz archive.' % (output_filename)))
         continue
-      extract_dir = output_filename[0:len(output_filename)-7]
+      extract_dir = output_filename[:-len('.tar.gz')]
     if os.path.exists(output_filename) and not force:
       if not extract or os.path.exists(extract_dir):
         if get_sha1(output_filename) == input_sha1_sum:
@@ -339,9 +351,57 @@ class PrinterThread(threading.Thread):
       print line
 
 
+def _data_exists(input_sha1_sum, output_filename, extract):
+  """Returns True if the data exists locally and matches the sha1.
+
+  This conservatively returns False for error cases.
+
+  Args:
+    input_sha1_sum: Expected sha1 stored on disk.
+    output_filename: The file to potentially download later. Its sha1 will be
+        compared to input_sha1_sum.
+    extract: Wheather or not a downloaded file should be extracted. If the file
+        is not extracted, this just compares the sha1 of the file. If the file
+        is to be extracted, this only compares the sha1 of the target archive if
+        the target directory already exists. The content of the target directory
+        is not checked.
+  """
+  extract_dir = None
+  if extract:
+    if not output_filename.endswith('.tar.gz'):
+      # This will cause an error later. Conservativly return False to not bail
+      # out too early.
+      return False
+    extract_dir = output_filename[:-len('.tar.gz')]
+  if os.path.exists(output_filename):
+    if not extract or os.path.exists(extract_dir):
+      if get_sha1(output_filename) == input_sha1_sum:
+        return True
+  return False
+
+
 def download_from_google_storage(
     input_filename, base_url, gsutil, num_threads, directory, recursive,
     force, output, ignore_errors, sha1_file, verbose, auto_platform, extract):
+
+  # Tuples of sha1s and paths.
+  input_data = list(enumerate_input(
+      input_filename, directory, recursive, ignore_errors, output, sha1_file,
+      auto_platform))
+
+  # Sequentially check for the most common case and see if we can bail out
+  # early before making any slow calls to gsutil.
+  if not force and all(
+      _data_exists(sha1, path, extract) for sha1, path in input_data):
+    return 0
+
+  # Call this once to ensure gsutil's update routine is called only once. Only
+  # needs to be done if we'll process input data in parallel, which can lead to
+  # a race in gsutil's self-update on the first call. Note, this causes a
+  # network call, therefore any fast bailout should be done before this point.
+  if len(input_data) > 1:
+    gsutil.check_call('version')
+
   # Start up all the worker threads.
   all_threads = []
   download_start = time.time()
@@ -361,10 +421,9 @@ def download_from_google_storage(
   printer_thread.daemon = True
   printer_thread.start()
 
-  # Enumerate our work queue.
-  work_queue_size = enumerate_work_queue(
-      input_filename, work_queue, directory, recursive,
-      ignore_errors, output, sha1_file, auto_platform)
+  # Populate our work queue.
+  for sha1, path in input_data:
+    work_queue.put((sha1, path))
   for _ in all_threads:
     work_queue.put((None, None))  # Used to tell worker threads to stop.
 
@@ -384,7 +443,7 @@ def download_from_google_storage(
   # Only print summary if any work was done.
   if printer_thread.did_print_anything:
     print 'Downloading %d files took %1f second(s)' % (
-        work_queue_size, time.time() - download_start)
+        len(input_data), time.time() - download_start)
   return max_ret_code
 
 
@@ -488,7 +547,6 @@ def main(args):
   else:
     parser.error('gsutil not found in %s, bad depot_tools checkout?' %
                  GSUTIL_DEFAULT_PATH)
-  gsutil.check_call('version')  # Call this once to ensure it exists.
 
   # Passing in -g/--config will run our copy of GSUtil, then quit.
   if options.config:
@@ -496,6 +554,7 @@ def main(args):
     print 'If you do not have a project ID, enter "0" when asked for one.'
     print '===End note from depot_tools==='
     print
+    gsutil.check_call('version')
     return gsutil.call('config')
 
   if not args:

data/vendor/depot_tools/fetch.py

@@ -61,11 +61,15 @@ class Checkout(object):
   def sync(self):
     pass
 
-  def run(self, cmd, **kwargs):
+  def run(self, cmd, return_stdout=False, **kwargs):
     print 'Running: %s' % (' '.join(pipes.quote(x) for x in cmd))
     if self.options.dry_run:
       return ''
-    return subprocess.check_output(cmd, **kwargs)
+    if return_stdout:
+      return subprocess.check_output(cmd, **kwargs)
+    else:
+      subprocess.check_call(cmd, **kwargs)
+      return ''
 
 
 class GclientCheckout(Checkout):
@@ -79,7 +83,7 @@ class GclientCheckout(Checkout):
 
   def exists(self):
     try:
-      gclient_root = self.run_gclient('root').strip()
+      gclient_root = self.run_gclient('root', return_stdout=True).strip()
       return (os.path.exists(os.path.join(gclient_root, '.gclient')) or
               os.path.exists(os.path.join(os.getcwd(), self.root)))
     except subprocess.CalledProcessError:
@@ -140,9 +144,10 @@ class GclientGitCheckout(GclientCheckout, GitCheckout):
         'submodule', 'foreach',
         'git config -f $toplevel/.git/config submodule.$name.ignore all',
         cwd=wd)
-    self.run_git(
-        'config', '--add', 'remote.origin.fetch',
-        '+refs/tags/*:refs/tags/*', cwd=wd)
+    if not self.options.no_history:
+      self.run_git(
+          'config', '--add', 'remote.origin.fetch',
+          '+refs/tags/*:refs/tags/*', cwd=wd)
     self.run_git('config', 'diff.ignoreSubmodules', 'all', cwd=wd)
 
 

data/vendor/depot_tools/fetch_configs/chromium.py

@@ -17,7 +17,6 @@ class Chromium(config_util.Config):
     url = 'https://chromium.googlesource.com/chromium/src.git'
     solution = { 'name'   :'src',
                  'url'    : url,
-                 'deps_file': '.DEPS.git',
                  'managed'   : False,
                  'custom_deps': {},
     }

data/vendor/depot_tools/fetch_configs/goma_client.py

@@ -0,0 +1,41 @@
+# Copyright 2018 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 sys
+
+import config_util  # pylint: disable=import-error
+
+
+# This class doesn't need an __init__ method, so we disable the warning
+# pylint: disable=no-init
+class GomaClient(config_util.Config):
+  """Basic Config class for Goma client."""
+
+  @staticmethod
+  def fetch_spec(_props):
+    return {
+      'type': 'gclient_git',
+      'gclient_git_spec': {
+        'solutions': [
+          {
+            'name'     : 'client',
+            'url'      : 'https://chromium.googlesource.com/infra/goma/client.git',
+            'deps_file': 'DEPS',
+            'managed'  : False,
+          }
+        ],
+      },
+    }
+
+  @staticmethod
+  def expected_root(_props):
+    return 'client'
+
+
+def main(argv=None):
+  return GomaClient().handle_args(argv)
+
+
+if __name__ == '__main__':
+  sys.exit(main(sys.argv))

data/vendor/depot_tools/fetch_configs/infra.py

@@ -21,7 +21,6 @@ class Infra(config_util.Config):
           {
             'name'     : 'infra',
             'url'      : 'https://chromium.googlesource.com/infra/infra.git',
-            'deps_file': '.DEPS.git',
             'managed'  : False,
           }
         ],

data/vendor/depot_tools/fetch_configs/infra_internal.py

@@ -22,7 +22,6 @@ class InfraInternal(config_util.Config):
         {
           'name': 'infra_internal',
           'url': url('chrome-internal', 'infra/infra_internal'),
-          'deps_file': '.DEPS.git',
           'managed': False
         },
       ],

data/vendor/depot_tools/gclient-new-workdir.py

@@ -50,6 +50,8 @@ def parse_options():
 
 
 def support_cow(src, dest):
+  # 'cp --reflink' always succeeds when 'src' is a symlink or a directory
+  assert os.path.isfile(src) and not os.path.islink(src)
   try:
     subprocess.check_output(['cp', '-a', '--reflink', src, dest],
                             stderr=subprocess.STDOUT)
@@ -74,6 +76,8 @@ def main():
   args = parse_options()
 
   gclient = os.path.join(args.repository, '.gclient')
+  if os.path.islink(gclient):
+    gclient = os.path.realpath(gclient)
   new_gclient = os.path.join(args.new_workdir, '.gclient')
 
   if try_vol_snapshot(args.repository, args.new_workdir):

data/vendor/depot_tools/gclient.py

@@ -75,6 +75,10 @@
 #   Example:
 #     target_os = [ "ios" ]
 #     target_os_only = True
+#
+# Specifying a target CPU
+#   To specify a target CPU, the variables target_cpu and target_cpu_only
+#   are available and are analagous to target_os and target_os_only.
 
 from __future__ import print_function
 
@@ -94,6 +98,7 @@ import sys
 import time
 import urlparse
 
+import detect_host_arch
 import fix_encoding
 import gclient_eval
 import gclient_scm
@@ -159,8 +164,10 @@ class Hook(object):
     self._verbose = verbose
 
   @staticmethod
-  def from_dict(d, variables=None, verbose=False):
+  def from_dict(d, variables=None, verbose=False, conditions=None):
     """Creates a Hook instance from a dict like in the DEPS file."""
+    # Merge any local and inherited conditions.
+    gclient_eval.UpdateCondition(d, 'and', conditions)
     return Hook(
         d['action'],
         d.get('pattern'),
@@ -200,7 +207,7 @@ class Hook(object):
         not gclient_eval.EvaluateCondition(self._condition, self._variables)):
       return
 
-    cmd = [arg.format(**self._variables) for arg in self._action]
+    cmd = [arg for arg in self._action]
 
     if cmd[0] == 'python':
       # If the hook specified "python" as the first item, the action is a
@@ -233,18 +240,14 @@ class Hook(object):
 class DependencySettings(object):
   """Immutable configuration settings."""
   def __init__(
-      self, parent, raw_url, url, managed, custom_deps, custom_vars,
-      custom_hooks, deps_file, should_process, relative,
-      condition, condition_value):
+      self, parent, url, managed, custom_deps, custom_vars,
+      custom_hooks, deps_file, should_process, relative, condition):
     # These are not mutable:
     self._parent = parent
     self._deps_file = deps_file
-    self._raw_url = raw_url
     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
@@ -268,17 +271,19 @@ class DependencySettings(object):
     self._custom_hooks = custom_hooks or []
 
     # Post process the url to remove trailing slashes.
-    if isinstance(self._url, basestring):
+    if isinstance(self.url, basestring):
       # 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, (None.__class__)):
+      self.set_url(self.url.replace('/@', '@'))
+    elif not isinstance(self.url, (None.__class__)):
       raise gclient_utils.Error(
           ('dependency url must be either string or None, '
-           'instead of %s') % self._url.__class__.__name__)
+           '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)
+    if self._deps_file:
+      for sep in ['/', '\\']:
+        self._deps_file = self._deps_file.replace(sep, os.sep)
 
   @property
   def deps_file(self):
@@ -317,11 +322,6 @@ class DependencySettings(object):
   def custom_hooks(self):
     return self._custom_hooks[:]
 
-  @property
-  def raw_url(self):
-    """URL before variable expansion."""
-    return self._raw_url
-
   @property
   def url(self):
     """URL after variable expansion."""
@@ -331,10 +331,6 @@ class DependencySettings(object):
   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:
@@ -342,6 +338,13 @@ class DependencySettings(object):
     else:
       return self.parent.target_os
 
+  @property
+  def target_cpu(self):
+    return self.parent.target_cpu
+
+  def set_url(self, url):
+    self._url = url
+
   def get_custom_deps(self, name, url):
     """Returns a custom deps if applicable."""
     if self.parent:
@@ -353,14 +356,13 @@ class DependencySettings(object):
 class Dependency(gclient_utils.WorkItem, DependencySettings):
   """Object that represents a dependency checkout."""
 
-  def __init__(self, parent, name, raw_url, url, managed, custom_deps,
+  def __init__(self, parent, name, url, managed, custom_deps,
                custom_vars, custom_hooks, deps_file, should_process,
-               relative, condition, condition_value):
+               should_recurse, relative, condition, print_outbuf=False):
     gclient_utils.WorkItem.__init__(self, name)
     DependencySettings.__init__(
-        self, parent, raw_url, url, managed, custom_deps, custom_vars,
-        custom_hooks, deps_file, should_process, relative,
-        condition, condition_value)
+        self, parent, url, managed, custom_deps, custom_vars,
+        custom_hooks, deps_file, should_process, relative, condition)
 
     # This is in both .gclient and DEPS files:
     self._deps_hooks = []
@@ -368,11 +370,8 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     self._pre_deps_hooks = []
 
     # Calculates properties:
-    self._parsed_url = None
     self._dependencies = []
     self._vars = {}
-    self._os_dependencies = {}
-    self._os_deps_hooks = {}
 
     # A cache of the files affected by the current operation, necessary for
     # hooks.
@@ -382,6 +381,7 @@ 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()
+    self._gn_args_from = None
     # Spec for .gni output to write (if any).
     self._gn_args_file = None
     self._gn_args = []
@@ -402,26 +402,84 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     # unavailable
     self._got_revision = None
 
-    # This is a mutable value that overrides the normal recursion limit for this
-    # dependency.  It is read from the actual DEPS file so cannot be set on
-    # class instantiation.
-    self.recursion_override = None
     # recursedeps is a mutable value that selectively overrides the default
-    # 'no recursion' setting on a dep-by-dep basis.  It will replace
-    # recursion_override.
+    # 'no recursion' setting on a dep-by-dep basis.
     #
-    # It will be a dictionary of {deps_name: {"deps_file": depfile_name}} or
-    # None.
-    self.recursedeps = None
+    # It will be a dictionary of {deps_name: depfile_namee}
+    self.recursedeps = {}
+
+    # Whether we should process this dependency's DEPS file.
+    self._should_recurse = should_recurse
+
+    self._OverrideUrl()
     # This is inherited from WorkItem.  We want the URL to be a resource.
-    if url and isinstance(url, basestring):
+    if self.url and isinstance(self.url, basestring):
       # The url is usually given to gclient either as https://blah@123
       # or just https://blah.  The @123 portion is irrelevant.
-      self.resources.append(url.split('@')[0])
+      self.resources.append(self.url.split('@')[0])
+
+    # Controls whether we want to print git's output when we first clone the
+    # dependency
+    self.print_outbuf = print_outbuf
 
     if not self.name and self.parent:
       raise gclient_utils.Error('Dependency without name')
 
+  def _OverrideUrl(self):
+    """Resolves the parsed url from the parent hierarchy."""
+    parsed_url = self.get_custom_deps(self._name, self.url)
+    if parsed_url != self.url:
+      logging.info('Dependency(%s)._OverrideUrl(%s) -> %s', self._name,
+                   self.url, parsed_url)
+      self.set_url(parsed_url)
+
+    elif isinstance(self.url, basestring):
+      parsed_url = urlparse.urlparse(self.url)
+      if (not parsed_url[0] and
+          not re.match(r'^\w+\@[\w\.-]+\:[\w\/]+', parsed_url[2])):
+        path = parsed_url[2]
+        if not path.startswith('/'):
+          raise gclient_utils.Error(
+              'relative DEPS entry \'%s\' must begin with a slash' % self.url)
+        # A relative url. Get the parent url, strip from the last '/'
+        # (equivalent to unix basename), and append the relative url.
+        parent_url = self.parent.url
+        parsed_url = parent_url[:parent_url.rfind('/')] + self.url
+        logging.info('Dependency(%s)._OverrideUrl(%s) -> %s', self.name,
+                     self.url, parsed_url)
+        self.set_url(parsed_url)
+
+    elif self.url is None:
+      logging.info('Dependency(%s)._OverrideUrl(None) -> None', self._name)
+
+    else:
+      raise gclient_utils.Error('Unknown url type')
+
+  def PinToActualRevision(self):
+    """Updates self.url to the revision checked out on disk."""
+    if self.url is None:
+      return
+    url = None
+    scm = self.CreateSCM()
+    if os.path.isdir(scm.checkout_path):
+      revision = scm.revinfo(None, None, None)
+      url = '%s@%s' % (gclient_utils.SplitUrlRevision(self.url)[0], revision)
+    self.set_url(url)
+
+  def ToLines(self):
+    s = []
+    condition_part = (['    "condition": %r,' % self.condition]
+                      if self.condition else [])
+    s.extend([
+        '  # %s' % self.hierarchy(include_url=False),
+        '  "%s": {' % (self.name,),
+        '    "url": "%s",' % (self.url,),
+    ] + condition_part + [
+        '  },',
+        '',
+    ])
+    return s
+
   @property
   def requirements(self):
     """Calculate the list of requirements."""
@@ -436,9 +494,6 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     # This becomes messy for >2 depth as the DEPS file format is a dictionary,
     # thus unsorted, while the .gclient format is a list thus sorted.
     #
-    # * _recursion_limit is hard coded 2 and there is no hope to change this
-    # value.
-    #
     # Interestingly enough, the following condition only works in the case we
     # want: self is a 2nd level node. 3nd level node wouldn't need this since
     # they already have their parent as a requirement.
@@ -456,24 +511,8 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     return requirements
 
   @property
-  def try_recursedeps(self):
-    """Returns False if recursion_override is ever specified."""
-    if self.recursion_override is not None:
-      return False
-    return self.parent.try_recursedeps
-
-  @property
-  def recursion_limit(self):
-    """Returns > 0 if this dependency is not too recursed to be processed."""
-    # We continue to support the absence of recursedeps until tools and DEPS
-    # using recursion_override are updated.
-    if self.try_recursedeps and self.parent.recursedeps != None:
-      if self.name in self.parent.recursedeps:
-        return 1
-
-    if self.recursion_override is not None:
-      return self.recursion_override
-    return max(self.parent.recursion_limit - 1, 0)
+  def should_recurse(self):
+    return self._should_recurse
 
   def verify_validity(self):
     """Verifies that this Dependency is fine to add as a child of another one.
@@ -493,10 +532,8 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     # This require a full tree traversal with locks.
     siblings = [d for d in self.root.subtree(False) if d.name == self.name]
     for sibling in siblings:
-      self_url = self.LateOverride(self.url)
-      sibling_url = sibling.LateOverride(sibling.url)
       # Allow to have only one to be None or ''.
-      if self_url != sibling_url and bool(self_url) == bool(sibling_url):
+      if self.url != sibling.url and bool(self.url) == bool(sibling.url):
         raise gclient_utils.Error(
             ('Dependency %s specified more than once:\n'
             '  %s [%s]\n'
@@ -504,99 +541,15 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
             '  %s [%s]') % (
               self.name,
               sibling.hierarchy(),
-              sibling_url,
+              sibling.url,
               self.hierarchy(),
-              self_url))
+              self.url))
       # In theory we could keep it as a shadow of the other one. In
       # practice, simply ignore it.
       logging.warn('Won\'t process duplicate dependency %s' % sibling)
       return False
     return True
 
-  def LateOverride(self, url):
-    """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:
-      logging.info(
-          'Dependency(%s).LateOverride(%s) -> %s' %
-          (self.name, url, parsed_url))
-      return parsed_url
-
-    if isinstance(url, basestring):
-      parsed_url = urlparse.urlparse(url)
-      if (not parsed_url[0] and
-          not re.match(r'^\w+\@[\w\.-]+\:[\w\/]+', parsed_url[2])):
-        # A relative url. Fetch the real base.
-        path = parsed_url[2]
-        if not path.startswith('/'):
-          raise gclient_utils.Error(
-              'relative DEPS entry \'%s\' must begin with a slash' % url)
-        # Create a scm just to query the full url.
-        parent_url = self.parent.parsed_url
-        scm = gclient_scm.CreateSCM(
-            parent_url, self.root.root_dir, None, self.outbuf)
-        parsed_url = scm.FullUrlForRelativeUrl(url)
-      else:
-        parsed_url = url
-      logging.info(
-          'Dependency(%s).LateOverride(%s) -> %s' %
-          (self.name, url, parsed_url))
-      return parsed_url
-
-    if url is None:
-      logging.info(
-          'Dependency(%s).LateOverride(%s) -> %s' % (self.name, url, url))
-      return url
-
-    raise gclient_utils.Error('Unknown url type')
-
-  @staticmethod
-  def MergeWithOsDeps(deps, deps_os, target_os_list, process_all_deps):
-    """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."""
-    new_deps = deps.copy()
-    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 or process_all_deps
-
-        # 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.
@@ -604,9 +557,19 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
 
     # 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]
+    for dep_name, dep_info in self.custom_deps.iteritems():
+      if dep_name not in deps:
+        deps[dep_name] = {'url': dep_info, 'dep_type': 'git'}
+
+    # Make child deps conditional on any parent conditions. This ensures that,
+    # when flattened, recursed entries have the correct restrictions, even if
+    # not explicitly set in the recursed DEPS file. For instance, if
+    # "src/ios_foo" is conditional on "checkout_ios=True", then anything
+    # recursively included by "src/ios_foo/DEPS" should also require
+    # "checkout_ios=True".
+    if self.condition:
+      for value in deps.itervalues():
+        gclient_eval.UpdateCondition(value, 'and', self.condition)
 
     if rel_prefix:
       logging.warning('use_relative_paths enabled.')
@@ -624,38 +587,51 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     """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']
+      should_process = self.should_process
       if dep_value is None:
         continue
-      condition = None
-      condition_value = True
-      if isinstance(dep_value, basestring):
-        raw_url = dep_value
-      else:
-        # This should be guaranteed by schema checking in gclient_eval.
-        assert isinstance(dep_value, collections.Mapping)
-        raw_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')
-
-      url = raw_url.format(**self.get_vars())
-
-      if condition:
-        condition_value = gclient_eval.EvaluateCondition(
+
+      condition = dep_value.get('condition')
+      dep_type = dep_value.get('dep_type')
+
+      if condition and not self._get_option('process_all_deps', False):
+        should_process = should_process and gclient_eval.EvaluateCondition(
             condition, self.get_vars())
-        if not self._get_option('process_all_deps', False):
-          should_process = should_process and condition_value
-      deps_to_add.append(Dependency(
-          self, name, raw_url, url, None, None, self.custom_vars, None,
-          deps_file, should_process, use_relative_paths, condition,
-          condition_value))
+
+      if dep_type == 'cipd':
+        cipd_root = self.GetCipdRoot()
+        for package in dep_value.get('packages', []):
+          if 'version' in package:
+            # Matches version to vars value.
+            version = package['version']
+            package['version'] = version
+          deps_to_add.append(
+              CipdDependency(
+                  parent=self,
+                  name=name,
+                  dep_value=package,
+                  cipd_root=cipd_root,
+                  custom_vars=self.custom_vars,
+                  should_process=should_process,
+                  relative=use_relative_paths,
+                  condition=condition))
+      else:
+        url = dep_value.get('url')
+        deps_to_add.append(
+            GitDependency(
+                parent=self,
+                name=name,
+                url=url,
+                managed=True,
+                custom_deps=None,
+                custom_vars=self.custom_vars,
+                custom_hooks=None,
+                deps_file=self.recursedeps.get(name, self.deps_file),
+                should_process=should_process,
+                should_recurse=name in self.recursedeps,
+                relative=use_relative_paths,
+                condition=condition))
+
     deps_to_add.sort(key=lambda x: x.name)
     return deps_to_add
 
@@ -688,16 +664,10 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
 
     local_scope = {}
     if deps_content:
-      global_scope = {
-        'Var': lambda var_name: '{%s}' % var_name,
-        'deps_os': {},
-      }
-      # Eval the content.
       try:
-        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)
+        local_scope = gclient_eval.Parse(
+            deps_content, self._get_option('validate_syntax', False),
+            filepath, self.get_vars())
       except SyntaxError as e:
         gclient_utils.SyntaxErrorToError(filepath, e)
 
@@ -713,8 +683,14 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
             'ParseDepsFile(%s): allowed_hosts must be absent '
             'or a non-empty iterable' % self.name)
 
+    self._gn_args_from = local_scope.get('gclient_gn_args_from')
     self._gn_args_file = local_scope.get('gclient_gn_args_file')
     self._gn_args = local_scope.get('gclient_gn_args', [])
+    # It doesn't make sense to set all of these, since setting gn_args_from to
+    # another DEPS will make gclient ignore any other local gn_args* settings.
+    assert not (self._gn_args_from and self._gn_args_file), \
+        'Only specify one of "gclient_gn_args_from" or ' \
+        '"gclient_gn_args_file + gclient_gn_args".'
 
     self._vars = local_scope.get('vars', {})
     if self.parent:
@@ -740,22 +716,16 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     elif self._relative:
       rel_prefix = os.path.dirname(self.name)
 
-    deps = {}
-    for key, value in local_scope.get('deps', {}).iteritems():
-      deps[key.format(**self.get_vars())] = value
-
     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
+          '%s: Ignoring recursion = %d.', self.name, local_scope['recursion'])
+
     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}
+          self.recursedeps[ent] = self.deps_file
         else:  # (depname, depsfilename)
-          self.recursedeps[ent[0]] = {"deps_file": ent[1]}
+          self.recursedeps[ent[0]] = ent[1]
       logging.warning('Found recursedeps %r.', repr(self.recursedeps))
 
       if rel_prefix:
@@ -765,23 +735,16 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
           rel_deps[
               os.path.normpath(os.path.join(rel_prefix, depname))] = options
         self.recursedeps = rel_deps
+    # To get gn_args from another DEPS, that DEPS must be recursed into.
+    if self._gn_args_from:
+      assert self.recursedeps and self._gn_args_from in self.recursedeps, \
+              'The "gclient_gn_args_from" value must be in 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:
-      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 and not self._get_option(
-          'do_not_merge_os_specific_entries', False):
-        deps = self.MergeWithOsDeps(
-            deps, local_scope['deps_os'], target_os_list,
-            self._get_option('process_all_deps', False))
 
+    deps = local_scope.get('deps', {})
     deps_to_add = self._deps_to_objects(
         self._postprocess_deps(deps, rel_prefix), use_relative_paths)
 
@@ -791,29 +754,16 @@ 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)
-    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(), verbose=True)
-            for hook in os_hooks]
-
-      # Specifically append these to ensure that hooks_os run after hooks.
-      if not self._get_option('do_not_merge_os_specific_entries', False):
-        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:
       if 'action' in hook:
         hooks_to_run.append(hook)
 
-    if self.recursion_limit:
+    if self.should_recurse:
       self._pre_deps_hooks = [
-          Hook.from_dict(hook, variables=self.get_vars(), verbose=True)
+          Hook.from_dict(hook, variables=self.get_vars(), verbose=True,
+                         conditions=self.condition)
           for hook in local_scope.get('pre_deps_hooks', [])
       ]
 
@@ -833,7 +783,8 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
         self.add_dependency(dep)
     self._mark_as_parsed([
         Hook.from_dict(
-            h, variables=self.get_vars(), verbose=self.root._options.verbose)
+            h, variables=self.get_vars(), verbose=self.root._options.verbose,
+            conditions=self.condition)
         for h in hooks
     ])
 
@@ -855,9 +806,42 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
           bad_deps.append(dep)
     return bad_deps
 
+  def FuzzyMatchUrl(self, candidates):
+    """Attempts to find this dependency in the list of candidates.
+
+    It looks first for the URL of this dependency in the list of
+    candidates. If it doesn't succeed, and the URL ends in '.git', it will try
+    looking for the URL minus '.git'. Finally it will try to look for the name
+    of the dependency.
+
+    Args:
+      candidates: list, dict. The list of candidates in which to look for this
+          dependency. It can contain URLs as above, or dependency names like
+          "src/some/dep".
+
+    Returns:
+      If this dependency is not found in the list of candidates, returns None.
+      Otherwise, it returns under which name did we find this dependency:
+       - Its parsed url: "https://example.com/src.git'
+       - Its parsed url minus '.git': "https://example.com/src"
+       - Its name: "src"
+    """
+    if self.url:
+      origin, _ = gclient_utils.SplitUrlRevision(self.url)
+      if origin in candidates:
+        return origin
+      if origin.endswith('.git') and origin[:-len('.git')] in candidates:
+        return origin[:-len('.git')]
+      if origin + '.git' in candidates:
+        return origin + '.git'
+    if self.name in candidates:
+      return self.name
+    return None
+
   # Arguments number differs from overridden method
   # pylint: disable=arguments-differ
-  def run(self, revision_overrides, command, args, work_queue, options):
+  def run(self, revision_overrides, command, args, work_queue, options,
+          patch_refs):
     """Runs |command| then parse the DEPS file."""
     logging.info('Dependency(%s).run()' % self.name)
     assert self._file_list == []
@@ -868,21 +852,26 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     # copy state, so skip the SCM status check.
     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:
+    revision_override = revision_overrides.pop(
+        self.FuzzyMatchUrl(revision_overrides), None)
+    if not revision_override and not self.managed:
+      revision_override = 'unmanaged'
+    if run_scm and self.url:
       # Create a shallow copy to mutate revision.
       options = copy.copy(options)
       options.revision = revision_override
       self._used_revision = options.revision
-      self._used_scm = gclient_scm.CreateSCM(
-          parsed_url, self.root.root_dir, self.name, self.outbuf,
-          out_cb=work_queue.out_cb)
+      self._used_scm = self.CreateSCM(out_cb=work_queue.out_cb)
       self._got_revision = self._used_scm.RunCommand(command, options, args,
                                                      file_list)
+
+      patch_repo = self.url.split('@')[0]
+      patch_ref = patch_refs.pop(self.FuzzyMatchUrl(patch_refs), None)
+      if command == 'update' and patch_ref is not None:
+        self._used_scm.apply_patch_ref(patch_repo, patch_ref, options,
+                                       file_list)
+
       if file_list:
         file_list = [os.path.join(self.name, f.strip()) for f in file_list]
 
@@ -899,13 +888,14 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
         while file_list[i].startswith(('\\', '/')):
           file_list[i] = file_list[i][1:]
 
-    # Always parse the DEPS file.
-    self.ParseDepsFile()
-    self._run_is_done(file_list or [], parsed_url)
-    if command in ('update', 'revert') and not options.noprehooks:
-      self.RunPreDepsHooks()
+    if self.should_recurse:
+      self.ParseDepsFile()
+
+    self._run_is_done(file_list or [])
 
-    if self.recursion_limit:
+    if self.should_recurse:
+      if command in ('update', 'revert') and not options.noprehooks:
+        self.RunPreDepsHooks()
       # Parse the dependencies of this dependency.
       for s in self.dependencies:
         if s.should_process:
@@ -913,7 +903,7 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
 
     if command == 'recurse':
       # Skip file only checkout.
-      scm = gclient_scm.GetScmName(parsed_url)
+      scm = self.GetScmName()
       if not options.scm or scm in options.scm:
         cwd = os.path.normpath(os.path.join(self.root.root_dir, self.name))
         # Pass in the SCM type as an env variable.  Make sure we don't put
@@ -921,8 +911,8 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
         env = os.environ.copy()
         if scm:
           env['GCLIENT_SCM'] = str(scm)
-        if parsed_url:
-          env['GCLIENT_URL'] = str(parsed_url)
+        if self.url:
+          env['GCLIENT_URL'] = str(self.url)
         env['GCLIENT_DEP_PATH'] = str(self.name)
         if options.prepend_dir and scm == 'git':
           print_stdout = False
@@ -953,7 +943,7 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
           print_stdout = True
           filter_fn = None
 
-        if parsed_url is None:
+        if self.url is None:
           print('Skipped omitted dependency %s' % cwd, file=sys.stderr)
         elif os.path.isdir(cwd):
           try:
@@ -967,6 +957,12 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
         else:
           print('Skipped missing %s' % cwd, file=sys.stderr)
 
+  def GetScmName(self):
+    raise NotImplementedError()
+
+  def CreateSCM(self, out_cb=None):
+    raise NotImplementedError()
+
   def HasGNArgsFile(self):
     return self._gn_args_file is not None
 
@@ -982,10 +978,9 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
       f.write('\n'.join(lines))
 
   @gclient_utils.lockedmethod
-  def _run_is_done(self, file_list, parsed_url):
+  def _run_is_done(self, file_list):
     # Both these are kept for hooks that are run as a separate tree traversal.
     self._file_list = file_list
-    self._parsed_url = parsed_url
     self._processed = True
 
   def GetHooks(self, options):
@@ -994,7 +989,7 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     RunOnDeps() must have been called before to load the DEPS.
     """
     result = []
-    if not self.should_process or not self.recursion_limit:
+    if not self.should_process or not self.should_recurse:
       # Don't run the hook when it is above recursion_limit.
       return result
     # If "--force" was specified, run all hooks regardless of what files have
@@ -1003,24 +998,11 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
       # TODO(maruel): If the user is using git, then we don't know
       # what files have changed so we always run all hooks. It'd be nice to fix
       # that.
-      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'))):
-        result.extend(self.deps_hooks)
-      else:
-        for hook in self.deps_hooks:
-          if hook.matches(self.file_list_and_children):
-            result.append(hook)
+      result.extend(self.deps_hooks)
     for s in self.dependencies:
       result.extend(s.GetHooks(options))
     return result
 
-  def WriteGNArgsFilesRecursively(self, dependencies):
-    for dep in dependencies:
-      if dep.HasGNArgsFile():
-        dep.WriteGNArgsFile()
-      self.WriteGNArgsFilesRecursively(dep.dependencies)
-
   def RunHooksRecursively(self, options, progress):
     assert self.hooks_ran == False
     self._hooks_ran = True
@@ -1045,6 +1027,13 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
     for hook in self.pre_deps_hooks:
       hook.run(self.root.root_dir)
 
+  def GetCipdRoot(self):
+    if self.root is self:
+      # Let's not infinitely recurse. If this is root and isn't an
+      # instance of GClient, do nothing.
+      return None
+    return self.root.GetCipdRoot()
+
   def subtree(self, include_all):
     """Breadth first recursion excluding root node."""
     dependencies = self.dependencies
@@ -1069,31 +1058,16 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
   def dependencies(self):
     return tuple(self._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 os_deps_hooks(self):
-    return dict(self._os_deps_hooks)
-
   @property
   @gclient_utils.lockedmethod
   def pre_deps_hooks(self):
     return tuple(self._pre_deps_hooks)
 
-  @property
-  @gclient_utils.lockedmethod
-  def parsed_url(self):
-    return self._parsed_url
-
   @property
   @gclient_utils.lockedmethod
   def deps_parsed(self):
@@ -1144,7 +1118,7 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
 
   def __str__(self):
     out = []
-    for i in ('name', 'url', 'parsed_url', 'custom_deps',
+    for i in ('name', 'url', 'custom_deps',
               'custom_vars', 'deps_hooks', 'file_list', 'should_process',
               'processed', 'hooks_ran', 'deps_parsed', 'requirements',
               'allowed_hosts'):
@@ -1177,21 +1151,47 @@ class Dependency(gclient_utils.WorkItem, DependencySettings):
       i = i.parent
     return out
 
+  def hierarchy_data(self):
+    """Returns a machine-readable hierarchical reference to a Dependency."""
+    d = self
+    out = []
+    while d and d.name:
+      out.insert(0, (d.name, d.url))
+      d = d.parent
+    return tuple(out)
+
   def get_vars(self):
     """Returns a dictionary of effective variable values
     (DEPS file contents with applied custom_vars overrides)."""
     # Provide some built-in variables.
     result = {
         'checkout_android': 'android' in self.target_os,
+        'checkout_chromeos': 'chromeos' in self.target_os,
         'checkout_fuchsia': 'fuchsia' in self.target_os,
         'checkout_ios': 'ios' in self.target_os,
         'checkout_linux': 'unix' in self.target_os,
         'checkout_mac': 'mac' in self.target_os,
         'checkout_win': 'win' in self.target_os,
         'host_os': _detect_host_os(),
+
+        'checkout_arm': 'arm' in self.target_cpu,
+        'checkout_arm64': 'arm64' in self.target_cpu,
+        'checkout_x86': 'x86' in self.target_cpu,
+        'checkout_mips': 'mips' in self.target_cpu,
+        'checkout_ppc': 'ppc' in self.target_cpu,
+        'checkout_s390': 's390' in self.target_cpu,
+        'checkout_x64': 'x64' in self.target_cpu,
+        'host_cpu': detect_host_arch.HostArch(),
     }
-    # Variables defined in DEPS file override built-in ones.
+    # Variable precedence:
+    # - built-in
+    # - DEPS vars
+    # - parents, from first to last
+    # - custom_vars overrides
     result.update(self._vars)
+    if self.parent:
+      parent_vars = self.parent.get_vars()
+      result.update(parent_vars)
     result.update(self.custom_vars or {})
     return result
 
@@ -1209,7 +1209,23 @@ def _detect_host_os():
   return _PLATFORM_MAPPING[sys.platform]
 
 
-class GClient(Dependency):
+class GitDependency(Dependency):
+  """A Dependency object that represents a single git checkout."""
+
+  #override
+  def GetScmName(self):
+    """Always 'git'."""
+    return 'git'
+
+  #override
+  def CreateSCM(self, out_cb=None):
+    """Create a Wrapper instance suitable for handling this git dependency."""
+    return gclient_scm.GitWrapper(
+        self.url, self.root.root_dir, self.name, self.outbuf, out_cb,
+        print_outbuf=self.print_outbuf)
+
+
+class GClient(GitDependency):
   """Object that represent a gclient checkout. A tree of Dependency(), one per
   solution or DEPS entry."""
 
@@ -1226,6 +1242,7 @@ class GClient(Dependency):
     "linux3": "unix",
     "android": "android",
     "ios": "ios",
+    "fuchsia": "fuchsia",
   }
 
   DEFAULT_CLIENT_FILE_TEXT = ("""\
@@ -1242,28 +1259,30 @@ solutions = [
 cache_dir = %(cache_dir)r
 """)
 
-  DEFAULT_SNAPSHOT_SOLUTION_TEXT = ("""\
-  { "name"        : "%(solution_name)s",
-    "url"         : "%(solution_url)s",
-    "deps_file"   : "%(deps_file)s",
-    "managed"     : %(managed)s,
-    "custom_deps" : {
-%(solution_deps)s    },
-  },
-""")
-
   DEFAULT_SNAPSHOT_FILE_TEXT = ("""\
 # Snapshot generated with gclient revinfo --snapshot
-solutions = [
-%(solution_list)s]
+solutions = %(solution_list)s
 """)
 
   def __init__(self, root_dir, options):
     # Do not change previous behavior. Only solution level and immediate DEPS
     # are processed.
     self._recursion_limit = 2
-    Dependency.__init__(self, None, None, None, None, True, None, None, None,
-                        'unused', True, None, None, True)
+    super(GClient, self).__init__(
+        parent=None,
+        name=None,
+        url=None,
+        managed=True,
+        custom_deps=None,
+        custom_vars=None,
+        custom_hooks=None,
+        deps_file='unused',
+        should_process=True,
+        should_recurse=True,
+        relative=None,
+        condition=None,
+        print_outbuf=True)
+
     self._options = options
     if options.deps_os:
       enforced_os = options.deps_os.split(',')
@@ -1272,7 +1291,9 @@ solutions = [
     if 'all' in enforced_os:
       enforced_os = self.DEPS_OS_CHOICES.itervalues()
     self._enforced_os = tuple(set(enforced_os))
+    self._enforced_cpu = detect_host_arch.HostArch(),
     self._root_dir = root_dir
+    self._cipd_root = None
     self.config_content = None
 
   def _CheckConfig(self):
@@ -1280,8 +1301,7 @@ solutions = [
     solutions."""
     for dep in self.dependencies:
       if dep.managed and dep.url:
-        scm = gclient_scm.CreateSCM(
-            dep.url, self.root_dir, dep.name, self.outbuf)
+        scm = dep.CreateSCM()
         actual_url = scm.GetActualRemoteURL(self._options)
         if actual_url and not scm.DoesRemoteURLMatch(self._options):
           mirror = scm.GetCacheMirror()
@@ -1305,10 +1325,10 @@ You should ensure that the URL listed in .gclient is correct and either change
 it or fix the checkout.
 '''  % {'checkout_path': os.path.join(self.root_dir, dep.name),
         'expected_url': dep.url,
-        'expected_scm': gclient_scm.GetScmName(dep.url),
+        'expected_scm': dep.GetScmName(),
         'mirror_string' : mirror_string,
         'actual_url': actual_url,
-        'actual_scm': gclient_scm.GetScmName(actual_url)})
+        'actual_scm': dep.GetScmName()})
 
   def SetConfig(self, content):
     assert not self.dependencies
@@ -1326,6 +1346,13 @@ it or fix the checkout.
     else:
       self._enforced_os = tuple(set(self._enforced_os).union(target_os))
 
+    # Append any target CPU that is not already being enforced to the tuple.
+    target_cpu = config_dict.get('target_cpu', [])
+    if config_dict.get('target_cpu_only', False):
+      self._enforced_cpu = tuple(set(target_cpu))
+    else:
+      self._enforced_cpu = tuple(set(self._enforced_cpu).union(target_cpu))
+
     cache_dir = config_dict.get('cache_dir', self._options.cache_dir)
     if cache_dir:
       cache_dir = os.path.join(self.root_dir, cache_dir)
@@ -1338,20 +1365,27 @@ it or fix the checkout.
       raise gclient_utils.Error('Can\'t use target_os_only if target_os is '
                                 'not specified')
 
+    if not target_cpu and config_dict.get('target_cpu_only', False):
+      raise gclient_utils.Error('Can\'t use target_cpu_only if target_cpu is '
+                                'not specified')
+
     deps_to_add = []
     for s in config_dict.get('solutions', []):
       try:
-        deps_to_add.append(Dependency(
-            self, s['name'], s['url'], s['url'],
-            s.get('managed', True),
-            s.get('custom_deps', {}),
-            s.get('custom_vars', {}),
-            s.get('custom_hooks', []),
-            s.get('deps_file', 'DEPS'),
-            True,
-            None,
-            None,
-            True))
+        deps_to_add.append(GitDependency(
+            parent=self,
+            name=s['name'],
+            url=s['url'],
+            managed=s.get('managed', True),
+            custom_deps=s.get('custom_deps', {}),
+            custom_vars=s.get('custom_vars', {}),
+            custom_hooks=s.get('custom_hooks', []),
+            deps_file=s.get('deps_file', 'DEPS'),
+            should_process=True,
+            should_recurse=True,
+            relative=None,
+            condition=None,
+            print_outbuf=True))
       except KeyError:
         raise gclient_utils.Error('Invalid .gclient file. Solution is '
                                   'incomplete: %s' % s)
@@ -1417,7 +1451,7 @@ it or fix the checkout.
     result = 'entries = {\n'
     for entry in self.root.subtree(False):
       result += '  %s: %s,\n' % (pprint.pformat(entry.name),
-          pprint.pformat(entry.parsed_url))
+          pprint.pformat(entry.url))
     result += '}\n'
     file_path = os.path.join(self.root_dir, self._options.entries_filename)
     logging.debug(result)
@@ -1445,10 +1479,6 @@ it or fix the checkout.
     revision_overrides = {}
     if self._options.head:
       return revision_overrides
-    if not self._options.revisions:
-      for s in self.dependencies:
-        if not s.managed:
-          self._options.revisions.append('%s@unmanaged' % s.name)
     if not self._options.revisions:
       return revision_overrides
     solutions_names = [s.name for s in self.dependencies]
@@ -1462,6 +1492,20 @@ it or fix the checkout.
       index += 1
     return revision_overrides
 
+  def _EnforcePatchRefs(self):
+    """Checks for patch refs."""
+    patch_refs = {}
+    if not self._options.patch_refs:
+      return patch_refs
+    for given_patch_ref in self._options.patch_refs:
+      patch_repo, _, patch_ref = given_patch_ref.partition('@')
+      if not patch_repo or not patch_ref:
+        raise gclient_utils.Error(
+            'Wrong revision format: %s should be of the form '
+            'patch_repo@patch_ref.' % given_patch_ref)
+      patch_refs[patch_repo] = patch_ref
+    return patch_refs
+
   def RunOnDeps(self, command, args, ignore_requirements=False, progress=True):
     """Runs a command on each dependency in a client and its dependencies.
 
@@ -1473,12 +1517,16 @@ it or fix the checkout.
       raise gclient_utils.Error('No solution specified')
 
     revision_overrides = {}
+    patch_refs = {}
     # 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',
                        'validate'):
       self._CheckConfig()
       revision_overrides = self._EnforceRevisions()
+
+    if command == 'update':
+      patch_refs = self._EnforcePatchRefs()
     # Disable progress for non-tty stdout.
     should_show_progress = (
         setup_color.IS_TTY and not self._options.verbose and progress)
@@ -1494,15 +1542,32 @@ it or fix the checkout.
     for s in self.dependencies:
       if s.should_process:
         work_queue.enqueue(s)
-    work_queue.flush(revision_overrides, command, args, options=self._options)
+    work_queue.flush(revision_overrides, command, args, options=self._options,
+                     patch_refs=patch_refs)
+
     if revision_overrides:
       print('Please fix your script, having invalid --revision flags will soon '
-            'considered an error.', file=sys.stderr)
+            'be considered an error.', file=sys.stderr)
+
+    if patch_refs:
+      raise gclient_utils.Error(
+          'The following --patch-ref flags were not used. Please fix it:\n%s' %
+          ('\n'.join(
+              patch_repo + '@' + patch_ref
+              for patch_repo, patch_ref in patch_refs.iteritems())))
+
+    if self._cipd_root:
+      self._cipd_root.run(command)
 
     # Once all the dependencies have been processed, it's now safe to write
-    # out any gn_args_files and run the hooks.
+    # out the gn_args_file and run the hooks.
     if command == 'update':
-      self.WriteGNArgsFilesRecursively(self.dependencies)
+      gn_args_dep = self.dependencies[0]
+      if gn_args_dep._gn_args_from:
+        deps_map = dict([(dep.name, dep) for dep in gn_args_dep.dependencies])
+        gn_args_dep = deps_map.get(gn_args_dep._gn_args_from)
+      if gn_args_dep and gn_args_dep.HasGNArgsFile():
+        gn_args_dep.WriteGNArgsFile()
 
     if not self._options.nohooks:
       if should_show_progress:
@@ -1529,7 +1594,7 @@ it or fix the checkout.
             (not any(path.startswith(entry + '/') for path in entries)) and
             os.path.exists(e_dir)):
           # The entry has been removed from DEPS.
-          scm = gclient_scm.CreateSCM(
+          scm = gclient_scm.GitWrapper(
               prev_url, self.root_dir, entry_fixed, self.outbuf)
 
           # Check to see if this directory is now part of a higher-up checkout.
@@ -1612,56 +1677,66 @@ it or fix the checkout.
     for s in self.dependencies:
       if s.should_process:
         work_queue.enqueue(s)
-    work_queue.flush({}, None, [], options=self._options)
+    work_queue.flush({}, None, [], options=self._options, patch_refs=None)
 
-    def GetURLAndRev(dep):
-      """Returns the revision-qualified SCM url for a Dependency."""
-      if dep.parsed_url is None:
-        return None
-      url, _ = gclient_utils.SplitUrlRevision(dep.parsed_url)
-      scm = gclient_scm.CreateSCM(
-          dep.parsed_url, self.root_dir, dep.name, self.outbuf)
-      if not os.path.isdir(scm.checkout_path):
-        return None
-      return '%s@%s' % (url, scm.revinfo(self._options, [], None))
+    def ShouldPrintRevision(dep):
+      return (not self._options.filter
+              or dep.FuzzyMatchUrl(self._options.filter))
 
     if self._options.snapshot:
-      new_gclient = ''
+      json_output = []
       # First level at .gclient
       for d in self.dependencies:
         entries = {}
         def GrabDeps(dep):
           """Recursively grab dependencies."""
           for d in dep.dependencies:
-            entries[d.name] = GetURLAndRev(d)
+            d.PinToActualRevision()
+            if ShouldPrintRevision(d):
+              entries[d.name] = d.url
             GrabDeps(d)
         GrabDeps(d)
-        custom_deps = []
-        for k in sorted(entries.keys()):
-          if entries[k]:
-            # Quotes aren't escaped...
-            custom_deps.append('      \"%s\": \'%s\',\n' % (k, entries[k]))
-          else:
-            custom_deps.append('      \"%s\": None,\n' % k)
-        new_gclient += self.DEFAULT_SNAPSHOT_SOLUTION_TEXT % {
-            'solution_name': d.name,
+        json_output.append({
+            'name': d.name,
             'solution_url': d.url,
             'deps_file': d.deps_file,
             'managed': d.managed,
-            'solution_deps': ''.join(custom_deps),
-        }
-      # Print the snapshot configuration file
-      print(self.DEFAULT_SNAPSHOT_FILE_TEXT % {'solution_list': new_gclient})
+            'custom_deps': entries,
+        })
+      if self._options.output_json == '-':
+        print(json.dumps(json_output, indent=2, separators=(',', ': ')))
+      elif self._options.output_json:
+        with open(self._options.output_json, 'w') as f:
+          json.dump(json_output, f)
+      else:
+        # Print the snapshot configuration file
+        print(self.DEFAULT_SNAPSHOT_FILE_TEXT % {
+            'solution_list': pprint.pformat(json_output, indent=2),
+        })
     else:
       entries = {}
       for d in self.root.subtree(False):
         if self._options.actual:
-          entries[d.name] = GetURLAndRev(d)
+          d.PinToActualRevision()
+        if ShouldPrintRevision(d):
+          entries[d.name] = d.url
+      if self._options.output_json:
+        json_output = {
+            name: {
+                'url': rev.split('@')[0] if rev else None,
+                'rev': rev.split('@')[1] if rev and '@' in rev else None,
+            }
+            for name, rev in entries.iteritems()
+        }
+        if self._options.output_json == '-':
+          print(json.dumps(json_output, indent=2, separators=(',', ': ')))
         else:
-          entries[d.name] = d.parsed_url
-      keys = sorted(entries.keys())
-      for x in keys:
-        print('%s: %s' % (x, entries[x]))
+          with open(self._options.output_json, 'w') as f:
+            json.dump(json_output, f)
+      else:
+        keys = sorted(entries.keys())
+        for x in keys:
+          print('%s: %s' % (x, entries[x]))
     logging.info(str(self))
 
   def ParseDepsFile(self):
@@ -1674,6 +1749,17 @@ it or fix the checkout.
     print('Loaded .gclient config in %s:\n%s' % (
         self.root_dir, self.config_content))
 
+  def GetCipdRoot(self):
+    if not self._cipd_root:
+      self._cipd_root = gclient_scm.CipdRoot(
+          self.root_dir,
+          # TODO(jbudorick): Support other service URLs as necessary.
+          # Service URLs should be constant over the scope of a cipd
+          # root, so a var per DEPS file specifying the service URL
+          # should suffice.
+          'https://chrome-infra-packages.appspot.com')
+    return self._cipd_root
+
   @property
   def root_dir(self):
     """Root directory of gclient checkout."""
@@ -1685,18 +1771,122 @@ it or fix the checkout.
     return self._enforced_os
 
   @property
-  def recursion_limit(self):
-    """How recursive can each dependencies in DEPS file can load DEPS file."""
-    return self._recursion_limit
+  def target_os(self):
+    return self._enforced_os
 
   @property
-  def try_recursedeps(self):
-    """Whether to attempt using recursedeps-style recursion processing."""
+  def target_cpu(self):
+    return self._enforced_cpu
+
+
+class CipdDependency(Dependency):
+  """A Dependency object that represents a single CIPD package."""
+
+  def __init__(
+      self, parent, name, dep_value, cipd_root,
+      custom_vars, should_process, relative, condition):
+    package = dep_value['package']
+    version = dep_value['version']
+    url = urlparse.urljoin(
+        cipd_root.service_url, '%s@%s' % (package, version))
+    super(CipdDependency, self).__init__(
+        parent=parent,
+        name=name + ':' + package,
+        url=url,
+        managed=None,
+        custom_deps=None,
+        custom_vars=custom_vars,
+        custom_hooks=None,
+        deps_file=None,
+        should_process=should_process,
+        should_recurse=False,
+        relative=relative,
+        condition=condition)
+    if relative:
+      # TODO(jbudorick): Implement relative if necessary.
+      raise gclient_utils.Error(
+          'Relative CIPD dependencies are not currently supported.')
+    self._cipd_package = None
+    self._cipd_root = cipd_root
+    # CIPD wants /-separated paths, even on Windows.
+    native_subdir_path = os.path.relpath(
+        os.path.join(self.root.root_dir, name), cipd_root.root_dir)
+    self._cipd_subdir = posixpath.join(*native_subdir_path.split(os.sep))
+    self._package_name = package
+    self._package_version = version
+
+  #override
+  def run(self, revision_overrides, command, args, work_queue, options,
+          patch_refs):
+    """Runs |command| then parse the DEPS file."""
+    logging.info('CipdDependency(%s).run()' % self.name)
+    if not self.should_process:
+      return
+    self._CreatePackageIfNecessary()
+    super(CipdDependency, self).run(revision_overrides, command, args,
+                                    work_queue, options, patch_refs)
+
+  def _CreatePackageIfNecessary(self):
+    # We lazily create the CIPD package to make sure that only packages
+    # that we want (as opposed to all packages defined in all DEPS files
+    # we parse) get added to the root and subsequently ensured.
+    if not self._cipd_package:
+      self._cipd_package = self._cipd_root.add_package(
+          self._cipd_subdir, self._package_name, self._package_version)
+
+  def ParseDepsFile(self):
+    """CIPD dependencies are not currently allowed to have nested deps."""
+    self.add_dependencies_and_close([], [])
+
+  #override
+  def verify_validity(self):
+    """CIPD dependencies allow duplicate name for packages in same directory."""
+    logging.info('Dependency(%s).verify_validity()' % self.name)
     return True
 
-  @property
-  def target_os(self):
-    return self._enforced_os
+  #override
+  def GetScmName(self):
+    """Always 'cipd'."""
+    return 'cipd'
+
+  #override
+  def CreateSCM(self, out_cb=None):
+    """Create a Wrapper instance suitable for handling this CIPD dependency."""
+    self._CreatePackageIfNecessary()
+    return gclient_scm.CipdWrapper(
+        self.url, self.root.root_dir, self.name, self.outbuf, out_cb,
+        root=self._cipd_root, package=self._cipd_package)
+
+  def ToLines(self):
+    """Return a list of lines representing this in a DEPS file."""
+    s = []
+    self._CreatePackageIfNecessary()
+    if self._cipd_package.authority_for_subdir:
+      condition_part = (['    "condition": %r,' % self.condition]
+                        if self.condition else [])
+      s.extend([
+          '  # %s' % self.hierarchy(include_url=False),
+          '  "%s": {' % (self.name.split(':')[0],),
+          '    "packages": [',
+      ])
+      for p in sorted(
+          self._cipd_root.packages(self._cipd_subdir),
+          cmp=lambda x, y: cmp(x.name, y.name)):
+        s.extend([
+            '      {',
+            '        "package": "%s",' % p.name,
+            '        "version": "%s",' % p.version,
+            '      },',
+        ])
+
+      s.extend([
+          '    ],',
+          '    "dep_type": "cipd",',
+      ] + condition_part + [
+          '  },',
+          '',
+      ])
+    return s
 
 
 #### gclient commands.
@@ -1775,9 +1965,7 @@ class Flattener(object):
 
     self._allowed_hosts = set()
     self._deps = {}
-    self._deps_os = {}
     self._hooks = []
-    self._hooks_os = {}
     self._pre_deps_hooks = []
     self._vars = {}
 
@@ -1798,24 +1986,16 @@ class Flattener(object):
     Arguments:
       dep (Dependency): dependency to process
     """
-    if dep.parsed_url is None:
+    if dep.url is None:
       return
 
     # Make sure the revision is always fully specified (a hash),
     # as opposed to refs or tags which might change. Similarly,
     # shortened shas might become ambiguous; make sure to always
     # use full one for pinning.
-    url, revision = gclient_utils.SplitUrlRevision(dep.parsed_url)
-    if revision and gclient_utils.IsFullGitSha(revision):
-      return
-
-    scm = gclient_scm.CreateSCM(
-        dep.parsed_url, self._client.root_dir, dep.name, dep.outbuf)
-    revinfo = scm.revinfo(self._client._options, [], None)
-
-    dep._parsed_url = dep._url = '%s@%s' % (url, revinfo)
-    raw_url, _ = gclient_utils.SplitUrlRevision(dep._raw_url)
-    dep._raw_url = '%s@%s' % (raw_url, revinfo)
+    revision = gclient_utils.SplitUrlRevision(dep.url)[1]
+    if not revision or not gclient_utils.IsFullGitSha(revision):
+      dep.PinToActualRevision()
 
   def _flatten(self, pin_all_deps=False):
     """Runs the flattener. Saves resulting DEPS string.
@@ -1832,14 +2012,9 @@ class Flattener(object):
       for dep in self._deps.itervalues():
         self._pin_dep(dep)
 
-      for os_deps in self._deps_os.itervalues():
-        for dep in os_deps.itervalues():
-          self._pin_dep(dep)
-
     def add_deps_file(dep):
       # Only include DEPS files referenced by recursedeps.
-      if not (dep.parent is None or
-              (dep.name in (dep.parent.recursedeps or {}))):
+      if not dep.should_recurse:
         return
       deps_file = dep.deps_file
       deps_path = os.path.join(self._client.root_dir, dep.name, deps_file)
@@ -1850,27 +2025,22 @@ class Flattener(object):
         deps_path = os.path.join(self._client.root_dir, dep.name, deps_file)
         if not os.path.exists(deps_path):
           return
-      assert dep.parsed_url
-      self._deps_files.add((dep.parsed_url, deps_file))
+      assert dep.url
+      self._deps_files.add((dep.url, deps_file, dep.hierarchy_data()))
     for dep in self._deps.itervalues():
       add_deps_file(dep)
-    for os_deps in self._deps_os.itervalues():
-      for dep in os_deps.itervalues():
-        add_deps_file(dep)
 
+    gn_args_dep = self._deps.get(self._client.dependencies[0]._gn_args_from,
+                                 self._client.dependencies[0])
     self._deps_string = '\n'.join(
-        _GNSettingsToLines(
-            self._client.dependencies[0]._gn_args_file,
-            self._client.dependencies[0]._gn_args) +
+        _GNSettingsToLines(gn_args_dep._gn_args_file, gn_args_dep._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) +
         ['# %s, %s' % (url, deps_file)
-         for url, deps_file in sorted(self._deps_files)] +
+         for url, deps_file, _ in sorted(self._deps_files)] +
         [''])  # Ensure newline at end of file.
 
   def _add_dep(self, dep):
@@ -1884,81 +2054,50 @@ class Flattener(object):
     if dep.url:
       self._deps[dep.name] = dep
 
-  def _add_os_dep(self, os_dep, dep_os):
-    """Helper to add an OS-specific dependency to flattened DEPS.
-
-    Arguments:
-      os_dep (Dependency): dependency to add
-      dep_os (str): name of the OS
-    """
-    assert (
-        os_dep.name not in self._deps_os.get(dep_os, {}) or
-        self._deps_os.get(dep_os, {}).get(os_dep.name) == os_dep), (
-            os_dep.name, self._deps_os.get(dep_os, {}).get(os_dep.name))
-    if os_dep.url:
-      # OS-specific deps need to have their full URL resolved manually.
-      assert not os_dep.parsed_url, (os_dep, os_dep.parsed_url)
-      os_dep._parsed_url = os_dep.LateOverride(os_dep.url)
-
-      self._deps_os.setdefault(dep_os, {})[os_dep.name] = os_dep
-
-  def _flatten_dep(self, dep, dep_os=None):
+  def _flatten_dep(self, dep):
     """Visits a dependency in order to flatten it (see CMDflatten).
 
     Arguments:
       dep (Dependency): dependency to process
-      dep_os (str or None): name of the OS |dep| is specific to
     """
-    logging.debug('_flatten_dep(%s, %s)', dep.name, dep_os)
+    logging.debug('_flatten_dep(%s)', dep.name)
 
-    if not dep.deps_parsed:
-      dep.ParseDepsFile()
+    assert dep.deps_parsed, (
+        "Attempted to flatten %s but it has not been processed." % dep.name)
 
     self._allowed_hosts.update(dep.allowed_hosts)
 
-    # Only include vars listed in the DEPS files, not possible local overrides.
+    # Only include vars explicitly listed in the DEPS files or gclient solution,
+    # not automatic, local overrides (i.e. not all of dep.get_vars()).
+    hierarchy = dep.hierarchy(include_url=False)
     for key, value in dep._vars.iteritems():
       # Make sure there are no conflicting variables. It is fine however
       # to use same variable name, as long as the value is consistent.
       assert key not in self._vars or self._vars[key][1] == value
-      self._vars[key] = (dep, value)
+      self._vars[key] = (hierarchy, value)
+    # Override explicit custom variables.
+    for key, value in dep.custom_vars.iteritems():
+      # Do custom_vars that don't correspond to DEPS vars ever make sense? DEPS
+      # conditionals shouldn't be using vars that aren't also defined in the
+      # DEPS (presubmit actually disallows this), so any new custom_var must be
+      # unused in the DEPS, so no need to add it to the flattened output either.
+      if key not in self._vars:
+        continue
+      # Don't "override" existing vars if it's actually the same value.
+      elif self._vars[key][1] == value:
+        continue
+      # Anything else is overriding a default value from the DEPS.
+      self._vars[key] = (hierarchy + ' [custom_var override]', value)
 
     self._pre_deps_hooks.extend([(dep, hook) for hook in dep.pre_deps_hooks])
-
-    if dep_os:
-      if dep.deps_hooks:
-        self._hooks_os.setdefault(dep_os, []).extend(
-            [(dep, hook) for hook in dep.deps_hooks])
-    else:
-      self._hooks.extend([(dep, hook) for hook in dep.deps_hooks])
+    self._hooks.extend([(dep, hook) for hook in dep.deps_hooks])
 
     for sub_dep in dep.dependencies:
-      if dep_os:
-        self._add_os_dep(sub_dep, dep_os)
-      else:
-        self._add_dep(sub_dep)
-
-    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])
-
-    for sub_dep_os, os_deps in dep.os_dependencies.iteritems():
-      for os_dep in os_deps:
-        self._add_os_dep(os_dep, sub_dep_os)
-
-    # Process recursedeps. |deps_by_name| is a map where keys are dependency
-    # names, and values are maps of OS names to |Dependency| instances.
-    # |None| in place of OS name means the dependency is not OS-specific.
-    deps_by_name = dict((d.name, {None: d}) for d in dep.dependencies)
-    for sub_dep_os, os_deps in dep.os_dependencies.iteritems():
-      for os_dep in os_deps:
-        assert sub_dep_os not in deps_by_name.get(os_dep.name, {}), (
-            os_dep.name, sub_dep_os)
-        deps_by_name.setdefault(os_dep.name, {})[sub_dep_os] = os_dep
-    for recurse_dep_name in (dep.recursedeps or []):
-      dep_info = deps_by_name[recurse_dep_name]
-      for sub_dep_os, os_dep in dep_info.iteritems():
-        self._flatten_dep(os_dep, dep_os=(sub_dep_os or dep_os))
+      self._add_dep(sub_dep)
+
+    for d in dep.dependencies:
+      if d.should_recurse:
+        self._flatten_dep(d)
 
 
 def CMDflatten(parser, args):
@@ -1974,7 +2113,6 @@ def CMDflatten(parser, args):
             'for checked out deps, NOT deps_os.'))
   options, args = parser.parse_args(args)
 
-  options.do_not_merge_os_specific_entries = True
   options.nohooks = True
   options.process_all_deps = True
   client = GClient.LoadCurrentConfig(options)
@@ -1993,7 +2131,7 @@ def CMDflatten(parser, args):
   else:
     print(flattener.deps_string)
 
-  deps_files = [{'url': d[0], 'deps_file': d[1]}
+  deps_files = [{'url': d[0], 'deps_file': d[1], 'hierarchy': d[2]}
                 for d in sorted(flattener.deps_files)]
   if options.output_deps_files:
     with open(options.output_deps_files, 'w') as f:
@@ -2028,17 +2166,8 @@ def _DepsToLines(deps):
   if not deps:
     return []
   s = ['deps = {']
-  for name, dep in sorted(deps.iteritems()):
-    condition_part = (['    "condition": %r,' % dep.condition]
-                      if dep.condition else [])
-    s.extend([
-        '  # %s' % dep.hierarchy(include_url=False),
-        '  "%s": {' % (name,),
-        '    "url": "%s",' % (dep.raw_url,),
-    ] + condition_part + [
-        '  },',
-        '',
-    ])
+  for _, dep in sorted(deps.iteritems()):
+    s.extend(dep.ToLines())
   s.extend(['}', ''])
   return s
 
@@ -2056,7 +2185,7 @@ def _DepsOsToLines(deps_os):
       s.extend([
           '    # %s' % dep.hierarchy(include_url=False),
           '    "%s": {' % (name,),
-          '      "url": "%s",' % (dep.raw_url,),
+          '      "url": "%s",' % (dep.url,),
       ] + condition_part + [
           '    },',
           '',
@@ -2129,9 +2258,9 @@ def _VarsToLines(variables):
     return []
   s = ['vars = {']
   for key, tup in sorted(variables.iteritems()):
-    dep, value = tup
+    hierarchy, value = tup
     s.extend([
-        '  # %s' % dep.hierarchy(include_url=False),
+        '  # %s' % hierarchy,
         '  "%s": %r,' % (key, value),
         '',
     ])
@@ -2331,9 +2460,21 @@ def CMDsync(parser, args):
                     dest='revisions', metavar='REV', default=[],
                     help='Enforces revision/hash for the solutions with the '
                          'format src@rev. The src@ part is optional and can be '
-                         'skipped. -r can be used multiple times when .gclient '
-                         'has multiple solutions configured and will work even '
-                         'if the src@ part is skipped.')
+                         'skipped. You can also specify URLs instead of paths '
+                         'and gclient will find the solution corresponding to '
+                         'the given URL. If a path is also specified, the URL '
+                         'takes precedence. -r can be used multiple times when '
+                         '.gclient has multiple solutions configured, and will '
+                         'work even if the src@ part is skipped.')
+  parser.add_option('--patch-ref', action='append',
+                    dest='patch_refs', metavar='GERRIT_REF', default=[],
+                    help='Patches the given reference with the format dep@ref. '
+                         'For dep, you can specify URLs as well as paths, with '
+                         'URLs taking preference. The reference will be '
+                         'applied to the necessary path, will be rebased on '
+                         'top what the dep was synced to, and then will do a '
+                         'soft reset. Use --no-rebase-patch-ref and '
+                         '--reset-patch-ref to disable this behavior.')
   parser.add_option('--with_branch_heads', action='store_true',
                     help='Clone git "branch_heads" refspecs in addition to '
                          'the default refspecs. This adds about 1/2GB to a '
@@ -2363,10 +2504,6 @@ def CMDsync(parser, args):
                     help='override deps for the specified (comma-separated) '
                          'platform(s); \'all\' will process all deps_os '
                          'references')
-  # TODO(phajdan.jr): use argparse.SUPPRESS to hide internal flags.
-  parser.add_option('--do-not-merge-os-specific-entries', action='store_true',
-                    help='INTERNAL ONLY - disables merging of deps_os and '
-                         'hooks_os to dependencies and hooks')
   parser.add_option('--process-all-deps', action='store_true',
                     help='Check out all deps, even for different OS-es, '
                          'or with conditions evaluating to false')
@@ -2405,6 +2542,12 @@ def CMDsync(parser, args):
   parser.add_option('--disable-syntax-validation', action='store_false',
                     dest='validate_syntax',
                     help='Disable validation of .gclient and DEPS syntax.')
+  parser.add_option('--no-rebase-patch-ref', action='store_false',
+                    dest='rebase_patch_ref', default=True,
+                    help='Bypass rebase of the patch ref after checkout.')
+  parser.add_option('--no-reset-patch-ref', action='store_false',
+                    dest='reset_patch_ref', default=True,
+                    help='Bypass calling reset after patching the ref.')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
 
@@ -2422,6 +2565,10 @@ def CMDsync(parser, args):
     slns = {}
     for d in client.subtree(True):
       normed = d.name.replace('\\', '/').rstrip('/') + '/'
+      if normed in slns and not d.should_process:
+        # If an unprocessed dependency would override an existing dependency,
+        # ignore it.
+        continue
       slns[normed] = {
           'revision': d.got_revision,
           'scm': d.used_scm.name if d.used_scm else None,
@@ -2533,6 +2680,12 @@ def CMDrevinfo(parser, args):
                     help='creates a snapshot .gclient file of the current '
                          'version of all repositories to reproduce the tree, '
                          'implies -a')
+  parser.add_option('--filter', action='append', dest='filter',
+                     help='Display revision information only for the specified '
+                          'dependencies (filtered by URL or path).')
+  parser.add_option('--output-json',
+                    help='Output a json document to this path containing '
+                         'information about the revisions.')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
@@ -2541,6 +2694,109 @@ def CMDrevinfo(parser, args):
   return 0
 
 
+def CMDgetdep(parser, args):
+  """Gets revision information and variable values from a DEPS file."""
+  parser.add_option('--var', action='append',
+                    dest='vars', metavar='VAR', default=[],
+                    help='Gets the value of a given variable.')
+  parser.add_option('-r', '--revision', action='append',
+                    dest='revisions', metavar='DEP', default=[],
+                    help='Gets the revision/version for the given dependency. '
+                         'If it is a git dependency, dep must be a path. If it '
+                         'is a CIPD dependency, dep must be of the form '
+                         'path:package.')
+  parser.add_option('--deps-file', default='DEPS',
+                    # TODO(ehmaldonado): Try to find the DEPS file pointed by
+                    # .gclient first.
+                    help='The DEPS file to be edited. Defaults to the DEPS '
+                         'file in the current directory.')
+  (options, args) = parser.parse_args(args)
+
+  if not os.path.isfile(options.deps_file):
+    raise gclient_utils.Error(
+        'DEPS file %s does not exist.' % options.deps_file)
+  with open(options.deps_file) as f:
+    contents = f.read()
+  local_scope = gclient_eval.Exec(contents, options.deps_file)
+
+  for var in options.vars:
+    print(gclient_eval.GetVar(local_scope, var))
+
+  for name in options.revisions:
+    if ':' in name:
+      name, _, package = name.partition(':')
+      if not name or not package:
+        parser.error(
+            'Wrong CIPD format: %s:%s should be of the form path:pkg.'
+            % (name, package))
+      print(gclient_eval.GetCIPD(local_scope, name, package))
+    else:
+      print(gclient_eval.GetRevision(local_scope, name))
+
+
+def CMDsetdep(parser, args):
+  """Modifies dependency revisions and variable values in a DEPS file"""
+  parser.add_option('--var', action='append',
+                    dest='vars', metavar='VAR=VAL', default=[],
+                    help='Sets a variable to the given value with the format '
+                         'name=value.')
+  parser.add_option('-r', '--revision', action='append',
+                    dest='revisions', metavar='DEP@REV', default=[],
+                    help='Sets the revision/version for the dependency with '
+                         'the format dep@rev. If it is a git dependency, dep '
+                         'must be a path and rev must be a git hash or '
+                         'reference (e.g. src/dep@deadbeef). If it is a CIPD '
+                         'dependency, dep must be of the form path:package and '
+                         'rev must be the package version '
+                         '(e.g. src/pkg:chromium/pkg@2.1-cr0).')
+  parser.add_option('--deps-file', default='DEPS',
+                    # TODO(ehmaldonado): Try to find the DEPS file pointed by
+                    # .gclient first.
+                    help='The DEPS file to be edited. Defaults to the DEPS '
+                         'file in the current directory.')
+  (options, args) = parser.parse_args(args)
+  if args:
+    parser.error('Unused arguments: "%s"' % '" "'.join(args))
+  if not options.revisions and not options.vars:
+    parser.error(
+        'You must specify at least one variable or revision to modify.')
+
+  if not os.path.isfile(options.deps_file):
+    raise gclient_utils.Error(
+        'DEPS file %s does not exist.' % options.deps_file)
+  with open(options.deps_file) as f:
+    contents = f.read()
+  local_scope = gclient_eval.Exec(contents, options.deps_file)
+
+  for var in options.vars:
+    name, _, value = var.partition('=')
+    if not name or not value:
+      parser.error(
+          'Wrong var format: %s should be of the form name=value.' % var)
+    if name in local_scope['vars']:
+      gclient_eval.SetVar(local_scope, name, value)
+    else:
+      gclient_eval.AddVar(local_scope, name, value)
+
+  for revision in options.revisions:
+    name, _, value = revision.partition('@')
+    if not name or not value:
+      parser.error(
+          'Wrong dep format: %s should be of the form dep@rev.' % revision)
+    if ':' in name:
+      name, _, package = name.partition(':')
+      if not name or not package:
+        parser.error(
+            'Wrong CIPD format: %s:%s should be of the form path:pkg@version.'
+            % (name, package))
+      gclient_eval.SetCIPD(local_scope, name, package, value)
+    else:
+      gclient_eval.SetRevision(local_scope, name, value)
+
+  with open(options.deps_file, 'w') as f:
+    f.write(gclient_eval.RenderDEPSFile(local_scope))
+
+
 def CMDverify(parser, args):
   """Verifies the DEPS file deps are only from allowed_hosts."""
   (options, args) = parser.parse_args(args)