(WIP) Worker: Merge ParentFrameTaskRunners into TaskRunnerHelper

third_party/WebKit/Source/core/workers/ThreadedMessagingProxyBase.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/ThreadedMessagingProxyBase.h"
 
 #include "bindings/core/v8/SourceLocation.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/frame/Deprecation.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/workers/WorkerInspectorProxy.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 namespace {
 
 static int s_liveMessagingProxyCount = 0;
 
 }  // namespace
 
 ThreadedMessagingProxyBase::ThreadedMessagingProxyBase(
     ExecutionContext* executionContext)
     : m_executionContext(executionContext),
       m_workerInspectorProxy(WorkerInspectorProxy::create()),
-      m_parentFrameTaskRunners(ParentFrameTaskRunners::create(
-          toDocument(m_executionContext.get())->frame())),
       m_mayBeDestroyed(false),
       m_askedToTerminate(false) {
   DCHECK(isParentContextThread());
   s_liveMessagingProxyCount++;
 }
 
 ThreadedMessagingProxyBase::~ThreadedMessagingProxyBase() {
   DCHECK(isParentContextThread());
   if (m_loaderProxy)
     m_loaderProxy->detachProvider(this);
   s_liveMessagingProxyCount--;
 }
 
 int ThreadedMessagingProxyBase::proxyCount() {
   DCHECK(isMainThread());
   return s_liveMessagingProxyCount;
 }
 
 void ThreadedMessagingProxyBase::initializeWorkerThread(
     std::unique_ptr<WorkerThreadStartupData> startupData) {
   DCHECK(isParentContextThread());
 
   Document* document = toDocument(getExecutionContext());
   double originTime =
       document->loader() ? document->loader()->timing().referenceMonotonicTime()
                          : monotonicallyIncreasingTime();
 
   m_loaderProxy = WorkerLoaderProxy::create(this);
   m_workerThread = createWorkerThread(originTime);
-  m_workerThread->start(std::move(startupData), getParentFrameTaskRunners());
+  m_workerThread->start(std::move(startupData),
+                        FrameTaskRunnersHolder::create(document->frame()));
   workerThreadCreated();
 }
 
 void ThreadedMessagingProxyBase::postTaskToWorkerGlobalScope(
     const WebTraceLocation& location,
     std::unique_ptr<WTF::CrossThreadClosure> task) {
   if (m_askedToTerminate)
     return;
 
   DCHECK(m_workerThread);
   m_workerThread->postTask(location, std::move(task));
 }
 
 void ThreadedMessagingProxyBase::postTaskToLoader(
     const WebTraceLocation& location,
     std::unique_ptr<WTF::CrossThreadClosure> task) {
-  m_parentFrameTaskRunners->get(TaskType::Networking)
+  FrameTaskRunnerHelper::get(TaskType::Networking, m_workerThread.get())
       ->postTask(BLINK_FROM_HERE, std::move(task));
 }
 
 ExecutionContext* ThreadedMessagingProxyBase::getLoaderExecutionContext() {
   DCHECK(isParentContextThread());
   return getExecutionContext();
 }
 
 void ThreadedMessagingProxyBase::countFeature(UseCounter::Feature feature) {
   DCHECK(isParentContextThread());
@@ skipping 19 matching lines @@
 }
 
 void ThreadedMessagingProxyBase::workerThreadCreated() {
   DCHECK(isParentContextThread());
   DCHECK(!m_askedToTerminate);
   DCHECK(m_workerThread);
 }
 
 void ThreadedMessagingProxyBase::parentObjectDestroyed() {
   DCHECK(isParentContextThread());
-
-  getParentFrameTaskRunners()
-      ->get(TaskType::UnspecedTimer)
+  FrameTaskRunnerHelper::get(TaskType::UnspecedTimer, m_workerThread.get())
       ->postTask(
           BLINK_FROM_HERE,
           WTF::bind(&ThreadedMessagingProxyBase::parentObjectDestroyedInternal,
                     WTF::unretained(this)));
 }
 
 void ThreadedMessagingProxyBase::parentObjectDestroyedInternal() {
   DCHECK(isParentContextThread());
   m_mayBeDestroyed = true;
   if (m_workerThread)
@@ skipping 36 matching lines @@
 }
 
 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(m_executionContext->isDocument());
   return isMainThread();
 }
 
 }  // namespace blink