Use WithoutPathExpansion on DictionaryValue in GN.

tools/gn/analyzer.cc

 // Copyright 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 "tools/gn/analyzer.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <vector>
@@ skipping 84 matching lines @@
     }
     strings.push_back(std::move(s));
   }
   *err = Err();
   return strings;
 }
 
 void WriteString(base::DictionaryValue& dict,
                  const std::string& key,
                  const std::string& value) {
-  dict.SetString(key, value);
+  dict.SetStringWithoutPathExpansion(key, value);
 };
 
 void WriteLabels(const Label& default_toolchain,
                  base::DictionaryValue& dict,
                  const std::string& key,
                  const LabelSet& labels) {
   std::vector<std::string> strings;
   auto value = base::WrapUnique(new base::ListValue());
   for (const auto l : labels)
     strings.push_back(l.GetUserVisibleName(default_toolchain));
   std::sort(strings.begin(), strings.end());
   value->AppendStrings(strings);
-  dict.Set(key, std::move(value));
+  dict.SetWithoutPathExpansion(key, std::move(value));
 }
 
 Label AbsoluteOrSourceAbsoluteStringToLabel(const Label& default_toolchain,
                                             const std::string& s, Err* err) {
   if (!IsPathSourceAbsolute(s) && !IsPathAbsolute(s)) {
     *err = Err(Location(),
                "\"" + s + "\" is not a source-absolute or absolute path.");
     return Label();
   }
   return Label::Resolve(SourceDir("//"), default_toolchain, Value(nullptr, s),
@@ skipping 71 matching lines @@
 
   if (outputs.error.size()) {
     WriteString(*value, "error", outputs.error);
     WriteLabels(default_toolchain, *value, "invalid_targets",
                 outputs.invalid_labels);
   } else {
     WriteString(*value, "status", outputs.status);
     if (outputs.compile_includes_all) {
       auto compile_targets = base::WrapUnique(new base::ListValue());
       compile_targets->AppendString("all");
-      value->Set("compile_targets", std::move(compile_targets));
+      value->SetWithoutPathExpansion("compile_targets",
+                                     std::move(compile_targets));
     } else {
       WriteLabels(default_toolchain, *value, "compile_targets",
                   outputs.compile_labels);
     }
     WriteLabels(default_toolchain, *value, "test_targets", outputs.test_labels);
   }
 
   if (!base::JSONWriter::Write(*value.get(), &output))
     *err = Err(Location(), "Failed to marshal JSON value for output");
   return output;
@@ skipping 181 matching lines @@
 void Analyzer::AddAllRefsTo(const Target* target, TargetSet* results) const {
   if (results->find(target) != results->end())
     return;  // Already found this target.
   results->insert(target);
 
   auto dep_begin = dep_map_.lower_bound(target);
   auto dep_end = dep_map_.upper_bound(target);
   for (auto cur_dep = dep_begin; cur_dep != dep_end; cur_dep++)
     AddAllRefsTo(cur_dep->second, results);
 }