Fix crashing bugs when dart code executed inside the debugger triggers breakpoints

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 41 matching lines @@
 static v8::Local<v8::FunctionTemplate> libraryProxyTemplate();
 static v8::Local<v8::FunctionTemplate> typeProxyTemplate(Dart_Handle type);
 static v8::Local<v8::FunctionTemplate> frameProxyTemplate();
 
 DartScriptValue* readPointerFromProxy(v8::Handle<v8::Value> proxy)
 {
     void* pointer = proxy.As<v8::Object>()->GetAlignedPointerFromInternalField(0);
     return static_cast<DartScriptValue*>(pointer);
 }
 
+/**
+ * Helper class to manage all scopes that must be entered to safely invoke Dart
+ * code.
+ */
+class DartScopes {
+private:
+    DartScriptValue* scriptValue;
+    DartIsolateScope scope;
+    DartApiScope apiScope;
+    Dart_ExceptionPauseInfo previousPauseInfo;
+
+public:
+    Dart_Handle handle;
+
+    DartScopes(v8::Local<v8::Object> v8Handle) :
+        scriptValue(readPointerFromProxy(v8Handle)),
+        scope(scriptValue->isolate())
+    {
+        ASSERT(scriptValue->isIsolateAlive());
+        handle = Dart_HandleFromPersistent(scriptValue->value());
+        previousPauseInfo = Dart_GetExceptionPauseInfo();
+        // FIXME: it is not clear this is the right long term solution but for
+        // now we prevent pausing on exceptions when executing Dart code to
+        // avoid crashing when handling an exception triggers an exception.
+        Dart_SetExceptionPauseInfo(kNoPauseOnExceptions);
+    }
+
+    ~DartScopes()
+    {
+        Dart_SetExceptionPauseInfo(previousPauseInfo);
+    }
+};
+
 static void weakCallback(v8::Isolate* isolate, v8::Persistent<v8::Object>* proxy, DartScriptValue* value)
 {
     delete value;
     proxy->Dispose(isolate);
 }
 
 static Dart_Handle unwrapValue(v8::Handle<v8::Value> value)
 {
     if (DartHandleProxy::isDartProxy(value))
         return Dart_HandleFromPersistent(readPointerFromProxy(value)->value());
@@ skipping 56 matching lines @@
     Dart_Handle exception = 0;
     bool ret = DartUtilities::dartToBool(DartUtilities::invokeUtilsMethod("isNode", 1, &type), exception);
     ASSERT(!exception);
     if (!ret)
         return false;
     if (!DartNode::toNative(type, exception))
         return false;
     return true;
 }
 
+bool isNoSuchMethodError(Dart_Handle type)
+{
+    Dart_Handle exception = 0;
+    bool ret = DartUtilities::dartToBool(DartUtilities::invokeUtilsMethod("isNoSuchMethodError", 1, &type), exception);
+    ASSERT(!exception);
+    return ret;
+}
+
 Dart_Handle createLocalVariablesMap(Dart_Handle localVariablesList)
 {
     return DartUtilities::invokeUtilsMethod("createLocalVariablesMap", 1, &localVariablesList);
 }
 
 Dart_Handle getMapKeyList(Dart_Handle localVariablesMap)
 {
     return DartUtilities::invokeUtilsMethod("getMapKeyList", 1, &localVariablesMap);
 }
 
 bool mapContainsKey(Dart_Handle map, Dart_Handle key)
 {
     Dart_Handle exception = 0;
     return DartUtilities::dartToBool(Dart_Invoke(map, Dart_NewStringFromCString("containsKey"), 1, &key), exception);
 }
 
 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);
+
+        // FIXME: the DartVM doesn't correctly handle invoking properties with
+        // private names. For now, skip private function names.
+        intptr_t functionNameLength = 0;
+        uint8_t* functionNameData;
+        Dart_StringToUTF8(functionName, &functionNameData, &functionNameLength);
+        if (functionNameLength > 0 && functionNameData[0] == '_')
+            continue;
+
         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;
+
+            // Skip setters as any setter we care to enumerate should have a matching getter.
+            // Setters without matching getters will still be callable but won't be enumerated.
+            if (isSetter)
+                continue;
         }
 
         // Strip off the leading typename from constructor name.
         if (isConstructor)
             functionName = stripClassName(functionName, Dart_ClassName(handle));
 
         properties->Set(*count, V8Converter::stringToV8(functionName));
         *count = *count + 1;
     }
 }
@@ skipping 57 matching lines @@
 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.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     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);
     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());
+    DartScopes scopes(args.Holder());
+    Dart_Handle handle = scopes.handle;
 
     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 type = Dart_FunctionOwner(handle);
     if (isConstructor)
         // FIXME: this seems like an overly complex way to have to invoke a constructor.
         return convertResult(
             Dart_New(type, stripClassName(Dart_FunctionName(handle), Dart_ClassName(type)),
                 dartFunctionArgs.size(), dartFunctionArgs.data()));
     else
         return convertResult(
             Dart_Invoke(type, Dart_FunctionName(handle), dartFunctionArgs.size(), dartFunctionArgs.data()));
 }
 
 static v8::Handle<v8::Value> typeProxyConstructorInvocationCallback(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());
