libv8 7.3.492.27.1 → 8.4.255.0

data/vendor/depot_tools/gclient_scm.py

@@ -24,7 +24,6 @@ try:
 except ImportError:  # For Py3 compatibility
   import urllib.parse as urlparse
 
-import download_from_google_storage
 import gclient_utils
 import git_cache
 import scm
@@ -230,18 +229,7 @@ class GitWrapper(SCMWrapper):
     if self.out_cb:
       filter_kwargs['predicate'] = self.out_cb
     self.filter = gclient_utils.GitFilter(**filter_kwargs)
-
-  @staticmethod
-  def BinaryExists():
-    """Returns true if the command exists."""
-    try:
-      # We assume git is newer than 1.7.  See: crbug.com/114483
-      result, version = scm.GIT.AssertVersion('1.7')
-      if not result:
-        raise gclient_utils.Error('Git version is older than 1.7: %s' % version)
-      return result
-    except OSError:
-      return False
+    self._running_under_rosetta = None
 
   def GetCheckoutRoot(self):
     return scm.GIT.GetCheckoutRoot(self.checkout_path)
@@ -256,9 +244,10 @@ class GitWrapper(SCMWrapper):
   def _GetDiffFilenames(self, base):
     """Returns the names of files modified since base."""
     return self._Capture(
-      # Filter to remove base if it is None.
-      filter(bool, ['-c', 'core.quotePath=false', 'diff', '--name-only', base])
-    ).split()
+        # Filter to remove base if it is None.
+        list(filter(bool, ['-c', 'core.quotePath=false', 'diff', '--name-only',
+                           base])
+        )).split()
 
   def diff(self, options, _args, _file_list):
     _, revision = gclient_utils.SplitUrlRevision(self.url)
@@ -317,7 +306,7 @@ class GitWrapper(SCMWrapper):
       files = self._Capture(
           ['-c', 'core.quotePath=false', 'ls-files']).splitlines()
       file_list.extend(
-          [os.path.join(self.checkout_path, f.decode()) for f in files])
+          [os.path.join(self.checkout_path, f) for f in files])
 
   def _DisableHooks(self):
     hook_dir = os.path.join(self.checkout_path, '.git', 'hooks')
@@ -350,63 +339,38 @@ class GitWrapper(SCMWrapper):
               self.Print('FAILED to break lock: %s: %s' % (to_break, ex))
               raise
 
