Improve Dart Debugger performance and robustness by creating Dart wrappers using the standard SetNa…

Source/bindings/dart/DartHandleProxy.cpp

 /*
  * Copyright (C) 2012 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
@@ skipping 10 matching lines @@
  * 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.
  */
 #include "config.h"
+#include "DartNode.h"
 #include "bindings/dart/DartHandleProxy.h"
-
 #include "bindings/dart/DartScriptValue.h"
 #include "bindings/dart/DartUtilities.h"
 #include "bindings/dart/V8Converter.h"
+#include "bindings/v8/PageScriptDebugServer.h"
+#include "bindings/v8/ScriptController.h"
+#include "bindings/v8/ScriptState.h"
+#include "bindings/v8/V8Binding.h"
+
+#include "core/platform/Logging.h"
+
+#include "wtf/StdLibExtras.h"
 
 #include <dart_debugger_api.h>
 
 namespace WebCore {
 
-static v8::Persistent<v8::FunctionTemplate> proxyTemplate();
+typedef HashMap<String, v8::Persistent<v8::FunctionTemplate> > FunctionTemplateMap;
 
-static DartScriptValue* readPointerFromProxy(v8::Handle<v8::Value> proxy)
+static v8::Persistent<v8::FunctionTemplate> objectProxyTemplate(Dart_Handle instance);
+static v8::Persistent<v8::FunctionTemplate> functionProxyTemplate();
+static v8::Persistent<v8::FunctionTemplate> libraryProxyTemplate();
+static v8::Persistent<v8::FunctionTemplate> classProxyTemplate(Dart_Handle clazz);
+static v8::Persistent<v8::FunctionTemplate> frameProxyTemplate();
+
+DartScriptValue* readPointerFromProxy(v8::Handle<v8::Value> proxy)
 {
     void* pointer = proxy.As<v8::Object>()->GetAlignedPointerFromInternalField(0);
     return static_cast<DartScriptValue*>(pointer);
 }
 
 static void weakCallback(v8::Isolate* isolate, v8::Persistent<v8::Object>* proxy, void*)
 {
     delete readPointerFromProxy(*proxy);
     proxy->Dispose(isolate);
 }
 
+static Dart_Handle unwrapValue(v8::Handle<v8::Value> value)
+{
+    if (DartHandleProxy::isDartProxy(value)) {
+        return Dart_HandleFromPersistent(readPointerFromProxy(value)->value());
+    }
+    Dart_Handle exception = 0;
+    Dart_Handle handle = V8Converter::toDart(value, exception);
+    ASSERT(!exception);
+    return handle;
+}
+
+bool libraryHasMember(Dart_Handle library, Dart_Handle name)

[Jacob, 2013/07/11 18:52:27]

Requested Dart API:
"LibraryHasMember" or something similar.

Basically we need an internal and external version depending on whether the
question you are asking is:
"Does library Foo have member Bar when used externally and does it have member
Bar when you are within library Bar itself.

+{
+    return !Dart_IsError(Dart_GetField(library, name))
+        || !Dart_IsError(Dart_GetClass(library, name))
+        || Dart_IsFunction(Dart_LookupFunction(library, name));
+}
+
+bool classHasMember(Dart_Handle clazz, Dart_Handle name)
+{

[Jacob, 2013/07/11 18:52:27]

Requested Dart Api:
"ClassHasMember"
would be nice if this was one line.

+    return !Dart_IsError(Dart_GetField(clazz, name)) || Dart_IsFunction(Dart_LookupFunction(clazz, name));
+}
+
+Dart_Handle getEncodedMapKeyList(Dart_Handle object)
+{
+    return DartUtilities::invokeUtilsMethod("getEncodedMapKeyList", 1, &object);
+}
+
+Dart_Handle stripTrailingDot(Dart_Handle str)
+{
+    return DartUtilities::invokeUtilsMethod("stripTrailingDot", 1, &str);
+}
+
+Dart_Handle addTrailingDot(Dart_Handle str)
+{
+    return DartUtilities::invokeUtilsMethod("addTrailingDot", 1, &str);
+}
+
+Dart_Handle lookupValueForEncodedMapKey(Dart_Handle object, Dart_Handle key)
+{
+    Dart_Handle args[] = {object, key};
+    return DartUtilities::invokeUtilsMethod("lookupValueForEncodedMapKey", 2, args);
+}
+
+Dart_Handle buildConstructorName(Dart_Handle className, Dart_Handle constructorName)
+{
+    Dart_Handle args[] = {className, constructorName};
+    return DartUtilities::invokeUtilsMethod("buildConstructorName", 2, args);
+}
+
+Dart_Handle stripClassName(Dart_Handle str, Dart_Handle className)
+{
+    Dart_Handle args[] = {str, className};
+    return DartUtilities::invokeUtilsMethod("stripClassName", 2, args);
+}
+
+Dart_Handle isNode(Dart_Handle clazz)
+{
+    return DartUtilities::invokeUtilsMethod("isNode", 1, &clazz);
+}
+
+void addFunctionNames(Dart_Handle handle, v8::Local<v8::Array>& properties, intptr_t* count, bool isInstance, bool noMethods)
+{
+    intptr_t length = 0;
+    Dart_Handle functionNames = Dart_GetFunctionNames(handle);
+    ASSERT(!Dart_IsError(functionNames));
+    bool isLibrary = Dart_IsLibrary(handle);
+    Dart_ListLength(functionNames, &length);
+    for (intptr_t i = 0; i < length; i++) {
+        Dart_Handle functionName = Dart_ListGetAt(functionNames, i);
+        Dart_Handle function = Dart_LookupFunction(handle, functionName);
+        bool isStatic = false;
+        Dart_FunctionIsStatic(function, &isStatic);
+
+        bool isConstructor = false;
+        Dart_FunctionIsConstructor(function, &isConstructor);
+
+        if (!isLibrary) {
+            if (isInstance && (isStatic || isConstructor))
+                continue;
+
+            bool isSetter = false;
+            Dart_FunctionIsSetter(function, &isSetter);
+            bool isGetter = false;
+            Dart_FunctionIsGetter(function, &isGetter);
+
+            if (noMethods && !isSetter && !isGetter)
+                continue;
+
+            if (isInstance && (isSetter || isStatic || isConstructor))
+                continue;
+        }
+
+        // Strip off the leading classname from constructor name.
+        if (isConstructor)

[Jacob, 2013/07/11 18:52:27]

Nit: why are constructor names prefixed with the class name? Seems like this
just adds extra work for api users?

+            functionName = stripClassName(functionName, Dart_ClassName(handle));
+
+        properties->Set(*count, V8Converter::stringToV8(functionName));
+        *count = *count + 1;
+    }
+}
+
+void addClassNames(Dart_Handle library, v8::Local<v8::Array>& properties, intptr_t* count)
+{
+    intptr_t length = 0;
+    Dart_Handle classNames = Dart_LibraryGetClassNames(library);
+    ASSERT(!Dart_IsNull(classNames));
+    ASSERT(Dart_IsList(classNames));
+    Dart_ListLength(classNames, &length);
+    for (intptr_t i = 0; i < length; i++) {
+        Dart_Handle className = Dart_ListGetAt(classNames, i);
+        properties->Set(*count, V8Converter::stringToV8(className));
+        *count = *count + 1;
+    }
+}
+
+void addFieldNames(intptr_t libraryId, v8::Local<v8::Array>& properties, intptr_t* count)
+{
+    intptr_t length = 0;
+    Dart_Handle fieldNames = Dart_GetLibraryFields(libraryId);
+    ASSERT(!Dart_IsNull(fieldNames));
+    ASSERT(Dart_IsList(fieldNames));
+    Dart_ListLength(fieldNames, &length);
+    for (intptr_t i = 0; i < length; i+=2) {
+        Dart_Handle fieldName = Dart_ListGetAt(fieldNames, i);
+        properties->Set(*count, V8Converter::stringToV8(fieldName));
+        *count = *count + 1;
+    }
+}
+
+static v8::Handle<v8::Value> convertResult(Dart_Handle result)
+{
+    if (Dart_IsError(result)) {
+        // FIXME: we would really prefer to call the following however it has
+        // bad unintended consequences as then JS cannot catch the thrown exception.
+        // DartUtilities::reportProblem(DartUtilities::scriptExecutionContext(), result);
+        // return v8::Undefined();
+
+        return v8::ThrowException(v8::String::New(Dart_GetError(result)));
+    }
+    return DartHandleProxy::create(result);
+}
+
+void setDartHandleInternalField(v8::Local<v8::Object> proxy, Dart_Handle value)
+{
+    proxy->SetAlignedPointerInInternalField(0, new DartScriptValue(value));
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Persistent<v8::Object> persistentHandle = v8::Persistent<v8::Object>::New(isolate, proxy);
+    persistentHandle.MakeWeak<v8::Object, void>(0, &weakCallback);
+}
+
+intptr_t getLibraryId(v8::Local<v8::Object> proxy)
+{
+    return (intptr_t)proxy.As<v8::Object>()->GetHiddenValue(v8::String::NewSymbol("libraryId"))->Int32Value();
+}
+
+// Returns a String of the library prefix or Dart_Null if no prefix is found.
+Dart_Handle getLibraryPrefix(v8::Local<v8::Object> proxy)
+{
+    v8::Local<v8::Value> prefix = proxy.As<v8::Object>()->GetHiddenValue(v8::String::NewSymbol("prefix"));
+    if (*prefix && prefix->IsString())
+        return V8Converter::stringToDart(prefix);
+    return Dart_Null();
+}
+
+static v8::Handle<v8::Value> functionNamedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret;
+    ASSERT(Dart_IsFunction(handle) || Dart_IsClosure(handle));
+
+    ret = Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("get:"), name)), 0, 0);

