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

third_party/WebKit/Source/web/WebIsolatedWorkerImpl.cpp

Index: third_party/WebKit/Source/web/WebIsolatedWorkerImpl.cpp
diff --git a/third_party/WebKit/Source/web/WebIsolatedWorkerImpl.cpp b/third_party/WebKit/Source/web/WebIsolatedWorkerImpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3eab7360a76307425261985f008da733cd0aab68
--- /dev/null
+++ b/third_party/WebKit/Source/web/WebIsolatedWorkerImpl.cpp
@@ -0,0 +1,179 @@
+
+#include "web/WebIsolatedWorkerImpl.h"
+
+#include "base/debug/stack_trace.h"
+#include "base/logging.h"
+#include "bindings/core/v8/ScriptSourceCode.h"
+#include "core/fetch/CachedMetadata.h"
+#include "core/inspector/ConsoleMessage.h"
+#include "core/workers/WorkerBackingThread.h"
+#include "core/workers/WorkerReportingProxy.h"
+#include "core/workers/WorkerThread.h"
+#include "core/workers/WorkerThreadStartupData.h"
+#include "modules/EventTargetModulesNames.h"
+#include "modules/fetch/Request.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 "mojo/public/cpp/bindings/binding.h"
+#include "platform/TraceEvent.h"
+#include "platform/WebThreadSupportingGC.h"
+#include "public/platform/modules/serviceworker/service_worker.mojom-blink.h"
+#include "public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebThread.h"
+#include "public/web/modules/serviceworker/WebIsolatedWorkerContextClient.h"
+#include "public/web/WebSettings.h"
+#include "public/web/WebView.h"
+#include "web/WebLocalFrameImpl.h"
+#include "wtf/PtrUtil.h"
+#include "wtf/Threading.h"
+
+namespace blink {
+
+WebIsolatedWorkerImpl::MainThreadProxy::MainThreadProxy(WebIsolatedWorkerImpl* worker, KURL scopeURL)
+    : m_worker(worker)
+    , m_scopeURL(scopeURL)
+{
+    // Created in IO thread
+}
+
+WebIsolatedWorkerImpl::MainThreadProxy::~MainThreadProxy()
+{
+    // TODO: Must be deleted in Main thread
+    DCHECK(!m_worker);
+}
+
+void WebIsolatedWorkerImpl::MainThreadProxy::detach()
+{
+    MutexLocker locker(m_lock_for_worker);
+    m_worker = nullptr;
+}
+
+void WebIsolatedWorkerImpl::MainThreadProxy::initializeOnMainThread(KURL scopeURL)
+{
+    // Called in Main thread.
+    TRACE_EVENT0("ServiceWorker", "WebIsolatedWorkerImpl::MainThreadProxy::initializeOnMainThread");
+    LOG(ERROR) << "WebIsolatedWorkerImpl::MainThreadProxy::initializeOnMainThread~=|~~~~~~~~~~~~~~~~~~";
+    CHECK(isMainThread());
+
+    WebView* webView = WebView::create(nullptr, WebPageVisibilityStateVisible);
+    WebSettings* settings = webView->settings();
+    settings->setAcceleratedCompositingEnabled(false);
+    settings->setStrictMixedContentChecking(true);
+    settings->setAllowDisplayOfInsecureContent(false);
+    settings->setAllowRunningOfInsecureContent(false);
+    settings->setDataSaverEnabled(false);
+    WebLocalFrameImpl* mainFrame = toWebLocalFrameImpl(WebLocalFrame::create(WebTreeScopeType::Document, this));
+    webView->setMainFrame(mainFrame);
+    {
+        TRACE_EVENT0("ServiceWorker", "WebIsolatedWorkerImpl::MainThreadProxy::initializeOnMainThread lock");
+        MutexLocker locker(m_lock_for_document);
+        m_webView = webView;
+        m_mainFrame = mainFrame;
+        CString content("");
+        RefPtr<SharedBuffer> buffer(SharedBuffer::create(content.data(), content.length()));
+        m_mainFrame->frame()->loader().load(FrameLoadRequest(0, ResourceRequest(scopeURL), SubstituteData(buffer, "text/html", "UTF-8", KURL())));
+
+        // TODO: initialize shadow page
+    }
+}
+
+void WebIsolatedWorkerImpl::MainThreadProxy::postTaskToLoader(const WebTraceLocation& location, std::unique_ptr<ExecutionContextTask> task)
+{
+    TRACE_EVENT0("ServiceWorker", "WebIsolatedWorkerImpl::MainThreadProxy::postTaskToLoader");
+    MutexLocker locker(m_lock_for_document);
+    LOG(ERROR) << "WebIsolatedWorkerImpl::MainThreadProxy::postTaskToLoader";
+    if (!m_shadowPageLoadStarted) {
+        m_shadowPageLoadStarted = true;
+        Platform::current()->mainThread()->getWebTaskRunner()->postTask(
+            BLINK_FROM_HERE,
+            crossThreadBind(
+                &MainThreadProxy::initializeOnMainThread,
+                wrapPassRefPtr(this), m_scopeURL));
+        m_pending_tasks.push_back(std::move(task));
+        return;
+    }
+
+    // Keep tasks if the shadow page is not created yet.
+    if (m_shadowPageLoaded)
+        m_mainFrame->frame()->document()->postTask(location, std::move(task));
+    else
+        m_pending_tasks.push_back(std::move(task));
+}
+
+void WebIsolatedWorkerImpl::MainThreadProxy::postTaskToWorkerGlobalScope(const WebTraceLocation& location, std::unique_ptr<ExecutionContextTask> task)
+{
+    TRACE_EVENT0("ServiceWorker", "WebIsolatedWorkerImpl::MainThreadProxy::postTaskToWorkerGlobalScope");
+    LOG(ERROR) << "WebIsolatedWorkerImpl::postTaskToWorkerGlobalScope";
+    MutexLocker locker(m_lock_for_worker);
+
+    m_worker->thread()->postTask(location, std::move(task));
+}
+
+void WebIsolatedWorkerImpl::MainThreadProxy::willSendRequest(WebLocalFrame*, WebURLRequest& request)
+{
+    TRACE_EVENT1("ServiceWorker", "WebIsolatedWorkerImpl::MainThreadProxy::willSendRequest",
+        "URL", request.url().string().utf8().data());
+    LOG(ERROR) << "WebIsolatedWorkerImpl::MainThreadProxy::willSendRequest ";
+    // TODO: set provider host id
+}
+
+void WebIsolatedWorkerImpl::MainThreadProxy::didFinishDocumentLoad(WebLocalFrame*)
+{
+    TRACE_EVENT0("ServiceWorker", "WebIsolatedWorkerImpl::MainThreadProxy::didFinishDocumentLoad");
+    LOG(ERROR) << "WebIsolatedWorkerImpl::MainThreadProxy::didFinishDocumentLoad";
+    MutexLocker locker(m_lock_for_document);
+    m_shadowPageLoaded = true;
+    for (auto& task : m_pending_tasks)
+        m_mainFrame->frame()->document()->postTask(BLINK_FROM_HERE, std::move(task));
+    m_pending_tasks.clear();
+}
+
+WebIsolatedWorker* WebIsolatedWorker::create(WebIsolatedWorkerContextClient* client)
+{
+    // Called in IO thread.
+    return new WebIsolatedWorkerImpl(wrapUnique(client));
+}
+
+WebIsolatedWorkerImpl::WebIsolatedWorkerImpl(std::unique_ptr<WebIsolatedWorkerContextClient> client)
+    : m_workerGlobalScopeProxy(IsolatedWorkerReportingProxy::create(std::move(client)))
+{
+    // Called in IO thread.
+    TRACE_EVENT0("ServiceWorker", "WebIsolatedWorkerImpl::WebIsolatedWorkerImpl");
+}
+
+WebIsolatedWorkerImpl::~WebIsolatedWorkerImpl()
+{
+    // Called in IO thread.
+    TRACE_EVENT0("ServiceWorker", "WebIsolatedWorkerImpl::~WebIsolatedWorkerImpl");
+}
+
+void WebIsolatedWorkerImpl::startWorker(int64_t versionID, WebURL scopeURL, WebURL scriptURL)
+{
+    // Called in IO thread.
+    TRACE_EVENT0("ServiceWorker", "WebIsolatedWorkerImpl::startWorker");
+    m_mainThreadProxy = new MainThreadProxy(this, scopeURL);
+    m_loaderProxy = WorkerLoaderProxy::create(m_mainThreadProxy.get());
+    m_workerThread = IsolatedWorkerThread::create(m_loaderProxy, *m_workerGlobalScopeProxy);
+    m_workerGlobalScopeProxy->setVersionID(versionID);
+    m_workerGlobalScopeProxy->setThread(m_workerThread.get());
+    m_workerThread->start(WorkerThreadStartupData::create(
+        scriptURL,
+        "fake user agent",
+        "console.log('test1');importScripts(\"importScripts.js\");console.log('test2');",
+        nullptr,
+        DontPauseWorkerGlobalScopeOnStart,
+        nullptr,
+        "",
+        nullptr,
+        nullptr,
+        WebAddressSpaceLocal,
+        nullptr,
+        nullptr,
+        V8CacheOptionsDefault));
+}
+
+} // namespace blink