libv8 7.3.492.27.1 → 7.3.492.27.3beta1

data/vendor/depot_tools/git_cl.py

@@ -68,6 +68,24 @@ import watchlists
 
 __version__ = '2.0'
 
+# Traces for git push will be stored in a traces directory inside the
+# depot_tools checkout.
+DEPOT_TOOLS = os.path.dirname(os.path.abspath(__file__))
+TRACES_DIR = os.path.join(DEPOT_TOOLS, 'traces')
+
+# When collecting traces, Git hashes will be reduced to 6 characters to reduce
+# the size after compression.
+GIT_HASH_RE = re.compile(r'\b([a-f0-9]{6})[a-f0-9]{34}\b', flags=re.I)
+# Used to redact the cookies from the gitcookies file.
+GITCOOKIES_REDACT_RE = re.compile(r'1/.*')
+
+TRACES_MESSAGE = (
+'When filing a bug, be sure to include the traces found at:\n'
+'  %s.zip\n'
+'Consider including the git config and gitcookies,\n'
+'which we have packed for you at:\n'
+'  %s.zip\n')
+
 COMMIT_BOT_EMAIL = 'commit-bot@chromium.org'
 POSTUPSTREAM_HOOK = '.git/hooks/post-cl-land'
 DESCRIPTION_BACKUP_FILE = '~/.git_cl_description_backup'
@@ -1244,7 +1262,7 @@ class Changelist(object):
   def GetUpstreamBranch(self):
     if self.upstream_branch is None:
       remote, upstream_branch = self.FetchUpstreamTuple(self.GetBranch())
