Redo GN "args" command

tools/gn/setup.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 "tools/gn/setup.h"
 
 #include <stdlib.h>
 
 #include <algorithm>
+#include <sstream>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/process/launch.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
@@ skipping 106 matching lines @@
 }
 
 void DecrementWorkCount() {
   g_scheduler->DecrementWorkCount();
 }
 
 }  // namespace
 
 // CommonSetup -----------------------------------------------------------------
 
+const char CommonSetup::kBuildArgFileName[] = "gn.args";
+
 CommonSetup::CommonSetup()
     : build_settings_(),
       loader_(new LoaderImpl(&build_settings_)),
       builder_(new Builder(loader_.get())),
       root_build_file_("//BUILD.gn"),
       check_for_bad_items_(true),
       check_for_unused_overrides_(true),
       check_public_headers_(false) {
   loader_->set_complete_callback(base::Bind(&DecrementWorkCount));
 }
@@ skipping 62 matching lines @@
     SaveTraces(cmdline->GetSwitchValuePath(kTracelogSwitch));
 
   return true;
 }
 
 // Setup -----------------------------------------------------------------------
 
 Setup::Setup()
     : CommonSetup(),
       empty_settings_(&empty_build_settings_, std::string()),
-      dotfile_scope_(&empty_settings_) {
+      dotfile_scope_(&empty_settings_),
+      fill_arguments_(true) {
   empty_settings_.set_toolchain_label(Label());
   build_settings_.set_item_defined_callback(
       base::Bind(&ItemDefinedCallback, scheduler_.main_loop(), builder_));
 
   // The scheduler's main loop wasn't created when the Loader was created, so
   // we need to set it now.
   loader_->set_main_loop(scheduler_.main_loop());
 }
 
 Setup::~Setup() {
 }
 
 bool Setup::DoSetup(const std::string& build_dir) {
   CommandLine* cmdline = CommandLine::ForCurrentProcess();
 
   scheduler_.set_verbose_logging(cmdline->HasSwitch(kSwitchVerbose));
   if (cmdline->HasSwitch(kTimeSwitch) ||
       cmdline->HasSwitch(kTracelogSwitch))
     EnableTracing();
 
-  if (!FillArguments(*cmdline))
-    return false;
+  ScopedTrace setup_trace(TraceItem::TRACE_SETUP, "DoSetup");
+
   if (!FillSourceDir(*cmdline))
     return false;
   if (!RunConfigFile())
     return false;
   if (!FillOtherConfig(*cmdline))
     return false;
   if (!FillBuildDir(build_dir))  // Must be after FillSourceDir to resolve.
     return false;
+  if (fill_arguments_) {
+    if (!FillArguments(*cmdline))
+      return false;
+  }
   FillPythonPath();
 
   return true;
 }
 
 bool Setup::Run() {
   RunPreMessageLoop();
   if (!scheduler_.Run())
     return false;
   return RunPostMessageLoop();
 }
 
 Scheduler* Setup::GetScheduler() {
   return &scheduler_;
 }
 
+SourceFile Setup::GetBuildArgFile() const {
+  return SourceFile(build_settings_.build_dir().value() + kBuildArgFileName);
+}
+
 bool Setup::FillArguments(const CommandLine& cmdline) {
-  std::string args = cmdline.GetSwitchValueASCII(kSwitchArgs);
-  if (args.empty())
-    return true;  // Nothing to set.
+  // Add a dependency on the build arguments file. If this changes, we want
+  // to re-generated the build.
+  g_scheduler->AddGenDependency(build_settings_.GetFullPath(GetBuildArgFile()));
 
+  // Use the args on the command line if specified, and save them. Do this even
+  // if the list is empty (this means clear any defaults).
+  if (cmdline.HasSwitch(kSwitchArgs)) {
+    if (!FillArgsFromCommandLine(cmdline.GetSwitchValueASCII(kSwitchArgs)))
+      return false;
+    SaveArgsToFile();
+    return true;
+  }
+
+  // No command line args given, use the arguments from the build dir (if any).
+  return FillArgsFromFile();
+}
+
+bool Setup::FillArgsFromCommandLine(const std::string& args) {
   args_input_file_.reset(new InputFile(SourceFile()));
   args_input_file_->SetContents(args);
-  args_input_file_->set_friendly_name("the command-line \"--args\" settings");
+  args_input_file_->set_friendly_name("the command-line \"--args\"");
+  return FillArgsFromArgsInputFile();
+}
+
+bool Setup::FillArgsFromFile() {
+  ScopedTrace setup_trace(TraceItem::TRACE_SETUP, "Load args file");
+
+  SourceFile build_arg_source_file = GetBuildArgFile();
+  base::FilePath build_arg_file =
+      build_settings_.GetFullPath(build_arg_source_file);
+
+  std::string contents;
+  if (!base::ReadFileToString(build_arg_file, &contents))
+    return true;  // File doesn't exist, continue with default args.
+  if (contents.empty())
+    return true;  // Empty file, do nothing.
+
+  args_input_file_.reset(new InputFile(build_arg_source_file));
+  args_input_file_->SetContents(contents);
+  args_input_file_->set_friendly_name(
+      "build arg file (use \"gn args <out_dir>\" to edit)");
+
+  setup_trace.Done();  // Only want to count the load as part of the trace.
+  return FillArgsFromArgsInputFile();
+}
+
+bool Setup::FillArgsFromArgsInputFile() {
+  ScopedTrace setup_trace(TraceItem::TRACE_SETUP, "Parse args");
 
   Err err;
   args_tokens_ = Tokenizer::Tokenize(args_input_file_.get(), &err);
   if (err.has_error()) {
     err.PrintToStdout();
     return false;
   }
 
   args_root_ = Parser::Parse(args_tokens_, &err);
   if (err.has_error()) {
     err.PrintToStdout();
     return false;
   }
 
   Scope arg_scope(&empty_settings_);
   args_root_->AsBlock()->ExecuteBlockInScope(&arg_scope, &err);
   if (err.has_error()) {
     err.PrintToStdout();
     return false;
   }
 
   // Save the result of the command args.
   Scope::KeyValueMap overrides;
   arg_scope.GetCurrentScopeValues(&overrides);
   build_settings_.build_args().AddArgOverrides(overrides);
   return true;
 }
 
+bool Setup::SaveArgsToFile() {
+  ScopedTrace setup_trace(TraceItem::TRACE_SETUP, "Save args file");
+
+  Scope::KeyValueMap args = build_settings_.build_args().GetAllOverrides();
+
+  std::ostringstream stream;
+  for (Scope::KeyValueMap::const_iterator i = args.begin();
+       i != args.end(); ++i) {
+    stream << i->first.as_string() << " = " << i->second.ToString(true);
+    stream << std::endl;
+  }
+
+  // For the first run, the build output dir might not be created yet, so do
+  // that so we can write a file into it. Ignore errors, we'll catch the error
+  // when we try to write a file to it below.
+  base::FilePath build_arg_file =
+      build_settings_.GetFullPath(GetBuildArgFile());
+  base::CreateDirectory(build_arg_file.DirName());
+
+  std::string contents = stream.str();
+#if defined(OS_WIN)
+  // Use Windows lineendings for this file since it will often open in
+  // Notepad which can't handle Unix ones.
+  ReplaceSubstringsAfterOffset(&contents, 0, "\n", "\r\n");
+#endif
+  if (base::WriteFile(build_arg_file, contents.c_str(), contents.size()) ==
+      -1) {
+    Err(Location(), "Args file could not be written.",
+      "The file is \"" + FilePathToUTF8(build_arg_file) +
+        "\"").PrintToStdout();
+    return false;
+  }
+
+  return true;
+}
+
 bool Setup::FillSourceDir(const CommandLine& cmdline) {
   // Find the .gn file.
   base::FilePath root_path;
 
   // Prefer the command line args to the config file.
   base::FilePath relative_root_path = cmdline.GetSwitchValuePath(kSwitchRoot);
   if (!relative_root_path.empty()) {
     root_path = base::MakeAbsoluteFilePath(relative_root_path);
     if (root_path.empty()) {
       Err(Location(), "Root source path not found.",
@@ skipping 51 matching lines @@
     return false;
   }
 
   if (scheduler_.verbose_logging())
     scheduler_.Log("Using build dir", resolved.value());
   build_settings_.SetBuildDir(resolved);
   return true;
 }
 
 void Setup::FillPythonPath() {
+  // Trace this since it tends to be a bit slow on Windows.
+  ScopedTrace setup_trace(TraceItem::TRACE_SETUP, "Fill Python Path");
 #if defined(OS_WIN)
   // Find Python on the path so we can use the absolute path in the build.
   const base::char16 kGetPython[] =
       L"cmd.exe /c python -c \"import sys; print sys.executable\"";
   std::string python_path;
   if (base::GetAppOutput(kGetPython, &python_path)) {
     base::TrimWhitespaceASCII(python_path, base::TRIM_ALL, &python_path);
     if (scheduler_.verbose_logging())
       scheduler_.Log("Found python", python_path);
   } else {
@@ skipping 118 matching lines @@
 }
 
 void DependentSetup::RunPreMessageLoop() {
   CommonSetup::RunPreMessageLoop();
 }
 
 bool DependentSetup::RunPostMessageLoop() {
   return CommonSetup::RunPostMessageLoop();
 }