[Jacob, 2013/07/11 18:52:27]

For classes, I can just call 
Dart_Invoke with the prefix "get:" added to get a closure to a member, invoke a
getter, or get a field.
This is very convenient and it would be nice if I could do the same with
Libraries but currently I cannot.

+    if (Dart_IsError(ret) && name->Equals(v8::String::NewSymbol("__proto__")))
+        return v8::Undefined();
+
+    return convertResult(ret);
+}
+
+static v8::Handle<v8::Value> functionNamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    return throwError(v8ReferenceError, "Dart functions do not have writeable properties", v8::Isolate::GetCurrent());
+}
+
+static v8::Handle<v8::Value> functionInvocationCallback(v8::Arguments const& args)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(args.Holder());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    ASSERT(Dart_IsFunction(handle) || Dart_IsClosure(handle));
+    bool isConstructor = false;
+    Dart_FunctionIsConstructor(handle, &isConstructor);
+    if (args.IsConstructCall() != isConstructor) {
+        return throwError(v8ReferenceError,
+            isConstructor ? "Constructor called without new" : "Regular function called as constructor",
+            v8::Isolate::GetCurrent());
+    }
+
+    Vector<Dart_Handle> dartFunctionArgs;
+    for (uint32_t i = 0; i < args.Length(); ++i)
+        dartFunctionArgs.append(unwrapValue(args[i]));
+
+    if (Dart_IsClosure(handle))
+        return convertResult(Dart_InvokeClosure(handle, dartFunctionArgs.size(), dartFunctionArgs.data()));
+    Dart_Handle clazz = Dart_FunctionOwner(handle);
+    if (isConstructor)
+        // FIXME: this seems like an overly complex way to have to invoke a constructor.

[Jacob, 2013/07/11 18:52:27]

nit: this seems more complex than needed.

+        return convertResult(
+            Dart_New(clazz, stripClassName(Dart_FunctionName(handle), Dart_ClassName(clazz)),
+                dartFunctionArgs.size(), dartFunctionArgs.data()));
+    else
+        return convertResult(
+            Dart_Invoke(clazz, Dart_FunctionName(handle), dartFunctionArgs.size(), dartFunctionArgs.data()));
+}
+
+static v8::Handle<v8::Value> classProxyConstructorInvocationCallback(v8::Arguments const& args)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(args.Holder());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    ASSERT(Dart_IsClass(handle));
+
+    if (!args.IsConstructCall())
+        return throwError(v8SyntaxError, "Constructors can only be invoked with 'new'", v8::Isolate::GetCurrent());
+
+    Vector<Dart_Handle> dartFunctionArgs;
+    for (uint32_t i = 0; i < args.Length(); ++i)
+        dartFunctionArgs.append(unwrapValue(args[i]));
+
+    return convertResult(Dart_New(handle, Dart_Null(), dartFunctionArgs.size(), dartFunctionArgs.data()));
+}
+
+void getImportedLibrariesMatchingPrefix(int32_t libraryId, Dart_Handle prefix, Vector<std::pair<Dart_Handle, intptr_t> >* libraries)

[Jacob, 2013/07/11 18:52:27]

It would be nice if I didn't have to do all this work to find the libraries
matching a prefix.
With the right debugger APIs, I should even have to worry about exactly what
libraries match a prefix. 
Ideal solution for me:
Make all the existing library APIs just let me specify a prefix.
For example: I would be golden if I could just write (psuedo code)
Dart_Invoke(someLibraryHandle,  "someLibraryPrefix.someMemberName");