-      if remote is not '.':
+      if remote != '.':
         upstream_branch = upstream_branch.replace('refs/heads/',
                                                   'refs/remotes/%s/' % remote)
         upstream_branch = upstream_branch.replace('refs/branch-heads/',
@@ -2449,7 +2467,7 @@ class _GerritChangelistImpl(_ChangelistCodereviewBase):
       part = parsed_url.fragment
     else:
       part = parsed_url.path
-    match = re.match('(/c(/.*/\+)?)?/(\d+)(/(\d+)?/?)?$', part)
+    match = re.match(r'(/c(/.*/\+)?)?/(\d+)(/(\d+)?/?)?$', part)
     if match:
       return _ParsedIssueNumberArgument(
           issue=int(match.group(3)),
@@ -2478,6 +2496,83 @@ class _GerritChangelistImpl(_ChangelistCodereviewBase):
       else:
         print('OK, will keep Gerrit commit-msg hook in place.')
 
+  def _RunGitPushWithTraces(self, change_desc, refspec, refspec_opts):
+    gclient_utils.safe_makedirs(TRACES_DIR)
+
+    # Create a temporary directory to store traces in. Traces will be compressed
+    # and stored in a 'traces' dir inside depot_tools.
+    traces_dir = tempfile.mkdtemp()
+    trace_name = os.path.basename(traces_dir)
+    traces_zip = os.path.join(TRACES_DIR, trace_name + '-traces')
+    # Create a temporary dir to store git config and gitcookies in. It will be
+    # compressed and stored next to the traces.
+    git_info_dir = tempfile.mkdtemp()
+    git_info_zip = os.path.join(TRACES_DIR, trace_name + '-git-info')
+
+    env = os.environ.copy()
+    env['GIT_REDACT_COOKIES'] = 'o,SSO,GSSO_Uberproxy'
+    env['GIT_TR2_EVENT'] = os.path.join(traces_dir, 'tr2-event')
+    env['GIT_TRACE_CURL'] = os.path.join(traces_dir, 'trace-curl')
+    env['GIT_TRACE_CURL_NO_DATA'] = '1'
+    env['GIT_TRACE_PACKET'] = os.path.join(traces_dir, 'trace-packet')
+
+    try:
+      push_returncode = 0
+      before_push = time_time()
+      push_stdout = gclient_utils.CheckCallAndFilter(
+          ['git', 'push', self.GetRemoteUrl(), refspec],
+          env=env,
+          print_stdout=True,
+          # Flush after every line: useful for seeing progress when running as
+          # recipe.
+          filter_fn=lambda _: sys.stdout.flush())
+    except subprocess2.CalledProcessError as e:
+      push_returncode = e.returncode
+      DieWithError('Failed to create a change. Please examine output above '
+                   'for the reason of the failure.\n'
+                   'Hint: run command below to diagnose common Git/Gerrit '
+                   'credential problems:\n'
+                   '  git cl creds-check\n' +
+                   TRACES_MESSAGE % (traces_zip, git_info_zip),
+                   change_desc)
+    finally:
+      execution_time = time_time() - before_push
+      metrics.collector.add_repeated('sub_commands', {
+        'command': 'git push',
+        'execution_time': execution_time,
+        'exit_code': push_returncode,
+        'arguments': metrics_utils.extract_known_subcommand_args(refspec_opts),
+      })
+
+      if push_returncode != 0:
+        # Keep only the first 6 characters of the git hashes on the packet
+        # trace. This greatly decreases size after compression.
+        packet_traces = os.path.join(traces_dir, 'trace-packet')
+        contents = gclient_utils.FileRead(packet_traces)
+        gclient_utils.FileWrite(
+            packet_traces, GIT_HASH_RE.sub(r'\1', contents))
+        shutil.make_archive(traces_zip, 'zip', traces_dir)
+
+        # Collect and compress the git config and gitcookies.
+        git_config = RunGit(['config', '-l'])
+        gclient_utils.FileWrite(
+            os.path.join(git_info_dir, 'git-config'),
+            git_config)
+
+        cookie_auth = gerrit_util.Authenticator.get()
+        if isinstance(cookie_auth, gerrit_util.CookiesAuthenticator):
+          gitcookies_path = cookie_auth.get_gitcookies_path()
+          gitcookies = gclient_utils.FileRead(gitcookies_path)
+          gclient_utils.FileWrite(
+              os.path.join(git_info_dir, 'gitcookies'),
+              GITCOOKIES_REDACT_RE.sub('REDACTED', gitcookies))
+        shutil.make_archive(git_info_zip, 'zip', git_info_dir)
+
+      gclient_utils.rmtree(git_info_dir)
+      gclient_utils.rmtree(traces_dir)
+
+    return push_stdout
+
   def CMDUploadChange(self, options, git_diff_args, custom_cl_base, change):
     """Upload the current branch to Gerrit."""
     if options.squash and options.no_squash:
@@ -2727,30 +2822,7 @@ class _GerritChangelistImpl(_ChangelistCodereviewBase):
           'spaces not allowed in refspec: "%s"' % refspec_suffix)
     refspec = '%s:refs/for/%s%s' % (ref_to_push, branch, refspec_suffix)
 
-    try:
-      push_returncode = 0
-      before_push = time_time()
-      push_stdout = gclient_utils.CheckCallAndFilter(
-          ['git', 'push', self.GetRemoteUrl(), refspec],
-          print_stdout=True,
-          # Flush after every line: useful for seeing progress when running as
-          # recipe.
-          filter_fn=lambda _: sys.stdout.flush())
-    except subprocess2.CalledProcessError as e:
-      push_returncode = e.returncode
-      DieWithError('Failed to create a change. Please examine output above '
-                   'for the reason of the failure.\n'
-                   'Hint: run command below to diagnose common Git/Gerrit '
-                   'credential problems:\n'
-                   '  git cl creds-check\n',
-                   change_desc)
-    finally:
-      metrics.collector.add_repeated('sub_commands', {
-        'command': 'git push',
-        'execution_time': time_time() - before_push,
-        'exit_code': push_returncode,
-        'arguments': metrics_utils.extract_known_subcommand_args(refspec_opts),
-      })
+    push_stdout = self._RunGitPushWithTraces(change_desc, refspec, refspec_opts)
 
     if options.squash:
       regex = re.compile(r'remote:\s+https?://[\w\-\.\+\/#]*/(\d+)\s.*')

data/vendor/depot_tools/infra/config/recipes.cfg

@@ -15,7 +15,7 @@
   "deps": {
     "recipe_engine": {
       "branch": "master",
-      "revision": "f6dd8332ee794be50574a5887a6efa6ff4516971",
+      "revision": "0589a429cf3c164004dae4ced4c75784a50afd81",
       "url": "https://chromium.googlesource.com/infra/luci/recipes-py.git"
     }
   },

data/vendor/depot_tools/man/src/filter_demo_output.py

@@ -66,7 +66,7 @@ def main():
   backend = sys.argv[1]
   output = sys.stdin.read().rstrip()
 
-  callout_re = re.compile('\x1b\[(\d+)c\n')
+  callout_re = re.compile(r'\x1b\[(\d+)c\n')
   callouts = collections.defaultdict(int)
   for i, line in enumerate(output.splitlines(True)):
     m = callout_re.match(line)

data/vendor/depot_tools/metrics.README.md

@@ -34,8 +34,8 @@ First, some words about what data we are **NOT** collecting:
 
 The metrics we're collecting are:
 
-- A timestamp, with a week resolution.
-- The age of your depot\_tools checkout, with a week resolution.
+- The time when the command was run.
+- The age of your depot\_tools checkout.
 - Your version of Python (in the format major.minor.micro).
 - Your version of Git (in the format major.minor.micro).
 - The OS of your machine (i.e. win, linux or mac).
@@ -47,7 +47,7 @@ The metrics we're collecting are:
 - The exit code.
 - The project you're working on. We only record data about projects you can
   fetch using depot\_tools' fetch command (e.g. Chromium, WebRTC, V8, etc)
-- The age of your project checkout, with a week resolution.
+- The age of your project checkout.
 - What features are you using in your DEPS and .gclient files. For example:
   - Are you setting `use_relative_paths=True`?
   - Are you using `recursedeps`?

data/vendor/depot_tools/metrics.py

@@ -198,6 +198,7 @@ class MetricsCollector(object):
         return func(*args, **kwargs)
 
     self._collecting_metrics = True
+    self.add('metrics_version', metrics_utils.CURRENT_VERSION)
     self.add('command', command_name)
     try:
       start = time.time()
@@ -213,14 +214,14 @@ class MetricsCollector(object):
     self.add('exit_code', exit_code)
 
     # Add metrics regarding environment information.
-    self.add('timestamp', metrics_utils.seconds_to_weeks(time.time()))
+    self.add('timestamp', int(time.time()))
     self.add('python_version', metrics_utils.get_python_version())
     self.add('host_os', gclient_utils.GetMacWinOrLinux())
     self.add('host_arch', detect_host_arch.HostArch())
 
     depot_tools_age = metrics_utils.get_repo_timestamp(DEPOT_TOOLS)
     if depot_tools_age is not None:
-      self.add('depot_tools_age', depot_tools_age)
+      self.add('depot_tools_age', int(depot_tools_age))
 
     git_version = metrics_utils.get_git_version()
     if git_version:

data/vendor/depot_tools/metrics_utils.py

@@ -183,15 +183,6 @@ def return_code_from_exception(exception):
   return 1
 
 
-def seconds_to_weeks(duration):
-  """Transform a |duration| from seconds to weeks approximately.
-
-  Drops the lowest 19 bits of the integer representation, which ammounts to
-  about 6 days.
-  """
-  return int(duration) >> 19
-
-
 def extract_known_subcommand_args(args):
   """Extract the known arguments from the passed list of args."""
   known_args = []
@@ -276,8 +267,7 @@ def get_repo_timestamp(path_to_repo):
   if p.returncode != 0:
     return None
 
-  # Get the age of the checkout in weeks.
-  return seconds_to_weeks(stdout.strip())
+  return stdout.strip()
 
 def print_boxed_text(out, min_width, lines):
   [EW, NS, SE, SW, NE, NW] = list('=|++++')

data/vendor/depot_tools/owners.py

@@ -125,7 +125,9 @@ class Database(object):
     # Mapping of owners to the paths or globs they own.
     self._owners_to_paths = {EVERYONE: set()}
 
-    # Mapping of paths to authorized owners.
+    # Mappings of paths to authorized owners, via the longest path with no
+    # glob in it.
+    # For instance "chrome/browser" -> "chrome/browser/*.h" -> ("john", "maria")
     self._paths_to_owners = {}
 
     # Mapping reviewers to the preceding comment per file in the OWNERS files.
@@ -134,9 +136,11 @@ class Database(object):
     # Cache of compiled regexes for _fnmatch()
     self._fnmatch_cache = {}
 
-    # Set of paths that stop us from looking above them for owners.
-    # (This is implicitly true for the root directory).
-    self._stop_looking = set([''])
+    # Sets of paths that stop us from looking above them for owners.
+    # (This is implicitly true for the root directory). They are organized
+    # by glob free path so that a 'ui/events/devices/mojo/*_struct_traits*.*'
+    # rule would be found in 'ui/events/devices/mojo'.
+    self._stop_looking = {'': set([''])}
 
     # Set of files which have already been read.
     self.read_files = set()
@@ -219,23 +223,59 @@ class Database(object):
 
   def load_data_needed_for(self, files):
     self._read_global_comments()
+    visited_dirs = set()
     for f in files:
       dirpath = self.os_path.dirname(f)
-      while not self._owners_for(dirpath):
+      while dirpath not in visited_dirs:
+        visited_dirs.add(dirpath)
+
+        obj_owners = self._owners_for(dirpath)
+        if obj_owners:
+          break
         self._read_owners(self.os_path.join(dirpath, 'OWNERS'))
         if self._should_stop_looking(dirpath):
           break
+
         dirpath = self.os_path.dirname(dirpath)
 
   def _should_stop_looking(self, objname):
-    return any(self._fnmatch(objname, stop_looking)
-               for stop_looking in self._stop_looking)
+    dirname = objname
+    while True:
+      if dirname in self._stop_looking:
+        if any(self._fnmatch(objname, stop_looking)
+               for stop_looking in self._stop_looking[dirname]):
+          return True
+      up_dirname = self.os_path.dirname(dirname)
+      if up_dirname == dirname:
+        break
+      dirname = up_dirname
+    return False
+
+  def _get_root_affected_dir(self, obj_name):
+    """Returns the deepest directory/path that is affected by a file pattern
+    |obj_name|."""
+    root_affected_dir = obj_name
+    while '*' in root_affected_dir:
+      root_affected_dir = self.os_path.dirname(root_affected_dir)
+    return root_affected_dir
 
   def _owners_for(self, objname):
     obj_owners = set()
-    for owned_path, path_owners in self._paths_to_owners.iteritems():
-      if self._fnmatch(objname, owned_path):
-        obj_owners |= path_owners
+
+    # Possibly relevant rules can be found stored at every directory
+    # level so iterate upwards, looking for them.
+    dirname = objname
+    while True:
+      dir_owner_rules = self._paths_to_owners.get(dirname)
+      if dir_owner_rules:
+        for owned_path, path_owners in dir_owner_rules.iteritems():
+          if self._fnmatch(objname, owned_path):
+            obj_owners |= path_owners
+      up_dirname = self.os_path.dirname(dirname)
+      if up_dirname == dirname:
+        break
+      dirname = up_dirname
+
     return obj_owners
 
   def _read_owners(self, path):
@@ -268,7 +308,7 @@ class Database(object):
       line = line.strip()
       if line.startswith('#'):
         if is_toplevel:
-          m = re.match('#\s*OWNERS_STATUS\s+=\s+(.+)$', line)
+          m = re.match(r'#\s*OWNERS_STATUS\s+=\s+(.+)$', line)
           if m:
             self._status_file = m.group(1).strip()
             continue
@@ -293,7 +333,8 @@ class Database(object):
 
       previous_line_was_blank = False
       if line == 'set noparent':
-        self._stop_looking.add(dirpath)
+        self._stop_looking.setdefault(
+          self._get_root_affected_dir(dirpath), set()).add(dirpath)
         continue
 
       m = re.match('per-file (.+)=(.+)', line)
@@ -364,7 +405,8 @@ class Database(object):
 
   def _add_entry(self, owned_paths, directive, owners_path, lineno, comment):
     if directive == 'set noparent':
-      self._stop_looking.add(owned_paths)
+      self._stop_looking.setdefault(
+        self._get_root_affected_dir(owned_paths), set()).add(owned_paths)
     elif directive.startswith('file:'):
       include_file = self._resolve_include(directive[5:], owners_path, lineno)
       if not include_file:
@@ -374,13 +416,17 @@ class Database(object):
       included_owners = self._read_just_the_owners(include_file)
       for owner in included_owners:
         self._owners_to_paths.setdefault(owner, set()).add(owned_paths)
-        self._paths_to_owners.setdefault(owned_paths, set()).add(owner)
+        self._paths_to_owners.setdefault(
+          self._get_root_affected_dir(owned_paths), {}).setdefault(
+            owned_paths, set()).add(owner)
     elif self.email_regexp.match(directive) or directive == EVERYONE:
       if comment:
         self.comments.setdefault(directive, {})
         self.comments[directive][owned_paths] = comment
       self._owners_to_paths.setdefault(directive, set()).add(owned_paths)
-      self._paths_to_owners.setdefault(owned_paths, set()).add(directive)
+      self._paths_to_owners.setdefault(
+        self._get_root_affected_dir(owned_paths), {}).setdefault(
+          owned_paths, set()).add(directive)
     else:
       raise SyntaxErrorInOwnersFile(owners_path, lineno,
           ('"%s" is not a "set noparent", file include, "*", '
@@ -463,29 +509,60 @@ class Database(object):
           all_possible_owners[o] = new_dirs
     return suggested_owners
 
-  def all_possible_owners(self, dirs, author):
+  def _all_possible_owners_for_dir_or_file(self, dir_or_file, author,
+                                           cache):
+    """Returns a dict of {potential owner: (dir_or_file, distance)} mappings.
+    """
+    assert not dir_or_file.startswith("/")
+    res = cache.get(dir_or_file)
+    if res is None:
+      res = {}
+      dirname = dir_or_file
+      for owner in self._owners_for(dirname):
+        if author and owner == author:
+          continue
+        res.setdefault(owner, [])
+        res[owner] = (dir_or_file, 1)
+      if not self._should_stop_looking(dirname):
+        dirname = self.os_path.dirname(dirname)
+
+        parent_res = self._all_possible_owners_for_dir_or_file(dirname,
+                                                               author, cache)
+
+        # Merge the parent information with our information, adjusting
+        # distances as necessary, and replacing the parent directory
+        # names with our names.
+        for owner, par_dir_and_distances in parent_res.iteritems():
+          if owner in res:
+            # If the same person is in multiple OWNERS files above a given
+            # directory, only count the closest one.
+            continue
+          parent_distance = par_dir_and_distances[1]
+          res[owner] = (dir_or_file, parent_distance + 1)
+
+      cache[dir_or_file] = res
+
+    return res
+
+  def all_possible_owners(self, dirs_and_files, author):
     """Returns a dict of {potential owner: (dir, distance)} mappings.
 
     A distance of 1 is the lowest/closest possible distance (which makes the
     subsequent math easier).
     """
+
+    all_possible_owners_for_dir_or_file_cache = {}
     all_possible_owners = {}
-    for current_dir in dirs:
-      dirname = current_dir
-      distance = 1
-      while True:
-        for owner in self._owners_for(dirname):
-          if author and owner == author:
-            continue
-          all_possible_owners.setdefault(owner, [])
-          # If the same person is in multiple OWNERS files above a given
-          # directory, only count the closest one.
-          if not any(current_dir == el[0] for el in all_possible_owners[owner]):
-            all_possible_owners[owner].append((current_dir, distance))
-        if self._should_stop_looking(dirname):
-          break
-        dirname = self.os_path.dirname(dirname)
-        distance += 1
+    for current_dir in dirs_and_files:
+      dir_owners = self._all_possible_owners_for_dir_or_file(
+        current_dir, author,
+        all_possible_owners_for_dir_or_file_cache)
+      for owner, dir_and_distance in dir_owners.iteritems():
+          if owner in all_possible_owners:
+            all_possible_owners[owner].append(dir_and_distance)
+          else:
+            all_possible_owners[owner] = [dir_and_distance]
+
     return all_possible_owners
 
   def _fnmatch(self, filename, pattern):