diff --git a/mojo/dart/embedder/BUILD.gn b/mojo/dart/embedder/BUILD.gn
index f15e4aa..df63c0c 100644
--- a/mojo/dart/embedder/BUILD.gn
+++ b/mojo/dart/embedder/BUILD.gn
@@ -48,6 +48,7 @@
     "//third_party/dart-pkg",
     "//mojo/public/c/system",
     "//mojo/public/cpp/system",
+    "//tonic",
   ]
 
   defines = []
diff --git a/tonic/BUILD.gn b/tonic/BUILD.gn
index 4f37841..b3e7dd6 100644
--- a/tonic/BUILD.gn
+++ b/tonic/BUILD.gn
@@ -39,14 +39,8 @@
     "dart_snapshot_loader.h",
     "dart_state.cc",
     "dart_state.h",
-    "dart_string.cc",
-    "dart_string.h",
-    "dart_string_cache.cc",
-    "dart_string_cache.h",
     "dart_timer_heap.cc",
     "dart_timer_heap.h",
-    "dart_value.cc",
-    "dart_value.h",
     "dart_wrappable.cc",
     "dart_wrappable.h",
     "dart_wrapper_info.h",
@@ -59,7 +53,31 @@
     "//base",
     "//mojo/common",
     "//mojo/public/cpp/system",