+    DartScopes scopes(args.Holder());
+    Dart_Handle handle = scopes.handle;
 
     ASSERT(Dart_IsType(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]));
 
@@ skipping 48 matching lines @@
     if (!Dart_IsNull(ret) && !Dart_IsError(ret)) {
         *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)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     Dart_Handle ret;
     ASSERT(Dart_IsLibrary(handle));
     intptr_t libraryId = getLibraryId(info.Holder());
     Dart_Handle dartName = V8Converter::stringToDart(name);
     Dart_Handle prefix = getLibraryPrefix(info.Holder());
     bool hasLibraryPrefix = !Dart_IsNull(prefix) && Dart_IsString(prefix);
 
     if (hasLibraryPrefix) {
         Vector<std::pair<Dart_Handle, intptr_t> > libraries;
@@ skipping 23 matching lines @@
     }
     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"))));
+    return v8::Undefined();
 }
 
 // FIXME: we need to handle prefixes when setting library properties as well
 // for completness. Postponing implementing this for now as we hope Dart_Invoke
 // can just be fixed to handle libraries 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.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     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 ? v8::Integer::New(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(Dart_GetLibraryFields(libraryId), properties, count);
 }
 
 static v8::Handle<v8::Array> libraryPropertyEnumerator(const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     intptr_t libraryId = getLibraryId(info.Holder());
     ASSERT(Dart_IsLibrary(handle));
     v8::Local<v8::Array> cachedProperties = info.Holder().As<v8::Object>()->GetHiddenValue(v8::String::NewSymbol("cache")).As<v8::Array>();
     if (*cachedProperties)
         return cachedProperties;
 
     Dart_Handle prefix = getLibraryPrefix(info.Holder());
     bool hasLibraryPrefix = Dart_IsString(prefix);
 
@@ skipping 29 matching lines @@
 
 bool isShowStatics(v8::Handle<v8::Value> value)
 {
     v8::Local<v8::Value> showStatics = value.As<v8::Object>()->GetHiddenValue(v8::String::NewSymbol("showStatics"));
     ASSERT(*showStatics && showStatics->IsBoolean());
     return showStatics->BooleanValue();
 }
 
 static v8::Handle<v8::Value> typeNamedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     Dart_Handle ret;
     ASSERT(Dart_IsType(handle));
 
     if (name->Equals(v8::String::NewSymbol("__proto__"))) {
         // Due to Dart semantics, if we are showing statics, we need to
         // not link types up to their superclasses as statics in superclasses
         // are not visible in subclasses.
         if (isShowStatics(info.Holder()))
             return v8::Null();
@@ skipping 11 matching lines @@
     ret = Dart_LookupFunction(handle, dartName);
     if (!Dart_IsNull(ret) && !Dart_IsError(ret))
         return convertResult(ret);
 
     Dart_Handle typeName = Dart_ClassName(handle);
     ASSERT(Dart_IsString(typeName));
     Dart_Handle constructorName = buildConstructorName(typeName, V8Converter::stringToDart(name));
     ret = Dart_LookupFunction(handle, constructorName);
     if (!Dart_IsNull(ret) && !Dart_IsError(ret))
         return convertResult(ret);
-
-    return v8::ThrowException(v8::Exception::ReferenceError(v8::String::Concat(name, v8::String::New(" is not defined"))));
+    return v8::Undefined();
 }
 
 static v8::Handle<v8::Value> typeNamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     Dart_Handle ret;
     ASSERT(Dart_IsType(handle));
     Dart_Handle dartValue = unwrapValue(value);
     ret = Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("set:"), property)), 1, &dartValue);
     return convertResult(ret);
 }
 
 static v8::Handle<v8::Integer> typeQueryProperty(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     Dart_Handle ret;
     ASSERT(Dart_IsType(handle));
     if (name->Equals(v8::String::NewSymbol("__proto__"))
         || typeHasMember(handle, V8Converter::stringToDart(name)))
         return v8::Integer::New(0, info.GetIsolate());
     return v8::Handle<v8::Integer>();
 }
 
 static v8::Handle<v8::Array> typePropertyEnumerator(const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
     bool showStatics = isShowStatics(info.Holder());
 
     ASSERT(Dart_IsType(handle));
 
     v8::Local<v8::Array> properties = v8::Array::New();
     intptr_t count = 0;
     addFunctionNames(handle, properties, &count, !showStatics, false);
     if (showStatics)
         addFieldNames(Dart_GetStaticFields(handle), properties, &count);
 
     return properties;
 }
 
 static v8::Handle<v8::Value> frameNamedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     Dart_Handle dartName = dartName;
     if (mapContainsKey(handle, V8Converter::stringToDart(name))) {
-        Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
         Dart_Handle indexedGetterOperator = Dart_NewStringFromCString("[]");
         Dart_Handle dartName = V8Converter::stringToDart(name);
         return convertResult(Dart_Invoke(handle, indexedGetterOperator, 1, &dartName));
     }
