[worklets] Split up InProcessWorkerMessagingProxy into a base+worker class.

third_party/WebKit/Source/core/workers/ThreadedMessagingProxyBase.cpp

-/*
- * Copyright (C) 2008 Apple Inc. All Rights Reserved.
- * 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:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 APPLE COMPUTER, INC. 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.
- *
- */
+// 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 "core/workers/InProcessWorkerMessagingProxy.h"
+#include "core/workers/ThreadedMessagingProxyBase.h"
 
+#include "bindings/core/v8/SourceLocation.h"
 #include "core/dom/Document.h"
-#include "core/dom/ExecutionContextTask.h"
-#include "core/dom/SecurityContext.h"
-#include "core/events/ErrorEvent.h"
-#include "core/events/MessageEvent.h"
-#include "core/frame/FrameConsole.h"
-#include "core/frame/LocalFrame.h"
-#include "core/frame/csp/ContentSecurityPolicy.h"
-#include "core/inspector/ConsoleMessage.h"
-#include "core/loader/DocumentLoadTiming.h"
 #include "core/loader/DocumentLoader.h"
-#include "core/origin_trials/OriginTrialContext.h"
-#include "core/workers/InProcessWorkerBase.h"
-#include "core/workers/InProcessWorkerObjectProxy.h"
 #include "core/workers/ParentFrameTaskRunners.h"
-#include "core/workers/WorkerClients.h"
-#include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerInspectorProxy.h"
 #include "core/workers/WorkerThreadStartupData.h"
