Use WithoutPathExpansion on DictionaryValue in GN.

tools/gn/desc_builder.cc

 // Copyright (c) 2016 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 <set>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/config.h"
@@ skipping 141 matching lines @@
       out->AppendString(name);
       if (tree_)
         FillInConfigVector(out, config.ptr->configs(), indent + 1);
     }
   }
 
   void FillInPrecompiledHeader(base::DictionaryValue* out,
                                const ConfigValues& values) {
     if (what(variables::kPrecompiledHeader) &&
         !values.precompiled_header().empty()) {
-      out->Set(variables::kPrecompiledHeader,
-               RenderValue(values.precompiled_header(), true));
+      out->SetWithoutPathExpansion(
+          variables::kPrecompiledHeader,
+          RenderValue(values.precompiled_header(), true));
     }
     if (what(variables::kPrecompiledSource) &&
         !values.precompiled_source().is_null()) {
-      out->Set(variables::kPrecompiledSource,
-               RenderValue(values.precompiled_source()));
+      out->SetWithoutPathExpansion(variables::kPrecompiledSource,
+                                   RenderValue(values.precompiled_source()));
     }
   }
 
   std::set<std::string> what_;
   bool all_;
   bool tree_;
   bool blame_;
 };
 
 class ConfigDescBuilder : public BaseDescBuilder {
  public:
   ConfigDescBuilder(const Config* config, const std::set<std::string>& what)
       : BaseDescBuilder(what, false, false, false), config_(config) {}
 
   std::unique_ptr<base::DictionaryValue> BuildDescription() {
     auto res = base::MakeUnique<base::DictionaryValue>();
     const ConfigValues& values = config_->resolved_values();
 
     if (what_.empty())
-      res->SetString(
+      res->SetStringWithoutPathExpansion(
           "toolchain",
           config_->label().GetToolchainLabel().GetUserVisibleName(false));
 
     if (what(variables::kConfigs) && !config_->configs().empty()) {
       auto configs = base::MakeUnique<base::ListValue>();
       FillInConfigVector(configs.get(), config_->configs().vector());
-      res->Set(variables::kConfigs, std::move(configs));
+      res->SetWithoutPathExpansion(variables::kConfigs, std::move(configs));
     }
 
 #define CONFIG_VALUE_ARRAY_HANDLER(name, type)                        \
   if (what(#name)) {                                                  \
     ValuePtr ptr =                                                    \
         render_config_value_array<type>(values, &ConfigValues::name); \
     if (ptr) {                                                        \
-      res->Set(#name, std::move(ptr));                                \
+      res->SetWithoutPathExpansion(#name, std::move(ptr));            \
     }                                                                 \
   }
     CONFIG_VALUE_ARRAY_HANDLER(arflags, std::string)
     CONFIG_VALUE_ARRAY_HANDLER(asmflags, std::string)
     CONFIG_VALUE_ARRAY_HANDLER(cflags, std::string)
     CONFIG_VALUE_ARRAY_HANDLER(cflags_c, std::string)
     CONFIG_VALUE_ARRAY_HANDLER(cflags_cc, std::string)
     CONFIG_VALUE_ARRAY_HANDLER(cflags_objc, std::string)
     CONFIG_VALUE_ARRAY_HANDLER(cflags_objcc, std::string)
     CONFIG_VALUE_ARRAY_HANDLER(defines, std::string)
@@ skipping 37 matching lines @@
                     bool all,
                     bool tree,
                     bool blame)
       : BaseDescBuilder(what, all, tree, blame), target_(target) {}
 
   std::unique_ptr<base::DictionaryValue> BuildDescription() {
     auto res = base::MakeUnique<base::DictionaryValue>();
     bool is_binary_output = target_->IsBinary();
 
     if (what_.empty()) {
-      res->SetString("type",
-                     Target::GetStringForOutputType(target_->output_type()));
-      res->SetString(
+      res->SetStringWithoutPathExpansion(
+          "type",
+          Target::GetStringForOutputType(target_->output_type()));
+      res->SetStringWithoutPathExpansion(
           "toolchain",
           target_->label().GetToolchainLabel().GetUserVisibleName(false));
     }
 
     // General target meta variables.
     if (what(variables::kVisibility))
-      res->Set(variables::kVisibility, target_->visibility().AsValue());
+      res->SetWithoutPathExpansion(variables::kVisibility,
+                                   target_->visibility().AsValue());
 
     if (what(variables::kTestonly))
-      res->SetBoolean(variables::kTestonly, target_->testonly());
+      res->SetBooleanWithoutPathExpansion(variables::kTestonly,
+                                          target_->testonly());
 
     if (is_binary_output) {
       if (what(variables::kCheckIncludes))
-        res->SetBoolean(variables::kCheckIncludes, target_->check_includes());
+        res->SetBooleanWithoutPathExpansion(variables::kCheckIncludes,
+                                            target_->check_includes());
 
       if (what(variables::kAllowCircularIncludesFrom)) {
         auto labels = base::MakeUnique<base::ListValue>();
         for (const auto& cur : target_->allow_circular_includes_from())
           labels->AppendString(cur.GetUserVisibleName(GetToolchainLabel()));
 
-        res->Set(variables::kAllowCircularIncludesFrom, std::move(labels));
+        res->SetWithoutPathExpansion(variables::kAllowCircularIncludesFrom,
+                                     std::move(labels));
       }
     }
 
     if (what(variables::kSources) && !target_->sources().empty())
-      res->Set(variables::kSources, RenderValue(target_->sources()));
+      res->SetWithoutPathExpansion(variables::kSources,
+                                   RenderValue(target_->sources()));
 
     if (what(variables::kOutputName) && !target_->output_name().empty())
-      res->SetString(variables::kOutputName, target_->output_name());
+      res->SetStringWithoutPathExpansion(variables::kOutputName,
+                                         target_->output_name());
 
     if (what(variables::kOutputDir) && !target_->output_dir().is_null())
-      res->Set(variables::kOutputDir, RenderValue(target_->output_dir()));
+      res->SetWithoutPathExpansion(variables::kOutputDir,
+                                   RenderValue(target_->output_dir()));
 
     if (what(variables::kOutputExtension) && target_->output_extension_set())
-      res->SetString(variables::kOutputExtension, target_->output_extension());
+      res->SetStringWithoutPathExpansion(variables::kOutputExtension,
+                                         target_->output_extension());
 
     if (what(variables::kPublic)) {
       if (target_->all_headers_public())
-        res->SetString(variables::kPublic, "*");
+        res->SetStringWithoutPathExpansion(variables::kPublic, "*");
       else
-        res->Set(variables::kPublic, RenderValue(target_->public_headers()));
+        res->SetWithoutPathExpansion(variables::kPublic,
+                                     RenderValue(target_->public_headers()));
     }
 
     if (what(variables::kInputs) && !target_->inputs().empty())
-      res->Set(variables::kInputs, RenderValue(target_->inputs()));
+      res->SetWithoutPathExpansion(variables::kInputs,
+                                   RenderValue(target_->inputs()));
 
     if (is_binary_output && what(variables::kConfigs) &&
         !target_->configs().empty()) {
       auto configs = base::MakeUnique<base::ListValue>();
       FillInConfigVector(configs.get(), target_->configs().vector());
-      res->Set(variables::kConfigs, std::move(configs));
+      res->SetWithoutPathExpansion(variables::kConfigs, std::move(configs));
     }
 
     if (what(variables::kPublicConfigs) && !target_->public_configs().empty()) {
       auto configs = base::MakeUnique<base::ListValue>();
       FillInConfigVector(configs.get(), target_->public_configs());
-      res->Set(variables::kPublicConfigs, std::move(configs));
+      res->SetWithoutPathExpansion(variables::kPublicConfigs,
+                                   std::move(configs));
     }
 
     if (what(variables::kAllDependentConfigs) &&
         !target_->all_dependent_configs().empty()) {
       auto configs = base::MakeUnique<base::ListValue>();
       FillInConfigVector(configs.get(), target_->all_dependent_configs());
-      res->Set(variables::kAllDependentConfigs, std::move(configs));
+      res->SetWithoutPathExpansion(variables::kAllDependentConfigs,
+                                   std::move(configs));
     }
 
     // Action
     if (target_->output_type() == Target::ACTION ||
         target_->output_type() == Target::ACTION_FOREACH) {
       if (what(variables::kScript))
-        res->SetString(variables::kScript,
-                       target_->action_values().script().value());
+        res->SetStringWithoutPathExpansion(
+            variables::kScript,
+            target_->action_values().script().value());
 
       if (what(variables::kArgs)) {
         auto args = base::MakeUnique<base::ListValue>();
         for (const auto& elem : target_->action_values().args().list())
           args->AppendString(elem.AsString());
 
-        res->Set(variables::kArgs, std::move(args));
+        res->SetWithoutPathExpansion(variables::kArgs, std::move(args));
       }
       if (what(variables::kDepfile) &&
           !target_->action_values().depfile().empty()) {
-        res->SetString(variables::kDepfile,
-                       target_->action_values().depfile().AsString());
+        res->SetStringWithoutPathExpansion(
+            variables::kDepfile,
+            target_->action_values().depfile().AsString());
       }
     }
 
     if (target_->output_type() != Target::SOURCE_SET &&
         target_->output_type() != Target::GROUP &&
         target_->output_type() != Target::BUNDLE_DATA) {
       if (what(variables::kOutputs))
         FillInOutputs(res.get());
     }
 
     // Source outputs are only included when specifically asked for it
     if (what_.find("source_outputs") != what_.end())
       FillInSourceOutputs(res.get());
 
     if (target_->output_type() == Target::CREATE_BUNDLE && what("bundle_data"))
       FillInBundle(res.get());
 
     if (is_binary_output) {
 #define CONFIG_VALUE_ARRAY_HANDLER(name, type)                    \
   if (what(#name)) {                                              \
     ValuePtr ptr = RenderConfigValues<type>(&ConfigValues::name); \
     if (ptr) {                                                    \
-      res->Set(#name, std::move(ptr));                            \
+      res->SetWithoutPathExpansion(#name, std::move(ptr));        \
     }                                                             \
   }
       CONFIG_VALUE_ARRAY_HANDLER(arflags, std::string)
       CONFIG_VALUE_ARRAY_HANDLER(asmflags, std::string)
       CONFIG_VALUE_ARRAY_HANDLER(cflags, std::string)
       CONFIG_VALUE_ARRAY_HANDLER(cflags_c, std::string)
       CONFIG_VALUE_ARRAY_HANDLER(cflags_cc, std::string)
       CONFIG_VALUE_ARRAY_HANDLER(cflags_objc, std::string)
       CONFIG_VALUE_ARRAY_HANDLER(cflags_objcc, std::string)
       CONFIG_VALUE_ARRAY_HANDLER(defines, std::string)
       CONFIG_VALUE_ARRAY_HANDLER(include_dirs, SourceDir)
       CONFIG_VALUE_ARRAY_HANDLER(ldflags, std::string)
 #undef CONFIG_VALUE_ARRAY_HANDLER
 
       // Libs and lib_dirs are handled specially below.
 
       FillInPrecompiledHeader(res.get(), target_->config_values());
     }
 
     if (what(variables::kDeps))
-      res->Set(variables::kDeps, RenderDeps());
+      res->SetWithoutPathExpansion(variables::kDeps, RenderDeps());
 
     // Runtime deps are special, print only when explicitly asked for and not in
     // overview mode.
     if (what_.find("runtime_deps") != what_.end())
-      res->Set("runtime_deps", RenderRuntimeDeps());
+      res->SetWithoutPathExpansion("runtime_deps", RenderRuntimeDeps());
 
     // libs and lib_dirs are special in that they're inherited. We don't
     // currently
     // implement a blame feature for this since the bottom-up inheritance makes
     // this difficult.
 
     // Libs can be part of any target and get recursively pushed up the chain,
     // so display them regardless of target type.
     if (what(variables::kLibs)) {
       const OrderedSet<LibFile>& all_libs = target_->all_libs();
       if (!all_libs.empty()) {
         auto libs = base::MakeUnique<base::ListValue>();
         for (size_t i = 0; i < all_libs.size(); i++)
           libs->AppendString(all_libs[i].value());
-        res->Set(variables::kLibs, std::move(libs));
+        res->SetWithoutPathExpansion(variables::kLibs, std::move(libs));
       }
     }
 
     if (what(variables::kLibDirs)) {
       const OrderedSet<SourceDir>& all_lib_dirs = target_->all_lib_dirs();
       if (!all_lib_dirs.empty()) {
         auto lib_dirs = base::MakeUnique<base::ListValue>();
         for (size_t i = 0; i < all_lib_dirs.size(); i++)
           lib_dirs->AppendString(FormatSourceDir(all_lib_dirs[i]));
-        res->Set(variables::kLibDirs, std::move(lib_dirs));
+        res->SetWithoutPathExpansion(variables::kLibDirs, std::move(lib_dirs));
       }
     }
 
     return res;
   }
 
  private:
   // Prints dependencies of the given target (not the target itself). If the
   // set is non-null, new targets encountered will be added to the set, and if
   // a dependency is in the set already, it will not be recused into. When the
@@ skipping 105 matching lines @@
       std::vector<OutputFile> outputs;
       Toolchain::ToolType tool_type = Toolchain::TYPE_NONE;
       if (target_->GetOutputFilesForSource(source, &tool_type, &outputs)) {
         auto list = base::MakeUnique<base::ListValue>();
         for (const auto& output : outputs)
           list->AppendString(output.value());
 
         dict->SetWithoutPathExpansion(source.value(), std::move(list));
       }
     }
-    res->Set("source_outputs", std::move(dict));
+    res->SetWithoutPathExpansion("source_outputs", std::move(dict));
   }
 
   void FillInBundle(base::DictionaryValue* res) {
     auto data = base::MakeUnique<base::DictionaryValue>();
     const BundleData& bundle_data = target_->bundle_data();
     const Settings* settings = target_->settings();
     BundleData::SourceFiles sources;
     bundle_data.GetSourceFiles(&sources);
-    data->Set("source_files", RenderValue(sources));
-    data->SetString("root_dir_output",
-                    bundle_data.GetBundleRootDirOutput(settings).value());
-    data->Set("root_dir", RenderValue(bundle_data.root_dir()));
-    data->Set("resources_dir", RenderValue(bundle_data.resources_dir()));
-    data->Set("executable_dir", RenderValue(bundle_data.executable_dir()));
-    data->Set("plugins_dir", RenderValue(bundle_data.plugins_dir()));
-    data->SetString("product_type", bundle_data.product_type());
+    data->SetWithoutPathExpansion("source_files", RenderValue(sources));
+    data->SetStringWithoutPathExpansion(
+        "root_dir_output",
+        bundle_data.GetBundleRootDirOutput(settings).value());
+    data->SetWithoutPathExpansion("root_dir",
+                                  RenderValue(bundle_data.root_dir()));
+    data->SetWithoutPathExpansion("resources_dir",
+                                  RenderValue(bundle_data.resources_dir()));
+    data->SetWithoutPathExpansion("executable_dir",
+                                  RenderValue(bundle_data.executable_dir()));
+    data->SetWithoutPathExpansion("plugins_dir",
+                                  RenderValue(bundle_data.plugins_dir()));
+    data->SetStringWithoutPathExpansion("product_type",
+                                        bundle_data.product_type());
 
     auto deps = base::MakeUnique<base::ListValue>();
     for (const auto* dep : bundle_data.bundle_deps())
       deps->AppendString(dep->label().GetUserVisibleName(GetToolchainLabel()));
 
-    data->Set("deps", std::move(deps));
-    res->Set("bundle_data", std::move(data));
+    data->SetWithoutPathExpansion("deps", std::move(deps));
+    res->SetWithoutPathExpansion("bundle_data", std::move(data));
   }
 
   void FillInOutputs(base::DictionaryValue* res) {
     if (target_->output_type() == Target::ACTION) {
       auto list = base::MakeUnique<base::ListValue>();
       for (const auto& elem : target_->action_values().outputs().list())
         list->AppendString(elem.AsString());
 
-      res->Set(variables::kOutputs, std::move(list));
+      res->SetWithoutPathExpansion(variables::kOutputs, std::move(list));
     } else if (target_->output_type() == Target::CREATE_BUNDLE) {
       std::vector<SourceFile> output_files;
       target_->bundle_data().GetOutputsAsSourceFiles(target_->settings(),
                                                      &output_files);
-      res->Set(variables::kOutputs, RenderValue(output_files));
+      res->SetWithoutPathExpansion(variables::kOutputs,
+                                   RenderValue(output_files));
     } else if (target_->output_type() == Target::ACTION_FOREACH ||
                target_->output_type() == Target::COPY_FILES) {
       const SubstitutionList& outputs = target_->action_values().outputs();
       if (!outputs.required_types().empty()) {
         auto patterns = base::MakeUnique<base::ListValue>();
         for (const auto& elem : outputs.list())
           patterns->AppendString(elem.AsString());
 
-        res->Set("output_patterns", std::move(patterns));
+        res->SetWithoutPathExpansion("output_patterns", std::move(patterns));
       }
       std::vector<SourceFile> output_files;
       SubstitutionWriter::ApplyListToSources(target_->settings(), outputs,
                                              target_->sources(), &output_files);
-      res->Set(variables::kOutputs, RenderValue(output_files));
+      res->SetWithoutPathExpansion(variables::kOutputs,
+                                   RenderValue(output_files));
     } else {
       DCHECK(target_->IsBinary());
       const Tool* tool =
           target_->toolchain()->GetToolForTargetFinalOutput(target_);
 
       std::vector<OutputFile> output_files;
       SubstitutionWriter::ApplyListToLinkerAsOutputFile(
           target_, tool, tool->outputs(), &output_files);
       std::vector<SourceFile> output_files_as_source_file;
       for (const OutputFile& output_file : output_files)
         output_files_as_source_file.push_back(
             output_file.AsSourceFile(target_->settings()->build_settings()));
 
-      res->Set(variables::kOutputs, RenderValue(output_files_as_source_file));
+      res->SetWithoutPathExpansion(variables::kOutputs,
+                                   RenderValue(output_files_as_source_file));
     }
   }
 
   // Writes a given config value type to the string, optionally with
   // attribution.
   // This should match RecursiveTargetConfigToStream in the order it traverses.
   template <class T>
   ValuePtr RenderConfigValues(const std::vector<T>& (ConfigValues::*getter)()
                                   const) {
     auto res = base::MakeUnique<base::ListValue>();
@@ skipping 62 matching lines @@
 
 std::unique_ptr<base::DictionaryValue> DescBuilder::DescriptionForConfig(
     const Config* config,
     const std::string& what) {
   std::set<std::string> w;
   if (!what.empty())
     w.insert(what);
   ConfigDescBuilder b(config, w);
   return b.BuildDescription();
 }