Reland "Android: Add owned resources to android studio"

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 glob
@@ skipping 16 matching lines @@
 import jinja_template
 from util import build_utils
 
 
 _DEFAULT_ANDROID_MANIFEST_PATH = os.path.join(
     host_paths.DIR_SOURCE_ROOT, 'build', 'android', 'AndroidManifest.xml')
 _FILE_DIR = os.path.dirname(__file__)
 _SRCJARS_SUBDIR = 'extracted-srcjars'
 _JNI_LIBS_SUBDIR = 'symlinked-libs'
 _ARMEABI_SUBDIR = 'armeabi'
+_RES_SUBDIR = 'extracted-res'
 
 _DEFAULT_TARGETS = [
     # 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 _TemplatePath(name):
   return os.path.join(_FILE_DIR, '{}.jinja'.format(name))
 
 
 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 path_or_list is None:
+    return []
   if not isinstance(path_or_list, basestring):
     return [_RebasePath(p, new_cwd, old_cwd) for p in path_or_list]
   if old_cwd is None:
     old_cwd = constants.GetOutDirectory()
   old_cwd = os.path.abspath(old_cwd)
   if new_cwd:
     new_cwd = os.path.abspath(new_cwd)
     return os.path.relpath(os.path.join(old_cwd, path_or_list), new_cwd)
   return os.path.abspath(os.path.join(old_cwd, path_or_list))
 
@@ skipping 95 matching lines @@
   def DepsInfo(self):
     return self.BuildConfig()['deps_info']
 
   def Gradle(self):
     return self.BuildConfig()['gradle']
 
   def GetType(self):
     """Returns the target type from its .build_config."""
     return self.DepsInfo()['type']
 
+  def ResZips(self):
+    return self.DepsInfo().get('owned_resources_zips')
+
   def JavaFiles(self):
     if self._java_files is None:
       java_sources_file = self.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)
       self._java_files = java_files
     return self._java_files
 
@@ skipping 15 matching lines @@
     return jni_libs
 
   def _GenJavaDirs(self, entry):
     java_dirs, excludes = _CreateJavaSourceDir(
         constants.GetOutDirectory(), entry.JavaFiles())
     if self.Srcjars(entry):
       java_dirs.append(
           os.path.join(self.EntryOutputDir(entry), _SRCJARS_SUBDIR))
     return java_dirs, excludes
 
+  def _GenResDirs(self, entry):
+    res_dirs = list(entry.DepsInfo().get('owned_resources_dirs', []))
+    if entry.ResZips():
+      res_dirs.append(os.path.join(self.EntryOutputDir(entry), _RES_SUBDIR))
+    return res_dirs
+
   def _Relativize(self, entry, paths):
     return _RebasePath(paths, self.EntryOutputDir(entry))
 
   def EntryOutputDir(self, entry):
     return os.path.join(self.project_dir, entry.GradleSubdir())
 
   def Srcjars(self, entry):
     srcjars = _RebasePath(entry.Gradle().get('bundled_srcjars', []))
     if not self.use_gradle_process_resources:
       srcjars += _RebasePath(entry.BuildConfig()['javac']['srcjars'])
     return srcjars
 
   def GeneratedInputs(self, entry):
     generated_inputs = []
     generated_inputs.extend(self.Srcjars(entry))
+    generated_inputs.extend(_RebasePath(entry.ResZips()))
     generated_inputs.extend(
         p for p in entry.JavaFiles() if not p.startswith('..'))
     generated_inputs.extend(entry.Gradle()['dependent_prebuilt_jars'])
     return generated_inputs
 
   def Generate(self, entry):
     variables = {}
     android_test_manifest = entry.Gradle().get(
         'android_manifest', _DEFAULT_ANDROID_MANIFEST_PATH)
     variables['android_manifest'] = self._Relativize(
         entry, android_test_manifest)
     java_dirs, excludes = self._GenJavaDirs(entry)
     variables['java_dirs'] = self._Relativize(entry, java_dirs)
     variables['java_excludes'] = excludes
     variables['jni_libs'] = self._Relativize(entry, self._GenJniLibs(entry))