+{
+    Dart_Handle imports = Dart_GetLibraryImports(libraryId);
+    ASSERT(!Dart_IsError(imports));
+    // Unfortunately dart_debugger_api.h adds a trailing dot to import prefixes.
+    if (!Dart_IsNull(prefix))
+        prefix = addTrailingDot(prefix);
+    intptr_t length = 0;
+    Dart_ListLength(imports, &length);
+    for (intptr_t i = 0; i < length; i += 2) {
+        Dart_Handle importPrefix = Dart_ListGetAt(imports, i);
+        ASSERT(Dart_IsNull(importPrefix) || Dart_IsString(importPrefix));
+        bool equals = false;
+        Dart_Handle result = Dart_ObjectEquals(prefix, importPrefix, &equals);
+        ASSERT(!Dart_IsError(result));
+        if (equals) {
+            Dart_Handle importedLibraryIdHandle = Dart_ListGetAt(imports, i + 1);
+            ASSERT(Dart_IsInteger(importedLibraryIdHandle));
+            int64_t importedLibraryId;
+            Dart_IntegerToInt64(importedLibraryIdHandle, &importedLibraryId);
+            Dart_Handle libraryURL = Dart_GetLibraryURL(importedLibraryId);
+            ASSERT(!Dart_IsError(libraryURL));
+            Dart_Handle library = Dart_LookupLibrary(libraryURL);
+            ASSERT(Dart_IsLibrary(library));
+            libraries->append(std::pair<Dart_Handle, intptr_t>(library, importedLibraryId));
+        }
+    }
+}
+
+static v8::Handle<v8::Value> libraryNamedPropertyGetterHelper(Dart_Handle library, Dart_Handle dartName, bool* handled)
+{

[Jacob, 2013/07/11 18:52:27]

would be nice if I could just call Dart_Invoke instead of calling all three
options

+    Dart_Handle ret;
+    ret  = Dart_GetField(library, dartName);
+    if (!Dart_IsApiError(ret)) {
+        *handled = true;
+        return convertResult(ret);
+    }
+
+    ret = Dart_GetClass(library, dartName);
+    if (!Dart_IsError(ret)) {
+        *handled = true;
+        return convertResult(ret);
+    }
+
+    ret = Dart_LookupFunction(library, dartName);
+    if (!Dart_IsNull(ret) && !Dart_IsError(ret)) {

[Jacob, 2013/07/15 18:03:26]

why do i have a null check here?

+        *handled = true;
+        return convertResult(ret);
+    }
+    return v8::Undefined();
+}
+
+static v8::Handle<v8::Value> libraryNamedPropertyGetterHelper(v8::Local<v8::String> name,
+    const v8::AccessorInfo& info, bool* handled)
+{

[Jacob, 2013/07/11 18:52:27]

This is a mess due to handling prefixes.
It would be nice if the API was prefix aware

+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret;
+    ASSERT(Dart_IsLibrary(handle));
+    intptr_t libraryId = getLibraryId(info.This());
+    Dart_Handle dartName = V8Converter::stringToDart(name);
+    Dart_Handle prefix = getLibraryPrefix(info.This());
+    bool hasLibraryPrefix = !Dart_IsNull(prefix) && Dart_IsString(prefix);
+
+    if (hasLibraryPrefix) {
+        Vector<std::pair<Dart_Handle, intptr_t> > libraries;
+        getImportedLibrariesMatchingPrefix(libraryId, prefix, &libraries);
+        for (size_t i = 0; i < libraries.size(); i++) {
+            v8::Handle<v8::Value> returnValue = libraryNamedPropertyGetterHelper(libraries[i].first, dartName, handled);
+            if (*handled)
+                return returnValue;
+        }
+    } else {
+        v8::Handle<v8::Value> returnValue = libraryNamedPropertyGetterHelper(handle, dartName, handled);
+        if (*handled)
+            return returnValue;
+
+        // Check whether there is at least one library imported with the specified prefix.
+        Vector<std::pair<Dart_Handle, intptr_t> > libraries;
+        getImportedLibrariesMatchingPrefix(libraryId, dartName, &libraries);
+        if (libraries.size() > 0) {
+            *handled = true;
+            return DartHandleProxy::createLibraryProxy(handle, libraryId, dartName);
+        }
+    }
+
+    if (name->Equals(v8::String::NewSymbol("__proto__"))) {
+        *handled = true;
+        return v8::Null();
+    }
+    return v8::Undefined();
+}
+
+static v8::Handle<v8::Value> libraryNamedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    bool handled = false;
+    v8::Handle<v8::Value> ret = libraryNamedPropertyGetterHelper(name, info, &handled);
+    if (handled)
+        return ret;
+    return v8::ThrowException(v8::Exception::ReferenceError(v8::String::Concat(name, v8::String::New(" is not defined"))));
+}
+
+// TODO(jacobr): need to handle prefixes in this case as well.
+// Before checkin, handle prefixes correctly.
+static v8::Handle<v8::Value> libraryNamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret;
+    ASSERT(Dart_IsLibrary(handle));
+    Dart_Handle dartValue = unwrapValue(value);
+    ret = Dart_SetField(handle, V8Converter::stringToDart(property), dartValue);
+    return convertResult(ret);
+}
+
+static v8::Handle<v8::Integer> libraryQueryProperty(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    bool handled = false;
+    libraryNamedPropertyGetterHelper(name, info, &handled);
+    return handled ? v8Integer(0, info.GetIsolate()) : v8::Handle<v8::Integer>();
+}
+
+void libraryEnumerateHelper(Dart_Handle library, intptr_t libraryId, v8::Local<v8::Array> properties, intptr_t* count)
+{
+    addFunctionNames(library, properties, count, false, false);
+    addClassNames(library, properties, count);
+    addFieldNames(libraryId, properties, count);
+}
+
+static v8::Handle<v8::Array> libraryPropertyEnumerator(const v8::AccessorInfo& info)
+{

[Jacob, 2013/07/11 18:52:27]

It would be nice if Dart libraries provided a method to enumerate all members so
I didn't have to write all this code.
In particular, going back and forth between libraryIds and LibraryHandles is
slow and annoying.
This was enough of a bottleneck that I cache the list of library members for
performance.

+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    intptr_t libraryId = getLibraryId(info.This());
+    ASSERT(Dart_IsLibrary(handle));
+    v8::Local<v8::Array> cachedProperties = info.This().As<v8::Object>()->GetHiddenValue(v8::String::NewSymbol("cache")).As<v8::Array>();
+    if (*cachedProperties)
+        return cachedProperties;
+
+    Dart_Handle prefix = getLibraryPrefix(info.This());
+    bool hasLibraryPrefix = Dart_IsString(prefix);
+
+    v8::Local<v8::Array> properties = v8::Array::New();
+    intptr_t count = 0;
+
+    if (hasLibraryPrefix) {
+        Vector<std::pair<Dart_Handle, intptr_t> > libraries;
+        getImportedLibrariesMatchingPrefix(libraryId, prefix, &libraries);
+        for (intptr_t i = 0; i < libraries.size(); i++)
+            libraryEnumerateHelper(libraries[i].first, libraries[i].second, properties, &count);
+    } else {
+        libraryEnumerateHelper(handle, libraryId, properties, &count);
+        // Add all library prefixes of imports to the library.
+        Dart_Handle imports = Dart_GetLibraryImports(libraryId);
+        ASSERT(!Dart_IsError(imports));
+        intptr_t length = 0;
+        Dart_ListLength(imports, &length);
+        for (intptr_t i = 0; i < length; i += 2) {
+            Dart_Handle importPrefix = Dart_ListGetAt(imports, i);
+            if (!Dart_IsNull(importPrefix)) {
+                ASSERT(Dart_IsString(importPrefix));
+                properties->Set(count, V8Converter::stringToV8(
+                    stripTrailingDot(importPrefix)));
+                count++;
+            }
+            bool equals = false;
+        }
+    }
+    info.This()->SetHiddenValue(v8::String::NewSymbol("cache"), properties);
+    return properties;
+}
+
+static v8::Handle<v8::Value> classNamedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret;
+    ASSERT(Dart_IsClass(handle));
+    // XXX hack... remove... FILE A BUG!
+    bool isDynamic = false;

