generate_gradle.py: Build all generated files (not just .srcjars)

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 180 matching lines @@
     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)
     os.symlink(relpath, symlinked_path)
 
 
-def _CreateJavaSourceDir(output_dir, entry_output_dir, java_sources_file):
+def _CreateJavaSourceDir(output_dir, entry_output_dir, java_files):
   """Computes and constructs when necessary the list of java source directories.
 
   1. Computes the root java source directories from the list of files.
   2. Determines whether there are any .java files in them that are not included
-     in |java_sources_file|.
+     in |java_files|.
   3. If not, returns the list of java source directories. If so, constructs a
-     tree of symlinks within |entry_output_dir| of all files in
-     |java_sources_file|.
+     tree of symlinks within |entry_output_dir| of all files in |java_files|.
   """
   java_dirs = []
-  if java_sources_file:
-    java_files = _RebasePath(build_utils.ReadSourcesList(java_sources_file))
+  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)]
     if unwanted_java_files:
       logging.debug('Target requires .java symlinks: %s', entry_output_dir)
@@ skipping 164 matching lines @@
     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'):
       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'])
 
     java_sources_file = build_config['gradle'].get('java_sources_file')
+    java_files = []
     if java_sources_file:
       java_sources_file = _RebasePath(java_sources_file)
+      java_files = build_utils.ReadSourcesList(java_sources_file)
 
-    java_dirs = _CreateJavaSourceDir(output_dir, entry_output_dir,
-                                     java_sources_file)
+    java_dirs = _CreateJavaSourceDir(output_dir, entry_output_dir, java_files)
     if srcjars:
       java_dirs.append(os.path.join(entry_output_dir, _SRCJARS_SUBDIR))
 
     data = _GenerateGradleFile(build_config, build_vars, java_dirs, relativize,
                                args.use_gradle_process_resources,
                                jinja_processor)
     if data:
       project_entries.append(entry)
+      # Build all paths references by .gradle that exist within output_dir.
+      generated_inputs.extend(srcjars)
+      generated_inputs.extend(p for p in java_files if not p.startswith('..'))
+      generated_inputs.extend(build_config['gradle']['dependent_prebuilt_jars'])
+
       srcjar_tuples.extend(
           (s, os.path.join(entry_output_dir, _SRCJARS_SUBDIR)) for s in srcjars)
       _WriteFile(os.path.join(entry_output_dir, 'build.gradle'), data)
 
   _WriteFile(os.path.join(gradle_output_dir, 'build.gradle'),
              _GenerateRootGradle(jinja_processor))
 
   _WriteFile(os.path.join(gradle_output_dir, 'settings.gradle'),
              _GenerateSettingsGradle(project_entries))
 
   sdk_path = _RebasePath(build_vars['android_sdk_root'])
   _WriteFile(os.path.join(gradle_output_dir, 'local.properties'),
              _GenerateLocalProperties(sdk_path))
 
+  if generated_inputs:
+    logging.warning('Building generated source files...')
+    targets = _RebasePath(generated_inputs, output_dir)
+    _RunNinja(output_dir, targets)
+
   if srcjar_tuples:
-    logging.warning('Building all .srcjar files...')
-    targets = _RebasePath([s[0] for s in srcjar_tuples], output_dir)
-    _RunNinja(output_dir, targets)
     _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()