Add a way to require approval from owners other than the author.

owners.py

 # Copyright (c) 2012 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.
 
 """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).
 Note that all changes must still be reviewed by someone familiar with the code,
 so you may need approval from both an OWNER and a reviewer in many cases.
@@ skipping 97 matching lines @@
     # Mapping of owners to the paths they own.
     self.owned_by = {EVERYONE: set()}
 
     # Mapping of paths to authorized owners.
     self.owners_for = {}
 
     # Set of paths that stop us from looking above them for owners.
     # (This is implicitly true for the root directory).
     self.stop_looking = set([''])
 
-  def reviewers_for(self, files):
+  def reviewers_for(self, files, author):
     """Returns a suggested set of reviewers that will cover the files.
 
-    files is a sequence of paths relative to (and under) self.root."""
+    files is a sequence of paths relative to (and under) self.root.
+    If author is nonempty, we ensure it is not included in the set returned
+    in order avoid suggesting the author as a reviewer for their own changes."""
     self._check_paths(files)
     self._load_data_needed_for(files)
-    suggested_owners = self._covering_set_of_owners_for(files)
+    suggested_owners = self._covering_set_of_owners_for(files, author)
     if EVERYONE in suggested_owners:
       if len(suggested_owners) > 1:
         suggested_owners.remove(EVERYONE)
       else:
         suggested_owners = set(['<anyone>'])
     return suggested_owners
 
   def files_not_covered_by(self, files, reviewers):
     """Returns the files not owned by one of the reviewers.
 
@@ skipping 94 matching lines @@
     if directive == "set noparent":
       self.stop_looking.add(path)
     elif self.email_regexp.match(directive) or directive == EVERYONE:
       self.owned_by.setdefault(directive, set()).add(path)
       self.owners_for.setdefault(path, set()).add(directive)
     else:
       raise SyntaxErrorInOwnersFile(owners_path, lineno,
           ('%s is not a "set" directive, "*", '
            'or an email address: "%s"' % (line_type, directive)))
 
-  def _covering_set_of_owners_for(self, files):
+  def _covering_set_of_owners_for(self, files, author):
     dirs_remaining = set(self._enclosing_dir_with_owners(f) for f in files)
-    all_possible_owners = self._all_possible_owners(dirs_remaining)
+    all_possible_owners = self._all_possible_owners(dirs_remaining, author)
     suggested_owners = set()
     while dirs_remaining:
       owner = self.lowest_cost_owner(all_possible_owners, dirs_remaining)
       suggested_owners.add(owner)
       dirs_to_remove = set(el[0] for el in all_possible_owners[owner])
       dirs_remaining -= dirs_to_remove
     return suggested_owners
 
-  def _all_possible_owners(self, dirs):
+  def _all_possible_owners(self, dirs, author):
     """Returns a list of (potential owner, distance-from-dir) tuples; a
     distance of 1 is the lowest/closest possible distance (which makes the
     subsequent math easier)."""
     all_possible_owners = {}
     for current_dir in dirs:
       dirname = current_dir
       distance = 1
       while True:
         for owner in self.owners_for.get(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._stop_looking(dirname):
           break
         dirname = self.os_path.dirname(dirname)
         distance += 1
     return all_possible_owners
@@ skipping 16 matching lines @@
         if num_directories_owned:
           total_costs_by_owner[owner] = (total_distance /
                                          pow(num_directories_owned, 1.75))
 
     # 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)
     return random.Random().choice(lowest_cost_owners)