Revert of Worker: Introduce per-global-scope task scheduler

third_party/WebKit/Source/web/WebSharedWorkerImpl.cpp

 /*
  * 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
  * 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.
  */
 
 #include "web/WebSharedWorkerImpl.h"
 
 #include <memory>
 #include "core/dom/Document.h"
-#include "core/dom/TaskRunnerHelper.h"
 #include "core/events/MessageEvent.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/ThreadableLoadingContext.h"
 #include "core/probe/CoreProbes.h"
 #include "core/workers/ParentFrameTaskRunners.h"
 #include "core/workers/SharedWorkerGlobalScope.h"
 #include "core/workers/SharedWorkerThread.h"
 #include "core/workers/WorkerClients.h"
@@ skipping 202 matching lines @@
     std::unique_ptr<WTF::CrossThreadClosure> task) {
   DCHECK(worker_thread_->IsCurrentThread());
   parent_frame_task_runners_->Get(TaskType::kNetworking)
       ->PostTask(FROM_HERE, std::move(task));
 }
 
 void WebSharedWorkerImpl::PostTaskToWorkerGlobalScope(
     const WebTraceLocation& location,
     std::unique_ptr<WTF::CrossThreadClosure> task) {
   DCHECK(IsMainThread());
-  TaskRunnerHelper::Get(TaskType::kNetworking, GetWorkerThread())
-      ->PostTask(location, std::move(task));
+  worker_thread_->PostTask(location, std::move(task));
 }
 
 ThreadableLoadingContext* WebSharedWorkerImpl::GetThreadableLoadingContext() {
   if (!loading_context_) {
     loading_context_ =
         ThreadableLoadingContext::Create(*ToDocument(loading_document_.Get()));
   }
   return loading_context_;
 }
 
 void WebSharedWorkerImpl::Connect(
     std::unique_ptr<WebMessagePortChannel> web_channel) {
   DCHECK(IsMainThread());
-  TaskRunnerHelper::Get(TaskType::kDOMManipulation, GetWorkerThread())
-      ->PostTask(
-          BLINK_FROM_HERE,
-          CrossThreadBind(&WebSharedWorkerImpl::ConnectTaskOnWorkerThread,
-                          WTF::CrossThreadUnretained(this),
-                          WTF::Passed(std::move(web_channel))));
+  GetWorkerThread()->PostTask(
+      BLINK_FROM_HERE,
+      CrossThreadBind(&WebSharedWorkerImpl::ConnectTaskOnWorkerThread,
+                      WTF::CrossThreadUnretained(this),
+                      WTF::Passed(std::move(web_channel))));
 }
 
 void WebSharedWorkerImpl::ConnectTaskOnWorkerThread(
     std::unique_ptr<WebMessagePortChannel> channel) {
   // Wrap the passed-in channel in a MessagePort, and send it off via a connect
   // event.
   DCHECK(worker_thread_->IsCurrentThread());
   WorkerGlobalScope* worker_global_scope =
       ToWorkerGlobalScope(worker_thread_->GlobalScope());
   MessagePort* port = MessagePort::Create(*worker_global_scope);
@@ skipping 135 matching lines @@
   if (devtools_agent)
     devtools_agent->DispatchOnInspectorBackend(session_id, call_id, method,
                                                message);
 }
 
 WebSharedWorker* WebSharedWorker::Create(WebSharedWorkerClient* client) {
   return new WebSharedWorkerImpl(client);
 }
 
 }  // namespace blink