Worker: Remove cross-thread PostTask functions from WorkerLoaderProxy

third_party/WebKit/Source/modules/websockets/WorkerWebSocketChannel.cpp

 /*
  * Copyright (C) 2011, 2012 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 144 matching lines @@
   bridge_.Clear();
 }
 
 DEFINE_TRACE(WorkerWebSocketChannel) {
   visitor->Trace(bridge_);
   WebSocketChannel::Trace(visitor);
 }
 
 Peer::Peer(Bridge* bridge,
            PassRefPtr<WorkerLoaderProxy> loader_proxy,
+           RefPtr<WebTaskRunner> worker_networking_task_runner,
            WorkerThreadLifecycleContext* worker_thread_lifecycle_context)
     : WorkerThreadLifecycleObserver(worker_thread_lifecycle_context),
       bridge_(bridge),
       loader_proxy_(std::move(loader_proxy)),
+      worker_networking_task_runner_(std::move(worker_networking_task_runner)),
       main_web_socket_channel_(nullptr) {
   DCHECK(IsMainThread());
 }
 
 Peer::~Peer() {
   DCHECK(IsMainThread());
 }
 
 bool Peer::Initialize(std::unique_ptr<SourceLocation> location,
                       ThreadableLoadingContext* loading_context) {
@@ skipping 56 matching lines @@
 
 static void WorkerGlobalScopeDidConnect(Bridge* bridge,
                                         const String& subprotocol,
                                         const String& extensions) {
   if (bridge && bridge->Client())
     bridge->Client()->DidConnect(subprotocol, extensions);
 }
 
 void Peer::DidConnect(const String& subprotocol, const String& extensions) {
   DCHECK(IsMainThread());
-  loader_proxy_->PostTaskToWorkerGlobalScope(
+  worker_networking_task_runner_->PostTask(
       BLINK_FROM_HERE, CrossThreadBind(&WorkerGlobalScopeDidConnect, bridge_,
                                        subprotocol, extensions));
 }
 
 static void WorkerGlobalScopeDidReceiveTextMessage(Bridge* bridge,
                                                    const String& payload) {
   if (bridge && bridge->Client())
     bridge->Client()->DidReceiveTextMessage(payload);
 }
 
 void Peer::DidReceiveTextMessage(const String& payload) {
   DCHECK(IsMainThread());
-  loader_proxy_->PostTaskToWorkerGlobalScope(
+  worker_networking_task_runner_->PostTask(
       BLINK_FROM_HERE, CrossThreadBind(&WorkerGlobalScopeDidReceiveTextMessage,
                                        bridge_, payload));
 }
 
 static void WorkerGlobalScopeDidReceiveBinaryMessage(
     Bridge* bridge,
     std::unique_ptr<Vector<char>> payload) {
   if (bridge && bridge->Client())
     bridge->Client()->DidReceiveBinaryMessage(std::move(payload));
 }
 
 void Peer::DidReceiveBinaryMessage(std::unique_ptr<Vector<char>> payload) {
   DCHECK(IsMainThread());
-  loader_proxy_->PostTaskToWorkerGlobalScope(
+  worker_networking_task_runner_->PostTask(
       BLINK_FROM_HERE,
       CrossThreadBind(&WorkerGlobalScopeDidReceiveBinaryMessage, bridge_,
                       WTF::Passed(std::move(payload))));
 }
 
 static void WorkerGlobalScopeDidConsumeBufferedAmount(Bridge* bridge,
                                                       uint64_t consumed) {
   if (bridge && bridge->Client())
     bridge->Client()->DidConsumeBufferedAmount(consumed);
 }
 
 void Peer::DidConsumeBufferedAmount(uint64_t consumed) {
   DCHECK(IsMainThread());
-  loader_proxy_->PostTaskToWorkerGlobalScope(
+  worker_networking_task_runner_->PostTask(
       BLINK_FROM_HERE,
       CrossThreadBind(&WorkerGlobalScopeDidConsumeBufferedAmount, bridge_,
                       consumed));
 }
 
 static void WorkerGlobalScopeDidStartClosingHandshake(Bridge* bridge) {
   if (bridge && bridge->Client())
     bridge->Client()->DidStartClosingHandshake();
 }
 
 void Peer::DidStartClosingHandshake() {
   DCHECK(IsMainThread());
-  loader_proxy_->PostTaskToWorkerGlobalScope(
+  worker_networking_task_runner_->PostTask(
       BLINK_FROM_HERE,
       CrossThreadBind(&WorkerGlobalScopeDidStartClosingHandshake, bridge_));
 }
 
 static void WorkerGlobalScopeDidClose(
     Bridge* bridge,
     WebSocketChannelClient::ClosingHandshakeCompletionStatus
         closing_handshake_completion,
     unsigned short code,
     const String& reason) {
   if (bridge && bridge->Client())
     bridge->Client()->DidClose(closing_handshake_completion, code, reason);
 }
 
 void Peer::DidClose(
     ClosingHandshakeCompletionStatus closing_handshake_completion,
     unsigned short code,
     const String& reason) {
   DCHECK(IsMainThread());
   if (main_web_socket_channel_) {
     main_web_socket_channel_->Disconnect();
     main_web_socket_channel_ = nullptr;
   }
-  loader_proxy_->PostTaskToWorkerGlobalScope(
+  worker_networking_task_runner_->PostTask(
       BLINK_FROM_HERE,
       CrossThreadBind(&WorkerGlobalScopeDidClose, bridge_,
                       closing_handshake_completion, code, reason));
 }
 
 static void WorkerGlobalScopeDidError(Bridge* bridge) {
   if (bridge && bridge->Client())
     bridge->Client()->DidError();
 }
 
 void Peer::DidError() {
   DCHECK(IsMainThread());
-  loader_proxy_->PostTaskToWorkerGlobalScope(
+  worker_networking_task_runner_->PostTask(
       BLINK_FROM_HERE, CrossThreadBind(&WorkerGlobalScopeDidError, bridge_));
 }
 
 void Peer::ContextDestroyed(WorkerThreadLifecycleContext*) {
   DCHECK(IsMainThread());
   if (main_web_socket_channel_) {
     main_web_socket_channel_->Disconnect();
     main_web_socket_channel_ = nullptr;
   }
   bridge_ = nullptr;
 }
 
 DEFINE_TRACE(Peer) {
   visitor->Trace(main_web_socket_channel_);
   WebSocketChannelClient::Trace(visitor);
   WorkerThreadLifecycleObserver::Trace(visitor);
 }
 
 Bridge::Bridge(WebSocketChannelClient* client,
                WorkerGlobalScope& worker_global_scope)
     : client_(client),
       worker_global_scope_(worker_global_scope),
-      loader_proxy_(worker_global_scope_->GetThread()->GetWorkerLoaderProxy()) {
-}
+      loader_proxy_(worker_global_scope_->GetThread()->GetWorkerLoaderProxy()),
+      parent_frame_task_runners_(
+          worker_global_scope_->GetThread()->GetParentFrameTaskRunners()) {}
 
 Bridge::~Bridge() {
   DCHECK(!peer_);
 }
 
 void Bridge::ConnectOnMainThread(
     std::unique_ptr<SourceLocation> location,
     RefPtr<WorkerLoaderProxy> loader_proxy,
+    RefPtr<WebTaskRunner> worker_networking_task_runner,
     WorkerThreadLifecycleContext* worker_thread_lifecycle_context,
     const KURL& url,
     const String& protocol,
     WebSocketChannelSyncHelper* sync_helper) {
   DCHECK(IsMainThread());
   DCHECK(!peer_);
   ThreadableLoadingContext* loading_context =
       loader_proxy->GetThreadableLoadingContext();
   if (!loading_context)
     return;
-  Peer* peer = new Peer(this, loader_proxy_, worker_thread_lifecycle_context);
+  Peer* peer =
+      new Peer(this, loader_proxy_, std::move(worker_networking_task_runner),
+               worker_thread_lifecycle_context);
   if (peer->Initialize(std::move(location), loading_context)) {
     peer_ = peer;
     sync_helper->SetConnectRequestResult(peer_->Connect(url, protocol));
   }
   sync_helper->SignalWorkerThread();
 }
 
 bool Bridge::Connect(std::unique_ptr<SourceLocation> location,
                      const KURL& url,
                      const String& protocol) {
   // Wait for completion of the task on the main thread because the mixed
   // content check must synchronously be conducted.
   WebSocketChannelSyncHelper sync_helper;
-  loader_proxy_->PostTaskToLoader(
-      BLINK_FROM_HERE,
-      CrossThreadBind(
-          &Bridge::ConnectOnMainThread, WrapCrossThreadPersistent(this),
-          WTF::Passed(location->Clone()), loader_proxy_,
-          WrapCrossThreadPersistent(worker_global_scope_->GetThread()
-                                        ->GetWorkerThreadLifecycleContext()),
-          url, protocol, CrossThreadUnretained(&sync_helper)));
+  RefPtr<WebTaskRunner> worker_networking_task_runner =
+      TaskRunnerHelper::Get(TaskType::kNetworking, worker_global_scope_.Get());
+  parent_frame_task_runners_->Get(TaskType::kNetworking)
+      ->PostTask(
+          BLINK_FROM_HERE,
+          CrossThreadBind(&Bridge::ConnectOnMainThread,
+                          WrapCrossThreadPersistent(this),
+                          WTF::Passed(location->Clone()), loader_proxy_,
+                          std::move(worker_networking_task_runner),
+                          WrapCrossThreadPersistent(
+                              worker_global_scope_->GetThread()
+                                  ->GetWorkerThreadLifecycleContext()),
+                          url, protocol, CrossThreadUnretained(&sync_helper)));
   sync_helper.Wait();
   return sync_helper.ConnectRequestResult();
 }
 
 void Bridge::Send(const CString& message) {
   DCHECK(peer_);
   std::unique_ptr<Vector<char>> data =
       WTF::WrapUnique(new Vector<char>(message.length()));
   if (message.length())
     memcpy(data->data(), static_cast<const char*>(message.data()),
            message.length());
 
-  loader_proxy_->PostTaskToLoader(
-      BLINK_FROM_HERE, CrossThreadBind(&Peer::SendTextAsCharVector, peer_,
-                                       WTF::Passed(std::move(data))));
+  parent_frame_task_runners_->Get(TaskType::kNetworking)
+      ->PostTask(BLINK_FROM_HERE,
+                 CrossThreadBind(&Peer::SendTextAsCharVector, peer_,
+                                 WTF::Passed(std::move(data))));
 }
 
 void Bridge::Send(const DOMArrayBuffer& binary_data,
                   unsigned byte_offset,
                   unsigned byte_length) {
   DCHECK(peer_);
   // ArrayBuffer isn't thread-safe, hence the content of ArrayBuffer is copied
   // into Vector<char>.
   std::unique_ptr<Vector<char>> data =
       WTF::MakeUnique<Vector<char>>(byte_length);
   if (binary_data.ByteLength())
     memcpy(data->data(),
            static_cast<const char*>(binary_data.Data()) + byte_offset,
            byte_length);
 
-  loader_proxy_->PostTaskToLoader(
-      BLINK_FROM_HERE, CrossThreadBind(&Peer::SendBinaryAsCharVector, peer_,
-                                       WTF::Passed(std::move(data))));
+  parent_frame_task_runners_->Get(TaskType::kNetworking)
+      ->PostTask(BLINK_FROM_HERE,
+                 CrossThreadBind(&Peer::SendBinaryAsCharVector, peer_,
+                                 WTF::Passed(std::move(data))));
 }
 
 void Bridge::Send(PassRefPtr<BlobDataHandle> data) {
   DCHECK(peer_);
-  loader_proxy_->PostTaskToLoader(
-      BLINK_FROM_HERE,
-      CrossThreadBind(&Peer::SendBlob, peer_, std::move(data)));
+  parent_frame_task_runners_->Get(TaskType::kNetworking)
+      ->PostTask(BLINK_FROM_HERE,
+                 CrossThreadBind(&Peer::SendBlob, peer_, std::move(data)));
 }
 
 void Bridge::Close(int code, const String& reason) {
   DCHECK(peer_);
-  loader_proxy_->PostTaskToLoader(
-      BLINK_FROM_HERE, CrossThreadBind(&Peer::Close, peer_, code, reason));
+  parent_frame_task_runners_->Get(TaskType::kNetworking)
+      ->PostTask(BLINK_FROM_HERE,
+                 CrossThreadBind(&Peer::Close, peer_, code, reason));
 }
 
 void Bridge::Fail(const String& reason,
                   MessageLevel level,
                   std::unique_ptr<SourceLocation> location) {
   DCHECK(peer_);
-  loader_proxy_->PostTaskToLoader(
-      BLINK_FROM_HERE, CrossThreadBind(&Peer::Fail, peer_, reason, level,
-                                       WTF::Passed(location->Clone())));
+  parent_frame_task_runners_->Get(TaskType::kNetworking)
+      ->PostTask(BLINK_FROM_HERE,
+                 CrossThreadBind(&Peer::Fail, peer_, reason, level,
+                                 WTF::Passed(location->Clone())));
 }
 
 void Bridge::Disconnect() {
   if (!peer_)
     return;
 
-  loader_proxy_->PostTaskToLoader(BLINK_FROM_HERE,
-                                  CrossThreadBind(&Peer::Disconnect, peer_));
+  parent_frame_task_runners_->Get(TaskType::kNetworking)
+      ->PostTask(BLINK_FROM_HERE, CrossThreadBind(&Peer::Disconnect, peer_));
 
   client_ = nullptr;
   peer_ = nullptr;
   worker_global_scope_.Clear();
 }
 
 DEFINE_TRACE(Bridge) {
   visitor->Trace(client_);
   visitor->Trace(worker_global_scope_);
 }
 
 }  // namespace blink