libv8 7.3.492.27.1 → 8.4.255.0

data/vendor/depot_tools/owners.py

@@ -2,7 +2,7 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""A database of OWNERS files.
+r"""A database of OWNERS files.
 
 OWNERS files indicate who is allowed to approve changes in a specific directory
 (or who is allowed to make changes without needing approval of another OWNER).
@@ -59,9 +59,16 @@ Examples for all of these combinations can be found in tests/owners_unittest.py.
 
 import collections
 import fnmatch
+import os
 import random
 import re
 
+try:
+  # This fallback applies for all versions of Python before 3.3
+  import collections.abc as collections_abc
+except ImportError:
+  import collections as collections_abc
+
 
 # If this is present by itself on a line, this means that everyone can review.
 EVERYONE = '*'
@@ -77,12 +84,12 @@ GLOBAL_STATUS = '*'
 
 
 def _assert_is_collection(obj):
-  assert not isinstance(obj, basestring)
+  assert not isinstance(obj, str)
   # Module 'collections' has no 'Iterable' member
   # pylint: disable=no-member
-  if hasattr(collections, 'Iterable') and hasattr(collections, 'Sized'):
-    assert (isinstance(obj, collections.Iterable) and
-            isinstance(obj, collections.Sized))
+  if hasattr(collections_abc, 'Iterable') and hasattr(collections_abc, 'Sized'):
+    assert (isinstance(obj, collections_abc.Iterable) and
+            isinstance(obj, collections_abc.Sized))
 
 
 class SyntaxErrorInOwnersFile(Exception):
@@ -125,7 +132,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 directories -> globs in the directory -> owners
+    # Example: "chrome/browser" -> "chrome/browser/*.h" -> ("john", "maria")
+    # Paths used as keys must use slashes as the separator, even on Windows.
     self._paths_to_owners = {}
 
     # Mapping reviewers to the preceding comment per file in the OWNERS files.
@@ -134,9 +143,15 @@ class Database(object):
     # Cache of compiled regexes for _fnmatch()
     self._fnmatch_cache = {}
 
-    # Set of paths that stop us from looking above them for owners.
+    # Sets of paths that stop us from looking above them for owners.
     # (This is implicitly true for the root directory).
-    self._stop_looking = set([''])
+    #
+    # The implementation is a mapping:
+    # Directory -> globs in the directory,
+    #
+    # Example:
+    # 'ui/events/devices/mojo' -> 'ui/events/devices/mojo/*_struct_traits*.*'
+    self._stop_looking = {'': set([''])}
 
     # Set of files which have already been read.
     self.read_files = set()
@@ -219,23 +234,61 @@ class Database(object):
 
   def load_data_needed_for(self, files):
     self._read_global_comments()
+    visited_dirs = set()
     for f in files:
+      # Always use slashes as separators.
+      f = f.replace(os.sep, '/')
       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.items():
+          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 +321,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 +346,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)
@@ -363,8 +417,12 @@ class Database(object):
           'cannot parse status entry: "%s"' % line.strip())
 
   def _add_entry(self, owned_paths, directive, owners_path, lineno, comment):
+    # Consistently uses paths with slashes as the keys or else Windows will
+    # break in surprising and untested ways.
+    owned_paths = owned_paths.replace(os.sep, '/')
     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 +432,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, "*", '
@@ -392,7 +454,7 @@ class Database(object):
     else:
       assert start.startswith(self.root)
       start = self.os_path.dirname(self.os_path.relpath(start, self.root))
-      include_path = self.os_path.join(start, path)
+      include_path = self.os_path.normpath(self.os_path.join(start, path))
 
     if include_path in self.override_files:
       return include_path
@@ -429,6 +491,10 @@ class Database(object):
               line.startswith('per-file')):
         continue
 
+      # If the line ends with a comment, strip the comment.
+      line, _delim, _comment = line.partition('#')
+      line = line.strip()
+
       if self.email_regexp.match(line) or line == EVERYONE:
         owners.add(line)
         continue
@@ -455,7 +521,7 @@ class Database(object):
       # Now that we've used `owner` and covered all their dirs, remove them
       # from consideration.
       del all_possible_owners[owner]
-      for o, dirs in all_possible_owners.items():
+      for o, dirs in list(all_possible_owners.items()):
         new_dirs = [(d, dist) for (d, dist) in dirs if d not in dirs_to_remove]
         if not new_dirs:
           del all_possible_owners[o]
@@ -463,33 +529,71 @@ 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.items():
+          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:
+      # Always use slashes as separators.
+      current_dir = current_dir.replace(os.sep, '/')
+      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.items():
+          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):
-    """Same as fnmatch.fnmatch(), but interally caches the compiled regexes."""
+    """Same as fnmatch.fnmatch(), but internally caches the compiled regexes."""
+    # Make sure backslashes are never used in the filename. The regex
+    # expressions generated by fnmatch.translate don't handle matching slashes
+    # to backslashes.
+    filename = filename.replace(os.sep, '/')
+    assert pattern.count('\\') == 0, 'Backslashes found in %s' % pattern
     matcher = self._fnmatch_cache.get(pattern)
     if matcher is None:
       matcher = re.compile(fnmatch.translate(pattern)).match
@@ -521,8 +625,17 @@ class Database(object):
     total_costs_by_owner = Database.total_costs_by_owner(all_possible_owners,
                                                          dirs)
     # Return the lowest cost owner. In the case of a tie, pick one randomly.
-    lowest_cost = min(total_costs_by_owner.itervalues())
-    lowest_cost_owners = filter(
-        lambda owner: total_costs_by_owner[owner] == lowest_cost,
-        total_costs_by_owner)
+    lowest_cost = min(total_costs_by_owner.values())
+    lowest_cost_owners = [
+        owner for owner, cost in total_costs_by_owner.items()
+        if cost == lowest_cost]
     return random.Random().choice(lowest_cost_owners)
+
+  def owners_rooted_at_file(self, filename):
+    """Returns a set of all owners transitively listed in filename.
+
+    This function returns a set of all the owners either listed in filename, or
+    in a file transitively included by filename. Lines that are not plain owners
+    (i.e. per-file owners) are ignored.
+    """
+    return self._read_just_the_owners(filename)

data/vendor/depot_tools/owners_finder.py

@@ -4,9 +4,15 @@
 
 """Interactive tool for finding reviewers/owners for a change."""
 
+from __future__ import print_function
+
 import os
 import copy
 import owners as owners_module
+import random
+
+
+import gclient_utils
 
 
 def first(iterable):
@@ -123,7 +129,7 @@ class OwnersFinder(object):
           self.list_owners(self.owners_queue)
           break
         elif inp == 'p' or inp == 'pick':
-          self.pick_owner(raw_input('Pick an owner: '))
+          self.pick_owner(gclient_utils.AskForData('Pick an owner: '))
           break
         elif inp.startswith('p ') or inp.startswith('pick '):
           self.pick_owner(inp.split(' ', 2)[1].strip())
@@ -159,9 +165,12 @@ class OwnersFinder(object):
     self.selected_owners = set()
     self.deselected_owners = set()
 
-    # Initialize owners queue, sort it by the score
-    self.owners_queue = list(sorted(self.owners_to_files.keys(),
-                                    key=lambda owner: self.owners_score[owner]))
+    # Randomize owners' names so that if many reviewers have identical scores
+    # they will be randomly ordered to avoid bias.
+    owners = list(self.owners_to_files.keys())
+    random.shuffle(owners)
+    self.owners_queue = sorted(owners,
+                               key=lambda owner: self.owners_score[owner])
     self.find_mandatory_owners()
 
   def select_owner(self, owner, findMandatoryOwners=True):
@@ -325,14 +334,19 @@ class OwnersFinder(object):
     # Print results
     self.writeln()
     self.writeln()
-    self.writeln('** You selected these owners **')
-    self.writeln()
-    for owner in self.selected_owners:
-      self.writeln(self.bold_name(owner) + ':')
-      self.indent()
-      for file_name in sorted(self.owners_to_files[owner]):
-        self.writeln(file_name)
-      self.unindent()
+    if len(self.selected_owners) == 0:
+      self.writeln('This change list already has owner-reviewers for all '
+                   'files.')
+      self.writeln('Use --ignore-current if you want to ignore them.')
+    else:
+      self.writeln('** You selected these owners **')
+      self.writeln()
+      for owner in self.selected_owners:
+        self.writeln(self.bold_name(owner) + ':')
+        self.indent()
+        for file_name in sorted(self.owners_to_files[owner]):
+          self.writeln(file_name)
+        self.unindent()
 
   def bold(self, text):
     return self.COLOR_BOLD + text + self.COLOR_RESET
@@ -354,7 +368,7 @@ class OwnersFinder(object):
     return '  ' * self.indentation
 
   def writeln(self, text=''):
-    print self.print_indent() + text
+    print(self.print_indent() + text)
 
   def hr(self):
     self.writeln('=====================')
@@ -367,5 +381,5 @@ class OwnersFinder(object):
 
   def input_command(self, owner):
     self.writeln('Add ' + self.bold_name(owner) + ' as your reviewer? ')
-    return raw_input(
+    return gclient_utils.AskForData(
         '[yes/no/Defer/pick/files/owners/quit/restart]: ').lower()

data/vendor/depot_tools/post_build_ninja_summary.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env vpython
 # Copyright (c) 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.
@@ -24,26 +25,20 @@ Typical output looks like this:
 ninja.exe -C out\debug_component base -j 960 -l 48  -d keeprsp
 ninja: Entering directory `out\debug_component'
 [1 processes, 1/1 @ 0.3/s : 3.092s ] Regenerating ninja files
-[1 processes, 23/23 @ 0.9/s : 26.280s ] LINK(DLL) base.dll base.dll.lib
-    Longest build steps:
-           0.9 weighted s to build obj/base/base_jumbo_17.obj (5.0 s CPU time)
-           1.0 weighted s to build obj/base/base_jumbo_31.obj (13.1 s CPU time)
-           1.2 weighted s to build obj/base/base_jumbo_4.obj (14.7 s CPU time)
-           1.3 weighted s to build obj/base/base_jumbo_32.obj (15.0 s CPU time)
-           1.6 weighted s to build obj/base/base_jumbo_26.obj (17.1 s CPU time)
-           1.7 weighted s to build base.dll, base.dll.lib (1.7 s CPU time)
-           1.7 weighted s to build obj/base/base_jumbo_11.obj (15.9 s CPU time)
-           1.9 weighted s to build obj/base/base_jumbo_12.obj (18.5 s CPU time)
-           3.6 weighted s to build obj/base/base_jumbo_34.obj (20.1 s CPU time)
-           4.3 weighted s to build obj/base/base_jumbo_33.obj (22.3 s CPU time)
-    Time by build-step type:
-           0.1 s weighted time to generate 1 .c files (0.1 s CPU time)
-           0.1 s weighted time to generate 1 .stamp files (0.1 s CPU time)
-           0.2 s weighted time to generate 1 .h files (0.2 s CPU time)
-           1.7 s weighted time to generate 1 PEFile files (1.7 s CPU time)
-          24.3 s weighted time to generate 19 .obj files (233.4 s CPU time)
-    26.3 s weighted time (235.5 s CPU time, 9.0x parallelism)
-    23 build steps completed, average of 0.88/s
+Longest build steps:
+       0.1 weighted s to build obj/base/base/trace_log.obj (6.7 s elapsed time)
+       0.2 weighted s to build nasm.exe, nasm.exe.pdb (0.2 s elapsed time)
+       0.3 weighted s to build obj/base/base/win_util.obj (12.4 s elapsed time)
+       1.2 weighted s to build base.dll, base.dll.lib (1.2 s elapsed time)
+Time by build-step type:
+       0.0 s weighted time to generate 6 .lib files (0.3 s elapsed time sum)
+       0.1 s weighted time to generate 25 .stamp files (1.2 s elapsed time sum)
+       0.2 s weighted time to generate 20 .o files (2.8 s elapsed time sum)
+       1.7 s weighted time to generate 4 PEFile (linking) files (2.0 s elapsed
+time sum)
+      23.9 s weighted time to generate 770 .obj files (974.8 s elapsed time sum)
+26.1 s weighted time (982.9 s elapsed time sum, 37.7x parallelism)
+839 build steps completed, average of 32.17/s
 
 If no gn clean has been done then results will be for the last non-NULL
 invocation of ninja. Ideas for future statistics, and implementations are
@@ -56,8 +51,11 @@ will have a weighted time that is the same or similar to its elapsed time. A
 compile that runs in parallel with 999 other compiles will have a weighted time
 that is tiny."""
 
