Worker: Remove WorkerLoaderProxy for clean-up

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

 /*
  * Copyright (C) 2009, 2010 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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/loader/WorkerThreadableLoader.h"
 
 #include <memory>
 #include "core/loader/DocumentThreadableLoader.h"
 #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"
 #include "platform/loader/fetch/ResourceRequest.h"
 #include "platform/loader/fetch/ResourceResponse.h"
 #include "platform/loader/fetch/ResourceTimingInfo.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "platform/wtf/Functional.h"
 #include "platform/wtf/debug/Alias.h"
@@ skipping 141 matching lines @@
   RefPtr<WaitableEventWithTasks> event_with_tasks_;
 };
 
 WorkerThreadableLoader::WorkerThreadableLoader(
     WorkerGlobalScope& worker_global_scope,
     ThreadableLoaderClient* client,
     const ThreadableLoaderOptions& options,
     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),
       threadable_loader_options_(options),
       resource_loader_options_(resource_loader_options),
       blocking_behavior_(blocking_behavior) {
   DCHECK(client);
 }
 
 void WorkerThreadableLoader::LoadResourceSynchronously(
     WorkerGlobalScope& worker_global_scope,
     const ResourceRequest& request,
     ThreadableLoaderClient& client,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resource_loader_options) {
   (new WorkerThreadableLoader(worker_global_scope, &client, options,
                               resource_loader_options, kLoadSynchronously))
       ->Start(request);
 }
 
 WorkerThreadableLoader::~WorkerThreadableLoader() {
   DCHECK(!main_thread_loader_holder_);
   DCHECK(!client_);
 }
 
 void WorkerThreadableLoader::Start(const ResourceRequest& original_request) {
+  DCHECK(worker_global_scope_->IsContextThread());
   ResourceRequest request(original_request);
   if (!request.DidSetHTTPReferrer()) {
     request.SetHTTPReferrer(SecurityPolicy::GenerateReferrer(
         worker_global_scope_->GetReferrerPolicy(), request.Url(),
         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;
 
   event_with_tasks->Wait();
 
   if (event_with_tasks->IsAborted()) {
     // This thread is going to terminate.
     Cancel();
     return;
@@ skipping 167 matching lines @@
   client_->DidReceiveResourceTiming(*info);
 }
 
 DEFINE_TRACE(WorkerThreadableLoader) {
   visitor->Trace(worker_global_scope_);
   ThreadableLoader::Trace(visitor);
 }
 
 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,
     const ThreadableLoaderOptions& options,
     const ResourceLoaderOptions& resource_loader_options,
     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
     forwarder = new AsyncTaskForwarder(std::move(worker_loading_task_runner));
 
   MainThreadLoaderHolder* main_thread_loader_holder =
       new MainThreadLoaderHolder(forwarder, worker_thread_lifecycle_context);
   if (main_thread_loader_holder->WasContextDestroyedBeforeObserverCreation()) {
     // The thread is already terminating.
     forwarder->Abort();
@@ skipping 216 matching lines @@
   DCHECK(IsMainThread());
   ResourceLoaderOptions resource_loader_options =
       original_resource_loader_options;
   resource_loader_options.request_initiator_context = kWorkerContext;
   main_thread_loader_ = DocumentThreadableLoader::Create(
       loading_context, this, options, resource_loader_options);
   main_thread_loader_->Start(ResourceRequest(request.get()));
 }
 
 }  // namespace blink