Make blink::protocol::StringBuilder a distinct type from WTF::StringBuilder.

third_party/inspector_protocol/lib/Values_cpp.template

 // 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 "Values.h"
 
 {% for namespace in config.protocol.namespace %}
 namespace {{namespace}} {
 {% endfor %}
 
 namespace {
 
 const char* const nullValueString = "null";
 const char* const trueValueString = "true";
 const char* const falseValueString = "false";
 
 inline bool escapeChar(uint16_t c, StringBuilder* dst)
 {
     switch (c) {
-    case '\b': dst->append("\\b"); break;
-    case '\f': dst->append("\\f"); break;
-    case '\n': dst->append("\\n"); break;
-    case '\r': dst->append("\\r"); break;
-    case '\t': dst->append("\\t"); break;
-    case '\\': dst->append("\\\\"); break;
-    case '"': dst->append("\\\""); break;
+    case '\b': StringUtil::builderAppend(*dst, "\\b"); break;
+    case '\f': StringUtil::builderAppend(*dst, "\\f"); break;
+    case '\n': StringUtil::builderAppend(*dst, "\\n"); break;
+    case '\r': StringUtil::builderAppend(*dst, "\\r"); break;
+    case '\t': StringUtil::builderAppend(*dst, "\\t"); break;
+    case '\\': StringUtil::builderAppend(*dst, "\\\\"); break;
+    case '"': StringUtil::builderAppend(*dst, "\\\""); break;
     default:
         return false;
     }
     return true;
 }
 
 const char hexDigits[17] = "0123456789ABCDEF";
 
 void appendUnsignedAsHex(uint16_t number, StringBuilder* dst)
 {
-    dst->append("\\u");
+    StringUtil::builderAppend(*dst, "\\u");
     for (size_t i = 0; i < 4; ++i) {
         uint16_t c = hexDigits[(number & 0xF000) >> 12];
-        dst->append(c);
+        StringUtil::builderAppend(*dst, c);
         number <<= 4;
     }
 }
 
 void escapeStringForJSON(const String& str, StringBuilder* dst)
 {
     for (unsigned i = 0; i < str.length(); ++i) {
         uint16_t c = str[i];
         if (!escapeChar(c, dst)) {
             if (c < 32 || c > 126 || c == '<' || c == '>') {
                 // 1. Escaping <, > to prevent script execution.
                 // 2. Technically, we could also pass through c > 126 as UTF8, but this
                 //    is also optional. It would also be a pain to implement here.
                 appendUnsignedAsHex(c, dst);
             } else {
-                dst->append(c);
+                StringUtil::builderAppend(*dst, c);
             }
         }
     }
 }
 
 void doubleQuoteStringForJSON(const String& str, StringBuilder* dst)
 {
-    dst->append('"');
+    StringUtil::builderAppend(*dst, '"');
     escapeStringForJSON(str, dst);
-    dst->append('"');
+    StringUtil::builderAppend(*dst, '"');
 }
 
 } // anonymous namespace
 
 bool Value::asBoolean(bool*) const
 {
     return false;
 }
 
 bool Value::asDouble(double*) const
@@ skipping 12 matching lines @@
 }
 
 bool Value::asSerialized(String*) const
 {
     return false;
 }
 
 void Value::writeJSON(StringBuilder* output) const
 {
     DCHECK(m_type == TypeNull);
-    output->append(nullValueString, 4);
+    StringUtil::builderAppend(*output, nullValueString, 4);
 }
 
 std::unique_ptr<Value> Value::clone() const
 {
     return Value::null();
 }
 
 String Value::serialize()
 {
     StringBuilder result;
     StringUtil::builderReserve(result, 512);
     writeJSON(&result);
-    return result.toString();
+    return StringUtil::builderToString(result);
 }
 
 bool FundamentalValue::asBoolean(bool* output) const
 {
     if (type() != TypeBoolean)
         return false;
     *output = m_boolValue;
     return true;
 }
 
