Switch the DevTools to support a true Dart REPL

Source/bindings/dart/DartDebugServer.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 197 matching lines @@
     ASSERT(length);
     ASSERT(Dart_CurrentIsolate());
     int isolateHandle = isolateMap().getByValue(Dart_CurrentIsolate());
 
     v8::Local<v8::Array> callFrames = v8::Array::New(length);
     for (int i = length - 1; i >=0; --i) {
         Dart_ActivationFrame frame = 0;
         result = Dart_GetActivationFrame(trace, i, &frame);
         ASSERT(!Dart_IsError(result));
         Dart_Handle functionName = 0;
+        Dart_Handle function = 0;
         Dart_Handle scriptURL = 0;
         intptr_t lineNumber = 0;
         intptr_t libraryId = 0;
 
-        result = Dart_ActivationFrameInfo(frame, &functionName, &scriptURL, &lineNumber, &libraryId);
+        result = Dart_ActivationFrameInfo(frame, &functionName, &function, &scriptURL, &lineNumber, &libraryId);
         ASSERT(!Dart_IsError(result));
         Dart_Handle libraryURL = Dart_GetLibraryURL(libraryId);
         ASSERT(!Dart_IsError(libraryURL));
         Dart_Handle library = Dart_LookupLibrary(libraryURL);
+        Dart_Handle localVariablesHandle = Dart_GetLocalVariables(frame);
 
         v8::Local<v8::Object> callFrame = v8::Object::New();
         callFrame->Set(v8::String::New("functionName"), V8Converter::stringToV8(functionName));
+        callFrame->Set(v8::String::New("functionProxy"), DartHandleProxy::create(function));
         callFrame->Set(v8::String::New("scriptURL"), V8Converter::stringToV8(scriptURL));
         callFrame->Set(v8::String::New("lineNumber"), v8::Number::New(lineNumber - 1));
         callFrame->Set(v8::String::New("libraryProxy"), DartHandleProxy::createLibraryProxy(library, libraryId, Dart_Null()));
         callFrame->Set(v8::String::New("localScopeProxy"), DartHandleProxy::createLocalScopeProxy(
-            Dart_GetLocalVariables(frame)));
+            localVariablesHandle));
+        callFrame->Set(v8::String::New("localVariables"), DartHandleProxy::create(localVariablesHandle));
         callFrame->Set(v8::String::New("isolateHandle"), v8::Number::New(isolateHandle));
         callFrames->Set(i, callFrame);
     }
 
     ASSERT(!m_dartDebugObject.isEmpty());
     v8::Handle<v8::Function> executionStateConstructor = v8::Local<v8::Function>::Cast(dartDebugObject()->Get(v8::String::New("ExecutionState")));
     v8::Handle<v8::Value> args[] = { callFrames };
     return v8::Local<v8::Object>::Cast(executionStateConstructor->CallAsConstructor(1, args));
 }
 