[Jacob, 2013/07/11 18:52:27]

What should we do about the class "dynamic".
It exists but then behaves badly so I have to hack around it.

+    Dart_ObjectEquals(Dart_ClassName(handle), Dart_NewStringFromCString("dynamic"), &isDynamic);
+
+    if (!Dart_ClassIsTypedef(handle) && !Dart_ClassIsFunctionType(handle) && !isDynamic) {

[Jacob, 2013/07/11 18:52:27]

Similarly to the case of Library, it would be nice if there was just an API to
get all the string names of Class/Type members

+
+        Dart_Handle dartName = V8Converter::stringToDart(name);
+        ret = Dart_GetField(handle, dartName);
+        if (!Dart_IsError(ret))
+            return convertResult(ret);
+        ret = Dart_LookupFunction(handle, dartName);
+        if (!Dart_IsNull(ret) && !Dart_IsError(ret))
+            return convertResult(ret);
+
+        Dart_Handle className = Dart_ClassName(handle);
+        ASSERT(Dart_IsString(className));
+        Dart_Handle constructorName = buildConstructorName(className, V8Converter::stringToDart(name));
+        ret = Dart_LookupFunction(handle, constructorName);
+        if (!Dart_IsNull(ret) && !Dart_IsError(ret))
+            return convertResult(ret);
+    }
+
+    if (name->Equals(v8::String::NewSymbol("__proto__"))) {
+        Dart_Handle superclass = Dart_GetSuperclass(handle);
+        if (!Dart_IsError(superclass))
+            return DartHandleProxy::create(superclass);
+        return v8::Undefined();
+    }
+    return v8::ThrowException(v8::Exception::ReferenceError(v8::String::Concat(name, v8::String::New(" is not defined"))));
+}
+
+static v8::Handle<v8::Value> classNamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret;
+    ASSERT(Dart_IsClass(handle));
+    Dart_Handle dartValue = unwrapValue(value);
+    ret = Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("set:"), property)), 1, &dartValue);

[Jacob, 2013/07/11 18:52:27]

TODO(jacobr): similar to the case of Libraries, this probably doesn't work for
static fields.

