Worker: Remove WorkerLoaderProxy for clean-up

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 18 matching lines @@
  */
 
 #include "modules/websockets/WorkerWebSocketChannel.h"
 
 #include <memory>
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/fileapi/Blob.h"
 #include "core/loader/ThreadableLoadingContext.h"
 #include "core/workers/WorkerGlobalScope.h"
-#include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "modules/websockets/DocumentWebSocketChannel.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/Functional.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/text/CString.h"
 #include "platform/wtf/text/WTFString.h"
@@ skipping 104 matching lines @@
   bridge_->Disconnect();
   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,
@@ skipping 171 matching lines @@
 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()),
       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,
+    ThreadableLoadingContext* loading_context,
     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_, std::move(worker_networking_task_runner),
-               worker_thread_lifecycle_context);
+  Peer* peer = new Peer(this, 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) {
+  DCHECK(worker_global_scope_->IsContextThread());
   // Wait for completion of the task on the main thread because the mixed
   // content check must synchronously be conducted.
   WebSocketChannelSyncHelper sync_helper;
   RefPtr<WebTaskRunner> worker_networking_task_runner =
       TaskRunnerHelper::Get(TaskType::kNetworking, worker_global_scope_.Get());
+  WorkerThread* worker_thread = worker_global_scope_->GetThread();
   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)));
+          CrossThreadBind(
+              &Bridge::ConnectOnMainThread, WrapCrossThreadPersistent(this),
+              WTF::Passed(location->Clone()),
+              WrapCrossThreadPersistent(worker_thread->GetLoadingContext()),
+              std::move(worker_networking_task_runner),
+              WrapCrossThreadPersistent(
+                  worker_thread->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()),
@@ skipping 59 matching lines @@
   peer_ = nullptr;
   worker_global_scope_.Clear();
 }
 
 DEFINE_TRACE(Bridge) {
   visitor->Trace(client_);
   visitor->Trace(worker_global_scope_);
 }
 
 }  // namespace blink