@@ skipping 154 matching lines @@
 }
 
 static void stepOut(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     Dart_SetStepOut();
 }
 
 static void evaluateInScope(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Handle<v8::String> expression = args[0]->ToString();
-    v8::Handle<v8::Object> receiver = args[1].As<v8::Object>();
-    v8::Handle<v8::Value> scopeObjectGlobal = args[2];
-    v8::Handle<v8::Value> scopeObjectLocal = args[3];
-    v8::Handle<v8::Value> scopes[] = { scopeObjectGlobal, scopeObjectLocal };
+    v8::Handle<v8::Value> receiver = args[1];
+    v8::Handle<v8::Object> functionProxy = args[2].As<v8::Object>();
+    v8::Handle<v8::Value> localVariablesProxy = args[3];
 
+    DartScopes scopes(functionProxy);
+    Dart_Handle target = 0;
     if (receiver->IsNull() || receiver->IsUndefined()) {
-        // There is no receiver which indicates we are in a static method
-        // scope in Dart. We should ignore the receiver for this case.
-        // Using null or undefined  as the receiver for a function triggers
-        // asserts in V8 while running in Debug mode if an exception occurs.
-        receiver = v8::Object::New();
-        expression = v8::String::Concat(v8::String::New(
-            "(function($$scopeObjectGlobal, $$scopeObjectLocal) { "
-            "with ($$scopeObjectGlobal) with($$scopeObjectLocal) { "
-            "return "),
-            expression);
-        expression = v8::String::Concat(expression, v8::String::New("} })"));
+        Dart_Handle functionHandle = scopes.handle;
+        ASSERT(Dart_IsFunction(functionHandle));
+        target = Dart_FunctionOwner(functionHandle);
     } else {
-        expression = v8::String::Concat(v8::String::New(
-            "(function($$scopeObjectGlobal, $$scopeObjectLocal) { "
-            "with ($$scopeObjectGlobal) with (this) with($$scopeObjectLocal) { "
-            "return "),
-            expression);
-        expression = v8::String::Concat(expression, v8::String::New("} })"));
+        target = DartHandleProxy::unwrapValue(receiver);
     }
+    ASSERT(!Dart_IsError(target));
+    Dart_Handle localVariables = DartHandleProxy::unwrapValue(localVariablesProxy);
+    ASSERT(Dart_IsList(localVariables));
+    intptr_t localVariablesLength = 0;
+    Dart_ListLength(localVariables, &localVariablesLength);
 
-    v8::TryCatch tryCatch;
-    v8::Handle<v8::Function> function = V8ScriptRunner::compileAndRunInternalScript(expression, args.GetIsolate()).As<v8::Function>();
+    Dart_Handle wrapExpressionArgs[2] = { V8Converter::stringToDart(expression), localVariables };
 
-    if (tryCatch.HasCaught()) {
-        v8SetReturnValue(args, tryCatch.ReThrow());
-        return;
+    Dart_Handle wrappedExpressionTuple =
+        DartUtilities::invokeUtilsMethod("wrapExpressionAsClosure", 2, wrapExpressionArgs);
+    ASSERT(Dart_IsList(wrappedExpressionTuple));
+    Dart_Handle wrappedExpression = Dart_ListGetAt(wrappedExpressionTuple, 0);
+    Dart_Handle wrappedExpressionArgs = Dart_ListGetAt(wrappedExpressionTuple, 1);
+
+    ASSERT(Dart_IsString(wrappedExpression));
+    Dart_Handle closure = Dart_EvaluateExpr(target, wrappedExpression);
+    if (Dart_IsError(closure)) {
+        // There was a parse error. FIXME: consider cleaning up the line
+        // numbers in the error message.
+        V8ThrowException::throwError(v8::String::New(Dart_GetError(closure)));
+    } else {
+        // Invoke the closure passing in the

[vsm, 2013/09/12 00:17:23]

Finish the comment.  :-)

[Jacob, 2013/09/17 21:44:43]

Done.

+        ASSERT(Dart_IsClosure(closure));
+        intptr_t length = 0;
+        Dart_ListLength(wrappedExpressionArgs, &length);
+        Vector<Dart_Handle> dartFunctionArgs;
+        for (uint32_t i = 0; i < length; i ++) {
+            dartFunctionArgs.append(Dart_ListGetAt(wrappedExpressionArgs, i));
+        }
+
+        Dart_Handle result = Dart_InvokeClosure(closure, dartFunctionArgs.size(), dartFunctionArgs.data());
+        if (Dart_IsError(result)) {
+            V8ThrowException::throwError(v8::String::New(Dart_GetError(result)));
+        } else {
+            v8SetReturnValue(args, DartHandleProxy::create(result));
+        }
     }
-
-    v8::Local<v8::Value> result = V8ScriptRunner::callFunction(
-        function, getScriptExecutionContext(),
-        receiver,
-        2, scopes);
-
-    if (tryCatch.HasCaught()) {
-        v8SetReturnValue(args, tryCatch.ReThrow());
-        return;
-    }
-    crashIfV8IsDead();
-    v8SetReturnValue(args, result);
 }
 
 void DartDebugServer::ensureHooksInstalled()
 {
     DEFINE_STATIC_LOCAL(bool, hooksInstalled, (false));
 
     if (hooksInstalled)
         return;
 
     hooksInstalled = true;
@@ skipping 16 matching lines @@
     nativeCallbacks->Set(v8::String::New("handleDebugEvent"), v8::FunctionTemplate::New(&handleDebugEvent)->GetFunction());
     nativeCallbacks->Set(v8::String::New("scriptsForIsolate"), v8::FunctionTemplate::New(&scriptsForIsolate)->GetFunction());
     nativeCallbacks->Set(v8::String::New("setBreakpoint"), v8::FunctionTemplate::New(&setBreakpoint)->GetFunction());
     nativeCallbacks->Set(v8::String::New("removeBreakpoint"), v8::FunctionTemplate::New(&removeBreakpoint)->GetFunction());
     nativeCallbacks->Set(v8::String::New("getBreakpointLine"), v8::FunctionTemplate::New(&getBreakpointLine)->GetFunction());
     nativeCallbacks->Set(v8::String::New("setExceptionPauseInfo"), v8::FunctionTemplate::New(&setExceptionPauseInfo)->GetFunction());
     nativeCallbacks->Set(v8::String::New("stepInto"), v8::FunctionTemplate::New(&stepInto)->GetFunction());
     nativeCallbacks->Set(v8::String::New("stepOver"), v8::FunctionTemplate::New(&stepOver)->GetFunction());
     nativeCallbacks->Set(v8::String::New("stepOut"), v8::FunctionTemplate::New(&stepOut)->GetFunction());
     nativeCallbacks->Set(v8::String::New("evaluateInScope"), evaluateInScopeFunction);
+    {
+        // Trampoline script is required to properly set calling context before
+        // invoking Dart code because of security checks in console.log
+        // implementation (see InjectedScriptManager::canAccessInspectedWindow).
+        V8Scope v8scope;
+        v8::Handle<v8::String> trampolineScript = v8::String::New("(function (func, args) { return func.apply(this, args); })");
+        v8::Local<v8::Function> trampoline = v8::Local<v8::Function>::Cast(v8::Script::Compile(trampolineScript)->Run());
+        nativeCallbacks->Set(v8::String::New("invocationTrampoline"), trampoline);
+    }
     dartDebugObject()->Set(v8::String::New("nativeCallbacks"), nativeCallbacks);
 }
 
 v8::Local<v8::Object> DartDebugServer::dartDebugObject()
 {
     return m_dartDebugObject.newLocal(v8::Isolate::GetCurrent());
 }
 
 }