Port more String and HashMap usages

sky/engine/tonic/dart_exception_factory.cc

 // Copyright 2015 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 "sky/engine/tonic/dart_exception_factory.h"
 
 #include "sky/engine/tonic/dart_converter.h"
 #include "sky/engine/tonic/dart_builtin.h"
-#include "sky/engine/wtf/text/StringBuilder.h"
 
 namespace blink {
 
+// TODO(johnmccutchan): Move this into another file.
+class StdStringBuilder {
+ public:
+  StdStringBuilder() {
+  }
+
+  void Append(const char* s, intptr_t length) {
+    if (s == NULL) {
+      return;
+    }
+    for (intptr_t i = 0; i < length; i++) {
+      buffer_.push_back(s[i]);
+    }
+  }
+
+  void Append(const char* s) {
+    if (s == NULL) {
+      return;
+    }
+    for (intptr_t i = 0; s[i] != '\0'; i++) {
+      buffer_.push_back(s[i]);
+    }
+  }
+
+  void Append(char ch) {
+    buffer_.push_back(ch);
+  }
+
+  void Append(std::string s) {
+    if (s.length() == 0) {
+      return;
+    }
+    const char* c_str = s.data();
+    intptr_t c_str_length = s.size();
+    Append(c_str, c_str_length);
+  }
+
+  void AppendNumber(int num) {
+    Append(std::to_string(num));
+  }
+
+  void Clear() {
+    buffer_.resize(0);
+  }
+
+  void ShrinkToFit() {
+    buffer_.shrink_to_fit();
+  }
+
+  void Reserve(intptr_t capacity) {
+    buffer_.reserve(capacity);
+  }
+
+  std::string ToString() {
+    return std::string(buffer_.data(), buffer_.size());
+  }
+
+  const char* data() const {
+    return buffer_.data();
+  }
+
+  char* data() {
+    return buffer_.data();
+  }
+
+  intptr_t size() const {
+    return buffer_.size();
+  }
+
+ private:
+  std::vector<char> buffer_;
+
+  DISALLOW_COPY_AND_ASSIGN(StdStringBuilder);
+};
+
 DartExceptionFactory::DartExceptionFactory(DartState* dart_state)
     : dart_state_(dart_state) {
 }
 
 DartExceptionFactory::~DartExceptionFactory() {
 }
 
 Dart_Handle DartExceptionFactory::CreateNullArgumentException(int index) {
-  StringBuilder message;
-  message.appendLiteral("Argument ");
-  message.appendNumber(index);
-  message.appendLiteral(" cannot be null.");
-  return CreateException("ArgumentError", message.toString());
+  StdStringBuilder builder;
+  builder.Append("Argument ");
+  builder.AppendNumber(index);
+  builder.Append(" cannot be null.");
+  Dart_Handle message_handle = Dart_NewStringFromUTF8(
+      reinterpret_cast<const uint8_t*>(builder.data()), builder.size());
+  return CreateException("ArgumentError", message_handle);
 }
 
-Dart_Handle DartExceptionFactory::CreateException(const String& class_name,
-                                                  const String& message) {
+Dart_Handle DartExceptionFactory::CreateException(const std::string& class_name,
+                                                  const std::string& message) {
+  return CreateException(class_name, StdStringToDart(message));
+}
+
+Dart_Handle DartExceptionFactory::CreateException(const std::string& class_name,
+                                                  Dart_Handle message) {
   if (core_library_.is_empty()) {
     Dart_Handle library = DartBuiltin::LookupLibrary("dart:core");
     core_library_.Set(dart_state_, library);
   }
 
   Dart_Handle exception_class = Dart_GetType(
-      core_library_.value(), StringToDart(dart_state_, class_name), 0, 0);
-  Dart_Handle message_handle = StringToDart(dart_state_, message);
-  return Dart_New(exception_class, Dart_EmptyString(), 1, &message_handle);
+      core_library_.value(), StdStringToDart(class_name), 0, 0);
+  return Dart_New(exception_class, Dart_EmptyString(), 1, &message);
 }
 
 }  // namespace blink