[proof-of-concept] SW thread independent of the main thread

third_party/WebKit/Source/modules/serviceworkers/IsolatedWorkerReportingProxy.cpp

Index: third_party/WebKit/Source/modules/serviceworkers/IsolatedWorkerReportingProxy.cpp
diff --git a/third_party/WebKit/Source/modules/serviceworkers/IsolatedWorkerReportingProxy.cpp b/third_party/WebKit/Source/modules/serviceworkers/IsolatedWorkerReportingProxy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d968819a488d05b93fdd03a5cf0932e6c1733317
--- /dev/null
+++ b/third_party/WebKit/Source/modules/serviceworkers/IsolatedWorkerReportingProxy.cpp
@@ -0,0 +1,306 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "modules/serviceworkers/IsolatedWorkerReportingProxy.h"
+
+#include "mojo/public/cpp/bindings/binding.h"
+#include "platform/TraceEvent.h"
+#include "core/inspector/ConsoleMessage.h"
+#include "modules/serviceworkers/IsolatedWorkerThread.h"
+#include "public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
+#include "modules/serviceworkers/WaitUntilObserver.h"
+#include "modules/serviceworkers/FetchEvent.h"
+#include "modules/serviceworkers/FetchEventInit.h"
+#include "modules/serviceworkers/IsolatedWorkerReportingProxy.h"
+#include "modules/serviceworkers/IsolatedWorkerThread.h"
+#include "modules/serviceworkers/RespondWithObserver.h"
+#include "public/web/modules/serviceworker/WebServiceWorkerContextClient.h"
+#include "modules/serviceworkers/ServiceWorkerGlobalScopeClient.h"
+#include "web/ServiceWorkerGlobalScopeClientImpl.h"
+#include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
+#include "modules/serviceworkers/ServiceWorkerGlobalScope.h"
+
+namespace blink {
+class IsolatedWorkerReportingProxy::IsolatedServiceWorkerContextClient
+    : public WebServiceWorkerContextClient {
+public:
+    IsolatedServiceWorkerContextClient(IsolatedWorkerReportingProxy* proxy)
+        : m_proxy(proxy)
+    {
+    }
+    ~IsolatedServiceWorkerContextClient() {}
+
+private:
+    void respondToFetchEvent(int responseID, double) override
+    {
+        m_proxy->respondToFetchEvent(responseID);
+    }
+    void respondToFetchEvent(int responseID, const WebServiceWorkerResponse& response, double) override
+    {
+        m_proxy->respondToFetchEvent(responseID, response);
+    }
+    void didHandleFetchEvent(int eventFinishID, WebServiceWorkerEventResult result, double) override
+    {
+        LOG(ERROR) << "didHandleFetchEvent " << eventFinishID;
+    }
+    void getClient(const WebString&, WebServiceWorkerClientCallbacks*) override {}
+    void getClients(const WebServiceWorkerClientQueryOptions&, WebServiceWorkerClientsCallbacks*) override {}
+    void openWindow(const WebURL&, WebServiceWorkerClientCallbacks*) override {}
+    void setCachedMetadata(const WebURL& url, const char* data, size_t size) {}
+    void clearCachedMetadata(const WebURL& url) {}
+    void postMessageToClient(const WebString& uuid, const WebString&, WebMessagePortChannelArray*) override {}
+    void postMessageToCrossOriginClient(const WebCrossOriginServiceWorkerClient&, const WebString&, WebMessagePortChannelArray*) override {}
+    void skipWaiting(WebServiceWorkerSkipWaitingCallbacks*) override {}
+    void claim(WebServiceWorkerClientsClaimCallbacks*) override {}
+    void focus(const WebString& uuid, WebServiceWorkerClientCallbacks*) override {}
+    void navigate(const WebString& uuid, const WebURL&, WebServiceWorkerClientCallbacks*) override {}
+    void registerForeignFetchScopes(const WebVector<WebURL>& subScopes, const WebVector<WebSecurityOrigin>& origins) override {}
+    IsolatedWorkerReportingProxy* m_proxy;
+};
+
+class IsolatedWorkerReportingProxy::IsolatedWorkerClientImpl : public mojom::blink::IsolatedWorkerClient {
+public:
+    explicit IsolatedWorkerClientImpl(IsolatedWorkerReportingProxy* workerReportingProxy)
+        : m_binding(this)
+        , m_workerReportingProxy(workerReportingProxy)
+    {
+        TRACE_EVENT0(
+            "ServiceWorker",
+            "IsolatedWorkerClientImpl::IsolatedWorkerClientImpl");
+        LOG(ERROR) << "IsolatedWorkerClientImpl" << this;
+    }
+    ~IsolatedWorkerClientImpl() override
+    {
+        LOG(ERROR) << "~IsolatedWorkerClientImpl" << this;
+    }
+    void Bind(mojom::blink::IsolatedWorkerClientRequest local_interfaces_request)
+    {
+        DCHECK(!m_binding.is_bound());
+        m_binding.Bind(std::move(local_interfaces_request));
+    }
+
+    void OnFetchEvent(int32_t responseID, int32_t eventFinishID, const String& url, bool is_navigate, const OnFetchEventCallback& callback) override
+    {
+        TRACE_EVENT0(
+            "ServiceWorker",
+            "IsolatedWorkerClientImpl::OnFetchEvent");
+        LOG(ERROR) << "responseID: " << responseID << " eventFinishID: " << eventFinishID;
+        m_workerReportingProxy->OnFetchEvent(responseID, eventFinishID, url, is_navigate, callback);
+        //callback.Run(1000);
+    }
+
+private:
+    mojo::Binding<mojom::blink::IsolatedWorkerClient> m_binding;
+    IsolatedWorkerReportingProxy* m_workerReportingProxy;
+};
+
+std::unique_ptr<IsolatedWorkerReportingProxy> IsolatedWorkerReportingProxy::create(std::unique_ptr<WebIsolatedWorkerContextClient> workerContextClient)
+{
+
+    return wrapUnique(new IsolatedWorkerReportingProxy(std::move(workerContextClient)));
+}
+IsolatedWorkerReportingProxy::~IsolatedWorkerReportingProxy()
+{
+    LOG(ERROR) << "~IsolatedWorkerReportingProxy";
+}
+void IsolatedWorkerReportingProxy::setVersionID(int64_t versionID)
+{
+    m_versionID = versionID;
+}
+void IsolatedWorkerReportingProxy::setThread(IsolatedWorkerThread* thread)
+{
+    m_thread = thread;
+}
+
+void IsolatedWorkerReportingProxy::reportException(const String& errorMessage, std::unique_ptr<SourceLocation>, int exceptionId)
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::reportException");
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::reportException: \"" << errorMessage.utf8().data() << "\"";
+}
+void IsolatedWorkerReportingProxy::reportConsoleMessage(MessageSource, MessageLevel, const String& message, SourceLocation*)
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::reportConsoleMessage");
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::reportConsoleMessage: \"" << message.utf8().data() << "\"";
+}
+void IsolatedWorkerReportingProxy::postMessageToPageInspector(const String&)
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::postMessageToPageInspector");
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::postMessageToPageInspector";
+}
+
+// Invoked when the worker script is evaluated. |success| is true if the
+// evaluation completed with no uncaught exception.
+void IsolatedWorkerReportingProxy::didEvaluateWorkerScript(bool success)
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::didEvaluateWorkerScript");
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::didEvaluateWorkerScript";
+
+    // m_isolated_worker_host_service->WorkerScriptEvaluated();
+    m_isolated_worker_host_service->OnScriptEvaluated();
+    m_thread->postTask(
+        BLINK_FROM_HERE, createSameThreadTask(
+                             &IsolatedWorkerReportingProxy::sendWorkerStarted, WTF::unretained(this)));
+}
+
+// Invoked when the thread creates a worker script context.
+void IsolatedWorkerReportingProxy::didInitializeWorkerContext()
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::didInitializeWorkerContext");
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::didInitializeWorkerContext";
+    m_scriptList = m_workerContextClient->takeWorkerScriptList();
+    for (const auto& script : *m_scriptList) {
+        LOG(ERROR) << "script: " << script->url;
+    }
+}
+
+// Invoked when the new WorkerGlobalScope is started.
+void IsolatedWorkerReportingProxy::workerGlobalScopeStarted(WorkerOrWorkletGlobalScope* workerGlobalScope)
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::workerGlobalScopeStarted");
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::workerGlobalScopeStarted";
+    CHECK(workerGlobalScope == m_thread->globalScope());
+
+    std::unique_ptr<WebServiceWorkerRegistration::Handle> registrationHandle(m_workerContextClient->takeAssociatedRegistration());
+    static_cast<ServiceWorkerGlobalScope*>(workerGlobalScope)->setRegistration(std::move(registrationHandle));
+
+    m_seriveWorkerContextClient.reset(new IsolatedServiceWorkerContextClient(this));
+    provideServiceWorkerGlobalScopeClientToWorker(static_cast<WorkerGlobalScope*>(workerGlobalScope)->clients(), ServiceWorkerGlobalScopeClientImpl::create(*m_seriveWorkerContextClient));
+}
+
+// Invoked when close() is invoked on the worker context.
+void IsolatedWorkerReportingProxy::workerGlobalScopeClosed()
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::workerGlobalScopeClosed");
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::workerGlobalScopeClosed";
+}
+
+// Invoked when the thread is stopped and WorkerGlobalScope is being
+// destructed. (This is be the last method that is called on this
+// interface)
+void IsolatedWorkerReportingProxy::workerThreadTerminated()
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::workerThreadTerminated");
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::workerThreadTerminated";
+}
+
+// Invoked when the thread is about to be stopped and WorkerGlobalScope
+// is to be destructed. (When this is called it is guaranteed that
+// WorkerGlobalScope is still alive)
+void IsolatedWorkerReportingProxy::willDestroyWorkerGlobalScope()
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::willDestroyWorkerGlobalScope");
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::willDestroyWorkerGlobalScope";
+}
+
+void IsolatedWorkerReportingProxy::initializeOnWorkerThread()
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::initializeOnWorkerThread");
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::initializeOnWorkerThread";
+    m_workerContextClient->initializeOnWorkerThread();
+    m_workerContextClient->connectToRemoteService(mojo::GetProxy(&m_isolated_worker_host_service));
+    mojom::blink::IsolatedWorkerClientPtr client_ptr;
+    m_isolatedWorkerClient.reset(new IsolatedWorkerClientImpl(this));
+    m_isolatedWorkerClient->Bind(GetProxy(&client_ptr));
+    m_isolated_worker_host_service->OnThreadStarted(m_versionID, std::move(client_ptr));
+}
+
+std::unique_ptr<String> IsolatedWorkerReportingProxy::takeAlternativeCode(const KURL& url)
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::takeAlternativeCode");
+    LOG(ERROR) << url.getString().utf8().data();
+    const String urlString(url.getString());
+    for (const auto& script : *m_scriptList) {
+        if (String::fromUTF8(script->url.data(), script->url.length()) != urlString)
+            continue;
+        std::unique_ptr<String> scriptString(new String);
+        for (const auto& dataItem : *script->data) {
+            scriptString->append(String::fromUTF8(dataItem->data(), dataItem->size()));
+        }
+        return scriptString;
+    }
+    return nullptr;
+}
+
+std::unique_ptr<WTF::Vector<char>> IsolatedWorkerReportingProxy::takeAlternativeCachedMetadata(const KURL& url)
+{
+    TRACE_EVENT0("ServiceWorker", "IsolatedWorkerReportingProxy::takeAlternativeCode");
+    LOG(ERROR) << url.getString().utf8().data();
+    const String urlString(url.getString());
+    for (const auto& script : *m_scriptList) {
+        if (String::fromUTF8(script->url.data(), script->url.length()) != urlString)
+            continue;
+        std::unique_ptr<WTF::Vector<char>> data(new WTF::Vector<char>);
+        // TODO: reserve
+
+        for (const auto& dataItem : *script->meta_data) {
+            data->append(dataItem->data(), dataItem->size());
+        }
+        return data;
+    }
+    return nullptr;
+}
+
+IsolatedWorkerReportingProxy::IsolatedWorkerReportingProxy(std::unique_ptr<WebIsolatedWorkerContextClient> workerContextClient)
+    : m_workerContextClient(std::move(workerContextClient))
+    , m_weakFactory(this)
+{
+    LOG(ERROR) << "IsolatedWorkerReportingProxy";
+}
+void IsolatedWorkerReportingProxy::sendWorkerStarted()
+{
+    LOG(ERROR) << "sendWorkerStarted";
+    m_isolated_worker_host_service->OnWorkerStarted();
+}
+void IsolatedWorkerReportingProxy::OnFetchEvent(int32_t responseID, int32_t eventFinishID, const String& url, bool is_navigate, const mojom::blink::IsolatedWorkerClient::OnFetchEventCallback& callback)
+{
+    LOG(ERROR) << "IsolatedWorkerReportingProxy::OnFetchEvent    " << url.utf8().data();
+    m_onFetchCallbacks.set(responseID, callback);
+    blink::WebServiceWorkerRequest webRequest;
+    webRequest.setURL(blink::WebURL(KURL(ParsedURLString, url)));
+    if (is_navigate)
+        webRequest.setMode(WebURLRequest::FetchRequestModeNavigate);
+    WorkerGlobalScope* workerGlobalScope = static_cast<WorkerGlobalScope*>(m_thread->globalScope());
+    ScriptState::Scope scope(workerGlobalScope->scriptController()->getScriptState());
+    WaitUntilObserver* waitUntilObserver = WaitUntilObserver::create(workerGlobalScope, WaitUntilObserver::Fetch, eventFinishID);
+    RespondWithObserver* respondWithObserver = RespondWithObserver::create(workerGlobalScope, responseID, webRequest.url(), webRequest.mode(), webRequest.frameType(), webRequest.requestContext(), waitUntilObserver);
+    Request* request = Request::create(workerGlobalScope->scriptController()->getScriptState(), webRequest);
+    request->getHeaders()->setGuard(Headers::ImmutableGuard);
+    FetchEventInit eventInit;
+    eventInit.setCancelable(true);
+    eventInit.setRequest(request);
+    eventInit.setClientId(webRequest.isMainResourceLoad() ? WebString() : webRequest.clientId());
+    eventInit.setIsReload(webRequest.isReload());
+    FetchEvent* fetchEvent = FetchEvent::create(workerGlobalScope->scriptController()->getScriptState(), EventTypeNames::fetch, eventInit, respondWithObserver, waitUntilObserver);
+    waitUntilObserver->willDispatchEvent();
+    DispatchEventResult dispatchResult = workerGlobalScope->dispatchEvent(fetchEvent);
+    respondWithObserver->didDispatchEvent(dispatchResult);
+    // false is okay because waitUntil for fetch event doesn't care about the
+    // promise rejection or an uncaught runtime script error.
+    waitUntilObserver->didDispatchEvent(false /*
+       errorOccurred */);
+}
+
+void IsolatedWorkerReportingProxy::respondToFetchEvent(int responseID)
+{
+    LOG(ERROR) << "respondToFetchEvent " << responseID;
+    mojom::blink::IsolatedWorkerClient::OnFetchEventCallback callback = m_onFetchCallbacks.take(responseID);
+    callback.Run(false, nullptr);
+}
+void IsolatedWorkerReportingProxy::respondToFetchEvent(int responseID, const WebServiceWorkerResponse& response)
+{
+    LOG(ERROR) << "respondToFetchEvent " << responseID;
+    LOG(ERROR) << "response blobid " << response.blobUUID().utf8().data();
+    LOG(ERROR) << "response blobid " << response.blobSize();
+    mojom::blink::ServiceWorkerResponsePtr res(mojom::blink::ServiceWorkerResponse::New());
+    res->url = response.url().string();
+    res->status_code = response.status();
+    res->status_text = response.statusText();
+    res->blob_uuid = response.blobUUID();
+    res->blob_size = response.blobSize();
+    res->stream_url = response.streamURL().string();
+    mojom::blink::IsolatedWorkerClient::OnFetchEventCallback callback = m_onFetchCallbacks.take(responseID);
+    callback.Run(true, std::move(res));
+}
+
+} // namespace blink