+from __future__ import print_function
+
 import argparse
 import errno
+import fnmatch
 import os
 import sys
 
@@ -65,7 +63,7 @@ import sys
 # The number of long build times to report:
 long_count = 10
 # The number of long times by extension to report
-long_ext_count = 5
+long_ext_count = 10
 
 
 class Target:
@@ -100,7 +98,7 @@ class Target:
         # Allow for modest floating-point errors
         epsilon = 0.000002
         if (self.weighted_duration > self.Duration() + epsilon):
-          print '%s > %s?' % (self.weighted_duration, self.Duration())
+          print('%s > %s?' % (self.weighted_duration, self.Duration()))
         assert(self.weighted_duration <= self.Duration() + epsilon)
         return self.weighted_duration
 
@@ -166,37 +164,54 @@ def ReadTargets(log, show_all):
     return targets_dict.values()
 
 
-def GetExtension(target):
+def GetExtension(target, extra_patterns):
   """Return the file extension that best represents a target.
 
   For targets that generate multiple outputs it is important to return a
   consistent 'canonical' extension. Ultimately the goal is to group build steps
   by type."""
   for output in target.targets:
-    # Normalize all mojo related outputs to 'mojo'.
-    if output.count('.mojom') > 0:
-      extension = 'mojo'
-      break
+    if extra_patterns:
+      for fn_pattern in extra_patterns.split(';'):
+        if fnmatch.fnmatch(output, '*' + fn_pattern + '*'):
+          return fn_pattern
     # Not a true extension, but a good grouping.
     if output.endswith('type_mappings'):
       extension = 'type_mappings'
       break
