Use StringBuilder::appendLiteral() / StringBuilder::append(char) when possible

Source/platform/JSONValues.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 28 matching lines @@
 
 namespace {
 
 const char* const nullString = "null";
 const char* const trueString = "true";
 const char* const falseString = "false";
 
 inline bool escapeChar(UChar c, StringBuilder* dst)
 {
     switch (c) {
-    case '\b': dst->append("\\b", 2); break;
-    case '\f': dst->append("\\f", 2); break;
-    case '\n': dst->append("\\n", 2); break;
-    case '\r': dst->append("\\r", 2); break;
-    case '\t': dst->append("\\t", 2); break;
-    case '\\': dst->append("\\\\", 2); break;
-    case '"': dst->append("\\\"", 2); break;
+    case '\b': dst->appendLiteral("\\b"); break;
+    case '\f': dst->appendLiteral("\\f"); break;
+    case '\n': dst->appendLiteral("\\n"); break;
+    case '\r': dst->appendLiteral("\\r"); break;
+    case '\t': dst->appendLiteral("\\t"); break;
+    case '\\': dst->appendLiteral("\\\\"); break;
+    case '"': dst->appendLiteral("\\\""); break;
     default:
         return false;
     }
     return true;
 }
 
 inline void doubleQuoteString(const String& str, StringBuilder* dst)
 {
     dst->append('"');
     for (unsigned i = 0; i < str.length(); ++i) {
@@ skipping 10 matching lines @@
                 dst->append(c);
             }
         }
     }
     dst->append('"');
 }
 
 void writeIndent(int depth, StringBuilder* output)
 {
     for (int i = 0; i < depth; ++i)
-        output->append("  ");
+        output->appendLiteral("  ");
 }
 
 } // anonymous namespace
 
 bool JSONValue::asBoolean(bool*) const
 {
     return false;
 }
 
 bool JSONValue::asNumber(double*) const
@@ skipping 291 matching lines @@
             output->append(',');
         doubleQuoteString(it->key, output);
         output->append(':');
         it->value->writeJSON(output);
     }
     output->append('}');
 }
 
 void JSONObjectBase::prettyWriteJSONInternal(StringBuilder* output, int depth) const
 {
-    output->append("{\n");
+    output->appendLiteral("{\n");
     for (size_t i = 0; i < m_order.size(); ++i) {
         Dictionary::const_iterator it = m_data.find(m_order[i]);
         ASSERT_WITH_SECURITY_IMPLICATION(it != m_data.end());
         if (i)
-            output->append(",\n");
+            output->appendLiteral(",\n");
         writeIndent(depth + 1, output);
         doubleQuoteString(it->key, output);
-        output->append(": ");
+        output->appendLiteral(": ");
         it->value->prettyWriteJSONInternal(output, depth + 1);
     }
     output->append('\n');
     writeIndent(depth, output);
     output->append('}');
 }
 
 JSONObjectBase::JSONObjectBase()
     : JSONValue(TypeObject)
     , m_data()
@@ skipping 103 matching lines @@
     m_data.append(value);
 }
 
 PassRefPtr<JSONValue> JSONArrayBase::get(size_t index)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(index < m_data.size());
     return m_data[index];
 }
 
 } // namespace blink