Added Dartium changes onto 45.0.2454.104

Source/bindings/core/dart/DartUtilities.h

Index: Source/bindings/core/dart/DartUtilities.h
diff --git a/Source/bindings/core/dart/DartUtilities.h b/Source/bindings/core/dart/DartUtilities.h
new file mode 100644
index 0000000000000000000000000000000000000000..97f2fb24e3412db3fc115df3308e4ca256ff6369
--- /dev/null
+++ b/Source/bindings/core/dart/DartUtilities.h
@@ -0,0 +1,1314 @@
+// Copyright 2011, 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
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef DartUtilities_h
+#define DartUtilities_h
+
+#if OS(ANDROID)
+#include <sys/system_properties.h>
+#endif
+
+
+#include "bindings/core/v8/Dictionary.h"
+#include "bindings/core/dart/DartDOMData.h"
+#include "bindings/core/dart/DartScriptValue.h"
+#include "bindings/core/dart/DartStringCache.h"
+#include "bindings/core/v8/SerializedScriptValue.h"
+#include "bindings/core/v8/V8RecursionScope.h"
+#include "bindings/core/v8/V8ScriptState.h"
+#include "bindings/dart/DartWebkitClassIds.h"
+#include "core/dom/DOMStringList.h"
+#include "core/dom/MessagePort.h"
+#include "core/inspector/ScriptCallFrame.h"
+#include "modules/mediastream/MediaStreamTrack.h"
+#include "platform/heap/Heap.h"
+
+#include "wtf/ArrayBufferView.h"
+#include "wtf/Float32Array.h"
+#include "wtf/HashMap.h"
+#include "wtf/ListHashSet.h"
+#include "wtf/Uint8Array.h"
+#include "wtf/text/WTFString.h"
+#include <dart_api.h>
+#include <dart_tools_api.h>
+
+namespace WTF {
+class ArrayBuffer;
+class Uint8ClampedArray;
+}
+
+namespace blink {
+
+class Dictionary;
+class Frame;
+class SQLValue;
+class ScriptArguments;
+class ScriptCallStack;
+class ExecutionContext;
+class SerializedScriptValue;
+
+class DartStringPeer {
+public:
+    explicit DartStringPeer(PassRefPtr<StringImpl> stringImpl)
+        : m_plainString(stringImpl), m_atomicString(), m_atomicCached(false)
+    {
+    }
+
+    explicit DartStringPeer(StringImpl* stringImpl)
+        : m_plainString(stringImpl), m_atomicString(), m_atomicCached(false)
+    {
+    }
+
+    const String& toString() const { return m_plainString; }
+    const AtomicString& toAtomicString()
+    {
+        if (m_atomicCached)
+            return m_atomicString;
+        return toAtomicStringSlow();
+    }
+    const AtomicString& toAtomicStringSlow()
+    {
+        if (!m_plainString.isNull()) {
+            m_atomicString = AtomicString(m_plainString);
+            ASSERT(!m_atomicString.isNull());
+        }
+        m_atomicCached = true;
+        return m_atomicString;
+    }
+    static DartStringPeer* nullString();
+    static DartStringPeer* emptyString();
+
+private:
+    DartStringPeer() : m_plainString(), m_atomicString()
+    {
+    }
+
+    String m_plainString;
+    AtomicString m_atomicString;
+    bool m_atomicCached;
+};
+
+class DartStringAdapter {
+public:
+    explicit DartStringAdapter(DartStringPeer* stringPeer) : m_stringPeer(stringPeer)
+    {
+        ASSERT(stringPeer);
+    }
+
+    operator String() const { return m_stringPeer->toString(); }
+    operator AtomicString() const { return m_stringPeer->toAtomicString(); }
+
+private:
+    DartStringPeer* m_stringPeer;
+};
+
+class DartApiScope {
+public:
+    DartApiScope() { Dart_EnterScope(); }
+    ~DartApiScope() { Dart_ExitScope(); }
+};
+
+class DartUtilities {
+public:
+    static Dart_Handle stringImplToDartString(StringImpl*);
+    static Dart_Handle stringToDartString(const String&);
+    static Dart_Handle stringToDartString(const AtomicString&);
+    static Dart_Handle safeStringImplToDartString(StringImpl*);
+    static Dart_Handle safeStringToDartString(const String&);
+    static Dart_Handle safeStringToDartString(const AtomicString&);
+
+    static Dart_Handle errorToException(Dart_Handle error)
+    {
+        ASSERT(Dart_IsError(error));
+        if (Dart_ErrorHasException(error))
+            return Dart_ErrorGetException(error);
+        return Dart_NewStringFromCString(Dart_GetError(error));
+    }
+
+    static bool checkResult(Dart_Handle result, Dart_Handle& exception)
+    {
+        if (!Dart_IsError(result))
+            return true;
+
+        exception = errorToException(result);
+        return false;
+    }
+
+    static void extractListElements(Dart_Handle list, Dart_Handle& exception, Vector<Dart_Handle>& elements);
+    static Dart_Handle toList(const Vector<Dart_Handle>& elements, Dart_Handle& exception);
+
+    static void extractMapElements(Dart_Handle map, Dart_Handle& exception, HashMap<String, Dart_Handle>& elements);
+
+    static int64_t toInteger(Dart_Handle, Dart_Handle& exception);
+    static String toString(Dart_Handle);
+    static void toMessagePortArray(Dart_Handle, MessagePortArray&, ArrayBufferArray&, Dart_Handle& exception);
+    static PassRefPtr<SerializedScriptValue> toSerializedScriptValue(Dart_Handle, MessagePortArray*, ArrayBufferArray*, Dart_Handle& exception);
+    static SQLValue toSQLValue(Dart_Handle, Dart_Handle& exception);
+    template <class T, class Convertor>
+    static void toVector(Convertor convertor, Dart_Handle object, Vector<T>& result, Dart_Handle& exception)
+    {
+        ASSERT(Dart_IsList(object));
+        ASSERT(result.isEmpty());
+
+        Vector<Dart_Handle> handles;
+        DartUtilities::extractListElements(object, exception, handles);
+        if (exception)
+            return;
+
+        for (unsigned i = 0; i < handles.size(); ++i) {
+            result.append(convertor(handles[i], exception));
+            if (exception)
+                return;
+        }
+    }
+    template <class T, class Convertor>
+    static void toVector(Convertor convertor, Dart_Handle object, HeapVector<Member<T> >& result, Dart_Handle& exception)
+    {
+        ASSERT(Dart_IsList(object));
+        ASSERT(result.isEmpty());
+
+        Vector<Dart_Handle> handles;
+        DartUtilities::extractListElements(object, exception, handles);
+        if (exception)
+            return;
+
+        for (unsigned i = 0; i < handles.size(); ++i) {
+            result.append(convertor(handles[i], exception));
+            if (exception)
+                return;
+        }
+    }
+
+    template <class T>
+    struct TypeConvertor { };
+
+    template <class T>
+    static void toNativeVector(Dart_Handle object, Vector<T>& result, Dart_Handle& exception)
+    {
+        toVector(TypeConvertor<T>(), object, result, exception);
+    }
+    template <class T>
+    static void toNativeVector(Dart_NativeArguments args, int idx, Vector<T>& result, Dart_Handle& exception)
+    {
+        Dart_Handle object = Dart_GetNativeArgument(args, idx);
+        toVector(TypeConvertor<T>(), object, result, exception);
+    }
+
+    template <class T>
+    static void toNativeVector(Dart_Handle object, HeapVector<Member<T> >& result, Dart_Handle& exception)
+    {
+        toVector(TypeConvertor<T>(), object, result, exception);
+    }
+    template <class T>
+    static void toNativeVector(Dart_NativeArguments args, int idx, HeapVector<Member<T> >& result, Dart_Handle& exception)
+    {
+        Dart_Handle object = Dart_GetNativeArgument(args, idx);
+        toVector(TypeConvertor<T>(), object, result, exception);
+    }
+
+    static Dart_Handle listHashSetToDartList(ListHashSet<String> set, Dart_Handle& exception)
+    {
+        Dart_Handle result = Dart_NewList(set.size());
+        if (!DartUtilities::checkResult(result, exception))
+            return Dart_Null();
+
+        ListHashSet<String>::const_iterator end = set.end();
+        int index = 0;
+        for (ListHashSet<String>::const_iterator it = set.begin(); it != end; ++it, ++index)
+            Dart_ListSetAt(result, index, DartUtilities::stringToDartString(*it));
+        return result;
+    }
+
+    static Dictionary dartToDictionary(Dart_Handle, Dart_Handle& exception);
+    static Dictionary dartToDictionaryWithNullCheck(Dart_Handle, Dart_Handle& exception);
+    static Dictionary dartToDictionary(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+    static Dictionary dartToDictionaryWithNullCheck(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+
+    static LocalDOMWindow* domWindowForCurrentIsolate();
+    static LocalDOMWindow* enteredDomWindowForCurrentIsolate()
+    {
+        // FIXME: Add check to enforce this is the right window.
+        return domWindowForCurrentIsolate();
+    }
+
+    static LocalDOMWindow* callingDomWindowForCurrentIsolate()
+    {
+        // FIXME: Add check to enforce this is the right window.
+        return domWindowForCurrentIsolate();
+    }
+
+    static V8ScriptState* v8ScriptStateForCurrentIsolate();
+
+    static ExecutionContext* scriptExecutionContext();
+    // FIXMEDART: Should have a variant that takes a Dart_NativeArguments to avoid TLS.
+    static DartScriptState* currentScriptState();
+
+    static bool processingUserGesture();
+
+    static PassRefPtr<ScriptArguments> createScriptArguments(Dart_Handle argument, Dart_Handle& exception);
+
+    static PassRefPtr<ScriptCallStack> createScriptCallStack();
+    static ScriptCallFrame getTopFrame(Dart_StackTrace, Dart_Handle& exception);
+    static ScriptCallFrame toScriptCallFrame(Dart_ActivationFrame, Dart_Handle& exception);
+
+    static const uint8_t* vmIsolateSnapshot();
+    static const uint8_t* isolateSnapshot();
+
+    static Dart_Handle canonicalizeUrl(Dart_Handle library, Dart_Handle urlHandle, String url);
+
+    static void reportProblem(ExecutionContext*, const String&, int line = 0, int col = 0);
+    static void reportProblem(ExecutionContext*, Dart_Handle);
+    static void reportProblem(ExecutionContext*, Dart_Handle, const String& sourceURL);
+
+    static Dart_Handle toDartCoreException(const String &className, const String& message);
+
+    static Dart_Handle coreArgumentErrorException(const String& message);
+
+    static Dart_Handle invalidNumberOfArgumentsException()
+    {
+        return Dart_NewStringFromCString("Invalid number of arguments");
+    }
+
+    static Dart_Handle conditionalFunctionalityException()
+    {
+        return Dart_NewStringFromCString("Ooops, this functionality is not enabled in this browser");
+    }
+
+    static Dart_Handle notImplementedException(const char* fileName, int lineNumber);
+
+    static Dart_Handle internalErrorException(const char* msg)
+    {
+        // FIXME: wrap into proper type.
+        return Dart_NewStringFromCString(msg);
+    }
+
+    static Dart_Handle newResolvedPromise(Dart_Handle value);
+    static Dart_Handle newSmashedPromise(Dart_Handle error);
+    static Dart_Handle newResolver();
+    static Dart_Handle newArgumentError(const String& message);
+
+    static Dart_Handle invokeUtilsMethod(const char* methodName, int argCount, Dart_Handle* args);
+
+    static Dart_Handle convertSourceString(const String& source)
+    {
+        // FIXME: Decide whether to externalize this here.
+        const CString utf8encoded = source.utf8();
+        return Dart_NewStringFromUTF8(
+            reinterpret_cast<const uint8_t*>(utf8encoded.data()),
+            utf8encoded.length());
+    }
+
+    static DartStringAdapter dartToString(Dart_Handle object, Dart_Handle& exception)
+    {
+        intptr_t charsize = 0;
+        intptr_t strlength = 0;
+        void* peer = 0;
+        Dart_Handle result = Dart_StringGetProperties(object, &charsize, &strlength, &peer);
+        if (peer) {
+            return DartStringAdapter(reinterpret_cast<DartStringPeer*>(peer));
+        }
+        if (Dart_IsError(result)) {
+            exception = Dart_NewStringFromCString("String Expected");
+            return DartStringAdapter(DartStringPeer::nullString());
+        }
+        return dartToStringImpl(object, exception, true);
+    }
+    static DartStringAdapter dartToString(Dart_NativeArguments args, int index, Dart_Handle& exception, bool autoDartScope = true)
+    {
+        void* peer = 0;
+        Dart_Handle object = Dart_GetNativeStringArgument(args, index, &peer);
+        if (peer) {
+            return DartStringAdapter(reinterpret_cast<DartStringPeer*>(peer));
+        }
+        if (Dart_IsError(object)) {
+            exception = Dart_NewStringFromCString("String Expected");
+            return DartStringAdapter(DartStringPeer::nullString());
+        }
+        return dartToStringImpl(object, exception, autoDartScope);
+    }
+    static DartStringAdapter dartToStringWithNullCheck(Dart_NativeArguments args, int index, Dart_Handle& exception, bool autoDartScope = true)
+    {
+        void* peer = 0;
+        Dart_Handle object = Dart_GetNativeStringArgument(args, index, &peer);
+        if (peer) {
+            return DartStringAdapter(reinterpret_cast<DartStringPeer*>(peer));
+        }
+        if (Dart_IsNull(object)) {
+            return DartStringAdapter(DartStringPeer::nullString());
+        }
+        return dartToString(args, index, exception, autoDartScope);
+    }
+    static DartStringAdapter dartToStringWithEmptyCheck(Dart_NativeArguments args, int index, Dart_Handle& exception, bool autoDartScope = true)
+    {
+        void* peer = 0;
+        Dart_Handle object = Dart_GetNativeStringArgument(args, index, &peer);
+        if (peer) {
+            return DartStringAdapter(reinterpret_cast<DartStringPeer*>(peer));
+        }
+        if (Dart_IsNull(object)) {
+            return DartStringAdapter(DartStringPeer::emptyString());
+        }
+        return dartToString(args, index, exception, autoDartScope);
+    }
+    static Dart_Handle stringToDart(const AtomicString& value)
+    {
+        DartDOMData* domData = DartDOMData::current();
+        StringImpl* stringImpl = value.impl();
+        if (!stringImpl) {
+            return domData->emptyString();
+        }
+        return Dart_HandleFromWeakPersistent(domData->stringCache().get(stringImpl));
+    }
+    static Dart_Handle stringToDart(const String& value)
+    {
+        DartDOMData* domData = DartDOMData::current();
+        StringImpl* stringImpl = value.impl();
+        if (!stringImpl) {
+            return domData->emptyString();
+        }
+        return Dart_HandleFromWeakPersistent(domData->stringCache().get(stringImpl));
+    }
+    template <class StringClass>
+    static Dart_Handle stringToDartWithNullCheck(const StringClass& value)
+    {
+        if (value.isNull())
+            return Dart_Null();
+        return stringToDart(value);
+    }
+    static void setDartUnsignedReturnValue(Dart_NativeArguments args, unsigned value)
+    {
+        Dart_SetIntegerReturnValue(args, value);
+    }
+    static void setDartUnsignedLongLongReturnValue(Dart_NativeArguments args, unsigned long long value)
+    {
+        // FIXME: WebIDL unsigned long long is guaranteed to fit into 64-bit unsigned,
+        // so we need a dart API for constructing an integer from uint64_t.
+        ASSERT(value <= 0x7fffffffffffffffLL);
+        Dart_SetIntegerReturnValue(args, static_cast<int64_t>(value));
+    }
+    static void setDartIntegerReturnValue(Dart_NativeArguments args, int64_t value)
+    {
+        Dart_SetIntegerReturnValue(args, value);
+    }
+    static void setDartStringReturnValue(Dart_NativeArguments args, const AtomicString& value, bool autoDartScope = true)
+    {
+        DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
+        StringImpl* stringImpl = value.impl();
+        if (!stringImpl) {
+            Dart_SetReturnValue(args, domData->emptyString());
+        } else {
+            Dart_SetWeakHandleReturnValue(args, domData->stringCache().get(value.impl(), autoDartScope));
+        }
+    }
+    static void setDartStringReturnValue(Dart_NativeArguments args, const String& value, bool autoDartScope = true)
+    {
+        DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
+        StringImpl* stringImpl = value.impl();
+        if (!stringImpl) {
+            Dart_SetReturnValue(args, domData->emptyString());
+        } else {
+            Dart_SetWeakHandleReturnValue(args, domData->stringCache().get(value.impl(), autoDartScope));
+        }
+    }
+    static void setDartStringReturnValueWithNullCheck(
+        Dart_NativeArguments args, const AtomicString& value, bool autoDartScope = true)
+    {
+        if (value.isNull()) {
+            Dart_SetReturnValue(args, Dart_Null());
+        } else {
+            setDartStringReturnValue(args, value, autoDartScope);
+        }
+    }
+    static void setDartStringReturnValueWithNullCheck(Dart_NativeArguments args, const String& value, bool autoDartScope = true)
+    {
+        if (value.isNull()) {
+            Dart_SetReturnValue(args, Dart_Null());
+        } else {
+            setDartStringReturnValue(args, value, autoDartScope);
+        }
+    }
+
+    // ScalarValueString helpers. ScalarValueString is identical to DOMString
+    // except that "convert a DOMString to a sequence of Unicode characters".
+
+    static DartStringAdapter dartToScalarValueString(Dart_Handle object, Dart_Handle& exception)
+    {
+        intptr_t charsize = 0;
+        intptr_t strlength = 0;
+        void* peer = 0;
+        Dart_Handle result = Dart_StringGetProperties(object, &charsize, &strlength, &peer);
+        if (peer) {
+            return DartStringAdapter(reinterpret_cast<DartStringPeer*>(peer));
+        }
+        if (Dart_IsError(result)) {
+            exception = Dart_NewStringFromCString("String Expected");
+            return DartStringAdapter(DartStringPeer::nullString());
+        }
+        // TODO(terry): Need to implement similar code to replace with UTF-16
+        //              with valid unicode. See V8Bindings.h implementation.
+        return dartToStringImpl(object, exception, true);
+    }
+    static DartStringAdapter dartToScalarValueString(Dart_NativeArguments args, int index, Dart_Handle& exception, bool autoDartScope = true)
+    {
+        void* peer = 0;
+        Dart_Handle object = Dart_GetNativeStringArgument(args, index, &peer);
+        if (peer) {
+            return DartStringAdapter(reinterpret_cast<DartStringPeer*>(peer));
+        }
+        if (Dart_IsError(object)) {
+            exception = Dart_NewStringFromCString("String Expected");
+            return DartStringAdapter(DartStringPeer::nullString());
+        }
+        // TODO(terry): Need to implement similar code to replace with UTF-16
+        //              with valid unicode. See V8Bindings.h implementation.
+        return dartToStringImpl(object, exception, autoDartScope);
+    }
+    static DartStringAdapter dartToScalarValueStringWithNullCheck(Dart_NativeArguments args, int index, Dart_Handle& exception, bool autoDartScope = true)
+    {
+        void* peer = 0;
+        Dart_Handle object = Dart_GetNativeStringArgument(args, index, &peer);
+        if (peer) {
+            return DartStringAdapter(reinterpret_cast<DartStringPeer*>(peer));
+        }
+        if (Dart_IsNull(object)) {
+            return DartStringAdapter(DartStringPeer::nullString());
+        }
+        return dartToScalarValueString(args, index, exception, autoDartScope);
+    }
+    static void setDartScalarValueStringReturnValue(Dart_NativeArguments args, const AtomicString& value, bool autoDartScope = true)
+    {
+        DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
+        StringImpl* stringImpl = value.impl();
+        if (!stringImpl) {
+            Dart_SetReturnValue(args, domData->emptyString());
+        } else {
+            // TODO(terry): Need to implement similar code to replace with UTF-16
+            //              with valid unicode. See V8Bindings.h implementation.
+        }
+    }
+    static void setDartScalarValueStringReturnValue(Dart_NativeArguments args, const String& value, bool autoDartScope = true)
+    {
+        DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
+        StringImpl* stringImpl = value.impl();
+        if (!stringImpl) {
+            Dart_SetReturnValue(args, domData->emptyString());
+        } else {
+            // TODO(terry): Need to implement similar code to replace with UTF-16
+            //              with valid unicode. See V8Bindings.h implementation.
+        }
+    }
+    static void setDartScalarValueStringReturnValueWithNullCheck(
+        Dart_NativeArguments args, const AtomicString& value, bool autoDartScope = true)
+    {
+        if (value.isNull()) {
+            Dart_SetReturnValue(args, Dart_Null());
+        } else {
+            setDartScalarValueStringReturnValue(args, value, autoDartScope);
+        }
+    }
+    static void setDartScalarValueStringReturnValueWithNullCheck(Dart_NativeArguments args, const String& value, bool autoDartScope = true)
+    {
+        if (value.isNull()) {
+            Dart_SetReturnValue(args, Dart_Null());
+        } else {
+            setDartScalarValueStringReturnValue(args, value, autoDartScope);
+        }
+    }
+
+    // ByteString helpers. Converts a value to a String, throwing if any code
+    // unit is outside 0-255.
+
+    static DartStringAdapter dartToByteString(Dart_Handle object, Dart_Handle& exception)
+    {
+        intptr_t charsize = 0;
+        intptr_t strlength = 0;
+        void* peer = 0;
+        Dart_Handle result = Dart_StringGetProperties(object, &charsize, &strlength, &peer);
+        if (peer) {
+            return DartStringAdapter(reinterpret_cast<DartStringPeer*>(peer));
+        }
+        if (Dart_IsError(result)) {
+            exception = Dart_NewStringFromCString("String Expected");
+            return DartStringAdapter(DartStringPeer::nullString());
+        }
+        // TODO(terry): Need to implement similar code to toByteString see
+        //              bindings/core/v8/V8Bindings.h for implementation.
+        return dartToStringImpl(object, exception, true);
+    }
+    static DartStringAdapter dartToByteString(Dart_NativeArguments args, int index, Dart_Handle& exception, bool autoDartScope = true)
+    {
+        void* peer = 0;
+        Dart_Handle object = Dart_GetNativeStringArgument(args, index, &peer);
+        if (peer) {
+            return DartStringAdapter(reinterpret_cast<DartStringPeer*>(peer));
+        }
+        if (Dart_IsError(object)) {
+            exception = Dart_NewStringFromCString("String Expected");
+            return DartStringAdapter(DartStringPeer::nullString());
+        }
+        // TODO(terry): Need to implement similar code to toByteString see
+        //              bindings/core/v8/V8Bindings.h for implementation.
+        return dartToStringImpl(object, exception, autoDartScope);
+    }
+    static DartStringAdapter dartToByteStringWithNullCheck(Dart_NativeArguments args, int index, Dart_Handle& exception, bool autoDartScope = true)
+    {
+        void* peer = 0;
+        Dart_Handle object = Dart_GetNativeStringArgument(args, index, &peer);
+        if (peer) {
+            return DartStringAdapter(reinterpret_cast<DartStringPeer*>(peer));
+        }
+        if (Dart_IsNull(object)) {
+            return DartStringAdapter(DartStringPeer::nullString());
+        }
+        // TODO(terry): Need to implement similar code to toByteString see
+        //              bindings/core/v8/V8Bindings.h for implementation.
+        return dartToScalarValueString(args, index, exception, autoDartScope);
+    }
+    static void setDartByteStringReturnValue(Dart_NativeArguments args, const AtomicString& value, bool autoDartScope = true)
+    {
+        DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
+        StringImpl* stringImpl = value.impl();
+        if (!stringImpl) {
+            Dart_SetReturnValue(args, domData->emptyString());
+        } else {
+            // TODO(terry): Need to implement similar code to toByteString see
+            //              bindings/core/v8/V8Bindings.h for implementation.
+        }
+    }
+    static void setDartByteStringReturnValue(Dart_NativeArguments args, const String& value, bool autoDartScope = true)
+    {
+        DartDOMData* domData = static_cast<DartDOMData*>(Dart_GetNativeIsolateData(args));
+        StringImpl* stringImpl = value.impl();
+        if (!stringImpl) {
+            Dart_SetReturnValue(args, domData->emptyString());
+        } else {
+            // TODO(terry): Need to implement similar code to toByteString see
+            //              bindings/core/v8/V8Bindings.h for implementation.
+        }
+    }
+    static void setDartByteStringReturnValueWithNullCheck(
+        Dart_NativeArguments args, const AtomicString& value, bool autoDartScope = true)
+    {
+        if (value.isNull()) {
+            Dart_SetReturnValue(args, Dart_Null());
+        } else {
+            setDartByteStringReturnValue(args, value, autoDartScope);
+        }
+    }
+    static void setDartByteStringReturnValueWithNullCheck(Dart_NativeArguments args, const String& value, bool autoDartScope = true)
+    {
+        if (value.isNull()) {
+            Dart_SetReturnValue(args, Dart_Null());
+        } else {
+            setDartByteStringReturnValue(args, value, autoDartScope);
+        }
+    }
+
+    static bool dartToBool(Dart_Handle, Dart_Handle& exception);
+    static bool dartToBoolWithNullCheck(Dart_Handle object, Dart_Handle& exception)
+    {
+        // dartToBool converts Null to false
+        return dartToBool(object, exception);
+    }
+    static bool dartToBool(Dart_NativeArguments args, int index, Dart_Handle& exception)
+    {
+        // FIXME: There is currently no difference between doing the null check and not.
+        // If this is the desired semantics, we should stop generating these. If not,
+        // we should make this version throw an error.
+        return dartToBoolWithNullCheck(args, index, exception);
+    }
+    static bool dartToBoolWithNullCheck(Dart_NativeArguments args, int index, Dart_Handle& exception)
+    {
+        // Dart_GetNativeBooleanArgument converts null to false
+        bool value;
+        Dart_Handle result = Dart_GetNativeBooleanArgument(args, index, &value);
+        if (Dart_IsError(result)) {
+            exception = Dart_NewStringFromCString(Dart_GetError(result));
+            return false;
+        }
+        return value;
+    }
+    static Dart_Handle boolToDart(bool value)
+    {
+        return Dart_NewBoolean(value);
+    }
+
+    static int dartToInt(Dart_Handle, Dart_Handle& exception);
+    static int dartToInt(Dart_NativeArguments args, int index, Dart_Handle& exception)
+    {
+        int64_t value;
+        Dart_Handle result = Dart_GetNativeIntegerArgument(args, index, &value);
+        if (Dart_IsError(result)) {
+            exception = Dart_NewStringFromCString(Dart_GetError(result));
+            return 0;
+        }
+        if (value < INT_MIN || value > INT_MAX) {
+            exception = Dart_NewStringFromCString("value out of range");
+            return 0;
+        }
+        return value;
+    }
+    static Dart_Handle intToDart(int64_t value)
+    {
+        return Dart_NewInteger(value);
+    }
+
+    static unsigned dartToUnsigned(Dart_Handle, Dart_Handle& exception);
+    static unsigned dartToUnsigned(Dart_NativeArguments args, int index, Dart_Handle& exception)
+    {
+        int64_t value;
+        Dart_Handle result = Dart_GetNativeIntegerArgument(args, index, &value);
+        if (Dart_IsError(result)) {
+            exception = Dart_NewStringFromCString(Dart_GetError(result));
+            return 0;
+        }
+        if (value < 0 || value > UINT_MAX) {
+            exception = Dart_NewStringFromCString("value out of range");
+            return 0;
+        }
+        return value;
+    }
+    static Dart_Handle unsignedToDart(unsigned value)
+    {
+        return Dart_NewInteger(value);
+    }
+
+    static long long dartToLongLong(Dart_Handle, Dart_Handle& exception);
+    static long long dartToLongLong(Dart_NativeArguments args, int index, Dart_Handle& exception)
+    {
+        int64_t value;
+        Dart_Handle result = Dart_GetNativeIntegerArgument(args, index, &value);
+        if (Dart_IsError(result)) {
+            exception = Dart_NewStringFromCString(Dart_GetError(result));
+            return 0;
+        }
+        return value;
+    }
+    static Dart_Handle longLongToDart(long long value)
+    {
+        return Dart_NewInteger(value);
+    }
+
+    static unsigned long long dartToUnsignedLongLong(Dart_Handle, Dart_Handle& exception);
+    static unsigned long long dartToUnsignedLongLong(Dart_NativeArguments args, int index, Dart_Handle& exception)
+    {
+        int64_t value;
+        Dart_Handle result = Dart_GetNativeIntegerArgument(args, index, &value);
+        if (Dart_IsError(result)) {
+            exception = Dart_NewStringFromCString(Dart_GetError(result));
+            return 0;
+        }
+        if (value < 0) {
+            exception = Dart_NewStringFromCString("value out of range");
+            return 0;
+        }
+        return value;
+    }
+    static Dart_Handle unsignedLongLongToDart(unsigned long long value)
+    {
+        // FIXME: WebIDL unsigned long long is guaranteed to fit into 64-bit unsigned,
+        // so we need a dart API for constructing an integer from uint64_t.
+        ASSERT(value <= 0x7fffffffffffffffLL);
+        return Dart_NewInteger(static_cast<int64_t>(value));
+    }
+
+    static double dartToDouble(Dart_Handle, Dart_Handle& exception);
+    static double dartToDouble(Dart_NativeArguments args, int index, Dart_Handle& exception)
+    {
+        double value;
+        Dart_Handle result = Dart_GetNativeDoubleArgument(args, index, &value);
+        if (Dart_IsError(result)) {
+            exception = Dart_NewStringFromCString(Dart_GetError(result));
+            return 0;
+        }
+        return value;
+    }
+    static Dart_Handle doubleToDart(double value)
+    {
+        return Dart_NewDouble(value);
+    }
+
+    static Dart_Handle numberToDart(double value);
+
+    static intptr_t libraryHandleToLibraryId(Dart_Handle library);
+
+    static ScriptValue dartToScriptValue(Dart_Handle);
+    static ScriptValue dartToScriptValue(Dart_NativeArguments args, int index)
+    {
+        Dart_Handle object = Dart_GetNativeArgument(args, index);
+        return dartToScriptValue(object);
+    }
+    // NOTE: consider revisiting this once situation w/ optional arguments checks
+    // in dart:html is clearer.
+    // The implementation below will convert null to undefined script value. Which
+    // is exactly what is desired if actual value wasn't specified at call site,
+    // but is most probably wrong if null was explicitly provided. On more positive
+    // side indexed db are converted to Dart null anyway, so it might be tricky
+    // to observe from user code.
+    static ScriptValue dartToScriptValueWithNullCheck(Dart_Handle handle)
+    {
+        if (Dart_IsNull(handle)) {
+            V8ScriptState* scriptState = v8ScriptStateForCurrentIsolate();
+            return ScriptValue(scriptState, v8::Undefined(scriptState->isolate()));
+        }
+        return dartToScriptValue(handle);
+    }
+    static ScriptValue dartToScriptValueWithNullCheck(Dart_NativeArguments args, int index)
+    {
+        Dart_Handle object = Dart_GetNativeArgument(args, index);
+        return dartToScriptValueWithNullCheck(object);
+    }
+
+    static PassRefPtr<SerializedScriptValue> dartToSerializedScriptValue(Dart_Handle, Dart_Handle& exception);
+    static Dart_Handle serializedScriptValueToDart(PassRefPtr<SerializedScriptValue>);
+
+    static Dart_Handle dateToDart(double);
+    static double dartToDate(Dart_Handle, Dart_Handle&);
+    static double dartToDate(Dart_NativeArguments args, int idx, Dart_Handle&);
+    static bool isDateTime(DartDOMData*, Dart_Handle);
+    static bool isTypeSubclassOf(Dart_Handle type, Dart_Handle library, const char* typeName);
+    static Dart_Handle getAndValidateNativeType(Dart_Handle type, const String& tagName);
+    static bool objectIsType(Dart_Handle, Dart_Handle type);
+
+    static bool isFunction(DartDOMData*, Dart_Handle);
+
+    static Dart_Handle getDartType(const char*, const char*);
+    static Dart_Handle getDartHtmlType(const char* typeName);
+
+    static bool isNode(Dart_Handle);
+    static Node* dartNodeToNativeNode(void*);
+
+    static bool isMessagePort(Dart_Handle);
+    static MessagePort* dartMessagePortToNativeMessagePort(void*);
+
+    static Dart_Handle arrayBufferToDart(WTF::ArrayBuffer*);
+    static Dart_Handle arrayBufferToDart(PassRefPtr<WTF::ArrayBuffer> value)
+    {
+        return arrayBufferToDart(value.get());
+    }
+
+    static Dart_Handle arrayBufferViewToDart(WTF::ArrayBufferView*);
+
+    // FIXME: For typed data views in the VM heap, this currently creates
+    // a new array buffer object with a copy of the data and loses the
+    // connection to the dart object.
+    static Dart_Handle arrayBufferViewToDart(PassRefPtr<WTF::ArrayBufferView> value)
+    {
+        return arrayBufferViewToDart(value.get());
+    }
+
+    static PassRefPtr<WTF::ArrayBuffer> dartToArrayBuffer(Dart_Handle array, Dart_Handle& exception);
+    static PassRefPtr<WTF::ArrayBuffer> dartToArrayBufferWithNullCheck(Dart_Handle array, Dart_Handle& exception)
+    {
+        return Dart_IsNull(array) ? nullptr : dartToArrayBuffer(array, exception);
+    }
+    static PassRefPtr<WTF::ArrayBuffer> dartToArrayBuffer(Dart_NativeArguments args, int index, Dart_Handle& exception)
+    {
+        Dart_Handle object = Dart_GetNativeArgument(args, index);
+        return dartToArrayBuffer(object, exception);
+    }
+    static PassRefPtr<WTF::ArrayBuffer> dartToArrayBufferWithNullCheck(Dart_NativeArguments args, int idx, Dart_Handle& excp)
+    {
+        Dart_Handle object = Dart_GetNativeArgument(args, idx);
+        return dartToArrayBufferWithNullCheck(object, excp);
+    }
+
+    // FIXME: For typed data objects in the VM heap, this currently creates
+    // a new array buffer object with a copy of the data and loses the
+    // connection to the dart object.
+    static PassRefPtr<WTF::ArrayBuffer> dartToExternalizedArrayBuffer(Dart_Handle, Dart_Handle&);
+
+    static PassRefPtr<WTF::ArrayBufferView> dartToArrayBufferView(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::ArrayBufferView> dartToArrayBufferViewWithNullCheck(Dart_Handle array, Dart_Handle& exception)
+    {
+        return Dart_IsNull(array) ? nullptr : dartToArrayBufferView(array, exception);
+    }
+    static PassRefPtr<WTF::ArrayBufferView> dartToArrayBufferView(Dart_NativeArguments args, int idx, Dart_Handle& exception)
+    {
+        Dart_Handle object = Dart_GetNativeArgument(args, idx);
+        return dartToArrayBufferView(object, exception);
+    }
+    static PassRefPtr<WTF::ArrayBufferView> dartToArrayBufferViewWithNullCheck(Dart_NativeArguments args, int idx, Dart_Handle& exception)
+    {
+        Dart_Handle object = Dart_GetNativeArgument(args, idx);
+        return dartToArrayBufferViewWithNullCheck(object, exception);
+    }
+
+    static PassRefPtr<WTF::ArrayBufferView> dartToExternalizedArrayBufferView(Dart_Handle, Dart_Handle&);
+
+    static PassRefPtr<WTF::Int8Array> dartToInt8Array(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::Int8Array> dartToInt8ArrayWithNullCheck(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::Int8Array> dartToInt8Array(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+    static PassRefPtr<WTF::Int8Array> dartToInt8ArrayWithNullCheck(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+    static PassRefPtr<WTF::Int32Array> dartToInt32Array(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::Int32Array> dartToInt32ArrayWithNullCheck(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::Int32Array> dartToInt32Array(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+    static PassRefPtr<WTF::Int32Array> dartToInt32ArrayWithNullCheck(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+    static PassRefPtr<WTF::Uint8Array> dartToUint8Array(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::Uint8Array> dartToUint8ArrayWithNullCheck(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::Uint8Array> dartToUint8Array(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+    static PassRefPtr<WTF::Uint8Array> dartToUint8ArrayWithNullCheck(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+    static PassRefPtr<WTF::Uint8ClampedArray> dartToUint8ClampedArray(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::Uint8ClampedArray> dartToUint8ClampedArrayWithNullCheck(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::Uint8ClampedArray> dartToUint8ClampedArray(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+    static PassRefPtr<WTF::Uint8ClampedArray> dartToUint8ClampedArrayWithNullCheck(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+    static PassRefPtr<WTF::Float32Array> dartToFloat32Array(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::Float32Array> dartToFloat32ArrayWithNullCheck(Dart_Handle, Dart_Handle&);
+    static PassRefPtr<WTF::Float32Array> dartToFloat32Array(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+    static PassRefPtr<WTF::Float32Array> dartToFloat32ArrayWithNullCheck(Dart_NativeArguments args, int idx, Dart_Handle& exception);
+
+    static bool isUint8Array(Dart_Handle);
+    static bool isUint8ClampedArray(Dart_Handle);
+
+    template<class ElementType, class TransformType, Dart_Handle transform(TransformType)>
+    static Dart_Handle vectorToDart(const Vector<ElementType>& vector)
+    {
+        Dart_Handle list = Dart_NewList(vector.size());
+        if (Dart_IsError(list))
+            return list;
+        for (size_t i = 0; i < vector.size(); i++) {
+            Dart_Handle result = Dart_ListSetAt(list, i, transform(vector[i]));
+            if (Dart_IsError(result))
+                return result;
+        }
+        return list;
+    }
+
+    template<class ElementType, Dart_Handle transform(ElementType*)>
+    static Dart_Handle vectorToDart(const HeapVector<Member<ElementType> >& vector)
+    {
+        Dart_Handle list = Dart_NewList(vector.size());
+        if (Dart_IsError(list))
+            return list;
+        for (size_t i = 0; i < vector.size(); i++) {
+            Dart_Handle result = Dart_ListSetAt(list, i, transform(vector[i]));
+            if (Dart_IsError(result))
+                return result;
+        }
+        return list;
+    }
+
+    static v8::Local<v8::Context> currentV8Context();
+
+
+    enum {
+#if OS(ANDROID)
+        PROP_VALUE_MAX_LEN = PROP_VALUE_MAX
+#else
+        PROP_VALUE_MAX_LEN = 256
+#endif
+    };
+
+    enum {
+        VmIsolateSnapshotId = 0,
+        IsolateSnapshotId = 1,
+    };
+
+    static int getProp(const char* name, char* value, int valueLen);
+
+private:
+    static DartStringAdapter dartToStringImpl(Dart_Handle, Dart_Handle& exception, bool autoDartScope = true);
+    static DartStringPeer* toStringImpl(Dart_Handle, intptr_t charsize, intptr_t strlength);
+};
+
+class DartIsolateScope {
+public:
+    explicit DartIsolateScope(Dart_Isolate isolate)
+    {
+        m_isolate = isolate;
+        m_previousIsolate = Dart_CurrentIsolate();
+        if (m_previousIsolate != m_isolate) {
+            if (m_previousIsolate)
+                Dart_ExitIsolate();
+            Dart_EnterIsolate(m_isolate);
+        }
+    }
+
+    ~DartIsolateScope()
+    {
+        ASSERT(Dart_CurrentIsolate() == m_isolate);
+        if (m_previousIsolate != m_isolate) {
+            Dart_ExitIsolate();
+            if (m_previousIsolate)
+                Dart_EnterIsolate(m_previousIsolate);
+        }
+    }
+
+private:
+    Dart_Isolate m_isolate;
+    Dart_Isolate m_previousIsolate;
+};
+
+class V8Scope {
+public:
+    explicit V8Scope(DartDOMData*, v8::Handle<v8::Context>);
+    V8Scope(DartDOMData*);
+    ~V8Scope();
+private:
+    v8::Isolate* m_v8Isolate;
+    DartDOMData* m_dartDOMData;
+    v8::HandleScope m_handleScope;
+    v8::Context::Scope m_contextScope;
+    V8RecursionScope m_recursionScope;
+};
+
+struct DartNativeEntry {
+    Dart_NativeFunction nativeFunction;
+    intptr_t argumentCount;
+    const char* name;
+};
+
+template<>
+struct DartUtilities::TypeConvertor<bool> {
+    bool operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return DartUtilities::dartToBool(object, exception);
+    }
+};
+
+
+template<>
+struct DartUtilities::TypeConvertor<float> {
+    float operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return static_cast<float>(DartUtilities::dartToDouble(object, exception));
+    }
+};
+
+
+template<>
+struct DartUtilities::TypeConvertor<double> {
+    double operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return DartUtilities::dartToDouble(object, exception);
+    }
+};
+
+
+template<>
+struct DartUtilities::TypeConvertor<int> {
+    int operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return DartUtilities::dartToInt(object, exception);
+    }
+};
+
+
+template<>
+struct DartUtilities::TypeConvertor<unsigned> {
+    unsigned operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return DartUtilities::dartToUnsigned(object, exception);
+    }
+};
+
+
+template<>
+struct DartUtilities::TypeConvertor<unsigned short> {
+    unsigned short operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return static_cast<unsigned short>(DartUtilities::dartToUnsigned(object, exception));
+    }
+};
+
+
+template<>
+struct DartUtilities::TypeConvertor<unsigned long> {
+    unsigned long operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return static_cast<unsigned long>(DartUtilities::dartToUnsignedLongLong(object, exception));
+    }
+};
+
+
+template<>
+struct DartUtilities::TypeConvertor<unsigned long long> {
+    unsigned long long operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return DartUtilities::dartToUnsignedLongLong(object, exception);
+    }
+};
+
+
+template<typename T>
+struct DartUtilities::TypeConvertor<Nullable<T>> {
+    Nullable<T> operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        if (Dart_IsNull(object))
+            return Nullable<T>();
+        return Nullable<T>(TypeConvertor<T>()(object, exception));
+    }
+};
+
+
+template<>
+struct DartUtilities::TypeConvertor<String> {
+    DartStringAdapter operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return DartUtilities::dartToString(object, exception);
+    }
+};
+
+
+template<>
+struct DartUtilities::TypeConvertor<ScriptValue> {
+    ScriptValue operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return ScriptValue(DartScriptValue::create(currentScriptState(), object));
+    }
+};
+
+template<>
+struct DartUtilities::TypeConvertor<Dictionary> {
+    Dictionary operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        return DartUtilities::dartToDictionary(object, exception);
+    }
+};
+
+
+template<>
+struct DartUtilities::TypeConvertor<MediaStreamTrack> {
+    RawPtr<MediaStreamTrack> operator()(Dart_Handle object, Dart_Handle& exception)
+    {
+        // FIXME: proper implementation.
+        return nullptr;
+    }
+};
+
+
+template <typename T>
+struct DartValueTraits {
+    static Dart_Handle toDartValue(const T& value, DartDOMData* domData)
+    {
+        return Dart_Null();
+    }
+};
+
+template<>
+struct DartValueTraits<String> {
+    static inline Dart_Handle toDartValue(const String& value, DartDOMData* domData)
+    {
+        return DartUtilities::stringToDart(value);
+    }
+};
+
+template<>
+struct DartValueTraits<AtomicString> {
+    static inline Dart_Handle toDartValue(const AtomicString& value, DartDOMData* domData)
+    {
+        return DartUtilities::stringToDart(value);
+    }
+};
+
+template<size_t n>
+struct DartValueTraits<char const[n]> {
+    static inline Dart_Handle toDartValue(char const (&value)[n], DartDOMData* domData)
+    {
+        return DartUtilities::stringToDart(value);
+    }
+};
+
+template<>
+struct DartValueTraits<const char*> {
+    static inline Dart_Handle toDartValue(const char* const& value, DartDOMData* domData)
+    {
+        // AtomicString?
+        return DartUtilities::stringToDart((String)value);
+    }
+};
+
+template<>
+struct DartValueTraits<V8UndefinedType> {
+    static inline Dart_Handle toDartValue(const V8UndefinedType& value, DartDOMData* domData)
+    {
+        return Dart_Null();
+    }
+};
+
+template<>
+struct DartValueTraits<V8NullType> {
+    static inline Dart_Handle toDartValue(const V8NullType& value, DartDOMData* domData)
+    {
+        return Dart_Null();
+    }
+};
+
+template<>
+struct DartValueTraits<V8BoolType> {
+    static inline Dart_Handle toDartValue(const V8BoolType& value, DartDOMData* domData)
+    {
+        return value.value() ? Dart_True() : Dart_False();
+    }
+};
+
+
+template<>
+struct DartValueTraits<Dart_Handle> {
+    static inline Dart_Handle toDartValue(const Dart_Handle& value, DartDOMData* domData)
+    {
+        return value;
+    }
+};
+
+template<>
+struct DartValueTraits<v8::Handle<v8::Value> > {
+    static inline Dart_Handle toDartValue(const v8::Handle<v8::Value>& value, DartDOMData* domData)
+    {
+        Dart_Handle exception = 0;
+        Dart_Handle result = V8Converter::toDart(value, exception);
+        if (exception)
+            return exception;
+        return result;
+    }
+};
+
+template<>
+struct DartValueTraits<bool> {
+    static inline Dart_Handle toDartValue(const bool& value, DartDOMData* domData)
+    {
+        return DartUtilities::boolToDart(value);
+    }
+};
+
+template<>
+struct DartValueTraits<int> {
+    static inline Dart_Handle toDartValue(const int& value, DartDOMData* domData)
+    {
+        return DartUtilities::intToDart(value);
+    }
+};
+
+template<>
+struct DartValueTraits<long> {
+    static inline Dart_Handle toDartValue(const long& value, DartDOMData* domData)
+    {
+        return DartUtilities::intToDart(value);
+    }
+};
+
+template<>
+struct DartValueTraits<unsigned> {
+    static inline Dart_Handle toDartValue(const unsigned& value, DartDOMData* domData)
+    {
+        return DartUtilities::unsignedToDart(value);
+    }
+};
+
+template<>
+struct DartValueTraits<unsigned long> {
+    static inline Dart_Handle toDartValue(const unsigned long& value, DartDOMData* domData)
+    {
+        return DartUtilities::unsignedToDart(value);
+    }
+};
+
+template<>
+struct DartValueTraits<float> {
+    static inline Dart_Handle toDartValue(const float& value, DartDOMData* domData)
+    {
+        return DartUtilities::doubleToDart(value);
+    }
+};
+
+template<>
+struct DartValueTraits<double> {
+    static inline Dart_Handle toDartValue(const double& value, DartDOMData* domData)
+    {
+        return DartUtilities::doubleToDart(value);
+    }
+};
+
+template<>
+struct DartValueTraits<PassRefPtr<ArrayBuffer> > {
+    static inline Dart_Handle toDartValue(const PassRefPtr<ArrayBuffer>& value, DartDOMData* domData)
+    {
+        return DartUtilities::arrayBufferToDart(value);
+    }
+};
+
+template<typename T, size_t inlineCapacity>
+Dart_Handle dartArray(const Vector<T, inlineCapacity>& vector, DartDOMData* domData)
+{
+    Dart_Handle result = Dart_NewList(vector.size());
+    int index = 0;
+    typename Vector<T, inlineCapacity>::const_iterator end = vector.end();
+    typedef DartValueTraits<T> TraitsType;
+    for (typename Vector<T, inlineCapacity>::const_iterator iter = vector.begin(); iter != end; ++iter)
+        Dart_ListSetAt(result, index, TraitsType::toDartValue(*iter, domData));
+    return result;
+}
+
+template <typename T, size_t inlineCapacity, typename Allocator>
+struct DartValueTraits<WTF::Vector<T, inlineCapacity, Allocator> > {
+    static inline Dart_Handle toDartValue(const Vector<T, inlineCapacity, Allocator>& value, DartDOMData* domData)
+    {
+        return dartArray(value, domData);
+    }
+};
+
+// Errors?
+template<typename T, size_t inlineCapacity>
+Dart_Handle dartArray(const HeapVector<T, inlineCapacity>& vector, DartDOMData* domData)
+{
+    Dart_Handle result = Dart_NewList(vector.size());
+    int index = 0;
+    typename HeapVector<T, inlineCapacity>::const_iterator end = vector.end();
+    typedef DartValueTraits<T> TraitsType;
+    for (typename HeapVector<T, inlineCapacity>::const_iterator iter = vector.begin(); iter != end; ++iter)
+        Dart_ListSetAt(result, index, TraitsType::toDartValue(*iter, domData));
+    return result;
+}
+
+template<typename T, size_t inlineCapacity>
+struct DartValueTraits<HeapVector<T, inlineCapacity> > {
+    static inline Dart_Handle toDartValue(const HeapVector<T, inlineCapacity>& value, DartDOMData* domData)
+    {
+        return dartArray(value, domData);
+    }
+};
+
+
+#define DART_UNIMPLEMENTED_EXCEPTION() DartUtilities::notImplementedException(__FILE__, __LINE__)
+#define DART_UNIMPLEMENTED() Dart_ThrowException(DART_UNIMPLEMENTED_EXCEPTION());
+
+#if defined(DART_TIMER_SCOPE)
+#define DART_START_TIMER()        \
+    double timerStop, timerStart = currentTimeMS();
+#define DART_RECORD_TIMER(msg)    \
+    timerStop = currentTimeMS();  \
+    fprintf(stdout, "%s %.3f ms\n", msg, (timerStop - timerStart));
+#else
+#define DART_START_TIMER()
+#define DART_RECORD_TIMER(msg)
+#endif
+
+} // namespace blink
+
+#endif // DartUtilities_h