libv8 6.3.292.48.1 → 6.7.288.46.0

data/vendor/depot_tools/owners.py

@@ -11,11 +11,10 @@ so you may need approval from both an OWNER and a reviewer in many cases.
 
 The syntax of the OWNERS file is, roughly:
 
-lines     := (\s* line? \s* "\n")*
+lines     := (\s* line? \s* comment? \s* "\n")*
 
 line      := directive
           | "per-file" \s+ glob \s* "=" \s* directive
-          | comment
 
 directive := "set noparent"
           |  "file:" glob
@@ -276,6 +275,12 @@ class Database(object):
         previous_line_was_blank = True
         continue
 
+      # If the line ends with a comment, strip the comment and store it for this
+      # line only.
+      line, _, line_comment = line.partition('#')
+      line = line.strip()
+      line_comment = [line_comment.strip()] if line_comment else []
+
       previous_line_was_blank = False
       if line == 'set noparent':
         self._stop_looking.add(dirpath)
@@ -292,7 +297,7 @@ class Database(object):
               line)
         relative_glob_string = self.os_path.relpath(full_glob_string, self.root)
         self._add_entry(relative_glob_string, directive, owners_path,
-                        lineno, '\n'.join(comment))
+                        lineno, '\n'.join(comment + line_comment))
         if reset_comment_after_use:
           comment = []
         continue
@@ -302,7 +307,7 @@ class Database(object):
             'unknown option: "%s"' % line[4:].strip())
 
       self._add_entry(dirpath, line, owners_path, lineno,
-                      ' '.join(comment))
+                      ' '.join(comment + line_comment))
       if reset_comment_after_use:
         comment = []
 

data/vendor/depot_tools/owners_finder.py

@@ -22,7 +22,7 @@ class OwnersFinder(object):
 
   indentation = 0
 
-  def __init__(self, files, local_root, author,
+  def __init__(self, files, local_root, author, reviewers,
                fopen, os_path,
                email_postfix='@chromium.org',
                disable_color=False,
@@ -45,9 +45,13 @@ class OwnersFinder(object):
 
     filtered_files = files
 
-    # Eliminate files that the author can review.
+    reviewers = list(reviewers)
+    if author:
+      reviewers.append(author)
+
+    # Eliminate files that existing reviewers can review.
     filtered_files = list(self.db.files_not_covered_by(
-      filtered_files, [author] if author else []))
+        filtered_files, reviewers))
 
     # If some files are eliminated.
     if len(filtered_files) != len(files):

data/vendor/depot_tools/post_build_ninja_summary.py

