[Android WebView] Prepare the copyrights scanner to run from presubmit scripts

android_webview/tools/webview_licenses.py

 #!/usr/bin/python
 # Copyright 2014 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.
 
 """Checks third-party licenses for the purposes of the Android WebView build.
 
 The Android tree includes a snapshot of Chromium in order to power the system
 WebView.  This tool checks that all code uses open-source licenses compatible
 with Android, and that we meet the requirements of those licenses. It can also
@@ skipping 26 matching lines @@
                   os.path.join(REPOSITORY_ROOT, 'third_party', 'PRESUBMIT.py'))
 
 sys.path.append(os.path.join(REPOSITORY_ROOT, 'tools'))
 import licenses
 
 import copyright_scanner
 import known_issues
 
 class InputApi(object):
   def __init__(self):
+    self.os_path = os.path
+    self.os_walk = os.walk
     self.re = re
+    self.ReadFile = _ReadFile
 
 def GetIncompatibleDirectories():
   """Gets a list of third-party directories which use licenses incompatible
   with Android. This is used by the snapshot tool.
   Returns:
     A list of directories.
   """
 
   result = []
   for directory in _FindThirdPartyDirs():
@@ skipping 34 matching lines @@
   known_incompatible = frozenset(known_incompatible)
   return incompatible_directories.difference(known_incompatible)
 
 
 class ScanResult(object):
   Ok, Warnings, Errors = range(3)
 
 # Needs to be a top-level function for multiprocessing
 def _FindCopyrightViolations(files_to_scan_as_string):
   return copyright_scanner.FindCopyrightViolations(
-    REPOSITORY_ROOT, files_to_scan_as_string)
+    InputApi(), REPOSITORY_ROOT, files_to_scan_as_string)
 
 def _ShardList(l, shard_len):
   return [l[i:i + shard_len] for i in range(0, len(l), shard_len)]
 
 def _CheckLicenseHeaders(excluded_dirs_list, whitelisted_files):
   """Checks that all files which are not in a listed third-party directory,
   and which do not use the standard Chromium license, are whitelisted.
   Args:
     excluded_dirs_list: The list of directories to exclude from scanning.
     whitelisted_files: The whitelist of files.
@@ skipping 37 matching lines @@
   # Swarming tools, doesn't exist in the snapshot
   excluded_dirs_list.append('tools/swarming_client')
   # Arm sysroot tools, doesn't exist in the snapshot
   excluded_dirs_list.append('arm-sysroot')
   # Data is not part of open source chromium, but are included on some bots.
   excluded_dirs_list.append('data')
   # This is not part of open source chromium, but are included on some bots.
   excluded_dirs_list.append('skia/tools/clusterfuzz-data')
 
   files_to_scan = copyright_scanner.FindFiles(
-    REPOSITORY_ROOT, ['.'], excluded_dirs_list)
+    InputApi(), REPOSITORY_ROOT, ['.'], excluded_dirs_list)
   sharded_files_to_scan = _ShardList(files_to_scan, 2000)
   pool = multiprocessing.Pool()
   offending_files_chunks = pool.map_async(
       _FindCopyrightViolations, sharded_files_to_scan).get(999999)
   pool.close()
   pool.join()
   # Flatten out the result
   offending_files = \
     [item for sublist in offending_files_chunks for item in sublist]
 
@@ skipping 15 matching lines @@
         '\n'.join(sorted(missing))
 
   if unknown:
     return ScanResult.Errors
   elif stale or missing:
     return ScanResult.Warnings
   else:
     return ScanResult.Ok
 
 
-def _ReadFile(path):
+def _ReadFile(full_path, mode='rU'):
+  """Reads a file from disk. This emulates presubmit InputApi.ReadFile func.
+  Args:
+    full_path: The path of the file to read.
+  Returns:
+    The contents of the file as a string.
+  """
+
+  with open(full_path, mode) as f:
+    return f.read()
+
+
+def _ReadLocalFile(path, mode='rb'):
   """Reads a file from disk.
   Args:
     path: The path of the file to read, relative to the root of the repository.
   Returns:
     The contents of the file as a string.
   """
 
-  with open(os.path.join(REPOSITORY_ROOT, path), 'rb') as f:
-    return f.read()
+  return _ReadFile(os.path.join(REPOSITORY_ROOT, path), mode)
 
 
 def _FindThirdPartyDirs():
   """Gets the list of third-party directories.
   Returns:
     The list of third-party directories.
   """
 
   # Please don't add here paths that have problems with license files,
   # as they will end up included in Android WebView snapshot.
@@ skipping 39 matching lines @@
   all_licenses_valid = True
   for path in sorted(third_party_dirs):
     try:
       licenses.ParseDir(path, REPOSITORY_ROOT)
     except licenses.LicenseError, e:
       if not (path in known_issues.KNOWN_ISSUES):
         print 'Got LicenseError "%s" while scanning %s' % (e, path)
         all_licenses_valid = False
 
   # Second, check for non-standard license text.
-  files_data = _ReadFile(os.path.join('android_webview', 'tools',
-                                      'third_party_files_whitelist.txt'))
+  files_data = _ReadLocalFile(os.path.join('android_webview', 'tools',
+                                           'third_party_files_whitelist.txt'))
   whitelisted_files = []
   for line in files_data.splitlines():
     match = re.match(r'([^#\s]+)', line)
     if match:
       whitelisted_files.append(match.group(1))
   licenses_check = _CheckLicenseHeaders(third_party_dirs, whitelisted_files)
 
   return licenses_check if all_licenses_valid else ScanResult.Errors
 
 
 def GenerateNoticeFile():
   """Generates the contents of an Android NOTICE file for the third-party code.
   This is used by the snapshot tool.
   Returns:
     The contents of the NOTICE file.
   """
 
   third_party_dirs = _FindThirdPartyDirs()
 
   # Don't forget Chromium's LICENSE file
-  content = [_ReadFile('LICENSE')]
+  content = [_ReadLocalFile('LICENSE')]
 
   # We provide attribution for all third-party directories.
   # TODO(steveblock): Limit this to only code used by the WebView binary.
   for directory in sorted(third_party_dirs):
     metadata = licenses.ParseDir(directory, REPOSITORY_ROOT,
                                  require_license_file=False)
     license_file = metadata['License File']
     if license_file and license_file != licenses.NOT_SHIPPED:
-      content.append(_ReadFile(license_file))
+      content.append(_ReadLocalFile(license_file))
 
   return '\n'.join(content)
 
 
 def _ProcessIncompatibleResult(incompatible_directories):
   if incompatible_directories:
     print ("Incompatibly licensed directories found:\n" +
            "\n".join(sorted(incompatible_directories)))
     return ScanResult.Errors
   return ScanResult.Ok
@@ skipping 30 matching lines @@
     return scan_result
   elif args[0] == 'notice':
     print GenerateNoticeFile()
     return ScanResult.Ok
   elif args[0] == 'incompatible_directories':
     return _ProcessIncompatibleResult(GetUnknownIncompatibleDirectories())
   elif args[0] == 'all_incompatible_directories':
     return _ProcessIncompatibleResult(GetIncompatibleDirectories())
   elif args[0] == 'display_copyrights':
     files = sys.stdin.read().splitlines()
-    for f, c in zip(files, copyright_scanner.FindCopyrights('.', files)):
+    for f, c in \
+        zip(files, copyright_scanner.FindCopyrights(InputApi(), '.', files)):
       print f, '\t', ' / '.join(sorted(c))
     return ScanResult.Ok
   parser.print_help()
   return ScanResult.Errors
 
 if __name__ == '__main__':
   sys.exit(main())