diff --git a/tools/gn/BUILD.gn b/tools/gn/BUILD.gn
index 036d471..8f9f012 100644
--- a/tools/gn/BUILD.gn
+++ b/tools/gn/BUILD.gn
@@ -7,6 +7,8 @@
 defines = [ "GN_BUILD" ]
 
 static_library("gn_lib") {
+  configs += [ "//build/config:precompiled_headers" ]
+
   sources = [
     "action_target_generator.cc",
     "action_target_generator.h",
diff --git a/tools/gn/config_values.h b/tools/gn/config_values.h
index dec43c6..64c0acc 100644
--- a/tools/gn/config_values.h
+++ b/tools/gn/config_values.h
@@ -10,6 +10,7 @@
 
 #include "base/basictypes.h"
 #include "tools/gn/source_dir.h"
+#include "tools/gn/source_file.h"
 
 // Holds the values (include_dirs, defines, compiler flags, etc.) for a given
 // config or target.
@@ -39,6 +40,22 @@
 #undef STRING_VALUES_ACCESSOR
 #undef DIR_VALUES_ACCESSOR
 
+  bool has_precompiled_headers() const {
+    return !precompiled_header_.empty() || !precompiled_source_.is_null();
+  }
+  const std::string& precompiled_header() const {
+    return precompiled_header_;
+  }
+  void set_precompiled_header(const std::string& f) {
+    precompiled_header_ = f;
+  }
+  const SourceFile& precompiled_source() const {
+    return precompiled_source_;
+  }
+  void set_precompiled_source(const SourceFile& f) {
+    precompiled_source_ = f;
+  }
+
  private:
   std::vector<std::string> cflags_;
   std::vector<std::string> cflags_c_;
@@ -51,6 +68,8 @@
   std::vector<SourceDir>   lib_dirs_;
   std::vector<std::string> libs_;
 
+  std::string precompiled_header_;
+  SourceFile precompiled_source_;
 
   DISALLOW_COPY_AND_ASSIGN(ConfigValues);
 };
diff --git a/tools/gn/config_values_extractors.h b/tools/gn/config_values_extractors.h
index 4ac2840..5d248fb 100644
--- a/tools/gn/config_values_extractors.h
+++ b/tools/gn/config_values_extractors.h
@@ -25,7 +25,7 @@
 //
 // Example:
 //   for (ConfigValueIterator iter(target); !iter.done(); iter.Next())
-//     DoSomething(iter->cur());
+//     DoSomething(iter.cur());
 class ConfigValuesIterator {
  public:
   explicit ConfigValuesIterator(const Target* target)
diff --git a/tools/gn/config_values_generator.cc b/tools/gn/config_values_generator.cc
index f66ddfd..7eb7bc5 100644
--- a/tools/gn/config_values_generator.cc
+++ b/tools/gn/config_values_generator.cc
@@ -4,6 +4,7 @@
 
 #include "tools/gn/config_values_generator.h"
 
+#include "base/strings/string_util.h"
 #include "tools/gn/config_values.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/settings.h"
@@ -81,4 +82,34 @@
 
 #undef FILL_STRING_CONFIG_VALUE
 #undef FILL_DIR_CONFIG_VALUE
+
+  // Precompiled headers.
+  const Value* precompiled_header_value =
+      scope_->GetValue(variables::kPrecompiledHeader, true);
+  if (precompiled_header_value) {
+    if (!precompiled_header_value->VerifyTypeIs(Value::STRING, err_))
+      return;
+
+    // Check for common errors. This is a string and not a file.
+    const std::string& pch_string = precompiled_header_value->string_value();
+    if (base::StartsWith(pch_string, "//", base::CompareCase::SENSITIVE)) {
+      *err_ = Err(*precompiled_header_value,
+          "This precompiled_header value is wrong.",
+          "You need to specify a string that the compiler will match against\n"
+          "the #include lines rather than a GN-style file name.\n");
+      return;
+    }
+    config_values_->set_precompiled_header(pch_string);
+  }
+
+  const Value* precompiled_source_value =
+      scope_->GetValue(variables::kPrecompiledSource, true);
+  if (precompiled_source_value) {
+    config_values_->set_precompiled_source(
+        input_dir_.ResolveRelativeFile(
+            *precompiled_source_value, err_,
+            scope_->settings()->build_settings()->root_path_utf8()));
+    if (err_->has_error())
+      return;
+  }
 }
diff --git a/tools/gn/config_values_generator.h b/tools/gn/config_values_generator.h
index eb8a2e6..4e58010 100644
--- a/tools/gn/config_values_generator.h
+++ b/tools/gn/config_values_generator.h
@@ -43,6 +43,7 @@
 // For using in documentation for functions which use this.
 #define CONFIG_VALUES_VARS_HELP \
     "  Flags: cflags, cflags_c, cflags_cc, cflags_objc, cflags_objcc,\n" \
-    "         defines, include_dirs, ldflags, lib_dirs, libs\n"
+    "         defines, include_dirs, ldflags, lib_dirs, libs\n" \
+    "         precompiled_header, precompiled_source\n"
 
 #endif  // TOOLS_GN_CONFIG_VALUES_GENERATOR_H_
diff --git a/tools/gn/filesystem_utils.cc b/tools/gn/filesystem_utils.cc
index 6e1c01d..c98db86 100644
--- a/tools/gn/filesystem_utils.cc
+++ b/tools/gn/filesystem_utils.cc
@@ -744,7 +744,7 @@
     result.value().append(&source_dir.value()[2],
                           source_dir.value().size() - 2);
   } else {
-    // system-absolute
+    // System-absolute.
     const std::string& build_dir =
         settings->build_settings()->build_dir().value();
 
diff --git a/tools/gn/function_toolchain.cc b/tools/gn/function_toolchain.cc
index c4a7037..2fe5f53 100644
--- a/tools/gn/function_toolchain.cc
+++ b/tools/gn/function_toolchain.cc
@@ -114,6 +114,25 @@
   return true;
 }
 
+bool ReadPrecompiledHeaderType(Scope* scope, Tool* tool, Err* err) {
+  const Value* value = scope->GetValue("precompiled_header_type", true);
+  if (!value)
+    return true;  // Not present is fine.
+  if (!value->VerifyTypeIs(Value::STRING, err))
+    return false;
+
+  if (value->string_value().empty())
+    return true;  // Accept empty string, do nothing (default is "no PCH").
+
+  if (value->string_value() == "msvc") {
+    tool->set_precompiled_header_type(Tool::PCH_MSVC);
+    return true;
+  }
+  *err = Err(*value, "Invalid precompiled_header_type",
+             "Must either be empty or \"msvc\".");
+  return false;
+}
+
 bool ReadDepsFormat(Scope* scope, Tool* tool, Err* err) {
   const Value* value = scope->GetValue("depsformat", true);
   if (!value)
@@ -503,6 +522,20 @@
     "        Posix systems:\n"
     "          output_prefix = \"lib\"\n"
     "\n"
+    "    precompiled_header_type  [string]\n"
+    "        Valid for: \"cc\", \"cxx\", \"objc\", \"objcxx\"\n"
+    "\n"
+    "        Type of precompiled headers. If undefined or the empty string,\n"
+    "        precompiled headers will not be used for this tool. Otherwise\n"
+    "        use \"msvc\" which is the only currently supported value.\n"
+    "\n"
+    "        For precompiled headers to be used for a given target, the\n"
+    "        target (or a config applied to it) must also specify a\n"
+    "        \"precompiled_header\" and, for \"msvc\"-style headers, a\n"
+    "        \"precompiled_source\" value.\n"
+    "\n"
+    "        See \"gn help precompiled_header\" for more.\n"
+    "\n"
     "    restat  [boolean]\n"
     "        Valid for: all tools (optional, defaults to false)\n"
     "\n"
@@ -540,7 +573,7 @@
     "            rspfile_content = \"{{inputs}} {{solibs}} {{libs}}\"\n"
     "          }\n"
     "\n"
-    "Expansions for tool variables"
+    "Expansions for tool variables\n"
     "\n"
     "  All paths are relative to the root build directory, which is the\n"
     "  current directory for running all tools. These expansions are\n"
@@ -784,6 +817,7 @@
                    &Tool::set_depend_output, err) ||
       !ReadString(&block_scope, "output_prefix", tool.get(),
                   &Tool::set_output_prefix, err) ||