-    "//sky/engine/wtf",
+  ]
+
+  public_deps = [
+    "//dart/runtime:libdart",
+    "//dart/runtime/vm:libdart_platform",
+  ]
+}
+
+# TODO(johnmccutchan): Move these sources into sky_engine and remove this.
+source_set("tonic_wtf") {
+  sources = [
+    "dart_converter_wtf.cc",
+    "dart_converter_wtf.h",
+    "dart_string.cc",
+    "dart_string.h",
+    "dart_string_cache.cc",
+    "dart_string_cache.h",
+    "dart_value.cc",
+    "dart_value.h",
+  ]
+
+  deps = [
+    "//base",
+    "//mojo/common",
+    "//mojo/public/cpp/system",
   ]
 
   public_deps = [
diff --git a/tonic/dart_converter.h b/tonic/dart_converter.h
index 47d9f84..f0387b2 100644
--- a/tonic/dart_converter.h
+++ b/tonic/dart_converter.h
@@ -6,12 +6,8 @@
 #define SKY_ENGINE_TONIC_DART_CONVERTER_H_
 
 #include <string>
+
 #include "tonic/dart_state.h"
-#include "tonic/dart_string.h"
-#include "tonic/dart_string_cache.h"
-#include "tonic/dart_value.h"
-#include "sky/engine/wtf/text/StringUTF8Adaptor.h"
-#include "sky/engine/wtf/text/WTFString.h"
 
 namespace blink {
 
@@ -176,187 +172,6 @@
   }
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// Strings
-
-template <>
-struct DartConverter<String> {
-  static Dart_Handle ToDart(DartState* state, const String& val) {
-    if (val.isEmpty())
-      return Dart_EmptyString();
-    return Dart_HandleFromWeakPersistent(state->string_cache().Get(val.impl()));
-  }
-
-  static void SetReturnValue(Dart_NativeArguments args,
-                             const String& val,
-                             bool auto_scope = true) {
-    // TODO(abarth): What should we do with auto_scope?
-    if (val.isEmpty()) {
-      Dart_SetReturnValue(args, Dart_EmptyString());
-      return;
-    }
-    DartState* state = DartState::Current();
-    Dart_SetWeakHandleReturnValue(args, state->string_cache().Get(val.impl()));
-  }
-
-  static void SetReturnValueWithNullCheck(Dart_NativeArguments args,
-                                          const String& val,
-                                          bool auto_scope = true) {
-    if (val.isNull())
-      Dart_SetReturnValue(args, Dart_Null());
-    else
-      SetReturnValue(args, val, auto_scope);
-  }
-
-  static String FromDart(Dart_Handle handle) {
-    intptr_t char_size = 0;
-    intptr_t length = 0;
-    void* peer = nullptr;
-    Dart_Handle result =
-        Dart_StringGetProperties(handle, &char_size, &length, &peer);
-    if (peer)
-      return String(static_cast<StringImpl*>(peer));
-    if (Dart_IsError(result))
-      return String();
-    return ExternalizeDartString(handle);
-  }
-
-  static String FromArguments(Dart_NativeArguments args,
-                              int index,
-                              Dart_Handle& exception,
-                              bool auto_scope = true) {
-    // TODO(abarth): What should we do with auto_scope?
-    void* peer = nullptr;
-    Dart_Handle handle = Dart_GetNativeStringArgument(args, index, &peer);
-    if (peer)
-      return reinterpret_cast<StringImpl*>(peer);
-    if (Dart_IsError(handle))
-      return String();
-    return ExternalizeDartString(handle);
-  }
-
-  static String FromArgumentsWithNullCheck(Dart_NativeArguments args,
-                                           int index,
-                                           Dart_Handle& exception,
-                                           bool auto_scope = true) {
-    // TODO(abarth): What should we do with auto_scope?
-    void* peer = nullptr;
-    Dart_Handle handle = Dart_GetNativeStringArgument(args, index, &peer);
-    if (peer)
-      return reinterpret_cast<StringImpl*>(peer);
-    if (Dart_IsError(handle) || Dart_IsNull(handle))
-      return String();
-    return ExternalizeDartString(handle);
-  }
-};
-
-template <>
-struct DartConverter<AtomicString> {
-  static Dart_Handle ToDart(DartState* state, const AtomicString& val) {
-    return DartConverter<String>::ToDart(state, val.string());
-  }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Collections
-
-template <typename T>
-struct DartConverter<Vector<T>> {
-  using ValueType = typename DartConverterTypes<T>::ValueType;
-  using ConverterType = typename DartConverterTypes<T>::ConverterType;
-
-  static Dart_Handle ToDart(const Vector<ValueType>& val) {
-    Dart_Handle list = Dart_NewList(val.size());
-    if (Dart_IsError(list))
-      return list;
-    for (size_t i = 0; i < val.size(); i++) {
-      Dart_Handle result =
-          Dart_ListSetAt(list, i,
-                         DartConverter<ConverterType>::ToDart(val[i]));
-      if (Dart_IsError(result))
-        return result;
-    }
-    return list;
-  }
-
-  static Vector<ValueType> FromDart(Dart_Handle handle) {
-    Vector<ValueType> result;
-    if (!Dart_IsList(handle))
-      return result;
-    intptr_t length = 0;
-    Dart_ListLength(handle, &length);
-    result.reserveCapacity(length);
-    for (intptr_t i = 0; i < length; ++i) {
-      Dart_Handle item = Dart_ListGetAt(handle, i);
-      DCHECK(!Dart_IsError(item));
-      DCHECK(item);
-      result.append(DartConverter<ConverterType>::FromDart(item));
-    }
-    return result;
-  }
-
-  static Vector<ValueType> FromArguments(Dart_NativeArguments args,
-                                          int index,
-                                          Dart_Handle& exception,
-                                          bool auto_scope = true) {
-    // TODO(abarth): What should we do with auto_scope?
-    return FromDart(Dart_GetNativeArgument(args, index));
-  }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// DartValue
-
-template <>
-struct DartConverter<DartValue*> {
-  static Dart_Handle ToDart(DartState* state, DartValue* val) {
-    return val->dart_value();
-  }
-
-  static void SetReturnValue(Dart_NativeArguments args, DartValue* val) {
-    Dart_SetReturnValue(args, val->dart_value());
-  }
-
-  static PassRefPtr<DartValue> FromDart(Dart_Handle handle) {
-    return DartValue::Create(DartState::Current(), handle);
-  }
-
-  static PassRefPtr<DartValue> FromArguments(Dart_NativeArguments args,
-                                             int index,
-                                             Dart_Handle& exception,
-                                             bool auto_scope = true) {
-    // TODO(abarth): What should we do with auto_scope?
-    return FromDart(Dart_GetNativeArgument(args, index));
-  }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-// Convience wrappers for commonly used conversions
-
-inline Dart_Handle StringToDart(DartState* state, const String& val) {
-  return DartConverter<String>::ToDart(state, val);
-}
-
-inline Dart_Handle StringToDart(DartState* state, const AtomicString& val) {
-  return DartConverter<AtomicString>::ToDart(state, val);
-}
-
-inline String StringFromDart(Dart_Handle handle) {
-  return DartConverter<String>::FromDart(handle);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Convience wrappers using type inference for ease of code generation
-
-template <typename T>
-inline Dart_Handle VectorToDart(const Vector<T>& val) {
-  return DartConverter<Vector<T>>::ToDart(val);
-}
-
-template<typename T>
-Dart_Handle ToDart(const T& object) {
-  return DartConverter<T>::ToDart(object);
-}
 
 ////////////////////////////////////////////////////////////////////////////////
 // std::string support (slower, but more convienent for some clients)
@@ -367,9 +182,14 @@
 }
 
 inline std::string StdStringFromDart(Dart_Handle handle) {
-  String string = StringFromDart(handle);
-  StringUTF8Adaptor utf8(string);
-  return std::string(utf8.data(), utf8.length());
+  uint8_t* data = nullptr;
+  intptr_t length = 0;
+  Dart_Handle r = Dart_StringToUTF8(handle, &data, &length);
+  if (Dart_IsError(r)) {
+    return std::string();
+  }
+  return std::string(reinterpret_cast<const char*>(data),
+                     static_cast<size_t>(length));
 }
 
 
diff --git a/tonic/dart_converter_wtf.cc b/tonic/dart_converter_wtf.cc
new file mode 100644
index 0000000..6fe5ae7
--- /dev/null
+++ b/tonic/dart_converter_wtf.cc
@@ -0,0 +1,8 @@
+// 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 "tonic/dart_converter_wtf.h"
+
+// This file exists to ensure dart_converter_wtf.h doesn't miss any
+// dependencies.
diff --git a/tonic/dart_converter_wtf.h b/tonic/dart_converter_wtf.h
new file mode 100644
index 0000000..5a48748
--- /dev/null
+++ b/tonic/dart_converter_wtf.h
@@ -0,0 +1,211 @@
+// 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.
+
+#ifndef SKY_ENGINE_TONIC_DART_CONVERTER_WTF_H_
+#define SKY_ENGINE_TONIC_DART_CONVERTER_WTF_H_
+
+#include <string>
+#include "sky/engine/wtf/text/StringUTF8Adaptor.h"
+#include "sky/engine/wtf/text/WTFString.h"
+#include "tonic/dart_converter.h"
+#include "tonic/dart_string.h"
+#include "tonic/dart_string_cache.h"
+#include "tonic/dart_value.h"
+
+namespace blink {
+
+////////////////////////////////////////////////////////////////////////////////
+// Strings
+
+template <>
+struct DartConverter<String> {
+  static Dart_Handle ToDart(DartState* state, const String& val) {
+    if (val.isEmpty())
+      return Dart_EmptyString();
+    return Dart_HandleFromWeakPersistent(state->string_cache().Get(val.impl()));
+  }
+
+  static void SetReturnValue(Dart_NativeArguments args,
+                             const String& val,
+                             bool auto_scope = true) {
+    // TODO(abarth): What should we do with auto_scope?
+    if (val.isEmpty()) {
+      Dart_SetReturnValue(args, Dart_EmptyString());
+      return;
+    }
+    DartState* state = DartState::Current();
+    Dart_SetWeakHandleReturnValue(args, state->string_cache().Get(val.impl()));
+  }
+
+  static void SetReturnValueWithNullCheck(Dart_NativeArguments args,
+                                          const String& val,
+                                          bool auto_scope = true) {
+    if (val.isNull())
+      Dart_SetReturnValue(args, Dart_Null());
+    else
+      SetReturnValue(args, val, auto_scope);
+  }
+
+  static String FromDart(Dart_Handle handle) {
+    intptr_t char_size = 0;
+    intptr_t length = 0;
+    void* peer = nullptr;
+    Dart_Handle result =
+        Dart_StringGetProperties(handle, &char_size, &length, &peer);
+    if (peer)
+      return String(static_cast<StringImpl*>(peer));
+    if (Dart_IsError(result))
+      return String();
+    return ExternalizeDartString(handle);
+  }
+
+  static String FromArguments(Dart_NativeArguments args,
+                              int index,
+                              Dart_Handle& exception,
+                              bool auto_scope = true) {
+    // TODO(abarth): What should we do with auto_scope?
+    void* peer = nullptr;
+    Dart_Handle handle = Dart_GetNativeStringArgument(args, index, &peer);
+    if (peer)
+      return reinterpret_cast<StringImpl*>(peer);
+    if (Dart_IsError(handle))
+      return String();
+    return ExternalizeDartString(handle);
+  }
+
+  static String FromArgumentsWithNullCheck(Dart_NativeArguments args,
+                                           int index,
+                                           Dart_Handle& exception,
+                                           bool auto_scope = true) {
+    // TODO(abarth): What should we do with auto_scope?
+    void* peer = nullptr;
+    Dart_Handle handle = Dart_GetNativeStringArgument(args, index, &peer);
+    if (peer)
+      return reinterpret_cast<StringImpl*>(peer);
+    if (Dart_IsError(handle) || Dart_IsNull(handle))
+      return String();
+    return ExternalizeDartString(handle);
+  }
+};
+
+template <>
+struct DartConverter<AtomicString> {
+  static Dart_Handle ToDart(DartState* state, const AtomicString& val) {
+    return DartConverter<String>::ToDart(state, val.string());
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Collections
+
+template <typename T>
+struct DartConverter<Vector<T>> {
+  using ValueType = typename DartConverterTypes<T>::ValueType;
+  using ConverterType = typename DartConverterTypes<T>::ConverterType;
+
+  static Dart_Handle ToDart(const Vector<ValueType>& val) {
+    Dart_Handle list = Dart_NewList(val.size());
+    if (Dart_IsError(list))
+      return list;
+    for (size_t i = 0; i < val.size(); i++) {
+      Dart_Handle result =
+          Dart_ListSetAt(list, i,
+                         DartConverter<ConverterType>::ToDart(val[i]));
+      if (Dart_IsError(result))
+        return result;
+    }
+    return list;
+  }
+
+  static Vector<ValueType> FromDart(Dart_Handle handle) {
+    Vector<ValueType> result;
+    if (!Dart_IsList(handle))
+      return result;
+    intptr_t length = 0;
+    Dart_ListLength(handle, &length);
+    result.reserveCapacity(length);
+    for (intptr_t i = 0; i < length; ++i) {
+      Dart_Handle item = Dart_ListGetAt(handle, i);
+      DCHECK(!Dart_IsError(item));
+      DCHECK(item);
+      result.append(DartConverter<ConverterType>::FromDart(item));
+    }
+    return result;
+  }
+
+  static Vector<ValueType> FromArguments(Dart_NativeArguments args,
+                                          int index,
+                                          Dart_Handle& exception,
+                                          bool auto_scope = true) {
+    // TODO(abarth): What should we do with auto_scope?
+    return FromDart(Dart_GetNativeArgument(args, index));
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// DartValue
+
+template <>
+struct DartConverter<DartValue*> {
+  static Dart_Handle ToDart(DartState* state, DartValue* val) {
+    return val->dart_value();
+  }
+
+  static void SetReturnValue(Dart_NativeArguments args, DartValue* val) {
+    Dart_SetReturnValue(args, val->dart_value());
+  }
+
+  static PassRefPtr<DartValue> FromDart(Dart_Handle handle) {
+    return DartValue::Create(DartState::Current(), handle);
+  }
+
+  static PassRefPtr<DartValue> FromArguments(Dart_NativeArguments args,
+                                             int index,
+                                             Dart_Handle& exception,
+                                             bool auto_scope = true) {
+    // TODO(abarth): What should we do with auto_scope?
+    return FromDart(Dart_GetNativeArgument(args, index));
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Convience wrappers for commonly used conversions
+
+inline Dart_Handle StringToDart(DartState* state, const String& val) {
+  return DartConverter<String>::ToDart(state, val);
+}
+
+inline Dart_Handle StringToDart(DartState* state, const AtomicString& val) {
+  return DartConverter<AtomicString>::ToDart(state, val);
+}
+
+inline String StringFromDart(Dart_Handle handle) {
+  return DartConverter<String>::FromDart(handle);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Convience wrappers using type inference for ease of code generation
+
+template <typename T>
+inline Dart_Handle VectorToDart(const Vector<T>& val) {
+  return DartConverter<Vector<T>>::ToDart(val);
+}
+
+template<typename T>
+Dart_Handle ToDart(const T& object) {
+  return DartConverter<T>::ToDart(object);
+}
+
+template<typename T>
+struct DartConverter<RefPtr<T>> {
+  static Dart_Handle ToDart(RefPtr<T> val) {
+    return DartConverter<T*>::ToDart(val.get());
+  }
+
+  static RefPtr<T> FromDart(Dart_Handle handle) {
+    return DartConverter<T*>::FromDart(handle);
+  }
+};
+
+#endif  // SKY_ENGINE_TONIC_DART_CONVERTER_WTF_H_
diff --git a/tonic/dart_library_loader.cc b/tonic/dart_library_loader.cc
index a6492ad..dbb73f7 100644
--- a/tonic/dart_library_loader.cc
+++ b/tonic/dart_library_loader.cc
@@ -56,7 +56,8 @@
       loader_->DidFailJob(this);
       return;
     }
-    drainer_ = adoptPtr(new DataPipeDrainer(this, pipe.Pass()));
+    drainer_ = std::unique_ptr<DataPipeDrainer>(
+        new DataPipeDrainer(this, pipe.Pass()));
   }
 
   // DataPipeDrainer::Client
@@ -67,7 +68,7 @@
   // Subclasses must implement OnDataComplete.
 
   std::string name_;
-  OwnPtr<DataPipeDrainer> drainer_;
+  std::unique_ptr<DataPipeDrainer> drainer_;
 
   base::WeakPtrFactory<Job> weak_factory_;
 };
@@ -150,7 +151,8 @@
   WatcherSignaler(DartLibraryLoader& loader,
                   DartDependency* resolved_dependency)
       : loader_(loader),
-        catcher_(adoptPtr(new DartDependencyCatcher(loader))),
+        catcher_(std::unique_ptr<DartDependencyCatcher>(
+                    new DartDependencyCatcher(loader))),
         resolved_dependency_(resolved_dependency) {}
 
   ~WatcherSignaler() {
@@ -164,7 +166,7 @@
     // Notice that we remove the dependency catcher and extract all the
     // callbacks before running any of them. We don't want to be re-entered
     // below the callbacks and end up in an inconsistent state.
-    catcher_.clear();
+    catcher_.reset();
     std::vector<base::Closure> callbacks;
     for (const auto& watcher : completed_watchers) {
       callbacks.push_back(watcher->callback());
@@ -178,7 +180,7 @@
 
  private:
   DartLibraryLoader& loader_;
-  OwnPtr<DartDependencyCatcher> catcher_;
+  std::unique_ptr<DartDependencyCatcher> catcher_;
   DartDependency* resolved_dependency_;
 };
 
diff --git a/tonic/dart_state.cc b/tonic/dart_state.cc
index 60732bd..76851ce 100644
--- a/tonic/dart_state.cc
+++ b/tonic/dart_state.cc
@@ -8,7 +8,6 @@
 #include "tonic/dart_converter.h"
 #include "tonic/dart_exception_factory.h"
 #include "tonic/dart_library_loader.h"
-#include "tonic/dart_string_cache.h"
 #include "tonic/dart_timer_heap.h"
 
 namespace blink {
@@ -26,8 +25,6 @@
           new DartExceptionFactory(this))),
       library_loader_(std::unique_ptr<DartLibraryLoader>(
           new DartLibraryLoader(this))),
-      string_cache_(std::unique_ptr<DartStringCache>(
-          new DartStringCache)),
       timer_heap_(std::unique_ptr<DartTimerHeap>(
           new DartTimerHeap())),
       weak_factory_(this) {
diff --git a/tonic/dart_state.h b/tonic/dart_state.h
index 5eafb55..e56d38a 100644
--- a/tonic/dart_state.h
+++ b/tonic/dart_state.h
@@ -17,7 +17,6 @@
 class DartClassLibrary;
 class DartExceptionFactory;
 class DartLibraryLoader;
-class DartStringCache;
 class DartTimerHeap;
 
 // DartState represents the state associated with a given Dart isolate. The
@@ -51,7 +50,6 @@
   DartClassLibrary& class_library() { return *class_library_; }
   DartExceptionFactory& exception_factory() { return *exception_factory_; }
   DartLibraryLoader& library_loader() { return *library_loader_; }
-  DartStringCache& string_cache() { return *string_cache_; }
   DartTimerHeap& timer_heap() { return *timer_heap_; }
 
   Dart_Handle index_handle() { return index_handle_.value(); }
@@ -63,7 +61,6 @@
   std::unique_ptr<DartClassLibrary> class_library_;
   std::unique_ptr<DartExceptionFactory> exception_factory_;
   std::unique_ptr<DartLibraryLoader> library_loader_;
-  std::unique_ptr<DartStringCache> string_cache_;
   std::unique_ptr<DartTimerHeap> timer_heap_;
   DartPersistentValue index_handle_;
 
diff --git a/tonic/dart_wrappable.h b/tonic/dart_wrappable.h
index 13feb99..9428601 100644
--- a/tonic/dart_wrappable.h
+++ b/tonic/dart_wrappable.h
@@ -123,17 +123,6 @@
 };
 
 template<typename T>
-struct DartConverter<RefPtr<T>> {
-  static Dart_Handle ToDart(RefPtr<T> val) {
-    return DartConverter<T*>::ToDart(val.get());
-  }
-
-  static RefPtr<T> FromDart(Dart_Handle handle) {
-    return DartConverter<T*>::FromDart(handle);
-  }
-};
-
-template<typename T>
 inline T* GetReceiver(Dart_NativeArguments args) {
   intptr_t receiver;
   Dart_Handle result = Dart_GetNativeReceiver(args, &receiver);
diff --git a/tonic/float32_list.cc b/tonic/float32_list.cc
index 6bcfc7a..38e67e5 100644
--- a/tonic/float32_list.cc
+++ b/tonic/float32_list.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/logging.h"
 #include "tonic/dart_error.h"
 #include "tonic/float32_list.h"
 
@@ -16,7 +17,7 @@
   Dart_TypedDataAcquireData(
       list, &type, reinterpret_cast<void**>(&data_), &num_elements_);
   DCHECK(!LogIfError(list));
-  ASSERT(type == Dart_TypedData_kFloat32);
+  DCHECK(type == Dart_TypedData_kFloat32);
 }
 
 Float32List::Float32List(Float32List&& other)