Consider bundle_data as public_deps of create_bundle targets.

tools/gn/target.cc

 // Copyright (c) 2013 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.
 
 #include "tools/gn/target.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 107 matching lines @@
   }
 
   // Only check private deps if requested.
   if (check_private_deps) {
     for (const auto& pair : target->private_deps()) {
       if (EnsureFileIsGeneratedByDependency(pair.ptr, file, false,
                                             consider_object_files,
                                             seen_targets))
         return true;  // Found a path.
     }
+    if (target->output_type() == Target::CREATE_BUNDLE) {
+      for (const auto& dep : target->bundle_data().deps()) {
+        if (EnsureFileIsGeneratedByDependency(dep, file, false,
+                                              consider_object_files,
+                                              seen_targets))
+          return true;  // Found a path.
+      }
+    }
   }
   return false;
 }
 
 // check_this indicates if the given target should be matched against the
 // patterns. It should be set to false for the first call since assert_no_deps
 // shouldn't match the target itself.
 //
 // visited should point to an empty set, this will be used to prevent
 // multiple visits.
@@ skipping 336 matching lines @@
     if (pair.ptr->hard_dep())
       recursive_hard_deps_.insert(pair.ptr);
 
     // Recursive hard dependencies of all dependencies.
     recursive_hard_deps_.insert(pair.ptr->recursive_hard_deps().begin(),
                                 pair.ptr->recursive_hard_deps().end());
   }
 }
 
 void Target::PullRecursiveBundleData() {
+  UniqueVector<const Target*>& bundle_data_deps = bundle_data_.deps();
+  for (const auto& pair : GetDeps(DEPS_LINKED)) {
+    // Stop recursion at create_bundle targets.

[brettw, 2016/03/21 22:49:47]

This would be more clear to me as something like "Don't propagate bundle data
once they're added to a bundle." (or something). The thing that threw me off
here is that this code isn't actually doing recursion any more.

+    if (pair.ptr->output_type() == CREATE_BUNDLE)
+      continue;
+
+    // Direct dependency on a bundle_data target.
+    if (pair.ptr->output_type() == BUNDLE_DATA)
+      bundle_data_deps.push_back(pair.ptr);
+

[brettw, 2016/03/21 22:49:47]

Extra blank line in here.

+
+    // Recursive bundle_data informations from all dependencies.
+    bundle_data_deps.Append(pair.ptr->bundle_data().deps().begin(),
+                            pair.ptr->bundle_data().deps().end());
+  }
+
   if (output_type_ != CREATE_BUNDLE)
     return;
 
-  std::set<const Target*> visited;
-  std::vector<const Target*> deps;
-  deps.push_back(this);
-
-  while (!deps.empty()) {
-    const Target* current = deps.back();
-    deps.pop_back();
-
-    if (visited.find(current) != visited.end())
-      continue;
-    visited.insert(current);
-
-    if (current->output_type_ == BUNDLE_DATA)
-      bundle_data_.AddFileRuleFromTarget(current);
-
-    for (const LabelTargetPair& pair : current->GetDeps(DEPS_ALL)) {
-      DCHECK(pair.ptr);
-      DCHECK(pair.ptr->toolchain_);
-      if (visited.find(pair.ptr) != visited.end())
-        continue;
-
-      if (pair.ptr->output_type() == CREATE_BUNDLE)
-        continue;
-
-      deps.push_back(pair.ptr);
-    }
-  }
-
+  for (const auto& target : bundle_data_.deps())
+    bundle_data_.AddFileRuleFromTarget(target);

[brettw, 2016/03/21 22:49:47]

Can this function be changed now? It's weird to pass in a member of a class to a
function of that same class from outside as the only invocation of this
function.

I think this is the only place where bundle_data.deps is written to. It might be
better to make this set read only and have a function
AddBundleData(UniqueVector* swapped_in_bundle_data) or maybe even better would
be to just have AddBundleData(const Target*) that does everything for one
target.

[brettw, 2016/03/21 22:59:08]

By this I mean append that target to the bundle_deps and if it's new, do the
stuff that AddFileRuleFromTarget did before

[sdefresne, 2016/03/22 12:34:05]

There was a small optimisation that this removed (only Target::CREATE_BUNDLE
cares about file_rules_ and asset_catalog_sources_).

To avoid initializing those fields for all target, I've added a separate method
OnTargetResolved(). It also sets the target sources() field for
Target::CREATE_BUNDLE.

WDYT?

   bundle_data_.GetSourceFiles(&sources_);
 }
 
 void Target::FillOutputFiles() {
   const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
   bool check_tool_outputs = false;
   switch (output_type_) {
     case GROUP:
     case BUNDLE_DATA:
     case CREATE_BUNDLE:
@@ skipping 239 matching lines @@
   if (!EnsureFileIsGeneratedByDependency(this, out_file, true, false,
                                          &seen_targets)) {
     // Check object files (much slower and very rare) only if the "normal"
     // output check failed.
     seen_targets.clear();
     if (!EnsureFileIsGeneratedByDependency(this, out_file, true, true,
                                            &seen_targets))
       g_scheduler->AddUnknownGeneratedInput(this, source);
   }
 }