-    extension = os.path.splitext(output)[1]
+
+    # Capture two extensions if present. For example: file.javac.jar should be
+    # distinguished from file.interface.jar.
+    root, ext1 = os.path.splitext(output)
+    _, ext2 = os.path.splitext(root)
+    extension = ext2 + ext1 # Preserve the order in the file name.
+
     if len(extension) == 0:
       extension = '(no extension found)'
-    if extension in ['.pdb', '.dll', '.exe']:
+
+    if ext1 in ['.pdb', '.dll', '.exe']:
       extension = 'PEFile (linking)'
       # Make sure that .dll and .exe are grouped together and that the
       # .dll.lib files don't cause these to be listed as libraries
       break
-    if extension in ['.so', '.TOC']:
+    if ext1 in ['.so', '.TOC']:
       extension = '.so (linking)'
       # Attempt to identify linking, avoid identifying as '.TOC'
       break
+    # Make sure .obj files don't get categorized as mojo files
+    if ext1 in ['.obj', '.o']:
+      break
+    # Jars are the canonical output of java targets.
+    if ext1 == '.jar':
+      break
+    # Normalize all mojo related outputs to 'mojo'.
+    if output.count('.mojom') > 0:
+      extension = 'mojo'
+      break
   return extension
 
 
-def SummarizeEntries(entries):
+def SummarizeEntries(entries, extra_step_types):
     """Print a summary of the passed in list of Target objects."""
 
     # Create a list that is in order by time stamp and has entries for the
