Model each Dart library as its own ScriptState when devtools are enabled.

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 165 matching lines @@
 {
     Page* page = DartUtilities::domWindowForCurrentIsolate()->document()->page();
     if (!page || !instrumentationForPage(page)->inspectorDebuggerAgent())
         return;
 
     V8Scope v8Scope(v8::Debug::GetDebugContext());
 
     ASSERT(Dart_CurrentIsolate());
     int isolateHandle = isolateMap().getByValue(Dart_CurrentIsolate());
 
+    ScriptState* scriptState = ScriptState::current();
+    Frame* frame = DartUtilities::domWindowForCurrentIsolate()->frame();
+    DartController* controller = DartController::retrieve(frame);
+    Vector<ScriptState*> scriptStates;
+    controller->collectScriptStatesForIsolate(Dart_CurrentIsolate(), DartUtilities::currentV8Context(), scriptStates);
+    for (size_t i = 0; i< scriptStates.size(); i++)
+        InspectorInstrumentation::didCreateIsolatedContext(frame, scriptStates[i], 0);
+
     ASSERT(!m_dartDebugObject.isEmpty());
     v8::Local<v8::Function> isolateLoaded = v8::Local<v8::Function>::Cast(dartDebugObject()->Get(v8::String::New("isolateLoaded")));
     v8::Handle<v8::Value> args[] = { v8::Number::New(isolateHandle) };
     isolateLoaded->Call(dartDebugObject(), 1, args);
 }
 
 void DartDebugServer::disable()
 {
     V8Scope v8Scope(v8::Debug::GetDebugContext());
     // Only invoke the disable method when Dart code was executed on the page.
@@ skipping 251 matching lines @@
 {
     Dart_SetStepOut();
 }
 
 static void evaluateInScope(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Handle<v8::String> expression = args[0]->ToString();
     v8::Handle<v8::Value> receiver = args[1];
     v8::Handle<v8::Object> functionProxy = args[2].As<v8::Object>();
     v8::Handle<v8::Value> localVariablesProxy = args[3];
+    bool disableBreak = args[4]->BooleanValue();
 
-    DartScopes scopes(functionProxy);
+    DartScopes scopes(functionProxy, disableBreak);
     Dart_Handle target = 0;
     if (receiver->IsNull() || receiver->IsUndefined()) {
         Dart_Handle functionHandle = scopes.handle;
         ASSERT(Dart_IsFunction(functionHandle));
         target = Dart_FunctionOwner(functionHandle);
     } else {
         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);
 
-    Dart_Handle wrapExpressionArgs[2] = { V8Converter::stringToDart(expression), localVariables };
-
-    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 expression arguments specified by
-        // wrappedExpressionTuple.
-        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));
-        }
-    }
+    v8SetReturnValue(args, DartHandleProxy::evaluate(target, V8Converter::stringToDart(expression), localVariables));
 }
 
 void DartDebugServer::ensureHooksInstalled()
 {
     DEFINE_STATIC_LOCAL(bool, hooksInstalled, (false));
 
     if (hooksInstalled)
         return;
 
     hooksInstalled = true;
@@ skipping 34 matching lines @@
     }
     dartDebugObject()->Set(v8::String::New("nativeCallbacks"), nativeCallbacks);
 }
 
 v8::Local<v8::Object> DartDebugServer::dartDebugObject()
 {
     return m_dartDebugObject.newLocal(v8::Isolate::GetCurrent());
 }
 
 }