+      !ReadPrecompiledHeaderType(&block_scope, tool.get(), err) ||
       !ReadBool(&block_scope, "restat", tool.get(), &Tool::set_restat, err) ||
       !ReadPattern(&block_scope, "rspfile", subst_validator, tool.get(),
                    &Tool::set_rspfile, err) ||
diff --git a/tools/gn/header_checker.cc b/tools/gn/header_checker.cc
index d055243..1141e6e 100644
--- a/tools/gn/header_checker.cc
+++ b/tools/gn/header_checker.cc
@@ -158,7 +158,7 @@
   for (const auto& file : files) {
     // Only check C-like source files (RC files also have includes).
     SourceFileType type = GetSourceFileType(file.first);
-    if (type != SOURCE_CC && type != SOURCE_H && type != SOURCE_C &&
+    if (type != SOURCE_CPP && type != SOURCE_H && type != SOURCE_C &&
         type != SOURCE_M && type != SOURCE_MM && type != SOURCE_RC)
       continue;
 
diff --git a/tools/gn/ninja_binary_target_writer.cc b/tools/gn/ninja_binary_target_writer.cc
index 680c0d9..7b81bfa 100644
--- a/tools/gn/ninja_binary_target_writer.cc
+++ b/tools/gn/ninja_binary_target_writer.cc
@@ -4,6 +4,7 @@
 
 #include "tools/gn/ninja_binary_target_writer.h"
 
+#include <cstring>
 #include <set>
 #include <sstream>
 
@@ -12,12 +13,33 @@
 #include "tools/gn/deps_iterator.h"
 #include "tools/gn/err.h"
 #include "tools/gn/escape.h"
+#include "tools/gn/filesystem_utils.h"
 #include "tools/gn/ninja_utils.h"
 #include "tools/gn/settings.h"
+#include "tools/gn/source_file_type.h"
 #include "tools/gn/string_utils.h"
 #include "tools/gn/substitution_writer.h"
 #include "tools/gn/target.h"
 
+// Represents a set of tool types. Must be first since it is also shared by
+// some helper functions in the anonymous namespace below.
+class NinjaBinaryTargetWriter::SourceFileTypeSet {
+ public:
+  SourceFileTypeSet() {
+    memset(flags_, 0, sizeof(bool) * static_cast<int>(SOURCE_NUMTYPES));
+  }
+
+  void Set(SourceFileType type) {
+    flags_[static_cast<int>(type)] = true;
+  }
+  bool Get(SourceFileType type) const {
+    return flags_[static_cast<int>(type)];
+  }
+
+ private:
+  bool flags_[static_cast<int>(SOURCE_NUMTYPES)];
+};
+
 namespace {
 
 // Returns the proper escape options for writing compiler and linker flags.
@@ -65,31 +87,231 @@
   PathOutput& path_output_;
 };
 
+// Computes the set of output files resulting from compiling the given source
+// file. If the file can be compiled and the tool exists, fills the outputs in
+// and writes the tool type to computed_tool_type. If the file is not
+// compilable, returns false.
+//
+// The target that the source belongs to is passed as an argument. In the case
+// of linking to source sets, this can be different than the target this class
+// is currently writing.
+//
+// The function can succeed with a "NONE" tool type for object files which are
+// just passed to the output. The output will always be overwritten, not
+// appended to.
+bool GetOutputFilesForSource(const Target* target,
+                             const SourceFile& source,
+                             Toolchain::ToolType* computed_tool_type,
+                             std::vector<OutputFile>* outputs) {
+  outputs->clear();
+  *computed_tool_type = Toolchain::TYPE_NONE;
+
+  SourceFileType file_type = GetSourceFileType(source);
+  if (file_type == SOURCE_UNKNOWN)
+    return false;
+  if (file_type == SOURCE_O) {
+    // Object files just get passed to the output and not compiled.
+    outputs->push_back(
+        OutputFile(target->settings()->build_settings(), source));
+    return true;
+  }
+
+  *computed_tool_type =
+      target->toolchain()->GetToolTypeForSourceType(file_type);
+  if (*computed_tool_type == Toolchain::TYPE_NONE)
+    return false;  // No tool for this file (it's a header file or something).
+  const Tool* tool = target->toolchain()->GetTool(*computed_tool_type);
+  if (!tool)
+    return false;  // Tool does not apply for this toolchain.file.
+
+  // Figure out what output(s) this compiler produces.
+  SubstitutionWriter::ApplyListToCompilerAsOutputFile(
+      target, source, tool->outputs(), outputs);
+  return !outputs->empty();
+}
+
+// Returns the language-specific prefix/suffix for precomiled header files.
+const char* GetPCHLangForToolType(Toolchain::ToolType type) {
+  switch (type) {
+    case Toolchain::TYPE_CC:
+      return "c";
+    case Toolchain::TYPE_CXX:
+      return "cc";
+    case Toolchain::TYPE_OBJC:
+      return "m";
+    case Toolchain::TYPE_OBJCXX:
+      return "mm";
+    default:
+      NOTREACHED() << "Not a valid PCH tool type type";
+      return "";
+  }
+}
+
+// Returns the object files for the precompiled header of the given type (flag
+// type and tool type must match).
+void GetWindowsPCHObjectFiles(const Target* target,
+                              Toolchain::ToolType tool_type,
+                              std::vector<OutputFile>* outputs) {
+  outputs->clear();
+
+  // Compute the tool. This must use the tool type passed in rather than the
+  // detected file type of the precompiled source file since the same
+  // precompiled source file will be used for separate C/C++ compiles.
+  const Tool* tool = target->toolchain()->GetTool(tool_type);
+  if (!tool)
+    return;
+  SubstitutionWriter::ApplyListToCompilerAsOutputFile(
+      target, target->config_values().precompiled_source(),
+      tool->outputs(), outputs);
+
+  if (outputs->empty())
+    return;
+  if (outputs->size() > 1)
+    outputs->resize(1);  // Only link the first output from the compiler tool.
+
+  // Need to annotate the obj files with the language type. For example:
+  //   obj/foo/target_name.precompile.obj ->
+  //   obj/foo/target_name.precompile.cc.obj
+  const char* lang_suffix = GetPCHLangForToolType(tool_type);
+  std::string& output_value = (*outputs)[0].value();
+  size_t extension_offset = FindExtensionOffset(output_value);
+  if (extension_offset == std::string::npos) {
+    NOTREACHED() << "No extension found";
+  } else {
+    DCHECK(extension_offset >= 1);
+    DCHECK(output_value[extension_offset - 1] == '.');
+    output_value.insert(extension_offset - 1, ".");
+    output_value.insert(extension_offset, lang_suffix);
+  }
+}
+
+// Appends the object files generated by the given source set to the given
+// output vector.
+void AddSourceSetObjectFiles(const Target* source_set,
+                             UniqueVector<OutputFile>* obj_files) {
+  std::vector<OutputFile> tool_outputs;  // Prevent allocation in loop.
+  NinjaBinaryTargetWriter::SourceFileTypeSet used_types;
+
+  // Compute object files for all sources. Only link the first output from
+  // the tool if there are more than one.
+  for (const auto& source : source_set->sources()) {
+    Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
+    if (GetOutputFilesForSource(source_set, source, &tool_type, &tool_outputs))
+      obj_files->push_back(tool_outputs[0]);
+
+    used_types.Set(GetSourceFileType(source));
+  }
+
+  // Precompiled header object files.
+  if (source_set->config_values().has_precompiled_headers()) {
+    if (used_types.Get(SOURCE_C)) {
+      GetWindowsPCHObjectFiles(source_set, Toolchain::TYPE_CC, &tool_outputs);
+      obj_files->Append(tool_outputs.begin(), tool_outputs.end());
+    }
+    if (used_types.Get(SOURCE_CPP)) {
+      GetWindowsPCHObjectFiles(source_set, Toolchain::TYPE_CXX, &tool_outputs);
+      obj_files->Append(tool_outputs.begin(), tool_outputs.end());
+    }
+    if (used_types.Get(SOURCE_M)) {
+      GetWindowsPCHObjectFiles(source_set, Toolchain::TYPE_OBJC, &tool_outputs);
+      obj_files->Append(tool_outputs.begin(), tool_outputs.end());
+    }
+    if (used_types.Get(SOURCE_MM)) {
+      GetWindowsPCHObjectFiles(source_set, Toolchain::TYPE_OBJCXX,
+                               &tool_outputs);
+      obj_files->Append(tool_outputs.begin(), tool_outputs.end());
+    }
+  }
+}
+
 }  // namespace
 
 NinjaBinaryTargetWriter::NinjaBinaryTargetWriter(const Target* target,
                                                  std::ostream& out)
     : NinjaTargetWriter(target, out),
-      tool_(target->toolchain()->GetToolForTargetFinalOutput(target)) {
+      tool_(target->toolchain()->GetToolForTargetFinalOutput(target)),
+      rule_prefix_(GetNinjaRulePrefixForToolchain(settings_)) {
 }
 
 NinjaBinaryTargetWriter::~NinjaBinaryTargetWriter() {
 }
 
 void NinjaBinaryTargetWriter::Run() {
-  WriteCompilerVars();
+  // Figure out what source types are needed.
+  SourceFileTypeSet used_types;
+  for (const auto& source : target_->sources())
+    used_types.Set(GetSourceFileType(source));
 
+  WriteCompilerVars(used_types);
+
+  // The input dependencies will be an order-only dependency. This will cause
+  // Ninja to make sure the inputs are up-to-date before compiling this source,
+  // but changes in the inputs deps won't cause the file to be recompiled.
+  //
+  // This is important to prevent changes in unrelated actions that are
+  // upstream of this target from causing everything to be recompiled
+  //
+  // Why can we get away with this rather than using implicit deps ("|", which
+  // will force rebuilds when the inputs change)?  For source code, the
+  // computed dependencies of all headers will be computed by the compiler,
+  // which will cause source rebuilds if any "real" upstream dependencies
+  // change.
+  //
+  // If a .cc file is generated by an input dependency, Ninja will see the
+  // input to the build rule doesn't exist, and that it is an output from a
+  // previous step, and build the previous step first. This is a "real"
+  // dependency and doesn't need | or || to express.
+  //
+  // The only case where this rule matters is for the first build where no .d
+  // files exist, and Ninja doesn't know what that source file depends on. In
+  // this case it's sufficient to ensure that the upstream dependencies are
+  // built first. This is exactly what Ninja's order-only dependencies
+  // expresses.
+  OutputFile order_only_dep =
+      WriteInputDepsStampAndGetDep(std::vector<const Target*>());
+
+  std::vector<OutputFile> pch_obj_files;
+  WritePrecompiledHeaderCommands(used_types, order_only_dep, &pch_obj_files);
+
+  // Treat all precompiled object files as explicit dependencies of all
+  // compiles. Some notes:
+  //
+  //  - Technically only the language-specific one is required for any specific
+  //    compile, but that's more difficult to express and the additional logic
+  //    doesn't buy much reduced parallelism. Just list them all (there's
+  //    usually only one anyway).
+  //
+  //  - Technically the .pch file is the input to the compile, not the
+  //    precompiled header's corresponding object file that we're using here.
+  //    But Ninja's depslog doesn't support multiple outputs from the
+  //    precompiled header compile step (it outputs both the .pch file and a
+  //    corresponding .obj file). So we consistently list the .obj file and the
+  //    .pch file we really need comes along with it.
   std::vector<OutputFile> obj_files;
   std::vector<SourceFile> other_files;
-  WriteSources(&obj_files, &other_files);
+  WriteSources(pch_obj_files, order_only_dep, &obj_files, &other_files);
 
-  if (target_->output_type() == Target::SOURCE_SET)
+  // Also link all pch object files.
+  obj_files.insert(obj_files.end(), pch_obj_files.begin(), pch_obj_files.end());
+
+  if (target_->output_type() == Target::SOURCE_SET) {
     WriteSourceSetStamp(obj_files);
-  else
+#ifndef NDEBUG
+    // Verify that the function that separately computes a source set's object
+    // files match the object files just computed.
+    UniqueVector<OutputFile> computed_obj;
+    AddSourceSetObjectFiles(target_, &computed_obj);
+    DCHECK_EQ(obj_files.size(), computed_obj.size());
+    for (const auto& obj : obj_files)
+      DCHECK_NE(static_cast<size_t>(-1), computed_obj.IndexOf(obj));
+#endif
+  } else {
     WriteLinkerStuff(obj_files, other_files);
+  }
 }
 
-void NinjaBinaryTargetWriter::WriteCompilerVars() {
+void NinjaBinaryTargetWriter::WriteCompilerVars(
+    const SourceFileTypeSet& used_types) {
   const SubstitutionBits& subst = target_->toolchain()->substitution_bits();
 
   // Defines.
@@ -113,36 +335,134 @@
     out_ << std::endl;
   }
 
-  // C flags and friends.
-  EscapeOptions flag_escape_options = GetFlagOptions();
-#define WRITE_FLAGS(name, subst_enum) \
-    if (subst.used[subst_enum]) { \
-      out_ << kSubstitutionNinjaNames[subst_enum] << " ="; \
-      RecursiveTargetConfigStringsToStream(target_, &ConfigValues::name, \
-                                           flag_escape_options, out_); \
-      out_ << std::endl; \
-    }
+  bool has_precompiled_headers =
+      target_->config_values().has_precompiled_headers();
 
-  WRITE_FLAGS(cflags, SUBSTITUTION_CFLAGS)
-  WRITE_FLAGS(cflags_c, SUBSTITUTION_CFLAGS_C)
-  WRITE_FLAGS(cflags_cc, SUBSTITUTION_CFLAGS_CC)
-  WRITE_FLAGS(cflags_objc, SUBSTITUTION_CFLAGS_OBJC)
-  WRITE_FLAGS(cflags_objcc, SUBSTITUTION_CFLAGS_OBJCC)
-
-#undef WRITE_FLAGS
+  // Some toolchains pass cflags to the assembler since it's the same command,
+  // and cflags_c might also be sent to the objective C compiler.
+  //
+  // TODO(brettw) remove the SOURCE_M from the CFLAGS_C writing once the Chrome
+  // Mac build is updated not to pass cflags_c to .m files.
+  EscapeOptions opts = GetFlagOptions();
+  if (used_types.Get(SOURCE_C) || used_types.Get(SOURCE_CPP) ||
+      used_types.Get(SOURCE_M) || used_types.Get(SOURCE_MM) ||
+      used_types.Get(SOURCE_ASM)) {
+    WriteOneFlag(SUBSTITUTION_CFLAGS, false, Toolchain::TYPE_NONE,
+                 &ConfigValues::cflags, opts);
+  }
+  if (used_types.Get(SOURCE_C) || used_types.Get(SOURCE_M) ||
+      used_types.Get(SOURCE_ASM)) {
+    WriteOneFlag(SUBSTITUTION_CFLAGS_C, has_precompiled_headers,
+                 Toolchain::TYPE_CC, &ConfigValues::cflags_c, opts);
+  }
+  if (used_types.Get(SOURCE_CPP)) {
+    WriteOneFlag(SUBSTITUTION_CFLAGS_CC, has_precompiled_headers,
+                 Toolchain::TYPE_CXX, &ConfigValues::cflags_cc, opts);
+  }
+  if (used_types.Get(SOURCE_M)) {
+    WriteOneFlag(SUBSTITUTION_CFLAGS_OBJC, has_precompiled_headers,
+                 Toolchain::TYPE_OBJC, &ConfigValues::cflags_objc, opts);
+  }
+  if (used_types.Get(SOURCE_MM)) {
+    WriteOneFlag(SUBSTITUTION_CFLAGS_OBJCC, has_precompiled_headers,
+                 Toolchain::TYPE_OBJCXX, &ConfigValues::cflags_objcc, opts);
+  }
 
   WriteSharedVars(subst);
 }
 
+void NinjaBinaryTargetWriter::WriteOneFlag(
+    SubstitutionType subst_enum,
+    bool has_precompiled_headers,
+    Toolchain::ToolType tool_type,
+    const std::vector<std::string>& (ConfigValues::* getter)() const,
+    EscapeOptions flag_escape_options) {
+  if (!target_->toolchain()->substitution_bits().used[subst_enum])
+    return;
+
+  out_ << kSubstitutionNinjaNames[subst_enum] << " =";
+
+  if (has_precompiled_headers) {
+    const Tool* tool = target_->toolchain()->GetTool(tool_type);
+    if (tool && tool->precompiled_header_type() == Tool::PCH_MSVC) {
+      // Name the .pch file.
+      out_ << " /Fp";
+      path_output_.WriteFile(out_, GetWindowsPCHFile(tool_type));
+
+      // Enables precompiled headers and names the .h file. It's a string
+      // rather than a file name (so no need to rebase or use path_output_).
+      out_ << " /Yu" << target_->config_values().precompiled_header();
+    }
+  }
+
+  RecursiveTargetConfigStringsToStream(target_, getter,
+                                       flag_escape_options, out_);
+  out_ << std::endl;
+}
+
+void NinjaBinaryTargetWriter::WritePrecompiledHeaderCommands(
+    const SourceFileTypeSet& used_types,
+    const OutputFile& order_only_dep,
+    std::vector<OutputFile>* object_files) {
+  if (!target_->config_values().has_precompiled_headers())
+    return;
+
+  const Tool* tool_c = target_->toolchain()->GetTool(Toolchain::TYPE_CC);
+  if (tool_c &&
+      tool_c->precompiled_header_type() == Tool::PCH_MSVC &&
+      used_types.Get(SOURCE_C)) {
+    WriteWindowsPCHCommand(SUBSTITUTION_CFLAGS_C,
+                           Toolchain::TYPE_CC,
+                           order_only_dep, object_files);
+  }
+  const Tool* tool_cxx = target_->toolchain()->GetTool(Toolchain::TYPE_CXX);
+  if (tool_cxx &&
+      tool_cxx->precompiled_header_type() == Tool::PCH_MSVC &&
+      used_types.Get(SOURCE_CPP)) {
+    WriteWindowsPCHCommand(SUBSTITUTION_CFLAGS_CC,
+                           Toolchain::TYPE_CXX,
+                           order_only_dep, object_files);
+  }
+}
+
+void NinjaBinaryTargetWriter::WriteWindowsPCHCommand(
+    SubstitutionType flag_type,
+    Toolchain::ToolType tool_type,
+    const OutputFile& order_only_dep,
+    std::vector<OutputFile>* object_files) {
+  // Compute the object file (it will be language-specific).
+  std::vector<OutputFile> outputs;
+  GetWindowsPCHObjectFiles(target_, tool_type, &outputs);
+  if (outputs.empty())
+    return;
+  object_files->insert(object_files->end(), outputs.begin(), outputs.end());
+
+  // Build line to compile the file.
+  WriteCompilerBuildLine(target_->config_values().precompiled_source(),
+                         std::vector<OutputFile>(), order_only_dep, tool_type,
+                         outputs);
+
+  // This build line needs a custom language-specific flags value. It needs to
+  // include the switch to generate the .pch file in addition to the normal
+  // ones. Rule-specific variables are just indented underneath the rule line,
+  // and this defines the new one in terms of the old value.
+  out_ << "  " << kSubstitutionNinjaNames[flag_type] << " =";
+  out_ << " ${" << kSubstitutionNinjaNames[flag_type] << "}";
+
+  // Append the command to generate the .pch file.
+  out_ << " /Yc" << target_->config_values().precompiled_header();
+
+  // Write two blank lines to help separate the PCH build lines from the
+  // regular source build lines.
+  out_ << std::endl << std::endl;
+}
+
 void NinjaBinaryTargetWriter::WriteSources(
+    const std::vector<OutputFile>& extra_deps,
+    const OutputFile& order_only_dep,
     std::vector<OutputFile>* object_files,
     std::vector<SourceFile>* other_files) {
-  object_files->reserve(target_->sources().size());
-
-  OutputFile input_dep =
-      WriteInputDepsStampAndGetDep(std::vector<const Target*>());
-
-  std::string rule_prefix = GetNinjaRulePrefixForToolchain(settings_);
+  object_files->reserve(object_files->size() + target_->sources().size());
 
   std::vector<OutputFile> tool_outputs;  // Prevent reallocation in loop.
   for (const auto& source : target_->sources()) {
@@ -154,41 +474,8 @@
     }
 
     if (tool_type != Toolchain::TYPE_NONE) {
-      out_ << "build";
-      path_output_.WriteFiles(out_, tool_outputs);
-
-      out_ << ": " << rule_prefix << Toolchain::ToolTypeToName(tool_type);
-      out_ << " ";
-      path_output_.WriteFile(out_, source);
-      if (!input_dep.value().empty()) {
-        // Write out the input dependencies as an order-only dependency. This
-        // will cause Ninja to make sure the inputs are up-to-date before
-        // compiling this source, but changes in the inputs deps won't cause
-        // the file to be recompiled.
-        //
-        // This is important to prevent changes in unrelated actions that
-        // are upstream of this target from causing everything to be recompiled.
-        //
-        // Why can we get away with this rather than using implicit deps ("|",
-        // which will force rebuilds when the inputs change)?  For source code,
-        // the computed dependencies of all headers will be computed by the
-        // compiler, which will cause source rebuilds if any "real" upstream
-        // dependencies change.
-        //
-        // If a .cc file is generated by an input dependency, Ninja will see
-        // the input to the build rule doesn't exist, and that it is an output
-        // from a previous step, and build the previous step first.  This is a
-        // "real" dependency and doesn't need | or || to express.
-        //
-        // The only case where this rule matters is for the first build where
-        // no .d files exist, and Ninja doesn't know what that source file
-        // depends on. In this case it's sufficient to ensure that the upstream
-        // dependencies are built first. This is exactly what Ninja's order-
-        // only dependencies expresses.
-        out_ << " || ";
-        path_output_.WriteFile(out_, input_dep);
-      }
-      out_ << std::endl;
+      WriteCompilerBuildLine(source, extra_deps, order_only_dep, tool_type,
+                             tool_outputs);
     }
 
     // It's theoretically possible for a compiler to produce more than one
@@ -198,6 +485,34 @@
   out_ << std::endl;
 }
 
+void NinjaBinaryTargetWriter::WriteCompilerBuildLine(
+    const SourceFile& source,
+    const std::vector<OutputFile>& extra_deps,
+    const OutputFile& order_only_dep,
+    Toolchain::ToolType tool_type,
+    const std::vector<OutputFile>& outputs) {
+  out_ << "build";
+  path_output_.WriteFiles(out_, outputs);
+
+  out_ << ": " << rule_prefix_ << Toolchain::ToolTypeToName(tool_type);
+  out_ << " ";
+  path_output_.WriteFile(out_, source);
+
+  if (!extra_deps.empty()) {
+    out_ << " |";
+    for (const OutputFile& dep : extra_deps) {
+      out_ << " ";
+      path_output_.WriteFile(out_, dep);
+    }
+  }
+
+  if (!order_only_dep.value().empty()) {
+    out_ << " || ";
+    path_output_.WriteFile(out_, order_only_dep);
+  }
+  out_ << std::endl;
+}
+
 void NinjaBinaryTargetWriter::WriteLinkerStuff(
     const std::vector<OutputFile>& object_files,
     const std::vector<SourceFile>& other_files) {
@@ -208,8 +523,7 @@
   out_ << "build";
   path_output_.WriteFiles(out_, output_files);
 
-  out_ << ": "
-       << GetNinjaRulePrefixForToolchain(settings_)
+  out_ << ": " << rule_prefix_
        << Toolchain::ToolTypeToName(
               target_->toolchain()->GetToolTypeForTargetFinalOutput(target_));
 
@@ -219,18 +533,12 @@
   GetDeps(&extra_object_files, &linkable_deps, &non_linkable_deps);
 
   // Object files.
-  for (const auto& obj : object_files) {
-    out_ << " ";
-    path_output_.WriteFile(out_, obj);
-  }
-  for (const auto& obj : extra_object_files) {
-    out_ << " ";
-    path_output_.WriteFile(out_, obj);
-  }
+  path_output_.WriteFiles(out_, object_files);
+  path_output_.WriteFiles(out_, extra_object_files);
 
+  // Dependencies.
   std::vector<OutputFile> implicit_deps;
   std::vector<OutputFile> solibs;
-
   for (const Target* cur : linkable_deps) {
     // All linkable deps should have a link output file.
     DCHECK(!cur->link_output_file().value().empty())
@@ -442,18 +750,8 @@
     // just forward the dependency, otherwise the files in the source
     // set can easily get linked more than once which will cause
     // multiple definition errors.
-    if (can_link_libs) {
-      // Linking in a source set to an executable, shared library, or
-      // complete static library, so copy its object files.
-      std::vector<OutputFile> tool_outputs;  // Prevent allocation in loop.
-      for (const auto& source : dep->sources()) {
-        Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
-        if (GetOutputFilesForSource(dep, source, &tool_type, &tool_outputs)) {
-          // Only link the first output if there are more than one.
-          extra_object_files->push_back(tool_outputs[0]);
-        }
-      }
-    }
+    if (can_link_libs)
+      AddSourceSetObjectFiles(dep, extra_object_files);
 
     // Add the source set itself as a non-linkable dependency on the current
     // target. This will make sure that anything the source set's stamp file
@@ -481,33 +779,15 @@
   }
 }
 
-bool NinjaBinaryTargetWriter::GetOutputFilesForSource(
-    const Target* target,
-    const SourceFile& source,
-    Toolchain::ToolType* computed_tool_type,
-    std::vector<OutputFile>* outputs) const {
-  outputs->clear();
-  *computed_tool_type = Toolchain::TYPE_NONE;
+OutputFile NinjaBinaryTargetWriter::GetWindowsPCHFile(
+    Toolchain::ToolType tool_type) const {
+  // Use "obj/{dir}/{target_name}_{lang}.pch" which ends up
+  // looking like "obj/chrome/browser/browser.cc.pch"
+  OutputFile ret = GetTargetOutputDirAsOutputFile(target_);
+  ret.value().append(target_->label().name());
+  ret.value().push_back('_');
+  ret.value().append(GetPCHLangForToolType(tool_type));
+  ret.value().append(".pch");
 
-  SourceFileType file_type = GetSourceFileType(source);
-  if (file_type == SOURCE_UNKNOWN)
-    return false;
-  if (file_type == SOURCE_O) {
-    // Object files just get passed to the output and not compiled.
-    outputs->push_back(OutputFile(settings_->build_settings(), source));
-    return true;
-  }
-
-  *computed_tool_type =
-      target->toolchain()->GetToolTypeForSourceType(file_type);
-  if (*computed_tool_type == Toolchain::TYPE_NONE)
-    return false;  // No tool for this file (it's a header file or something).
-  const Tool* tool = target->toolchain()->GetTool(*computed_tool_type);
-  if (!tool)
-    return false;  // Tool does not apply for this toolchain.file.
-
-  // Figure out what output(s) this compiler produces.
-  SubstitutionWriter::ApplyListToCompilerAsOutputFile(
-      target, source, tool->outputs(), outputs);
-  return !outputs->empty();
+  return ret;
 }
diff --git a/tools/gn/ninja_binary_target_writer.h b/tools/gn/ninja_binary_target_writer.h
index 977e982..fe7a132 100644
--- a/tools/gn/ninja_binary_target_writer.h
+++ b/tools/gn/ninja_binary_target_writer.h
@@ -12,11 +12,14 @@
 #include "tools/gn/unique_vector.h"
 
 struct EscapeOptions;
+class SourceFileTypeSet;
 
 // Writes a .ninja file for a binary target type (an executable, a shared
 // library, or a static library).
 class NinjaBinaryTargetWriter : public NinjaTargetWriter {
  public:
+  class SourceFileTypeSet;
+
   NinjaBinaryTargetWriter(const Target* target, std::ostream& out);
   ~NinjaBinaryTargetWriter() override;
 
@@ -25,9 +28,57 @@
  private:
   typedef std::set<OutputFile> OutputFileSet;
 
-  void WriteCompilerVars();
-  void WriteSources(std::vector<OutputFile>* object_files,
+  // Writes all flags for the compiler: includes, defines, cflags, etc.
+  void WriteCompilerVars(const SourceFileTypeSet& used_types);
+
+  // has_precompiled_headers is set when this substitution matches a tool type
+  // that supports precompiled headers, and this target supports precompiled
+  // headers. It doesn't indicate if the tool has precompiled headers (this
+  // will be looked up by this function).
+  //
+  // The tool_type indicates the corresponding tool for flags that are
+  // tool-specific (e.g. "cflags_c"). For non-tool-specific flags (e.g.
+  // "defines") tool_type should be TYPE_NONE.
+  void WriteOneFlag(
+      SubstitutionType subst_enum,
+      bool has_precompiled_headers,
+      Toolchain::ToolType tool_type,
+      const std::vector<std::string>& (ConfigValues::* getter)() const,
+      EscapeOptions flag_escape_options);
+
+  // Writes build lines required for precompiled headers. Any generated
+  // object files will be appended to the given vector.
+  //
+  // input_dep is the stamp file collecting the dependencies required before
+  // compiling this target. It will be empty if there are no input deps.
+  void WritePrecompiledHeaderCommands(const SourceFileTypeSet& used_types,
+                                      const OutputFile& input_dep,
+                                      std::vector<OutputFile>* object_files);
+
+  // Writes a Windows .pch compile build line for a language type.
+  void WriteWindowsPCHCommand(SubstitutionType flag_type,
+                              Toolchain::ToolType tool_type,
+                              const OutputFile& input_dep,
+                              std::vector<OutputFile>* object_files);
+
+  // extra_deps are additional dependencies to run before the rule.
+  //
+  // iorder_only_dep is the name of the stamp file that covers the dependencies
+  // that must be run before doing any compiles.
+  //
+  // The files produced by the compiler will be added to two output vectors.
+  void WriteSources(const std::vector<OutputFile>& extra_deps,
+                    const OutputFile& order_only_dep,
+                    std::vector<OutputFile>* object_files,
                     std::vector<SourceFile>* other_files);
+
+  // Writes a build line.
+  void WriteCompilerBuildLine(const SourceFile& source,
+                              const std::vector<OutputFile>& extra_deps,
+                              const OutputFile& order_only_dep,
+                              Toolchain::ToolType tool_type,
+                              const std::vector<OutputFile>& outputs);
+
   void WriteLinkerStuff(const std::vector<OutputFile>& object_files,
                         const std::vector<SourceFile>& other_files);
   void WriteLinkerFlags(const SourceFile* optional_def_file);
@@ -61,25 +112,15 @@
   void WriteOrderOnlyDependencies(
       const UniqueVector<const Target*>& non_linkable_deps);
 
-  // Computes the set of output files resulting from compiling the given source
-  // file. If the file can be compiled and the tool exists, fills the outputs in
-  // and writes the tool type to computed_tool_type. If the file is not
-  // compilable, returns false.
-  //
-  // The target that the source belongs to is passed as an argument. In the
-  // case of linking to source sets, this can be different than the target
-  // this class is currently writing.
-  //
-  // The function can succeed with a "NONE" tool type for object files which are
-  // just passed to the output. The output will always be overwritten, not
-  // appended to.
-  bool GetOutputFilesForSource(const Target* target,
-                               const SourceFile& source,
-                               Toolchain::ToolType* computed_tool_type,
-                               std::vector<OutputFile>* outputs) const;
+  // Returns the computed name of the Windows .pch file for the given
+  // tool type. The tool must support precompiled headers.
+  OutputFile GetWindowsPCHFile(Toolchain::ToolType tool_type) const;
 
   const Tool* tool_;
 
+  // Cached version of the prefix used for rule types for this toolchain.
+  std::string rule_prefix_;
+
   DISALLOW_COPY_AND_ASSIGN(NinjaBinaryTargetWriter);
 };
 
diff --git a/tools/gn/ninja_binary_target_writer_unittest.cc b/tools/gn/ninja_binary_target_writer_unittest.cc
index f4e4065..2ad816a 100644
--- a/tools/gn/ninja_binary_target_writer_unittest.cc
+++ b/tools/gn/ninja_binary_target_writer_unittest.cc
@@ -38,10 +38,7 @@
         "defines =\n"
         "include_dirs =\n"
         "cflags =\n"
-        "cflags_c =\n"
         "cflags_cc =\n"
-        "cflags_objc =\n"
-        "cflags_objcc =\n"
         "root_out_dir = .\n"
         "target_out_dir = obj/foo\n"
         "target_output_name = bar\n"
@@ -70,11 +67,6 @@
     const char expected[] =
         "defines =\n"
         "include_dirs =\n"
-        "cflags =\n"
-        "cflags_c =\n"
-        "cflags_cc =\n"
-        "cflags_objc =\n"
-        "cflags_objcc =\n"
         "root_out_dir = .\n"
         "target_out_dir = obj/foo\n"
         "target_output_name = libshlib\n"
@@ -108,11 +100,6 @@
     const char expected[] =
         "defines =\n"
         "include_dirs =\n"
-        "cflags =\n"
-        "cflags_c =\n"
-        "cflags_cc =\n"
-        "cflags_objc =\n"
-        "cflags_objcc =\n"
         "root_out_dir = .\n"
         "target_out_dir = obj/foo\n"
         "target_output_name = libstlib\n"
@@ -138,11 +125,6 @@
     const char expected[] =
         "defines =\n"
         "include_dirs =\n"
-        "cflags =\n"
-        "cflags_c =\n"
-        "cflags_cc =\n"
-        "cflags_objc =\n"
-        "cflags_objcc =\n"
         "root_out_dir = .\n"
         "target_out_dir = obj/foo\n"
         "target_output_name = libstlib\n"
@@ -196,10 +178,7 @@
       "defines =\n"
       "include_dirs =\n"
       "cflags =\n"
-      "cflags_c =\n"
       "cflags_cc =\n"
-      "cflags_objc =\n"
-      "cflags_objcc =\n"
       "root_out_dir = .\n"
       "target_out_dir = obj/foo\n"
       "target_output_name = libshlib\n"
@@ -249,10 +228,7 @@
       "defines =\n"
       "include_dirs =\n"
       "cflags =\n"
-      "cflags_c =\n"
       "cflags_cc =\n"
-      "cflags_objc =\n"
-      "cflags_objcc =\n"
       "root_out_dir = .\n"
       "target_out_dir = obj/foo\n"
       "target_output_name = libshlib\n"
@@ -305,10 +281,7 @@
       "defines =\n"
       "include_dirs =\n"
       "cflags =\n"
-      "cflags_c =\n"
       "cflags_cc =\n"
-      "cflags_objc =\n"
-      "cflags_objcc =\n"
       "root_out_dir = .\n"
       "target_out_dir = obj/foo\n"
       "target_output_name = inter\n"
@@ -340,10 +313,7 @@
       "defines =\n"
       "include_dirs =\n"
       "cflags =\n"
-      "cflags_c =\n"
       "cflags_cc =\n"
-      "cflags_objc =\n"
-      "cflags_objcc =\n"
       "root_out_dir = .\n"
       "target_out_dir = obj/foo\n"
       "target_output_name = exe\n"
@@ -380,10 +350,7 @@
       "defines =\n"
       "include_dirs =\n"
       "cflags =\n"
-      "cflags_c =\n"
       "cflags_cc =\n"
-      "cflags_objc =\n"
-      "cflags_objcc =\n"
       "root_out_dir = .\n"
       "target_out_dir = obj/foo\n"
       "target_output_name = libbar\n"
@@ -396,3 +363,99 @@
       "  output_extension = .so\n";
   EXPECT_EQ(expected, out.str());
 }
+
+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"));
+
+  // 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);
+  pch_toolchain.SetTool(Toolchain::TYPE_CXX, cxx_tool.Pass());
+  pch_toolchain.ToolchainSetupComplete();
+
+  // This target doesn't specify precompiled headers.
+  {
+    Target no_pch_target(&pch_settings,
+                         Label(SourceDir("//foo/"), "no_pch_target"));
+    no_pch_target.set_output_type(Target::SOURCE_SET);
+    no_pch_target.visibility().SetPublic();
+    no_pch_target.sources().push_back(SourceFile("//foo/input1.cc"));
+    no_pch_target.SetToolchain(&pch_toolchain);
+    ASSERT_TRUE(no_pch_target.OnResolved(&err));
+
+    std::ostringstream out;
+    NinjaBinaryTargetWriter writer(&no_pch_target, out);
+    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"
+        "\n"
+        "build withpch/obj/foo/no_pch_target.stamp: "
+               "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"));
+    pch_target.set_output_type(Target::SOURCE_SET);
+    pch_target.visibility().SetPublic();
+    pch_target.sources().push_back(SourceFile("//foo/input1.cc"));
+    pch_target.SetToolchain(&pch_toolchain);
+    ASSERT_TRUE(pch_target.OnResolved(&err));
+
+    std::ostringstream out;
+    NinjaBinaryTargetWriter writer(&pch_target, out);
+    writer.Run();
+
+    const char pch_win_expected[] =
+        "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"
+        "  cflags_cc = ${cflags_cc} /Ycbuild/precompile.h\n"
+        "\n"
+        "build withpch/obj/foo/pch_target.input1.o: "
+               "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 "
+               // 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());
+  }
+}
diff --git a/tools/gn/path_output.cc b/tools/gn/path_output.cc
index 5b333d8..711341f 100644
--- a/tools/gn/path_output.cc
+++ b/tools/gn/path_output.cc
@@ -83,6 +83,14 @@
   }
 }
 
