generate_gradle.py: Add support for junit and java_binary targets

build/android/gradle/generate_gradle.py

 #!/usr/bin/env python
 # Copyright 2016 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.
 
 """Generates an Android Studio project from a GN target."""
 
 import argparse
 import codecs
 import logging
@@ skipping 18 matching lines @@
 
 _DEFAULT_ANDROID_MANIFEST_PATH = os.path.join(
     host_paths.DIR_SOURCE_ROOT, 'build', 'android', 'AndroidManifest.xml')
 _JINJA_TEMPLATE_PATH = os.path.join(
     os.path.dirname(__file__), 'build.gradle.jinja')
 
 _JAVA_SUBDIR = 'symlinked-java'
 _SRCJARS_SUBDIR = 'extracted-srcjars'
 
 _DEFAULT_TARGETS = [
-    '//android_webview:system_webview_apk',
+    # TODO(agrieve): Requires alternate android.jar to compile.
+    # '//android_webview:system_webview_apk',
     '//android_webview/test:android_webview_apk',
     '//android_webview/test:android_webview_test_apk',
+    '//base:base_junit_tests',
+    '//chrome/android:chrome_junit_tests',
     '//chrome/android:chrome_public_apk',
     '//chrome/android:chrome_public_test_apk',
     '//chrome/android:chrome_sync_shell_apk',
     '//chrome/android:chrome_sync_shell_test_apk',
+    '//content/public/android:content_junit_tests',
+    '//content/shell/android:content_shell_apk',
 ]
 
 def _RebasePath(path_or_list, new_cwd=None, old_cwd=None):
   """Makes the given path(s) relative to new_cwd, or absolute if not specified.
 
   If new_cwd is not specified, absolute paths are returned.
   If old_cwd is not specified, constants.GetOutDirectory() is assumed.
   """
   if not isinstance(path_or_list, basestring):
     return [_RebasePath(p, new_cwd, old_cwd) for p in path_or_list]
@@ skipping 102 matching lines @@
     """Returns the target type from its .build_config."""
     return self.BuildConfig()['deps_info']['type']
 
 
 def _ComputeJavaSourceDirs(java_files):
   """Returns the list of source directories for the given files."""
   found_roots = set()
   for path in java_files:
     path_root = path
     # Recognize these tokens as top-level.
-    while os.path.basename(path_root) not in ('javax', 'org', 'com', 'src'):
-      assert path_root, 'Failed to find source dir for ' + path
+    while True:
       path_root = os.path.dirname(path_root)
-    # Assume that if we've hit "src", the we're at the root.
-    if os.path.basename(path_root) != 'src':
-      path_root = os.path.dirname(path_root)
+      basename = os.path.basename(path_root)
+      assert basename, 'Failed to find source dir for ' + path
+      if basename in ('java', 'src'):
+        break
+      if basename in ('javax', 'org', 'com'):
+        path_root = os.path.dirname(path_root)
+        break
     found_roots.add(path_root)
   return list(found_roots)
 
 
 def _CreateSymlinkTree(entry_output_dir, symlink_dir, desired_files,
                        parent_dirs):
   """Creates a directory tree of symlinks to the given files.
 
   The idea here is to replicate a directory tree while leaving out files within
   it not listed by |desired_files|.
   """
   assert _IsSubpathOf(symlink_dir, entry_output_dir)
-  if os.path.exists(symlink_dir):
-    shutil.rmtree(symlink_dir)
 
   for target_path in desired_files:
     prefix = next(d for d in parent_dirs if target_path.startswith(d))
     subpath = os.path.relpath(target_path, prefix)
     symlinked_path = os.path.join(symlink_dir, subpath)
     symlinked_dir = os.path.dirname(symlinked_path)
     if not os.path.exists(symlinked_dir):
       os.makedirs(symlinked_dir)
     relpath = os.path.relpath(target_path, symlinked_dir)
     logging.debug('Creating symlink %s -> %s', symlinked_path, relpath)
@@ skipping 13 matching lines @@
   if java_files:
     java_files = _RebasePath(java_files)
     java_dirs = _ComputeJavaSourceDirs(java_files)
 
     found_java_files = build_utils.FindInDirectories(java_dirs, '*.java')
     unwanted_java_files = set(found_java_files) - set(java_files)
     missing_java_files = set(java_files) - set(found_java_files)
     # Warn only about non-generated files that are missing.
     missing_java_files = [p for p in missing_java_files
                           if not p.startswith(output_dir)]
+
+    symlink_dir = os.path.join(entry_output_dir, _JAVA_SUBDIR)
+    shutil.rmtree(symlink_dir, True)
+
     if unwanted_java_files:
       logging.debug('Target requires .java symlinks: %s', entry_output_dir)
-      symlink_dir = os.path.join(entry_output_dir, _JAVA_SUBDIR)
       _CreateSymlinkTree(entry_output_dir, symlink_dir, java_files, java_dirs)
       java_dirs = [symlink_dir]
 
     if missing_java_files:
       logging.warning('Some java files were not found: %s', missing_java_files)
 
   return java_dirs
 
 
 def _GenerateLocalProperties(sdk_dir):
   """Returns the data for project.properties as a string."""
   return '\n'.join([
       '# Generated by //build/android/gradle/generate_gradle.py',
       'sdk.dir=%s' % sdk_dir,
       ''])
 
 
 def _GenerateGradleFile(build_config, build_vars, java_dirs, relativize,
                         use_gradle_process_resources, jinja_processor):
   """Returns the data for a project's build.gradle."""
   deps_info = build_config['deps_info']
   gradle = build_config['gradle']
 
+  variables = {
+      'sourceSetName': 'main',
+      'depCompileName': 'compile',
+  }
   if deps_info['type'] == 'android_apk':
     target_type = 'android_apk'
