Have the DEPS only parsed in the relevant thread.

gclient.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 """Meta checkout manager supporting both Subversion and GIT.
 
 Files
   .gclient      : Current client configuration, written by 'config' command.
                   Format is a Python script defining 'solutions', a list whose
@@ skipping 326 matching lines @@
     if isinstance(url, self.FromImpl):
       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
-      # Make sure the referenced dependency DEPS file is loaded and file the
-      # inner referenced dependency.
-      # TODO(maruel): Shouldn't do that.
-      ref.ParseDepsFile()
-      found_dep = None
-      for d in ref.dependencies:
-        if d.name == sub_target:
-          found_dep = d
-          break
-      if not found_dep:
+      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(
           'LateOverride(%s, %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]:
         # A relative url. Fetch the real base.
         path = parsed_url[2]
@@ skipping 16 matching lines @@
       return url
 
     if url is None:
       logging.info('LateOverride(%s, %s) -> %s' % (self.name, url, url))
       return url
 
     raise gclient_utils.Error('Unknown url type')
 
   def ParseDepsFile(self):
     """Parses the DEPS file for this dependency."""
-    if self.deps_parsed:
-      logging.debug('%s was already parsed' % self.name)
-      return
+    assert not self.deps_parsed
     assert not self.dependencies
     # One thing is unintuitive, vars = {} must happen before Var() use.
     local_scope = {}
     var = self.VarImpl(self.custom_vars, local_scope)
     global_scope = {
       'File': self.FileImpl,
       'From': self.FromImpl,
       'Var': var.Lookup,
       'deps_os': {},
     }
@@ skipping 142 matching lines @@
         # It depends on the command being executed (like runhooks vs sync).
         if not os.path.isabs(file_list[i]):
           continue
         prefix = os.path.commonprefix(
             [self.root.root_dir.lower(), file_list[i].lower()])
         file_list[i] = file_list[i][len(prefix):]
         # Strip any leading path separators.
         while file_list[i].startswith(('\\', '/')):
           file_list[i] = file_list[i][1:]
 
-    if self.recursion_limit:
-      # Then we can parse the DEPS file.
-      self.ParseDepsFile()
+    # Always parse the DEPS file.
+    self.ParseDepsFile()
 
     self._run_is_done(file_list, parsed_url)
 
     if self.recursion_limit:
       # Parse the dependencies of this dependency.
       for s in self.dependencies:
         work_queue.enqueue(s)
 
   @gclient_utils.lockedmethod
   def _run_is_done(self, file_list, parsed_url):
@@ skipping 101 matching lines @@
     return tuple(self._deps_hooks)
 
   @property
   @gclient_utils.lockedmethod
   def parsed_url(self):
     return self._parsed_url
 
   @property
   @gclient_utils.lockedmethod
   def deps_parsed(self):
+    """This is purely for debugging purposes. It's not used anywhere."""
     return self._deps_parsed
 
   @property
   @gclient_utils.lockedmethod
   def processed(self):
     return self._processed
 
   @property
   @gclient_utils.lockedmethod
   def hooks_ran(self):
@@ skipping 792 matching lines @@
   except (gclient_utils.Error, subprocess2.CalledProcessError), e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   fix_encoding.fix_encoding()
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: