Worker: Remove WorkerLoaderProxy for clean-up

third_party/WebKit/Source/core/workers/ThreadedMessagingProxyBase.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/workers/ThreadedMessagingProxyBase.h"
 
 #include "bindings/core/v8/SourceLocation.h"
 #include "core/dom/Document.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/frame/Deprecation.h"
@@ skipping 18 matching lines @@
       parent_frame_task_runners_(ParentFrameTaskRunners::Create(
           ToDocument(execution_context_.Get())->GetFrame())),
       may_be_destroyed_(false),
       asked_to_terminate_(false) {
   DCHECK(IsParentContextThread());
   g_live_messaging_proxy_count++;
 }
 
 ThreadedMessagingProxyBase::~ThreadedMessagingProxyBase() {
   DCHECK(IsParentContextThread());
-  if (loader_proxy_)
-    loader_proxy_->DetachProvider(this);
   g_live_messaging_proxy_count--;
 }
 
 int ThreadedMessagingProxyBase::ProxyCount() {
   DCHECK(IsMainThread());
   return g_live_messaging_proxy_count;
 }
 
 void ThreadedMessagingProxyBase::SetWorkerThreadForTest(
     std::unique_ptr<WorkerThread> worker_thread) {
   worker_thread_ = std::move(worker_thread);
 }
 
 void ThreadedMessagingProxyBase::InitializeWorkerThread(
     std::unique_ptr<WorkerThreadStartupData> startup_data) {
   DCHECK(IsParentContextThread());
 
   Document* document = ToDocument(GetExecutionContext());
   double origin_time =
       document->Loader()
           ? document->Loader()->GetTiming().ReferenceMonotonicTime()
           : MonotonicallyIncreasingTime();
 
-  loader_proxy_ = WorkerLoaderProxy::Create(this);
   worker_thread_ = CreateWorkerThread(origin_time);
   worker_thread_->Start(std::move(startup_data), GetParentFrameTaskRunners());
   WorkerThreadCreated();
 }
 
 ThreadableLoadingContext*
 ThreadedMessagingProxyBase::GetThreadableLoadingContext() {
   DCHECK(IsParentContextThread());
-  if (!loading_context_) {
-    loading_context_ =
-        ThreadableLoadingContext::Create(*ToDocument(execution_context_));
-  }
-  return loading_context_;
+  return ThreadableLoadingContext::Create(*ToDocument(execution_context_));
 }
 
 void ThreadedMessagingProxyBase::CountFeature(UseCounter::Feature feature) {
   DCHECK(IsParentContextThread());
   UseCounter::Count(execution_context_, feature);
 }
 
 void ThreadedMessagingProxyBase::CountDeprecation(UseCounter::Feature feature) {
   DCHECK(IsParentContextThread());
   Deprecation::CountDeprecation(execution_context_, feature);
@@ skipping 72 matching lines @@
 }
 
 bool ThreadedMessagingProxyBase::IsParentContextThread() const {
   // TODO(nhiroki): Nested worker is not supported yet, so the parent context
   // thread should be equal to the main thread (http://crbug.com/31666).
   DCHECK(execution_context_->IsDocument());
   return IsMainThread();
 }
 
 }  // namespace blink