+void PathOutput::WriteFiles(std::ostream& out,
+                            const UniqueVector<OutputFile>& files) const {
+  for (const auto& file : files) {
+    out << " ";
+    WriteFile(out, file);
+  }
+}
+
 void PathOutput::WriteDir(std::ostream& out,
                           const OutputFile& file,
                           DirSlashEnding slash_ending) const {
diff --git a/tools/gn/path_output.h b/tools/gn/path_output.h
index f7beb42..46c1aa9 100644
--- a/tools/gn/path_output.h
+++ b/tools/gn/path_output.h
@@ -12,6 +12,7 @@
 #include "base/strings/string_piece.h"
 #include "tools/gn/escape.h"
 #include "tools/gn/source_dir.h"
+#include "tools/gn/unique_vector.h"
 
 class OutputFile;
 class SourceFile;
@@ -55,6 +56,8 @@
   // write an initial space before the first item.
   void WriteFiles(std::ostream& out,
                   const std::vector<OutputFile>& files) const;
+  void WriteFiles(std::ostream& out,
+                  const UniqueVector<OutputFile>& files) const;
 
   // This variant assumes the dir ends in a trailing slash or is empty.
   void WriteDir(std::ostream& out,
diff --git a/tools/gn/source_file_type.cc b/tools/gn/source_file_type.cc
index 2b34125..72b872c 100644
--- a/tools/gn/source_file_type.cc
+++ b/tools/gn/source_file_type.cc
@@ -10,7 +10,7 @@
 SourceFileType GetSourceFileType(const SourceFile& file) {
   base::StringPiece extension = FindExtension(&file.value());
   if (extension == "cc" || extension == "cpp" || extension == "cxx")
-    return SOURCE_CC;
+    return SOURCE_CPP;
   if (extension == "h")
     return SOURCE_H;
   if (extension == "c")
diff --git a/tools/gn/source_file_type.h b/tools/gn/source_file_type.h
index f738daa..c43b432 100644
--- a/tools/gn/source_file_type.h
+++ b/tools/gn/source_file_type.h
@@ -7,11 +7,13 @@
 
 class SourceFile;
 
+// This should be sequential integers starting from 0 so they can be used as
+// array indices.
 enum SourceFileType {
-  SOURCE_UNKNOWN,
+  SOURCE_UNKNOWN = 0,
   SOURCE_ASM,
   SOURCE_C,
-  SOURCE_CC,
+  SOURCE_CPP,
   SOURCE_H,
   SOURCE_M,
   SOURCE_MM,
@@ -19,6 +21,9 @@
   SOURCE_RC,
   SOURCE_O,  // Object files can be inputs, too. Also counts .obj.
   SOURCE_DEF,
+
+  // Must be last.
+  SOURCE_NUMTYPES,
 };
 
 SourceFileType GetSourceFileType(const SourceFile& file);
diff --git a/tools/gn/target.cc b/tools/gn/target.cc
index 0b189e6..a7a3d07 100644
--- a/tools/gn/target.cc
+++ b/tools/gn/target.cc
@@ -170,6 +170,8 @@
   PullDependentTargets();
   PullForwardedDependentConfigs();
   PullRecursiveHardDeps();
+  if (!ResolvePrecompiledHeaders(err))
+    return false;
 
   FillOutputFiles();
 
@@ -215,12 +217,12 @@
   std::string result;
   if (include_prefix) {
     const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
-    const std::string& prefix = tool->output_prefix();
-    // Only add the prefix if the name doesn't already have it.
-    if (!base::StartsWithASCII(name, prefix, true))
-      result = prefix;
+    if (tool) {
+      // Only add the prefix if the name doesn't already have it.
+      if (!base::StartsWithASCII(name, tool->output_prefix(), true))
+        result = tool->output_prefix();
+    }
   }
-
   result.append(name);
   return result;
 }
@@ -429,6 +431,60 @@
     computed_outputs_.push_back(OutputFile(settings()->build_settings(), out));
 }
 
+bool Target::ResolvePrecompiledHeaders(Err* err) {
+  // Precompiled headers are stored on a ConfigValues struct. This way, the
+  // build can set all the precompiled header settings in a config and apply
+  // it to many targets. Likewise, the precompiled header values may be
+  // specified directly on a target.
+  //
+  // Unlike other values on configs which are lists that just get concatenated,
+  // the precompiled header settings are unique values. We allow them to be
+  // specified anywhere, but if they are specified in more than one place all
+  // places must match.
+
+  // Track where the current settings came from for issuing errors.
+  const Label* pch_header_settings_from = NULL;
+  if (config_values_.has_precompiled_headers())
+    pch_header_settings_from = &label();
+
+  for (ConfigValuesIterator iter(this); !iter.done(); iter.Next()) {
+    if (!iter.GetCurrentConfig())
+      continue;  // Skip the one on the target itself.
+
+    const Config* config = iter.GetCurrentConfig();
+    const ConfigValues& cur = config->config_values();
+    if (!cur.has_precompiled_headers())
+      continue;  // This one has no precompiled header info, skip.
+
+    if (config_values_.has_precompiled_headers()) {
+      // Already have a precompiled header values, the settings must match.
+      if (config_values_.precompiled_header() != cur.precompiled_header() ||
+          config_values_.precompiled_source() != cur.precompiled_source()) {
+        *err = Err(defined_from(),
+            "Precompiled header setting conflict.",
+            "The target " + label().GetUserVisibleName(false) + "\n"
+            "has conflicting precompiled header settings.\n"
+            "\n"
+            "From " + pch_header_settings_from->GetUserVisibleName(false) +
+            "\n  header: " + config_values_.precompiled_header() +
+            "\n  source: " + config_values_.precompiled_source().value() +
+            "\n\n"
+            "From " + config->label().GetUserVisibleName(false) +
+            "\n  header: " + cur.precompiled_header() +
+            "\n  source: " + cur.precompiled_source().value());
+        return false;
+      }
+    } else {
+      // Have settings from a config, apply them to ourselves.
+      pch_header_settings_from = &config->label();
+      config_values_.set_precompiled_header(cur.precompiled_header());
+      config_values_.set_precompiled_source(cur.precompiled_source());
+    }
+  }
+
+  return true;
+}
+
 bool Target::CheckVisibility(Err* err) const {
   for (const auto& pair : GetDeps(DEPS_ALL)) {
     if (!Visibility::CheckItemVisibility(this, pair.ptr, err))
diff --git a/tools/gn/target.h b/tools/gn/target.h
index 58319f1..e8758b7 100644
--- a/tools/gn/target.h
+++ b/tools/gn/target.h
@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "base/synchronization/lock.h"
@@ -252,6 +253,8 @@
   }
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(Target, ResolvePrecompiledHeaders);
+
   // Pulls necessary information from dependencies to this one when all
   // dependencies have been resolved.
   void PullDependentTarget(const Target* dep, bool is_public);
@@ -266,6 +269,10 @@
   // Fills the link and dependency output files when a target is resolved.
   void FillOutputFiles();
 
+  // Checks precompiled headers from configs and makes sure the resulting
+  // values are in config_values_.
+  bool ResolvePrecompiledHeaders(Err* err);
+
   // Validates the given thing when a target is resolved.
   bool CheckVisibility(Err* err) const;
   bool CheckTestonly(Err* err) const;
@@ -310,8 +317,13 @@
   // target is marked resolved. This will not include the current target.
   std::set<const Target*> recursive_hard_deps_;
 
-  ConfigValues config_values_;  // Used for all binary targets.
-  ActionValues action_values_;  // Used for action[_foreach] targets.
+  // Used for all binary targets. The precompiled header values in this struct
+  // will be resolved to the ones to use for this target, if precompiled
+  // headers are used.
+  ConfigValues config_values_;
+
+  // Used for action[_foreach] targets.
+  ActionValues action_values_;
 
   // Toolchain used by this target. Null until target is resolved.
   const Toolchain* toolchain_;
diff --git a/tools/gn/target_unittest.cc b/tools/gn/target_unittest.cc
index 48fb84c..c9e0b1e 100644
--- a/tools/gn/target_unittest.cc
+++ b/tools/gn/target_unittest.cc
@@ -558,3 +558,58 @@
   // Should be OK.
   EXPECT_TRUE(scheduler.GetUnknownGeneratedInputs().empty());
 }
+
+TEST(Target, ResolvePrecompiledHeaders) {
+  TestWithScope setup;
+  Err err;
+
+  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);
+  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);
+  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());
+}
diff --git a/tools/gn/test_with_scope.cc b/tools/gn/test_with_scope.cc
index 847af62..d37b722 100644
--- a/tools/gn/test_with_scope.cc
+++ b/tools/gn/test_with_scope.cc
@@ -8,19 +8,6 @@
 #include "tools/gn/parser.h"
 #include "tools/gn/tokenizer.h"
 