-#include "public/platform/WebTaskRunner.h"
-#include "wtf/WTF.h"
-#include <memory>
+#include "wtf/CurrentTime.h"
 
 namespace blink {
 
 namespace {
 
-void processUnhandledExceptionOnWorkerGlobalScope(int exceptionId, ExecutionContext* scriptContext)
-{
-    WorkerGlobalScope* globalScope = toWorkerGlobalScope(scriptContext);
-    globalScope->exceptionUnhandled(exceptionId);
-}
-
-void processMessageOnWorkerGlobalScope(PassRefPtr<SerializedScriptValue> message, std::unique_ptr<MessagePortChannelArray> channels, InProcessWorkerObjectProxy* workerObjectProxy, ExecutionContext* scriptContext)
-{
-    WorkerGlobalScope* globalScope = toWorkerGlobalScope(scriptContext);
-    MessagePortArray* ports = MessagePort::entanglePorts(*scriptContext, std::move(channels));
-    globalScope->dispatchEvent(MessageEvent::create(ports, message));
-    workerObjectProxy->confirmMessageFromWorkerObject();
-    workerObjectProxy->startPendingActivityTimer();
-}
-
 static int s_liveMessagingProxyCount = 0;
 
 } // namespace
 
-InProcessWorkerMessagingProxy::InProcessWorkerMessagingProxy(InProcessWorkerBase* workerObject, WorkerClients* workerClients)
-    : InProcessWorkerMessagingProxy(workerObject->getExecutionContext(), workerObject, workerClients)
+ThreadedMessagingProxyBase::ThreadedMessagingProxyBase(ExecutionContext* executionContext)
+    : m_executionContext(executionContext)
+    , m_mayBeDestroyed(false)
+    , m_unconfirmedMessageCount(0)
+    , m_workerGlobalScopeMayHavePendingActivity(false)
+    , m_askedToTerminate(false)
+    , m_workerInspectorProxy(WorkerInspectorProxy::create())
+    , m_parentFrameTaskRunners(ParentFrameTaskRunners::create(toDocument(m_executionContext.get())->frame()))
 {
-    DCHECK(m_workerObject);
+    DCHECK(isParentContextThread());
+    s_liveMessagingProxyCount++;
 }
 
-InProcessWorkerMessagingProxy::~InProcessWorkerMessagingProxy()
+ThreadedMessagingProxyBase::~ThreadedMessagingProxyBase()
 {
     DCHECK(isParentContextThread());
-    DCHECK(!m_workerObject);
     if (m_loaderProxy)
         m_loaderProxy->detachProvider(this);
     s_liveMessagingProxyCount--;
 }
 
-int InProcessWorkerMessagingProxy::proxyCount()
+int ThreadedMessagingProxyBase::proxyCount()
 {
     DCHECK(isMainThread());
     return s_liveMessagingProxyCount;
 }
 
-void InProcessWorkerMessagingProxy::startWorkerGlobalScope(const KURL& scriptURL, const String& userAgent, const String& sourceCode)
+void ThreadedMessagingProxyBase::initializeWorkerThread(std::unique_ptr<WorkerThreadStartupData> startupData)
 {
     DCHECK(isParentContextThread());
-    if (m_askedToTerminate) {
-        // Worker.terminate() could be called from JS before the thread was
-        // created.
-        return;
-    }
 
     Document* document = toDocument(getExecutionContext());
-    SecurityOrigin* starterOrigin = document->getSecurityOrigin();
-
-    ContentSecurityPolicy* csp = m_workerObject->contentSecurityPolicy() ? m_workerObject->contentSecurityPolicy() : document->contentSecurityPolicy();
-    DCHECK(csp);
-
-    WorkerThreadStartMode startMode = m_workerInspectorProxy->workerStartMode(document);
-    std::unique_ptr<WorkerSettings> workerSettings = wrapUnique(new WorkerSettings(document->settings()));
-    std::unique_ptr<WorkerThreadStartupData> startupData = WorkerThreadStartupData::create(scriptURL, userAgent, sourceCode, nullptr, startMode, csp->headers().get(), m_workerObject->referrerPolicy(), starterOrigin, m_workerClients.release(), document->addressSpace(), OriginTrialContext::getTokens(document).get(), std::move(workerSettings));
     double originTime = document->loader() ? document->loader()->timing().referenceMonotonicTime() : monotonicallyIncreasingTime();
 
     m_loaderProxy = WorkerLoaderProxy::create(this);
     m_workerThread = createWorkerThread(originTime);
     m_workerThread->start(std::move(startupData));
     workerThreadCreated();
-    m_workerInspectorProxy->workerThreadCreated(document, m_workerThread.get(), scriptURL);
 }
 
-void InProcessWorkerMessagingProxy::postMessageToWorkerObject(PassRefPtr<SerializedScriptValue> message, std::unique_ptr<MessagePortChannelArray> channels)
+void ThreadedMessagingProxyBase::postOrQueueTaskToWorkerGlobalScope(std::unique_ptr<ExecutionContextTask> task)

[nhiroki, 2016/09/06 07:07:08]

I'd prefer to keep 'Message(Event)' instead of 'Task' in order to clarify this
is different from postTaskToWorkerGlobalScope() and specialized for postMessage.

[ikilpatrick, 2016/09/06 18:59:49]

Acknowledged.

 {
-    DCHECK(isParentContextThread());
-    if (!m_workerObject || m_askedToTerminate)
-        return;
-
-    MessagePortArray* ports = MessagePort::entanglePorts(*getExecutionContext(), std::move(channels));
-    m_workerObject->dispatchEvent(MessageEvent::create(ports, message));
-}
-
-void InProcessWorkerMessagingProxy::postMessageToWorkerGlobalScope(PassRefPtr<SerializedScriptValue> message, std::unique_ptr<MessagePortChannelArray> channels)
-{
-    DCHECK(isParentContextThread());
-    if (m_askedToTerminate)
-        return;
-
-    std::unique_ptr<ExecutionContextTask> task = createCrossThreadTask(&processMessageOnWorkerGlobalScope, message, passed(std::move(channels)), crossThreadUnretained(&workerObjectProxy()));

[nhiroki, 2016/09/06 07:07:08]

Will Worklet support postMessage()? If it'll be supported, we could keep this
task creation in postOrQueueTaskToWorkerGlobalScope(). If it won't be supported,
we could entirely move postOrQueueTaskToWorkerGlobalScope() and fields
(m_unconfirmedMessageCount, m_queuedEarlyTasks) to
InProcessWorkerMessagingProxy.

[ikilpatrick, 2016/09/06 18:59:50]

Yeah I wasn't sure what to do here initially. My initial thoughts were to try
and contain all of the "lifecycle" methods in one class. But changed, and
actually looks pretty good.

Major thing is that worklets wont have a hasPendingActivity call now which I
think makes sense.

     if (m_workerThread) {
         // A message event is an activity and may initiate another activity.
         m_workerGlobalScopeMayHavePendingActivity = true;
         ++m_unconfirmedMessageCount;
         m_workerThread->postTask(BLINK_FROM_HERE, std::move(task));
     } else {
         m_queuedEarlyTasks.append(std::move(task));
     }
 }
 
-void InProcessWorkerMessagingProxy::postTaskToWorkerGlobalScope(const WebTraceLocation& location, std::unique_ptr<ExecutionContextTask> task)
+void ThreadedMessagingProxyBase::postTaskToWorkerGlobalScope(const WebTraceLocation& location, std::unique_ptr<ExecutionContextTask> task)
 {
     if (m_askedToTerminate)
         return;
 
     DCHECK(m_workerThread);
     m_workerThread->postTask(location, std::move(task));
 }
 
-void InProcessWorkerMessagingProxy::postTaskToLoader(const WebTraceLocation& location, std::unique_ptr<ExecutionContextTask> task)
+void ThreadedMessagingProxyBase::postTaskToLoader(const WebTraceLocation& location, std::unique_ptr<ExecutionContextTask> task)
 {
     DCHECK(getExecutionContext()->isDocument());
     // TODO(hiroshige,yuryu): Make this not use ExecutionContextTask and use
     // m_parentFrameTaskRunners->get(TaskType::Networking) instead.
     getExecutionContext()->postTask(location, std::move(task));
 }
 
-void InProcessWorkerMessagingProxy::dispatchErrorEvent(const String& errorMessage, std::unique_ptr<SourceLocation> location, int exceptionId)
-{
-    DCHECK(isParentContextThread());
-    if (!m_workerObject)
-        return;
-
-    // We don't bother checking the askedToTerminate() flag here, because
-    // exceptions should *always* be reported even if the thread is terminated.
-    // This is intentionally different than the behavior in MessageWorkerTask,
-    // because terminated workers no longer deliver messages (section 4.6 of the
-    // WebWorker spec), but they do report exceptions.
-
-    ErrorEvent* event = ErrorEvent::create(errorMessage, location->clone(), nullptr);
-    if (m_workerObject->dispatchEvent(event) == DispatchEventResult::NotCanceled)
-        postTaskToWorkerGlobalScope(BLINK_FROM_HERE, createCrossThreadTask(&processUnhandledExceptionOnWorkerGlobalScope, exceptionId));
-}
-
-void InProcessWorkerMessagingProxy::reportConsoleMessage(MessageSource source, MessageLevel level, const String& message, std::unique_ptr<SourceLocation> location)
+void ThreadedMessagingProxyBase::reportConsoleMessage(MessageSource source, MessageLevel level, const String& message, std::unique_ptr<SourceLocation> location)
 {
     DCHECK(isParentContextThread());
     if (m_askedToTerminate)
         return;
     if (m_workerInspectorProxy)
         m_workerInspectorProxy->addConsoleMessageFromWorker(level, message, std::move(location));
 }
 
-void InProcessWorkerMessagingProxy::workerThreadCreated()
+void ThreadedMessagingProxyBase::workerThreadCreated()
 {
     DCHECK(isParentContextThread());
     DCHECK(!m_askedToTerminate);
     DCHECK(m_workerThread);
 
     DCHECK(!m_unconfirmedMessageCount);
     m_unconfirmedMessageCount = m_queuedEarlyTasks.size();
 
     // Worker initialization means a pending activity.
     m_workerGlobalScopeMayHavePendingActivity = true;
 
     for (auto& earlyTasks : m_queuedEarlyTasks)
         m_workerThread->postTask(BLINK_FROM_HERE, std::move(earlyTasks));
     m_queuedEarlyTasks.clear();
 }
 
-InProcessWorkerMessagingProxy::InProcessWorkerMessagingProxy(ExecutionContext* executionContext, InProcessWorkerBase* workerObject, WorkerClients* workerClients)
-    : m_executionContext(executionContext)
-    , m_workerObjectProxy(InProcessWorkerObjectProxy::create(this))
-    , m_workerObject(workerObject)
-    , m_mayBeDestroyed(false)
-    , m_unconfirmedMessageCount(0)
-    , m_workerGlobalScopeMayHavePendingActivity(false)
-    , m_askedToTerminate(false)
-    , m_workerInspectorProxy(WorkerInspectorProxy::create())
-    , m_workerClients(workerClients)
-    , m_parentFrameTaskRunners(ParentFrameTaskRunners::create(toDocument(m_executionContext.get())->frame()))
-{
-    DCHECK(isParentContextThread());
-    s_liveMessagingProxyCount++;
-}
-
-void InProcessWorkerMessagingProxy::workerObjectDestroyed()
+void ThreadedMessagingProxyBase::parentObjectDestroyed()
 {
     DCHECK(isParentContextThread());
 
-    // workerObjectDestroyed() is called in InProcessWorkerBase's destructor.
-    // Thus it should be guaranteed that a weak pointer m_workerObject has been
-    // cleared before this method gets called.
-    DCHECK(!m_workerObject);
-
-    m_parentFrameTaskRunners->get(TaskType::Internal)->postTask(BLINK_FROM_HERE, WTF::bind(&InProcessWorkerMessagingProxy::workerObjectDestroyedInternal, unretained(this)));
+    m_parentFrameTaskRunners->get(TaskType::Internal)->postTask(BLINK_FROM_HERE, WTF::bind(&ThreadedMessagingProxyBase::parentObjectDestroyedInternal, unretained(this)));
 }
 
-void InProcessWorkerMessagingProxy::workerObjectDestroyedInternal()
+void ThreadedMessagingProxyBase::parentObjectDestroyedInternal()
 {
     DCHECK(isParentContextThread());
     m_mayBeDestroyed = true;
     if (m_workerThread)
-        terminateWorkerGlobalScope();
+        terminateGlobalScope();
     else
         workerThreadTerminated();
 }
 
-void InProcessWorkerMessagingProxy::workerThreadTerminated()
+void ThreadedMessagingProxyBase::workerThreadTerminated()
 {
     DCHECK(isParentContextThread());
 
     // This method is always the last to be performed, so the proxy is not
     // needed for communication in either side any more. However, the Worker
     // object may still exist, and it assumes that the proxy exists, too.
     m_askedToTerminate = true;
     m_workerThread = nullptr;
     m_workerInspectorProxy->workerThreadTerminated();
     if (m_mayBeDestroyed)
         delete this;
 }
 
-void InProcessWorkerMessagingProxy::terminateWorkerGlobalScope()
+void ThreadedMessagingProxyBase::terminateGlobalScope()
 {
     DCHECK(isParentContextThread());
 
     if (m_askedToTerminate)
         return;
     m_askedToTerminate = true;
 
     if (m_workerThread)
         m_workerThread->terminate();
 
     m_workerInspectorProxy->workerThreadTerminated();
 }
 
-void InProcessWorkerMessagingProxy::postMessageToPageInspector(const String& message)
+void ThreadedMessagingProxyBase::postMessageToPageInspector(const String& message)
 {
     DCHECK(isParentContextThread());
     if (m_workerInspectorProxy)
         m_workerInspectorProxy->dispatchMessageFromWorker(message);
 }
 
-void InProcessWorkerMessagingProxy::confirmMessageFromWorkerObject()
+void ThreadedMessagingProxyBase::confirmMessageFromWorkerObject()
 {
     DCHECK(isParentContextThread());
     if (m_askedToTerminate)
         return;
     DCHECK(m_unconfirmedMessageCount);
     --m_unconfirmedMessageCount;
 }
 
-void InProcessWorkerMessagingProxy::pendingActivityFinished()
+void ThreadedMessagingProxyBase::pendingActivityFinished()
 {
     DCHECK(isParentContextThread());
     DCHECK(m_workerGlobalScopeMayHavePendingActivity);
     if (m_unconfirmedMessageCount > 0) {
         // Ignore the report because an inflight message event may initiate a
         // new activity.
         return;
     }
     m_workerGlobalScopeMayHavePendingActivity = false;
 }
 
-bool InProcessWorkerMessagingProxy::hasPendingActivity() const
+bool ThreadedMessagingProxyBase::hasPendingActivity() const
 {
     DCHECK(isParentContextThread());
     if (m_askedToTerminate)
         return false;
     return m_unconfirmedMessageCount || m_workerGlobalScopeMayHavePendingActivity;
 }
 
-bool InProcessWorkerMessagingProxy::isParentContextThread() const
+bool ThreadedMessagingProxyBase::isParentContextThread() const
 {
     // TODO(nhiroki): Nested worker is not supported yet, so the parent context
     // thread should be equal to the main thread (http://crbug.com/31666).
     DCHECK(getExecutionContext()->isDocument());
     return isMainThread();
 }
 
 } // namespace blink