[Android WebView] Remove code for generating list of incompatible dirs

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
 be used to generate an Android NOTICE file for the third-party code.
 
 It makes use of src/tools/licenses.py and the README.chromium files on which
 it depends. It also makes use of a data file, third_party_files_whitelist.txt,
 which whitelists indicidual files which contain third-party code but which
 aren't in a third-party directory with a README.chromium file.
 """
 
-import glob
 import imp
 import json
 import multiprocessing
 import optparse
 import os
 import re
 import sys
 import textwrap
 
 
@@ skipping 20 matching lines @@
     self.os_path = os.path
     self.os_walk = os.walk
     self.re = re
     self.ReadFile = _ReadFile
     self.change = InputApiChange()
 
 class InputApiChange(object):
   def __init__(self):
     self.RepositoryRoot = lambda: REPOSITORY_ROOT
 
-
-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():
-    if directory in known_issues.KNOWN_ISSUES:
-      result.append(directory)
-      continue
-    try:
-      metadata = licenses.ParseDir(directory, REPOSITORY_ROOT,
-                                   require_license_file=False,
-                                   optional_keys=['License Android Compatible'])
-    except licenses.LicenseError as e:
-      print 'Got LicenseError while scanning ' + directory
-      raise
-    if metadata.get('License Android Compatible', 'no').upper() == 'YES':
-      continue
-    license = re.split(' [Ll]icenses?$', metadata['License'])[0]
-    if not third_party.LicenseIsCompatibleWithAndroid(InputApi(), license):
-      result.append(directory)
-  return result
-
-def GetUnknownIncompatibleDirectories():
-  """Gets a list of third-party directories which use licenses incompatible
-  with Android which are not present in the known_issues.py file.
-  This is used by the AOSP bot.
-  Returns:
-    A list of directories.
-  """
-  incompatible_directories = frozenset(GetIncompatibleDirectories())
-  known_incompatible = []
-  input_api = InputApi()
-  for path, exclude_list in known_issues.KNOWN_INCOMPATIBLE.iteritems():
-    path = copyright_scanner.ForwardSlashesToOsPathSeps(input_api, path)
-    for exclude in exclude_list:
-      exclude = copyright_scanner.ForwardSlashesToOsPathSeps(input_api, exclude)
-      if glob.has_magic(exclude):
-        exclude_dirname = os.path.dirname(exclude)
-        if glob.has_magic(exclude_dirname):
-          print ('Exclude path %s contains an unexpected glob expression,' \
-                 ' skipping.' % exclude)
-        exclude = exclude_dirname
-      known_incompatible.append(os.path.normpath(os.path.join(path, exclude)))
-  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(
     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)]
@@ skipping 55 matching lines @@
   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.
-  """
-
-  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.
   # Instead, add them into known_issues.py.
   prune_paths = [
@@ skipping 130 matching lines @@
   if generate_licenses_file_list_only:
     return [entry['license_file'] for entry in entries]
   else:
     env = jinja2.Environment(
       loader=jinja2.FileSystemLoader(os.path.dirname(__file__)),
       extensions=['jinja2.ext.autoescape'])
     template = env.get_template('licenses_notice.tmpl')
     return template.render({ 'entries': entries }).encode('utf8')
 
 
-def _ProcessIncompatibleResult(incompatible_directories):
-  if incompatible_directories:
-    print ("Incompatibly licensed directories found:\n" +
-           "\n".join(sorted(incompatible_directories)))
-    return ScanResult.Errors
-  return ScanResult.Ok
-
 def main():
   class FormatterWithNewLines(optparse.IndentedHelpFormatter):
     def format_description(self, description):
       paras = description.split('\n')
       formatted_paras = [textwrap.fill(para, self.width) for para in paras]
       return '\n'.join(formatted_paras) + '\n'
 
   parser = optparse.OptionParser(formatter=FormatterWithNewLines(),
                                  usage='%prog [options]')
   parser.add_option('--json', help='Path to JSON output file')
   parser.description = (__doc__ +
                         '\nCommands:\n'
                         '  scan Check licenses.\n'
                         '  notice_deps Generate the list of dependencies for '
                         'Android NOTICE file.\n'
                         '  notice [file] Generate Android NOTICE file on '
                         'stdout or into |file|.\n'
-                        '  incompatible_directories Scan for incompatibly'
-                        ' licensed directories.\n'
-                        '  all_incompatible_directories Scan for incompatibly'
-                        ' licensed directories (even those in'
-                        ' known_issues.py).\n'
                         '  display_copyrights Display autorship on the files'
                         ' using names provided via stdin.\n')
   (options, args) = parser.parse_args()
   if len(args) < 1:
     parser.print_help()
     return ScanResult.Errors
 
   if args[0] == 'scan':
     scan_result, problem_paths = _Scan()
     if scan_result == ScanResult.Ok:
       print 'OK!'
     if options.json:
       with open(options.json, 'w') as f:
         json.dump(problem_paths, f)
     return scan_result
   elif args[0] == 'notice_deps':
     # 'set' is used to eliminate duplicate references to the same license file.
     print ' '.join(
       sorted(set(GenerateNoticeFile(generate_licenses_file_list_only=True))))
     return ScanResult.Ok
   elif args[0] == 'notice':
     notice_file_contents = GenerateNoticeFile()
     if len(args) == 1:
       print notice_file_contents
     else:
       with open(args[1], 'w') as output_file:
         output_file.write(notice_file_contents)
     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(InputApi(), '.', files)):
       print f, '\t', ' / '.join(sorted(c))
     return ScanResult.Ok
   parser.print_help()
   return ScanResult.Errors
 
 if __name__ == '__main__':
   sys.exit(main())