Import Dart bindings as of Blink r188698. This merely copies the files over and does not attach any…

sky/engine/bindings-dart/core/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
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "config.h"
+#include "bindings/core/dart/DartController.h"
+
+#if OS(ANDROID)
+#include <sys/system_properties.h>
+#endif
+
+
+#include "core/HTMLNames.h"
+#include "bindings/common/ScheduledAction.h"
+#include "bindings/core/dart/DartApplicationLoader.h"
+#include "bindings/core/dart/DartDOMData.h"
+#include "bindings/core/dart/DartDOMWrapper.h"
+#include "bindings/core/dart/DartDocument.h"
+#include "bindings/core/dart/DartGCController.h"
+#include "bindings/core/dart/DartInspectorTimeline.h"
+#include "bindings/core/dart/DartIsolateDestructionObserver.h"
+#include "bindings/core/dart/DartJsInterop.h"
+#include "bindings/core/dart/DartNativeUtilities.h"
+#include "bindings/core/dart/DartScriptDebugServer.h"
+#include "bindings/core/dart/DartScriptState.h"
+#include "bindings/core/dart/DartService.h"
+#include "bindings/core/dart/DartUtilities.h"
+#include "bindings/core/dart/DartWindow.h"
+#include "bindings/core/dart/ThreadSafeDartIsolateWrapper.h"
+#include "bindings/core/v8/ScriptController.h"
+#include "bindings/core/v8/V8Binding.h"
+#include "core/dom/Document.h"
+#include "core/dom/ExecutionContext.h"
+#include "core/dom/ExecutionContextTask.h"
+#include "core/dom/MutationObserver.h"
+#include "core/dom/NodeList.h"
+#include "core/dom/ScriptLoader.h"
+#include "core/frame/DOMTimer.h"
+#include "core/frame/LocalDOMWindow.h"
+#include "core/frame/LocalFrame.h"
+#include "core/frame/Settings.h"
+#include "core/html/HTMLDocument.h"
+#include "core/html/HTMLLinkElement.h"
+#include "core/html/HTMLScriptElement.h"
+#include "core/page/Page.h"
+#include "core/storage/StorageNamespace.h"
+#include "core/svg/SVGScriptElement.h"
+#include "modules/indexeddb/IDBPendingTransactionMonitor.h"
+#include "public/platform/Platform.h"
+
+#include <ctype.h>
+
+#include <dart_api.h>
+#include <dart_debugger_api.h>
+
+namespace blink {
+
+static void copyValue(Dart_Handle source, const char* fieldName,
+    Dart_Handle targetLibrary, const char* targetClass, const char* targetField)
+{
+    Dart_Handle value = Dart_GetField(source, Dart_NewStringFromCString(fieldName));
+    ASSERT(!Dart_IsError(value));
+
+    Dart_Handle target = targetClass ? Dart_GetType(targetLibrary, Dart_NewStringFromCString(targetClass), 0, 0) : targetLibrary;
+    ASSERT(!Dart_IsError(target));
+
+    Dart_SetField(target, Dart_NewStringFromCString(targetField), value);
+}
+
+static void messageNotifyCallback(Dart_Isolate);
+
+extern Dart_NativeFunction blinkSnapshotResolver(Dart_Handle name, int argumentCount, bool* autoSetupScope);
+
+static void throwDomDisabled(Dart_NativeArguments)
+{
+    DartApiScope apiScope;
+    Dart_ThrowException(Dart_NewStringFromCString("DOM access is not enabled in this isolate"));
+}
+
+Dart_NativeFunction pureIsolateResolver(Dart_Handle name, int argumentCount, bool* autoSetupScope)
+{
+    return throwDomDisabled;
+}
+
+const uint8_t* pureIsolateSymbolizer(Dart_NativeFunction nf)
+{
+    return 0;
+}
+
+void DartController::weakCallback(void* isolateCallbackData, Dart_WeakPersistentHandle handle, void* peer)
+{
+    // This weak handle has no peer associated with it, it is used to temporarily make
+    // weak handles strong during GC.
+    ASSERT(!peer);
+    DartDOMData* domData = reinterpret_cast<DartDOMData*>(isolateCallbackData);
+    domData->setReachableWeakHandle(0);
+}
+
+Dart_Isolate DartController::createIsolate(const char* scriptURL, const char* entryPoint, Document* document, bool isDOMEnabled, bool isDebuggerEnabled, char** errorMessage)
+{
+    DART_START_TIMER();
+    const uint8_t* snapshot = DartUtilities::fullSnapshot(document->frame());
+    DartDOMData* domData = new DartDOMData(document, scriptURL, isDOMEnabled);
+    Dart_Isolate isolate = Dart_CreateIsolate(scriptURL, entryPoint, snapshot, domData, errorMessage);
+    if (!isolate) {
+        delete domData;
+        return 0;
+    }
+    DART_RECORD_TIMER("    createIsolate after Dart_CreateIsolate call");
+
+    DartApiScope apiScope;
+
+    domData->setThreadSafeIsolateWrapper(ThreadSafeDartIsolateWrapper::create());
+
+    Dart_Handle blink = Dart_LookupLibrary(Dart_NewStringFromCString("dart:_blink"));
+    ASSERT(!Dart_IsError(blink));
+    // FIXME: this should be blinkSnapshotResolver
+    Dart_SetNativeResolver(blink, isDOMEnabled ? domIsolateHtmlResolver : pureIsolateResolver, isDOMEnabled ? domIsolateHtmlSymbolizer : pureIsolateSymbolizer);
+    domData->setBlinkLibrary(Dart_NewPersistentHandle(blink));
+
+    // Fix the html library.
+    Dart_Handle html = Dart_LookupLibrary(Dart_NewStringFromCString("dart:html"));
+    ASSERT(!Dart_IsError(html));
+    domData->setHtmlLibrary(Dart_NewPersistentHandle(html));
+
+    Dart_Handle js = Dart_LookupLibrary(Dart_NewStringFromCString("dart:js"));
+    ASSERT(!Dart_IsError(js));
+    Dart_SetNativeResolver(js, isDOMEnabled ? JsInterop::resolver : pureIsolateResolver, 0);
+    domData->setJsLibrary(Dart_NewPersistentHandle(js));
+
+    Dart_Handle core = Dart_LookupLibrary(Dart_NewStringFromCString("dart:core"));
+    ASSERT(!Dart_IsError(core));
+
+    domData->setSvgLibrary(0);
+
+    Dart_Handle functionType = Dart_GetType(core, Dart_NewStringFromCString("Function"), 0, 0);
+    ASSERT(!Dart_IsError(functionType));
+    domData->setFunctionType(Dart_NewPersistentHandle(functionType));
+
+    domData->setCurrentException(Dart_NewPersistentHandle(Dart_Null()));
+
+    // Setup configuration closures
+    char forwardingProp[DartUtilities::PROP_VALUE_MAX_LEN];
+    int propLen = DartUtilities::getProp("DART_FORWARDING_PRINT",
+        forwardingProp, DartUtilities::PROP_VALUE_MAX_LEN);
+    bool forwardPrint = propLen > 0;
+    const char * const printClosure = forwardPrint ?
+        "_forwardingPrintClosure" :
+        (isDOMEnabled ?  "_printClosure" : "_pureIsolatePrintClosure");
+    Dart_Handle asyncLib = Dart_LookupLibrary(Dart_NewStringFromCString("dart:async"));
+    ASSERT(!Dart_IsError(asyncLib));
+    Dart_Handle internalLib = Dart_LookupLibrary(Dart_NewStringFromCString("dart:_internal"));
+    ASSERT(!Dart_IsError(internalLib));
+    copyValue(html, printClosure, internalLib, 0, "_printClosure");
+    copyValue(html, isDOMEnabled ? "_timerFactoryClosure" : "_pureIsolateTimerFactoryClosure", asyncLib, "_TimerFactory", "_factory");
+    if (isDOMEnabled) {
+        copyValue(html, "_scheduleImmediateClosure", asyncLib, "_ScheduleImmediate", "_closure");
+    } else {
+        // Use the VM implementation (from dart:isolate) for scheduleImmediate.
+        Dart_Handle isolateLibrary = Dart_LookupLibrary(Dart_NewStringFromCString("dart:isolate"));
+        ASSERT(!Dart_IsError(isolateLibrary));
+
+        Dart_Handle value = Dart_Invoke(isolateLibrary, Dart_NewStringFromCString("_getIsolateScheduleImmediateClosure"), 0, 0);
+        ASSERT(!Dart_IsError(value));
+
+        Dart_Handle target = Dart_GetType(asyncLib, Dart_NewStringFromCString("_ScheduleImmediate"), 0, 0);
+        ASSERT(!Dart_IsError(target));
+
+        Dart_SetField(target, Dart_NewStringFromCString("_closure"), value);
+    }
+    copyValue(html, isDOMEnabled ? "_uriBaseClosure" : "_pureIsolateUriBaseClosure", core, 0, "_uriBaseClosure");
+
+    if (isDOMEnabled) {
+        // We need a weak handle to an always reachable object in order to temporarily make
+        // weak handles strong during GC, see the corresponding logic in DartGCController.
+        // We use the always reachable boolean 'True' object for this.
+        domData->setReachableWeakHandle(Dart_NewWeakPersistentHandle(Dart_True(), 0, 0, DartController::weakCallback));
+        Dart_SetMessageNotifyCallback(&messageNotifyCallback);
+        Dart_SetGcCallbacks(&DartGCController::prologueCallback, &DartGCController::epilogueCallback);
+
+        if (isDebuggerEnabled) {
+            DART_RECORD_TIMER("    createIsolate before debug setup");
+            DartScriptDebugServer::shared().registerIsolate(isolate, document->page());
+            DART_RECORD_TIMER("    createIsolate after debug setup");
+        }
+    }
+    DART_RECORD_TIMER("    createIsolate done %.3f ms");
+
+    return isolate;
+}
+
+Dart_Isolate DartController::createDOMEnabledIsolate(const String& scriptURL, const String& entryPoint, Document* document)
+{
+    DART_START_TIMER();
+    ASSERT(!Dart_CurrentIsolate());
+
+    // FIXME: proper error reporting.
+    char* errorMessage = 0;
+    Dart_Isolate newIsolate = createIsolate(scriptURL.utf8().data(), entryPoint.utf8().data(), document, true, true, &errorMessage);
+    ASSERT(newIsolate);
+    m_isolates.append(newIsolate);
+    DART_RECORD_TIMER("  createDOMEnabledIsolate took");
+    return newIsolate;
+}
+
+void DartController::shutdownIsolate(Dart_Isolate isolate)
+{
+    DartDOMData* domData = DartDOMData::current();
+    ASSERT(domData->isDOMEnabled());
+    // If the following assert triggers, we have hit dartbug.com/14183
+    // FIXME: keep the isolate alive until the recursion level is 0.
+    ASSERT(!*(domData->recursion()));
+    DartScriptDebugServer::shared().unregisterIsolate(isolate, m_frame->page());
+    DartIsolateDestructionObservers* observers = domData->isolateDestructionObservers();
+    for (DartIsolateDestructionObservers::iterator it = observers->begin(); it != observers->end(); ++it)
+        (*it)->isolateDestroyed();
+    Dart_ShutdownIsolate();
+    delete domData;
+}
+
+DartController::DartController(LocalFrame* frame)
+    : m_frame(frame)
+    , m_npObjectMap()
+{
+    // The DartController's constructor must be called in the LocalFrame's
+    // constructor, so it can properly maintain the unit of related
+    // browsing contexts.
+}
+
+DartController::~DartController()
+{
+    clearWindowShell();
+}
+
+void DartController::clearWindowShell()
+{
+    DART_START_TIMER();
+    initVMIfNeeded();
+    DART_RECORD_TIMER("clearWindowShell::initVM took");
+    m_documentsWithDart.clear();
+    if (m_loader) {
+        m_loader = nullptr;
+    }
+
+    // Due to synchronous dispatch, we may be in an isolate corresponding to another frame.
+    // If so, exit here but re-enter before returning.
+    Dart_Isolate currentIsolate = Dart_CurrentIsolate();
+    if (currentIsolate)
+        Dart_ExitIsolate();
+
+    Vector<Dart_Isolate>::iterator iterator;
+    for (iterator = m_isolates.begin(); iterator != m_isolates.end(); ++iterator) {
+        Dart_Isolate isolate = *iterator;
+        Dart_EnterIsolate(isolate);
+        shutdownIsolate(isolate);
+    }
+    m_isolates.clear();
+
+    DartScriptDebugServer::shared().clearWindowShell(m_frame->page());
+
+    for (ScriptStatesMap::iterator it = m_scriptStates.begin(); it != m_scriptStates.end(); ++it) {
+        LibraryIdMap* libraryIdMap = it->value;
+        delete libraryIdMap;
+    }
+    m_scriptStates.clear();
+
+    // Restore previous isolate.
+    if (currentIsolate)
+        Dart_EnterIsolate(currentIsolate);
+}
+
+void DartController::clearScriptObjects()
+{
+    // FIXME(dartbug.com/18427): Clear plugin / NP objects.
+}
+
+class MessageNotifyTask : public ExecutionContextTask {
+public:
+    explicit MessageNotifyTask(PassRefPtr<ThreadSafeDartIsolateWrapper> destinationIsolate)
+        : m_destinationIsolate(destinationIsolate)
+    { }
+
+    virtual void performTask(ExecutionContext* context)
+    {
+        if (!m_destinationIsolate->isIsolateAlive())
+            return;
+
+        DartIsolateScope scope(m_destinationIsolate->isolate());
+        DartApiScope apiScope;
+
+        DartDOMData* domData = DartDOMData::current();
+        // FIXME(dartbug.com/20303): we cannot safely initialize a V8 scope
+        // for the observatory isolate as it is not associated with a fully
+        // initialized document.
+        if (domData->isObservatoryFakeDartDOMData()) {
+            Dart_Handle result = Dart_HandleMessage();
+            if (Dart_IsError(result))
+                DartUtilities::reportProblem(context, result);
+        } else {
+            V8Scope v8scope(domData);
+            Dart_Handle result = Dart_HandleMessage();
+            if (Dart_IsError(result))
+                DartUtilities::reportProblem(context, result);
+        }
+    }
+
+private:
+    RefPtr<ThreadSafeDartIsolateWrapper> m_destinationIsolate;
+};
+
+static void messageNotifyCallback(Dart_Isolate destinationIsolate)
+{
+    DartDOMData* domData = static_cast<DartDOMData*>(Dart_IsolateData(destinationIsolate));
+    ASSERT(domData->isDOMEnabled());
+    ExecutionContext* destinationContext = domData->scriptExecutionContext();
+    destinationContext->postTask(adoptPtr(new MessageNotifyTask(domData->threadSafeIsolateWrapper())));
+}
+
+class SpawnUriErrorEventDispatcher : public DartErrorEventDispatcher {
+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 DartSpawnUriCallback : public DartApplicationLoader::Callback {
+public:
+    DartSpawnUriCallback(Dart_Isolate isolate, PassRefPtr<DartApplicationLoader> loader, const String& url, Document* originDocument)
+        : Callback(originDocument)
+        , m_isolate(isolate)
+        , m_loader(loader)
+        , m_url(url)
+    {
+    }
+
+    ~DartSpawnUriCallback() { }
+
+    virtual void initialize() = 0;
+    virtual bool domEnabled() = 0;
+
+    void ready()
+    {
+        RefPtr<SpawnUriErrorEventDispatcher> errorEventDispatcher = adoptRef(new SpawnUriErrorEventDispatcher());
+
+        m_loader->load(errorEventDispatcher);
+        initialize();
+    }
+
+protected:
+    Dart_Isolate m_isolate;
+    RefPtr<DartApplicationLoader> m_loader;
+    String m_url;
+};
+
+class DartSpawnBackgroundUriCallback : public DartSpawnUriCallback {
+public:
+    DartSpawnBackgroundUriCallback(Dart_Isolate isolate, PassRefPtr<DartApplicationLoader> loader, const String& url, Document* originDocument)
+        : DartSpawnUriCallback(isolate, loader, url, originDocument)
+    {
+    }
+
+    void initialize()
+    {
+        // The VM initiates background isolates.
+        Dart_IsolateMakeRunnable(m_isolate);
+    }
+
+    bool domEnabled() { return false; }
+};
+
+class DartSpawnDomUriCallback : public DartSpawnUriCallback {
+public:
+    DartSpawnDomUriCallback(Dart_Isolate isolate, PassRefPtr<DartApplicationLoader> loader, const String& url, Document* originDocument)
+        : DartSpawnUriCallback(isolate, loader, url, originDocument)
+    {
+    }
+
+    void initialize()
+    {
+        // The browser initiates DOM isolates directly.
+    }
+
+    bool domEnabled() { return true; }
+};
+
+Dart_Isolate DartController::createServiceIsolateCallback(void* callbackData, char** error)
+{
+    // FIXME(dartbug.com/20303): we create an empty document for the service
+    // isolate that is never GCed so that its lifecycle is not dependent on
+    // pages. One we support service isolates we can remove this hack.
+    Document* document = HTMLDocument::create().leakRef();
+
+    Dart_Isolate serviceIsolate = DartController::createIsolate("dart:vmservice_dartium", "main", document, true, false, error);
+    DartDOMData* domData = DartDOMData::current();
+    domData->setIsObservatoryFakeDartDOMData(true);
+    Dart_ExitIsolate();
+    return serviceIsolate;
+}
+
+
+Dart_Isolate DartController::createPureIsolateCallback(const char* scriptURL, const char* entryPoint, const char* packageRoot, void* data, char** errorMsg)
+{
+    bool isSpawnUri = scriptURL ? true : false;
+
+    if (isSpawnUri && !WTF::isMainThread()) {
+        // FIXME(14463): We need to forward this request to the main thread to fetch the URI.
+        *errorMsg = strdup("spawnUri is not yet supported on background isolates.");
+        return 0;
+    }
+
+    DartDOMData* parentDOMData = static_cast<DartDOMData*>(data);
+    ExecutionContext* context = parentDOMData->scriptExecutionContext();
+
+    if (parentDOMData->isDOMEnabled() && !isSpawnUri) {
+        // spawnFunction is not allowed from a DOM enabled isolate.
+        // This triggers an exception in the caller.
+        *errorMsg = strdup("spawnFunction is not supported from a dom-enabled isolate. Please use spawnUri instead.");
+        return 0;
+    }
+    if (!isSpawnUri) {
+        scriptURL = parentDOMData->scriptURL();
+    }
+
+    ASSERT(context->isDocument());
+    Document* document = static_cast<Document*>(context);
+
+    Dart_Isolate isolate = createIsolate(scriptURL, entryPoint, document, false, true, errorMsg);
+
+    if (!isolate) {
+        // This triggers an exception in the caller.
+        *errorMsg = strdup("Isolate spawn failed.");
+        return 0;
+    }
+
+    // FIXME: If a spawnFunction, we should not need to request resources again. But, it's not clear
+    // we need this callback in the first place for spawnFunction.
+
+    // We need to request the sources asynchronously.
+    RefPtr<DartApplicationLoader> loader = DartApplicationLoader::create(document, false);
+    RefPtr<DartSpawnUriCallback> callback = adoptRef(new DartSpawnBackgroundUriCallback(isolate, loader, scriptURL, document));
+    Dart_ExitIsolate();
+    loader->processSingleRequest(isolate, scriptURL, callback);
+
+    return isolate;
+}
+
+static char* skipWhiteSpace(char* p)
+{
+    for (; *p != '\0' && isspace(*p); p++) { }
+    return p;
+}
+
+static char* skipBlackSpace(char* p)
+{
+    for (; *p != '\0' && !isspace(*p); p++) { }
+    return p;
+}
+
+static void setDartFlags(const char* str)
+{
+    if (!str) {
+        Dart_SetVMFlags(0, 0);
+        return;
+    }
+
+    size_t length = strlen(str);
+    char* copy = new char[length + 1];
+    memmove(copy, str, length);
+    copy[length] = '\0';
+
+    // Strip leading white space.
+    char* start = skipWhiteSpace(copy);
+
+    // Count the number of 'arguments'.
+    int argc = 0;
+    for (char* p = start; *p != '\0'; argc++) {
+        p = skipBlackSpace(p);
+        p = skipWhiteSpace(p);
+    }
+
+    // Allocate argument array.
+    const char** argv = new const char*[argc];
+
+    // Split the flags string into arguments.
+    argc = 0;
+    for (char* p = start; *p != '\0'; argc++) {
+        argv[argc] = p;
+        p = skipBlackSpace(p);
+        if (*p != '\0')
+            *p++ = '\0'; // 0-terminate argument
+        p = skipWhiteSpace(p);
+    }
+
+    // Set the flags.
+    Dart_SetVMFlags(argc, argv);
+
+    delete[] argv;
+    delete[] copy;
+}
+
+namespace {
+
+#if OS(LINUX)
+
+static void* openFileCallback(const char* name, bool write)
+{
+    return fopen(name, write ? "w" : "r");
+}
+
+static void readFileCallback(const uint8_t** data, intptr_t* fileLength, void* stream)
+{
+    if (!stream) {
+        *data = 0;
+        *fileLength = 0;
+    } else {
+        FILE* file = reinterpret_cast<FILE*>(stream);
+
+        // Get the file size.
+        fseek(file, 0, SEEK_END);
+        *fileLength = ftell(file);
+        rewind(file);
+
+        // Allocate data buffer.
+        *data = new uint8_t[*fileLength];
+        *fileLength = fread(const_cast<uint8_t*>(*data), 1, *fileLength, file);
+    }
+}
+
+static void writeFileCallback(const void* data, intptr_t length, void* file)
+{
+    fwrite(data, 1, length, reinterpret_cast<FILE*>(file));
+}
+
+static void closeFileCallback(void* file)
+{
+    fclose(reinterpret_cast<FILE*>(file));
+}
+
+#else
+
+static Dart_FileOpenCallback openFileCallback = 0;
+static Dart_FileReadCallback readFileCallback = 0;
+static Dart_FileWriteCallback writeFileCallback = 0;
+static Dart_FileCloseCallback closeFileCallback = 0;
+
+#endif // OS(LINUX)
+
+}
+
+static bool generateEntropy(uint8_t* buffer, intptr_t length)
+{
+    if (blink::Platform::current()) {
+        blink::Platform::current()->cryptographicallyRandomValues(buffer, length);
+        return true;
+    }
+    return false;
+}
+
+void DartController::initVMIfNeeded()
+{
+    static bool hasBeenInitialized = false;
+    if (hasBeenInitialized)
+        return;
+
+    char flagsProp[DartUtilities::PROP_VALUE_MAX_LEN];
+    int propLen = DartUtilities::getProp(
+        "DART_FLAGS", flagsProp, DartUtilities::PROP_VALUE_MAX_LEN);
+    if (propLen > 0) {
+        setDartFlags(flagsProp);
+    } else {
+        setDartFlags(0);
+    }
+
+    // FIXME(antonm): implement proper unhandled exception callback.
+    Dart_Initialize(&createPureIsolateCallback, 0, 0, 0, openFileCallback, readFileCallback, writeFileCallback, closeFileCallback, generateEntropy, createServiceIsolateCallback);
+    hasBeenInitialized = true;
+}
+
+static bool checkForExpiration()
+{
+    const time_t ExpirationTimeSecsSinceEpoch =
+#include "bindings/dart/ExpirationTimeSecsSinceEpoch.time_t"
+    ;
+    const char* override = getenv("DARTIUM_EXPIRATION_TIME");
+    time_t expiration;
+    if (override) {
+        expiration = static_cast<time_t>(String(override).toInt64());
+    } else {
+        expiration = ExpirationTimeSecsSinceEpoch;
+    }
+    const time_t now = time(0);
+    double diff = difftime(now, expiration);
+    if (diff > 0) {
+        fprintf(stderr, "[dartToStderr]: Dartium build has expired\n");
+        return true;
+    }
+
+    return false;
+}
+
+class DartDomLoadCallback : public DartApplicationLoader::Callback {
+public:
+    DartDomLoadCallback(DartController* controller, const String& url, Dart_Isolate domIsolate, Document* originDocument, PassRefPtr<DartScriptInfo> info)
+        : Callback(originDocument, info)
+        , m_controller(controller)
+        , m_url(url)
+        , m_isolate(domIsolate)
+    {
+    }
+
+    void ready()
+    {
+        m_controller->scheduleScriptExecution(m_url, m_isolate, scriptInfo());
+    }
+
+private:
+    DartController* m_controller;
+    String m_url;
+    Dart_Isolate m_isolate;
+};
+
+class DartScriptRunner : public EventListener {
+public:
+    static PassRefPtr<DartScriptRunner> create(const String& url, Dart_Isolate isolate, PassRefPtr<DartScriptInfo> info)
+    {
+        return adoptRef(new DartScriptRunner(url, isolate, info));
+    }
+
+    virtual void handleEvent(ExecutionContext* context, Event*)
+    {
+        ASSERT(context->isDocument());
+        Document* document = static_cast<Document*>(context);
+
+        // this gets removed below, so protect it while handler runs.
+        RefPtr<DartScriptRunner> protect(this);
+        document->domWindow()->removeEventListener(AtomicString("DOMContentLoaded"), this, false);
+
+        DartController::retrieve(context)->loadAndRunScript(m_url, m_isolate, m_info);
+    }
+
+    virtual bool operator==(const EventListener& other)
+    {
+        return this == &other;
+    }
+
+private:
+    DartScriptRunner(const String& url, Dart_Isolate isolate, PassRefPtr<DartScriptInfo> info)
+        : EventListener(EventListener::NativeEventListenerType)
+        , m_url(url)
+        , m_isolate(isolate)
+        , m_info(info)
+    {
+    }
+
+    String m_url;
+    Dart_Isolate m_isolate;
+    RefPtr<DartScriptInfo> m_info;
+};
+
+void DartController::scheduleScriptExecution(const String& url, Dart_Isolate isolate, PassRefPtr<DartScriptInfo> info)
+{
+    Document* document = frame()->document();
+    if (document->readyState() == "loading")
+        document->domWindow()->addEventListener(AtomicString("DOMContentLoaded"), DartScriptRunner::create(url, isolate, info), false);
+    else
+        loadAndRunScript(url, isolate, info);
+}
+
+void DartController::loadAndRunScript(const String& url, Dart_Isolate isolate, PassRefPtr<DartScriptInfo> info)
+{
+    DART_START_TIMER();
+    RefPtr<DartScriptInfo> scriptInfo = info;
+    Document* ALLOW_UNUSED document = frame()->document();
+
+    // Invoke only if this is the main document.
+    ASSERT(scriptInfo->ownerDocument() == document);
+
+    ASSERT(m_loader);
+    // Due to deferred loading we might already be running Dart code on
+    // an isolate and the library tag handler callback could result in a call
+    // to this code, we skip the Enter/Exit Isolate calls in that case.
+    if (isolate == Dart_CurrentIsolate()) {
+        m_loader->load(scriptInfo);
+    } else {
+        Dart_EnterIsolate(isolate);
+        m_loader->load(scriptInfo);
+        Dart_ExitIsolate();
+    }
+
+    DART_RECORD_TIMER("DartController::loadAndRunScript took");
+}
+
+void DartController::evaluate(const ScriptSourceCode& sourceCode, ScriptLoader* loader)
+{
+    if (checkForExpiration())
+        return;
+
+    DART_START_TIMER();
+    initVMIfNeeded();
+    DART_RECORD_TIMER("evaluate::initVM took");
+    Document* document = frame()->document();
+    RefPtr<Element> element(loader->element());
+
+    RefPtr<DartScriptInfo> scriptInfo = DartScriptInfo::create(element);
+    if (!scriptInfo) {
+        DartUtilities::reportProblem(document, "Dart script must be in HTML or SVG document.");
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    Document* owner = scriptInfo->ownerDocument();
+    if (m_documentsWithDart.contains(owner)) {
+        int line = scriptInfo->startLineNumber().zeroBasedInt();
+        DartUtilities::reportProblem(owner, "Only one Dart script tag allowed per document", line);
+        return;
+    }
+    m_documentsWithDart.add(owner);
+
+    if (m_loader) {
+        if (m_loader->running()) {
+            // Main has already been invoked.
+            String scriptURL = scriptInfo->sourceAttributeValue();
+
+            // Enforce that no new code is loaded. We've already invoked main at this point.
+            // Any referenced code must already be in the isolate.
+            if (scriptURL.isEmpty()) {
+                int line = scriptInfo->startLineNumber().zeroBasedInt();
+                DartUtilities::reportProblem(document, "Inline Darts scripts not supported after main script is invoked.", line);
+            } else {
+                m_loader->validateUrlLoaded(scriptURL);
+            }
+            return;
+        }
+        if (m_loader->error()) {
+            return;
+        }
+    }
+
+    if (!m_loader) {
+        m_loader = DartApplicationLoader::create(document, true);
+    }
+
+    DART_RECORD_TIMER("evaluate::prep for loading took");
+    if (document == scriptInfo->ownerDocument()) {
+        String url = scriptInfo->url();
+        // FIXME: This should be the first DOM enabled isolate. There is a race condition
+        // however - m_loader above won't catch this if it hasn't been set yet.
+        // This problem goes away once we map each script to a separate isolate.
+        if (!m_isolates.isEmpty())
+            return;
+        DART_RECORD_TIMER("evaluate before createIsolate");
+        Dart_Isolate isolate = createDOMEnabledIsolate(url, "main", document);
+        DART_RECORD_TIMER("evaluate after createIsolate");
+        RefPtr<DartDomLoadCallback> callback = adoptRef(new DartDomLoadCallback(this, url, isolate, document, scriptInfo));
+        Dart_ExitIsolate();
+        m_loader->processRequests(isolate, sourceCode, callback);
+        DART_RECORD_TIMER("evaluate process request took");
+    } else {
+        m_loader->addRequest(scriptInfo);
+    }
+    DART_RECORD_TIMER("evaluate took");
+}
+
+void DartController::bindToWindowObject(LocalFrame* frame, const String& key, NPObject* object)
+{
+    // FIXME: proper management of lifetime.
+    m_npObjectMap.set(key, object);
+}
+
+NPObject* DartController::npObject(const String& key)
+{
+    return m_npObjectMap.get(key);
+}
+
+Dart_Handle DartController::callFunction(Dart_Handle function, int argc, Dart_Handle* argv)
+{
+    V8Scope v8scope(DartDOMData::current());
+
+    // FIXME: Introduce Dart variant of V8GCController::checkMemoryUsage();
+
+    if (V8RecursionScope::recursionLevel(v8::Isolate::GetCurrent()) >= kMaxRecursionDepth)
+        return Dart_NewApiError("Maximum call stack size exceeded");
+
+    // FIXME: implement InspectorInstrumentationCookie stuff a la v8.
+    Dart_Handle result = Dart_InvokeClosure(function, argc, argv);
+
+    // Handle fatal error in Dart VM a la v8.
+
+    return result;
+}
+
+DartController* DartController::retrieve(LocalFrame* frame)
+{
+    if (!frame)
+        return 0;
+    return &frame->dart();
+}
+
+DartController* DartController::retrieve(ExecutionContext* context)
+{
+    if (!context || !context->isDocument())
+        return 0;
+    return retrieve(static_cast<Document*>(context)->frame());
+}
+
+void DartController::collectScriptStates(V8ScriptState* v8ScriptState, Vector<DartScriptState*>& result)
+{
+    if (m_isolates.isEmpty())
+        return;
+
+    v8::HandleScope handleScope(v8::Isolate::GetCurrent());
+    v8::Handle<v8::Context> v8Context = v8ScriptState->context();
+
+    Vector<Dart_Isolate>::iterator iterator;
+    for (iterator = m_isolates.begin(); iterator != m_isolates.end(); ++iterator) {
+        Dart_Isolate isolate = *iterator;
+        collectScriptStatesForIsolate(isolate, v8Context, result);
+    }
+}
+
+LibraryIdMap* DartController::libraryIdMapForIsolate(Dart_Isolate isolate)
+{
+    LibraryIdMap* libraryIdMap;
+    ScriptStatesMap::iterator it = m_scriptStates.find(isolate);
+    if (it == m_scriptStates.end()) {
+        libraryIdMap = new LibraryIdMap();
+        m_scriptStates.set(isolate, libraryIdMap);
+    } else {
+        libraryIdMap = it->value;
+    }
+    return libraryIdMap;
+}
+
+DartScriptState* DartController::lookupScriptState(Dart_Isolate isolate, v8::Handle<v8::Context> v8Context, intptr_t libraryId)
+{
+    return lookupScriptStateFromLibraryIdMap(isolate, v8Context, libraryIdMapForIsolate(isolate), libraryId);
+}
+
+DartScriptState* DartController::lookupScriptStateFromLibraryIdMap(Dart_Isolate isolate, v8::Handle<v8::Context> v8Context, LibraryIdMap* libraryIdMap, intptr_t libraryId)
+{
+    // -1 cannot be used as a HashMap key however library ids are
+    // guaranteed to be non-negative so it is a non-issue.
+    ASSERT(libraryId >= 0);
+    // 0 cannot be used as a HashMap key so we add 1 to the library id to
+    // create a valid key.
+    intptr_t libraryIdKey = libraryId + 1;
+    LibraryIdMap::iterator libraryIter = libraryIdMap->find(libraryIdKey);
+    DartScriptState* scriptState;
+    if (libraryIter == libraryIdMap->end()) {
+        V8ScriptState* v8ScriptState = V8ScriptState::from(v8Context);
+        RefPtr<DartScriptState> scriptStatePtr = DartScriptState::create(isolate, libraryId, v8ScriptState);
+        libraryIdMap->set(libraryIdKey, scriptStatePtr);
+        scriptState = scriptStatePtr.get();
+    } else {
+        scriptState = libraryIter->value.get();
+        ASSERT(scriptState);
+    }
+    return scriptState;
+}
+
+void DartController::collectScriptStatesForIsolate(Dart_Isolate isolate, v8::Handle<v8::Context> v8Context, Vector<DartScriptState*>& result)
+{
+    if (!isolate)
+        return;
+    DartIsolateScope scope(isolate);
+    DartApiScope apiScope;
+    LibraryIdMap* libraryIdMap = libraryIdMapForIsolate(isolate);
+    Dart_Handle libraryIdList = Dart_GetLibraryIds();
+
+    intptr_t length = 0;
+    Dart_Handle ALLOW_UNUSED valid = Dart_ListLength(libraryIdList, &length);
+    ASSERT(!Dart_IsError(valid));
+
+
+    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);
+        DartScriptState* scriptState = lookupScriptStateFromLibraryIdMap(isolate, v8Context, libraryIdMap, libraryId);
+        result.append(scriptState);
+    }
+}
+
+void DartController::spawnDomUri(const String& url)
+{
+    // Save caller isolate.
+    Dart_Isolate caller = Dart_CurrentIsolate();
+    ASSERT(caller);
+    Dart_ExitIsolate();
+
+    // Create DOM isolate.
+    Document* document = frame()->document();
+    Dart_Isolate isolate = createDOMEnabledIsolate(url, "main", document);
+
+    // Fetch and start.
+    RefPtr<DartApplicationLoader> loader = DartApplicationLoader::create(document, true);
+    RefPtr<DartSpawnUriCallback> callback = adoptRef(new DartSpawnDomUriCallback(isolate, loader, url, document));
+    Dart_ExitIsolate();
+    loader->processSingleRequest(isolate, url, callback);
+
+    // Restore caller isolate.
+    Dart_EnterIsolate(caller);
+
+    // FIXME: We need some way to return a Dart_Handle to the isolate we just created.
+}
+
+}