libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/gclient_paths.py

@@ -0,0 +1,142 @@
+# Copyright 2019 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.
+
+# This file is imported by various thin wrappers (around gn, clang-format, ...),
+# so it's meant to import very quickly. To keep it that way don't add more
+# code, and even more importantly don't add more toplevel import statements,
+# particularly for modules that are not builtin (see sys.builtin_modules_names,
+# os isn't built in, but it's essential to this file).
+
+from __future__ import print_function
+
+import os
+import sys
+
+
+def FindGclientRoot(from_dir, filename='.gclient'):
+  """Tries to find the gclient root."""
+  real_from_dir = os.path.realpath(from_dir)
+  path = real_from_dir
+  while not os.path.exists(os.path.join(path, filename)):
+    split_path = os.path.split(path)
+    if not split_path[1]:
+      return None
+    path = split_path[0]
+
+  # If we did not find the file in the current directory, make sure we are in a
+  # sub directory that is controlled by this configuration.
+  if path != real_from_dir:
+    entries_filename = os.path.join(path, filename + '_entries')
+    if not os.path.exists(entries_filename):
+      # If .gclient_entries does not exist, a previous call to gclient sync
+      # might have failed. In that case, we cannot verify that the .gclient
+      # is the one we want to use. In order to not to cause too much trouble,
+      # just issue a warning and return the path anyway.
+      print(
+          "%s missing, %s file in parent directory %s might not be the file "
+          "you want to use." % (entries_filename, filename, path),
+          file=sys.stderr)
+      return path
+    scope = {}
+    try:
+      import io
+      with io.open(entries_filename, encoding='utf-8') as f:
+        exec(f.read(), scope)
+    except SyntaxError as e:
+      SyntaxErrorToError(filename, e)
+    all_directories = scope['entries'].keys()
+    path_to_check = real_from_dir[len(path)+1:]
+    while path_to_check:
+      if path_to_check in all_directories:
+        return path
+      path_to_check = os.path.dirname(path_to_check)
+    return None
+
+  import logging
+  logging.info('Found gclient root at ' + path)
+  return path
+
+
+def GetPrimarySolutionPath():
+  """Returns the full path to the primary solution. (gclient_root + src)"""
+
+  gclient_root = FindGclientRoot(os.getcwd())
+  if not gclient_root:
+    # Some projects might not use .gclient. Try to see whether we're in a git
+    # checkout.
+    top_dir = [os.getcwd()]
+    def filter_fn(line):
+      repo_root_path = os.path.normpath(line.rstrip('\n'))
+      if os.path.exists(repo_root_path):
+        top_dir[0] = repo_root_path
+    try:
+      CheckCallAndFilter(["git", "rev-parse", "--show-toplevel"],
+                         print_stdout=False, filter_fn=filter_fn)
+    except Exception:
+      pass
+    top_dir = top_dir[0]
+    if os.path.exists(os.path.join(top_dir, 'buildtools')):
+      return top_dir
+    return None
+
+  # Some projects' top directory is not named 'src'.
+  source_dir_name = GetGClientPrimarySolutionName(gclient_root) or 'src'
+  return os.path.join(gclient_root, source_dir_name)
+
+
+def GetBuildtoolsPath():
+  """Returns the full path to the buildtools directory.
+  This is based on the root of the checkout containing the current directory."""
+
+  # Overriding the build tools path by environment is highly unsupported and may
+  # break without warning.  Do not rely on this for anything important.
+  override = os.environ.get('CHROMIUM_BUILDTOOLS_PATH')
+  if override is not None:
+    return override
+
+  primary_solution = GetPrimarySolutionPath()
+  if not primary_solution:
+    return None
+  buildtools_path = os.path.join(primary_solution, 'buildtools')
+  if not os.path.exists(buildtools_path):
+    # Buildtools may be in the gclient root.
+    gclient_root = FindGclientRoot(os.getcwd())
+    buildtools_path = os.path.join(gclient_root, 'buildtools')
+  return buildtools_path
+
+
+def GetBuildtoolsPlatformBinaryPath():
+  """Returns the full path to the binary directory for the current platform."""
+  buildtools_path = GetBuildtoolsPath()
+  if not buildtools_path:
+    return None
+
+  if sys.platform.startswith(('cygwin', 'win')):
+    subdir = 'win'
+  elif sys.platform == 'darwin':
+    subdir = 'mac'
+  elif sys.platform.startswith('linux'):
+    subdir = 'linux64'
+  else:
+    raise Error('Unknown platform: ' + sys.platform)
+  return os.path.join(buildtools_path, subdir)
+
+
+def GetExeSuffix():
+  """Returns '' or '.exe' depending on how executables work on this platform."""
+  if sys.platform.startswith(('cygwin', 'win')):
+    return '.exe'
+  return ''
+
+
+def GetGClientPrimarySolutionName(gclient_root_dir_path):
+  """Returns the name of the primary solution in the .gclient file specified."""
+  gclient_config_file = os.path.join(gclient_root_dir_path, '.gclient')
+  env = {}
+  exec(compile(open(gclient_config_file).read(), gclient_config_file, 'exec'),
+       env)
+  solutions = env.get('solutions', [])
+  if solutions:
+    return solutions[0].get('name')
+  return None

