Revert of 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
-  owner_email, reviewers = _CodereviewOwnersAndReviewers(
+  # TODO(tandrii): this will always return None, set() in case of Gerrit.
+  owner_email, reviewers = _RietveldOwnerAndReviewers(
       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:
-    return None
+    reviewers = set()
+    if not approval_needed:
+      reviewers = _ReviewersFromChange(input_api.change)
+    return None, reviewers
 
   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_email(m['sender'], owner_email,
-                                                     email_regexp))
+      if m.get('approval') and match_reviewer(m['sender']))
+
   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
             input_api.os_path.splitext(f.LocalPath())[1] in ('.h', '.m', '.mm'))
 
@@ skipping 160 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