@@ -0,0 +1,322 @@
+# 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.
+
+"""Summarize the last ninja build, invoked with ninja's -C syntax.
+
+This script is designed to be automatically run after each ninja build in
+order to summarize the build's performance. Making build performance information
+more visible should make it easier to notice anomalies and opportunities. To use
+this script on Windows just set NINJA_SUMMARIZE_BUILD=1 and run autoninja.bat.
+
+On Linux you can get autoninja to invoke this script using this syntax:
+
+$ NINJA_SUMMARIZE_BUILD=1 autoninja -C out/Default/ chrome
+
+You can also call this script directly using ninja's syntax to specify the
+output directory of interest:
+
+> python post_build_ninja_summary.py -C out/Default
+
+Typical output looks like this:
+
+>ninja -C out\debug_component base
+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
+
+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
+appreciated.
+
+The "weighted" time is the elapsed time of each build step divided by the number
+of tasks that were running in parallel. This makes it an excellent approximation
+of how "important" a slow step was. A link that is entirely or mostly serialized
+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."""
+
+import argparse
+import errno
+import os
+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
+
+
+class Target:
+    """Represents a single line read for a .ninja_log file."""
+    def __init__(self, start, end):
+        """Creates a target object by passing in the start/end times in seconds
+        as a float."""
+        self.start = start
+        self.end = end
+        # A list of targets, appended to by the owner of this object.
+        self.targets = []
+        self.weighted_duration = 0.0
+
+    def Duration(self):
+        """Returns the task duration in seconds as a float."""
+        return self.end - self.start
+
+    def SetWeightedDuration(self, weighted_duration):
+        """Sets the duration, in seconds, passed in as a float."""
+        self.weighted_duration = weighted_duration
+
+    def WeightedDuration(self):
+        """Returns the task's weighted duration in seconds as a float.
+
+        Weighted_duration takes the elapsed time of the task and divides it
+        by how many other tasks were running at the same time. Thus, it
+        represents the approximate impact of this task on the total build time,
+        with serialized or serializing steps typically ending up with much
+        longer weighted durations.
+        weighted_duration should always be the same or shorter than duration.
+        """
+        # Allow for modest floating-point errors
+        epsilon = 0.000002
+        if (self.weighted_duration > self.Duration() + epsilon):
+          print '%s > %s?' % (self.weighted_duration, self.Duration())
+        assert(self.weighted_duration <= self.Duration() + epsilon)
+        return self.weighted_duration
+
+    def DescribeTargets(self):
+        """Returns a printable string that summarizes the targets."""
+        if len(self.targets) == 1:
+          return self.targets[0]
+        # Some build steps generate dozens of outputs - handle them sanely.
+        # It's a bit odd that if there are three targets we return all three
+        # but if there are more than three we just return two, but this works
+        # well in practice.
+        elif len(self.targets) > 3:
+          return '(%d items) ' % len(self.targets) + (
+                 ', '.join(self.targets[:2]) + ', ...')
+        else:
+          return ', '.join(self.targets)
+
+
+# Copied with some modifications from ninjatracing
+def ReadTargets(log, show_all):
+    """Reads all targets from .ninja_log file |log_file|, sorted by duration.
+
+    The result is a list of Target objects."""
+    header = log.readline()
+    assert header == '# ninja log v5\n', \
+           'unrecognized ninja log version %r' % header
+    targets_dict = {}
+    last_end_seen = 0.0
+    for line in log:
+        parts = line.strip().split('\t')
+        if len(parts) != 5:
+          # If ninja.exe is rudely halted then the .ninja_log file may be
+          # corrupt. Silently continue.
+          continue
+        start, end, _, name, cmdhash = parts # Ignore restat.
+        # Convert from integral milliseconds to float seconds.
+        start = int(start) / 1000.0
+        end = int(end) / 1000.0
+        if not show_all and end < last_end_seen:
+            # An earlier time stamp means that this step is the first in a new
+            # build, possibly an incremental build. Throw away the previous
+            # data so that this new build will be displayed independently.
+            # This has to be done by comparing end times because records are
+            # written to the .ninja_log file when commands complete, so end
+            # times are guaranteed to be in order, but start times are not.
+            targets_dict = {}
+        target = None
+        if cmdhash in targets_dict:
+          target = targets_dict[cmdhash]
+          if not show_all and (target.start != start or target.end != end):
+            # If several builds in a row just run one or two build steps then
+            # the end times may not go backwards so the last build may not be
+            # detected as such. However in many cases there will be a build step
+            # repeated in the two builds and the changed start/stop points for
+            # that command, identified by the hash, can be used to detect and
+            # reset the target dictionary.
+            targets_dict = {}
+            target = None
+        if not target:
+          targets_dict[cmdhash] = target = Target(start, end)
+        last_end_seen = end
+        target.targets.append(name)
+    return targets_dict.values()
+
+
+def GetExtension(target):
+  """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
+    # Not a true extension, but a good grouping.
+    if output.endswith('type_mappings'):
+      extension = 'type_mappings'
+      break
+    extension = os.path.splitext(output)[1]
+    if len(extension) == 0:
+      extension = '(no extension found)'
+    if extension 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']:
+      extension = '.so (linking)'
+      # Attempt to identify linking, avoid identifying as '.TOC'
+      break
+  return extension
+
+
+def SummarizeEntries(entries):
+    """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
+    # beginning and ending of each build step (one time stamp may have multiple
+    # entries due to multiple steps starting/stopping at exactly the same time).
+    # Iterate through this list, keeping track of which tasks are running at all
+    # times. At each time step calculate a running total for weighted time so
+    # that when each task ends its own weighted time can easily be calculated.
+    task_start_stop_times = []
+
+    earliest = -1
+    latest = 0
+    total_cpu_time = 0
+    for target in entries:
+      if earliest < 0 or target.start < earliest:
+        earliest = target.start
+      if target.end > latest:
+        latest = target.end
+      total_cpu_time += target.Duration()
+      task_start_stop_times.append((target.start, 'start', target))
+      task_start_stop_times.append((target.end, 'stop', target))
+    length = latest - earliest
+    weighted_total = 0.0
+
+    task_start_stop_times.sort()
+    # Now we have all task start/stop times sorted by when they happen. If a
+    # task starts and stops on the same time stamp then the start will come
+    # first because of the alphabet, which is important for making this work
+    # correctly.
+    # Track the tasks which are currently running.
+    running_tasks = {}
+    # Record the time we have processed up to so we know how to calculate time
+    # deltas.
+    last_time = task_start_stop_times[0][0]
+    # Track the accumulated weighted time so that it can efficiently be added
+    # to individual tasks.
+    last_weighted_time = 0.0
+    # Scan all start/stop events.
+    for event in task_start_stop_times:
+      time, action_name, target = event
+      # Accumulate weighted time up to now.
+      num_running = len(running_tasks)
+      if num_running > 0:
+        # Update the total weighted time up to this moment.
+        last_weighted_time += (time - last_time) / float(num_running)
+      if action_name == 'start':
+        # Record the total weighted task time when this task starts.
+        running_tasks[target] = last_weighted_time
+      if action_name == 'stop':
+        # Record the change in the total weighted task time while this task ran.
+        weighted_duration = last_weighted_time - running_tasks[target]
+        target.SetWeightedDuration(weighted_duration)
+        weighted_total += weighted_duration
+        del running_tasks[target]
+      last_time = time
+    assert(len(running_tasks) == 0)
+
+    # 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 the slowest build steps (by weighted time).
+    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)' % (
+            target.WeightedDuration(),
+            target.DescribeTargets(), target.Duration())
+
+    # Sum up the time by file extension/type of the output file
+    count_by_ext = {}
+    time_by_ext = {}
+    weighted_time_by_ext = {}
+    # Scan through all of the targets to build up per-extension statistics.
+    for target in entries:
+      extension = GetExtension(target)
+      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:'
+    # 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 '    %.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))
+
+
+def main():
+    log_file = '.ninja_log'
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-C', dest='build_directory',
+                        help='Build directory.')
+    parser.add_argument('--log-file',
+                        help="specific ninja log file to analyze.")
+    args, _extra_args = parser.parse_known_args()
+    if args.build_directory:
+        log_file = os.path.join(args.build_directory, log_file)
+    if args.log_file:
+        log_file = args.log_file
+
+    try:
+      with open(log_file, 'r') as log:
+        entries = ReadTargets(log, False)
+        SummarizeEntries(entries)
+    except IOError:
+      print 'Log file %r not found, no build summary created.' % log_file
+      return errno.ENOENT
+
+
+if __name__ == '__main__':
+    sys.exit(main())