+    variables['res_dirs'] = self._Relativize(entry, self._GenResDirs(entry))
     deps = [_ProjectEntry.FromBuildConfigPath(p)
             for p in entry.Gradle()['dependent_android_projects']]
     variables['android_project_deps'] = [d.ProjectName() for d in deps]
     # TODO(agrieve): Add an option to use interface jars and see if that speeds
     # things up at all.
     variables['prebuilts'] = self._Relativize(
         entry, entry.Gradle()['dependent_prebuilt_jars'])
     deps = [_ProjectEntry.FromBuildConfigPath(p)
             for p in entry.Gradle()['dependent_java_projects']]
     variables['java_project_deps'] = [d.ProjectName() for d in deps]
@@ skipping 175 matching lines @@
   lines.append('')
 
   for entry in project_entries:
     # Example target: android_webview:android_webview_java__build_config
     lines.append('include ":%s"' % entry.ProjectName())
     lines.append('project(":%s").projectDir = new File(settingsDir, "%s")' %
                  (entry.ProjectName(), entry.GradleSubdir()))
   return '\n'.join(lines)
 
 
-def _ExtractSrcjars(entry_output_dir, srcjar_tuples):
+def _ExtractFile(zip_path, extracted_path):
+  logging.info('Extracting %s to %s', zip_path, extracted_path)
+  with zipfile.ZipFile(zip_path) as z:
+    z.extractall(extracted_path)
+
+
+def _ExtractZips(entry_output_dir, zip_tuples):
   """Extracts all srcjars to the directory given by the tuples."""
-  extracted_paths = set(s[1] for s in srcjar_tuples)
+  extracted_paths = set(s[1] for s in zip_tuples)
   for extracted_path in extracted_paths:
     assert _IsSubpathOf(extracted_path, entry_output_dir)
     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)
+  for zip_path, extracted_path in zip_tuples:
+    _ExtractFile(zip_path, extracted_path)
 
 
 def _FindAllProjectEntries(main_entries):
   """Returns the list of all _ProjectEntry instances given the root project."""
   found = set()
   to_scan = list(main_entries)
   while to_scan:
     cur_entry = to_scan.pop()
     if cur_entry in found:
       continue
@@ skipping 94 matching lines @@
 
   all_entries = _FindAllProjectEntries(main_entries)
   logging.info('Found %d dependent build_config targets.', len(all_entries))
   entries = _CombineTestEntries(all_entries)
   logging.info('Creating %d projects for targets.', len(entries))
 
   logging.warning('Writing .gradle files...')
   jinja_processor = jinja_template.JinjaProcessor(_FILE_DIR)
   build_vars = _ReadBuildVars(output_dir)
   project_entries = []
-  srcjar_tuples = []
+  zip_tuples = []
   generated_inputs = []
   for entry in entries:
     if entry.GetType() not in ('android_apk', 'java_library', 'java_binary'):
       continue
 
     data = _GenerateGradleFile(entry, generator, build_vars, jinja_processor)
     if data:
       project_entries.append(entry)
       # Build all paths references by .gradle that exist within output_dir.
       generated_inputs.extend(generator.GeneratedInputs(entry))
-      srcjar_tuples.extend(
+      zip_tuples.extend(
           (s, os.path.join(generator.EntryOutputDir(entry), _SRCJARS_SUBDIR))
           for s in generator.Srcjars(entry))
+      zip_tuples.extend(
+          (s, os.path.join(generator.EntryOutputDir(entry), _RES_SUBDIR))
+          for s in _RebasePath(entry.ResZips()))
       _WriteFile(
           os.path.join(generator.EntryOutputDir(entry), 'build.gradle'), data)
 
   _WriteFile(os.path.join(generator.project_dir, 'build.gradle'),
              _GenerateRootGradle(jinja_processor))
 
   _WriteFile(os.path.join(generator.project_dir, 'settings.gradle'),
              _GenerateSettingsGradle(project_entries))
 
   sdk_path = _RebasePath(build_vars['android_sdk_root'])
   _WriteFile(os.path.join(generator.project_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:
-    _ExtractSrcjars(generator.project_dir, srcjar_tuples)
+  if zip_tuples:
+    _ExtractZips(generator.project_dir, zip_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()