Consider bundle_data as public_deps of create_bundle targets.

tools/gn/bundle_data.cc

 // 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.
 
 #include "tools/gn/bundle_data.h"
 
 #include "base/logging.h"
 #include "tools/gn/output_file.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/target.h"
@@ skipping 25 matching lines @@
     std::string asset_catalog_path = dir.as_string();
     *asset_catalog = SourceFile(SourceFile::SWAP_IN, &asset_catalog_path);
   }
   return true;
 }
 
 BundleData::BundleData() {}
 
 BundleData::~BundleData() {}
 
-void BundleData::AddFileRuleFromTarget(const Target* target) {
+void BundleData::AddBundleData(const Target* target) {
   DCHECK_EQ(target->output_type(), Target::BUNDLE_DATA);
+  bundle_deps_.push_back(target);
+}
 
-  std::vector<SourceFile> file_rule_sources;
-  for (const SourceFile& source_file : target->sources()) {
-    if (IsSourceFileFromAssetCatalog(source_file, nullptr)) {
-      asset_catalog_sources_.push_back(source_file);
-    } else {
-      file_rule_sources.push_back(source_file);
+void BundleData::OnTargetResolved(Target* owning_target) {
+  // Only initialize file_rules_ and asset_catalog_sources for "create_bundle"
+  // target (properties are only used by those targets).
+  if (owning_target->output_type() != Target::CREATE_BUNDLE)
+    return;
+
+  for (const Target* target : bundle_deps_) {
+    SourceFiles file_rule_sources;
+    for (const SourceFile& source_file : target->sources()) {
+      if (IsSourceFileFromAssetCatalog(source_file, nullptr)) {
+        asset_catalog_sources_.push_back(source_file);
+      } else {
+        file_rule_sources.push_back(source_file);
+      }
+    }
+
+    if (!file_rule_sources.empty()) {
+      DCHECK_EQ(target->action_values().outputs().list().size(), 1u);
+      file_rules_.push_back(BundleFileRule(
+          file_rule_sources, target->action_values().outputs().list()[0]));
     }
   }
 
-  if (!file_rule_sources.empty()) {
-    DCHECK_EQ(target->action_values().outputs().list().size(), 1u);
-    file_rules_.push_back(BundleFileRule(
-        file_rule_sources, target->action_values().outputs().list()[0]));
-  }
+  GetSourceFiles(&owning_target->sources());
 }
 
-void BundleData::GetSourceFiles(std::vector<SourceFile>* sources) const {
+void BundleData::GetSourceFiles(SourceFiles* sources) const {
   for (const BundleFileRule& file_rule : file_rules_) {
     sources->insert(sources->end(), file_rule.sources().begin(),
                     file_rule.sources().end());
   }
   sources->insert(sources->end(), asset_catalog_sources_.begin(),
                   asset_catalog_sources_.end());
 }
 
 void BundleData::GetOutputFiles(const Settings* settings,
-                                std::vector<OutputFile>* outputs) const {
-  std::vector<SourceFile> outputs_as_sources;
+                                OutputFiles* outputs) const {
+  SourceFiles outputs_as_sources;
   GetOutputsAsSourceFiles(settings, &outputs_as_sources);
   for (const SourceFile& source_file : outputs_as_sources)
     outputs->push_back(OutputFile(settings->build_settings(), source_file));
 }
 
 void BundleData::GetOutputsAsSourceFiles(
     const Settings* settings,
-    std::vector<SourceFile>* outputs_as_source) const {
+    SourceFiles* outputs_as_source) const {
   for (const BundleFileRule& file_rule : file_rules_) {
     for (const SourceFile& source : file_rule.sources()) {
       outputs_as_source->push_back(
           file_rule.ApplyPatternToSource(settings, *this, source));
     }
   }
 
   if (!asset_catalog_sources_.empty())
     outputs_as_source->push_back(GetCompiledAssetCatalogPath());
 }
 
 SourceFile BundleData::GetCompiledAssetCatalogPath() const {
   DCHECK(!asset_catalog_sources_.empty());
   std::string assets_car_path = resources_dir_ + "/Assets.car";
   return SourceFile(SourceFile::SWAP_IN, &assets_car_path);
 }