@@ skipping 16 matching lines @@
         return false;
     *output = m_integerValue;
     return true;
 }
 
 void FundamentalValue::writeJSON(StringBuilder* output) const
 {
     DCHECK(type() == TypeBoolean || type() == TypeInteger || type() == TypeDouble);
     if (type() == TypeBoolean) {
         if (m_boolValue)
-            output->append(trueValueString, 4);
+            StringUtil::builderAppend(*output, trueValueString, 4);
         else
-            output->append(falseValueString, 5);
+            StringUtil::builderAppend(*output, falseValueString, 5);
     } else if (type() == TypeDouble) {
         if (!std::isfinite(m_doubleValue)) {
-            output->append(nullValueString, 4);
+            StringUtil::builderAppend(*output, nullValueString, 4);
             return;
         }
-        output->append(StringUtil::fromDouble(m_doubleValue));
+        StringUtil::builderAppend(*output, StringUtil::fromDouble(m_doubleValue));
     } else if (type() == TypeInteger) {
-        output->append(StringUtil::fromInteger(m_integerValue));
+        StringUtil::builderAppend(*output, StringUtil::fromInteger(m_integerValue));
     }
 }
 
 std::unique_ptr<Value> FundamentalValue::clone() const
 {
     switch (type()) {
     case TypeDouble: return FundamentalValue::create(m_doubleValue);
     case TypeInteger: return FundamentalValue::create(m_integerValue);
     case TypeBoolean: return FundamentalValue::create(m_boolValue);
     default:
@@ skipping 21 matching lines @@
 
 bool SerializedValue::asSerialized(String* output) const
 {
     *output = m_serializedValue;
     return true;
 }
 
 void SerializedValue::writeJSON(StringBuilder* output) const
 {
     DCHECK(type() == TypeSerialized);
-    output->append(m_serializedValue);
+    StringUtil::builderAppend(*output, m_serializedValue);
 }
 
 std::unique_ptr<Value> SerializedValue::clone() const
 {
     return SerializedValue::create(m_serializedValue);
 }
 
 DictionaryValue::~DictionaryValue()
 {
 }
@@ skipping 111 matching lines @@
 }
 
 void DictionaryValue::remove(const String& name)
 {
     m_data.erase(name);
     m_order.erase(std::remove(m_order.begin(), m_order.end(), name), m_order.end());
 }
 
 void DictionaryValue::writeJSON(StringBuilder* output) const
 {
-    output->append('{');
+    StringUtil::builderAppend(*output, '{');
     for (size_t i = 0; i < m_order.size(); ++i) {
         Dictionary::const_iterator it = m_data.find(m_order[i]);
         CHECK(it != m_data.end());
         if (i)
-            output->append(',');
+            StringUtil::builderAppend(*output, ',');
         doubleQuoteStringForJSON(it->first, output);
-        output->append(':');
+        StringUtil::builderAppend(*output, ':');
         it->second->writeJSON(output);
     }
-    output->append('}');
+    StringUtil::builderAppend(*output, '}');
 }
 
 std::unique_ptr<Value> DictionaryValue::clone() const
 {
     std::unique_ptr<DictionaryValue> result = DictionaryValue::create();
     for (size_t i = 0; i < m_order.size(); ++i) {
         String key = m_order[i];
         Dictionary::const_iterator value = m_data.find(key);
         DCHECK(value != m_data.cend() && value->second);
         result->setValue(key, value->second->clone());
     }
     return std::move(result);
 }
 
 DictionaryValue::DictionaryValue()
     : Value(TypeObject)
 {
 }
 
 ListValue::~ListValue()
 {
 }
 
 void ListValue::writeJSON(StringBuilder* output) const
 {
-    output->append('[');
+    StringUtil::builderAppend(*output, '[');
     bool first = true;
     for (const std::unique_ptr<protocol::Value>& value : m_data) {
         if (!first)
-            output->append(',');
+            StringUtil::builderAppend(*output, ',');
         value->writeJSON(output);
         first = false;
     }
-    output->append(']');
+    StringUtil::builderAppend(*output, ']');
 }
 
 std::unique_ptr<Value> ListValue::clone() const
 {
     std::unique_ptr<ListValue> result = ListValue::create();
     for (const std::unique_ptr<protocol::Value>& value : m_data)
         result->pushValue(value->clone());
     return std::move(result);
 }
 
@@ skipping 10 matching lines @@
 
 protocol::Value* ListValue::at(size_t index)
 {
     DCHECK_LT(index, m_data.size());
     return m_data[index].get();
 }
 
 {% for namespace in config.protocol.namespace %}
 } // namespace {{namespace}}
 {% endfor %}