-    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"))));
+    return v8::Undefined();
 }
 
 static v8::Handle<v8::Value> frameNamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
 {
     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.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
 
-    return mapContainsKey(handle, V8Converter::stringToDart(name)) ? v8::Integer::New(0, info.GetIsolate()) : v8::Handle<v8::Integer>();
+    return mapContainsKey(scopes.handle, V8Converter::stringToDart(name)) ? v8::Integer::New(0, info.GetIsolate()) : v8::Handle<v8::Integer>();
 }
 
 static v8::Handle<v8::Array> framePropertyEnumerator(const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle keyList = getMapKeyList(Dart_HandleFromPersistent(scriptValue->value()));
+    DartScopes scopes(info.Holder());
+    Dart_Handle keyList = getMapKeyList(scopes.handle);
     ASSERT(!Dart_IsError(keyList));
     ASSERT(Dart_IsList(keyList));
 
     intptr_t length = 0;
     Dart_ListLength(keyList, &length);
     v8::Local<v8::Array> properties = v8::Array::New(length);
     for (intptr_t i = 0; i < length; i ++)
         properties->Set(i, V8Converter::stringToV8(Dart_ListGetAt(keyList, i)));
     return properties;
 }
 
 static v8::Handle<v8::Value> namedPropertyGetter(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     ASSERT(Dart_IsInstance(handle));
     if (name->Equals(v8::String::NewSymbol("__proto__")))
         return DartHandleProxy::createTypeProxy(Dart_InstanceGetType(handle), false);
 
     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)));
     }
     // Prefix for metadata used only by the Dart Editor debugger.
     if (data[0] == '@') {
         if (name->Equals(v8::String::New("@staticFields")))
             return DartHandleProxy::createTypeProxy(Dart_InstanceGetType(handle), true);
     }
 
-    return convertResult(Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("get:"), name)), 0, 0));
+    Dart_Handle result = Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("get:"), name)), 0, 0);
+    if (Dart_IsError(result)) {
+        // To match JS conventions, we should just return undefined if a
+        // property does not exist rather than throwing.
+        if (Dart_ErrorHasException(result) && isNoSuchMethodError(Dart_ErrorGetException(result)))
+            return v8::Undefined();
+
+        return v8::ThrowException(v8::String::New(Dart_GetError(result)));
+    }
+    return DartHandleProxy::create(result);
 }
 
 static v8::Handle<v8::Value> namedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     Dart_Handle dartValue = unwrapValue(value);
     return convertResult(Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("set:"), property)), 1, &dartValue));
 }
 
 static v8::Handle<v8::Integer> objectQueryProperty(v8::Local<v8::String> name, const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     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 v8::Integer::New(v8::ReadOnly, info.GetIsolate());
-    if (data[0] =='@')
+    if (data[0] == '@')
         return v8::Integer::New(v8::DontEnum, 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 v8::Integer::New(0, info.GetIsolate());
         return v8::Handle<v8::Integer>();
     }
     return v8::Integer::New(0, info.GetIsolate());
 }
 
 static v8::Handle<v8::Array> objectPropertyEnumerator(const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     ASSERT(Dart_IsInstance(handle));
 
     Dart_Handle typeHandle = Dart_InstanceGetType(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
@@ skipping 21 matching lines @@
         typeHandle = Dart_GetSupertype(typeHandle);
     }
 
     properties->Set(count, v8::String::New("@staticFields"));
     count++;
     return properties;
 }
 
 static v8::Handle<v8::Value> indexedGetter(uint32_t index, const v8::AccessorInfo& info)
 {
-    DartScriptValue* scriptValue = readPointerFromProxy(info.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     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.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     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.Holder());
-    ASSERT(scriptValue->isIsolateAlive());
-    DartIsolateScope scope(scriptValue->isolate());
-    DartApiScope apiScope;
-    Dart_Handle handle = Dart_HandleFromPersistent(scriptValue->value());
+    DartScopes scopes(info.Holder());
+    Dart_Handle handle = scopes.handle;
 
     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;
@@ skipping 221 matching lines @@
 {
     v8::Local<v8::Object> proxy = frameProxyTemplate()->InstanceTemplate()->NewInstance();
     Dart_Handle localScopeVariableMap = createLocalVariablesMap(localVariables);
     ASSERT(!Dart_IsError(localScopeVariableMap));
     setDartHandleInternalField(proxy, localScopeVariableMap);
     proxy->SetHiddenValue(v8::String::NewSymbol("dartProxy"), v8::Boolean::New(true));
     return proxy;
 }
 
 }