@@ -256,16 +271,16 @@ def SummarizeEntries(entries):
 
     # Warn if the sum of weighted times is off by more than half a second.
     if abs(length - weighted_total) > 500:
-      print 'Discrepancy!!! Length = %.3f, weighted total = %.3f' % (
-            length, weighted_total)
+      print('Discrepancy!!! Length = %.3f, weighted total = %.3f' % (
+            length, weighted_total))
 
     # Print the slowest build steps (by weighted time).
-    print '    Longest build steps:'
+    print('    Longest build steps:')
     entries.sort(key=lambda x: x.WeightedDuration())
     for target in entries[-long_count:]:
-      print '      %8.1f weighted s to build %s (%.1f s CPU time)' % (
+      print('      %8.1f weighted s to build %s (%.1f s elapsed time)' % (
             target.WeightedDuration(),
-            target.DescribeTargets(), target.Duration())
+            target.DescribeTargets(), target.Duration()))
 
     # Sum up the time by file extension/type of the output file
     count_by_ext = {}
@@ -273,27 +288,27 @@ def SummarizeEntries(entries):
     weighted_time_by_ext = {}
     # Scan through all of the targets to build up per-extension statistics.
     for target in entries:
-      extension = GetExtension(target)
+      extension = GetExtension(target, extra_step_types)
       time_by_ext[extension] = time_by_ext.get(extension, 0) + target.Duration()
       weighted_time_by_ext[extension] = weighted_time_by_ext.get(extension,
               0) + target.WeightedDuration()
       count_by_ext[extension] = count_by_ext.get(extension, 0) + 1
 
