Worker: Remove WorkerLoaderProxy for clean-up

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 31 matching lines @@
 #include "core/loader/ThreadableLoadingContext.h"
 #include "core/loader/WorkerFetchContext.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"
 #include "core/workers/WorkerContentSettingsClient.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerInspectorProxy.h"
-#include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerScriptLoader.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/heap/Handle.h"
 #include "platform/heap/Persistent.h"
 #include "platform/loader/fetch/ResourceResponse.h"
 #include "platform/network/ContentSecurityPolicyParsers.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
@@ skipping 32 matching lines @@
 }
 
 WebSharedWorkerImpl::~WebSharedWorkerImpl() {
   DCHECK(IsMainThread());
   DCHECK(web_view_);
   // Detach the client before closing the view to avoid getting called back.
   main_frame_->SetClient(0);
 
   web_view_->Close();
   main_frame_->Close();
-  if (loader_proxy_)
-    loader_proxy_->DetachProvider(this);
 }
 
 void WebSharedWorkerImpl::TerminateWorkerThread() {
   DCHECK(IsMainThread());
   if (asked_to_terminate_)
     return;
   asked_to_terminate_ = true;
   if (main_script_loader_) {
     main_script_loader_->Cancel();
     main_script_loader_.Clear();
@@ skipping 128 matching lines @@
   TerminateWorkerThread();
 }
 
 void WebSharedWorkerImpl::DidTerminateWorkerThread() {
   DCHECK(IsMainThread());
   client_->WorkerContextDestroyed();
   // The lifetime of this proxy is controlled by the worker context.
   delete this;
 }
 
-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());
   // The HTML spec requires to queue a connect event using the DOM manipulation
   // task source.
   // https://html.spec.whatwg.org/multipage/workers.html#shared-workers-and-the-sharedworker-interface
   TaskRunnerHelper::Get(TaskType::kDOMManipulation, GetWorkerThread())
       ->PostTask(
           BLINK_FROM_HERE,
           CrossThreadBind(&WebSharedWorkerImpl::ConnectTaskOnWorkerThread,
@@ skipping 104 matching lines @@
 
   // SharedWorker can sometimes run tasks that are initiated by/associated with
   // a document's frame but these documents can be from a different process. So
   // we intentionally populate the task runners with null document in order to
   // use the thread's default task runner. Note that |m_document| should not be
   // used as it's a dummy document for loading that doesn't represent the frame
   // of any associated document.
   ParentFrameTaskRunners* task_runners =
       ParentFrameTaskRunners::Create(nullptr);
 
-  loader_proxy_ = WorkerLoaderProxy::Create(this);
   reporting_proxy_ = new WebSharedWorkerReportingProxyImpl(this, task_runners);
-  worker_thread_ =
-      SharedWorkerThread::Create(name_, loader_proxy_, *reporting_proxy_);
+  worker_thread_ = WTF::MakeUnique<SharedWorkerThread>(
+      name_,
+      ThreadableLoadingContext::Create(*ToDocument(loading_document_.Get())),
+      *reporting_proxy_);
   probe::scriptImported(loading_document_, main_script_loader_->Identifier(),
                         main_script_loader_->SourceText());
   main_script_loader_.Clear();
 
   GetWorkerThread()->Start(std::move(startup_data), task_runners);
   worker_inspector_proxy_->WorkerThreadCreated(ToDocument(loading_document_),
                                                GetWorkerThread(), url_);
   client_->WorkerScriptLoaded();
 }
 
@@ skipping 38 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