Worker: Remove WorkerLoaderProxy for clean-up

third_party/WebKit/Source/core/loader/ThreadableLoaderTest.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/loader/ThreadableLoader.h"
 
 #include <memory>
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/loader/DocumentThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/loader/ThreadableLoadingContext.h"
 #include "core/loader/WorkerThreadableLoader.h"
 #include "core/testing/DummyPageHolder.h"
-#include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThreadTestHelper.h"
 #include "platform/WaitableEvent.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/loader/fetch/MemoryCache.h"
 #include "platform/loader/fetch/ResourceError.h"
 #include "platform/loader/fetch/ResourceLoaderOptions.h"
 #include "platform/loader/fetch/ResourceRequest.h"
 #include "platform/loader/fetch/ResourceResponse.h"
 #include "platform/loader/fetch/ResourceTimingInfo.h"
@@ skipping 138 matching lines @@
   }
 
  private:
   Document& GetDocument() { return dummy_page_holder_->GetDocument(); }
 
   std::unique_ptr<DummyPageHolder> dummy_page_holder_;
   Checkpoint checkpoint_;
   Persistent<DocumentThreadableLoader> loader_;
 };
 
-class WorkerThreadableLoaderTestHelper : public ThreadableLoaderTestHelper,
-                                         public WorkerLoaderProxyProvider {
+class WorkerThreadableLoaderTestHelper : public ThreadableLoaderTestHelper {
  public:
   WorkerThreadableLoaderTestHelper()
       : dummy_page_holder_(DummyPageHolder::Create(IntSize(1, 1))) {}
 
   void CreateLoader(
       ThreadableLoaderClient* client,
       CrossOriginRequestPolicy cross_origin_request_policy) override {
     std::unique_ptr<WaitableEvent> completion_event =
         WTF::MakeUnique<WaitableEvent>();
     worker_loading_task_runner_->PostTask(
@@ skipping 52 matching lines @@
                         CrossThreadUnretained(this),
                         CrossThreadUnretained(completion_event.get()), n));
     completion_event->Wait();
   }
 
   void OnSetUp() override {
     reporting_proxy_ = WTF::MakeUnique<WorkerReportingProxy>();
     security_origin_ = GetDocument().GetSecurityOrigin();
     parent_frame_task_runners_ =
         ParentFrameTaskRunners::Create(&dummy_page_holder_->GetFrame());
-    worker_thread_ =
-        WTF::WrapUnique(new WorkerThreadForTest(this, *reporting_proxy_));
-    loading_context_ = ThreadableLoadingContext::Create(GetDocument());
+    worker_thread_ = WTF::WrapUnique(new WorkerThreadForTest(
+        ThreadableLoadingContext::Create(GetDocument()), *reporting_proxy_));

[kinuko, 2017/04/24 09:30:16]

nit: makeunique (while you're there)

[nhiroki, 2017/05/29 04:20:24]

Done.

 
     worker_thread_->StartWithSourceCode(security_origin_.Get(),
                                         "//fake source code",
                                         parent_frame_task_runners_.Get());
     worker_thread_->WaitForInit();
     worker_loading_task_runner_ =
         TaskRunnerHelper::Get(TaskType::kUnspecedLoading, worker_thread_.get());
   }
 
   void OnServeRequests() override { testing::RunPendingTasks(); }
 
   void OnTearDown() override {
     worker_loading_task_runner_->PostTask(
         BLINK_FROM_HERE,
         CrossThreadBind(&WorkerThreadableLoaderTestHelper::ClearLoader,
                         CrossThreadUnretained(this)));
     WaitableEvent event;
     worker_loading_task_runner_->PostTask(
         BLINK_FROM_HERE,
         CrossThreadBind(&WaitableEvent::Signal, CrossThreadUnretained(&event)));
     event.Wait();
     worker_thread_->TerminateAndWait();
 
     // Needed to clean up the things on the main thread side and
     // avoid Resource leaks.
     testing::RunPendingTasks();
-
-    worker_thread_->GetWorkerLoaderProxy()->DetachProvider(this);
   }
 
  private:
   Document& GetDocument() { return dummy_page_holder_->GetDocument(); }
 
   void WorkerCreateLoader(
       ThreadableLoaderClient* client,
       WaitableEvent* event,
       CrossOriginRequestPolicy cross_origin_request_policy) {
     DCHECK(worker_thread_);
@@ skipping 26 matching lines @@
     event->Signal();
   }
 
   void WorkerCallCheckpoint(WaitableEvent* event, int n) {
     DCHECK(worker_thread_);
     DCHECK(worker_thread_->IsCurrentThread());
     checkpoint_.Call(n);
     event->Signal();
   }
 
-  // WorkerLoaderProxyProvider methods.
-  ThreadableLoadingContext* GetThreadableLoadingContext() override {
-    return loading_context_.Get();
-  }
-
   RefPtr<SecurityOrigin> security_origin_;
   std::unique_ptr<WorkerReportingProxy> reporting_proxy_;
   std::unique_ptr<WorkerThreadForTest> worker_thread_;
 
   std::unique_ptr<DummyPageHolder> dummy_page_holder_;
   // Accessed cross-thread when worker thread posts tasks to the parent.
   CrossThreadPersistent<ParentFrameTaskRunners> parent_frame_task_runners_;
   RefPtr<WebTaskRunner> worker_loading_task_runner_;
   Checkpoint checkpoint_;
   // |m_loader| must be touched only from the worker thread only.
   CrossThreadPersistent<ThreadableLoader> loader_;
-
-  Persistent<ThreadableLoadingContext> loading_context_;
 };
 
 class ThreadableLoaderTest
     : public ::testing::TestWithParam<ThreadableLoaderToTest> {
  public:
   ThreadableLoaderTest() {
     switch (GetParam()) {
       case kDocumentThreadableLoaderTest:
         helper_ = WTF::WrapUnique(new DocumentThreadableLoaderTestHelper);
         break;
@@ skipping 517 matching lines @@
   // test is not saying that didFailAccessControlCheck should be dispatched
   // synchronously, but is saying that even when a response is served
   // synchronously it should not lead to a crash.
   StartLoader(KURL(KURL(), "about:blank"));
   CallCheckpoint(2);
 }
 
 }  // namespace
 
 }  // namespace blink