Switch the DevTools to support a true Dart REPL

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 14 matching lines @@
  * 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 "bindings/dart/DartHandleProxy.h"
 
 #include "DartNode.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 "bindings/v8/V8ScriptRunner.h"
 #include "bindings/v8/V8ThrowException.h"
 
 #include "wtf/StdLibExtras.h"
 
-#include <dart_debugger_api.h>
-
 namespace WebCore {
 
 typedef HashMap<String, v8::Persistent<v8::FunctionTemplate>* > FunctionTemplateMap;
 
 static v8::Local<v8::FunctionTemplate> objectProxyTemplate(Dart_Handle instance);
 static v8::Local<v8::FunctionTemplate> functionProxyTemplate();
 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;
+DartScopes::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);
+}
 
-public:
-    Dart_Handle handle;
+DartScopes::~DartScopes()
+{
+    Dart_SetExceptionPauseInfo(previousPauseInfo);
+}
 
-    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)
+Dart_Handle DartHandleProxy::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;
 }
 
@@ skipping 226 matching lines @@
     bool isConstructor = false;
     Dart_FunctionIsConstructor(handle, &isConstructor);
     if (args.IsConstructCall() != isConstructor) {
         V8ThrowException::throwError(v8::String::New(
             isConstructor ? "Constructor called without new" : "Regular function called as constructor"));
         return;
     }
 
     Vector<Dart_Handle> dartFunctionArgs;
     for (uint32_t i = 0; i < args.Length(); ++i)
-        dartFunctionArgs.append(unwrapValue(args[i]));
+        dartFunctionArgs.append(DartHandleProxy::unwrapValue(args[i]));
 
     if (Dart_IsClosure(handle)) {
         setReturnValue(args, Dart_InvokeClosure(handle, dartFunctionArgs.size(), dartFunctionArgs.data()));
         return;
     }
     Dart_Handle type = Dart_FunctionOwner(handle);
     if (isConstructor) {
         // FIXME: this seems like an overly complex way to have to invoke a constructor.
         setReturnValue(args,
             Dart_New(type, stripClassName(Dart_FunctionName(handle), Dart_ClassName(type)),
@@ skipping 24 matching lines @@
 
     ASSERT(Dart_IsType(handle));
 
     if (!args.IsConstructCall()) {
         V8ThrowException::throwError(v8::String::New("Constructors can only be invoked with 'new'"));
         return;
     }
 
     Vector<Dart_Handle> dartFunctionArgs;
     for (uint32_t i = 0; i < args.Length(); ++i)
-        dartFunctionArgs.append(unwrapValue(args[i]));
+        dartFunctionArgs.append(DartHandleProxy::unwrapValue(args[i]));
 
     setReturnValue(args, 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)
 {
     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))
@@ skipping 101 matching lines @@
 // 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 void libraryNamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     DartScopes scopes(info.Holder());
     Dart_Handle handle = scopes.handle;
 
     Dart_Handle ret;
     ASSERT(Dart_IsLibrary(handle));
-    Dart_Handle dartValue = unwrapValue(value);
+    Dart_Handle dartValue = DartHandleProxy::unwrapValue(value);
     setReturnValue(info, Dart_SetField(handle, V8Converter::stringToDart(property), dartValue));
 }
 
 static void libraryQueryProperty(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info)
 {
     if (libraryNamedPropertyGetterHelper(name, info.Holder(), 0))
         v8SetReturnValueInt(info, 0);
 }
 
 void libraryEnumerateHelper(Dart_Handle library, intptr_t libraryId, v8::Local<v8::Array> properties, intptr_t* count)
@@ skipping 100 matching lines @@
     if (!Dart_IsNull(ret) && !Dart_IsError(ret))
         setReturnValue(info, ret);
 }
 
 static void typeNamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     DartScopes scopes(info.Holder());
     Dart_Handle handle = scopes.handle;
 
     ASSERT(Dart_IsType(handle));
-    Dart_Handle dartValue = unwrapValue(value);
+    Dart_Handle dartValue = DartHandleProxy::unwrapValue(value);
     setReturnValue(info, Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("set:"), property)), 1, &dartValue));
 }
 
 static void typeQueryProperty(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info)
 {
     DartScopes scopes(info.Holder());
     Dart_Handle handle = scopes.handle;
 
     Dart_Handle ret;
     ASSERT(Dart_IsType(handle));
@@ skipping 99 matching lines @@
         return;
     }
     v8SetReturnValue(info, DartHandleProxy::create(result));
 }
 
 static void namedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     DartScopes scopes(info.Holder());
     Dart_Handle handle = scopes.handle;
 
-    Dart_Handle dartValue = unwrapValue(value);
+    Dart_Handle dartValue = DartHandleProxy::unwrapValue(value);
     setReturnValue(info, Dart_Invoke(handle, V8Converter::stringToDart(v8::String::Concat(v8::String::New("set:"), property)), 1, &dartValue));
 }
 
 static void objectQueryProperty(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Integer>& info)
 {
     DartScopes scopes(info.Holder());
     Dart_Handle handle = scopes.handle;
 
     Dart_Handle ret;
     ASSERT(Dart_IsInstance(handle));
@@ skipping 75 matching lines @@
     setReturnValue(info, ret);
 }
 
 static void indexedSetter(uint32_t index, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
 {
     DartScopes scopes(info.Holder());
     Dart_Handle handle = scopes.handle;
 
     Dart_Handle ret = 0;
     if (Dart_IsList(handle))
-        ret = Dart_ListSetAt(handle, index, unwrapValue(value));
+        ret = Dart_ListSetAt(handle, index, DartHandleProxy::unwrapValue(value));
     else
         ret = Dart_Null();
 
     setReturnValue(info, ret);
 }
 
 static void indexedEnumerator(const v8::PropertyCallbackInfo<v8::Array>& info)
 {
     DartScopes scopes(info.Holder());
     Dart_Handle handle = scopes.handle;
@@ skipping 231 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;
 }
 
 }