Worker: Factor out common functions into ThreadedObjectProxyBase

Several functions in InProcessWorkerObjectProxy and ThreadedWorkletObjectProxy
are common. This CL introduces ThreadedMessagingProxyBase class, factors out the
functions into the base class and makes the both proxies inherit it.

[Class relationships after this CL]

On MainThread                   / On WorkerThread
ThreadedMessagingProxyBase      / ThreadedObjectProxyBase
- InProcessWorkerMessagingProxy / - InProcessWorkerObjectProxy
- ThreadedWorkletMessagingProxy / - ThreadedWorkletObjectProxy

BUG=667357

Review-Url: https://codereview.chromium.org/2566623002
Cr-Commit-Position: refs/heads/master@{#437503}

third_party/WebKit/Source/core/workers/BUILD.gn

@@ -35,6 +35,8 @@ blink_core_sources("workers") {
     "SharedWorkerThread.h",
     "ThreadedMessagingProxyBase.cpp",
     "ThreadedMessagingProxyBase.h",
+    "ThreadedObjectProxyBase.cpp",
+    "ThreadedObjectProxyBase.h",
     "ThreadedWorkletGlobalScope.cpp",
     "ThreadedWorkletGlobalScope.h",
     "ThreadedWorkletMessagingProxy.cpp",

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

@@ -97,6 +97,8 @@ void InProcessWorkerObjectProxy::startPendingActivityTimer() {
 }
 
 void InProcessWorkerObjectProxy::countFeature(UseCounter::Feature feature) {
+  // TODO(nhiroki): Move this to ThreadedObjectProxyBase so that
+  // ThreadedWorklets can record API use (https://crbug.com/667357).
   getParentFrameTaskRunners()
       ->get(TaskType::Internal)
       ->postTask(BLINK_FROM_HERE,
@@ -105,6 +107,8 @@ void InProcessWorkerObjectProxy::countFeature(UseCounter::Feature feature) {
 }
 
 void InProcessWorkerObjectProxy::countDeprecation(UseCounter::Feature feature) {
+  // TODO(nhiroki): Move this to ThreadedObjectProxyBase so that
+  // ThreadedWorklets can record API use (https://crbug.com/667357).
   getParentFrameTaskRunners()
       ->get(TaskType::Internal)
       ->postTask(
@@ -126,37 +130,6 @@ void InProcessWorkerObjectProxy::reportException(
                           WTF::passed(location->clone()), exceptionId));
 }
 
-void InProcessWorkerObjectProxy::reportConsoleMessage(
-    MessageSource source,
-    MessageLevel level,
-    const String& message,
-    SourceLocation* location) {
-  getParentFrameTaskRunners()
-      ->get(TaskType::Internal)
-      ->postTask(
-          BLINK_FROM_HERE,
-          crossThreadBind(&InProcessWorkerMessagingProxy::reportConsoleMessage,
-                          m_messagingProxyWeakPtr, source, level, message,
-                          WTF::passed(location->clone())));
-}
-
-void InProcessWorkerObjectProxy::postMessageToPageInspector(
-    const String& message) {
-  // The TaskType of Inspector tasks need to be Unthrottled because they need to
-  // run even on a suspended page.
-  getParentFrameTaskRunners()
-      ->get(TaskType::Unthrottled)
-      ->postTask(BLINK_FROM_HERE,
-                 crossThreadBind(
-                     &InProcessWorkerMessagingProxy::postMessageToPageInspector,
-                     m_messagingProxyWeakPtr, message));
-}
-
-ParentFrameTaskRunners*
-InProcessWorkerObjectProxy::getParentFrameTaskRunners() {
-  return m_parentFrameTaskRunners.get();
-}
-
 void InProcessWorkerObjectProxy::didCreateWorkerGlobalScope(
     WorkerOrWorkletGlobalScope* globalScope) {
   DCHECK(!m_workerGlobalScope);
@@ -169,35 +142,16 @@ void InProcessWorkerObjectProxy::didEvaluateWorkerScript(bool) {
   startPendingActivityTimer();
 }
 
-void InProcessWorkerObjectProxy::didCloseWorkerGlobalScope() {
-  getParentFrameTaskRunners()
-      ->get(TaskType::Internal)
-      ->postTask(
-          BLINK_FROM_HERE,
-          crossThreadBind(&InProcessWorkerMessagingProxy::terminateGlobalScope,
-                          m_messagingProxyWeakPtr));
-}
-
 void InProcessWorkerObjectProxy::willDestroyWorkerGlobalScope() {
   m_timer.reset();
   m_workerGlobalScope = nullptr;
 }
 
-void InProcessWorkerObjectProxy::didTerminateWorkerThread() {
-  // This will terminate the MessagingProxy.
-  getParentFrameTaskRunners()
-      ->get(TaskType::Internal)
-      ->postTask(BLINK_FROM_HERE,
-                 crossThreadBind(
-                     &InProcessWorkerMessagingProxy::workerThreadTerminated,
-                     m_messagingProxyWeakPtr));
-}
-
 InProcessWorkerObjectProxy::InProcessWorkerObjectProxy(
     const WeakPtr<InProcessWorkerMessagingProxy>& messagingProxyWeakPtr,
     ParentFrameTaskRunners* parentFrameTaskRunners)
-    : m_messagingProxyWeakPtr(messagingProxyWeakPtr),
-      m_parentFrameTaskRunners(parentFrameTaskRunners),
+    : ThreadedObjectProxyBase(parentFrameTaskRunners),
+      m_messagingProxyWeakPtr(messagingProxyWeakPtr),
       m_defaultIntervalInSec(kDefaultIntervalInSec),
       m_nextIntervalInSec(kDefaultIntervalInSec),
       m_maxIntervalInSec(kMaxIntervalInSec) {}
@@ -224,4 +178,9 @@ void InProcessWorkerObjectProxy::checkPendingActivity(TimerBase*) {
   startPendingActivityTimer();
 }
 
+WeakPtr<ThreadedMessagingProxyBase>
+InProcessWorkerObjectProxy::messagingProxyWeakPtr() {
+  return m_messagingProxyWeakPtr;
+}
+
 }  // namespace blink

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

@@ -33,6 +33,7 @@
 
 #include "core/CoreExport.h"
 #include "core/dom/MessagePort.h"
+#include "core/workers/ThreadedObjectProxyBase.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "platform/Timer.h"
 #include "platform/heap/Handle.h"
@@ -44,18 +45,16 @@ namespace blink {
 
 class InProcessWorkerMessagingProxy;
 class ParentFrameTaskRunners;
+class ThreadedMessagingProxyBase;
 class WorkerGlobalScope;
 class WorkerOrWorkletGlobalScope;
 
-// A proxy to talk to the parent worker object. This object is created and
-// destroyed on the parent context thread (i.e. usually the main thread), and
-// used on the worker thread for proxying messages to the
-// InProcessWorkerMessagingProxy on the parent context thread.
-// InProcessWorkerMessagingProxy always outlives this proxy.
+// A proxy to talk to the parent worker object. See class comments on
+// ThreadedObjectProxyBase.h for lifetime of this class etc.
 //
 // This also checks pending activities on WorkerGlobalScope and reports a result
 // to the message proxy when an exponential backoff timer is fired.
-class CORE_EXPORT InProcessWorkerObjectProxy : public WorkerReportingProxy {
+class CORE_EXPORT InProcessWorkerObjectProxy : public ThreadedObjectProxyBase {
   USING_FAST_MALLOC(InProcessWorkerObjectProxy);
   WTF_MAKE_NONCOPYABLE(InProcessWorkerObjectProxy);
 
@@ -70,28 +69,22 @@ class CORE_EXPORT InProcessWorkerObjectProxy : public WorkerReportingProxy {
   void confirmMessageFromWorkerObject();
   void startPendingActivityTimer();
 
-  // WorkerReportingProxy overrides.
-  void countFeature(UseCounter::Feature) override;
-  void countDeprecation(UseCounter::Feature) override;
+  // ThreadedMessagingProxyBase overrides.
+  void countFeature(UseCounter::Feature) final;
+  void countDeprecation(UseCounter::Feature) final;
   void reportException(const String& errorMessage,
                        std::unique_ptr<SourceLocation>,
                        int exceptionId) override;
-  void reportConsoleMessage(MessageSource,
-                            MessageLevel,
-                            const String& message,
-                            SourceLocation*) override;
-  void postMessageToPageInspector(const String&) override;
-  ParentFrameTaskRunners* getParentFrameTaskRunners() override;
   void didCreateWorkerGlobalScope(WorkerOrWorkletGlobalScope*) override;
   void didEvaluateWorkerScript(bool success) override;
-  void didCloseWorkerGlobalScope() override;
   void willDestroyWorkerGlobalScope() override;
-  void didTerminateWorkerThread() override;
 
  protected:
   InProcessWorkerObjectProxy(const WeakPtr<InProcessWorkerMessagingProxy>&,
                              ParentFrameTaskRunners*);
 
+  WeakPtr<ThreadedMessagingProxyBase> messagingProxyWeakPtr() final;
+
  private:
   friend class InProcessWorkerMessagingProxyForTest;
 
@@ -102,10 +95,6 @@ class CORE_EXPORT InProcessWorkerObjectProxy : public WorkerReportingProxy {
   // the tasks.
   WeakPtr<InProcessWorkerMessagingProxy> m_messagingProxyWeakPtr;
 
-  // Used to post a task to InProcessWorkerMessagingProxy on the parent context
-  // thread.
-  CrossThreadPersistent<ParentFrameTaskRunners> m_parentFrameTaskRunners;
-
   // Used for checking pending activities on the worker global scope. This is
   // cancelled when the worker global scope is destroyed.
   std::unique_ptr<Timer<InProcessWorkerObjectProxy>> m_timer;

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

+// 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/ThreadedObjectProxyBase.h"
+
+#include "core/dom/ExecutionContext.h"
+#include "core/inspector/ConsoleMessage.h"
+#include "core/workers/ParentFrameTaskRunners.h"
+#include "core/workers/ThreadedMessagingProxyBase.h"
+#include "platform/CrossThreadFunctional.h"
+#include "platform/WebTaskRunner.h"
+#include "wtf/Functional.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
+
+namespace blink {
+
+void ThreadedObjectProxyBase::reportConsoleMessage(MessageSource source,
+                                                   MessageLevel level,
+                                                   const String& message,
+                                                   SourceLocation* location) {
+  getParentFrameTaskRunners()
+      ->get(TaskType::Internal)
+      ->postTask(
+          BLINK_FROM_HERE,
+          crossThreadBind(&ThreadedMessagingProxyBase::reportConsoleMessage,
+                          messagingProxyWeakPtr(), source, level, message,
+                          WTF::passed(location->clone())));
+}
+
+void ThreadedObjectProxyBase::postMessageToPageInspector(
+    const String& message) {
+  // The TaskType of Inspector tasks need to be Unthrottled because they need to
+  // run even on a suspended page.
+  getParentFrameTaskRunners()
+      ->get(TaskType::Unthrottled)
+      ->postTask(BLINK_FROM_HERE,
+                 crossThreadBind(
+                     &ThreadedMessagingProxyBase::postMessageToPageInspector,
+                     messagingProxyWeakPtr(), message));
+}
+
+ParentFrameTaskRunners* ThreadedObjectProxyBase::getParentFrameTaskRunners() {
+  return m_parentFrameTaskRunners.get();
+}
+
+void ThreadedObjectProxyBase::didCloseWorkerGlobalScope() {
+  getParentFrameTaskRunners()
+      ->get(TaskType::Internal)
+      ->postTask(
+          BLINK_FROM_HERE,
+          crossThreadBind(&ThreadedMessagingProxyBase::terminateGlobalScope,
+                          messagingProxyWeakPtr()));
+}
+
+void ThreadedObjectProxyBase::didTerminateWorkerThread() {
+  // This will terminate the MessagingProxy.
+  getParentFrameTaskRunners()
+      ->get(TaskType::Internal)
+      ->postTask(
+          BLINK_FROM_HERE,
+          crossThreadBind(&ThreadedMessagingProxyBase::workerThreadTerminated,
+                          messagingProxyWeakPtr()));
+}
+
+ThreadedObjectProxyBase::ThreadedObjectProxyBase(
+    ParentFrameTaskRunners* parentFrameTaskRunners)
+    : m_parentFrameTaskRunners(parentFrameTaskRunners) {}
+
+}  // namespace blink

third_party/WebKit/Source/core/workers/ThreadedObjectProxyBase.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 ThreadedObjectProxyBase_h
+#define ThreadedObjectProxyBase_h
+
+#include "bindings/core/v8/SourceLocation.h"
+#include "core/CoreExport.h"
+#include "core/dom/MessagePort.h"
+#include "core/workers/WorkerReportingProxy.h"
+
+namespace blink {
+
+class ThreadedMessagingProxyBase;
+
+// A proxy to talk to the parent object. This object is created and destroyed on
+// the main thread, and used on the worker thread for proxying messages to the
+// ThreadedMessagingProxyBase on the main thread. ThreadedMessagingProxyBase
+// always outlives this proxy.
+class CORE_EXPORT ThreadedObjectProxyBase : public WorkerReportingProxy {
+  USING_FAST_MALLOC(ThreadedObjectProxyBase);
+  WTF_MAKE_NONCOPYABLE(ThreadedObjectProxyBase);
+
+ public:
+  ~ThreadedObjectProxyBase() override = default;
+
+  void reportPendingActivity(bool hasPendingActivity);
+
+  // WorkerReportingProxy overrides.
+  void countFeature(UseCounter::Feature) override{};
+  void countDeprecation(UseCounter::Feature) override{};
+  void reportConsoleMessage(MessageSource,
+                            MessageLevel,
+                            const String& message,
+                            SourceLocation*) override;
+  void postMessageToPageInspector(const String&) override;
+  ParentFrameTaskRunners* getParentFrameTaskRunners() override;
+  void didCloseWorkerGlobalScope() override;
+  void didTerminateWorkerThread() override;
+
+ protected:
+  explicit ThreadedObjectProxyBase(ParentFrameTaskRunners*);
+  virtual WeakPtr<ThreadedMessagingProxyBase> messagingProxyWeakPtr() = 0;
+
+ private:
+  // Used to post a task to ThreadedMessagingProxyBase on the parent context
+  // thread.
+  CrossThreadPersistent<ParentFrameTaskRunners> m_parentFrameTaskRunners;
+};
+
+}  // namespace blink
+
+#endif  // ThreadedObjectProxyBase_h

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

@@ -4,13 +4,7 @@
 
 #include "core/workers/ThreadedWorkletObjectProxy.h"
 
-#include "core/dom/ExecutionContext.h"
-#include "core/inspector/ConsoleMessage.h"
-#include "core/workers/ParentFrameTaskRunners.h"
 #include "core/workers/ThreadedWorkletMessagingProxy.h"
-#include "platform/CrossThreadFunctional.h"
-#include "platform/WebTaskRunner.h"
-#include "wtf/Functional.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
@@ -28,73 +22,15 @@ ThreadedWorkletObjectProxy::~ThreadedWorkletObjectProxy() {
   DCHECK(m_messagingProxyWeakPtr);
 }
 
-void ThreadedWorkletObjectProxy::countFeature(UseCounter::Feature) {
-  // TODO(nhiroki): Support UseCounter for ThreadedWorklets. We could do the
-  // same thing with InProcessWorkerObjectProxy here.
-  // (https://crbug.com/376039)
-}
-
-void ThreadedWorkletObjectProxy::countDeprecation(UseCounter::Feature) {
-  // TODO(nhiroki): Support UseCounter for ThreadedWorklets. We could do the
-  // same thing with InProcessWorkerObjectProxy here.
-  // (https://crbug.com/376039)
-}
-
-void ThreadedWorkletObjectProxy::reportConsoleMessage(
-    MessageSource source,
-    MessageLevel level,
-    const String& message,
-    SourceLocation* location) {
-  getParentFrameTaskRunners()
-      ->get(TaskType::Internal)
-      ->postTask(
-          BLINK_FROM_HERE,
-          crossThreadBind(&ThreadedWorkletMessagingProxy::reportConsoleMessage,
-                          m_messagingProxyWeakPtr, source, level, message,
-                          WTF::passed(location->clone())));
-}
-
-void ThreadedWorkletObjectProxy::postMessageToPageInspector(
-    const String& message) {
-  DCHECK(m_messagingProxyWeakPtr->getExecutionContext()->isDocument());
-  // The TaskType of Inspector tasks need to be Unthrottled because they need to
-  // run even on a suspended page.
-  getParentFrameTaskRunners()
-      ->get(TaskType::Unthrottled)
-      ->postTask(BLINK_FROM_HERE,
-                 crossThreadBind(
-                     &ThreadedWorkletMessagingProxy::postMessageToPageInspector,
-                     m_messagingProxyWeakPtr, message));
-}
-
-ParentFrameTaskRunners*
-ThreadedWorkletObjectProxy::getParentFrameTaskRunners() {
-  return m_parentFrameTaskRunners.get();
-}
-
-void ThreadedWorkletObjectProxy::didCloseWorkerGlobalScope() {
-  getParentFrameTaskRunners()
-      ->get(TaskType::Internal)
-      ->postTask(
-          BLINK_FROM_HERE,
-          crossThreadBind(&ThreadedWorkletMessagingProxy::terminateGlobalScope,
-                          m_messagingProxyWeakPtr));
-}
-
-void ThreadedWorkletObjectProxy::didTerminateWorkerThread() {
-  // This will terminate the MessagingProxy.
-  getParentFrameTaskRunners()
-      ->get(TaskType::Internal)
-      ->postTask(BLINK_FROM_HERE,
-                 crossThreadBind(
-                     &ThreadedWorkletMessagingProxy::workerThreadTerminated,
-                     m_messagingProxyWeakPtr));
-}
-
 ThreadedWorkletObjectProxy::ThreadedWorkletObjectProxy(
     const WeakPtr<ThreadedWorkletMessagingProxy>& messagingProxyWeakPtr,
     ParentFrameTaskRunners* parentFrameTaskRunners)
-    : m_messagingProxyWeakPtr(messagingProxyWeakPtr),
-      m_parentFrameTaskRunners(parentFrameTaskRunners) {}
+    : ThreadedObjectProxyBase(parentFrameTaskRunners),
+      m_messagingProxyWeakPtr(messagingProxyWeakPtr) {}
+
+WeakPtr<ThreadedMessagingProxyBase>
+ThreadedWorkletObjectProxy::messagingProxyWeakPtr() {
+  return m_messagingProxyWeakPtr;
+}
 
 }  // namespace blink

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

@@ -8,17 +8,16 @@
 #include "bindings/core/v8/SourceLocation.h"
 #include "core/CoreExport.h"
 #include "core/dom/MessagePort.h"
+#include "core/workers/ThreadedObjectProxyBase.h"
 #include "core/workers/WorkerReportingProxy.h"
 
 namespace blink {
 
 class ThreadedWorkletMessagingProxy;
 
-// A proxy to talk to the parent worklet object. This object is created and
-// destroyed on the main thread, and used on the worklet thread for proxying
-// messages to the ThreadedWorkletMessagingProxy on the main thread.
-// ThreadedWorkletMessagingProxy always outlives this proxy.
-class CORE_EXPORT ThreadedWorkletObjectProxy : public WorkerReportingProxy {
+// A proxy to talk to the parent worker object. See class comments on
+// ThreadedObjectProxyBase.h for lifetime of this class etc.
+class CORE_EXPORT ThreadedWorkletObjectProxy : public ThreadedObjectProxyBase {
   USING_FAST_MALLOC(ThreadedWorkletObjectProxy);
   WTF_MAKE_NONCOPYABLE(ThreadedWorkletObjectProxy);
 
@@ -30,36 +29,24 @@ class CORE_EXPORT ThreadedWorkletObjectProxy : public WorkerReportingProxy {
 
   void reportPendingActivity(bool hasPendingActivity);
 
-  // WorkerReportingProxy overrides.
-  void countFeature(UseCounter::Feature) override;
-  void countDeprecation(UseCounter::Feature) override;
+  // ThreadedObjectProxyBase overrides.
   void reportException(const String& errorMessage,
                        std::unique_ptr<SourceLocation>,
-                       int exceptionId) override {}
-  void reportConsoleMessage(MessageSource,
-                            MessageLevel,
-                            const String& message,
-                            SourceLocation*) override;
-  void postMessageToPageInspector(const String&) override;
-  ParentFrameTaskRunners* getParentFrameTaskRunners() override;
-  void didEvaluateWorkerScript(bool success) override {}
-  void didCloseWorkerGlobalScope() override;
-  void willDestroyWorkerGlobalScope() override {}
-  void didTerminateWorkerThread() override;
+                       int exceptionId) final {}
+  void didEvaluateWorkerScript(bool success) final {}
+  void willDestroyWorkerGlobalScope() final {}
 
  protected:
   ThreadedWorkletObjectProxy(const WeakPtr<ThreadedWorkletMessagingProxy>&,
                              ParentFrameTaskRunners*);
 
+  WeakPtr<ThreadedMessagingProxyBase> messagingProxyWeakPtr() final;
+
  private:
   // No guarantees about the lifetimes of tasks posted by this proxy wrt the
   // ThreadedWorkletMessagingProxy so a weak pointer must be used when posting
   // the tasks.
   WeakPtr<ThreadedWorkletMessagingProxy> m_messagingProxyWeakPtr;
-
-  // Used to post a task to ThreadedWorkletMessagingProxy on the parent context
-  // thread.
-  CrossThreadPersistent<ParentFrameTaskRunners> m_parentFrameTaskRunners;
 };
 
 }  // namespace blink