Revert of Stop doing unnecessary UTF-8 to UTF-16 conversions in JSONWriter.

base/json/json_writer.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 "base/json/json_writer.h"
 
 #include <cmath>
 
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 
 namespace base {
 
 #if defined(OS_WIN)
 static const char kPrettyPrintLineEnding[] = "\r\n";
 #else
 static const char kPrettyPrintLineEnding[] = "\n";
 #endif
 
-// static
+/* static */
+const char* JSONWriter::kEmptyArray = "[]";
+
+/* static */
 void JSONWriter::Write(const Value* const node, std::string* json) {
   WriteWithOptions(node, 0, json);
 }
 
-// static
+/* static */
 void JSONWriter::WriteWithOptions(const Value* const node, int options,
                                   std::string* json) {
   json->clear();
   // Is there a better way to estimate the size of the output?
   json->reserve(1024);
 
+  bool escape = !(options & OPTIONS_DO_NOT_ESCAPE);
   bool omit_binary_values = !!(options & OPTIONS_OMIT_BINARY_VALUES);
   bool omit_double_type_preservation =
       !!(options & OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION);
   bool pretty_print = !!(options & OPTIONS_PRETTY_PRINT);
 
-  JSONWriter writer(omit_binary_values, omit_double_type_preservation,
+  JSONWriter writer(escape, omit_binary_values, omit_double_type_preservation,
                     pretty_print, json);
   writer.BuildJSONString(node, 0);
 
   if (pretty_print)
     json->append(kPrettyPrintLineEnding);
 }
 
-JSONWriter::JSONWriter(bool omit_binary_values,
+JSONWriter::JSONWriter(bool escape, bool omit_binary_values,
                        bool omit_double_type_preservation, bool pretty_print,
                        std::string* json)
-    : omit_binary_values_(omit_binary_values),
+    : escape_(escape),
+      omit_binary_values_(omit_binary_values),
       omit_double_type_preservation_(omit_double_type_preservation),
       pretty_print_(pretty_print),
       json_string_(json) {
   DCHECK(json);
 }
 
 void JSONWriter::BuildJSONString(const Value* const node, int depth) {
   switch (node->GetType()) {
     case Value::TYPE_NULL:
       json_string_->append("null");
@@ skipping 48 matching lines @@
         }
         json_string_->append(real);
         break;
       }
 
     case Value::TYPE_STRING:
       {
         std::string value;
         bool result = node->GetAsString(&value);
         DCHECK(result);
-        EscapeJSONString(value, true, json_string_);
+        if (escape_) {
+          JsonDoubleQuote(UTF8ToUTF16(value), true, json_string_);
+        } else {
+          JsonDoubleQuote(value, true, json_string_);
+        }
         break;
       }
 
     case Value::TYPE_LIST:
       {
         json_string_->append("[");
         if (pretty_print_)
           json_string_->append(" ");
 
         const ListValue* list = static_cast<const ListValue*>(node);
@@ skipping 21 matching lines @@
         break;
       }
 
     case Value::TYPE_DICTIONARY:
       {
         json_string_->append("{");
         if (pretty_print_)
           json_string_->append(kPrettyPrintLineEnding);
 
         const DictionaryValue* dict =
-            static_cast<const DictionaryValue*>(node);
+          static_cast<const DictionaryValue*>(node);
         bool first_entry = true;
         for (DictionaryValue::Iterator itr(*dict); !itr.IsAtEnd();
              itr.Advance(), first_entry = false) {
           if (omit_binary_values_ &&
               itr.value().GetType() == Value::TYPE_BINARY) {
             continue;
           }
 
           if (!first_entry) {
             json_string_->append(",");
             if (pretty_print_)
               json_string_->append(kPrettyPrintLineEnding);
           }
 
           if (pretty_print_)
             IndentLine(depth + 1);
-
-          EscapeJSONString(itr.key(), true, json_string_);
+          AppendQuotedString(itr.key());
           if (pretty_print_) {
             json_string_->append(": ");
           } else {
             json_string_->append(":");
           }
           BuildJSONString(&itr.value(), depth + 1);
         }
 
         if (pretty_print_) {
           json_string_->append(kPrettyPrintLineEnding);
@@ skipping 11 matching lines @@
           NOTREACHED() << "Cannot serialize binary value.";
         }
         break;
       }
 
     default:
       NOTREACHED() << "unknown json type";
   }
 }
 
+void JSONWriter::AppendQuotedString(const std::string& str) {
+  // TODO(viettrungluu): |str| is UTF-8, not ASCII, so to properly escape it we
+  // have to convert it to UTF-16. This round-trip is suboptimal.
+  JsonDoubleQuote(UTF8ToUTF16(str), true, json_string_);
+}
+
 void JSONWriter::IndentLine(int depth) {
   // It may be faster to keep an indent string so we don't have to keep
   // reallocating.
   json_string_->append(std::string(depth * 3, ' '));
 }
 
 }  // namespace base