Add retrolambda.py and integrate it to build process.

build/config/android/internal_rules.gni

 # Copyright 2014 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.
 
 # Do not add any imports to non-//build directories here.
 # Some projects (e.g. V8) do not have non-build directories DEPS'ed in.
 import("//build_overrides/build.gni")
 import("//build/config/android/config.gni")
 import("//build/config/dcheck_always_on.gni")
 import("//build/config/sanitizers/sanitizers.gni")
@@ skipping 400 matching lines @@
       rebased_renaming_sources =
           rebase_path(invoker.renaming_sources, root_build_dir)
       args += [ "--renaming-sources=$rebased_renaming_sources" ]
 
       renaming_destinations = invoker.renaming_destinations
       args += [ "--renaming-destinations=$renaming_destinations" ]
     }
   }
 }
 
-# Generates a script in the output bin directory which runs the test
+# Generates a script in the build bin directory which runs the test
 # target using the test runner script in build/android/test_runner.py.
 template("test_runner_script") {
   testonly = true
   _test_name = invoker.test_name
   _test_type = invoker.test_type
   _incremental_install =
       defined(invoker.incremental_install) && invoker.incremental_install
 
   _runtime_deps =
       !defined(invoker.ignore_all_data_deps) || !invoker.ignore_all_data_deps
@@ skipping 380 matching lines @@
         rebase_path(_result_path, root_build_dir),
         rebase_path(invoker.jar_path, root_build_dir),
       ]
 
       if (findbugs_verbose) {
         args += [ "-vv" ]
       }
     }
   }
 
-  # Generates a script in the output bin.java directory to run a java binary.
+  # Generates a script in the build bin directory to run a java binary.
   #
   # Variables