data/vendor/depot_tools/gclient_scm.py

@@ -18,7 +18,11 @@ import sys
 import tempfile
 import threading
 import traceback
-import urlparse
+
+try:
+  import urlparse
+except ImportError:  # For Py3 compatibility
+  import urllib.parse as urlparse
 
 import download_from_google_storage
 import gclient_utils
@@ -92,7 +96,6 @@ class SCMWrapper(object):
 
   This is the abstraction layer to bind to different SCM.
   """
-
   def __init__(self, url=None, root_dir=None, relpath=None, out_fh=None,
                out_cb=None, print_outbuf=False):
     self.url = url
@@ -138,7 +141,7 @@ class SCMWrapper(object):
     return log.splitlines()[0].split(' ', 1)[1]
 
   def GetCacheMirror(self):
-    if (getattr(self, 'cache_dir', None)):
+    if getattr(self, 'cache_dir', None):
       url, _ = gclient_utils.SplitUrlRevision(self.url)
       return git_cache.Mirror(url)
     return None
@@ -210,11 +213,17 @@ class GitWrapper(SCMWrapper):
   name = 'git'
   remote = 'origin'
 
-  cache_dir = None
+  @property
+  def cache_dir(self):
+    try:
+      return git_cache.Mirror.GetCachePath()
+    except RuntimeError:
+      return None
 
   def __init__(self, url=None, *args, **kwargs):
     """Removes 'git+' fake prefix from git URL."""
-    if url.startswith('git+http://') or url.startswith('git+https://'):
+    if url and (url.startswith('git+http://') or
+                url.startswith('git+https://')):
       url = url[4:]
     SCMWrapper.__init__(self, url, *args, **kwargs)
     filter_kwargs = { 'time_throttle': 1, 'out_fh': self.out_fh }
@@ -300,14 +309,15 @@ class GitWrapper(SCMWrapper):
 
   def _FetchAndReset(self, revision, file_list, options):
     """Equivalent to git fetch; git reset."""
-    self._UpdateBranchHeads(options, fetch=False)
+    self._SetFetchConfig(options)
 
     self._Fetch(options, prune=True, quiet=options.verbose)
     self._Scrub(revision, options)
     if file_list is not None:
       files = self._Capture(
           ['-c', 'core.quotePath=false', 'ls-files']).splitlines()
-      file_list.extend([os.path.join(self.checkout_path, f) for f in files])
+      file_list.extend(
+          [os.path.join(self.checkout_path, f.decode()) for f in files])
 
   def _DisableHooks(self):
     hook_dir = os.path.join(self.checkout_path, '.git', 'hooks')
@@ -340,29 +350,127 @@ class GitWrapper(SCMWrapper):
               self.Print('FAILED to break lock: %s: %s' % (to_break, ex))
               raise
 
-  def apply_patch_ref(self, patch_repo, patch_ref, options, file_list):
+  # TODO(ehmaldonado): Remove after bot_update is modified to pass the patch's
+  # branch.
+  def _GetTargetBranchForCommit(self, commit):
+    """Get the remote branch a commit is part of."""
+    _WELL_KNOWN_BRANCHES = [
+        'refs/remotes/origin/master',
+        'refs/remotes/origin/infra/config',
+        'refs/remotes/origin/lkgr',
+    ]
+    for branch in _WELL_KNOWN_BRANCHES:
+      if scm.GIT.IsAncestor(self.checkout_path, commit, branch):
+        return branch
+    remote_refs = self._Capture(
+        ['for-each-ref', 'refs/remotes/%s' % self.remote,
+         '--format=%(refname)']).splitlines()
+    for ref in sorted(remote_refs, reverse=True):
+      if scm.GIT.IsAncestor(self.checkout_path, commit, ref):
+        return ref
+    self.Print('Failed to find a remote ref that contains %s. '
+               'Candidate refs were %s.' % (commit, remote_refs))
+    # Fallback to the commit we got.
+    # This means that apply_path_ref will try to find the merge-base between the
+    # patch and the commit (which is most likely the commit) and cherry-pick
+    # everything in between.
+    return commit
+
+  def apply_patch_ref(self, patch_repo, patch_ref, target_branch, options,
+                      file_list):
+    """Apply a patch on top of the revision we're synced at.
+
+    The patch ref is given by |patch_repo|@|patch_ref|, and the current revision
+    is |base_rev|.
+    We also need the |target_branch| that the patch was uploaded against. We use
+    it to find a merge base between |patch_rev| and |base_rev|, so we can find
+    what commits constitute the patch:
+
+    Graphically, it looks like this:
+
+     ... -> merge_base -> [possibly already landed commits] -> target_branch
+                       \
+                        -> [possibly not yet landed dependent CLs] -> patch_rev
+
+    Next, we apply the commits |merge_base..patch_rev| on top of whatever is
+    currently checked out, denoted |base_rev|. Typically, it'd be a revision
+    from |target_branch|, but this is not required.
+
+    Graphically, we cherry pick |merge_base..patch_rev| on top of |base_rev|:
+
+     ... -> base_rev -> [possibly not yet landed dependent CLs] -> patch_rev
+
+    After application, if |options.reset_patch_ref| is specified, we soft reset
+    the just cherry-picked changes, keeping them in git index only.
+
+    Args:
+      patch_repo: The patch origin. e.g. 'https://foo.googlesource.com/bar'
+      patch_ref: The ref to the patch. e.g. 'refs/changes/1234/34/1'.
+      target_branch: The branch the patch was uploaded against.
+          e.g. 'refs/heads/master' or 'refs/heads/infra/config'.
+      options: The options passed to gclient.
+      file_list: A list where modified files will be appended.
+    """
+
+    # Abort any cherry-picks in progress.
+    try:
+      self._Capture(['cherry-pick', '--abort'])
+    except subprocess2.CalledProcessError:
+      pass
+
     base_rev = self._Capture(['rev-parse', 'HEAD'])
+    target_branch = target_branch or self._GetTargetBranchForCommit(base_rev)
     self.Print('===Applying patch ref===')
-    self.Print('Repo is %r @ %r, ref is %r, root is %r' % (
-        patch_repo, patch_ref, base_rev, self.checkout_path))
+    self.Print('Patch ref is %r @ %r. Target branch for patch is %r. '
+               'Current HEAD is %r. Current dir is %r' % (
+                   patch_repo, patch_ref, target_branch, base_rev,
+                   self.checkout_path))
     self._Capture(['reset', '--hard'])
     self._Capture(['fetch', patch_repo, patch_ref])
-    if file_list is not None:
-      file_list.extend(self._GetDiffFilenames('FETCH_HEAD'))
-    self._Capture(['checkout', 'FETCH_HEAD'])
+    patch_rev = self._Capture(['rev-parse', 'FETCH_HEAD'])
+
+    try:
+      if not options.rebase_patch_ref:
+        self._Capture(['checkout', patch_rev])
+      else:
+        # Find the merge-base between the branch_rev and patch_rev to find out
+        # the changes we need to cherry-pick on top of base_rev.
+        merge_base = self._Capture(['merge-base', target_branch, patch_rev])
+        self.Print('Merge base of %s and %s is %s' % (
+            target_branch, patch_rev, merge_base))
+        if merge_base == patch_rev:
+          # If the merge-base is patch_rev, it means patch_rev is already part
+          # of the history, so just check it out.
+          self._Capture(['checkout', patch_rev])
+        else:
+          # If a change was uploaded on top of another change, which has already
+          # landed, one of the commits in the cherry-pick range will be
+          # redundant, since it has already landed and its changes incorporated
+          # in the tree.
+          # We pass '--keep-redundant-commits' to ignore those changes.
+          self._Capture(['cherry-pick', merge_base + '..' + patch_rev,
+                         '--keep-redundant-commits'])
 
-    if options.rebase_patch_ref:
+      if file_list is not None:
+        file_list.extend(self._GetDiffFilenames(base_rev))
+
+    except subprocess2.CalledProcessError as e:
+      self.Print('Failed to apply patch.')
+      self.Print('Patch ref is %r @ %r. Target branch for patch is %r. '
+                 'Current HEAD is %r. Current dir is %r' % (
+                     patch_repo, patch_ref, target_branch, base_rev,
+                     self.checkout_path))
+      self.Print('git returned non-zero exit status %s:\n%s' % (
+          e.returncode, e.stderr))
+      # Print the current status so that developers know what changes caused the
+      # patch failure, since git cherry-pick doesn't show that information.
+      self.Print(self._Capture(['status']))
       try:
-        # TODO(ehmaldonado): Look into cherry-picking to avoid an expensive
-        # checkout + rebase.
-        self._Capture(['rebase', base_rev])
-      except subprocess2.CalledProcessError as e:
-        self.Print('Failed to apply %r @ %r to %r at %r' % (
-                patch_repo, patch_ref, base_rev, self.checkout_path))
-        self.Print('git returned non-zero exit status %s:\n%s' % (
-            e.returncode, e.stderr))
-        self._Capture(['rebase', '--abort'])
-        raise
+        self._Capture(['cherry-pick', '--abort'])
+      except subprocess2.CalledProcessError:
+        pass
+      raise
+
     if options.reset_patch_ref:
       self._Capture(['reset', '--soft', base_rev])
 
@@ -405,6 +513,14 @@ class GitWrapper(SCMWrapper):
       verbose = ['--verbose']
       printed_path = True
 
+    revision_ref = revision
+    if ':' in revision:
+      revision_ref, _, revision = revision.partition(':')
+
+    mirror = self._GetMirror(url, options, revision_ref)
+    if mirror:
+      url = mirror.mirror_path
+
     remote_ref = scm.GIT.RefToRemoteRef(revision, self.remote)
     if remote_ref:
       # Rewrite remote refs to their local equivalents.
@@ -418,10 +534,6 @@ class GitWrapper(SCMWrapper):
       # hash is also a tag, only make a distinction at checkout
       rev_type = "hash"
 
-    mirror = self._GetMirror(url, options)
-    if mirror:
-      url = mirror.mirror_path
-
     # If we are going to introduce a new project, there is a possibility that
     # we are syncing back to a state where the project was originally a
     # sub-project rolled by DEPS (realistic case: crossing the Blink merge point
@@ -448,16 +560,24 @@ class GitWrapper(SCMWrapper):
         self._Clone(revision, url, options)
       if file_list is not None:
         files = self._Capture(
-          ['-c', 'core.quotePath=false', 'ls-files']).splitlines()
-        file_list.extend([os.path.join(self.checkout_path, f) for f in files])
+            ['-c', 'core.quotePath=false', 'ls-files']).splitlines()
+        file_list.extend(
+            [os.path.join(self.checkout_path, f.decode()) for f in files])
+      if mirror:
+        self._Capture(
+            ['remote', 'set-url', '--push', 'origin', mirror.url])
       if not verbose:
         # Make the output a little prettier. It's nice to have some whitespace
         # between projects when cloning.
         self.Print('')
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
+    if mirror:
+      self._Capture(
+          ['remote', 'set-url', '--push', 'origin', mirror.url])
+
     if not managed:
-      self._UpdateBranchHeads(options, fetch=False)
+      self._SetFetchConfig(options)
       self.Print('________ unmanaged solution; skipping %s' % self.relpath)
       return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
@@ -475,8 +595,7 @@ class GitWrapper(SCMWrapper):
     # Skip url auto-correction if remote.origin.gclient-auto-fix-url is set.
     # This allows devs to use experimental repos which have a different url
     # but whose branch(s) are the same as official repos.
-    if (current_url.rstrip('/') != url.rstrip('/') and
-        url != 'git://foo' and
+    if (current_url.rstrip(b'/') != url.rstrip('/') and url != 'git://foo' and
         subprocess2.capture(
             ['git', 'config', 'remote.%s.gclient-auto-fix-url' % self.remote],
             cwd=self.checkout_path).strip() != 'False'):
@@ -542,14 +661,19 @@ class GitWrapper(SCMWrapper):
       else:
         raise gclient_utils.Error('Invalid Upstream: %s' % upstream_branch)
 
+    self._SetFetchConfig(options)
+
+    # Fetch upstream if we don't already have |revision|.
     if not scm.GIT.IsValidRevision(self.checkout_path, revision, sha_only=True):
-      # Update the remotes first so we have all the refs.
-      remote_output = scm.GIT.Capture(['remote'] + verbose + ['update'],
-              cwd=self.checkout_path)
-      if verbose:
-        self.Print(remote_output)
+      self._Fetch(options, prune=options.force)
 
-    self._UpdateBranchHeads(options, fetch=True)
+      if not scm.GIT.IsValidRevision(self.checkout_path, revision,
+                                     sha_only=True):
+        # Update the remotes first so we have all the refs.
+        remote_output = scm.GIT.Capture(['remote'] + verbose + ['update'],
+                cwd=self.checkout_path)
+        if verbose:
+          self.Print(remote_output)
 
     revision = self._AutoFetchRef(options, revision)
 
@@ -830,9 +954,9 @@ class GitWrapper(SCMWrapper):
     return os.path.join(self._root_dir,
                         'old_' + self.relpath.replace(os.sep, '_')) + '.git'
 
-  def _GetMirror(self, url, options):
+  def _GetMirror(self, url, options, revision_ref=None):
     """Get a git_cache.Mirror object for the argument url."""
-    if not git_cache.Mirror.GetCachePath():
+    if not self.cache_dir:
       return None
     mirror_kwargs = {
         'print_func': self.filter,
@@ -840,8 +964,12 @@ class GitWrapper(SCMWrapper):
     }
     if hasattr(options, 'with_branch_heads') and options.with_branch_heads:
       mirror_kwargs['refs'].append('refs/branch-heads/*')
+    elif revision_ref and revision_ref.startswith('refs/branch-heads/'):
+      mirror_kwargs['refs'].append(revision_ref)
     if hasattr(options, 'with_tags') and options.with_tags:
       mirror_kwargs['refs'].append('refs/tags/*')
+    elif revision_ref and revision_ref.startswith('refs/tags/'):
+      mirror_kwargs['refs'].append(revision_ref)
     return git_cache.Mirror(url, **mirror_kwargs)
 
   def _UpdateMirrorIfNotContains(self, mirror, options, rev_type, revision):
@@ -936,7 +1064,8 @@ class GitWrapper(SCMWrapper):
       gclient_utils.rmtree(tmp_dir)
       if template_dir:
         gclient_utils.rmtree(template_dir)
-    self._UpdateBranchHeads(options, fetch=True)
+    self._SetFetchConfig(options)
+    self._Fetch(options, prune=options.force)
     revision = self._AutoFetchRef(options, revision)
     remote_ref = scm.GIT.RefToRemoteRef(revision, self.remote)
     self._Checkout(options, ''.join(remote_ref or revision), quiet=True)
@@ -996,7 +1125,7 @@ class GitWrapper(SCMWrapper):
 
     try:
       rebase_output = scm.GIT.Capture(rebase_cmd, cwd=self.checkout_path)
-    except subprocess2.CalledProcessError, e:
+    except subprocess2.CalledProcessError as e:
       if (re.match(r'cannot rebase: you have unstaged changes', e.stderr) or
           re.match(r'cannot rebase: your index contains uncommitted changes',
                    e.stderr)):
@@ -1170,6 +1299,19 @@ class GitWrapper(SCMWrapper):
   def _Fetch(self, options, remote=None, prune=False, quiet=False,
              refspec=None):
     cfg = gclient_utils.DefaultIndexPackConfig(self.url)
+    # When updating, the ref is modified to be a remote ref .
+    # (e.g. refs/heads/NAME becomes refs/remotes/REMOTE/NAME).
+    # Try to reverse that mapping.
+    original_ref = scm.GIT.RemoteRefToRef(refspec, self.remote)
+    if original_ref:
+      refspec = original_ref + ':' + refspec
+      # When a mirror is configured, it only fetches
+      # refs/{heads,branch-heads,tags}/*.
+      # If asked to fetch other refs, we must fetch those directly from the
+      # repository, and not from the mirror.
+      if not original_ref.startswith(
+          ('refs/heads/', 'refs/branch-heads/', 'refs/tags/')):
+        remote, _ = gclient_utils.SplitUrlRevision(self.url)
     fetch_cmd =  cfg + [
         'fetch',
         remote or self.remote,
@@ -1188,24 +1330,30 @@ class GitWrapper(SCMWrapper):
     # Return the revision that was fetched; this will be stored in 'FETCH_HEAD'
     return self._Capture(['rev-parse', '--verify', 'FETCH_HEAD'])
 
-  def _UpdateBranchHeads(self, options, fetch=False):
+  def _SetFetchConfig(self, options):
     """Adds, and optionally fetches, "branch-heads" and "tags" refspecs
     if requested."""
-    need_fetch = fetch
+    if options.force or options.reset:
+      try:
+        self._Run(['config', '--unset-all', 'remote.%s.fetch' % self.remote],
+                  options)
+        self._Run(['config', 'remote.%s.fetch' % self.remote,
+                   '+refs/heads/*:refs/remotes/%s/*' % self.remote], options)
+      except subprocess2.CalledProcessError as e:
+        # If exit code was 5, it means we attempted to unset a config that
+        # didn't exist. Ignore it.
+        if e.returncode != 5:
+          raise
     if hasattr(options, 'with_branch_heads') and options.with_branch_heads:
       config_cmd = ['config', 'remote.%s.fetch' % self.remote,
                     '+refs/branch-heads/*:refs/remotes/branch-heads/*',
                     '^\\+refs/branch-heads/\\*:.*$']
       self._Run(config_cmd, options)
-      need_fetch = True
     if hasattr(options, 'with_tags') and options.with_tags:
       config_cmd = ['config', 'remote.%s.fetch' % self.remote,
                     '+refs/tags/*:refs/tags/*',
                     '^\\+refs/tags/\\*:.*$']
       self._Run(config_cmd, options)
-      need_fetch = True
-    if fetch and need_fetch:
-      self._Fetch(options, prune=options.force)
 
   def _AutoFetchRef(self, options, revision):
     """Attempts to fetch |revision| if not available in local repo.
@@ -1318,8 +1466,9 @@ class CipdRoot(object):
     try:
       ensure_file = None
       with tempfile.NamedTemporaryFile(
-          suffix='.ensure', delete=False) as ensure_file:
-        for subdir, packages in sorted(self._packages_by_subdir.iteritems()):
+          suffix='.ensure', delete=False, mode='w') as ensure_file:
+        ensure_file.write('$ParanoidMode CheckPresence\n\n')
+        for subdir, packages in sorted(self._packages_by_subdir.items()):
           ensure_file.write('@Subdir %s\n' % subdir)
           for package in sorted(packages, key=lambda p: p.name):
             ensure_file.write('%s %s\n' % (package.name, package.version))