GN get_label_info support toolchains for target_out_dir.

tools/gn/ninja_binary_target_writer_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 <sstream>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/ninja_binary_target_writer.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/target.h"
@@ skipping 357 matching lines @@
 TEST(NinjaBinaryTargetWriter, WinPrecompiledHeaders) {
   Err err;
 
   // This setup's toolchain does not have precompiled headers defined.
   TestWithScope setup;
 
   // A precompiled header toolchain.
   Settings pch_settings(setup.build_settings(), "withpch/");
   Toolchain pch_toolchain(&pch_settings,
                           Label(SourceDir("//toolchain/"), "withpch"));
+  pch_settings.set_toolchain_label(pch_toolchain.label());
+  pch_settings.set_default_toolchain_label(setup.toolchain()->label());
 
   // Declare a C++ compiler that supports PCH.
   scoped_ptr<Tool> cxx_tool(new Tool);
   TestWithScope::SetCommandForTool(
       "c++ {{source}} {{cflags}} {{cflags_cc}} {{defines}} {{include_dirs}} "
       "-o {{output}}",
       cxx_tool.get());
   cxx_tool->set_outputs(SubstitutionList::MakeForTest(
       "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o"));
   cxx_tool->set_precompiled_header_type(Tool::PCH_MSVC);
@@ skipping 15 matching lines @@
     writer.Run();
 
     const char no_pch_expected[] =
         "defines =\n"
         "include_dirs =\n"
         "cflags =\n"
         "cflags_cc =\n"
         "target_output_name = no_pch_target\n"
         "\n"
         "build withpch/obj/foo/no_pch_target.input1.o: "
-               "cxx ../../foo/input1.cc\n"
+               "withpch_cxx ../../foo/input1.cc\n"
         "\n"
         "build withpch/obj/foo/no_pch_target.stamp: "
-               "stamp withpch/obj/foo/no_pch_target.input1.o\n";
+               "withpch_stamp withpch/obj/foo/no_pch_target.input1.o\n";
     EXPECT_EQ(no_pch_expected, out.str());
   }
 
   // This target specifies PCH.
   {
     Target pch_target(&pch_settings,
                       Label(SourceDir("//foo/"), "pch_target"));
     pch_target.config_values().set_precompiled_header("build/precompile.h");
     pch_target.config_values().set_precompiled_source(
         SourceFile("//build/precompile.cc"));
@@ skipping 11 matching lines @@
         "defines =\n"
         "include_dirs =\n"
         "cflags =\n"
         // There should only be one .pch file created, for C++ files.
         "cflags_cc = /Fpwithpch/obj/foo/pch_target_cc.pch "
                      "/Yubuild/precompile.h\n"
         "target_output_name = pch_target\n"
         "\n"
         // Compile the precompiled source file with /Yc.
         "build withpch/obj/build/pch_target.precompile.cc.o: "
-               "cxx ../../build/precompile.cc\n"
+               "withpch_cxx ../../build/precompile.cc\n"
         "  cflags_cc = ${cflags_cc} /Ycbuild/precompile.h\n"
         "\n"
         "build withpch/obj/foo/pch_target.input1.o: "
-               "cxx ../../foo/input1.cc | "
+               "withpch_cxx ../../foo/input1.cc | "
                // Explicit dependency on the PCH build step.
                "withpch/obj/build/pch_target.precompile.cc.o\n"
         "\n"
         "build withpch/obj/foo/pch_target.stamp: "
-               "stamp withpch/obj/foo/pch_target.input1.o "
+               "withpch_stamp withpch/obj/foo/pch_target.input1.o "
                // The precompiled object file was added to the outputs.
                "withpch/obj/build/pch_target.precompile.cc.o\n";
     EXPECT_EQ(pch_win_expected, out.str());
   }
 }
 
 // Should throw an error with the scheduler if a duplicate object file exists.
 // This is dependent on the toolchain's object file mapping.
 TEST(NinjaBinaryTargetWriter, DupeObjFileError) {
   Scheduler scheduler;
 
   TestWithScope setup;
   TestTarget target(setup, "//foo:bar", Target::EXECUTABLE);
   target.sources().push_back(SourceFile("//a.cc"));
   target.sources().push_back(SourceFile("//a.cc"));
 
   EXPECT_FALSE(scheduler.is_failed());
 
   std::ostringstream out;
   NinjaBinaryTargetWriter writer(&target, out);
   writer.Run();
 
   // Should have issued an error.
   EXPECT_TRUE(scheduler.is_failed());
 }