-namespace {
-
-void SetCommandForTool(const std::string& cmd, Tool* tool) {
-  Err err;
-  SubstitutionPattern command;
-  command.Parse(cmd, nullptr, &err);
-  CHECK(!err.has_error())
-      << "Couldn't parse \"" << cmd << "\", " << "got " << err.message();
-  tool->set_command(command);
-}
-
-}  // namespace
-
 TestWithScope::TestWithScope()
     : build_settings_(),
       settings_(&build_settings_, std::string()),
@@ -132,6 +119,16 @@
   toolchain->ToolchainSetupComplete();
 }
 
+// static
+void TestWithScope::SetCommandForTool(const std::string& cmd, Tool* tool) {
+  Err err;
+  SubstitutionPattern command;
+  command.Parse(cmd, nullptr, &err);
+  CHECK(!err.has_error())
+      << "Couldn't parse \"" << cmd << "\", " << "got " << err.message();
+  tool->set_command(command);
+}
+
 void TestWithScope::AppendPrintOutput(const std::string& str) {
   print_output_.append(str);
 }
diff --git a/tools/gn/test_with_scope.h b/tools/gn/test_with_scope.h
index 79c6a08..e390df8 100644
--- a/tools/gn/test_with_scope.h
+++ b/tools/gn/test_with_scope.h
@@ -43,9 +43,14 @@
   // Fills in the tools for the given toolchain with reasonable default values.
   // The toolchain in this object will be automatically set up with this
   // function, it is exposed to allow tests to get the same functionality for