data/vendor/depot_tools/presubmit_canned_checks.py

@@ -80,7 +80,7 @@ def CheckChangeWasUploaded(input_api, output_api):
 
 ### Content checks
 
-def CheckAuthorizedAuthor(input_api, output_api):
+def CheckAuthorizedAuthor(input_api, output_api, bot_whitelist=None):
   """For non-googler/chromites committers, verify the author's email address is
   in AUTHORS.
   """
@@ -93,6 +93,11 @@ def CheckAuthorizedAuthor(input_api, output_api):
   if not author:
     input_api.logging.info('No author, skipping AUTHOR check')
     return []
+
+  # This is used for CLs created by trusted robot accounts.
+  if bot_whitelist and author in bot_whitelist:
+    return []
+
   authors_path = input_api.os_path.join(
       input_api.PresubmitLocalPath(), 'AUTHORS')
   valid_authors = (
@@ -528,11 +533,7 @@ def GetUnitTests(input_api, output_api, unit_tests, env=None):
 
   results = []
   for unit_test in unit_tests:
-    cmd = []
-    if input_api.platform == 'win32' and unit_test.endswith('.py'):
-      # Windows needs some help.
-      cmd = [input_api.python_executable]
-    cmd.append(unit_test)
+    cmd = [unit_test]
     if input_api.verbose:
       cmd.append('--verbose')
     kwargs = {'cwd': input_api.PresubmitLocalPath()}
@@ -611,6 +612,7 @@ def GetPythonUnitTests(input_api, output_api, unit_tests):
       if env.get('PYTHONPATH'):
         backpath.append(env.get('PYTHONPATH'))
       env['PYTHONPATH'] = input_api.os_path.pathsep.join((backpath))
+      env.pop('VPYTHON_CLEAR_PYTHONPATH', None)
     cmd = [input_api.python_executable, '-m', '%s' % unit_test]
     results.append(input_api.Command(
         name=unit_test_name,
@@ -730,12 +732,11 @@ def GetPylint(input_api, output_api, white_list=None, black_list=None,
 
   input_api.logging.info('Running pylint on %d files', len(files))
   input_api.logging.debug('Running pylint on: %s', files)
-  # Copy the system path to the environment so pylint can find the right
-  # imports.
   env = input_api.environ.copy()
-  import sys
   env['PYTHONPATH'] = input_api.os_path.pathsep.join(
-      extra_paths_list + sys.path).encode('utf8')
+    extra_paths_list).encode('utf8')
+  env.pop('VPYTHON_CLEAR_PYTHONPATH', None)
+  input_api.logging.debug('  with extra PYTHONPATH: %r', extra_paths_list)
 
   def GetPylintCmd(flist, extra, parallel):
     # Windows needs help running python files so we explicitly specify
@@ -797,15 +798,6 @@ def RunPylint(input_api, *args, **kwargs):
   return input_api.RunTests(GetPylint(input_api, *args, **kwargs), False)
 
 
-def CheckRietveldTryJobExecution(dummy_input_api, output_api,
-                                 dummy_host_url, dummy_platforms,
-                                 dummy_owner):
-  return [
-    output_api.PresubmitNotifyResult(
-        'CheckRietveldTryJobExecution is deprecated, please remove it.')
-  ]
-
-
 def CheckBuildbotPendingBuilds(input_api, output_api, url, max_pendings,
     ignored):
   try:
@@ -839,9 +831,29 @@ def CheckBuildbotPendingBuilds(input_api, output_api, url, max_pendings,
   return []
 
 
+def CheckOwnersFormat(input_api, output_api):
+  affected_files = set([
+      f.LocalPath()
+      for f in input_api.change.AffectedFiles()
+      if 'OWNERS' in f.LocalPath() and f.Action() != 'D'
+  ])
+  if not affected_files:
+    return []
+  try:
+    input_api.owners_db.load_data_needed_for(affected_files)
+    return []
+  except Exception as e:
+    return [output_api.PresubmitError(
+        'Error parsing OWNERS files:\n%s' % e)]
+
+
 def CheckOwners(input_api, output_api, source_file_filter=None):
+  affected_files = set([f.LocalPath() for f in
+      input_api.change.AffectedFiles(file_filter=source_file_filter)])
+  affects_owners = any('OWNERS' in name for name in affected_files)
+
   if input_api.is_committing:
-    if input_api.tbr:
+    if input_api.tbr and not affects_owners:
       return [output_api.PresubmitNotifyResult(
           '--tbr was specified, skipping OWNERS check')]
     needed = 'LGTM from an OWNER'
@@ -852,15 +864,13 @@ def CheckOwners(input_api, output_api, source_file_filter=None):
             'This is a dry run, but these failures would be reported on ' +
             'commit:\n' + text)
     else:
-      return [output_api.PresubmitError("OWNERS check failed: this change has "
-          "no Rietveld issue number, so we can't check it for approvals.")]
+      return [output_api.PresubmitError(
+          'OWNERS check failed: this CL has no Gerrit change number, '
+          'so we can\'t check it for approvals.')]
   else:
     needed = 'OWNER reviewers'
     output_fn = output_api.PresubmitNotifyResult
 
-  affected_files = set([f.LocalPath() for f in
-      input_api.change.AffectedFiles(file_filter=source_file_filter)])
-
   owners_db = input_api.owners_db
   owners_db.override_files = input_api.change.OriginalOwnersFiles()
   owner_email, reviewers = GetCodereviewOwnerAndReviewers(
@@ -870,24 +880,22 @@ def CheckOwners(input_api, output_api, source_file_filter=None):
 
   owner_email = owner_email or input_api.change.author_email
 
-  if owner_email:
-    reviewers_plus_owner = set([owner_email]).union(reviewers)
-    missing_files = owners_db.files_not_covered_by(affected_files,
-        reviewers_plus_owner)
-  else:
-    missing_files = owners_db.files_not_covered_by(affected_files, reviewers)
+  finder = input_api.owners_finder(
+      affected_files, input_api.change.RepositoryRoot(),
+      owner_email, reviewers, fopen=file, os_path=input_api.os_path,
+      email_postfix='', disable_color=True,
+      override_files=input_api.change.OriginalOwnersFiles())
+  missing_files = finder.unreviewed_files
 
   if missing_files:
     output_list = [
         output_fn('Missing %s for these files:\n    %s' %
                   (needed, '\n    '.join(sorted(missing_files))))]
+    if input_api.tbr and affects_owners:
+      output_list.append(output_fn('Note that TBR does not apply to changes '
+                                   'that affect OWNERS files.'))
     if not input_api.is_committing:
       suggested_owners = owners_db.reviewers_for(missing_files, owner_email)
-      finder = input_api.owners_finder(
-          missing_files, input_api.change.RepositoryRoot(),
-          owner_email, fopen=file, os_path=input_api.os_path,
-          email_postfix='', disable_color=True,
-          override_files=input_api.change.OriginalOwnersFiles())
       owners_with_comments = []
       def RecordComments(text):
         owners_with_comments.append(finder.print_indent() + text)
@@ -903,25 +911,25 @@ def CheckOwners(input_api, output_api, source_file_filter=None):
     return [output_fn('Missing LGTM from someone other than %s' % owner_email)]
   return []
 
+
 def GetCodereviewOwnerAndReviewers(input_api, email_regexp, approval_needed):
   """Return the owner and reviewers of a change, if any.
 
   If approval_needed is True, only reviewers who have approved the change
   will be returned.
   """
-  # Rietveld is default.
-  func = _RietveldOwnerAndReviewers
-  if input_api.gerrit:
-    func = _GerritOwnerAndReviewers
-  return func(input_api, email_regexp, approval_needed)
-
-
-def _GetRietveldIssueProps(input_api, messages):
-  """Gets the issue properties from rietveld."""
   issue = input_api.change.issue
-  if issue and input_api.rietveld:
-    return input_api.rietveld.get_issue_properties(
-        issue=int(issue), messages=messages)
+  if not issue:
+    return None, (set() if approval_needed else
+                  _ReviewersFromChange(input_api.change))
+
+  owner_email = input_api.gerrit.GetChangeOwner(issue)
+  reviewers = set(
+      r for r in input_api.gerrit.GetChangeReviewers(issue, approval_needed)
+      if _match_reviewer_email(r, owner_email, email_regexp))
+  input_api.logging.debug('owner: %s; approvals given by: %s',
+                          owner_email, ', '.join(sorted(reviewers)))
+  return owner_email, reviewers
 
 
 def _ReviewersFromChange(change):
@@ -937,49 +945,6 @@ def _ReviewersFromChange(change):
 def _match_reviewer_email(r, owner_email, email_regexp):
   return email_regexp.match(r) and r != owner_email
 
-def _RietveldOwnerAndReviewers(input_api, email_regexp, approval_needed=False):
-  """Return the owner and reviewers of a change, if any.
-
-  If approval_needed is True, only reviewers who have approved the change
-  will be returned.
-  """
-  issue_props = _GetRietveldIssueProps(input_api, True)
-  if not issue_props:
-    return None, (set() if approval_needed else
-                  _ReviewersFromChange(input_api.change))
-
-  if not approval_needed:
-    return issue_props['owner_email'], set(issue_props['reviewers'])
-
-  owner_email = issue_props['owner_email']
-
-  messages = issue_props.get('messages', [])
-  approvers = set(
-      m['sender'] for m in messages
-      if m.get('approval') and _match_reviewer_email(m['sender'], owner_email,
-                                                     email_regexp))
-  return owner_email, approvers
-
-
-def _GerritOwnerAndReviewers(input_api, email_regexp, approval_needed=False):
-  """Return the owner and reviewers of a change, if any.
-
-  If approval_needed is True, only reviewers who have approved the change
-  will be returned.
-  """
-  issue = input_api.change.issue
-  if not issue:
-    return None, (set() if approval_needed else
-                  _ReviewersFromChange(input_api.change))
-
-  owner_email = input_api.gerrit.GetChangeOwner(issue)
-  reviewers = set(
-      r for r in input_api.gerrit.GetChangeReviewers(issue, approval_needed)
-      if _match_reviewer_email(r, owner_email, email_regexp))
-  input_api.logging.debug('owner: %s; approvals given by: %s',
-                          owner_email, ', '.join(sorted(reviewers)))
-  return owner_email, reviewers
-
 
 def CheckSingletonInHeaders(input_api, output_api, source_file_filter=None):
   """Deprecated, must be removed."""
@@ -1057,6 +1022,10 @@ def PanProjectChecks(input_api, output_api,
         print "  %s took a long time: %dms" % (snapshot_memory[1], delta_ms)
     snapshot_memory[:] = (dt2, msg)
 
+  snapshot("checking owners files format")
+  results.extend(input_api.canned_checks.CheckOwnersFormat(
+      input_api, output_api))
+
   if owners_check:
     snapshot("checking owners")
     results.extend(input_api.canned_checks.CheckOwners(
@@ -1091,12 +1060,21 @@ def PanProjectChecks(input_api, output_api,
   return results
 
 
-def CheckPatchFormatted(input_api, output_api, check_js=False):
+def CheckPatchFormatted(
+    input_api, output_api, check_js=False, check_python=False,
+    result_factory=None):
+  result_factory = result_factory or output_api.PresubmitPromptWarning
   import git_cl
-  cmd = ['-C', input_api.change.RepositoryRoot(),
-         'cl', 'format', '--dry-run', '--presubmit']
+
+  display_args = []
   if check_js:
-    cmd.append('--js')
+    display_args.append('--js')
+  if check_python:
+    # --python requires --full
+    display_args.extend(['--python', '--full'])
+
+  cmd = ['-C', input_api.change.RepositoryRoot(),
+         'cl', 'format', '--dry-run', '--presubmit'] + display_args
   presubmit_subdir = input_api.os_path.relpath(
       input_api.PresubmitLocalPath(), input_api.change.RepositoryRoot())
   if presubmit_subdir.startswith('..') or presubmit_subdir == '.':
@@ -1112,10 +1090,11 @@ def CheckPatchFormatted(input_api, output_api, check_js=False):
       short_path = presubmit_subdir
     else:
       short_path = input_api.basename(input_api.change.RepositoryRoot())
-    return [output_api.PresubmitPromptWarning(
+    display_args.append(presubmit_subdir)
+    return [result_factory(
       'The %s directory requires source formatting. '
-      'Please run: git cl format %s%s' %
-      (short_path, '--js ' if check_js else '', presubmit_subdir))]
+      'Please run: git cl format %s' %
+      (short_path, ' '.join(display_args)))]
   # As this is just a warning, ignore all other errors if the user
   # happens to have a broken clang-format, doesn't use git, etc etc.
   return []
@@ -1217,7 +1196,7 @@ def CheckVPythonSpec(input_api, output_api, file_filter=None):
     A list of input_api.Command objects containing verification commands.
   """
   file_filter = file_filter or (lambda f: f.LocalPath().endswith('.vpython'))
-  affected_files = input_api.AffectedFiles(file_filter=file_filter)
+  affected_files = input_api.AffectedTestableFiles(file_filter=file_filter)
   affected_files = map(lambda f: f.AbsoluteLocalPath(), affected_files)
 
   commands = []
@@ -1235,6 +1214,7 @@ def CheckChangedLUCIConfigs(input_api, output_api):
   import collections
   import base64
   import json
+  import logging
   import urllib2
 
   import auth
@@ -1243,13 +1223,16 @@ def CheckChangedLUCIConfigs(input_api, output_api):
   LUCI_CONFIG_HOST_NAME = 'luci-config.appspot.com'
 
   cl = git_cl.Changelist()
-  remote, remote_branch = cl.GetRemoteBranch()
-  if remote_branch.startswith('refs/remotes/%s/' % remote):
-    remote_branch = remote_branch.replace(
-        'refs/remotes/%s/' % remote, 'refs/heads/', 1)
-  if remote_branch.startswith('refs/remotes/branch-heads/'):
-    remote_branch = remote_branch.replace(
-        'refs/remotes/branch-heads/', 'refs/branch-heads/', 1)
+  if input_api.change.issue and input_api.gerrit:
+    remote_branch = input_api.gerrit.GetDestRef(input_api.change.issue)
+  else:
+    remote, remote_branch = cl.GetRemoteBranch()
+    if remote_branch.startswith('refs/remotes/%s/' % remote):
+      remote_branch = remote_branch.replace(
+          'refs/remotes/%s/' % remote, 'refs/heads/', 1)
+    if remote_branch.startswith('refs/remotes/branch-heads/'):
+      remote_branch = remote_branch.replace(
+          'refs/remotes/branch-heads/', 'refs/branch-heads/', 1)
 
   remote_host_url = cl.GetRemoteUrl()
   if not remote_host_url:
@@ -1286,6 +1269,7 @@ def CheckChangedLUCIConfigs(input_api, output_api):
   if not config_sets:
     return [output_api.PresubmitWarning('No config_sets were returned')]
   loc_pref = '%s/+/%s/' % (remote_host_url, remote_branch)
+  logging.debug('Derived location prefix: %s', loc_pref)
   dir_to_config_set = {
     '%s/' % cs['location'][len(loc_pref):].rstrip('/'): cs['config_set']
     for cs in config_sets
@@ -1296,6 +1280,7 @@ def CheckChangedLUCIConfigs(input_api, output_api):
   for f in input_api.AffectedFiles():
     # windows
     file_path = f.LocalPath().replace(_os.sep, '/')
+    logging.debug('Affected file path: %s', file_path)
     for dr, cs in dir_to_config_set.iteritems():
       if dr == '/' or file_path.startswith(dr):
         cs_to_files[cs].append({