Implement tracking of BUILD.gn files used to define target, toolchain or

tools/gn/loader_unittest.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 <map>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
@@ skipping 90 matching lines @@
   for (const auto& cur : pending_) {
     CannedResponseMap::const_iterator found = canned_responses_.find(cur.first);
     if (found == canned_responses_.end())
       cur.second.Run(&block);
     else
       cur.second.Run(found->second->root.get());
   }
   pending_.clear();
 }
 
+class MockBuilder {
+ public:
+  void OnItemDefined(std::unique_ptr<Item> item);
+
+  bool HasOneDefined(std::set<std::string> source_files) const;
+  void Cleanup();
+
+ private:
+  std::vector<std::unique_ptr<Item>> items_;
+};
+
+void MockBuilder::OnItemDefined(std::unique_ptr<Item> item) {
+  items_.push_back(std::move(item));
+}
+
+bool MockBuilder::HasOneDefined(std::set<std::string> source_files) const {
+  if (items_.size() != 1u)
+    return false;
+
+  const auto& input_files = items_[0]->input_files();
+  for (const InputFile* input_file : input_files) {
+    auto found_source_file = source_files.find(input_file->name().value());
+    if (found_source_file == source_files.end())
+      return false;
+
+    source_files.erase(found_source_file);
+  }
+
+  return source_files.empty();
+};
+
+void MockBuilder::Cleanup() {
+  items_.clear();
+}
+
 // LoaderTest ------------------------------------------------------------------
 
 class LoaderTest : public testing::Test {
  public:
   LoaderTest() {
     build_settings_.SetBuildDir(SourceDir("//out/Debug/"));
   }
 
  protected:
   Scheduler scheduler_;
   BuildSettings build_settings_;
+  MockBuilder mock_builder_;
   MockInputFileManager mock_ifm_;
+  std::vector<std::unique_ptr<Item>> items_;
 };
 
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 TEST_F(LoaderTest, Foo) {
   SourceFile build_config("//build/config/BUILDCONFIG.gn");
   build_settings_.set_build_config_file(build_config);
 
@@ skipping 27 matching lines @@
   EXPECT_TRUE(mock_ifm_.HasOnePending(SourceFile("//tc2/BUILD.gn")));
 
   // Running the toolchain file should schedule the build config file to load
   // for that toolchain.
   mock_ifm_.IssueAllPending();
   base::RunLoop().RunUntilIdle();
 
   // We have to tell it we have a toolchain definition now (normally the
   // builder would do this).
   const Settings* default_settings = loader->GetToolchainSettings(Label());
-  Toolchain second_tc_object(default_settings, second_tc);
+  Toolchain second_tc_object(default_settings, second_tc, {});
   loader->ToolchainLoaded(&second_tc_object);
   EXPECT_TRUE(mock_ifm_.HasOnePending(build_config));
 
   // Scheduling a second file to load in that toolchain should not make it
   // pending yet (it's waiting for the build config).
   SourceFile third_file("//bar/BUILD.gn");
   loader->Load(third_file, LocationRange(), second_tc);
   EXPECT_TRUE(mock_ifm_.HasOnePending(build_config));
 
   // Running the build config file should make our third file pending.
   mock_ifm_.IssueAllPending();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(mock_ifm_.HasTwoPending(second_file, third_file));
 
   EXPECT_FALSE(scheduler_.is_failed());
 }
+
+TEST_F(LoaderTest, SourceFilesAreCollected) {
+  SourceFile build_config("//build/config/BUILDCONFIG.gn");
+  SourceFile root_build("//BUILD.gn");
+  build_settings_.set_build_config_file(build_config);
+
+  build_settings_.set_item_defined_callback(base::Bind(
+      &MockBuilder::OnItemDefined, base::Unretained(&mock_builder_)));
+
+  scoped_refptr<LoaderImpl> loader(new LoaderImpl(&build_settings_));
+
+  mock_ifm_.AddCannedResponse(build_config,
+                              "set_default_toolchain(\"//tc:tc\")");
+  mock_ifm_.AddCannedResponse(root_build,
+                              "executable(\"a\") { sources = [ \"a.cc\" ] }");
+
+  loader->set_async_load_file(mock_ifm_.GetCallback());
+
+  // Request the root build file be loaded. This should kick off the default
+  // build config loading.
+  loader->Load(root_build, LocationRange(), Label());
+  EXPECT_TRUE(mock_ifm_.HasOnePending(build_config));
+
+  // Completing the build config load should kick off the root build file load.
+  mock_ifm_.IssueAllPending();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(mock_ifm_.HasOnePending(root_build));
+
+  // Completing the root build file should define a target which must have
+  // set of source files hashes.
+  mock_ifm_.IssueAllPending();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(mock_builder_.HasOneDefined({"//BUILD.gn"}));
+
+  EXPECT_FALSE(scheduler_.is_failed());
+}