Allow GN configs to have sub-configs.

tools/gn/target_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 "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/config.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/target.h"
@@ skipping 72 matching lines @@
 
   // Set up a dependency chain of a -> b -> c
   TestTarget a(setup, "//foo:a", Target::EXECUTABLE);
   TestTarget b(setup, "//foo:b", Target::STATIC_LIBRARY);
   TestTarget c(setup, "//foo:c", Target::STATIC_LIBRARY);
   a.private_deps().push_back(LabelTargetPair(&b));
   b.private_deps().push_back(LabelTargetPair(&c));
 
   // Normal non-inherited config.
   Config config(setup.settings(), Label(SourceDir("//foo/"), "config"));
+  ASSERT_TRUE(config.OnResolved(&err));
   c.configs().push_back(LabelConfigPair(&config));
 
   // All dependent config.
   Config all(setup.settings(), Label(SourceDir("//foo/"), "all"));
+  ASSERT_TRUE(all.OnResolved(&err));
   c.all_dependent_configs().push_back(LabelConfigPair(&all));
 
   // Direct dependent config.
   Config direct(setup.settings(), Label(SourceDir("//foo/"), "direct"));
+  ASSERT_TRUE(direct.OnResolved(&err));
   c.public_configs().push_back(LabelConfigPair(&direct));
 
   ASSERT_TRUE(c.OnResolved(&err));
   ASSERT_TRUE(b.OnResolved(&err));
   ASSERT_TRUE(a.OnResolved(&err));
 
   // B should have gotten both dependent configs from C.
   ASSERT_EQ(2u, b.configs().size());
   EXPECT_EQ(&all, b.configs()[0].ptr);
   EXPECT_EQ(&direct, b.configs()[1].ptr);
@@ skipping 243 matching lines @@
   product.private_deps().push_back(LabelTargetPair(&testlib));
   ASSERT_FALSE(product.OnResolved(&err));
 }
 
 TEST(Target, PublicConfigs) {
   TestWithScope setup;
   Err err;
 
   Label pub_config_label(SourceDir("//a/"), "pubconfig");
   Config pub_config(setup.settings(), pub_config_label);
+  ASSERT_TRUE(pub_config.OnResolved(&err));
 
   // This is the destination target that has a public config.
   TestTarget dest(setup, "//a:a", Target::SOURCE_SET);
   dest.public_configs().push_back(LabelConfigPair(&pub_config));
   ASSERT_TRUE(dest.OnResolved(&err));
 
   // This target has a public dependency on dest.
   TestTarget pub(setup, "//a:pub", Target::SOURCE_SET);
   pub.public_deps().push_back(LabelTargetPair(&dest));
   ASSERT_TRUE(pub.OnResolved(&err));
@@ skipping 191 matching lines @@
 
   Target target(setup.settings(), Label(SourceDir("//foo/"), "bar"));
 
   // Target with no settings, no configs, should be a no-op.
   EXPECT_TRUE(target.ResolvePrecompiledHeaders(&err));
 
   // Config with PCH values.
   Config config_1(setup.settings(), Label(SourceDir("//foo/"), "c1"));
   std::string pch_1("pch.h");
   SourceFile pcs_1("//pcs.cc");
-  config_1.config_values().set_precompiled_header(pch_1);
-  config_1.config_values().set_precompiled_source(pcs_1);
+  config_1.own_values().set_precompiled_header(pch_1);
+  config_1.own_values().set_precompiled_source(pcs_1);
+  ASSERT_TRUE(config_1.OnResolved(&err));
   target.configs().push_back(LabelConfigPair(&config_1));
 
   // No PCH info specified on target, but the config specifies one, the
   // values should get copied to the target.
   EXPECT_TRUE(target.ResolvePrecompiledHeaders(&err));
   EXPECT_EQ(pch_1, target.config_values().precompiled_header());
   EXPECT_TRUE(target.config_values().precompiled_source() == pcs_1);
 
   // Now both target and config have matching PCH values. Resolving again
   // should be a no-op since they all match.
   EXPECT_TRUE(target.ResolvePrecompiledHeaders(&err));
   EXPECT_TRUE(target.config_values().precompiled_header() == pch_1);
   EXPECT_TRUE(target.config_values().precompiled_source() == pcs_1);
 
   // Second config with different PCH values.
   Config config_2(setup.settings(), Label(SourceDir("//foo/"), "c2"));
   std::string pch_2("pch2.h");
   SourceFile pcs_2("//pcs2.cc");
-  config_2.config_values().set_precompiled_header(pch_2);
-  config_2.config_values().set_precompiled_source(pcs_2);
+  config_2.own_values().set_precompiled_header(pch_2);
+  config_2.own_values().set_precompiled_source(pcs_2);
+  ASSERT_TRUE(config_2.OnResolved(&err));
   target.configs().push_back(LabelConfigPair(&config_2));
 
   // This should be an error since they don't match.
   EXPECT_FALSE(target.ResolvePrecompiledHeaders(&err));
 
   // Make sure the proper labels are blamed.
   EXPECT_EQ(
       "The target //foo:bar\n"
       "has conflicting precompiled header settings.\n"
       "\n"
       "From //foo:bar\n"
       "  header: pch.h\n"
       "  source: //pcs.cc\n"
       "\n"
       "From //foo:c2\n"
       "  header: pch2.h\n"
       "  source: //pcs2.cc",
       err.help_text());
 }