-  # 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,
+  def apply_patch_ref(self, patch_repo, patch_rev, target_rev, 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:
+    The patch ref is given by |patch_repo|@|patch_rev|.
+    |target_rev| is usually the branch that the |patch_rev| was uploaded against
+    (e.g. 'refs/heads/master'), but this is not required.
 
-    Graphically, it looks like this:
+    We cherry-pick all commits reachable from |patch_rev| on top of the curret
+    HEAD, excluding those reachable from |target_rev|
+    (i.e. git cherry-pick target_rev..patch_rev).
 
-     ... -> merge_base -> [possibly already landed commits] -> target_branch
-                       \
-                        -> [possibly not yet landed dependent CLs] -> patch_rev
+    Graphically, it looks like this:
 
-    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.
+     ... -> o -> [possibly already landed commits] -> target_rev
+             \
+              -> [possibly not yet landed dependent CLs] -> patch_rev
 
-    Graphically, we cherry pick |merge_base..patch_rev| on top of |base_rev|:
+    The final checkout state is then:
 
-     ... -> base_rev -> [possibly not yet landed dependent CLs] -> patch_rev
+     ... -> HEAD -> [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.
+    the 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.
+      patch_repo: The patch origin.
+          e.g. 'https://foo.googlesource.com/bar'
+      patch_rev: The revision to patch.
+          e.g. 'refs/changes/1234/34/1'.
+      target_rev: The revision to use when finding the merge base.
+          Typically, the branch that 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.
@@ -419,28 +383,48 @@ class GitWrapper(SCMWrapper):
       pass
 
     base_rev = self._Capture(['rev-parse', 'HEAD'])
-    target_branch = target_branch or self._GetTargetBranchForCommit(base_rev)
-    self.Print('===Applying patch ref===')
-    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))
+
+    if not target_rev:
+      raise gclient_utils.Error('A target revision for the patch must be given')
+    elif target_rev.startswith('refs/heads/'):
+      # If |target_rev| is in refs/heads/**, try first to find the corresponding
+      # remote ref for it, since |target_rev| might point to a local ref which
+      # is not up to date with the corresponding remote ref.
+      remote_ref = ''.join(scm.GIT.RefToRemoteRef(target_rev, self.remote))
+      self.Print('Trying the corresponding remote ref for %r: %r\n' % (
+          target_rev, remote_ref))
+      if scm.GIT.IsValidRevision(self.checkout_path, remote_ref):
+        target_rev = remote_ref
+    elif not scm.GIT.IsValidRevision(self.checkout_path, target_rev):
+      # Fetch |target_rev| if it's not already available.
+      url, _ = gclient_utils.SplitUrlRevision(self.url)
+      mirror = self._GetMirror(url, options, target_rev)
+      if mirror:
+        rev_type = 'branch' if target_rev.startswith('refs/') else 'hash'
+        self._UpdateMirrorIfNotContains(mirror, options, rev_type, target_rev)
+      self._Fetch(options, refspec=target_rev)
+
+    self.Print('===Applying patch===')
+    self.Print('Revision to patch is %r @ %r.' % (patch_repo, patch_rev))
+    self.Print('Current dir is %r' % self.checkout_path)
     self._Capture(['reset', '--hard'])
-    self._Capture(['fetch', patch_repo, patch_ref])
+    self._Capture(['fetch', '--no-tags', patch_repo, patch_rev])
     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.
+    if not options.rebase_patch_ref:
+      self._Capture(['checkout', patch_rev])
+      # Adjust base_rev to be the first parent of our checked out patch ref;
+      # This will allow us to correctly extend `file_list`, and will show the
+      # correct file-list to programs which do `git diff --cached` expecting to
+      # see the patch diff.
+      base_rev = self._Capture(['rev-parse', patch_rev+'~'])
+
+    else:
+      self.Print('Will cherrypick %r .. %r on top of %r.' % (
+          target_rev, patch_rev, base_rev))
+      try:
+        if scm.GIT.IsAncestor(self.checkout_path, patch_rev, target_rev):
+          # If |patch_rev| is an ancestor of |target_rev|, check it out.
           self._Capture(['checkout', patch_rev])
         else:
           # If a change was uploaded on top of another change, which has already
@@ -448,28 +432,29 @@ class GitWrapper(SCMWrapper):
           # 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,
+          self._Capture(['cherry-pick', target_rev + '..' + patch_rev,
                          '--keep-redundant-commits'])
 
-      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('Revision to patch was %r @ %r.' % (patch_repo, patch_rev))
+        self.Print('Tried to cherrypick %r .. %r on top of %r.' % (
+            target_rev, patch_rev, base_rev))
+        self.Print('Current dir is %r' % self.checkout_path)
+        self.Print('git returned non-zero exit status %s:\n%s' % (
+            e.returncode, e.stderr.decode('utf-8')))
+        # 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:
+          self._Capture(['cherry-pick', '--abort'])
+        except subprocess2.CalledProcessError:
+          pass
+        raise
 
-    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:
-        self._Capture(['cherry-pick', '--abort'])
-      except subprocess2.CalledProcessError:
-        pass
-      raise
+    if file_list is not None:
+      file_list.extend(self._GetDiffFilenames(base_rev))
 
     if options.reset_patch_ref:
       self._Capture(['reset', '--soft', base_rev])
