Reapply "Move isolate loading to a separate loader isolate."

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 17 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "config.h"
 #include "bindings/dart/DartController.h"
 
 #include "DartDocument.h"
 #include "DartWindow.h"
 #include "HTMLNames.h"
 #include "V8Navigator.h"
 #include "bindings/dart/DartApplicationLoader.h"
+#include "bindings/dart/DartAsyncLoader.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"
@@ skipping 262 matching lines @@
     destinationContext->postTask(adoptPtr(new MessageNotifyTask(domData->threadSafeIsolateWrapper())));
 }
 
 class SpawnUriErrorEventDispatcher : public DartApplicationLoader::ErrorEventDispatcher {
 public:
     // TODO(antonm): this is used to dispatch DOM error event. Most probably we need
     // nothing like that for spawnDomUri, but need to double check.
     void dispatchErrorEvent() { }
 };
 
-class ApplicationLoadedCallback : public VoidCallback {
+class DartSpawnLoadCallback : public DartAsyncLoader::LoadCallback {
 public:
-    ApplicationLoadedCallback(Dart_Isolate isolate, PassRefPtr<Document> document) : m_isolate(isolate), m_document(document) { }
+    DartSpawnLoadCallback(Dart_Isolate isolate, const String& url, Document* originDocument)
+        : LoadCallback(originDocument)
+        , m_isolate(isolate)
+        , m_url(url)
+    {
+    }
 
-    bool handleEvent()
+    void ready(PassRefPtr<DartAsyncLoader> loader)
     {
-        ASSERT(isMainThread());
-        ASSERT(Dart_CurrentIsolate() == m_isolate);
+        RefPtr<DartAsyncLoader> asyncLoader = loader;
+        RefPtr<SpawnUriErrorEventDispatcher> errorEventDispatcher = adoptRef(new SpawnUriErrorEventDispatcher());
 
-        Dart_ExitIsolate();
+        RefPtr<DartApplicationLoader> applicationLoader = adoptRef(new DartApplicationLoader(m_isolate, document(), errorEventDispatcher, asyncLoader, false));
+
+        applicationLoader->load(asyncLoader->scriptUrl(), asyncLoader->scriptSource(), asyncLoader->scriptLineNumber());
         Dart_IsolateMakeRunnable(m_isolate);
-        Dart_EnterIsolate(m_isolate);
-
-        return true;
     }
 
 private:
     Dart_Isolate m_isolate;
-    RefPtr<Document> m_document;
-};
-
-class LoadIsolateSourcesTask : public ScriptExecutionContext::Task {
-public:
-    LoadIsolateSourcesTask(const char* url, Dart_Isolate isolate, Document* document)
-        : m_url(strdup(url)), m_isolate(isolate), m_document(document)
-    { }
-
-    ~LoadIsolateSourcesTask()
-    {
-        free(m_url);
-    }
-
-    virtual void performTask(ScriptExecutionContext* context)
-    {
-        ASSERT(isMainThread());
-
-        RefPtr<SpawnUriErrorEventDispatcher> errorEventDispatcher = adoptRef(new SpawnUriErrorEventDispatcher());
-        RefPtr<VoidCallback> applicationLoadedCallback = adoptRef(new ApplicationLoadedCallback(m_isolate, m_document));
-        RefPtr<DartApplicationLoader> applicationLoader = adoptRef(new DartApplicationLoader(m_isolate, m_document, errorEventDispatcher, applicationLoadedCallback, false));
-        applicationLoader->loadScriptResource(m_url);
-    }
-
-private:
-    char* const m_url;
-    const Dart_Isolate m_isolate;
-    Document* m_document;
+    String m_url;
 };
 
 Dart_Isolate DartController::createPureIsolateCallback(const char* scriptURL, const char* entryPoint, void* data, char** errorMsg)
 {
-    bool needApplicationLoader = false;
+    bool needAsyncLoader = false;
 
     {
         DartApiScope apiScope;
         // Hacky way to find out if it's spawnFunction or spawnUri.
         Dart_Handle parentIsolateRootLibrary = Dart_RootLibrary();
         if (Dart_IsError(parentIsolateRootLibrary)) {
             *errorMsg = strdup(Dart_GetError(parentIsolateRootLibrary));
             return 0;
         }
         Dart_Handle parentIsolateURLHandle = Dart_LibraryUrl(parentIsolateRootLibrary);
         if (Dart_IsError(parentIsolateURLHandle)) {
             *errorMsg = strdup(Dart_GetError(parentIsolateURLHandle));
             return 0;
         }
         const char * parentIsolateURL = 0;
         Dart_Handle result = Dart_StringToCString(parentIsolateURLHandle, &parentIsolateURL);
         if (Dart_IsError(result)) {
             *errorMsg = strdup(Dart_GetError(result));
             return 0;
         }
 
-        needApplicationLoader = strcmp(scriptURL, parentIsolateURL);
+        needAsyncLoader = strcmp(scriptURL, parentIsolateURL);
     }
 
     DartDOMData* parentDOMData = static_cast<DartDOMData*>(data);
     ScriptExecutionContext* context = parentDOMData->scriptExecutionContext();
     ASSERT(context->isDocument());
     Document* document = static_cast<Document*>(context);
 
     Dart_Isolate isolate = createIsolate(scriptURL, entryPoint, document, false, errorMsg);
     if (!isolate)
         return 0;
 
-    if (needApplicationLoader) {
-        context->postTask(adoptPtr(new LoadIsolateSourcesTask(scriptURL, isolate, document)));
+    if (needAsyncLoader) {
+        // We need to request the sources asynchronously.
+        RefPtr<DartSpawnLoadCallback> callback = adoptRef(new DartSpawnLoadCallback(isolate, scriptURL, document));
+        // A DartAsyncLoader will delete itself once all resources are fetched.
+        DartAsyncLoader* asyncLoader = new DartAsyncLoader(scriptURL, callback);
+        asyncLoader->fetchScriptResource(scriptURL);
         Dart_ExitIsolate();
     } else {
         // FIXME: avoid copying parent snapshot.
         ASSERT(DartDOMData::current()->applicationSnapshot()->isEmpty());
         DartDOMData::current()->applicationSnapshot()->append(*parentDOMData->applicationSnapshot());
 
         {
             DartApiScope apiScope;
 
             // Initialize child isolate using the parent's snapshot.
@@ skipping 133 matching lines @@
 {
     DEFINE_STATIC_LOCAL(HashSet<String>, types, ());
     if (types.isEmpty()) {
         types.add("application/dart");
         types.add("application/dart-app");
         types.add("application/dart-script");
     }
     return !mimeType.isEmpty() && types.contains(mimeType);
 }
 
-
 class DartScriptRunner : public EventListener {
 public:
     static PassRefPtr<DartScriptRunner> create()
     {
         return adoptRef(new DartScriptRunner());
     }
 
     virtual void handleEvent(ScriptExecutionContext* context, Event*)
     {
         ASSERT(context->isDocument());
@@ skipping 82 matching lines @@
     virtual void dispatchErrorEvent()
     {
         m_scriptElement->dispatchErrorEvent();
     }
 
     WTF::OrdinalNumber startLineNumber()
     {
         return m_scriptElement->startLineNumber();
     }
 
+    ScriptLoader* loader()
+    {
+        return m_scriptElement;
+    }
+
     virtual ~ScriptElementProxy() { }
 
 protected:
     ScriptElementProxy(ScriptLoader* scriptElement)
         : m_scriptElement(scriptElement)
     {
     }
 
     ScriptLoader* m_scriptElement;
 };
@@ skipping 49 matching lines @@
         : ScriptElementProxy(scriptElement)
     {
     }
 
     SVGScriptElement* asSVGScriptElement() const
     {
         return static_cast<SVGScriptElement*>(m_scriptElement->element());
     }
 };
 
+class DartDomLoadCallback : public DartAsyncLoader::LoadCallback {
+public:
+    DartDomLoadCallback(DartController* controller, const String& url, Document* originDocument, PassRefPtr<ScriptElementProxy> proxy)
+        : LoadCallback(originDocument, proxy->loader())
+        , m_controller(controller)
+        , m_url(url)
+        , m_proxy(proxy)
+    {
+    }
+
+    void ready(PassRefPtr<DartAsyncLoader> asyncLoader)
+    {
+        m_controller->loadAndRunScript(m_url, asyncLoader, m_proxy);
+    }
+
+private:
+    DartController* m_controller;
+    String m_url;
+    RefPtr<ScriptElementProxy> m_proxy;
+};
+
+void DartController::loadAndRunScript(const String& url, PassRefPtr<DartAsyncLoader> loader, PassRefPtr<ScriptElementProxy> proxy)
+{
+    RefPtr<DartAsyncLoader> asyncLoader = loader;
+    Document* document = frame()->document();
+
+    createDOMEnabledIsolate(url, "main", document);
+
+    // FIXME: it may make sense to ensure that we'll never call evaluate more than once for the same script tag.
+    RefPtr<DartApplicationLoader> applicationLoader = adoptRef(new DartApplicationLoader(Dart_CurrentIsolate(), document, proxy, asyncLoader));
+    applicationLoader->load(asyncLoader->scriptUrl(), asyncLoader->scriptSource(), asyncLoader->scriptLineNumber());
+
+    Dart_ExitIsolate();
+}
+
+
 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());
         ASSERT(scriptElementProxy);
 
         String typeAttr = scriptElementProxy->typeAttributeValue();
         if (!isDartMimeType(typeAttr.stripWhiteSpace().lower()))
             continue;
 
         String scriptURL = scriptElementProxy->sourceAttributeValue();
-        createDOMEnabledIsolate(scriptURL, "main", document);
+        String url = scriptURL.isEmpty() ? document->url() : scriptURL;
 
-        // FIXME: it may make sense to ensure that we'll never call evaluate more than once for the same script tag.
-        RefPtr<DartApplicationLoader> applicationLoader = adoptRef(new DartApplicationLoader(Dart_CurrentIsolate(), document, scriptElementProxy));
+        RefPtr<DartDomLoadCallback> callback = adoptRef(new DartDomLoadCallback(this, url, document, scriptElementProxy));
+
+        // A DartAsyncLoader will delete itself once all resources are fetched.
+        DartAsyncLoader* asyncLoader = new DartAsyncLoader(url, callback);
+        WTF::OrdinalNumber startLineNumber = scriptElementProxy->startLineNumber();
+        intptr_t lineOffset = startLineNumber == OrdinalNumber::beforeFirst() ? 0 : startLineNumber.zeroBasedInt();
         if (scriptURL.isEmpty())
-            applicationLoader->load(m_frame->document()->url(), scriptElementProxy->scriptContent(), scriptElementProxy->startLineNumber());
+            asyncLoader->process(m_frame->document()->url(), scriptElementProxy->scriptContent(), lineOffset);
         else
-            applicationLoader->loadScriptResource(scriptURL);
-
-        Dart_ExitIsolate();
+            asyncLoader->fetchScriptResource(scriptURL);
     }
 
     m_scriptsLoaded = true;
 }
 
 void DartController::bindToWindowObject(Frame* frame, const String& key, NPObject* object)
 {
     // FIXME: proper management of lifetime.
     m_npObjectMap.set(key, object);
 }
@@ skipping 127 matching lines @@
             scriptState = new DartScriptState(isolate, libraryId, v8Context);
             libraryIdMap->add(libraryId, scriptState);
         } else {
             scriptState = libraryIter->value;
         }
         result.append(scriptState);
     }
 }
 
 }