-    print '    Time by build-step type:'
+    print('    Time by build-step type:')
     # Copy to a list with extension name and total time swapped, to (time, ext)
     weighted_time_by_ext_sorted = sorted((y, x) for (x, y) in
                                           weighted_time_by_ext.items())
     # Print the slowest build target types (by weighted time):
     for time, extension in weighted_time_by_ext_sorted[-long_ext_count:]:
-        print ('      %8.1f s weighted time to generate %d %s files '
-               '(%1.1f s CPU time)') % (time, count_by_ext[extension],
-                                        extension, time_by_ext[extension])
+        print('      %8.1f s weighted time to generate %d %s files '
+               '(%1.1f s elapsed time sum)' % (time, count_by_ext[extension],
+                                        extension, time_by_ext[extension]))
 
-    print '    %.1f s weighted time (%.1f s CPU time, %1.1fx parallelism)' % (
-          length, total_cpu_time,
-          total_cpu_time * 1.0 / length)
-    print '    %d build steps completed, average of %1.2f/s' % (
-          len(entries), len(entries) / (length))
+    print('    %.1f s weighted time (%.1f s elapsed time sum, %1.1fx '
+          'parallelism)' % (length, total_cpu_time,
+          total_cpu_time * 1.0 / length))
+    print('    %d build steps completed, average of %1.2f/s' % (
+          len(entries), len(entries) / (length)))
 
 
 def main():
@@ -301,6 +316,10 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('-C', dest='build_directory',
                         help='Build directory.')
+    parser.add_argument(
+        '-s',
+        '--step-types',
+        help='semicolon separated fnmatch patterns for build-step grouping')
     parser.add_argument('--log-file',
                         help="specific ninja log file to analyze.")
     args, _extra_args = parser.parse_known_args()
@@ -308,13 +327,22 @@ def main():
         log_file = os.path.join(args.build_directory, log_file)
     if args.log_file:
         log_file = args.log_file
+    if not args.step_types:
+      # Offer a convenient way to add extra step types automatically, including
+      # when this script is run by autoninja. get() returns None if the variable
+      # isn't set.
+      args.step_types = os.environ.get('chromium_step_types')
+    if args.step_types:
+      # Make room for the extra build types.
+      global long_ext_count
+      long_ext_count += len(args.step_types.split(';'))
 
     try:
       with open(log_file, 'r') as log:
         entries = ReadTargets(log, False)
-        SummarizeEntries(entries)
+        SummarizeEntries(entries, args.step_types)
     except IOError:
-      print 'Log file %r not found, no build summary created.' % log_file
+      print('Log file %r not found, no build summary created.' % log_file)
       return errno.ENOENT