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

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 26 matching lines @@
 #include "bindings/v8/PageScriptDebugServer.h"
 #include "bindings/v8/ScriptController.h"
 #include "bindings/v8/ScriptState.h"
 #include "bindings/v8/V8Binding.h"
 #include "core/dom/Document.h"
 #include "core/inspector/InspectorController.h"
 #include "core/inspector/InspectorDebuggerAgent.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/page/DOMWindow.h"
 #include "core/page/Page.h"
+#include "core/platform/Logging.h"
 
 #include <v8-debug.h>
 #include <wtf/HashMap.h>
 #include <wtf/Vector.h>
 
+
 namespace WebCore {
 
 class V8EventDetails : public v8::Debug::EventDetails {
  public:
   V8EventDetails(v8::DebugEvent event, v8::Handle<v8::Object> executionState, v8::Handle<v8::Object> eventData)
       : m_event(event)
       , m_executionState(executionState)
       , m_eventData(eventData)
   {
       Frame* frame = DartUtilities::domWindowForCurrentIsolate()->frame();
@@ skipping 121 matching lines @@
     isolateLoaded->Call(m_dartDebugObject.get(), 1, args);
 }
 
 void DartDebugServer::disable()
 {
     V8Scope v8Scope(v8::Debug::GetDebugContext());
     v8::Local<v8::Function> disable = v8::Local<v8::Function>::Cast(m_dartDebugObject.get()->Get(v8::String::New("disable")));
     disable->Call(m_dartDebugObject.get(), 0, 0);
 }
 
-v8::Handle<v8::Value> DartDebugServer::convertInspectedValue(Dart_Handle object)
-{
-    v8::Handle<v8::Function> wrapValue = v8::Handle<v8::Function>::Cast(shared().m_dartDebugObject.get()->Get(v8::String::New("wrapValue")));
-    v8::Handle<v8::Value> args[] = { DartHandleProxy::create(object) };
-    return wrapValue->Call(shared().m_dartDebugObject.get(), 1, args);
-}
-
 v8::Handle<v8::Object> DartDebugServer::createExecutionState(Dart_StackTrace trace)
 {
     intptr_t length = 0;
     Dart_Handle result = Dart_StackTraceLength(trace, &length);
     ASSERT(!Dart_IsError(result));
     UNUSED_PARAM(result);
     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 scriptURL = 0;
         intptr_t lineNumber = 0;
         intptr_t libraryId = 0;
+
         result = Dart_ActivationFrameInfo(frame, &functionName, &scriptURL, &lineNumber, &libraryId);
         ASSERT(!Dart_IsError(result));
+        Dart_Handle libraryURL = Dart_GetLibraryURL(libraryId);
+        ASSERT(!Dart_IsError(libraryURL));
+        Dart_Handle library = Dart_LookupLibrary(libraryURL);
 
         v8::Local<v8::Object> callFrame = v8::Object::New();
         callFrame->Set(v8::String::New("functionName"), V8Converter::stringToV8(functionName));
         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::createForLibrary(libraryId));
-        callFrame->Set(v8::String::New("localVariables"), convertInspectedValue(Dart_GetLocalVariables(frame)));
+        callFrame->Set(v8::String::New("libraryProxy"), DartHandleProxy::createLibraryProxy(library, libraryId, Dart_Null()));
+        callFrame->Set(v8::String::New("localScopeProxy"), DartHandleProxy::createLocalScopeProxy(
+            Dart_GetLocalVariables(frame)));
+        callFrame->Set(v8::String::New("isolateHandle"), v8::Number::New(isolateHandle));
         callFrames->Set(i, callFrame);
     }
 
     v8::Handle<v8::Function> executionStateConstructor = v8::Local<v8::Function>::Cast(m_dartDebugObject.get()->Get(v8::String::New("ExecutionState")));
     v8::Handle<v8::Value> args[] = { callFrames };
     return v8::Local<v8::Object>::Cast(executionStateConstructor->CallAsConstructor(1, args));
 }
 
 void DartDebugServer::breakpointHandler(Dart_IsolateId isolate_id, Dart_Breakpoint breakpoint, Dart_StackTrace trace)
 {
@@ skipping 11 matching lines @@
 void DartDebugServer::exceptionHandler(Dart_IsolateId isolate_id, Dart_Handle exception, Dart_StackTrace trace)
 {
     DartDebugServer::shared().handleException(exception, trace);
 }
 
 void DartDebugServer::handleException(Dart_Handle exception, Dart_StackTrace trace)
 {
     V8Scope v8Scope(v8::Debug::GetDebugContext());
     V8Scope v8WorldScope(DartUtilities::currentV8Context());
     v8::Handle<v8::Function> eventDataConstructor = v8::Local<v8::Function>::Cast(m_dartDebugObject.get()->Get(v8::String::New("EventData")));
-    v8::Handle<v8::Value> args[] = { convertInspectedValue(exception) };
+    v8::Handle<v8::Value> args[] = { DartHandleProxy::create(exception) };
     v8::Handle<v8::Object> eventData = v8::Local<v8::Object>::Cast(eventDataConstructor->CallAsConstructor(1, args));
     V8EventDetails eventDetails(v8::Exception, createExecutionState(trace), eventData);
     PageScriptDebugServer::shared().handleV8DebugEvent(eventDetails);
 }
 
 static v8::Handle<v8::Value> handleDebugEvent(const v8::Arguments& args)
 {
     v8::DebugEvent event = static_cast<v8::DebugEvent>(args[0]->Int32Value());
     v8::Local<v8::Object> executionState = v8::Local<v8::Object>::Cast(args[1]);
     v8::Local<v8::Object> eventData =  v8::Local<v8::Object>::Cast(args[2]);
@@ skipping 134 matching lines @@
 static v8::Handle<v8::Value> stepOut(const v8::Arguments& args)
 {
     Dart_SetStepOut();
     return v8::Undefined();
 }
 
 static v8::Handle<v8::Value> evaluateInScope(const v8::Arguments& args)
 {
     v8::Handle<v8::String> expression = args[0]->ToString();
     v8::Handle<v8::Object> receiver = args[1].As<v8::Object>();
-    v8::Handle<v8::Value> scopeObject = args[2];
+    v8::Handle<v8::Value> scopeObjectGlobal = args[2];
+    v8::Handle<v8::Value> scopeObjectLocal = args[3];
+    v8::Handle<v8::Value> scopes[] = { scopeObjectGlobal, scopeObjectLocal };
 
-    expression = v8::String::Concat(v8::String::New("(function(scopeObject) { with(scopeObject) { return "), expression);
+    expression = v8::String::Concat(v8::String::New(
+        "(function($$scopeObjectGlobal, $$scopeObjectLocal) { "
+        "var $$scopeObjectLocalThis = $$scopeObjectLocal.this;"
+        "with ($$scopeObjectGlobal) with ($$scopeObjectLocalThis || {}) with($$scopeObjectLocal) { "
+        "return "),
+        expression);
     expression = v8::String::Concat(expression, v8::String::New("} })"));
 
     v8::Handle<v8::Script> script = v8::Script::Compile(expression);
     if (script.IsEmpty()) // Return immediately in case of exception to let the caller handle it.
         return v8::Handle<v8::Value>();
+    v8::Debug::GetDebugContext()->Enter();
+
     v8::Handle<v8::Function> function = script->Run().As<v8::Function>();
-    return function->Call(receiver, 1, &scopeObject);
-}
-
-static v8::Handle<v8::Value> accessorGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info)
-{
-    v8::Handle<v8::Value> getter = info.Data()->ToObject()->Get(v8::String::New("getter"));
-    return v8::Handle<v8::Function>::Cast(getter)->Call(v8::Object::New(), 0, 0);
-}
-
-static void accessorSetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
-{
-    v8::Handle<v8::Value> setter = info.Data()->ToObject()->Get(v8::String::New("setter"));
-    if (!setter->IsUndefined())
-        v8::Handle<v8::Function>::Cast(setter)->Call(v8::Object::New(), 1, &value);
-}
-
-static v8::Handle<v8::Value> setAccessor(const v8::Arguments& args)
-{
-    v8::Handle<v8::Object> descriptor = v8::Object::New();
-    descriptor->Set(v8::String::New("getter"), args[2]);
-    descriptor->Set(v8::String::New("setter"), args[3]);
-    args[0]->ToObject()->SetAccessor(args[1]->ToString(), accessorGetter, accessorSetter, descriptor);
-    return v8::Undefined();
-}
-
-static v8::Handle<v8::Value> indexedGetter(uint32_t index, const v8::AccessorInfo& info)
-{
-    v8::Handle<v8::Function> getter = v8::Handle<v8::Function>::Cast(info.Holder()->GetHiddenValue(v8::String::New("getter")));
-    v8::Handle<v8::Value> args[] = { v8::Integer::New(index) };
-    return getter->Call(info.Holder(), 1, args);
-}
-
-static v8::Handle<v8::Value> indexedSetter(uint32_t index, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
-{
-    v8::Handle<v8::Function> setter = v8::Handle<v8::Function>::Cast(info.Holder()->GetHiddenValue(v8::String::New("setter")));
-    v8::Handle<v8::Value> args[] = { v8::Integer::New(index), value };
-    return setter->Call(info.Holder(), 2, args);
-}
-
-static v8::Handle<v8::Array> indexedEnumerator(const v8::AccessorInfo& info)
-{
-    v8::Handle<v8::Function> enumerator = v8::Handle<v8::Function>::Cast(info.Holder()->GetHiddenValue(v8::String::New("enumerator")));
-    return enumerator->Call(info.Holder(), 0, 0).As<v8::Array>();
-}
-
-static v8::Handle<v8::Value> createArrayWithIndexedPropertyHandler(const v8::Arguments& args)
-{
-    static v8::Persistent<v8::FunctionTemplate> arrayTemplate;
-    if (arrayTemplate.IsEmpty()) {
-        arrayTemplate = v8::Persistent<v8::FunctionTemplate>::New(args.GetIsolate(), v8::FunctionTemplate::New());
-        v8::Local<v8::ObjectTemplate> instanceTemplate = arrayTemplate->InstanceTemplate();
-        instanceTemplate->SetIndexedPropertyHandler(&indexedGetter, &indexedSetter, 0, 0, &indexedEnumerator);
-    }
-
-    v8::Local<v8::Object> array = arrayTemplate->InstanceTemplate()->NewInstance();
-    v8::Handle<v8::Value> arrayConstructor = v8::Context::GetCurrent()->Global()->Get(v8::String::New("Array"));
-    v8::Handle<v8::Value> arrayPrototype = arrayConstructor.As<v8::Object>()->Get(v8::String::New("prototype"));
-    array->Set(v8::String::New("__proto__"), arrayPrototype);
-    array->SetHiddenValue(v8::String::New("getter"), args[0]);
-    array->SetHiddenValue(v8::String::New("setter"), args[1]);
-    array->SetHiddenValue(v8::String::New("enumerator"), args[2]);
-    return array;
-}
-
-static v8::Handle<v8::Value> setHiddenValue(const v8::Arguments& args)
-{
-    return v8::Boolean::New(args[0]->ToObject()->SetHiddenValue(args[1]->ToString(), args[2]));
-}
-
-static v8::Handle<v8::Value> getHiddenValue(const v8::Arguments& args)
-{
-    return args[0]->ToObject()->GetHiddenValue(args[1]->ToString());
+    v8::Debug::GetDebugContext()->Exit();
+    Dart_ExceptionPauseInfo 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 an evaluate statement to
+    // avoid crashing debug dartium builds.
+    Dart_SetExceptionPauseInfo(kNoPauseOnExceptions);
+    v8::Handle<v8::Value> ret = function->Call(receiver, 2, scopes);
+    Dart_SetExceptionPauseInfo(previousPauseInfo);
+    return ret;
 }
 
 void DartDebugServer::ensureHooksInstalled()
 {
     DEFINE_STATIC_LOCAL(bool, hooksInstalled, (false));
 
     if (hooksInstalled)
         return;
 
     hooksInstalled = true;
 
     v8::HandleScope scope;
     V8Scope v8Scope(v8::Debug::GetDebugContext());
-
     String dartDebugHooksSource(reinterpret_cast<const char*>(DartDebugHooksSource_js), sizeof(DartDebugHooksSource_js));
 
     v8::Isolate* v8Isolate = v8::Isolate::GetCurrent();
     m_dartDebugObject.set(v8Isolate, v8::Local<v8::Object>::Cast(v8::Script::Compile(v8String(dartDebugHooksSource, v8Isolate))->Run()));
 
+    // We must set the v8 context to the page's context before invoking Dart
+    // code because of security checks in the console.log implementation
+    // (see InjectedScriptManager::canAccessInspectedWindow).
+    DartUtilities::currentV8Context()->Enter();
+    v8::Local<v8::Object> evaluateInScopeFunction = v8::FunctionTemplate::New(&evaluateInScope)->GetFunction();
+    DartUtilities::currentV8Context()->Exit();
+
     v8::Local<v8::Object> nativeCallbacks = v8::Object::New();
     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"), v8::FunctionTemplate::New(&evaluateInScope)->GetFunction());
-    nativeCallbacks->Set(v8::String::New("createArrayWithIndexedPropertyHandler"), v8::FunctionTemplate::New(&createArrayWithIndexedPropertyHandler)->GetFunction());
-    nativeCallbacks->Set(v8::String::New("setAccessor"), v8::FunctionTemplate::New(&setAccessor)->GetFunction());
-    nativeCallbacks->Set(v8::String::New("setHiddenValue"), v8::FunctionTemplate::New(&setHiddenValue)->GetFunction());
-    nativeCallbacks->Set(v8::String::New("getHiddenValue"), v8::FunctionTemplate::New(&getHiddenValue)->GetFunction());
-    {
-        // 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);
-    }
+    nativeCallbacks->Set(v8::String::New("evaluateInScope"), evaluateInScopeFunction);
     m_dartDebugObject.get()->Set(v8::String::New("nativeCallbacks"), nativeCallbacks);
-
-    v8::Local<v8::Object> mirrorAPI = v8::Object::New();
-    DartHandleProxy::getMirrorAPI(mirrorAPI);
-    m_dartDebugObject.get()->Set(v8::String::New("mirrorAPI"), mirrorAPI);
-
 }
 
 }