@@ -517,6 +502,9 @@ class GitWrapper(SCMWrapper):
     if ':' in revision:
       revision_ref, _, revision = revision.partition(':')
 
+    if revision_ref.startswith('refs/branch-heads'):
+      options.with_branch_heads = True
+
     mirror = self._GetMirror(url, options, revision_ref)
     if mirror:
       url = mirror.mirror_path
@@ -562,7 +550,7 @@ class GitWrapper(SCMWrapper):
         files = self._Capture(
             ['-c', 'core.quotePath=false', 'ls-files']).splitlines()
         file_list.extend(
-            [os.path.join(self.checkout_path, f.decode()) for f in files])
+            [os.path.join(self.checkout_path, f) for f in files])
       if mirror:
         self._Capture(
             ['remote', 'set-url', '--push', 'origin', mirror.url])
@@ -595,7 +583,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(b'/') != url.rstrip('/') and url != 'git://foo' and
+    if (current_url.rstrip('/') != 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'):
@@ -770,7 +758,8 @@ class GitWrapper(SCMWrapper):
         merge_output = self._Capture(merge_args)
       except subprocess2.CalledProcessError as e:
         rebase_files = []
-        if re.match('fatal: Not possible to fast-forward, aborting.', e.stderr):
+        if re.match(b'fatal: Not possible to fast-forward, aborting.',
+                    e.stderr):
           if not printed_path:
             self.Print('_____ %s at %s' % (self.relpath, revision),
                        timestamp=False)
@@ -800,19 +789,19 @@ class GitWrapper(SCMWrapper):
               return
             else:
               self.Print('Input not recognized')
-        elif re.match("error: Your local changes to '.*' would be "
-                      "overwritten by merge.  Aborting.\nPlease, commit your "
-                      "changes or stash them before you can merge.\n",
+        elif re.match(b"error: Your local changes to '.*' would be "
+                      b"overwritten by merge.  Aborting.\nPlease, commit your "
+                      b"changes or stash them before you can merge.\n",
                       e.stderr):
           if not printed_path:
             self.Print('_____ %s at %s' % (self.relpath, revision),
                        timestamp=False)
             printed_path = True
-          raise gclient_utils.Error(e.stderr)
+          raise gclient_utils.Error(e.stderr.decode('utf-8'))
         else:
           # Some other problem happened with the merge
           logging.error("Error during fast-forward merge in %s!" % self.relpath)
-          self.Print(e.stderr)
+          self.Print(e.stderr.decode('utf-8'))
           raise
       else:
         # Fast-forward merge was successful
@@ -869,7 +858,7 @@ class GitWrapper(SCMWrapper):
     if not os.path.isdir(self.checkout_path):
       # revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
-      self.Print('_____ %s is missing, synching instead' % self.relpath)
+      self.Print('_____ %s is missing, syncing instead' % self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
@@ -888,8 +877,8 @@ class GitWrapper(SCMWrapper):
     except NoUsableRevError as e:
       # If the DEPS entry's url and hash changed, try to update the origin.
       # See also http://crbug.com/520067.
-      logging.warn(
-          'Couldn\'t find usable revision, will retrying to update instead: %s',
+      logging.warning(
+          "Couldn't find usable revision, will retrying to update instead: %s",
           e.message)
       return self.update(options, [], file_list)
 
@@ -915,13 +904,14 @@ class GitWrapper(SCMWrapper):
       self.Print('________ couldn\'t run status in %s:\n'
                  'The directory does not exist.' % self.checkout_path)
     else:
-      try:
-        merge_base = [self._Capture(['merge-base', 'HEAD', self.remote])]
-      except subprocess2.CalledProcessError:
-        merge_base = []
+      merge_base = []
+      if self.url:
+        _, base_rev = gclient_utils.SplitUrlRevision(self.url)
+        if base_rev:
+          merge_base = [base_rev]
       self._Run(
           ['-c', 'core.quotePath=false', 'diff', '--name-status'] + merge_base,
-          options, stdout=self.out_fh, always=options.verbose)
+          options, always_show_header=options.verbose)
       if file_list is not None:
         files = self._GetDiffFilenames(merge_base[0] if merge_base else None)
         file_list.extend([os.path.join(self.checkout_path, f) for f in files])
@@ -993,9 +983,7 @@ class GitWrapper(SCMWrapper):
     mirror.populate(verbose=options.verbose,
                     bootstrap=not getattr(options, 'no_bootstrap', False),
                     depth=depth,
-                    ignore_lock=getattr(options, 'ignore_locks', False),
                     lock_timeout=getattr(options, 'lock_timeout', 0))
-    mirror.unlock()
 
   def _Clone(self, revision, url, options):
     """Clone a git repository from the given URL.
@@ -1046,12 +1034,12 @@ class GitWrapper(SCMWrapper):
       clone_cmd.append(tmp_dir)
       if self.print_outbuf:
         print_stdout = True
-        stdout = gclient_utils.WriteToStdout(self.out_fh)
+        filter_fn = None
       else:
         print_stdout = False
-        stdout = self.out_fh
+        filter_fn = self.filter
       self._Run(clone_cmd, options, cwd=self._root_dir, retry=True,
-                print_stdout=print_stdout, stdout=stdout)
+                print_stdout=print_stdout, filter_fn=filter_fn)
       gclient_utils.safe_makedirs(self.checkout_path)
       gclient_utils.safe_rename(os.path.join(tmp_dir, '.git'),
                                 os.path.join(self.checkout_path, '.git'))
@@ -1083,11 +1071,7 @@ class GitWrapper(SCMWrapper):
       raise gclient_utils.Error("Background task requires input. Rerun "
                                 "gclient with --jobs=1 so that\n"
                                 "interaction is possible.")
-    try:
-      return raw_input(prompt)
-    except KeyboardInterrupt:
-      # Hide the exception.
-      sys.exit(1)
+    return gclient_utils.AskForData(prompt)
 
 
   def _AttemptRebase(self, upstream, files, options, newbase=None,
@@ -1126,8 +1110,8 @@ class GitWrapper(SCMWrapper):
     try:
       rebase_output = scm.GIT.Capture(rebase_cmd, cwd=self.checkout_path)
     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',
+      if (re.match(br'cannot rebase: you have unstaged changes', e.stderr) or
+          re.match(br'cannot rebase: your index contains uncommitted changes',
                    e.stderr)):
         while True:
           rebase_action = self._AskForData(
@@ -1145,18 +1129,19 @@ class GitWrapper(SCMWrapper):
                                       "cd %s && git " % self.checkout_path
                                       + "%s" % ' '.join(rebase_cmd))
           elif re.match(r'show|s', rebase_action, re.I):
-            self.Print('%s' % e.stderr.strip())
+            self.Print('%s' % e.stderr.decode('utf-8').strip())
             continue
           else:
             gclient_utils.Error("Input not recognized")
             continue
-      elif re.search(r'^CONFLICT', e.stdout, re.M):
+      elif re.search(br'^CONFLICT', e.stdout, re.M):
         raise gclient_utils.Error("Conflict while rebasing this branch.\n"
                                   "Fix the conflict and run gclient again.\n"
                                   "See 'man git-rebase' for details.\n")
       else:
-        self.Print(e.stdout.strip())
-        self.Print('Rebase produced error output:\n%s' % e.stderr.strip())
+        self.Print(e.stdout.decode('utf-8').strip())
+        self.Print('Rebase produced error output:\n%s' %
+        e.stderr.decode('utf-8').strip())
         raise gclient_utils.Error("Unrecognized error, please merge or rebase "
                                   "manually.\ncd %s && git " %
                                   self.checkout_path
@@ -1186,7 +1171,7 @@ class GitWrapper(SCMWrapper):
     try:
       self._Capture(['rev-list', '-n', '1', 'HEAD'])
     except subprocess2.CalledProcessError as e:
-      if ('fatal: bad object HEAD' in e.stderr
+      if (b'fatal: bad object HEAD' in e.stderr
           and self.cache_dir and self.cache_dir in url):
         self.Print((
           'Likely due to DEPS change with git cache_dir, '
@@ -1267,13 +1252,27 @@ class GitWrapper(SCMWrapper):
     return branch
 
   def _Capture(self, args, **kwargs):
+    set_git_dir = 'cwd' not in kwargs
     kwargs.setdefault('cwd', self.checkout_path)
     kwargs.setdefault('stderr', subprocess2.PIPE)
     strip = kwargs.pop('strip', True)
     env = scm.GIT.ApplyEnvVars(kwargs)
-    ret = subprocess2.check_output(['git'] + args, env=env, **kwargs)
+    # If an explicit cwd isn't set, then default to the .git/ subdir so we get
+    # stricter behavior.  This can be useful in cases of slight corruption --
+    # we don't accidentally go corrupting parent git checks too.  See
+    # https://crbug.com/1000825 for an example.
+    if set_git_dir:
+      git_dir = os.path.abspath(os.path.join(self.checkout_path, '.git'))
+      # Depending on how the .gclient file was defined, self.checkout_path
+      # might be set to a unicode string, not a regular string; on Windows
+      # Python2, we can't set env vars to be unicode strings, so we
+      # forcibly cast the value to a string before setting it.
+      env.setdefault('GIT_DIR', str(git_dir))
+    ret = subprocess2.check_output(
+        ['git'] + args, env=env, **kwargs).decode('utf-8')
     if strip:
       ret = ret.strip()
+    self.Print('Finished running: %s %s' % ('git', ' '.join(args)))
     return ret
 
   def _Checkout(self, options, ref, force=False, quiet=None):
@@ -1282,7 +1281,7 @@ class GitWrapper(SCMWrapper):
     Args:
       options: The configured option set
       ref: (str) The branch/commit to checkout
-      quiet: (bool/None) Whether or not the checkout shoud pass '--quiet'; if
+      quiet: (bool/None) Whether or not the checkout should pass '--quiet'; if
           'None', the behavior is inferred from 'options.verbose'.
     Returns: (str) The output of the checkout operation
     """
@@ -1323,13 +1322,12 @@ class GitWrapper(SCMWrapper):
       fetch_cmd.append('--prune')
     if options.verbose:
       fetch_cmd.append('--verbose')
+    if not hasattr(options, 'with_tags') or not options.with_tags:
+      fetch_cmd.append('--no-tags')
     elif quiet:
       fetch_cmd.append('--quiet')
     self._Run(fetch_cmd, options, show_header=options.verbose, retry=True)
 
-    # Return the revision that was fetched; this will be stored in 'FETCH_HEAD'
-    return self._Capture(['rev-parse', '--verify', 'FETCH_HEAD'])
-
   def _SetFetchConfig(self, options):
     """Adds, and optionally fetches, "branch-heads" and "tags" refspecs
     if requested."""
@@ -1359,25 +1357,48 @@ class GitWrapper(SCMWrapper):
     """Attempts to fetch |revision| if not available in local repo.
 
     Returns possibly updated revision."""
-    try:
-      self._Capture(['rev-parse', revision])
-    except subprocess2.CalledProcessError:
+    if not scm.GIT.IsValidRevision(self.checkout_path, revision):
       self._Fetch(options, refspec=revision)
       revision = self._Capture(['rev-parse', 'FETCH_HEAD'])
     return revision
 
-  def _Run(self, args, options, show_header=True, **kwargs):
+  def _IsRunningUnderRosetta(self):
+    if sys.platform != 'darwin':
+      return False
+    if self._running_under_rosetta is None:
+      # If we are running under Rosetta, platform.machine() is
+      # 'x86_64'; we need to use a sysctl to see if we're being
+      # translated.
+      import ctypes
+      libSystem = ctypes.CDLL("libSystem.dylib")
+      ret = ctypes.c_int(0)
+      size = ctypes.c_size_t(4)
+      e = libSystem.sysctlbyname(ctypes.c_char_p(b'sysctl.proc_translated'),
+                                 ctypes.byref(ret), ctypes.byref(size), None, 0)
+      self._running_under_rosetta = e == 0 and ret.value == 1
+    return self._running_under_rosetta
+
+  def _Run(self, args, options, **kwargs):
     # Disable 'unused options' warning | pylint: disable=unused-argument
     kwargs.setdefault('cwd', self.checkout_path)
-    kwargs.setdefault('stdout', self.out_fh)
-    kwargs['filter_fn'] = self.filter
-    kwargs.setdefault('print_stdout', False)
+    kwargs.setdefault('filter_fn', self.filter)
+    kwargs.setdefault('show_header', True)
     env = scm.GIT.ApplyEnvVars(kwargs)
+
     cmd = ['git'] + args
-    if show_header:
-      gclient_utils.CheckCallAndFilterAndHeader(cmd, env=env, **kwargs)
-    else:
-      gclient_utils.CheckCallAndFilter(cmd, env=env, **kwargs)
+
+    if self._IsRunningUnderRosetta():
+      # We currently only ship an Intel Python binary in depot_tools.
+      # Intel binaries run under Rosetta on ARM Macs, and by default
+      # prefer to run their subprocesses as Intel under Rosetta too.
+      # Intel git running under Rosetta has a bug where it fails to
+      # clone src.git (rdar://7868319), so until we ship a native
+      # ARM python3 binary, explicitly use `arch` to let git run
+      # the native ARM slice instead of the Intel slice.
+      # TODO(thakis): Remove this again once we ship an arm64 python3
+      # binary.
+      cmd = ['arch', '-arch', 'arm64'] + cmd
+    gclient_utils.CheckCallAndFilter(cmd, env=env, **kwargs)
 
 
 class CipdPackage(object):
@@ -1464,15 +1485,16 @@ class CipdRoot(object):
   @contextlib.contextmanager
   def _create_ensure_file(self):
     try:
+      contents = '$ParanoidMode CheckPresence\n\n'
+      for subdir, packages in sorted(self._packages_by_subdir.items()):
+        contents += '@Subdir %s\n' % subdir
+        for package in sorted(packages, key=lambda p: p.name):
+          contents += '%s %s\n' % (package.name, package.version)
+        contents += '\n'
       ensure_file = None
       with tempfile.NamedTemporaryFile(
-          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))
-          ensure_file.write('\n')
+          suffix='.ensure', delete=False, mode='wb') as ensure_file:
+        ensure_file.write(contents.encode('utf-8', 'replace'))
       yield ensure_file.name
     finally:
       if ensure_file is not None and os.path.exists(ensure_file.name):
@@ -1488,7 +1510,8 @@ class CipdRoot(object):
             '-root', self.root_dir,
             '-ensure-file', ensure_file,
         ]
-        gclient_utils.CheckCallAndFilterAndHeader(cmd)
+        gclient_utils.CheckCallAndFilter(
+            cmd, print_stdout=True, show_header=True)
 
   def run(self, command):
     if command == 'update':
@@ -1573,8 +1596,7 @@ class CipdWrapper(SCMWrapper):
           '-version', self._package.version,
           '-json-output', describe_json_path
       ]
-      gclient_utils.CheckCallAndFilter(
-          cmd, filter_fn=lambda _line: None, print_stdout=False)
+      gclient_utils.CheckCallAndFilter(cmd)
       with open(describe_json_path) as f:
         describe_json = json.load(f)
       return describe_json.get('result', {}).get('pin', {}).get('instance_id')