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

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

Index: third_party/WebKit/Source/core/workers/ThreadedMessagingProxyBase.h
diff --git a/third_party/WebKit/Source/core/workers/InProcessWorkerMessagingProxy.h b/third_party/WebKit/Source/core/workers/ThreadedMessagingProxyBase.h
similarity index 33%
copy from third_party/WebKit/Source/core/workers/InProcessWorkerMessagingProxy.h
copy to third_party/WebKit/Source/core/workers/ThreadedMessagingProxyBase.h
index 65a768ec6f97d9505a6f661307028ffe5a849374..04937406aa190ea2d55138fec7381838c7ee8933 100644
--- a/third_party/WebKit/Source/core/workers/InProcessWorkerMessagingProxy.h
+++ b/third_party/WebKit/Source/core/workers/ThreadedMessagingProxyBase.h
@@ -1,82 +1,40 @@
-/*
- * 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.
- *
- */
-
-#ifndef InProcessWorkerMessagingProxy_h
-#define InProcessWorkerMessagingProxy_h
+// 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 ThreadedMessagingProxyBase_h
+#define ThreadedMessagingProxyBase_h
 
 #include "core/CoreExport.h"
-#include "core/dom/ExecutionContext.h"
-#include "core/dom/MessagePort.h"
 #include "core/inspector/ConsoleTypes.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 : private WorkerLoaderProxyProvider {
-    WTF_MAKE_NONCOPYABLE(InProcessWorkerMessagingProxy);
+class CORE_EXPORT ThreadedMessagingProxyBase : private WorkerLoaderProxyProvider {
 public:
-    // These methods should only be used on the parent context thread.
-    void startWorkerGlobalScope(const KURL& scriptURL, const String& userAgent, const String& sourceCode);
-    void terminateWorkerGlobalScope();
-    void postMessageToWorkerGlobalScope(PassRefPtr<SerializedScriptValue>, std::unique_ptr<MessagePortChannelArray>);
-    bool hasPendingActivity() const;
-    void workerObjectDestroyed();
-
-    // 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 terminateGlobalScope();
+
+    virtual void workerThreadCreated();
+
+    // This method should be called in the destructor of the object which
+    // initially created it. This object could either be a Worker or a Worklet.
+    virtual void parentObjectDestroyed();
+
     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(); }
@@ -85,53 +43,43 @@ public:
     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;
 
-    PassRefPtr<WorkerLoaderProxy> loaderProxy() { return m_loaderProxy; }
-    InProcessWorkerObjectProxy& workerObjectProxy() { return *m_workerObjectProxy.get(); }
+    WorkerThread* workerThread() const { return m_workerThread.get(); }
 
-private:
-    friend class InProcessWorkerMessagingProxyForTest;
-    InProcessWorkerMessagingProxy(ExecutionContext*, InProcessWorkerBase*, WorkerClients*);
+    bool askedToTerminate() const { return m_askedToTerminate; }
 
-    void workerObjectDestroyedInternal();
+    PassRefPtr<WorkerLoaderProxy> loaderProxy() { return m_loaderProxy; }
+    WorkerInspectorProxy* workerInspectorProxy() { return m_workerInspectorProxy.get(); }
+
+    // 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;
 
+    std::unique_ptr<WorkerThread> m_workerThread;
+
     RefPtr<WorkerLoaderProxy> m_loaderProxy;
+
+    bool m_mayBeDestroyed;
+    bool m_askedToTerminate;
 };
 
 } // namespace blink
 
-#endif // InProcessWorkerMessagingProxy_h
+#endif // ThreadedMessagingProxyBase_h