Jumbo for blink/core generated files as well (saving 8 CPU minutes)

build/config/jumbo.gni

 # Copyright 2017 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.
 
 import("//build/split_static_library.gni")  # When someone uses that target_type
 
 declare_args() {
   # If true, use a jumbo build (files compiled together) to speed up
   # compilation.
-  use_jumbo_build = false
+  use_jumbo_build = !is_official_build && !(is_android && !is_clang)

[Dirk Pranke, 2017/07/07 20:12:10]

I'm guessing this change isn't intentional (or at least, isn't meant for
landing)?

[Daniel Bratell, 2017/07/10 09:18:29]

I'm adding and removing this in every CL to verify that the changes work on all
platforms. It would be nice to land but I understand the need to be careful.

 
   # A target to exclude from jumbo builds, for optimal round trip time
   # when frequently changing a single cpp file.
   jumbo_build_excluded = ""
 
   # How many files to group at most. Smaller numbers give more
   # parallellism, higher numbers give less total CPU usage. Higher
   # numbers also give longer single-file recompilation times.
   #
   # Recommendations:
@@ skipping 38 matching lines @@
   }
 
   excluded_sources = []
   if (defined(invoker.jumbo_excluded_sources)) {
     excluded_sources += invoker.jumbo_excluded_sources
   }
 
   invoker_sources = invoker.sources
   gen_target_dir = get_path_info(invoker_sources[0], "gen_dir")
   assert(excluded_sources != [] || true)  # Prevent "unused variable".
+
+  # Find the gen_target_dir directory with shortest path.

[Dirk Pranke, 2017/07/07 20:12:10]

This is a bit obscure. Can you add more to the comment about what this is
actually doing, and why we need to do it (e.g., link to the ninja bug)? 

Is there maybe something we should be doing in GN to make sure we get the
shortest path here, instead?

[Daniel Bratell, 2017/07/10 09:18:30]

I've expanded the comment.

The part I missed in gn for this to be smoother was a len() operator to tell me
the length of a string, or actually, I'd need the number of / and \ in a string.
The most generic operator that would help would be one that said if a path was a
"parent" of another path.

+  foreach(source_file, invoker.sources) {
+    possibly_better_gen_target_dir = get_path_info(gen_target_dir, "dir")
+    possibly_better_gen_target_dir_2 =
+        get_path_info(possibly_better_gen_target_dir, "dir")
+    alt_gen_target_dir = get_path_info(source_file, "gen_dir")
+    if (alt_gen_target_dir == possibly_better_gen_target_dir ||
+        alt_gen_target_dir == possibly_better_gen_target_dir_2) {
+      gen_target_dir = alt_gen_target_dir
+    }
+  }
+
   assert(gen_target_dir != "")  # Prevent "unused variable".
 
   if (use_jumbo_build_for_target) {
     jumbo_files = []
 
     # Split the sources list into chunks that are not excessively large
     files_per_chunk = jumbo_file_merge_limit
     current_file_index = 0
     next_chunk_start = 0
     next_chunk_number = 1
@@ skipping 73 matching lines @@
     forward_variables_from(invoker, "*", variables_to_not_forward)
   }
 }
 
 set_defaults("jumbo_target") {
   # This sets the default list of configs when the content_source_set target
   # is defined. The default_compiler_configs comes from BUILDCONFIG.gn and
   # is the list normally applied to static libraries and source sets.
   configs = default_compiler_configs
 }