Worker: Remove WorkerLoaderProxy for clean-up

third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp

Index: third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
diff --git a/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp b/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
index a63be36a66b406f015433902e069001c006419d0..be1334598daeab03688aa2c5edc120aa17911bd4 100644
--- a/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
+++ b/third_party/WebKit/Source/core/loader/WorkerThreadableLoader.cpp
@@ -35,7 +35,6 @@
 #include "core/loader/ThreadableLoadingContext.h"
 #include "core/timing/WorkerGlobalScopePerformance.h"
 #include "core/workers/WorkerGlobalScope.h"
-#include "core/workers/WorkerLoaderProxy.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/heap/SafePoint.h"
 #include "platform/loader/fetch/ResourceError.h"
@@ -197,8 +196,6 @@ WorkerThreadableLoader::WorkerThreadableLoader(
     const ResourceLoaderOptions& resource_loader_options,
     BlockingBehavior blocking_behavior)
     : worker_global_scope_(&worker_global_scope),
-      worker_loader_proxy_(
-          worker_global_scope.GetThread()->GetWorkerLoaderProxy()),
       parent_frame_task_runners_(
           worker_global_scope.GetThread()->GetParentFrameTaskRunners()),
       client_(client),
@@ -225,6 +222,7 @@ WorkerThreadableLoader::~WorkerThreadableLoader() {
 }
 
 void WorkerThreadableLoader::Start(const ResourceRequest& original_request) {
+  DCHECK(worker_global_scope_->IsContextThread());
   ResourceRequest request(original_request);
   if (!request.DidSetHTTPReferrer()) {
     request.SetHTTPReferrer(SecurityPolicy::GenerateReferrer(
@@ -232,24 +230,25 @@ void WorkerThreadableLoader::Start(const ResourceRequest& original_request) {
         worker_global_scope_->OutgoingReferrer()));
   }
 
-  DCHECK(!IsMainThread());
   RefPtr<WaitableEventWithTasks> event_with_tasks;
   if (blocking_behavior_ == kLoadSynchronously)
     event_with_tasks = WaitableEventWithTasks::Create();
 
+  WorkerThread* worker_thread = worker_global_scope_->GetThread();
   RefPtr<WebTaskRunner> worker_loading_task_runner = TaskRunnerHelper::Get(
       TaskType::kUnspecedLoading, worker_global_scope_.Get());
   parent_frame_task_runners_->Get(TaskType::kUnspecedLoading)
       ->PostTask(
           BLINK_FROM_HERE,
-          CrossThreadBind(&MainThreadLoaderHolder::CreateAndStart,
-                          WrapCrossThreadPersistent(this), worker_loader_proxy_,
-                          std::move(worker_loading_task_runner),
-                          WrapCrossThreadPersistent(
-                              worker_global_scope_->GetThread()
-                                  ->GetWorkerThreadLifecycleContext()),
-                          request, threadable_loader_options_,
-                          resource_loader_options_, event_with_tasks));
+          CrossThreadBind(
+              &MainThreadLoaderHolder::CreateAndStart,
+              WrapCrossThreadPersistent(this),
+              WrapCrossThreadPersistent(worker_thread->GetLoadingContext()),
+              std::move(worker_loading_task_runner),
+              WrapCrossThreadPersistent(
+                  worker_thread->GetWorkerThreadLifecycleContext()),
+              request, threadable_loader_options_, resource_loader_options_,
+              event_with_tasks));
 
   if (blocking_behavior_ == kLoadAsynchronously)
     return;
@@ -437,7 +436,7 @@ DEFINE_TRACE(WorkerThreadableLoader) {
 
 void WorkerThreadableLoader::MainThreadLoaderHolder::CreateAndStart(
     WorkerThreadableLoader* worker_loader,
-    RefPtr<WorkerLoaderProxy> loader_proxy,
+    ThreadableLoadingContext* loading_context,
     RefPtr<WebTaskRunner> worker_loading_task_runner,
     WorkerThreadLifecycleContext* worker_thread_lifecycle_context,
     std::unique_ptr<CrossThreadResourceRequestData> request,
@@ -446,10 +445,6 @@ void WorkerThreadableLoader::MainThreadLoaderHolder::CreateAndStart(
     PassRefPtr<WaitableEventWithTasks> event_with_tasks) {
   DCHECK(IsMainThread());
   TaskForwarder* forwarder;
-  ThreadableLoadingContext* loading_context =
-      loader_proxy->GetThreadableLoadingContext();
-  if (!loading_context)
-    return;
   if (event_with_tasks)
     forwarder = new SyncTaskForwarder(std::move(event_with_tasks));
   else