Revert of Android: Support Android Studio 2.3

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
 import logging
 import os
 import re
 import shutil
 import subprocess
 import sys
 import zipfile
 
 _BUILD_ANDROID = os.path.join(os.path.dirname(__file__), os.pardir)
 sys.path.append(_BUILD_ANDROID)
@@ skipping 231 matching lines @@
       libraries += entry.BuildConfig().get('native', {}).get('libraries', [])
     if libraries:
       return _CreateJniLibsDir(constants.GetOutDirectory(),
           self.EntryOutputDir(root_entry), libraries)
     return []
 
   def _GenJavaDirs(self, root_entry):
     java_files = []
     for entry in self._GetEntries(root_entry):
       java_files += entry.JavaFiles()
-    java_dirs, single_files = _ComputeJavaSourceDirsAndFiles(
+    java_dirs, excludes = _ComputeJavaSourceDirsAndExcludes(
         constants.GetOutDirectory(), java_files)
-    return java_dirs, single_files
+    return java_dirs, excludes
 
   def _GenCustomManifest(self, entry):
     """Returns the path to the generated AndroidManifest.xml.
 
     Gradle uses package id from manifest when generating R.class. So, we need
     to generate a custom manifest if we let gradle process resources. We cannot
     simply set android.defaultConfig.applicationId because it is not supported
     for library targets."""
     resource_packages = entry.Javac().get('resource_packages')
     if not resource_packages:
@@ skipping 51 matching lines @@
     generated_inputs.update(self.AllSrcjars(root_entry))
     for entry in self._GetEntries(root_entry):
       generated_inputs.update(entry.GeneratedJavaFiles())
       generated_inputs.update(entry.PrebuiltJars())
     return set(generated_inputs)
 
   def Generate(self, root_entry):
     # TODO(agrieve): Add an option to use interface jars and see if that speeds
     # things up at all.
     variables = {}
-    java_dirs, java_files = self._GenJavaDirs(root_entry)
+    java_dirs, excludes = self._GenJavaDirs(root_entry)
     java_dirs.sort()
     variables['java_dirs'] = self._Relativize(root_entry, java_dirs)
     variables['java_dirs'].append(_SRCJARS_SUBDIR)
-    variables['java_files'] = self._Relativize(root_entry, java_files)
+    variables['java_excludes'] = excludes
     variables['jni_libs'] = self._Relativize(
         root_entry, set(self._GenJniLibs(root_entry)))
     variables['prebuilts'] = [
         p for e in self._GetEntries(root_entry) for p in e.PrebuiltJars()]
     variables['res_dirs'] = [
         p for e in self._GetEntries(root_entry) for p in e.ResDirs()]
     for entry in self._GetEntries(root_entry):
       variables['prebuilts'] += entry.PrebuiltJars()
       variables['res_dirs'] += entry.ResDirs()
     variables['prebuilts'] = self._Relativize(
@@ skipping 30 matching lines @@
         break
       if basename in ('javax', 'org', 'com'):
         path_root = os.path.dirname(path_root)
         break
     if path_root not in found_roots:
       found_roots[path_root] = []
     found_roots[path_root].append(path)
   return found_roots
 
 
-def _ComputeJavaSourceDirsAndFiles(output_dir, java_files):
-  """Computes the list of java source directories and single files.
+def _ComputeExcludeFilters(wanted_files, unwanted_files, parent_dir):
+  """Returns exclude patters to exclude unwanted files but keep wanted files.
+
+  - Shortens exclude list by globbing if possible.
+  - Exclude patterns are relative paths from the parent directory.
+  """
+  excludes = []
+  files_to_include = set(wanted_files)
+  files_to_exclude = set(unwanted_files)
+  while files_to_exclude:
+    unwanted_file = files_to_exclude.pop()
+    target_exclude = os.path.join(
+        os.path.dirname(unwanted_file), '*.java')
+    found_files = set(glob.glob(target_exclude))
+    valid_files = found_files & files_to_include
+    if valid_files:
+      excludes.append(os.path.relpath(unwanted_file, parent_dir))
+    else:
+      excludes.append(os.path.relpath(target_exclude, parent_dir))
+      files_to_exclude -= found_files
+  return excludes
+
+
+def _ComputeJavaSourceDirsAndExcludes(output_dir, java_files):
+  """Computes the list of java source directories and exclude patterns.
 
   1. Computes the root java source directories from the list of files.
-  2. Compute single files that are not included in full directories.
-  3. Returns the list of java source directories and single files.
+  2. Compute exclude patterns that exclude all extra files only.
+  3. Returns the list of java source directories and exclude patterns.
   """
   java_dirs = []
-  single_files = set()
+  excludes = []
   if java_files:
     java_files = _RebasePath(java_files)
     computed_dirs = _ComputeJavaSourceDirs(java_files)
+    java_dirs = computed_dirs.keys()
     all_found_java_files = set()
 
     for directory, files in computed_dirs.iteritems():
       found_java_files = build_utils.FindInDirectory(directory, '*.java')
       all_found_java_files.update(found_java_files)
       unwanted_java_files = set(found_java_files) - set(files)
       if unwanted_java_files:
-        logging.debug('Directory requires single files: %s', directory)
-        single_files.update(files)
-      else:
-        java_dirs.append(directory)
+        logging.debug('Directory requires excludes: %s', directory)
+        excludes.extend(
+            _ComputeExcludeFilters(files, unwanted_java_files, directory))
 
     missing_java_files = set(java_files) - all_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 missing_java_files:
-      logging.error(
+      logging.warning(
           'Some java files were not found: %s', missing_java_files)
 
-  return java_dirs, list(single_files)
+  return java_dirs, excludes
 
 
 def _CreateRelativeSymlink(target_path, link_path):
   link_dir = os.path.dirname(link_path)
   relpath = os.path.relpath(target_path, link_dir)
   logging.debug('Creating symlink %s -> %s', link_path, relpath)
   os.symlink(relpath, link_path)
 
 
 def _CreateJniLibsDir(output_dir, entry_output_dir, so_files):
@@ skipping 55 matching lines @@
     return None
 
   variables['target_name'] = os.path.splitext(deps_info['name'])[0]
   variables['template_type'] = target_type
   variables['use_gradle_process_resources'] = (
       generator.use_gradle_process_resources)
   source_properties = _ReadPropertiesFile(
       _RebasePath(os.path.join(build_vars['android_sdk_build_tools'],
                                'source.properties')))
   variables['build_tools_version'] = source_properties['Pkg.Revision']
-  # TODO(wnwen): Remove this line once http://crbug.com/688263 is fixed.
-  variables['build_tools_version'] = '25.0.0'
   variables['compile_sdk_version'] = (
       'android-%s' % build_vars['android_sdk_version'])
   variables['main'] = generator.Generate(entry)
   bootclasspath = gradle.get('bootclasspath')
   if bootclasspath:
     # Must use absolute path here.
     variables['bootclasspath'] = _RebasePath(bootclasspath)
   if entry.android_test_entry:
     variables['android_test'] = generator.Generate(
         entry.android_test_entry)
@@ skipping 199 matching lines @@
 
   if generated_inputs:
     logging.warning('Building generated source files...')
     targets = _RebasePath(generated_inputs, output_dir)
     _RunNinja(output_dir, targets)
 
   if zip_tuples:
     _ExtractZips(generator.project_dir, zip_tuples)
 
   logging.warning('Project created! (%d subprojects)', len(project_entries))
-  logging.warning('Generated projects are targeting Android Studio 2.3')
+  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()