-  #   main_class: The class containing the progam entry point.
+  #   main_class: The class containing the program entry point.
   #   jar_path: The path to the jar to run.
   #   script_name: Name of the script to generate.
   #   build_config: Path to .build_config for the jar (contains classpath).
   #   wrapper_script_args: List of extra arguments to pass to the executable.
   #
   template("java_binary_script") {
     set_sources_assignment_filter([])
     forward_variables_from(invoker, [ "testonly" ])
 
     _main_class = invoker.main_class
@@ skipping 157 matching lines @@
     forward_variables_from(invoker, [ "testonly" ])
 
     assert(invoker.build_config != "")
     _build_config = invoker.build_config
     _rebased_build_config = rebase_path(_build_config, root_build_dir)
     assert(_rebased_build_config != "" || true)  # Mark used.
 
     _input_jar_path = invoker.input_jar_path
     _output_jar_path = invoker.output_jar_path
 
-    _proguard_preprocess =
-        defined(invoker.proguard_preprocess) && invoker.proguard_preprocess
-
     _jar_excluded_patterns = []
     if (defined(invoker.jar_excluded_patterns)) {
       _jar_excluded_patterns = invoker.jar_excluded_patterns
     }
     _strip_resource_classes = defined(invoker.strip_resource_classes) &&
                               invoker.strip_resource_classes
     _filter_jar = _jar_excluded_patterns != [] || _strip_resource_classes
 
+    _proguard_preprocess =
+        defined(invoker.proguard_preprocess) && invoker.proguard_preprocess
+
     _enable_assert =
         defined(invoker.supports_android) && invoker.supports_android &&
         (is_java_debug || dcheck_always_on)
-    assert(_enable_assert || true)  # Mark used.
+
+    _retrolambda = defined(invoker.supports_android) &&
+                   invoker.supports_android && use_java8
+
+    _deps = []
+    _previous_output_jar = _input_jar_path
 
     if (_filter_jar) {
       _filter_target = "${target_name}__filter"
+      _filter_input_jar = _previous_output_jar
+      _filter_output_jar = "$target_out_dir/$target_name-filtered.jar"
 
-      _filter_jar_path = "$target_out_dir/$target_name-filtered.jar"
       action(_filter_target) {
         script = "//build/android/gyp/jar.py"
-        forward_variables_from(invoker,
-                               [
-                                 "deps",
-                                 "public_deps",
-                               ])
+        deps = _deps
+        if (defined(invoker.deps)) {
+          deps += invoker.deps
+        }
+        if (defined(invoker.public_deps)) {
+          public_deps = invoker.public_deps
+        }
         inputs = [
           _build_config,
-          _input_jar_path,
+          _filter_input_jar,
         ]
         outputs = [
-          _filter_jar_path,
+          _filter_output_jar,
         ]
         args = [
           "--input-jar",
-          rebase_path(_input_jar_path, root_build_dir),
+          rebase_path(_filter_input_jar, root_build_dir),
           "--jar-path",
-          rebase_path(_filter_jar_path, root_build_dir),
+          rebase_path(_filter_output_jar, root_build_dir),
           "--excluded-classes=$_jar_excluded_patterns",
         ]
         if (_strip_resource_classes) {
           args += [ "--strip-resource-classes-for=@FileArg($_rebased_build_config:javac:resource_packages)" ]
         }
       }
+
+      _deps = []
+      _deps = [ ":$_filter_target" ]
+      _previous_output_jar = _filter_output_jar
     }
 
     if (_proguard_preprocess) {
-      _output_jar_target = "${target_name}__proguard_process"
-      _proguard_output_jar = _output_jar_path
+      _proguard_target = "${target_name}__proguard_process"
+      _proguard_input_jar = _previous_output_jar
+      _proguard_output_jar = "$target_out_dir/$target_name-proguarded.jar"
       _proguard_config_path = invoker.proguard_preprocess_config
-      proguard(_output_jar_target) {
-        if (_filter_jar) {
-          _proguard_input_jar = _filter_jar_path
-          deps = [
-            ":$_filter_target",
-          ]
-        } else {
-          _proguard_input_jar = _input_jar_path
-          deps = []
-        }
+
+      proguard(_proguard_target) {
+        deps = _deps
         if (defined(invoker.deps)) {
           deps += invoker.deps
         }
         if (defined(invoker.public_deps)) {
           public_deps = invoker.public_deps
         }
         inputs = [
           _build_config,
           _proguard_config_path,
           _proguard_input_jar,
         ]
         output_jar_path = _proguard_output_jar
 
         _rebased_input_paths =
             [ rebase_path(_proguard_input_jar, root_build_dir) ]
         _rebased_proguard_configs =
             [ rebase_path(_proguard_config_path, root_build_dir) ]
         args = [
           "--input-paths=$_rebased_input_paths",
           "--proguard-configs=$_rebased_proguard_configs",
           "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
         ]
       }
-    } else if (_enable_assert) {
-      _output_jar_target = "${target_name}__assert"
-      _assert_output_jar = _output_jar_path
-      action(_output_jar_target) {
-        script = "$root_out_dir/bin/helper/java_assertion_enabler"
+
+      _deps = []
+      _deps = [ ":$_proguard_target" ]
+      _previous_output_jar = _proguard_output_jar
+    }
+
+    if (_enable_assert) {
+      _assert_target = "${target_name}__assert"
+      _assert_input_jar = _previous_output_jar
+      _assert_output_jar = "$target_out_dir/$target_name-asserted.jar"
+
+      action(_assert_target) {
+        script = "$root_build_dir/bin/helper/java_assertion_enabler"
         deps = [
           "//build/android/java_assertion_enabler($default_toolchain)",
         ]
-        if (_filter_jar) {
-          _assert_input_jar = _filter_jar_path
-          deps += [ ":$_filter_target" ]
-        } else {
-          _assert_input_jar = _input_jar_path
-        }
+        deps += _deps
         if (defined(invoker.deps)) {
           deps += invoker.deps
         }
         if (defined(invoker.public_deps)) {
           public_deps = invoker.public_deps
         }
         inputs = [
           _assert_input_jar,
         ]
         outputs = [
           _assert_output_jar,
         ]
         args = [
           rebase_path(_assert_input_jar, root_build_dir),
           rebase_path(_assert_output_jar, root_build_dir),
         ]
       }
-    } else {
-      _output_jar_target = "${target_name}__copy"
-      copy(_output_jar_target) {
-        if (_filter_jar) {
-          _copy_input_jar = _filter_jar_path
-          public_deps = [
-            ":$_filter_target",
-          ]
-        } else {
-          _copy_input_jar = _input_jar_path
-          public_deps = []
-        }
+
+      _deps = []
+      _deps = [ ":$_assert_target" ]
+      _previous_output_jar = _assert_output_jar
+    }
+
+    if (_retrolambda) {
+      _retrolambda_target = "${target_name}__retrolambda"
+      _retrolambda_input_jar = _previous_output_jar
+      _retrolambda_output_jar = "$target_out_dir/$target_name-retrolambda.jar"
+
+      android_sdk_jar = "$android_sdk/android.jar"
+      action(_retrolambda_target) {
+        script = "//build/android/gyp/retrolambda.py"
+        deps = _deps
         if (defined(invoker.deps)) {
-          deps = invoker.deps
+          deps += invoker.deps
         }
         if (defined(invoker.public_deps)) {
-          public_deps += invoker.public_deps
+          public_deps = invoker.public_deps
         }
-        sources = [
-          _copy_input_jar,
+        inputs = [
+          _build_config,
+          _retrolambda_input_jar,
         ]
         outputs = [
-          _output_jar_path,
+          _retrolambda_output_jar,
+        ]
+        args = [
+          "--input-jar",
+          rebase_path(_retrolambda_input_jar, root_build_dir),
+          "--output-jar",
+          rebase_path(_retrolambda_output_jar, root_build_dir),
+          "--classpath=@FileArg($_rebased_build_config:javac:classpath)",
+          "--android-sdk-jar",
+          rebase_path(android_sdk_jar, root_build_dir),
         ]
       }
+
+      _deps = []
+      _deps = [ ":$_retrolambda_target" ]
+      _previous_output_jar = _retrolambda_output_jar
+    }
+
+    _output_jar_target = "${target_name}__copy"
+    copy(_output_jar_target) {
+      deps = _deps
+      if (defined(invoker.deps)) {
+        deps += invoker.deps
+      }
+      if (defined(invoker.public_deps)) {
+        public_deps = invoker.public_deps
+      }
+      sources = [
+        _previous_output_jar,
+      ]
+      outputs = [
+        _output_jar_path,
+      ]
     }
 
     group(target_name) {
       forward_variables_from(invoker,
                              [
                                "data_deps",
                                "visibility",
                              ])
       public_deps = [
         ":$_output_jar_target",
@@ skipping 919 matching lines @@
           _android_sdk_ijar = invoker.alternative_android_sdk_ijar
         } else {
           deps += [ "//build/android:android_ijar" ]
           _android_sdk_ijar = "$root_out_dir/lib.java/android.interface.jar"
         }
         inputs += [ _android_sdk_ijar ]
         _rebased_android_sdk_ijar =
             rebase_path(_android_sdk_ijar, root_build_dir)
         args += [ "--bootclasspath=$_rebased_android_sdk_ijar" ]
       }
-      if (_supports_android) {
+      if (use_java8) {
+        args += [ "--java-version=1.8" ]
+      } else if (_supports_android) {
         args += [ "--java-version=1.7" ]
       }
       foreach(e, _manifest_entries) {
         args += [ "--manifest-entry=" + e ]
       }
       if (_chromium_code) {
         args += [ "--chromium-code=1" ]
       }
       if (_enable_errorprone) {
         deps += [ "//third_party/errorprone:chromium_errorprone" ]
@@ skipping 637 matching lines @@
         rebase_path(root_build_dir, root_build_dir),
         "--packed-libraries-dir",
         rebase_path(_packed_libraries_dir, root_build_dir),
         "--libraries=${invoker.libraries_filearg}",
         "--filelistjson",
         rebase_path(invoker.file_list_json, root_build_dir),
       ]
     }
   }
 }