Worker: Stop running worker tests with BlinkGC::MainThreadHeapMode

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 "core/dom/ExecutionContextTask.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceLoaderOptions.h"
 #include "core/loader/DocumentThreadableLoader.h"
@@ skipping 80 matching lines @@
 KURL redirectURL() {
   return KURL(KURL(), "http://example.com/redirect");
 }
 KURL redirectLoopURL() {
   return KURL(KURL(), "http://example.com/loop");
 }
 
 enum ThreadableLoaderToTest {
   DocumentThreadableLoaderTest,
   WorkerThreadableLoaderTest,
-  PerThreadHeapEnabledWorkerThreadableLoaderTest
 };
 
 class ThreadableLoaderTestHelper {
  public:
   virtual ~ThreadableLoaderTestHelper() {}
 
   virtual void createLoader(ThreadableLoaderClient*,
                             CrossOriginRequestPolicy) = 0;
   virtual void startLoader(const ResourceRequest&) = 0;
   virtual void cancelLoader() = 0;
@@ skipping 49 matching lines @@
   Document& document() { return m_dummyPageHolder->document(); }
 
   std::unique_ptr<DummyPageHolder> m_dummyPageHolder;
   Checkpoint m_checkpoint;
   Persistent<DocumentThreadableLoader> m_loader;
 };
 
 class WorkerThreadableLoaderTestHelper : public ThreadableLoaderTestHelper,
                                          public WorkerLoaderProxyProvider {
  public:
-  explicit WorkerThreadableLoaderTestHelper(
-      BlinkGC::ThreadHeapMode threadHeapMode)
-      : m_dummyPageHolder(DummyPageHolder::create(IntSize(1, 1))),
-        m_threadHeapMode(threadHeapMode) {}
+  WorkerThreadableLoaderTestHelper()
+      : m_dummyPageHolder(DummyPageHolder::create(IntSize(1, 1))) {}
 
   void createLoader(
       ThreadableLoaderClient* client,
       CrossOriginRequestPolicy crossOriginRequestPolicy) override {
     std::unique_ptr<WaitableEvent> completionEvent =
         WTF::makeUnique<WaitableEvent>();
     postTaskToWorkerGlobalScope(
         BLINK_FROM_HERE,
         createCrossThreadTask(
             &WorkerThreadableLoaderTestHelper::workerCreateLoader,
@@ skipping 50 matching lines @@
             crossThreadUnretained(this),
             crossThreadUnretained(completionEvent.get()), n));
     completionEvent->wait();
   }
 
   void onSetUp() override {
     m_mockWorkerReportingProxy = WTF::makeUnique<MockWorkerReportingProxy>();
     m_securityOrigin = document().getSecurityOrigin();
     m_parentFrameTaskRunners =
         ParentFrameTaskRunners::create(&m_dummyPageHolder->frame());
-    m_workerThread = WTF::wrapUnique(new WorkerThreadForTest(
-        this, *m_mockWorkerReportingProxy, m_threadHeapMode));
+    m_workerThread = WTF::wrapUnique(
+        new WorkerThreadForTest(this, *m_mockWorkerReportingProxy));
 
     expectWorkerLifetimeReportingCalls();
     m_workerThread->startWithSourceCode(m_securityOrigin.get(),
                                         "//fake source code");
     m_workerThread->waitForInit();
   }
 
   void onServeRequests() override { testing::runPendingTasks(); }
 
   void onTearDown() override {
@@ skipping 91 matching lines @@
 
   RefPtr<SecurityOrigin> m_securityOrigin;
   std::unique_ptr<MockWorkerReportingProxy> m_mockWorkerReportingProxy;
   std::unique_ptr<WorkerThreadForTest> m_workerThread;
 
   std::unique_ptr<DummyPageHolder> m_dummyPageHolder;
   Persistent<ParentFrameTaskRunners> m_parentFrameTaskRunners;
   Checkpoint m_checkpoint;
   // |m_loader| must be touched only from the worker thread only.
   CrossThreadPersistent<ThreadableLoader> m_loader;
-  const BlinkGC::ThreadHeapMode m_threadHeapMode;
 };
 
 class ThreadableLoaderTest
     : public ::testing::TestWithParam<ThreadableLoaderToTest> {
  public:
   ThreadableLoaderTest() {
     switch (GetParam()) {
       case DocumentThreadableLoaderTest:
         m_helper = WTF::wrapUnique(new DocumentThreadableLoaderTestHelper);
         break;
       case WorkerThreadableLoaderTest:
-        m_helper = WTF::wrapUnique(
-            new WorkerThreadableLoaderTestHelper(BlinkGC::MainThreadHeapMode));
-        break;
-      case PerThreadHeapEnabledWorkerThreadableLoaderTest:
-        m_helper = WTF::wrapUnique(
-            new WorkerThreadableLoaderTestHelper(BlinkGC::PerThreadHeapMode));
+        m_helper = WTF::wrapUnique(new WorkerThreadableLoaderTestHelper());
         break;
     }
   }
 
   void startLoader(const KURL& url) {
     ResourceRequest request(url);
     request.setRequestContext(WebURLRequest::RequestContextObject);
     m_helper->startLoader(request);
   }
 
@@ skipping 81 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(Document,
                         ThreadableLoaderTest,
                         ::testing::Values(DocumentThreadableLoaderTest));
 
 INSTANTIATE_TEST_CASE_P(Worker,
                         ThreadableLoaderTest,
                         ::testing::Values(WorkerThreadableLoaderTest));
 
-INSTANTIATE_TEST_CASE_P(
-    PerThreadHeapEnabledWorker,
-    ThreadableLoaderTest,
-    ::testing::Values(PerThreadHeapEnabledWorkerThreadableLoaderTest));
-
 TEST_P(ThreadableLoaderTest, StartAndStop) {}
 
 TEST_P(ThreadableLoaderTest, CancelAfterStart) {
   InSequence s;
   EXPECT_CALL(checkpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
   EXPECT_CALL(checkpoint(), Call(2))
       .WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
@@ skipping 403 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