-  // other toolchains they make
+  // other toolchains they make.
   static void SetupToolchain(Toolchain* toolchain);
 
+  // Sets the given text command on the given tool, parsing it as a
+  // substitution pattern. This will assert if the input is malformed. This is
+  // designed to help setting up Tools for tests.
+  static void SetCommandForTool(const std::string& cmd, Tool* tool);
+
  private:
   void AppendPrintOutput(const std::string& str);
 
diff --git a/tools/gn/tool.cc b/tools/gn/tool.cc
index b549283..139c032 100644
--- a/tools/gn/tool.cc
+++ b/tools/gn/tool.cc
@@ -6,6 +6,7 @@
 
 Tool::Tool()
     : depsformat_(DEPS_GCC),
+      precompiled_header_type_(PCH_NONE),
       restat_(false),
       complete_(false) {
 }
diff --git a/tools/gn/tool.h b/tools/gn/tool.h
index 14a64c1..b9575bc 100644
--- a/tools/gn/tool.h
+++ b/tools/gn/tool.h
@@ -19,6 +19,11 @@
     DEPS_MSVC = 1
   };
 
+  enum PrecompiledHeaderType {
+    PCH_NONE = 0,
+    PCH_MSVC = 1
+  };
+
   Tool();
   ~Tool();
 
