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.
     }
+    for (const auto& pair : target->bundle_data().deps()) {
+      if (EnsureFileIsGeneratedByDependency(pair.ptr, 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 363 matching lines @@
 
     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);

[brettw, 2016/03/16 17:27:44]

I was studying Target::PullRecursiveBundleData more in the context of this patch
and I think we need to change how this works. Currently, this does a dull
dependency walk for every target, which I think is O(n^2).

We should instead track the recursive bundle data for every target and just push
it up the tree as we go, merging the lists at each level. PullRecursiveHardDeps
does this and I think this code can easily be made to work the same way. You can
just use Target* pointers (rather than the LabelPtrPair) which are also faster
to deal with (LabelPtrPair is required for deps because we this is used to track
deps before the labels have been resolved to targets).

This will also give us a list on each target of the recursive bundle data which
I think should solve the problem you're trying to solve by adding deps to bundle
data.

     }
   }
 
   bundle_data_.GetSourceFiles(&sources_);
 }
 
 void Target::FillOutputFiles() {
   const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
   bool check_tool_outputs = false;
   switch (output_type_) {
@@ skipping 242 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);
   }
 }