+    return convertResult(ret);
+}
+
+static v8::Handle<v8::Integer> classQueryProperty(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret;
+    ASSERT(Dart_IsClass(handle));
+    if (classHasMember(handle, V8Converter::stringToDart(name)))
+        return v8Integer(0, info.GetIsolate());
+    return v8::Handle<v8::Integer>();
+}
+
+static v8::Handle<v8::Array> classPropertyEnumerator(const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    ASSERT(Dart_IsClass(handle));
+
+    v8::Local<v8::Array> properties = v8::Array::New();
+    intptr_t count = 0;
+    addFunctionNames(handle, properties, &count, false, false);

[Jacob, 2013/07/11 18:52:27]

it would be nice if there was just an Dart API method to enumerate all the
members of a Type/Library/Class instance.

+    return properties;
+}
+
+// Returns the index in the list of the property if it is found, -1 otherwise.
+static int findMatchingNamedProperty(Dart_Handle list, v8::Local<v8::String> name)
+{
+    // FIXME: perhaps push this logic into Dart code instead.
+    v8::String::Utf8Value stringValue(name);
+    const char* nameData = *stringValue;
+    intptr_t nameLength = stringValue.length();
+
+    intptr_t length = 0;
+    Dart_ListLength(list, &length);
+    for (intptr_t i = 0; i < length; i += 2) {
+        intptr_t candidateNameLength = 0;
+        uint8_t* candidateData = 0;
+        intptr_t candidateLength = 0;
+        Dart_StringToUTF8(Dart_ListGetAt(list, i), &candidateData, &candidateLength);
+        if ((candidateLength >= nameLength
+            && (candidateLength == nameLength || candidateData[nameLength] == '@'))
+            && !memcmp(candidateData, nameData, nameLength))
+            return i / 2;
+    }
+    return -1;
+}
+
+static v8::Handle<v8::Value> frameNamedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{

[Jacob, 2013/07/11 18:52:27]

It would be nice if the local frame was just exposed as a Dart object with
fields that could be returned and set rather than a list of field names and
values.
It would be nice if the local frame also included closures defined in the local
frame (don't think it does).

+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    ASSERT(Dart_IsList(handle));
+    int index = findMatchingNamedProperty(handle, name);
+    if (index != -1)
+        return convertResult(Dart_ListGetAt(handle, index * 2 + 1));
+    if (name->Equals(v8::String::NewSymbol("this")))
+        return v8::Undefined();
+    return v8::ThrowException(v8::Exception::ReferenceError(v8::String::Concat(name, v8::String::New(" is not defined"))));
+}
+
+static v8::Handle<v8::Value> frameNamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{

[Jacob, 2013/07/11 18:52:27]

This is the one case where we can't manipulate Data in the Dart context.  It
would be nice to fix for completeness.
Users will be confused that all other data is modifiable but not this.

+    return throwError(v8ReferenceError, "Dart does not yet provide a debugger api for setting local fields", v8::Isolate::GetCurrent());
+}
+
+static v8::Handle<v8::Integer> frameQueryProperty(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    ASSERT(Dart_IsList(handle));
+    int index = findMatchingNamedProperty(handle, name);
+    return index == -1 ? v8::Handle<v8::Integer>() : v8Integer(0, info.GetIsolate());
+}
+
+static v8::Handle<v8::Array> framePropertyEnumerator(const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    ASSERT(Dart_IsList(handle));
+
+    intptr_t length = 0;
+    Dart_ListLength(handle, &length);
+    v8::Local<v8::Array> properties = v8::Array::New(length / 2);
+    for (intptr_t i = 0; i < length; i += 2) {
+        // Truncate everything after the '@'.

[Jacob, 2013/07/11 18:52:27]

it would be nice if there was an option to get names without the @ both for the
frame api and elsewhere.

+        // TODO(jacobr): we shouldn't have to do this, there should be an API that provides
+        // Mirror APIs on frames directly.
+        const char* nameData = 0;
+        Dart_StringToCString(Dart_ListGetAt(handle, i), &nameData);
+        ASSERT(nameData);
+        if (!nameData)
+            continue;
+
+        intptr_t nameLength = strlen(nameData);
+
+        for (intptr_t j = 0; j < nameLength; j++) {
+            if (nameData[j] == '@') {
+                nameLength = j;
+                break;
+            }
+        }
+        properties->Set(i / 2, v8::String::New(nameData, nameLength));
+    }
+    return properties;
+}
+
+static v8::Handle<v8::Value> namedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret;
+    ASSERT(Dart_IsInstance(handle));
+    v8::String::Utf8Value stringName(name);
+    const char* data = *stringName;
+    if (data[0] == ':' || data[0] == '#') {
+        // Look up a map key instead of a regular property as regular dart property names
+        // cannot start with these symbols.
+        return convertResult(
+            lookupValueForEncodedMapKey(handle, V8Converter::stringToDart(name)));
+    }
+
+    ret = Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("get:"), name)), 0, 0);
+    if (Dart_IsError(ret) && name->Equals(v8::String::NewSymbol("__proto__")))
+        return DartHandleProxy::create(Dart_GetObjClass(handle));
+
+    return convertResult(ret);
+}
+
+static v8::Handle<v8::Value> namedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret;
+    Dart_Handle dartValue = unwrapValue(value);
+    ret = Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("set:"), property)), 1, &dartValue);
+    if (Dart_IsError(ret)) {
+        Dart_Handle dartPropertyName = V8Converter::stringToDart(property);
+        Dart_Handle indexedGetterOperator = Dart_NewStringFromCString("[]=");
+        Dart_Handle args[] = {dartPropertyName, dartValue};
+        ret = Dart_Invoke(handle, indexedGetterOperator, 2, args);
+    }
+    return convertResult(ret);
+}
+
+// FIXME: duplicated code with getter. XXX
+static v8::Handle<v8::Integer> objectQueryProperty(v8::Local<v8::String> name, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret;
+    ASSERT(Dart_IsInstance(handle));
+    v8::String::Utf8Value stringName(name);
+    const char* data = *stringName;
+
+    // Looking up a map key instead of a regular property... as regular dart property names
+    // cannot start with these symbols.
+    if (data[0] == ':' || data[0] == '#')
+        return v8Integer(0, info.GetIsolate());
+
+    ret = Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("get:"), name)), 0, 0);
+    if (Dart_IsError(ret)) {
+        if (name->Equals(v8::String::NewSymbol("__proto__")))
+            return v8Integer(0, info.GetIsolate());
+        return v8::Handle<v8::Integer>();
+    }
+    return v8Integer(0, info.GetIsolate());
+}
+
+static v8::Handle<v8::Array> objectPropertyEnumerator(const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    ASSERT(Dart_IsInstance(handle));
+
+    Dart_Handle typeHandle;
+    if (Dart_IsInstance(handle))
+        typeHandle = Dart_InstanceGetClass(handle);
+    else
+        typeHandle = handle;
+
+    v8::Local<v8::Array> properties = v8::Array::New();
+    intptr_t count = 0;
+
+    Dart_Handle mapKeys = getEncodedMapKeyList(handle);
+    if (Dart_IsList(mapKeys)) {
+        // If the object has map keys, add them all as properties at the start
+        // of the list. This aids for debugging although it risks confusing
+        // users.
+        intptr_t length = 0;
+        Dart_ListLength(mapKeys, &length);
+        for (intptr_t i = 0; i < length; i++) {
+            properties->Set(count, V8Converter::stringToV8(Dart_ListGetAt(mapKeys, i)));
+            count++;
+        }
+    }
+
+    Dart_Handle instanceFields = Dart_GetInstanceFields(handle);
+    intptr_t length = 0;
+    Dart_ListLength(instanceFields, &length);
+    for (intptr_t i = 0; i < length; i += 2) {
+        properties->Set(count, DartHandleProxy::create(
+            Dart_ListGetAt(instanceFields, i)));
+        count++;
+    }
+
+    while (!Dart_IsError(typeHandle) && !Dart_IsNull(typeHandle)) {
+        intptr_t interfaceCount = 0;
+        Dart_ClassGetInterfaceCount(typeHandle, &interfaceCount);
+        for (intptr_t i = 0; i < interfaceCount; i++) {
+            addFunctionNames(Dart_ClassGetInterfaceAt(typeHandle, i),
+                properties, &count, true, true);
+        }
+        // TODO(jacobr): is this duplicated work?
+        addFunctionNames(typeHandle, properties, &count, true, true);
+        typeHandle = Dart_GetSuperclass(typeHandle);
+    }
+    return properties;
+}
+
+static v8::Handle<v8::Value> indexedGetter(uint32_t index, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret = 0;
+    if (Dart_IsList(handle))
+        ret = Dart_ListGetAt(handle, index);
+    else
+        ret = Dart_Null();
+
+    return convertResult(ret);
+}
+
+static v8::Handle<v8::Value> indexedSetter(uint32_t index, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    Dart_Handle ret = 0;
+    if (Dart_IsList(handle))
+        ret = Dart_ListSetAt(handle, index, unwrapValue(value));
+    else
+        ret = Dart_Null();
+
+    return convertResult(ret);
+}
+
+static v8::Handle<v8::Array> indexedEnumerator(const v8::AccessorInfo& info)
+{
+    DartScriptValue* scriptValue = readPointerFromProxy(info.This());
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    intptr_t length = 0;
+    if (Dart_IsList(handle))
+        Dart_ListLength(handle, &length);
+
+    v8::Local<v8::Array> indexes = v8::Array::New(length);
+    for (int i = 0; i < length; i++)
+        indexes->Set(i, v8::Integer::New(i));
+
+    return indexes;
+}
+
+static v8::Local<v8::ObjectTemplate> setupInstanceTemplate(v8::Persistent<v8::FunctionTemplate> proxyTemplate)
+{
+    v8::Local<v8::ObjectTemplate> instanceTemplate = proxyTemplate->InstanceTemplate();
+    instanceTemplate->SetInternalFieldCount(1);
+    return instanceTemplate;
+}
+
+static v8::Persistent<v8::FunctionTemplate> objectProxyTemplate(Dart_Handle instance)
+{
+    DEFINE_STATIC_LOCAL(FunctionTemplateMap, map, ());
+    // FIXME: we should switch to Dart_InstanceGetType when possible.
+    Dart_Handle dartType = Dart_InstanceGetClass(instance);
+    ASSERT(!Dart_IsError(dartType));
+    Dart_Handle classNameHandle = Dart_ClassName(dartType);
+    ASSERT(!Dart_IsError(classNameHandle));
+    if (Dart_IsError(classNameHandle))
+        classNameHandle = Dart_NewStringFromCString("MYSTERY DART CLAZZ XXX");
+    ASSERT(!Dart_IsError(classNameHandle));
+    v8::Handle<v8::String> classNameV8 = V8Converter::stringToV8(classNameHandle);
+    String className = toWebCoreString(classNameV8);
+    v8::Persistent<v8::FunctionTemplate> proxyTemplate = map.get(className);
+
+    if (proxyTemplate.IsEmpty()) {
+        proxyTemplate = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), v8::FunctionTemplate::New());
+        proxyTemplate->SetClassName(classNameV8);
+        map.set(className, proxyTemplate);
+        v8::Local<v8::ObjectTemplate> instanceTemplate = setupInstanceTemplate(proxyTemplate);
+        instanceTemplate->SetIndexedPropertyHandler(&indexedGetter, &indexedSetter, 0, 0, &indexedEnumerator);
+        instanceTemplate->SetNamedPropertyHandler(&namedPropertyGetter, &namedPropertySetter, &objectQueryProperty, 0, &objectPropertyEnumerator);
+    }
+    return proxyTemplate;
+}
+
+static v8::Persistent<v8::FunctionTemplate> functionProxyTemplate()
+{
+    static v8::Persistent<v8::FunctionTemplate> proxyTemplate;
+    if (proxyTemplate.IsEmpty()) {
+        proxyTemplate = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), v8::FunctionTemplate::New());
+        proxyTemplate->SetClassName(v8::String::New("[Dart Function]"));
+        v8::Local<v8::ObjectTemplate> instanceTemplate = setupInstanceTemplate(proxyTemplate);
+        instanceTemplate->SetNamedPropertyHandler(&functionNamedPropertyGetter, &functionNamedPropertySetter);
+        instanceTemplate->SetCallAsFunctionHandler(&functionInvocationCallback);
+    }
+    return proxyTemplate;
+}
+
+static v8::Persistent<v8::FunctionTemplate> libraryProxyTemplate()
+{
+    static v8::Persistent<v8::FunctionTemplate> proxyTemplate;
+    if (proxyTemplate.IsEmpty()) {
+        proxyTemplate = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), v8::FunctionTemplate::New());
+        proxyTemplate->SetClassName(v8::String::New("[Dart Library]"));
+        v8::Local<v8::ObjectTemplate> instanceTemplate = setupInstanceTemplate(proxyTemplate);
+        instanceTemplate->SetNamedPropertyHandler(&libraryNamedPropertyGetter, &libraryNamedPropertySetter, &libraryQueryProperty, 0, &libraryPropertyEnumerator);
+    }
+    return proxyTemplate;
+}
+
+static v8::Persistent<v8::FunctionTemplate> classProxyTemplate(Dart_Handle clazz)
+{
+    DEFINE_STATIC_LOCAL(FunctionTemplateMap, map, ());
+    Dart_Handle classNameHandle = Dart_ClassName(clazz);
+    ASSERT(!Dart_IsError(classNameHandle));
+    v8::Handle<v8::String> classNameV8 = V8Converter::stringToV8(classNameHandle);
+    String className = toWebCoreString(classNameV8);
+
+    v8::Persistent<v8::FunctionTemplate> proxyTemplate = map.get(className);
+    if (proxyTemplate.IsEmpty()) {
+        proxyTemplate = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), v8::FunctionTemplate::New());
+        proxyTemplate->SetClassName(classNameV8);
+        v8::Local<v8::ObjectTemplate> instanceTemplate = setupInstanceTemplate(proxyTemplate);
+        instanceTemplate->SetNamedPropertyHandler(&classNamedPropertyGetter, &classNamedPropertySetter, &classQueryProperty, 0, &classPropertyEnumerator);
+        instanceTemplate->SetCallAsFunctionHandler(&classProxyConstructorInvocationCallback);
+        map.set(className, proxyTemplate);
+    }
+    return proxyTemplate;
+}
+
+static v8::Persistent<v8::FunctionTemplate> frameProxyTemplate()
+{
+    static v8::Persistent<v8::FunctionTemplate> proxyTemplate;
+    if (proxyTemplate.IsEmpty()) {
+        proxyTemplate = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), v8::FunctionTemplate::New());
+        proxyTemplate->SetClassName(v8::String::New("[Dart Frame]"));
+        v8::Local<v8::ObjectTemplate> instanceTemplate = setupInstanceTemplate(proxyTemplate);
+        instanceTemplate->SetNamedPropertyHandler(&frameNamedPropertyGetter, &frameNamedPropertySetter, &frameQueryProperty, 0, &framePropertyEnumerator);
+    }
+    return proxyTemplate;
+}
+
 v8::Handle<v8::Value> DartHandleProxy::create(Dart_Handle value)
 {
     v8::Context::Scope scope(DartUtilities::currentV8Context());
 
     if (Dart_IsNull(value))
         return v8::Null();
     if (Dart_IsString(value))
         return V8Converter::stringToV8(value);
     if (Dart_IsBoolean(value))
         return V8Converter::booleanToV8(value);
     if (Dart_IsNumber(value))
         return V8Converter::numberToV8(value);
-
-    v8::Local<v8::Object> proxy = proxyTemplate()->InstanceTemplate()->NewInstance();
-    proxy->SetAlignedPointerInInternalField(0, new DartScriptValue(value));
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
-    v8::Persistent<v8::Object> persistentHandle = v8::Persistent<v8::Object>::New(isolate, proxy);
-    persistentHandle.MakeWeak<v8::Object, void>(0, &weakCallback);
-    proxy->Set(v8::String::New("isProxy"), v8::Boolean::New(true));
+    v8::Local<v8::Object> proxy;
+    // TODO(jacobr): could optimize the order of these checks.
+    if (Dart_IsFunction(value) || Dart_IsClosure(value))
+        proxy = functionProxyTemplate()->InstanceTemplate()->NewInstance();
+    else if (Dart_IsInstance(value))
+        proxy = objectProxyTemplate(value)->InstanceTemplate()->NewInstance();
+    else {
+        ASSERT(Dart_IsClass(value));
+        proxy = classProxyTemplate(value)->InstanceTemplate()->NewInstance();
+    }
+    setDartHandleInternalField(proxy, value);
+    proxy->SetHiddenValue(v8::String::NewSymbol("dartProxy"), v8::Boolean::New(true));
+
     return proxy;
 }
 
