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

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

-/*
- * Copyright (C) 2008 Apple 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.
 
-#ifndef InProcessWorkerMessagingProxy_h
-#define InProcessWorkerMessagingProxy_h
+#ifndef ThreadedMessagingProxyBase_h
+#define ThreadedMessagingProxyBase_h
 
 #include "core/CoreExport.h"
-#include "core/dom/ExecutionContext.h"
-#include "core/workers/InProcessWorkerGlobalScopeProxy.h"
+#include "core/inspector/ConsoleTypes.h"
+#include "core/workers/ThreadedGlobalScopeProxy.h"
 #include "core/workers/WorkerLoaderProxy.h"
-#include "platform/heap/Handle.h"
 #include "wtf/Forward.h"
-#include "wtf/Noncopyable.h"
-#include "wtf/PassRefPtr.h"
-#include "wtf/RefPtr.h"
-#include "wtf/Vector.h"
-#include <memory>
 
 namespace blink {
 
 class ExecutionContext;
-class InProcessWorkerBase;
-class InProcessWorkerObjectProxy;
 class ParentFrameTaskRunners;
-class WorkerClients;
 class WorkerInspectorProxy;
+class WorkerLoaderProxy;
 class WorkerThread;
+class WorkerThreadStartupData;
 
-// TODO(nhiroki): "MessagingProxy" is not well-defined term among worker
-// components. Probably we should rename this to something more suitable.
-// (http://crbug.com/603785)
-class CORE_EXPORT InProcessWorkerMessagingProxy
-    : public InProcessWorkerGlobalScopeProxy
+class CORE_EXPORT ThreadedMessagingProxyBase
+    : public ThreadedGlobalScopeProxy
     , private WorkerLoaderProxyProvider {
-    WTF_MAKE_NONCOPYABLE(InProcessWorkerMessagingProxy);
 public:
-    // Implementations of InProcessWorkerGlobalScopeProxy.
-    // (Only use these methods in the parent context thread.)
-    void startWorkerGlobalScope(const KURL& scriptURL, const String& userAgent, const String& sourceCode) override;
-    void terminateWorkerGlobalScope() override;
-    void postMessageToWorkerGlobalScope(PassRefPtr<SerializedScriptValue>, std::unique_ptr<MessagePortChannelArray>) override;
+    void terminateGlobalScope() override;
     bool hasPendingActivity() const final;
-    void workerObjectDestroyed() override;
+    void parentObjectDestroyed() override;
 
-    // These methods come from worker context thread via
-    // InProcessWorkerObjectProxy and are called on the parent context thread.
-    void postMessageToWorkerObject(PassRefPtr<SerializedScriptValue>, std::unique_ptr<MessagePortChannelArray>);
-    void dispatchErrorEvent(const String& errorMessage, std::unique_ptr<SourceLocation>, int exceptionId);
     void reportConsoleMessage(MessageSource, MessageLevel, const String& message, std::unique_ptr<SourceLocation>);
     void postMessageToPageInspector(const String&);
 
     // 'virtual' for testing.
     virtual void confirmMessageFromWorkerObject();
     virtual void pendingActivityFinished();
     virtual void workerThreadTerminated();
 
     void workerThreadCreated();
 
     ExecutionContext* getExecutionContext() const { return m_executionContext.get(); }
 
     ParentFrameTaskRunners* getParentFrameTaskRunners() { return m_parentFrameTaskRunners.get(); }
 
     // Number of live messaging proxies, used by leak detection.
     static int proxyCount();
 
 protected:
-    InProcessWorkerMessagingProxy(InProcessWorkerBase*, WorkerClients*);
-    ~InProcessWorkerMessagingProxy() override;
+    ThreadedMessagingProxyBase(ExecutionContext*);
+    ~ThreadedMessagingProxyBase() override;
 
+    void initializeWorkerThread(std::unique_ptr<WorkerThreadStartupData>);
     virtual std::unique_ptr<WorkerThread> createWorkerThread(double originTime) = 0;
 
+    WorkerThread* workerThread() const { return m_workerThread.get(); }
+
+    void postOrQueueTaskToWorkerGlobalScope(std::unique_ptr<ExecutionContextTask>);
+    bool askedToTerminate() const { return m_askedToTerminate; }
+
     PassRefPtr<WorkerLoaderProxy> loaderProxy() { return m_loaderProxy; }
-    InProcessWorkerObjectProxy& workerObjectProxy() { return *m_workerObjectProxy.get(); }
+    WorkerInspectorProxy* workerInspectorProxy() { return m_workerInspectorProxy.get(); }
 
-private:
-    friend class InProcessWorkerMessagingProxyForTest;
-    InProcessWorkerMessagingProxy(ExecutionContext*, InProcessWorkerBase*, WorkerClients*);
-
-    void workerObjectDestroyedInternal();
+    // Returns true if this is called on the parent context thread.
+    bool isParentContextThread() const;
 
     // WorkerLoaderProxyProvider
     // These methods are called on different threads to schedule loading
     // requests and to send callbacks back to WorkerGlobalScope.
     void postTaskToLoader(const WebTraceLocation&, std::unique_ptr<ExecutionContextTask>) override;
     void postTaskToWorkerGlobalScope(const WebTraceLocation&, std::unique_ptr<ExecutionContextTask>) override;
-
-    // Returns true if this is called on the parent context thread.
-    bool isParentContextThread() const;
+private:
+    friend class InProcessWorkerMessagingProxyForTest;
+    void parentObjectDestroyedInternal();
 
     Persistent<ExecutionContext> m_executionContext;
-    std::unique_ptr<InProcessWorkerObjectProxy> m_workerObjectProxy;
-    WeakPersistent<InProcessWorkerBase> m_workerObject;
     bool m_mayBeDestroyed;
     std::unique_ptr<WorkerThread> m_workerThread;
 
     // Unconfirmed messages from the parent context thread to the worker thread.
     unsigned m_unconfirmedMessageCount;
 
     bool m_workerGlobalScopeMayHavePendingActivity;
     bool m_askedToTerminate;
 
     // Tasks are queued here until there's a thread object created.
     Vector<std::unique_ptr<ExecutionContextTask>> m_queuedEarlyTasks;
 
     Persistent<WorkerInspectorProxy> m_workerInspectorProxy;
 
-    Persistent<WorkerClients> m_workerClients;
-
     Persistent<ParentFrameTaskRunners> m_parentFrameTaskRunners;
 
     RefPtr<WorkerLoaderProxy> m_loaderProxy;
 };
 
 } // namespace blink
 
-#endif // InProcessWorkerMessagingProxy_h
+#endif // ThreadedMessagingProxyBase_h