diff --git a/sky/engine/bindings/dart_ui.cc b/sky/engine/bindings/dart_ui.cc
index e113ef746fdf8e58a96b9e7eb78984eba7a8fc59..3c94d5e8ca7ac333e5a594e2d63ef136ae530c60 100644
--- a/sky/engine/bindings/dart_ui.cc
+++ b/sky/engine/bindings/dart_ui.cc
@@ -6,6 +6,8 @@
 
 #include "gen/sky/bindings/DartGlobal.h"
 #include "sky/engine/bindings/dart_runtime_hooks.h"
+#include "sky/engine/core/compositing/Scene.h"
+#include "sky/engine/core/compositing/SceneBuilder.h"
 #include "sky/engine/core/painting/painting.h"
 #include "sky/engine/core/window/window.h"
 #include "sky/engine/tonic/dart_converter.h"
@@ -40,6 +42,8 @@ void DartUI::InitForIsolate() {
     DartRuntimeHooks::RegisterNatives(g_natives);
     Window::RegisterNatives(g_natives);
     Painting::RegisterNatives(g_natives);
+    Scene::RegisterNatives(g_natives);
+    SceneBuilder::RegisterNatives(g_natives);
   }
 
   DART_CHECK_VALID(Dart_SetNativeResolver(
diff --git a/sky/engine/bindings/scripts/dart_types.py b/sky/engine/bindings/scripts/dart_types.py
index 60440f0bb44fbc21b32340bcb03a262fc1c59ebf..12a4e707a1e91f29f0855d1ab3b9e7d3cdc50b8c 100644
--- a/sky/engine/bindings/scripts/dart_types.py
+++ b/sky/engine/bindings/scripts/dart_types.py
@@ -346,7 +346,7 @@ def pass_by_value_format(typename, null_check="{null_check}"):
 DART_TO_CPP_VALUE = {
     # Basic
     'Date': 'DartUtilities::dartToDate(args, {index}, exception)',
-    'DOMString': 'DartConverter<String>::FromArguments{null_check}(args, {index}, exception, {auto_scope})',
+    'DOMString': 'DartConverter<String>::FromArguments{null_check}(args, {index}, exception)',
     'ByteString': 'DartUtilities::dartToByteString{null_check}(args, {index}, exception, {auto_scope})',
     'ScalarValueString': 'DartUtilities::dartToScalarValueString{null_check}(args, {index}, exception, {auto_scope})',
     'boolean': 'DartConverter<bool>::FromArguments(args, {index}, exception)',
diff --git a/sky/engine/core/compositing/Scene.cpp b/sky/engine/core/compositing/Scene.cpp
index e03f6b58ff4d138eb31a90e6ac2476a929195d1a..0906f85b0704d85cb35ecfcb9d1047eaa08a9660 100644
--- a/sky/engine/core/compositing/Scene.cpp
+++ b/sky/engine/core/compositing/Scene.cpp
@@ -6,8 +6,26 @@
 
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
+#include "sky/engine/tonic/dart_args.h"
+#include "sky/engine/tonic/dart_converter.h"
+#include "sky/engine/tonic/dart_library_natives.h"
 
 namespace blink {
+namespace {
+
+void DisposeCallback(Dart_NativeArguments args) {
+  DartCall(&Scene::dispose, args);
+}
+
+}  // namespace
+
+IMPLEMENT_WRAPPERTYPEINFO(Scene);
+
+void Scene::RegisterNatives(DartLibraryNatives* natives) {
+  natives->Register({
+    { "Scene_dispose", DisposeCallback, 1, true },
+  });
+}
 
 PassRefPtr<Scene> Scene::create(
     std::unique_ptr<sky::compositor::Layer> rootLayer,
diff --git a/sky/engine/core/compositing/Scene.h b/sky/engine/core/compositing/Scene.h
index f80523a88d78de790993d75c11b0c1eb03654bd1..0369093280cc1e50a526dc6e79ea062244868b3b 100644
--- a/sky/engine/core/compositing/Scene.h
+++ b/sky/engine/core/compositing/Scene.h
@@ -16,6 +16,7 @@
 #include "third_party/skia/include/core/SkPicture.h"
 
 namespace blink {
+class DartLibraryNatives;
 
 class Scene : public RefCounted<Scene>, public DartWrappable {
   DEFINE_WRAPPERTYPEINFO();
@@ -30,6 +31,8 @@ class Scene : public RefCounted<Scene>, public DartWrappable {
 
   void dispose();
 
+  static void RegisterNatives(DartLibraryNatives* natives);
+
  private:
   explicit Scene(std::unique_ptr<sky::compositor::Layer> rootLayer,
                  uint32_t rasterizerTracingThreshold);
diff --git a/sky/engine/core/compositing/Scene.idl b/sky/engine/core/compositing/Scene.idl
deleted file mode 100644
index e3e8f0ea3487b418673829438823f460c9573e23..0000000000000000000000000000000000000000
--- a/sky/engine/core/compositing/Scene.idl
+++ /dev/null
@@ -1,8 +0,0 @@
-// 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.
-
-// An opaque handle to a composited scene.
-interface Scene {
-    void dispose();
-};
diff --git a/sky/engine/core/compositing/SceneBuilder.cpp b/sky/engine/core/compositing/SceneBuilder.cpp
index beb9a547b512d436fb3a2afed81ceff8deb1e313..e334cfc5a9e1e4f922cc192e8aecf21fb91da1e6 100644
--- a/sky/engine/core/compositing/SceneBuilder.cpp
+++ b/sky/engine/core/compositing/SceneBuilder.cpp
@@ -15,8 +15,88 @@
 #include "sky/compositor/picture_layer.h"
 #include "sky/compositor/statistics_layer.h"
 #include "sky/compositor/transform_layer.h"
+#include "sky/engine/tonic/dart_args.h"
+#include "sky/engine/tonic/dart_converter.h"
+#include "sky/engine/tonic/dart_library_natives.h"
 
 namespace blink {
+namespace {
+
+void ConstructorCallback(Dart_NativeArguments args) {
+  DartCallConstructor(&SceneBuilder::create, args);
+}
+
+void PushTransformCallback(Dart_NativeArguments args) {
+  DartArgIterator it(args);
+  Float64List matrix4 = it.GetNext<Float64List>();
+  if (it.had_exception())
+    return;
+  ExceptionState es;
+  GetReceiver<SceneBuilder>(args)->pushTransform(matrix4, es);
+  if (es.had_exception())
+    Dart_ThrowException(es.GetDartException(args, true));
+}
+
+void PushClipRectCallback(Dart_NativeArguments args) {
+  DartCall(&SceneBuilder::pushClipRect, args);
+}
+
+void PushClipRRectCallback(Dart_NativeArguments args) {
+  DartCall(&SceneBuilder::pushClipRRect, args);
+}
+
+void PushClipPathCallback(Dart_NativeArguments args) {
+  DartCall(&SceneBuilder::pushClipPath, args);
+}
+
+void PushOpacityCallback(Dart_NativeArguments args) {
+  DartCall(&SceneBuilder::pushOpacity, args);
+}
+
+void PushColorFilterCallback(Dart_NativeArguments args) {
+  DartCall(&SceneBuilder::pushColorFilter, args);
+}
+
+void PopCallback(Dart_NativeArguments args) {
+  DartCall(&SceneBuilder::pop, args);
+}
+
+void AddPictureCallback(Dart_NativeArguments args) {
+  DartCall(&SceneBuilder::addPicture, args);
+}
+
+void AddStatisticsCallback(Dart_NativeArguments args) {
+  DartCall(&SceneBuilder::addStatistics, args);
+}
+
+void SetRasterizerTracingThresholdCallback(Dart_NativeArguments args) {
+  DartCall(&SceneBuilder::setRasterizerTracingThreshold, args);
+}
+
+void BuildCallback(Dart_NativeArguments args) {
+  DartCallAndReturn(&SceneBuilder::build, args);
+}
+
+}  // namespace
+
+IMPLEMENT_WRAPPERTYPEINFO(SceneBuilder);
+
+void SceneBuilder::RegisterNatives(DartLibraryNatives* natives) {
+  natives->Register({
+    { "SceneBuilder_constructor", ConstructorCallback, 2, true },
+    { "SceneBuilder_pushTransform", PushTransformCallback, 2, true },
+    { "SceneBuilder_pushClipRect", PushClipRectCallback, 2, true },
+    { "SceneBuilder_pushClipRRect", PushClipRRectCallback, 3, true },
+    { "SceneBuilder_pushClipPath", PushClipPathCallback, 3, true },
+    { "SceneBuilder_pushOpacity", PushOpacityCallback, 3, true },
+    { "SceneBuilder_pushColorFilter", PushColorFilterCallback, 4, true },
+    { "SceneBuilder_pop", PopCallback, 1, true },
+    { "SceneBuilder_addPicture", AddPictureCallback, 4, true },
+    { "SceneBuilder_addStatistics", AddStatisticsCallback, 3, true },
+    { "SceneBuilder_setRasterizerTracingThreshold", SetRasterizerTracingThresholdCallback, 2, true },
+    { "SceneBuilder_build", BuildCallback, 1, true },
+  });
+}
 
 SceneBuilder::SceneBuilder(const Rect& bounds)
     : m_rootPaintBounds(bounds.sk_rect)
@@ -69,7 +149,7 @@ void SceneBuilder::pushOpacity(int alpha, const Rect& bounds)
     addLayer(std::move(layer));
 }
 
-void SceneBuilder::pushColorFilter(SkColor color, SkXfermode::Mode transferMode, const Rect& bounds)
+void SceneBuilder::pushColorFilter(CanvasColor color, TransferMode transferMode, const Rect& bounds)
 {
     std::unique_ptr<sky::compositor::ColorFilterLayer> layer(new sky::compositor::ColorFilterLayer());
     if (!bounds.is_null)
diff --git a/sky/engine/core/compositing/SceneBuilder.h b/sky/engine/core/compositing/SceneBuilder.h
index 1691ba4259b55b227776e4b5179c5eed995afc2c..d8d06626d62e7711bc93e8d03d64812a73be9336 100644
--- a/sky/engine/core/compositing/SceneBuilder.h
+++ b/sky/engine/core/compositing/SceneBuilder.h
@@ -40,7 +40,7 @@ public:
     void pushClipRRect(const RRect& rrect, const Rect& bounds);
     void pushClipPath(const CanvasPath* path, const Rect& bounds);
     void pushOpacity(int alpha, const Rect& bounds);
-    void pushColorFilter(SkColor color, SkXfermode::Mode transferMode, const Rect& bounds);
+    void pushColorFilter(CanvasColor color, TransferMode transferMode, const Rect& bounds);
     void pop();
 
     void addPicture(const Offset& offset, Picture* picture, const Rect& bounds);
@@ -50,6 +50,8 @@ public:
 
     PassRefPtr<Scene> build();
 
+    static void RegisterNatives(DartLibraryNatives* natives);
+
 private:
     explicit SceneBuilder(const Rect& bounds);
 
diff --git a/sky/engine/core/compositing/SceneBuilder.idl b/sky/engine/core/compositing/SceneBuilder.idl
deleted file mode 100644
index 2681e8ca850b77aa8e90451d151996bf31f06f2e..0000000000000000000000000000000000000000
--- a/sky/engine/core/compositing/SceneBuilder.idl
+++ /dev/null
@@ -1,21 +0,0 @@
-// 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.
-
-[
-  Constructor(Rect bounds),
-] interface SceneBuilder {
-  [RaisesException] void pushTransform(Float64List matrix4);
-  void pushClipRect(Rect rect);
-  void pushClipRRect(RRect rrect, Rect bounds);
-  void pushClipPath(Path path, Rect bounds);
-  void pushOpacity(long alpha, Rect bounds);
-  void pushColorFilter(Color color, TransferMode transferMode, Rect bounds);
-  void pop();
-
-  void addPicture(Offset offset, Picture picture, Rect bounds);
-  void addStatistics(unsigned long enabledOptions, Rect bounds);
-  void setRasterizerTracingThreshold(unsigned long frameInterval);
-
-  Scene build();
-};
diff --git a/sky/engine/core/core.gni b/sky/engine/core/core.gni
index c2179369974e5608baba6472d04d500d2200850d..744e294339997b5bf1a7d09ec9c027b38302f72c 100644
--- a/sky/engine/core/core.gni
+++ b/sky/engine/core/core.gni
@@ -236,8 +236,6 @@ sky_core_files = [
 ]
 
 core_idl_files = get_path_info([
-                                 "compositing/Scene.idl",
-                                 "compositing/SceneBuilder.idl",
                                  "painting/Canvas.idl",
                                  "painting/ColorFilter.idl",
                                  "painting/Drawable.idl",
@@ -258,6 +256,7 @@ core_idl_files = get_path_info([
                                "abspath")
 
 core_dart_files = get_path_info([
+                                  "dart/compositing.dart",
                                   "dart/hash_codes.dart",
                                   "dart/hooks.dart",
                                   "dart/lerp.dart",
diff --git a/sky/engine/core/dart/compositing.dart b/sky/engine/core/dart/compositing.dart
new file mode 100644
index 0000000000000000000000000000000000000000..aa5635a460b48148a020404de7e6f1d830923c80
--- /dev/null
+++ b/sky/engine/core/dart/compositing.dart
@@ -0,0 +1,29 @@
+// 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.
+
+part of dart_ui;
+
+abstract class Scene extends NativeFieldWrapperClass2 {
+  void dispose() native "Scene_dispose";
+}
+
+class SceneBuilder extends NativeFieldWrapperClass2 {
+  void _constructor(Rect bounds) native "SceneBuilder_constructor";
+  SceneBuilder(Rect bounds) { _constructor(bounds); }
+
+  void pushTransform(Float64List matrix4) native "SceneBuilder_pushTransform";
+  void pushClipRect(Rect rect) native "SceneBuilder_pushClipRect";
+  void pushClipRRect(RRect rrect, Rect bounds) native "SceneBuilder_pushClipRRect";
+  void pushClipPath(Path path, Rect bounds) native "SceneBuilder_pushClipPath";
+  void pushOpacity(int alpha, Rect bounds) native "SceneBuilder_pushOpacity";
+  void pushColorFilter(Color color, TransferMode transferMode, Rect bounds) native "SceneBuilder_pushColorFilter";
+
+  void pop() native "SceneBuilder_pop";
+
+  void addPicture(Offset offset, Picture picture, Rect bounds) native "SceneBuilder_addPicture";
+  void addStatistics(int enabledOptions, Rect bounds) native "SceneBuilder_addStatistics";
+  void setRasterizerTracingThreshold(int frameInterval) native "SceneBuilder_setRasterizerTracingThreshold";
+
+  Scene build() native "SceneBuilder_build";
+}
diff --git a/sky/engine/core/painting/CanvasColor.cpp b/sky/engine/core/painting/CanvasColor.cpp
index 11733c184cf4d3517114750169463135765556a0..d3f1b563b5751c98233084b4d5fd1bef47a87689 100644
--- a/sky/engine/core/painting/CanvasColor.cpp
+++ b/sky/engine/core/painting/CanvasColor.cpp
@@ -22,7 +22,7 @@ SkColor DartConverter<CanvasColor>::FromDart(Dart_Handle dart_color) {
   return static_cast<SkColor>(color);
 }
 
-SkColor DartConverter<CanvasColor>::FromArgumentsWithNullCheck(
+SkColor DartConverter<CanvasColor>::FromArguments(
     Dart_NativeArguments args,
     int index,
     Dart_Handle& exception) {
diff --git a/sky/engine/core/painting/CanvasColor.h b/sky/engine/core/painting/CanvasColor.h
index 0e727ea0416bf552f06a662684a3f533ca894516..245c2cd43c3c6f8d4e69df49fb43885abf6b60b0 100644
--- a/sky/engine/core/painting/CanvasColor.h
+++ b/sky/engine/core/painting/CanvasColor.h
@@ -13,7 +13,13 @@
 
 namespace blink {
 
-class CanvasColor {};
+struct CanvasColor {
+  SkColor color;
+
+  CanvasColor(SkColor color) : color(color) { }
+  CanvasColor() : color() { }
+  operator SkColor() { return color; }
+};
 
 template <>
 struct DartConverterTypes<CanvasColor> {
@@ -24,9 +30,14 @@ struct DartConverterTypes<CanvasColor> {
 template <>
 struct DartConverter<CanvasColor> {
   static SkColor FromDart(Dart_Handle handle);
+  static SkColor FromArguments(Dart_NativeArguments args,
+                               int index,
+                               Dart_Handle& exception);
   static SkColor FromArgumentsWithNullCheck(Dart_NativeArguments args,
                                             int index,
-                                            Dart_Handle& exception);
+                                            Dart_Handle& exception) {
+    return FromArguments(args, index, exception);
+  }
   static void SetReturnValue(Dart_NativeArguments args, SkColor val);
 };
 
diff --git a/sky/engine/core/painting/Offset.cpp b/sky/engine/core/painting/Offset.cpp
index 6fcdff9568d6b9fbb633ec17f48b3d729cb7a460..c8f7d2f1f8bbb47dca60cb90f9072cd7ea016c10 100644
--- a/sky/engine/core/painting/Offset.cpp
+++ b/sky/engine/core/painting/Offset.cpp
@@ -29,7 +29,7 @@ Offset DartConverter<Offset>::FromDart(Dart_Handle handle) {
   return result;
 }
 
-Offset DartConverter<Offset>::FromArgumentsWithNullCheck(
+Offset DartConverter<Offset>::FromArguments(
     Dart_NativeArguments args,
     int index,
     Dart_Handle& exception) {
diff --git a/sky/engine/core/painting/Offset.h b/sky/engine/core/painting/Offset.h
index 2a0acf22b0290ac56416aeb050f98fc2de51f192..1a920803ad0762ae994f1ecaab45013a7ad0a6d6 100644
--- a/sky/engine/core/painting/Offset.h
+++ b/sky/engine/core/painting/Offset.h
@@ -20,9 +20,14 @@ class Offset {
 template <>
 struct DartConverter<Offset> {
   static Offset FromDart(Dart_Handle handle);
+  static Offset FromArguments(Dart_NativeArguments args,
+                              int index,
+                              Dart_Handle& exception);
   static Offset FromArgumentsWithNullCheck(Dart_NativeArguments args,
-                                          int index,
-                                          Dart_Handle& exception);
+                                           int index,
+                                           Dart_Handle& exception) {
+    return FromArguments(args, index, exception);
+  }
 };
 
 } // namespace blink
diff --git a/sky/engine/core/painting/RRect.cpp b/sky/engine/core/painting/RRect.cpp
index b5f138b485c8f3154458b883ec6cfaa56e917de5..6d47dc6c49801d3cf85d2e78913e691ac0d1afbd 100644
--- a/sky/engine/core/painting/RRect.cpp
+++ b/sky/engine/core/painting/RRect.cpp
@@ -42,9 +42,9 @@ RRect DartConverter<RRect>::FromDart(Dart_Handle dart_rrect) {
   return result;
 }
 
-RRect DartConverter<RRect>::FromArgumentsWithNullCheck(Dart_NativeArguments args,
-                                                       int index,
-                                                       Dart_Handle& exception) {
+RRect DartConverter<RRect>::FromArguments(Dart_NativeArguments args,
+                                          int index,
+                                          Dart_Handle& exception) {
   Dart_Handle dart_rrect = Dart_GetNativeArgument(args, index);
   DCHECK(!LogIfError(dart_rrect));
   return FromDart(dart_rrect);
diff --git a/sky/engine/core/painting/RRect.h b/sky/engine/core/painting/RRect.h
index 5357972709e35da92d03a895a635cc279df2a076..016f8d27e8d7a505419d02d05a0b2ed83a931a1a 100644
--- a/sky/engine/core/painting/RRect.h
+++ b/sky/engine/core/painting/RRect.h
@@ -20,9 +20,14 @@ class RRect {
 template <>
 struct DartConverter<RRect> {
   static RRect FromDart(Dart_Handle handle);
+  static RRect FromArguments(Dart_NativeArguments args,
+                             int index,
+                             Dart_Handle& exception);
   static RRect FromArgumentsWithNullCheck(Dart_NativeArguments args,
                                           int index,
-                                          Dart_Handle& exception);
+                                          Dart_Handle& exception) {
+    return FromArguments(args, index, exception);
+  }
 };
 
 } // namespace blink
diff --git a/sky/engine/core/painting/Rect.cpp b/sky/engine/core/painting/Rect.cpp
index 65dea9592906d8761633b2d903c0beb45a5010ab..37213d39a3aba88cfc07a6cfb784fe8f05aba616 100644
--- a/sky/engine/core/painting/Rect.cpp
+++ b/sky/engine/core/painting/Rect.cpp
@@ -46,9 +46,9 @@ Rect DartConverter<Rect>::FromDart(Dart_Handle dart_rect) {
   return result;
 }
 
-Rect DartConverter<Rect>::FromArgumentsWithNullCheck(Dart_NativeArguments args,
-                                                     int index,
-                                                     Dart_Handle& exception) {
+Rect DartConverter<Rect>::FromArguments(Dart_NativeArguments args,
+                                        int index,
+                                        Dart_Handle& exception) {
   Dart_Handle dart_rect = Dart_GetNativeArgument(args, index);
   DCHECK(!LogIfError(dart_rect));
   return FromDart(dart_rect);
diff --git a/sky/engine/core/painting/Rect.h b/sky/engine/core/painting/Rect.h
index 359bcdfdb02570d9aa8fdf8133c81aca7d0d3653..57cfdf1b87e37f8306ed37f94e0ef9b12dba6e3f 100644
--- a/sky/engine/core/painting/Rect.h
+++ b/sky/engine/core/painting/Rect.h
@@ -20,9 +20,14 @@ class Rect {
 template <>
 struct DartConverter<Rect> {
   static Rect FromDart(Dart_Handle handle);
+  static Rect FromArguments(Dart_NativeArguments args,
+                            int index,
+                            Dart_Handle& exception);
   static Rect FromArgumentsWithNullCheck(Dart_NativeArguments args,
                                          int index,
-                                         Dart_Handle& exception);
+                                         Dart_Handle& exception) {
+    return FromArguments(args, index, exception);
+  }
 };
 
 } // namespace blink
diff --git a/sky/engine/core/painting/TransferMode.h b/sky/engine/core/painting/TransferMode.h
index fd90c6b88c5eb15e6d00d71e1725454d4ad1fdc8..1cc8d3eb789f3e6cdf3e5be0cb90a6d98d1c3c69 100644
--- a/sky/engine/core/painting/TransferMode.h
+++ b/sky/engine/core/painting/TransferMode.h
@@ -10,7 +10,13 @@
 
 namespace blink {
 
-class TransferMode {};
+struct TransferMode {
+  SkXfermode::Mode mode;
+
+  TransferMode() : mode() { }
+  TransferMode(SkXfermode::Mode mode) : mode(mode) { }
+  operator SkXfermode::Mode() { return mode; }
+};
 
 template <>
 struct DartConverter<TransferMode>
diff --git a/sky/engine/tonic/dart_args.h b/sky/engine/tonic/dart_args.h
new file mode 100644
index 0000000000000000000000000000000000000000..2cfe1195f85d2ce808dd5553c82bc87b5a636307
--- /dev/null
+++ b/sky/engine/tonic/dart_args.h
@@ -0,0 +1,168 @@
+// 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_ARGS_H_
+#define SKY_ENGINE_TONIC_DART_ARGS_H_
+
+#include <type_traits>
+
+#include "sky/engine/tonic/dart_converter.h"
+#include "sky/engine/tonic/dart_wrappable.h"
+#include "dart/runtime/include/dart_api.h"
+
+namespace blink {
+
+class DartArgIterator {
+ public:
+  explicit DartArgIterator(Dart_NativeArguments args)
+      : args_(args), index_(1), had_exception_(false) { }
+
+  template<typename T>
+  T GetNext() {
+    if (had_exception_)
+      return T();
+    Dart_Handle exception = nullptr;
+    T arg = DartConverter<T>::FromArguments(args_, index_++, exception);
+    if (exception) {
+      had_exception_ = true;
+      Dart_ThrowException(exception);
+    }
+    return arg;
+  }
+
+  bool had_exception() const { return had_exception_; }
+
+  Dart_NativeArguments args() const { return args_; }
+
+ private:
+  Dart_NativeArguments args_;
+  int index_;
+  bool had_exception_;
+
+  DISALLOW_COPY_AND_ASSIGN(DartArgIterator);
+};
+
+// Classes for generating and storing an argument pack of integer indices
+// (based on well-known "indices trick", see: http://goo.gl/bKKojn):
+template <size_t... indices>
+struct IndicesHolder {};
+
+template <size_t requested_index, size_t... indices>
+struct IndicesGenerator {
+  using type = typename IndicesGenerator<requested_index - 1,
+                                         requested_index - 1,
+                                         indices...>::type;
+};
+
+template <size_t... indices>
+struct IndicesGenerator<0, indices...> {
+  using type = IndicesHolder<indices...>;
+};
+
+template <typename T>
+class IndicesForSignature {};
+
+template <typename ResultType,
+          typename... ArgTypes>
+struct IndicesForSignature<ResultType (*)(ArgTypes...)> {
+  using type = typename IndicesGenerator<sizeof...(ArgTypes)>::type;
+};
+
+template <typename C,
+          typename ResultType,
+          typename... ArgTypes>
+struct IndicesForSignature<ResultType (C::*)(ArgTypes...)> {
+  using type = typename IndicesGenerator<sizeof...(ArgTypes)>::type;
+};
+
+template<size_t index, typename ArgType>
+struct DartArgHolder {
+  using ValueType = typename std::remove_const<
+    typename std::remove_reference<ArgType>::type
+  >::type;
+
+  ValueType value;
+
+  explicit DartArgHolder(DartArgIterator* it)
+      : value(it->GetNext<ValueType>()) {}
+};
+
+template <typename IndicesType, typename T>
+class DartDecoder {
+};
+
+template <size_t... indices,
+          typename ResultType,
+          typename... ArgTypes>
+struct DartDecoder<IndicesHolder<indices...>, ResultType (*)(ArgTypes...)>
+    : public DartArgHolder<indices, ArgTypes>... {
+  using FunctionPtr = ResultType (*)(ArgTypes...);
+
+  DartArgIterator* it_;
+
+  explicit DartDecoder(DartArgIterator* it)
+      : DartArgHolder<indices, ArgTypes>(it)..., it_(it) { }
+
+  ResultType Dispatch(FunctionPtr func) {
+    return (*func)(DartArgHolder<indices, ArgTypes>::value...);
+  }
+};
+
+template <size_t... indices,
+          typename C,
+          typename ResultType,
+          typename... ArgTypes>
+struct DartDecoder<IndicesHolder<indices...>, ResultType (C::*)(ArgTypes...)>
+    : public DartArgHolder<indices, ArgTypes>... {
+  using FunctionPtr = ResultType (C::*)(ArgTypes...);
+
+  DartArgIterator* it_;
+
+  explicit DartDecoder(DartArgIterator* it)
+      : DartArgHolder<indices, ArgTypes>(it)..., it_(it) { }
+
+  ResultType Dispatch(FunctionPtr func) {
+    return (GetReceiver<C>(it_->args())->*func)(
+        DartArgHolder<indices, ArgTypes>::value...);
+  }
+};
+
+template<typename T>
+void DartReturn(T result, Dart_NativeArguments args) {
+  DartConverter<T>::SetReturnValue(args, result);
+}
+
+template<typename Sig>
+void DartCall(Sig func, Dart_NativeArguments args) {
+  DartArgIterator it(args);
+  using Indices = typename IndicesForSignature<Sig>::type;
+  DartDecoder<Indices, Sig> decoder(&it);
+  if (it.had_exception())
+    return;
+  decoder.Dispatch(func);
+}
+
+template<typename Sig>
+void DartCallAndReturn(Sig func, Dart_NativeArguments args) {
+  DartArgIterator it(args);
+  using Indices = typename IndicesForSignature<Sig>::type;
+  DartDecoder<Indices, Sig> decoder(&it);
+  if (it.had_exception())
+    return;
+  DartReturn(decoder.Dispatch(func), args);
+}
+
+template<typename Sig>
+void DartCallConstructor(Sig func, Dart_NativeArguments args) {
+  DartArgIterator it(args);
+  using Indices = typename IndicesForSignature<Sig>::type;
+  DartDecoder<Indices, Sig> decoder(&it);
+  if (it.had_exception())
+    return;
+  decoder.Dispatch(func)->AssociateWithDartWrapper(args);
+}
+
+}  // namespace blink
+
+#endif  // SKY_ENGINE_TONIC_DART_ARGS_H_
diff --git a/sky/engine/tonic/dart_converter.h b/sky/engine/tonic/dart_converter.h
index 9cb95cac376ac6d69233a03086a78b3a2160e480..ffb3471d5b9aff151d3c6b81616b349c17f65cfc 100644
--- a/sky/engine/tonic/dart_converter.h
+++ b/sky/engine/tonic/dart_converter.h
@@ -226,8 +226,7 @@ struct DartConverter<String> {
 
   static String FromArguments(Dart_NativeArguments args,
                               int index,
-                              Dart_Handle& exception,
-                              bool auto_scope = true) {
+                              Dart_Handle& exception) {
     // TODO(abarth): What should we do with auto_scope?
     void* peer = nullptr;
     Dart_Handle handle = Dart_GetNativeStringArgument(args, index, &peer);
@@ -309,8 +308,7 @@ struct DartConverter<Vector<T>> {
 
   static Vector<ValueType> FromArguments(Dart_NativeArguments args,
                                           int index,
-                                          Dart_Handle& exception,
-                                          bool auto_scope = true) {
+                                          Dart_Handle& exception) {
     // TODO(abarth): What should we do with auto_scope?
     return FromDart(Dart_GetNativeArgument(args, index));
   }
@@ -335,8 +333,7 @@ struct DartConverter<DartValue*> {
 
   static PassRefPtr<DartValue> FromArguments(Dart_NativeArguments args,
                                              int index,
-                                             Dart_Handle& exception,
-                                             bool auto_scope = true) {
+                                             Dart_Handle& exception) {
     // TODO(abarth): What should we do with auto_scope?
     return FromDart(Dart_GetNativeArgument(args, index));
   }
diff --git a/sky/engine/tonic/dart_wrappable.h b/sky/engine/tonic/dart_wrappable.h
index 2a1add9916c8a6d33453e7276f39be3b48f895e2..0be3eea86e42f77163b7c264df67b4d96c4f1469 100644
--- a/sky/engine/tonic/dart_wrappable.h
+++ b/sky/engine/tonic/dart_wrappable.h
@@ -65,6 +65,21 @@ class DartWrappable {
  private:                                                                      \
   static const DartWrapperInfo& dart_wrapper_info_
 
+#define IMPLEMENT_WRAPPERTYPEINFO(ClassName)                                   \
+static void RefObject(DartWrappable* impl) {                                   \
+  static_cast<ClassName*>(impl)->ref();                                        \
+}                                                                              \
+static void DerefObject(DartWrappable* impl) {                                 \
+  static_cast<ClassName*>(impl)->deref();                                      \
+}                                                                              \
+static const DartWrapperInfo kDartWrapperInfo = {                              \
+  #ClassName,                                                                  \
+  sizeof(ClassName),                                                           \
+  &RefObject,                                                                  \
+  &DerefObject,                                                                \
+};                                                                             \
+const DartWrapperInfo& ClassName::dart_wrapper_info_ = kDartWrapperInfo;                                   \
+
 struct DartConverterWrappable {
   static DartWrappable* FromDart(Dart_Handle handle);
   static DartWrappable* FromArguments(Dart_NativeArguments args,
@@ -79,7 +94,7 @@ template<typename T>
 struct DartConverter<
     T*,
     typename base::enable_if<
-        base::is_convertible<T*, DartWrappable*>::value>::type> {
+        base::is_convertible<T*, const DartWrappable*>::value>::type> {
   static Dart_Handle ToDart(DartWrappable* val) {
     if (!val)
       return Dart_Null();
@@ -134,6 +149,15 @@ struct DartConverter<RefPtr<T>> {
   }
 };
 
+template<typename T>
+struct DartConverter<PassRefPtr<T>> {
+  static void SetReturnValue(Dart_NativeArguments args,
+                             PassRefPtr<T> val,
+                             bool auto_scope = true) {
+    DartConverter<T*>::SetReturnValue(args, val.get());
+  }
+};
+
 template<typename T>
 inline T* GetReceiver(Dart_NativeArguments args) {
   intptr_t receiver;
diff --git a/sky/engine/tonic/float32_list.cc b/sky/engine/tonic/float32_list.cc
index 2ca962dd7b427a7e4080ac2316ca77a66e16153e..5102a757fc5c8742ed79a9e3e6d3fb59b74be7ed 100644
--- a/sky/engine/tonic/float32_list.cc
+++ b/sky/engine/tonic/float32_list.cc
@@ -7,6 +7,9 @@
 
 namespace blink {
 
+Float32List::Float32List()
+    : data_(nullptr), num_elements_(0), dart_handle_(nullptr) {}
+
 Float32List::Float32List(Dart_Handle list)
     : data_(nullptr), num_elements_(0), dart_handle_(list) {
   if (Dart_IsNull(list))
@@ -32,7 +35,7 @@ Float32List::~Float32List() {
     Dart_TypedDataReleaseData(dart_handle_);
 }
 
-Float32List DartConverter<Float32List>::FromArgumentsWithNullCheck(
+Float32List DartConverter<Float32List>::FromArguments(
     Dart_NativeArguments args,
     int index,
     Dart_Handle& exception) {
diff --git a/sky/engine/tonic/float32_list.h b/sky/engine/tonic/float32_list.h
index 98b037a80ece832639fc6f764cabfe0de1580904..cfd2109b533d09fbe017826f12bba8d3644a445a 100644
--- a/sky/engine/tonic/float32_list.h
+++ b/sky/engine/tonic/float32_list.h
@@ -19,6 +19,7 @@ class Float32List {
  public:
   explicit Float32List(Dart_Handle list);
   Float32List(Float32List&& other);
+  Float32List();
   ~Float32List();
 
   float& at(intptr_t i)
@@ -50,10 +51,14 @@ class Float32List {
 template <>
 struct DartConverter<Float32List> {
   static void SetReturnValue(Dart_NativeArguments args, Float32List val);
-
+  static Float32List FromArguments(Dart_NativeArguments args,
+                                   int index,
+                                   Dart_Handle& exception);
   static Float32List FromArgumentsWithNullCheck(Dart_NativeArguments args,
                                                 int index,
-                                                Dart_Handle& exception);
+                                                Dart_Handle& exception) {
+    return FromArguments(args, index, exception);
+  }
 };
 
 } // namespace blink
diff --git a/sky/engine/tonic/float64_list.cc b/sky/engine/tonic/float64_list.cc
index 28a6f00a7e25727f7723076ae8582b03b772ea30..39f168eaef3111748e90f76a07610cacc64a25ad 100644
--- a/sky/engine/tonic/float64_list.cc
+++ b/sky/engine/tonic/float64_list.cc
@@ -7,6 +7,9 @@
 
 namespace blink {
 
+Float64List::Float64List()
+    : data_(nullptr), num_elements_(0), dart_handle_(nullptr) {}
+
 Float64List::Float64List(Dart_Handle list)
     : data_(nullptr), num_elements_(0), dart_handle_(list) {
   if (Dart_IsNull(list))
@@ -32,7 +35,7 @@ Float64List::~Float64List() {
     Dart_TypedDataReleaseData(dart_handle_);
 }
 
-Float64List DartConverter<Float64List>::FromArgumentsWithNullCheck(
+Float64List DartConverter<Float64List>::FromArguments(
     Dart_NativeArguments args,
     int index,
     Dart_Handle& exception) {
diff --git a/sky/engine/tonic/float64_list.h b/sky/engine/tonic/float64_list.h
index 325b883ad81c336a9c4b09e0465b57ddaf307b76..144823ab25d6457bbcf91006e8faf5f447a05335 100644
--- a/sky/engine/tonic/float64_list.h
+++ b/sky/engine/tonic/float64_list.h
@@ -19,6 +19,7 @@ class Float64List {
  public:
   explicit Float64List(Dart_Handle list);
   Float64List(Float64List&& other);
+  Float64List();
   ~Float64List();
 
   double& at(intptr_t i)
@@ -50,10 +51,14 @@ class Float64List {
 template <>
 struct DartConverter<Float64List> {
   static void SetReturnValue(Dart_NativeArguments args, Float64List val);
-
+  static Float64List FromArguments(Dart_NativeArguments args,
+                                   int index,
+                                   Dart_Handle& exception);
   static Float64List FromArgumentsWithNullCheck(Dart_NativeArguments args,
                                                 int index,
-                                                Dart_Handle& exception);
+                                                Dart_Handle& exception) {
+    return FromArguments(args, index, exception);
+  }
 };
 
 } // namespace blink
diff --git a/sky/engine/tonic/int32_list.cc b/sky/engine/tonic/int32_list.cc
index ca626fabe5aeac71f153666d2c1574d1a2edde3b..d479d0328b843e5a5b4777b83598f0cfff799b8e 100644
--- a/sky/engine/tonic/int32_list.cc
+++ b/sky/engine/tonic/int32_list.cc
@@ -7,6 +7,9 @@
 
 namespace blink {
 
+Int32List::Int32List()
+    : data_(nullptr), num_elements_(0), dart_handle_(nullptr) {}
+
 Int32List::Int32List(Dart_Handle list)
     : data_(nullptr), num_elements_(0), dart_handle_(list) {
   if (Dart_IsNull(list))
@@ -39,7 +42,7 @@ void Int32List::Release() {
 }
 
 
-Int32List DartConverter<Int32List>::FromArgumentsWithNullCheck(
+Int32List DartConverter<Int32List>::FromArguments(
     Dart_NativeArguments args,
     int index,
     Dart_Handle& exception) {
diff --git a/sky/engine/tonic/int32_list.h b/sky/engine/tonic/int32_list.h
index 8fc74042483495e8e5406a69349ad14a1a0cfda7..03e1d090e4257b01f4c484295a606fb359d4f9ef 100644
--- a/sky/engine/tonic/int32_list.h
+++ b/sky/engine/tonic/int32_list.h
@@ -19,6 +19,7 @@ class Int32List {
  public:
   explicit Int32List(Dart_Handle list);
   Int32List(Int32List&& other);
+  Int32List();
   ~Int32List();
 
   int32_t& at(intptr_t i)
@@ -52,10 +53,14 @@ class Int32List {
 template <>
 struct DartConverter<Int32List> {
   static void SetReturnValue(Dart_NativeArguments args, Int32List val);
-
+  static Int32List FromArguments(Dart_NativeArguments args,
+                                 int index,
+                                 Dart_Handle& exception);
   static Int32List FromArgumentsWithNullCheck(Dart_NativeArguments args,
                                               int index,
-                                              Dart_Handle& exception);
+                                              Dart_Handle& exception) {
+    return FromArguments(args, index, exception);
+  }
 };
 
 } // namespace blink
diff --git a/sky/engine/tonic/uint8_list.cc b/sky/engine/tonic/uint8_list.cc
index 0a2458e18c20855abea534d62fc625ff27d3869f..f272023c09d5c2dad79519a1be7d2fe8c146cd00 100644
--- a/sky/engine/tonic/uint8_list.cc
+++ b/sky/engine/tonic/uint8_list.cc
@@ -7,6 +7,9 @@
 
 namespace blink {
 
+Uint8List::Uint8List()
+    : data_(nullptr), num_elements_(0), dart_handle_(nullptr) {}
+
 Uint8List::Uint8List(Dart_Handle list)
     : data_(nullptr), num_elements_(0), dart_handle_(list) {
   if (Dart_IsNull(list))
@@ -32,7 +35,7 @@ Uint8List::~Uint8List() {
     Dart_TypedDataReleaseData(dart_handle_);
 }
 
-Uint8List DartConverter<Uint8List>::FromArgumentsWithNullCheck(
+Uint8List DartConverter<Uint8List>::FromArguments(
     Dart_NativeArguments args,
     int index,
     Dart_Handle& exception) {
diff --git a/sky/engine/tonic/uint8_list.h b/sky/engine/tonic/uint8_list.h
index a54349adb9d72fd79e1d39a23618164eb3d94210..b99e08e1155876f12cbf6be75f231aac497d5881 100644
--- a/sky/engine/tonic/uint8_list.h
+++ b/sky/engine/tonic/uint8_list.h
@@ -19,6 +19,7 @@ class Uint8List {
  public:
   explicit Uint8List(Dart_Handle list);
   Uint8List(Uint8List&& other);
+  Uint8List();
   ~Uint8List();
 
   uint8& at(intptr_t i)
@@ -50,10 +51,14 @@ class Uint8List {
 template <>
 struct DartConverter<Uint8List> {
   static void SetReturnValue(Dart_NativeArguments args, Uint8List val);
-
+  static Uint8List FromArguments(Dart_NativeArguments args,
+                                 int index,
+                                 Dart_Handle& exception);
   static Uint8List FromArgumentsWithNullCheck(Dart_NativeArguments args,
                                               int index,
-                                              Dart_Handle& exception);
+                                              Dart_Handle& exception) {
+    return FromArguments(args, index, exception);
+  }
 
   static Dart_Handle ToDart(const uint8_t* buffer, unsigned int length);
 };