Merge features of cronet_licenses.py into licenses.py.

tools/licenses.py

 #!/usr/bin/env python
 # 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.
 
 """Utility for checking and processing licensing information in third_party
 directories.
 
 Usage: licenses.py <command>
 
 Commands:
   scan     scan third_party directories, verifying that we have licensing info
   credits  generate about:credits on stdout
 
 (You can also import this as a module.)
 """
 
 import argparse
 import cgi
 import os
+import shutil
 import subprocess
 import sys
+import tempfile
 
 # TODO(agrieve): Move build_utils.WriteDepFile into a non-android directory.
 _REPOSITORY_ROOT = os.path.dirname(os.path.dirname(__file__))
 sys.path.append(os.path.join(_REPOSITORY_ROOT, 'build/android/gyp/util'))
 import build_utils
 
 
 # Paths from the root of the tree to directories to skip.
 PRUNE_PATHS = set([
     # Placeholder directory only, not third-party code.
@@ skipping 442 matching lines @@
     else:
         raise RuntimeError("Unsupported platform '%s'." % sys.platform)
 
     return os.path.join(_REPOSITORY_ROOT, 'buildtools', subdir, exe)
 
 
 def FindThirdPartyDeps(gn_out_dir, gn_target):
     if not gn_out_dir:
         raise RuntimeError("--gn-out-dir is required if --gn-target is used.")
 
-    gn_deps = subprocess.check_output([_GnBinary(), "desc", gn_out_dir,
-                                       gn_target,
-                                       "deps", "--as=buildfile", "--all"])
+    # Generate gn project in temp directory and use it to find dependencies.
+    # Current gn directory cannot be used when we run this script in a gn action
+    # rule, because gn doesn't allow recursive invocations due to potential side
+    # effects.
+    tmp_dir = None
+    try:
+        tmp_dir = tempfile.mkdtemp(dir = gn_out_dir)
+        shutil.copy(os.path.join(gn_out_dir, "args.gn"), tmp_dir)
+        subprocess.check_output([_GnBinary(), "gen", tmp_dir])
+        gn_deps = subprocess.check_output([
+            _GnBinary(), "desc", tmp_dir, gn_target,
+            "deps", "--as=buildfile", "--all"])
+    finally:
+        if tmp_dir and os.path.exists(tmp_dir):
+            shutil.rmtree(tmp_dir)
+
     third_party_deps = set()
     for build_dep in gn_deps.split():
         if ("third_party" in build_dep and
                 os.path.basename(build_dep) == "BUILD.gn"):
             third_party_deps.add(os.path.dirname(build_dep))
     return third_party_deps
 
 
 def ScanThirdPartyDirs(root=None):
     """Scan a list of directories and report on any problems we find."""
@@ skipping 109 matching lines @@
       # practice however.
       license_file_list = (entry['license_file'] for entry in entries)
       license_file_list = (os.path.relpath(p) for p in license_file_list)
       license_file_list = sorted(set(license_file_list))
       build_utils.WriteDepfile(depfile, output_file,
                                license_file_list + ['build.ninja'])
 
     return True
 
 
+def _ReadFile(path):
+    """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()
+
+
+def GenerateLicenseFile(output_file, gn_out_dir, gn_target):
+    """Generate a plain-text LICENSE file which can be used when you ship a part
+    of Chromium code (specified by gn_target) as a stand-alone library
+    (e.g., //ios/web_view).
+
+    The LICENSE file contains licenses of both Chromium and third-party
+    libraries which gn_target depends on. """
+
+    third_party_dirs = FindThirdPartyDeps(gn_out_dir, gn_target)
+
+    # Start with Chromium's LICENSE file.
+    content = [_ReadFile('LICENSE')]
+
+    # Add necessary third_party.
+    for directory in sorted(third_party_dirs):
+        metadata = ParseDir(
+            directory, _REPOSITORY_ROOT, require_license_file=True)
+        content.append('-' * 20)
+        content.append(directory.split('/')[-1])
+        content.append('-' * 20)
+        license_file = metadata['License File']
+        if license_file and license_file != NOT_SHIPPED:
+            content.append(_ReadFile(license_file))
+
+    content_text = '\n'.join(content)
+
+    if output_file:
+        with open(output_file, 'w') as output:
+            output.write(content_text)
+    else:
+        print content_text
+
+    return True
+
+
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('--file-template',
                         help='Template HTML to use for the license page.')
     parser.add_argument('--entry-template',
                         help='Template HTML to use for each license.')
     parser.add_argument('--target-os',
                         help='OS that this build is targeting.')
     parser.add_argument('--gn-out-dir',
                         help='GN output directory for scanning dependencies.')
     parser.add_argument('--gn-target',
                         help='GN target to scan for dependencies.')
-    parser.add_argument('command', choices=['help', 'scan', 'credits'])
+    parser.add_argument('command',
+                        choices=['help', 'scan', 'credits', 'license_file'])
     parser.add_argument('output_file', nargs='?')
     build_utils.AddDepfileOption(parser)
     args = parser.parse_args()
 
     if args.command == 'scan':
         if not ScanThirdPartyDirs():
             return 1
     elif args.command == 'credits':
         if not GenerateCredits(args.file_template, args.entry_template,
                                args.output_file, args.target_os,
                                args.gn_out_dir, args.gn_target, args.depfile):
             return 1
+    elif args.command == 'license_file':
+        if not GenerateLicenseFile(
+                args.output_file, args.gn_out_dir, args.gn_target):
+            return 1
     else:
         print __doc__
         return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())