Add checking for license formats to third_party/PRESUBMIT

third_party/PRESUBMIT.py

 # Copyright (c) 2011 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.
 
+ANDROID_WHITELISTED_LICENSES = [
+  'Apache( Version)? 2(\.0)?',
+  '(New )?([23]-Clause )?BSD( [23]-Clause)?( with advertising clause)?',
+  'L?GPL ?v?2(\.[01])?( or later)?',
+  'MIT(/X11)?(-like)?',
+  'MPL 1\.1 ?/ ?GPL 2(\.0)? ?/ ?LGPL 2\.1',
+  'MPL 2(\.0)?',
+  'Microsoft Limited Public License',
+  'Microsoft Permissive License',
+  'Public Domain',
+  'Python',
+  'SGI Free Software License B',
+  'University of Illinois\/NCSA Open Source',
+  'X11',
+]
+
+def LicenseIsCompatibleWithAndroid(input_api, license):
+  regex = '^(%s)$' % '|'.join(ANDROID_WHITELISTED_LICENSES)
+  tokens = \
+    [x.strip() for x in input_api.re.split(' and |,', license) if len(x) > 0]
+  has_compatible_license = False
+  for token in tokens:
+    if input_api.re.match(regex, token, input_api.re.IGNORECASE):
+      has_compatible_license = True
+      break
+  return has_compatible_license
+
 def _CheckThirdPartyReadmesUpdated(input_api, output_api):
   """
   Checks to make sure that README.chromium files are properly updated
   when dependancies in third_party are modified.
   """
   readmes = []
   files = []
   errors = []
   for f in input_api.AffectedFiles():
     local_path = f.LocalPath()
@@ skipping 17 matching lines @@
   shortname_pattern = input_api.re.compile(
     r'^Short Name: [a-zA-Z0-9_\-\.]+\r?$',
     input_api.re.IGNORECASE | input_api.re.MULTILINE)
   version_pattern = input_api.re.compile(
     r'^Version: [a-zA-Z0-9_\-\.:]+\r?$',
     input_api.re.IGNORECASE | input_api.re.MULTILINE)
   release_pattern = input_api.re.compile(
     r'^Security Critical: (yes)|(no)\r?$',
     input_api.re.IGNORECASE | input_api.re.MULTILINE)
   license_pattern = input_api.re.compile(
-    r'^License: .+\r?$',
+    r'^License: (.+)\r?$',
+    input_api.re.IGNORECASE | input_api.re.MULTILINE)
+  license_android_compatible_pattern = input_api.re.compile(
+    r'^License Android Compatible: (yes)|(no)\r?$',
     input_api.re.IGNORECASE | input_api.re.MULTILINE)
 
   for f in readmes:
     if 'D' in f.Action():
       _IgnoreIfDeleting(input_api, output_api, f, errors)
       continue
 
     contents = input_api.ReadFile(f)
     if (not shortname_pattern.search(contents)
         and not name_pattern.search(contents)):
       errors.append(output_api.PresubmitError(
         'Third party README files should contain either a \'Short Name\' or\n'
         'a \'Name\' which is the name under which the package is\n'
         'distributed. Check README.chromium.template for details.',
         [f]))
     if not version_pattern.search(contents):
       errors.append(output_api.PresubmitError(
         'Third party README files should contain a \'Version\' field.\n'
         'If the package is not versioned or the version is not known\n'
         'list the version as \'unknown\'.\n'
         'Check README.chromium.template for details.',
         [f]))
     if not release_pattern.search(contents):
       errors.append(output_api.PresubmitError(
         'Third party README files should contain a \'Security Critical\'\n'
         'field. This field specifies whether the package is built with\n'
         'Chromium. Check README.chromium.template for details.',
         [f]))
-    if not license_pattern.search(contents):
+    license_match = license_pattern.search(contents)
+    if not license_match:
       errors.append(output_api.PresubmitError(
         'Third party README files should contain a \'License\' field.\n'
         'This field specifies the license used by the package. Check\n'
         'README.chromium.template for details.',
         [f]))
+    elif not LicenseIsCompatibleWithAndroid(input_api, license_match.group(1)) \
+         and not license_android_compatible_pattern.search(contents):
+      errors.append(output_api.PresubmitError(
+        'The license specified does not seem to be allowed in\n' +

[mkosiba (inactive), 2014/01/31 17:47:38]

I guess this should be something like

'Cannot determine whether specified license is compatible with the Android
licensing requirements. Please check...'

right?
The way I understand it, this check says 'the license isn't on the whitelist and
the README.chromium doesn't explicitly specify whether it's compatible, so we
don't know'

[mnaganov (inactive), 2014/02/03 10:00:26]

Yes, you are right. Fixed the text.

Also, I have realized that making this issue an error actually prevents anyone
from using a non-compatible license, unless she also states 'License Android
Compatible: no', which is kind of silly. So I reclassified this into a warning.

[mkosiba (inactive), 2014/02/03 10:30:55]

Makes sense. I guess that once I add the other bit of the license check to the
AOSP bot/trybot it should be harder to add a third_party library with an
incompatible.

+        'the Android tree. Please check that the license name is spelled\n' +
+        'according to third_party/PRESUBMIT.py. Please see\n' +
+        'README.chromium.template for details.',
+        [f]))
   return errors
 
 
 def _IgnoreIfDeleting(input_api, output_api, affected_file, errors):
   third_party_dir = input_api.os_path.dirname(affected_file.LocalPath())
   for f in input_api.AffectedFiles():
     if f.LocalPath().startswith(third_party_dir):
       if 'D' not in f.Action():
         errors.append(output_api.PresubmitError(
           'Third party README should only be removed when the whole\n'
           'directory is being removed.\n', [f, affected_file]))
 
 
 def CheckChangeOnUpload(input_api, output_api):
   results = []
   results.extend(_CheckThirdPartyReadmesUpdated(input_api, output_api))
   return results