Revert of [GN] Add JSON project writer

tools/gn/commands.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/commands.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
-#include "base/values.h"
 #include "tools/gn/builder.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/item.h"
 #include "tools/gn/label.h"
 #include "tools/gn/label_pattern.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/target.h"
 
 namespace commands {
@@ skipping 254 matching lines @@
 
   targets->swap(result);
   return true;
 }
 
 // Returns the file path generating this item.
 base::FilePath BuildFileForItem(const Item* item) {
   return item->defined_from()->GetRange().begin().file()->physical_name();
 }
 
-void PrintTargetsAsBuildfiles(const std::vector<const Target*>& targets,
-                              base::ListValue* out) {
+void PrintTargetsAsBuildfiles(bool indent,
+                              const std::vector<const Target*>& targets) {
   // Output the set of unique source files.
   std::set<std::string> unique_files;
   for (const Target* target : targets)
     unique_files.insert(FilePathToUTF8(BuildFileForItem(target)));
 
   for (const std::string& file : unique_files) {
-    out->AppendString(file);
+    if (indent)
+      OutputString("  ");
+    OutputString(file + "\n");
   }
 }
 
-void PrintTargetsAsLabels(const std::vector<const Target*>& targets,
-                          base::ListValue* out) {
+void PrintTargetsAsLabels(bool indent,
+                          const std::vector<const Target*>& targets) {
   // Putting the labels into a set automatically sorts them for us.
   std::set<Label> unique_labels;
   for (const auto& target : targets)
     unique_labels.insert(target->label());
 
   // Grab the label of the default toolchain from the first target.
   Label default_tc_label =
       targets[0]->settings()->default_toolchain_label();
 
   for (const Label& label : unique_labels) {
     // Print toolchain only for ones not in the default toolchain.
-    out->AppendString(label.GetUserVisibleName(label.GetToolchainLabel() !=
-                                               default_tc_label));
+    if (indent)
+      OutputString("  ");
+    OutputString(label.GetUserVisibleName(
+        label.GetToolchainLabel() != default_tc_label));
+    OutputString("\n");
   }
 }
 
-void PrintTargetsAsOutputs(const std::vector<const Target*>& targets,
-                           base::ListValue* out) {
+void PrintTargetsAsOutputs(bool indent,
+                           const std::vector<const Target*>& targets) {
   if (targets.empty())
     return;
 
   // Grab the build settings from a random target.
   const BuildSettings* build_settings =
       targets[0]->settings()->build_settings();
 
   for (const Target* target : targets) {
     // Use the link output file if there is one, otherwise fall back to the
     // dependency output file (for actions, for example).
     OutputFile output_file = target->link_output_file();
     if (output_file.value().empty())
       output_file = target->dependency_output_file();
 
     SourceFile output_as_source =
         output_file.AsSourceFile(build_settings);
     std::string result = RebasePath(output_as_source.value(),
                                     build_settings->build_dir(),
                                     build_settings->root_path_utf8());
-    out->AppendString(result);
+    if (indent)
+      OutputString("  ");
+    OutputString(result);
+    OutputString("\n");
   }
 }
 
 }  // namespace
 
 CommandInfo::CommandInfo()
     : help_short(nullptr),
       help(nullptr),
       runner(nullptr) {
 }
@@ skipping 130 matching lines @@
     LabelPattern pattern =
         LabelPattern::GetPattern(root_dir, Value(nullptr, token), err);
     if (err->has_error())
       return false;
     filters->push_back(pattern);
   }
 
   return true;
 }
 
-void FilterAndPrintTargets(std::vector<const Target*>* targets,
-                           base::ListValue* out) {
+void FilterAndPrintTargets(bool indent, std::vector<const Target*>* targets) {
   if (targets->empty())
     return;
 
   if (!ApplyTestonlyFilter(targets))
     return;
   if (!ApplyTypeFilter(targets))
     return;
 
   TargetPrintingMode printing_mode = TARGET_PRINT_LABEL;
   if (targets->empty() || !GetTargetPrintingMode(&printing_mode))
     return;
   switch (printing_mode) {
     case TARGET_PRINT_BUILDFILE:
-      PrintTargetsAsBuildfiles(*targets, out);
+      PrintTargetsAsBuildfiles(indent, *targets);
       break;
     case TARGET_PRINT_LABEL:
-      PrintTargetsAsLabels(*targets, out);
+      PrintTargetsAsLabels(indent, *targets);
       break;
     case TARGET_PRINT_OUTPUT:
-      PrintTargetsAsOutputs(*targets, out);
+      PrintTargetsAsOutputs(indent, *targets);
       break;
   }
 }
 
-void FilterAndPrintTargets(bool indent, std::vector<const Target*>* targets) {
-  base::ListValue tmp;
-  FilterAndPrintTargets(targets, &tmp);
-  for (const auto& value : tmp) {
-    std::string string;
-    value->GetAsString(&string);
-    if (indent)
-      OutputString("  ");
-    OutputString(string);
-    OutputString("\n");
-  }
-}
-
 void FilterAndPrintTargetSet(bool indent,
                              const std::set<const Target*>& targets) {
   std::vector<const Target*> target_vector(targets.begin(), targets.end());
   FilterAndPrintTargets(indent, &target_vector);
 }
 
-void FilterAndPrintTargetSet(const std::set<const Target*>& targets,
-                             base::ListValue* out) {
-  std::vector<const Target*> target_vector(targets.begin(), targets.end());
-  FilterAndPrintTargets(&target_vector, out);
-}
-
 }  // namespace commands