JSONWriter cleanup: integrate pretty print into write options.

chrome/browser/chromeos/cros/onc_network_parser.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/cros/onc_network_parser.h"
 
 #include <keyhi.h>
 #include <pk11pub.h>
 
 #include "base/base64.h"
@@ skipping 229 matching lines @@
 }
 
 const bool GetBooleanValue(const base::Value& value) {
   bool bool_value = false;
   value.GetAsBoolean(&bool_value);
   return bool_value;
 }
 
 std::string ConvertValueToString(const base::Value& value) {
   std::string value_json;
-  base::JSONWriter::Write(&value, false, &value_json);
+  base::JSONWriter::Write(&value, &value_json);
   return value_json;
 }
 
 bool GetAsListOfStrings(const base::Value& value,
                         std::vector<std::string>* result) {
   const base::ListValue* list = NULL;
   if (!value.GetAsList(&list))
     return false;
   result->clear();
   result->reserve(list->GetSize());
@@ skipping 191 matching lines @@
   return info;
 }
 
 Network* OncNetworkParser::ParseNetwork(int n) {
   const base::DictionaryValue* info = GetNetworkConfig(n);
   if (!info)
     return NULL;
 
   if (VLOG_IS_ON(2)) {
     std::string network_json;
-    base::JSONWriter::Write(static_cast<const base::Value*>(info),
-                            true, &network_json);
+    base::JSONWriter::WriteWithOptions(static_cast<const base::Value*>(info),
+                                       base::JSONWriter::OPTIONS_PRETTY_PRINT,
+                                       &network_json);
     VLOG(2) << "Parsing network at index " << n
             << ": " << network_json;
   }
 
   return CreateNetworkFromInfo(std::string(), *info);
 }
 
 int OncNetworkParser::GetCertificatesSize() const {
   return certificates_ ? certificates_->GetSize() : 0;
 }
 
 scoped_refptr<net::X509Certificate> OncNetworkParser::ParseCertificate(
     int cert_index) {
   CHECK(certificates_);
   CHECK(static_cast<size_t>(cert_index) < certificates_->GetSize());
   CHECK_GE(cert_index, 0);
   base::DictionaryValue* certificate = NULL;
   if (!certificates_->GetDictionary(cert_index, &certificate)) {
     parse_error_ = l10n_util::GetStringUTF8(
         IDS_NETWORK_CONFIG_ERROR_CERT_DATA_MALFORMED);
     return NULL;
   }
 
   if (VLOG_IS_ON(2)) {
     std::string certificate_json;
-    base::JSONWriter::Write(static_cast<base::Value*>(certificate),
-                            true, &certificate_json);
+    base::JSONWriter::WriteWithOptions(static_cast<base::Value*>(certificate),
+                                       base::JSONWriter::OPTIONS_PRETTY_PRINT,
+                                       &certificate_json);
     VLOG(2) << "Parsing certificate at index " << cert_index
             << ": " << certificate_json;
   }
 
   // Get out the attributes of the given certificate.
   std::string guid;
   bool remove = false;
   if (!certificate->GetString("GUID", &guid) || guid.empty()) {
     LOG(WARNING) << "ONC File: certificate missing identifier at index"
                  << cert_index;
@@ skipping 55 matching lines @@
                          ParseNetworkConfigurationValue)) {
     LOG(WARNING) << "Network " << network->name() << " failed to parse.";
     if (parse_error_.empty())
       parse_error_ = l10n_util::GetStringUTF8(
           IDS_NETWORK_CONFIG_ERROR_NETWORK_PROP_DICT_MALFORMED);
     return NULL;
   }
 
   // Update the UI data property.
   std::string ui_data_json;
-  base::JSONWriter::Write(network->ui_data(), false, &ui_data_json);
+  base::JSONWriter::Write(network->ui_data(), &ui_data_json);
   base::StringValue ui_data_string_value(ui_data_json);
   network->UpdatePropertyMap(PROPERTY_INDEX_UI_DATA, &ui_data_string_value);
 
   if (VLOG_IS_ON(2)) {
     VLOG(2) << "Created Network '" << network->name()
             << "' from info. Path:" << service_path
             << " Type:" << ConnectionTypeToString(type);
   }
 
   return network.release();
@@ skipping 48 matching lines @@
     // change the mapped value.
     network->UpdatePropertyMap(index, inner_value);
     if (!parser(this, index, *inner_value, network)) {
       LOG(ERROR) << network->name() << ": field in " << onc_type
                  << " not parsed: " << key;
       any_errors = true;
       continue;
     }
     if (VLOG_IS_ON(2)) {
       std::string value_json;
-      base::JSONWriter::Write(inner_value, true, &value_json);
+      base::JSONWriter::WriteWithOptions(inner_value,
+                                         base::JSONWriter::OPTIONS_PRETTY_PRINT,
+                                         &value_json);
       VLOG(2) << network->name() << ": Successfully parsed [" << key
               << "(" << index << ")] = " << value_json;
     }
   }
   if (any_errors) {
     parse_error_ = l10n_util::GetStringUTF8(
         IDS_NETWORK_CONFIG_ERROR_NETWORK_PROP_DICT_MALFORMED);
   }
   return !any_errors;
 }
@@ skipping 1319 matching lines @@
     // on the value of AuthenticationType.
     { "L2TP-IPsec", PROVIDER_TYPE_L2TP_IPSEC_PSK },
     { "OpenVPN", PROVIDER_TYPE_OPEN_VPN },
   };
   CR_DEFINE_STATIC_LOCAL(EnumMapper<ProviderType>, parser,
       (table, arraysize(table), PROVIDER_TYPE_MAX));
   return parser.Get(type);
 }
 
 }  // namespace chromeos