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

Source/bindings/dart/DartController.cpp

 // Copyright (c) 2009, 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 23 matching lines @@
 #include "DartWindow.h"
 #include "HTMLNames.h"
 #include "V8Navigator.h"
 #include "bindings/dart/DartApplicationLoader.h"
 #include "bindings/dart/DartDOMData.h"
 #include "bindings/dart/DartDOMWrapper.h"
 #include "bindings/dart/DartDebugServer.h"
 #include "bindings/dart/DartGCController.h"
 #include "bindings/dart/DartIsolateDestructionObserver.h"
 #include "bindings/dart/DartNativeUtilities.h"
+#include "bindings/dart/DartScriptState.h"
 #include "bindings/dart/DartTimeline.h"
 #include "bindings/dart/DartUtilities.h"
 #include "bindings/dart/ThreadSafeDartIsolateWrapper.h"
 #include "bindings/v8/ScheduledAction.h"
 #include "bindings/v8/ScriptController.h"
 #include "bindings/v8/npruntime_impl.h"
 #include "core/dom/Document.h"
 #include "core/dom/MutationObserver.h"
 #include "core/dom/NodeList.h"
 #include "core/dom/ScriptExecutionContext.h"
 #include "core/dom/ScriptLoader.h"
 #include "core/html/HTMLScriptElement.h"
 #include "core/page/DOMTimer.h"
 #include "core/page/DOMWindow.h"
 #include "core/page/Frame.h"
 #include "core/page/Page.h"
 #include "core/page/PageGroup.h"
 #include "core/page/Settings.h"
 #include "core/storage/StorageNamespace.h"
 #include "core/svg/SVGScriptElement.h"
 #include "modules/indexeddb/IDBPendingTransactionMonitor.h"
 
 #include <ctype.h>
 
+#include <dart_api.h>
+#include <dart_debugger_api.h>
+
 namespace WebCore {
 
 static void copyValue(Dart_Handle source, const char* fieldName,
     const char* targetLibrary, const char* targetClass, const char* targetField)
 {
     Dart_Handle value = Dart_GetField(source, Dart_NewStringFromCString(fieldName));
     ASSERT(!Dart_IsError(value));
 
     Dart_Handle library = Dart_LookupLibrary(Dart_NewStringFromCString(targetLibrary));
     ASSERT(!Dart_IsError(library));
@@ skipping 158 matching lines @@
 
     Dart_Isolate currentIsolate = Dart_CurrentIsolate();
     if (currentIsolate)
         Dart_ExitIsolate();
     for (size_t i = 0; i < m_isolates.size(); ++i)
         shutdownIsolate(m_isolates[i]);
     if (currentIsolate)
         Dart_EnterIsolate(currentIsolate);
 
     m_isolates.clear();
+
+    for (ScriptStatesMap::iterator it = m_scriptStates.begin(); it != m_scriptStates.end(); ++it) {
+        LibraryIdMap* libraryIdMap = it->value;
+        for (LibraryIdMap::iterator scriptStateIt = libraryIdMap->begin(); scriptStateIt != libraryIdMap->end(); ++scriptStateIt) {
+            delete scriptStateIt->value;
+        }
+        delete libraryIdMap;
+    }
+    m_scriptStates.clear();
 }
 
 static void cleanupAfterCall()
 {
     // FIXME: Instrument any work that takes place when script exits to c++ (e.g. Mutation Observers).
 
     IDBPendingTransactionMonitor::deactivateNewTransactions();
 
     MutationObserver::deliverAllMutations();
 }
@@ skipping 451 matching lines @@
 
 void DartController::loadScripts()
 {
     if (m_scriptsLoaded)
         return;
 
     Timeline timeline(frame(), "DC::loadScripts");
     initVMIfNeeded();
 
     Document* document = frame()->document();
-
     RefPtr<NodeList> scripts = document->getElementsByTagName("script");
     Vector< RefPtr<Node> > scriptsCopy(scripts->length());
     for (unsigned i = 0; i < scripts->length(); ++i)
         scriptsCopy[i] = scripts->item(i);
     for (unsigned i = 0; i < scriptsCopy.size(); ++i) {
         RefPtr<ScriptElementProxy> scriptElementProxy;
         if (document->isHTMLDocument())
             scriptElementProxy = HTMLScriptElementProxy::create(scriptsCopy[i].get());
         else if (document->isSVGDocument())
             scriptElementProxy = SVGScriptElementProxy::create(scriptsCopy[i].get());
@@ skipping 140 matching lines @@
     return frame->script()->scriptControllerDelegate();
 }
 
 DartController* DartController::retrieve(ScriptExecutionContext* context)
 {
     if (!context || !context->isDocument())
         return 0;
     return retrieve(static_cast<Document*>(context)->frame());
 }
 
+void DartController::collectScriptStates(ScriptState* v8ScriptState, Vector<ScriptState*>& result)
+{
+    v8::HandleScope handleScope;
+    v8::Handle<v8::Context> v8Context = v8ScriptState->context();
+
+    for (Vector<Dart_Isolate>::iterator it = m_isolates.begin(); it != m_isolates.end(); ++it)

[vsm, 2013/09/30 22:08:03]

This will become just a single isolate.  

Note: non-dom isolates don't make it into this vector even now AFAIK.  This is
probably a good thing.  I assume we have no way of breaking in them either?

[Jacob, 2013/10/01 00:07:05]

You may be able to break into non-DOM isolates at the moment.  DartDebugServer
looks like it has the plumbing to support it although it wouldn't surprise me if
things went horribly wrong.  I believe you can set breakpoints in workers and
evaluate code in worker contexts in the JS side of the world.

+        collectScriptStatesForIsolate(*it, v8Context, result);
 }
+
+void DartController::collectScriptStatesForIsolate(Dart_Isolate isolate, v8::Handle<v8::Context> v8Context, Vector<ScriptState*>& result)
+{
+    DartIsolateScope scope(isolate);
+    DartApiScope apiScope;
+    ScriptStatesMap::iterator it = m_scriptStates.find(isolate);
+    LibraryIdMap* libraryIdMap;
+    if (it == m_scriptStates.end()) {
+        libraryIdMap = new LibraryIdMap();
+        m_scriptStates.add(isolate, libraryIdMap);
+    } else {
+        libraryIdMap = it->value;
+    }
+    Dart_Handle libraryIdList = Dart_GetLibraryIds();
+
+    intptr_t length = 0;
+    Dart_Handle res = Dart_ListLength(libraryIdList, &length);
+
+    for (intptr_t i = 0; i < length; i++) {
+        Dart_Handle libraryIdHandle = Dart_ListGetAt(libraryIdList, i);
+        Dart_Handle exception = 0;
+        intptr_t libraryId = DartUtilities::toInteger(libraryIdHandle, exception);
+        ASSERT(!exception);
+        LibraryIdMap::iterator libraryIter = libraryIdMap->find(libraryId);
+        DartScriptState* scriptState;
+        if (libraryIter == libraryIdMap->end()) {
+            scriptState = new DartScriptState(isolate, libraryId, v8Context);
+            libraryIdMap->add(libraryId, scriptState);
+        } else {
+            scriptState = libraryIter->value;
+        }
+        result.append(scriptState);
+    }
+}
+
+}