Reland Implement owners check in presubmit for Gerrit.

presubmit_canned_checks.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.
 
 """Generic presubmit checks that can be reused by other presubmit checks."""
 
 import os as _os
 _HERE = _os.path.dirname(_os.path.abspath(__file__))
 
 # Justifications for each filter:
@@ skipping 857 matching lines @@
     needed = 'LGTM from an OWNER'
     output = output_api.PresubmitError
   else:
     needed = 'OWNER reviewers'
     output = 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
-  # TODO(tandrii): this will always return None, set() in case of Gerrit.
-  owner_email, reviewers = _RietveldOwnerAndReviewers(
+  owner_email, reviewers = _CodereviewOwnersAndReviewers(
       input_api,
       owners_db.email_regexp,
       approval_needed=input_api.is_committing)
 
   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)
 
   if missing_files:
     output_list = [
         output('Missing %s for these files:\n    %s' %
                (needed, '\n    '.join(sorted(missing_files))))]
     if not input_api.is_committing:
       suggested_owners = owners_db.reviewers_for(missing_files, owner_email)
       output_list.append(output('Suggested OWNERS: ' +
           '(Use "git-cl owners" to interactively select owners.)\n    %s' %
           ('\n    '.join(suggested_owners or []))))
     return output_list
 
   if input_api.is_committing and not reviewers:
     return [output('Missing LGTM from someone other than %s' % owner_email)]
   return []
 
+def _CodereviewOwnersAndReviewers(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.
+  """
+  if input_api.change.issue:
+    if input_api.gerrit:
+      res = _GerritOwnerAndReviewers(input_api, email_regexp, approval_needed)
+    else:
+      # Rietveld is default.
+      res = _RietveldOwnerAndReviewers(input_api, email_regexp, approval_needed)
+    if res:
+      return res
+
+  reviewers = set()
+  if not approval_needed:
+    reviewers = _ReviewersFromChange(input_api.change)
+  return None, reviewers
+
 
 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)
 
 
 def _ReviewersFromChange(change):
   """Return the reviewers specified in the |change|, if any."""
   reviewers = set()
   if change.R:
     reviewers.update(set([r.strip() for r in change.R.split(',')]))
   if change.TBR:
     reviewers.update(set([r.strip() for r in change.TBR.split(',')]))
 
   # Drop reviewers that aren't specified in email address format.
   return set(reviewer for reviewer in reviewers if '@' in reviewer)
 
 
+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.
+  Returns None if can't fetch issue properties from codereview.
   """
   issue_props = _GetRietveldIssueProps(input_api, True)
   if not issue_props:
-    reviewers = set()
-    if not approval_needed:
-      reviewers = _ReviewersFromChange(input_api.change)
-    return None, reviewers
+    return None
 
   if not approval_needed:
     return issue_props['owner_email'], set(issue_props['reviewers'])
 
   owner_email = issue_props['owner_email']
 
-  def match_reviewer(r):
-    return email_regexp.match(r) and r != owner_email
-
   messages = issue_props.get('messages', [])
   approvers = set(
       m['sender'] for m in messages
-      if m.get('approval') and match_reviewer(m['sender']))
+      if m.get('approval') and _match_reviewer_email(m['sender'], owner_email,
+                                                     email_regexp))
+  return owner_email, approvers
 
-  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.
+  Returns None if can't fetch issue properties from codereview.
+  """
+  issue = input_api.change.issue
+  if not issue:
+    return None
+
+  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))
+  return owner_email, reviewers
 
 
 def _CheckConstNSObject(input_api, output_api, source_file_filter):
   """Checks to make sure no objective-c files have |const NSSomeClass*|."""
   pattern = input_api.re.compile(
     r'(?<!reinterpret_cast<)'
     r'const\s+NS(?!(Point|Range|Rect|Size)\s*\*)\w*\s*\*')
 
   def objective_c_filter(f):
     return (source_file_filter(f) and
@@ skipping 162 matching lines @@
   for f in affected_files:
     cmd = ['gn', 'format', '--dry-run', f.AbsoluteLocalPath()]
     rc = gn.main(cmd)
     if rc == 2:
       warnings.append(output_api.PresubmitPromptWarning(
           '%s requires formatting. Please run `gn format --in-place %s`.' % (
               f.AbsoluteLocalPath(), f.LocalPath())))
   # It's just a warning, so ignore other types of failures assuming they'll be
   # caught elsewhere.
   return warnings