-v8::Handle<v8::Value> DartHandleProxy::createForLibrary(intptr_t libraryId)
-{
-    Dart_Handle libraryURL = Dart_GetLibraryURL(libraryId);
-    ASSERT(!Dart_IsError(libraryURL));
-    Dart_Handle library = Dart_LookupLibrary(libraryURL);
-    v8::Handle<v8::Object> libraryProxy = create(library)->ToObject();
-    libraryProxy->SetHiddenValue(v8::String::New("libraryId"), v8::Number::New(libraryId));
-    return libraryProxy;
-}
-
-class DartReceiverScope {
-public:
-    DartReceiverScope(const v8::Arguments& args)
-        : m_receiver(readPointerFromProxy(args[0]))
-        , m_isolateScope(m_receiver->isolate())
-        , m_apiScope()
-    {
-    }
-
-    Dart_Handle receiver() { return Dart_HandleFromPersistent(m_receiver->value()); }
-
-private:
-    DartScriptValue* m_receiver;
-    DartIsolateScope m_isolateScope;
-    DartApiScope m_apiScope;
-};
-
-static v8::Persistent<v8::FunctionTemplate> proxyTemplate()
-{
-    static v8::Persistent<v8::FunctionTemplate> proxyTemplate;
-    if (proxyTemplate.IsEmpty()) {
-        proxyTemplate = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), v8::FunctionTemplate::New());
-        v8::Local<v8::ObjectTemplate> instanceTemplate = proxyTemplate->InstanceTemplate();
-        instanceTemplate->SetInternalFieldCount(1);
-    }
-    return proxyTemplate;
-}
-
-static Dart_Handle unwrapValue(v8::Handle<v8::Value> value)
-{
-    if (proxyTemplate()->HasInstance(value))
-        return Dart_HandleFromPersistent(readPointerFromProxy(value)->value());
+bool DartHandleProxy::isDartProxy(v8::Handle<v8::Value> value)
+{
+    if (value->IsObject()) {
+        v8::Local<v8::Value> hiddenValue = value.As<v8::Object>()->GetHiddenValue(v8::String::NewSymbol("dartProxy"));
+        return *hiddenValue && hiddenValue->IsBoolean();
+    }
+    return false;
+}
+
+const char* DartHandleProxy::getType(v8::Handle<v8::Value> value) {
+    DartScriptValue* scriptValue = readPointerFromProxy(value);
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+
+    if (Dart_IsInstance(handle)) {
+        if (Dart_IsList(handle))
+            return "array";
+
+        Dart_Handle exception = 0;
+        if (DartUtilities::dartToBool(isNode(handle), exception))
+            return "node";
+        ASSERT(!exception);
+    }
+
+    return 0;
+}
+
+Node* DartHandleProxy::toNativeNode(v8::Handle<v8::Value> value) {
+    DartScriptValue* scriptValue = readPointerFromProxy(value);
+    ASSERT(scriptValue->isIsolateAlive());
+    DartIsolateScope scope(scriptValue->isolate());
+    DartApiScope apiScope;
+    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
     Dart_Handle exception = 0;
-    Dart_Handle handle = V8Converter::toDart(value, exception);
+    Node* node = DartNode::toNative(handle, exception);
     ASSERT(!exception);
-    return handle;
-}
-
-static v8::Handle<v8::Value> convertResult(Dart_Handle result)
-{
-    if (Dart_IsError(result)) {
-        // Consider wrapping not as a string, but as dedicated
-        // exception wrapper.
-        return v8::String::New("<Exception thrown>");
-    }
-    return DartHandleProxy::create(result);
-}
-
-// --- Objects ----
-
-static v8::Handle<v8::Value> instanceGetClass(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return convertResult(Dart_InstanceGetClass(scope.receiver()));
-}
-
-// --- Lists ---
-
-static v8::Handle<v8::Value> isList(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return v8::Boolean::New(Dart_IsList(scope.receiver()));
-}
-
-static v8::Handle<v8::Value> listGetAt(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return convertResult(Dart_ListGetAt(scope.receiver(), args[1]->Int32Value()));
-}
-
-static v8::Handle<v8::Value> listSetAt(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return convertResult(Dart_ListSetAt(scope.receiver(), args[1]->Int32Value(), unwrapValue(args[2])));
-}
-
-// --- Classes and Interfaces ---
-
-static v8::Handle<v8::Value> className(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return convertResult(Dart_ClassName(scope.receiver()));
-}
-
-static v8::Handle<v8::Value> classGetLibrary(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return convertResult(Dart_ClassGetLibrary(scope.receiver()));
-}
-
-static v8::Handle<v8::Value> getSuperclass(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return convertResult(Dart_GetSuperclass(scope.receiver()));
-}
-
-// --- Function and Variable Declarations ---
-
-static v8::Handle<v8::Value> getFunctionNames(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return V8Converter::listToV8(Dart_GetFunctionNames(scope.receiver()));
-}
-
-static v8::Handle<v8::Value> getClassNames(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    Dart_Handle classNames = Dart_LibraryGetClassNames(scope.receiver());
-    ASSERT(!Dart_IsError(classNames) && !Dart_IsNull(classNames));
-    return V8Converter::listToV8(classNames);
-}
-
-static v8::Handle<v8::Value> lookupClass(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return convertResult(Dart_GetClass(scope.receiver(), V8Converter::stringToDart(args[1])));
-}
-
-static v8::Handle<v8::Value> lookupFunction(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-
-    Dart_Handle function = Dart_LookupFunction(scope.receiver(), V8Converter::stringToDart(args[1]));
-    ASSERT(!Dart_IsError(function) && !Dart_IsNull(function));
-
-    Dart_Handle result;
-    UNUSED_PARAM(result);
-
-    bool isAbstract;
-    result = Dart_FunctionIsAbstract(function, &isAbstract);
-    ASSERT(!Dart_IsError(result));
-    bool isStatic;
-    result = Dart_FunctionIsStatic(function, &isStatic);
-    ASSERT(!Dart_IsError(result));
-    bool isConstructor;
-    result = Dart_FunctionIsConstructor(function, &isConstructor);
-    ASSERT(!Dart_IsError(result));
-    bool isGetter;
-    result = Dart_FunctionIsGetter(function, &isGetter);
-    ASSERT(!Dart_IsError(result));
-    bool isSetter;
-    result = Dart_FunctionIsSetter(function, &isSetter);
-    ASSERT(!Dart_IsError(result));
-    int64_t fixedParameterCount;
-    int64_t optionalParamerterCount;
-    result = Dart_FunctionParameterCounts(function, &fixedParameterCount, &optionalParamerterCount);
-    ASSERT(!Dart_IsError(result));
-
-    v8::Handle<v8::Object> description = v8::Object::New();
-    description->Set(v8::String::New("isAbstract"), v8::Boolean::New(isAbstract));
-    description->Set(v8::String::New("isStatic"), v8::Boolean::New(isStatic));
-    description->Set(v8::String::New("isConstructor"), v8::Boolean::New(isConstructor));
-    description->Set(v8::String::New("isGetter"), v8::Boolean::New(isGetter));
-    description->Set(v8::String::New("isSetter"), v8::Boolean::New(isSetter));
-    description->Set(v8::String::New("fixedParameterCount"), v8::Integer::New(fixedParameterCount));
-    description->Set(v8::String::New("optionalParamerterCount"), v8::Integer::New(optionalParamerterCount));
-    return description;
-}
-
-static v8::Handle<v8::Value> getVariableNames(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return V8Converter::listToV8(Dart_GetVariableNames(scope.receiver()));
-}
-
-static v8::Handle<v8::Value> lookupVariable(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    Dart_Handle variable = Dart_LookupVariable(scope.receiver(), V8Converter::stringToDart(args[1]));
-    ASSERT(!Dart_IsError(variable) && !Dart_IsNull(variable));
-
-    Dart_Handle result;
-    UNUSED_PARAM(result);
-
-    bool isStatic;
-    result = Dart_VariableIsStatic(variable, &isStatic);
-    ASSERT(!Dart_IsError(result));
-    bool isFinal;
-    result = Dart_VariableIsFinal(variable, &isFinal);
-    ASSERT(!Dart_IsError(result));
-
-    v8::Local<v8::Object> description = v8::Object::New();
-    description->Set(v8::String::New("isStatic"), v8::Boolean::New(isStatic));
-    description->Set(v8::String::New("isFinal"), v8::Boolean::New(isFinal));
-    return description;
-}
-
-// --- Constructors, Methods, and Fields ---
-
-static v8::Handle<v8::Value> invoke(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    Vector<Dart_Handle> dartFunctionArgs;
-    v8::Handle<v8::Array> v8FunctionArgs = args[2].As<v8::Array>();
-    for (uint32_t i = 0; i < v8FunctionArgs->Length(); ++i)
-        dartFunctionArgs.append(unwrapValue(v8FunctionArgs->Get(i)));
-    return convertResult(Dart_Invoke(scope.receiver(), V8Converter::stringToDart(args[1]), dartFunctionArgs.size(), dartFunctionArgs.data()));
-}
-
-static v8::Handle<v8::Value> dartNew(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    Vector<Dart_Handle> dartConstructorArgs;
-    v8::Handle<v8::Array> v8ConstructorArgs = args[2].As<v8::Array>();
-    for (uint32_t i = 0; i < v8ConstructorArgs->Length(); ++i)
-        dartConstructorArgs.append(unwrapValue(v8ConstructorArgs->Get(i)));
-    return convertResult(Dart_New(scope.receiver(), V8Converter::stringToDart(args[1]), dartConstructorArgs.size(), dartConstructorArgs.data()));
-}
-
-static v8::Handle<v8::Value> getField(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-
-    return convertResult(Dart_GetField(scope.receiver(), V8Converter::stringToDart(args[1])));
-}
-
-static v8::Handle<v8::Value> setField(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    v8::Handle<v8::Array> v8FunctionArgs = args[2].As<v8::Array>();
-    ASSERT(v8FunctionArgs->Length() == 1);
-    return convertResult(Dart_SetField(scope.receiver(), V8Converter::stringToDart(args[1]), unwrapValue(v8FunctionArgs->Get(0))));
-}
-
-// --- Scripts and Libraries ---
-
-static v8::Handle<v8::Value> libraryName(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return convertResult(Dart_LibraryName(scope.receiver()));
-}
-
-static v8::Handle<v8::Value> libraryUrl(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    return convertResult(Dart_LibraryUrl(scope.receiver()));
-}
-
-static v8::Handle<v8::Value> libraryImports(const v8::Arguments& args)
-{
-    DartReceiverScope scope(args);
-    int32_t libraryId = args[0].As<v8::Object>()->GetHiddenValue(v8::String::New("libraryId"))->Int32Value();
-    Dart_Handle imports = Dart_GetLibraryImports(libraryId);
-    ASSERT(!Dart_IsError(imports));
-    intptr_t length = 0;
-    Dart_ListLength(imports, &length);
-    v8::Handle<v8::Array> result = v8::Array::New();
-    for (intptr_t i = 0; i < length; i += 2) {
-        Dart_Handle prefix = Dart_ListGetAt(imports, i);
-        result->Set(i, DartHandleProxy::create(prefix));
-        Dart_Handle importedLibraryIdHandle = Dart_ListGetAt(imports, i + 1);
-        ASSERT(Dart_IsInteger(importedLibraryIdHandle));
-        int64_t importedLibraryId;
-        Dart_IntegerToInt64(importedLibraryIdHandle, &importedLibraryId);
-        result->Set(i + 1, DartHandleProxy::createForLibrary(importedLibraryId));
-    }
-    return result;
-}
-
-void DartHandleProxy::getMirrorAPI(v8::Handle<v8::Object> container)
-{
-    V8Scope v8scope;
-    container->Set(v8::String::New("instanceGetClass"), v8::FunctionTemplate::New(&instanceGetClass)->GetFunction());
-    container->Set(v8::String::New("isList"), v8::FunctionTemplate::New(&isList)->GetFunction());
-    container->Set(v8::String::New("listGetAt"), v8::FunctionTemplate::New(&listGetAt)->GetFunction());
-    container->Set(v8::String::New("listSetAt"), v8::FunctionTemplate::New(&listSetAt)->GetFunction());
-    container->Set(v8::String::New("className"), v8::FunctionTemplate::New(&className)->GetFunction());
-    container->Set(v8::String::New("classGetLibrary"), v8::FunctionTemplate::New(&classGetLibrary)->GetFunction());
-    container->Set(v8::String::New("getSuperclass"), v8::FunctionTemplate::New(&getSuperclass)->GetFunction());
-    container->Set(v8::String::New("getFunctionNames"), v8::FunctionTemplate::New(&getFunctionNames)->GetFunction());
-    container->Set(v8::String::New("getClassNames"), v8::FunctionTemplate::New(&getClassNames)->GetFunction());
-    container->Set(v8::String::New("lookupFunction"), v8::FunctionTemplate::New(&lookupFunction)->GetFunction());
-    container->Set(v8::String::New("lookupClass"), v8::FunctionTemplate::New(&lookupClass)->GetFunction());
-    container->Set(v8::String::New("getVariableNames"), v8::FunctionTemplate::New(&getVariableNames)->GetFunction());
-    container->Set(v8::String::New("lookupVariable"), v8::FunctionTemplate::New(&lookupVariable)->GetFunction());
-    container->Set(v8::String::New("invoke"), v8::FunctionTemplate::New(&invoke)->GetFunction());
-    container->Set(v8::String::New("dartNew"), v8::FunctionTemplate::New(&dartNew)->GetFunction());
-    container->Set(v8::String::New("getField"), v8::FunctionTemplate::New(&getField)->GetFunction());
-    container->Set(v8::String::New("setField"), v8::FunctionTemplate::New(&setField)->GetFunction());
-    container->Set(v8::String::New("libraryName"), v8::FunctionTemplate::New(&libraryName)->GetFunction());
-    container->Set(v8::String::New("libraryUrl"), v8::FunctionTemplate::New(&libraryUrl)->GetFunction());
-    container->Set(v8::String::New("libraryImports"), v8::FunctionTemplate::New(&libraryImports)->GetFunction());
-}
-
-}
+    return node;
+}
+
+/**
+ * Creates a proxy for a Dart library.
+ * If a string prefix is specified, we similuate that all requests to the library start with
+ * the specified prefix.
+ */
+v8::Handle<v8::Value> DartHandleProxy::createLibraryProxy(Dart_Handle value, int32_t libraryId, Dart_Handle prefix)
+{

[Jacob, 2013/07/11 18:52:27]

why do I have to keep around both a handle to a library and a libraryId? 

+    v8::Context::Scope scope(DartUtilities::currentV8Context());
+    ASSERT(Dart_IsLibrary(value));
+    v8::Local<v8::Object> proxy = libraryProxyTemplate()->InstanceTemplate()->NewInstance();
+    setDartHandleInternalField(proxy, value);
+    proxy->SetHiddenValue(v8::String::NewSymbol("libraryId"), v8::Number::New(libraryId));
+    if (Dart_IsString(prefix))
+        proxy->SetHiddenValue(v8::String::NewSymbol("prefix"), V8Converter::stringToV8(prefix));
+
+    proxy->SetHiddenValue(v8::String::NewSymbol("dartProxy"), v8::Boolean::New(true));
+    return proxy;
+}
+
+v8::Handle<v8::Value> DartHandleProxy::createLocalScopeProxy(Dart_Handle localVariables)
+{
+    v8::Local<v8::Object> proxy = frameProxyTemplate()->InstanceTemplate()->NewInstance();
+    setDartHandleInternalField(proxy, localVariables);
+    proxy->SetHiddenValue(v8::String::NewSymbol("dartProxy"), v8::Boolean::New(true));
+    return proxy;
+}
+
+}