-  elif deps_info['type'] == 'java_library' and not deps_info['is_prebuilt']:
+  elif deps_info['type'] == 'java_library':
+    if deps_info['is_prebuilt'] or deps_info['gradle_treat_as_prebuilt']:
+      return None
+
     if deps_info['requires_android']:
       target_type = 'android_library'
     else:
       target_type = 'java_library'
+  elif deps_info['type'] == 'java_binary':
+    if gradle['main_class'] == 'org.chromium.testing.local.JunitTestMain':
+      target_type = 'android_junit'
+      variables['sourceSetName'] = 'test'
+      variables['depCompileName'] = 'testCompile'
+    else:
+      target_type = 'java_binary'
+      variables['main_class'] = gradle['main_class']
   else:
     return None
 
-  variables = {}
+  variables['target_name'] = os.path.splitext(deps_info['name'])[0]
   variables['template_type'] = target_type
   variables['use_gradle_process_resources'] = use_gradle_process_resources
   variables['build_tools_version'] = (
       build_vars['android_sdk_build_tools_version'])
   variables['compile_sdk_version'] = build_vars['android_sdk_version']
   android_manifest = gradle.get('android_manifest',
                                 _DEFAULT_ANDROID_MANIFEST_PATH)
   variables['android_manifest'] = relativize(android_manifest)
   variables['java_dirs'] = relativize(java_dirs)
+  # TODO(agrieve): Add an option to use interface jars and see if that speeds
+  # things up at all.
   variables['prebuilts'] = relativize(gradle['dependent_prebuilt_jars'])
   deps = [_ProjectEntry.FromBuildConfigPath(p)
           for p in gradle['dependent_android_projects']]
 
   variables['android_project_deps'] = [d.ProjectName() for d in deps]
   deps = [_ProjectEntry.FromBuildConfigPath(p)
           for p in gradle['dependent_java_projects']]
   variables['java_project_deps'] = [d.ProjectName() for d in deps]
 
   return jinja_processor.Render(_JINJA_TEMPLATE_PATH, variables)
@@ skipping 20 matching lines @@
     lines.append('project(":%s").projectDir = new File(settingsDir, "%s")' %
                  (entry.ProjectName(), entry.GradleSubdir()))
   return '\n'.join(lines)
 
 
 def _ExtractSrcjars(entry_output_dir, srcjar_tuples):
   """Extracts all srcjars to the directory given by the tuples."""
   extracted_paths = set(s[1] for s in srcjar_tuples)
   for extracted_path in extracted_paths:
     assert _IsSubpathOf(extracted_path, entry_output_dir)
-    if os.path.exists(extracted_path):
-      shutil.rmtree(extracted_path)
+    shutil.rmtree(extracted_path, True)
 
   for srcjar_path, extracted_path in srcjar_tuples:
     logging.info('Extracting %s to %s', srcjar_path, extracted_path)
     with zipfile.ZipFile(srcjar_path) as z:
       z.extractall(extracted_path)
 
 
 def _FindAllProjectEntries(main_entries):
   """Returns the list of all _ProjectEntry instances given the root project."""
   found = set()
@@ skipping 49 matching lines @@
   if args.all:
     # Run GN gen if necessary (faster than running "gn gen" in the no-op case).
     _RunNinja(output_dir, ['build.ninja'])
     # Query ninja for all __build_config targets.
     targets = _QueryForAllGnTargets(output_dir)
   else:
     targets = args.targets or _DEFAULT_TARGETS
     # TODO(agrieve): See if it makes sense to utilize Gradle's test constructs
     # for our instrumentation tests.
     targets = [re.sub(r'_test_apk$', '_test_apk__apk', t) for t in targets]
+    targets = [re.sub(r'_junit_tests$', '_junit_tests__java_binary', t)
+               for t in targets]
 
   main_entries = [_ProjectEntry(t) for t in targets]
 
   logging.warning('Building .build_config files...')
   _RunNinja(output_dir, [e.NinjaBuildConfigTarget() for e in main_entries])
 
   # There are many unused libraries, so restrict to those that are actually used
   # when using --all.
   if args.all:
     main_entries = [e for e in main_entries if e.GetType() == 'android_apk']
 
   all_entries = _FindAllProjectEntries(main_entries)
   logging.info('Found %d dependent build_config targets.', len(all_entries))
 
   logging.warning('Writing .gradle files...')
   jinja_processor = jinja_template.JinjaProcessor(host_paths.DIR_SOURCE_ROOT)
   build_vars = _ReadBuildVars(output_dir)
   project_entries = []
   srcjar_tuples = []
   generated_inputs = []
   for entry in all_entries:
-    if entry.GetType() not in ('android_apk', 'java_library'):
+    if entry.GetType() not in ('android_apk', 'java_library', 'java_binary'):
       continue
 
     entry_output_dir = os.path.join(gradle_output_dir, entry.GradleSubdir())
     relativize = lambda x, d=entry_output_dir: _RebasePath(x, d)
     build_config = entry.BuildConfig()
 
     srcjars = _RebasePath(build_config['gradle'].get('bundled_srcjars', []))
     if not args.use_gradle_process_resources:
       srcjars += _RebasePath(build_config['javac']['srcjars'])
 
@@ skipping 40 matching lines @@
     _ExtractSrcjars(gradle_output_dir, srcjar_tuples)
 
   logging.warning('Project created! (%d subprojects)', len(project_entries))
   logging.warning('Generated projects work best with Android Studio 2.2')
   logging.warning('For more tips: https://chromium.googlesource.com/chromium'
                   '/src.git/+/master/docs/android_studio.md')
 
 
 if __name__ == '__main__':
   main()