@@ -63,6 +68,13 @@
     depsformat_ = f;
   }
 
+  PrecompiledHeaderType precompiled_header_type() const {
+    return precompiled_header_type_;
+  }
+  void set_precompiled_header_type(PrecompiledHeaderType pch_type) {
+    precompiled_header_type_ = pch_type;
+  }
+
   const SubstitutionPattern& description() const {
     return description_;
   }
@@ -167,6 +179,7 @@
   std::string default_output_extension_;
   SubstitutionPattern depfile_;
   DepsFormat depsformat_;
+  PrecompiledHeaderType precompiled_header_type_;
   SubstitutionPattern description_;
   std::string lib_switch_;
   std::string lib_dir_switch_;
diff --git a/tools/gn/toolchain.cc b/tools/gn/toolchain.cc
index 8ec2c2d..cdd70c0 100644
--- a/tools/gn/toolchain.cc
+++ b/tools/gn/toolchain.cc
@@ -102,7 +102,7 @@
   switch (type) {
     case SOURCE_C:
       return TYPE_CC;
-    case SOURCE_CC:
+    case SOURCE_CPP:
       return TYPE_CXX;
     case SOURCE_M:
       return TYPE_OBJC;
diff --git a/tools/gn/variables.cc b/tools/gn/variables.cc
index 51a68d5..472554a 100644
--- a/tools/gn/variables.cc
+++ b/tools/gn/variables.cc
@@ -854,6 +854,76 @@
     "  file(s). For actions, the outputs should be the list of files\n"
     "  generated by the script.\n";
 
+const char kPrecompiledHeader[] = "precompiled_header";
+const char kPrecompiledHeader_HelpShort[] =
+    "precompiled_header: [string] Header file to precompile.";
+const char kPrecompiledHeader_Help[] =
+    "precompiled_header: [string] Header file to precompile.\n"
+    "\n"
+    "  Precompiled headers will be used when a target specifies this\n"
+    "  value, or a config applying to this target specifies this value.\n"
+    "  In addition, the tool corresponding to the source files must also\n"
+    "  specify precompiled headers (see \"gn help tool\"). The tool\n"
+    "  will also specify what type of precompiled headers to use.\n"
+    "\n"
+    "  The precompiled header/source variables can be specified on a target\n"
+    "  or a config, but must be the same for all configs applying to a given\n"
+    "  target since a target can only have one precompiled header.\n"
+    "\n"
+    "MSVC precompiled headers\n"
+    "\n"
+    "  When using MSVC-style precompiled headers, the \"precompiled_header\"\n"
+    "  value is a string corresponding to the header. This is NOT a path\n"
+    "  to a file that GN recognises, but rather the exact string that appears\n"
+    "  in quotes after an #include line in source code. The compiler will\n"
+    "  match this string against includes or forced includes (/FI).\n"
+    "\n"
+    "  MSVC also requires a source file to compile the header with. This must\n"
+    "  be specified by the \"precompiled_source\" value. In contrast to the\n"
+    "  header value, this IS a GN-style file name, and tells GN which source\n"
+    "  file to compile to make the .pch file used for subsequent compiles.\n"
+    "\n"
+    "  If you use both C and C++ sources, the precompiled header and source\n"
+    "  file will be compiled using both tools. You will want to make sure\n"
+    "  to wrap C++ includes in __cplusplus #ifdefs so the file will compile\n"
+    "  in C mode.\n"
+    "\n"
+    "  For example, if the toolchain specifies MSVC headers:\n"
+    "\n"
+    "    toolchain(\"vc_x64\") {\n"
+    "      ...\n"
+    "      tool(\"cxx\") {\n"
+    "        precompiled_header_type = \"msvc\"\n"
+    "        ...\n"
+    "\n"
+    "  You might make a config like this:\n"
+    "\n"
+    "    config(\"use_precompiled_headers\") {\n"
+    "      precompiled_header = \"build/precompile.h\"\n"
+    "      precompiled_source = \"//build/precompile.cc\"\n"
+    "\n"
+    "      # Either your source files should #include \"build/precompile.h\"\n"
+    "      # first, or you can do this to force-include the header.\n"
+    "      cflags = [ \"/FI$precompiled_header\" ]\n"
+    "    }\n"
+    "\n"
+    "  And then define a target that uses the config:\n"
+    "\n"
+    "    executable(\"doom_melon\") {\n"
+    "      configs += [ \":use_precompiled_headers\" ]\n"
+    "      ...\n"
+    "\n";
+
+const char kPrecompiledSource[] = "precompiled_source";
+const char kPrecompiledSource_HelpShort[] =
+    "precompiled_source: [file name] Source file to precompile.";
+const char kPrecompiledSource_Help[] =
+    "precompiled_source: [file name] Source file to precompile.\n"
+    "\n"
+    "  The source file that goes along with the precompiled_header when\n"
+    "  using \"msvc\"-style precompiled headers. It will be implicitly added\n"
+    "  to the sources of the target. See \"gn help precompiled_header\".\n";
+
 const char kPublic[] = "public";
 const char kPublic_HelpShort[] =
     "public: [file list] Declare public header files for a target.";
@@ -1121,6 +1191,8 @@
     INSERT_VARIABLE(OutputExtension)
     INSERT_VARIABLE(OutputName)
     INSERT_VARIABLE(Outputs)
+    INSERT_VARIABLE(PrecompiledHeader)
+    INSERT_VARIABLE(PrecompiledSource)
     INSERT_VARIABLE(Public)
     INSERT_VARIABLE(PublicConfigs)
     INSERT_VARIABLE(PublicDeps)
diff --git a/tools/gn/variables.h b/tools/gn/variables.h
index 57d6a98..4d8c4b4 100644
--- a/tools/gn/variables.h
+++ b/tools/gn/variables.h
@@ -171,6 +171,14 @@
 extern const char kOutputs_HelpShort[];
 extern const char kOutputs_Help[];
 
+extern const char kPrecompiledHeader[];
+extern const char kPrecompiledHeader_HelpShort[];
+extern const char kPrecompiledHeader_Help[];
+
+extern const char kPrecompiledSource[];
+extern const char kPrecompiledSource_HelpShort[];
+extern const char kPrecompiledSource_Help[];
+
 extern const char kPublic[];
 extern const char kPublic_HelpShort[];
 extern const char kPublic_Help[];