Worker: Stop running worker tests with BlinkGC::MainThreadHeapMode

Oilpan's per-thread heap mode is already shipped for workers and we no longer
have to run the tests on both BlinkGC::MainThreadHeapMode and
BlinkGC::PerThreadHeapMode.

BUG=674400

Review-Url: https://codereview.chromium.org/2578053002
Cr-Commit-Position: refs/heads/master@{#438790}

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

@@ -98,7 +98,6 @@ KURL redirectLoopURL() {
 enum ThreadableLoaderToTest {
   DocumentThreadableLoaderTest,
   WorkerThreadableLoaderTest,
-  PerThreadHeapEnabledWorkerThreadableLoaderTest
 };
 
 class ThreadableLoaderTestHelper {
@@ -168,10 +167,8 @@ class DocumentThreadableLoaderTestHelper : public ThreadableLoaderTestHelper {
 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,
@@ -242,8 +239,8 @@ class WorkerThreadableLoaderTestHelper : public ThreadableLoaderTestHelper,
     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(),
@@ -355,7 +352,6 @@ class WorkerThreadableLoaderTestHelper : public ThreadableLoaderTestHelper,
   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
@@ -367,12 +363,7 @@ class ThreadableLoaderTest
         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;
     }
   }
@@ -474,11 +465,6 @@ 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) {

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

@@ -37,14 +37,12 @@ class DedicatedWorkerThreadForTest final : public DedicatedWorkerThread {
  public:
   DedicatedWorkerThreadForTest(
       WorkerLoaderProxyProvider* workerLoaderProxyProvider,
-      InProcessWorkerObjectProxy& workerObjectProxy,
-      BlinkGC::ThreadHeapMode threadHeapMode)
+      InProcessWorkerObjectProxy& workerObjectProxy)
       : DedicatedWorkerThread(
             WorkerLoaderProxy::create(workerLoaderProxyProvider),
             workerObjectProxy,
             monotonicallyIncreasingTime()) {
-    m_workerBackingThread =
-        WorkerBackingThread::createForTest("Test thread", threadHeapMode);
+    m_workerBackingThread = WorkerBackingThread::createForTest("Test thread");
   }
 
   WorkerOrWorkletGlobalScope* createWorkerGlobalScope(
@@ -86,8 +84,7 @@ class DedicatedWorkerThreadForTest final : public DedicatedWorkerThread {
 class InProcessWorkerMessagingProxyForTest
     : public InProcessWorkerMessagingProxy {
  public:
-  InProcessWorkerMessagingProxyForTest(ExecutionContext* executionContext,
-                                       BlinkGC::ThreadHeapMode threadHeapMode)
+  InProcessWorkerMessagingProxyForTest(ExecutionContext* executionContext)
       : InProcessWorkerMessagingProxy(executionContext,
                                       nullptr /* workerObject */,
                                       nullptr /* workerClients */) {
@@ -97,9 +94,8 @@ class InProcessWorkerMessagingProxyForTest
 
     m_mockWorkerLoaderProxyProvider =
         WTF::makeUnique<MockWorkerLoaderProxyProvider>();
-    m_workerThread = WTF::wrapUnique(
-        new DedicatedWorkerThreadForTest(m_mockWorkerLoaderProxyProvider.get(),
-                                         workerObjectProxy(), threadHeapMode));
+    m_workerThread = WTF::wrapUnique(new DedicatedWorkerThreadForTest(
+        m_mockWorkerLoaderProxyProvider.get(), workerObjectProxy()));
     m_mockWorkerThreadLifecycleObserver = new MockWorkerThreadLifecycleObserver(
         m_workerThread->getWorkerThreadLifecycleContext());
     EXPECT_CALL(*m_mockWorkerThreadLifecycleObserver, contextDestroyed())
@@ -201,16 +197,14 @@ class InProcessWorkerMessagingProxyForTest
 
 using Notification = InProcessWorkerMessagingProxyForTest::Notification;
 
-class DedicatedWorkerTest
-    : public ::testing::TestWithParam<BlinkGC::ThreadHeapMode> {
+class DedicatedWorkerTest : public ::testing::Test {
  public:
-  DedicatedWorkerTest() : m_threadHeapMode(GetParam()) {}
+  DedicatedWorkerTest() {}
 
   void SetUp() override {
     m_page = DummyPageHolder::create();
-    m_workerMessagingProxy =
-        WTF::wrapUnique(new InProcessWorkerMessagingProxyForTest(
-            &m_page->document(), m_threadHeapMode));
+    m_workerMessagingProxy = WTF::wrapUnique(
+        new InProcessWorkerMessagingProxyForTest(&m_page->document()));
   }
 
   void TearDown() override {
@@ -237,18 +231,9 @@ class DedicatedWorkerTest
  private:
   std::unique_ptr<DummyPageHolder> m_page;
   std::unique_ptr<InProcessWorkerMessagingProxyForTest> m_workerMessagingProxy;
-  const BlinkGC::ThreadHeapMode m_threadHeapMode;
 };
 
-INSTANTIATE_TEST_CASE_P(MainThreadHeap,
-                        DedicatedWorkerTest,
-                        ::testing::Values(BlinkGC::MainThreadHeapMode));
-
-INSTANTIATE_TEST_CASE_P(PerThreadHeap,
-                        DedicatedWorkerTest,
-                        ::testing::Values(BlinkGC::PerThreadHeapMode));
-
-TEST_P(DedicatedWorkerTest, PendingActivity_NoActivity) {
+TEST_F(DedicatedWorkerTest, PendingActivity_NoActivity) {
   const String sourceCode = "// Do nothing";
   workerMessagingProxy()->startWithSourceCode(sourceCode);
 
@@ -261,7 +246,7 @@ TEST_P(DedicatedWorkerTest, PendingActivity_NoActivity) {
   EXPECT_FALSE(workerMessagingProxy()->hasPendingActivity());
 }
 
-TEST_P(DedicatedWorkerTest, PendingActivity_SetTimeout) {
+TEST_F(DedicatedWorkerTest, PendingActivity_SetTimeout) {
   // Start an oneshot timer on initial script evaluation.
   const String sourceCode = "setTimeout(function() {}, 0);";
   workerMessagingProxy()->startWithSourceCode(sourceCode);
@@ -276,7 +261,7 @@ TEST_P(DedicatedWorkerTest, PendingActivity_SetTimeout) {
   EXPECT_FALSE(workerMessagingProxy()->hasPendingActivity());
 }
 
-TEST_P(DedicatedWorkerTest, PendingActivity_SetInterval) {
+TEST_F(DedicatedWorkerTest, PendingActivity_SetInterval) {
   // Start a repeated timer on initial script evaluation, and stop it when a
   // message is received. The timer needs a non-zero delay or else worker
   // activities would not run.
@@ -303,7 +288,7 @@ TEST_P(DedicatedWorkerTest, PendingActivity_SetInterval) {
   EXPECT_FALSE(workerMessagingProxy()->hasPendingActivity());
 }
 
-TEST_P(DedicatedWorkerTest, PendingActivity_SetTimeoutOnMessageEvent) {
+TEST_F(DedicatedWorkerTest, PendingActivity_SetTimeoutOnMessageEvent) {
   // Start an oneshot timer on a message event.
   const String sourceCode =
       "addEventListener('message', function(event) {"
@@ -333,7 +318,7 @@ TEST_P(DedicatedWorkerTest, PendingActivity_SetTimeoutOnMessageEvent) {
   EXPECT_FALSE(workerMessagingProxy()->hasPendingActivity());
 }
 
-TEST_P(DedicatedWorkerTest, PendingActivity_SetIntervalOnMessageEvent) {
+TEST_F(DedicatedWorkerTest, PendingActivity_SetIntervalOnMessageEvent) {
   // Start a repeated timer on a message event, and stop it when another
   // message is received. The timer needs a non-zero delay or else worker
   // activities would not run.
@@ -387,7 +372,7 @@ TEST_P(DedicatedWorkerTest, PendingActivity_SetIntervalOnMessageEvent) {
   EXPECT_FALSE(workerMessagingProxy()->hasPendingActivity());
 }
 
-TEST_P(DedicatedWorkerTest, UseCounter) {
+TEST_F(DedicatedWorkerTest, UseCounter) {
   const String sourceCode = "// Do nothing";
   workerMessagingProxy()->startWithSourceCode(sourceCode);
 

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

@@ -54,8 +54,7 @@ DedicatedWorkerThread::DedicatedWorkerThread(
     double timeOrigin)
     : WorkerThread(std::move(workerLoaderProxy), workerObjectProxy),
       m_workerBackingThread(
-          WorkerBackingThread::create("DedicatedWorker Thread",
-                                      BlinkGC::PerThreadHeapMode)),
+          WorkerBackingThread::create("DedicatedWorker Thread")),
       m_workerObjectProxy(workerObjectProxy),
       m_timeOrigin(timeOrigin) {}
 

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

@@ -51,9 +51,7 @@ SharedWorkerThread::SharedWorkerThread(
     PassRefPtr<WorkerLoaderProxy> workerLoaderProxy,
     WorkerReportingProxy& workerReportingProxy)
     : WorkerThread(std::move(workerLoaderProxy), workerReportingProxy),
-      m_workerBackingThread(
-          WorkerBackingThread::create("SharedWorker Thread",
-                                      BlinkGC::PerThreadHeapMode)),
+      m_workerBackingThread(WorkerBackingThread::create("SharedWorker Thread")),
       m_name(name.isolatedCopy()) {}
 
 SharedWorkerThread::~SharedWorkerThread() {}

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

@@ -45,9 +45,9 @@ static void removeWorkerIsolate(v8::Isolate* isolate) {
 }
 
 WorkerBackingThread::WorkerBackingThread(const char* name,
-                                         bool shouldCallGCOnShutdown,
-                                         BlinkGC::ThreadHeapMode threadHeapMode)
-    : m_backingThread(WebThreadSupportingGC::create(name, threadHeapMode)),
+                                         bool shouldCallGCOnShutdown)
+    : m_backingThread(
+          WebThreadSupportingGC::create(name, BlinkGC::PerThreadHeapMode)),
       m_isOwningThread(true),
       m_shouldCallGCOnShutdown(shouldCallGCOnShutdown) {}
 

third_party/WebKit/Source/core/workers/WorkerBackingThread.h

@@ -28,11 +28,8 @@ class WebThreadSupportingGC;
 // WorkerGlobalScopes) can share one WorkerBackingThread.
 class CORE_EXPORT WorkerBackingThread final {
  public:
-  static std::unique_ptr<WorkerBackingThread> create(
-      const char* name,
-      BlinkGC::ThreadHeapMode threadHeapMode) {
-    return WTF::wrapUnique(
-        new WorkerBackingThread(name, false, threadHeapMode));
+  static std::unique_ptr<WorkerBackingThread> create(const char* name) {
+    return WTF::wrapUnique(new WorkerBackingThread(name, false));
   }
   static std::unique_ptr<WorkerBackingThread> create(WebThread* thread) {
     return WTF::wrapUnique(new WorkerBackingThread(thread, false));
@@ -40,10 +37,8 @@ class CORE_EXPORT WorkerBackingThread final {
 
   // These are needed to suppress leak reports. See
   // https://crbug.com/590802 and https://crbug.com/v8/1428.
-  static std::unique_ptr<WorkerBackingThread> createForTest(
-      const char* name,
-      BlinkGC::ThreadHeapMode threadHeapMode) {
-    return WTF::wrapUnique(new WorkerBackingThread(name, true, threadHeapMode));
+  static std::unique_ptr<WorkerBackingThread> createForTest(const char* name) {
+    return WTF::wrapUnique(new WorkerBackingThread(name, true));
   }
   static std::unique_ptr<WorkerBackingThread> createForTest(WebThread* thread) {
     return WTF::wrapUnique(new WorkerBackingThread(thread, true));
@@ -71,9 +66,7 @@ class CORE_EXPORT WorkerBackingThread final {
   static void setRAILModeOnWorkerThreadIsolates(v8::RAILMode);
 
  private:
-  WorkerBackingThread(const char* name,
-                      bool shouldCallGCOnShutdown,
-                      BlinkGC::ThreadHeapMode);
+  WorkerBackingThread(const char* name, bool shouldCallGCOnShutdown);
   WorkerBackingThread(WebThread*, bool shouldCallGCOnSHutdown);
 
   std::unique_ptr<WebThreadSupportingGC> m_backingThread;

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

@@ -36,10 +36,9 @@ void waitForSignalTask(WorkerThread* workerThread,
 
 }  // namespace
 
-class WorkerThreadTest
-    : public ::testing::TestWithParam<BlinkGC::ThreadHeapMode> {
+class WorkerThreadTest : public ::testing::Test {
  public:
-  WorkerThreadTest() : m_threadHeapMode(GetParam()) {}
+  WorkerThreadTest() {}
 
   void SetUp() override {
     m_loaderProxyProvider = WTF::makeUnique<MockWorkerLoaderProxyProvider>();
@@ -47,7 +46,7 @@ class WorkerThreadTest
     m_securityOrigin =
         SecurityOrigin::create(KURL(ParsedURLString, "http://fake.url/"));
     m_workerThread = WTF::wrapUnique(new WorkerThreadForTest(
-        m_loaderProxyProvider.get(), *m_reportingProxy, m_threadHeapMode));
+        m_loaderProxyProvider.get(), *m_reportingProxy));
     m_lifecycleObserver = new MockWorkerThreadLifecycleObserver(
         m_workerThread->getWorkerThreadLifecycleContext());
   }
@@ -119,18 +118,9 @@ class WorkerThreadTest
   std::unique_ptr<MockWorkerReportingProxy> m_reportingProxy;
   std::unique_ptr<WorkerThreadForTest> m_workerThread;
   Persistent<MockWorkerThreadLifecycleObserver> m_lifecycleObserver;
-  const BlinkGC::ThreadHeapMode m_threadHeapMode;
 };
 
-INSTANTIATE_TEST_CASE_P(MainThreadHeap,
-                        WorkerThreadTest,
-                        ::testing::Values(BlinkGC::MainThreadHeapMode));
-
-INSTANTIATE_TEST_CASE_P(PerThreadHeap,
-                        WorkerThreadTest,
-                        ::testing::Values(BlinkGC::PerThreadHeapMode));
-
-TEST_P(WorkerThreadTest, ShouldScheduleToTerminateExecution) {
+TEST_F(WorkerThreadTest, ShouldScheduleToTerminateExecution) {
   using ThreadState = WorkerThread::ThreadState;
   MutexLocker dummyLock(m_workerThread->m_threadStateMutex);
 
@@ -151,7 +141,7 @@ TEST_P(WorkerThreadTest, ShouldScheduleToTerminateExecution) {
   m_workerThread->setExitCode(dummyLock, ExitCode::GracefullyTerminated);
 }
 
-TEST_P(WorkerThreadTest, AsyncTerminate_OnIdle) {
+TEST_F(WorkerThreadTest, AsyncTerminate_OnIdle) {
   expectReportingCalls();
   start();
 
@@ -167,7 +157,7 @@ TEST_P(WorkerThreadTest, AsyncTerminate_OnIdle) {
   EXPECT_EQ(ExitCode::GracefullyTerminated, getExitCode());
 }
 
-TEST_P(WorkerThreadTest, SyncTerminate_OnIdle) {
+TEST_F(WorkerThreadTest, SyncTerminate_OnIdle) {
   expectReportingCalls();
   start();
 
@@ -179,7 +169,7 @@ TEST_P(WorkerThreadTest, SyncTerminate_OnIdle) {
   EXPECT_EQ(ExitCode::SyncForciblyTerminated, getExitCode());
 }
 
-TEST_P(WorkerThreadTest, AsyncTerminate_ImmediatelyAfterStart) {
+TEST_F(WorkerThreadTest, AsyncTerminate_ImmediatelyAfterStart) {
   expectReportingCallsForWorkerPossiblyTerminatedBeforeInitialization();
   start();
 
@@ -190,7 +180,7 @@ TEST_P(WorkerThreadTest, AsyncTerminate_ImmediatelyAfterStart) {
   EXPECT_EQ(ExitCode::GracefullyTerminated, getExitCode());
 }
 
-TEST_P(WorkerThreadTest, SyncTerminate_ImmediatelyAfterStart) {
+TEST_F(WorkerThreadTest, SyncTerminate_ImmediatelyAfterStart) {
   expectReportingCallsForWorkerPossiblyTerminatedBeforeInitialization();
   start();
 
@@ -210,7 +200,7 @@ TEST_P(WorkerThreadTest, SyncTerminate_ImmediatelyAfterStart) {
               ExitCode::SyncForciblyTerminated == exitCode);
 }
 
-TEST_P(WorkerThreadTest, AsyncTerminate_WhileTaskIsRunning) {
+TEST_F(WorkerThreadTest, AsyncTerminate_WhileTaskIsRunning) {
   const long long kForcibleTerminationDelayInMs = 10;
   setForcibleTerminationDelayInMs(kForcibleTerminationDelayInMs);
 
@@ -234,7 +224,7 @@ TEST_P(WorkerThreadTest, AsyncTerminate_WhileTaskIsRunning) {
   EXPECT_EQ(ExitCode::AsyncForciblyTerminated, getExitCode());
 }
 
-TEST_P(WorkerThreadTest, SyncTerminate_WhileTaskIsRunning) {
+TEST_F(WorkerThreadTest, SyncTerminate_WhileTaskIsRunning) {
   expectReportingCallsForWorkerForciblyTerminated();
   startWithSourceCodeNotToFinish();
   m_reportingProxy->waitUntilScriptEvaluation();
@@ -244,7 +234,7 @@ TEST_P(WorkerThreadTest, SyncTerminate_WhileTaskIsRunning) {
   EXPECT_EQ(ExitCode::SyncForciblyTerminated, getExitCode());
 }
 
-TEST_P(WorkerThreadTest,
+TEST_F(WorkerThreadTest,
        AsyncTerminateAndThenSyncTerminate_WhileTaskIsRunning) {
   const long long kForcibleTerminationDelayInMs = 10;
   setForcibleTerminationDelayInMs(kForcibleTerminationDelayInMs);
@@ -264,7 +254,7 @@ TEST_P(WorkerThreadTest,
   EXPECT_EQ(ExitCode::SyncForciblyTerminated, getExitCode());
 }
 
-TEST_P(WorkerThreadTest, Terminate_WhileDebuggerTaskIsRunningOnInitialization) {
+TEST_F(WorkerThreadTest, Terminate_WhileDebuggerTaskIsRunningOnInitialization) {
   EXPECT_CALL(*m_reportingProxy, didCreateWorkerGlobalScope(_)).Times(1);
   EXPECT_CALL(*m_reportingProxy, didInitializeWorkerContext()).Times(1);
   EXPECT_CALL(*m_reportingProxy, willDestroyWorkerGlobalScope()).Times(1);
@@ -324,7 +314,7 @@ TEST_P(WorkerThreadTest, Terminate_WhileDebuggerTaskIsRunningOnInitialization) {
   EXPECT_EQ(ExitCode::GracefullyTerminated, getExitCode());
 }
 
-TEST_P(WorkerThreadTest, Terminate_WhileDebuggerTaskIsRunning) {
+TEST_F(WorkerThreadTest, Terminate_WhileDebuggerTaskIsRunning) {
   expectReportingCalls();
   start();
   m_workerThread->waitForInit();

third_party/WebKit/Source/core/workers/WorkerThreadTestHelper.h

@@ -119,13 +119,11 @@ class MockWorkerThreadLifecycleObserver final
 class WorkerThreadForTest : public WorkerThread {
  public:
   WorkerThreadForTest(WorkerLoaderProxyProvider* mockWorkerLoaderProxyProvider,
-                      WorkerReportingProxy& mockWorkerReportingProxy,
-                      BlinkGC::ThreadHeapMode threadHeapMode)
+                      WorkerReportingProxy& mockWorkerReportingProxy)
       : WorkerThread(WorkerLoaderProxy::create(mockWorkerLoaderProxyProvider),
                      mockWorkerReportingProxy),
         m_workerBackingThread(
-            WorkerBackingThread::createForTest("Test thread", threadHeapMode)) {
-  }
+            WorkerBackingThread::createForTest("Test thread")) {}
 
   ~WorkerThreadForTest() override {}
 

third_party/WebKit/Source/core/workers/WorkletThreadHolder.h

@@ -24,15 +24,13 @@ class WorkletThreadHolder {
     return s_threadHolderInstance;
   }
 
-  static void ensureInstance(const char* threadName,
-                             BlinkGC::ThreadHeapMode threadHeapMode) {
+  static void ensureInstance(const char* threadName) {
     DCHECK(isMainThread());
     MutexLocker locker(holderInstanceMutex());
     if (s_threadHolderInstance)
       return;
     s_threadHolderInstance = new WorkletThreadHolder<DerivedWorkletThread>;
-    s_threadHolderInstance->initialize(
-        WorkerBackingThread::create(threadName, threadHeapMode));
+    s_threadHolderInstance->initialize(WorkerBackingThread::create(threadName));
   }
 
   static void ensureInstance(WebThread* thread) {
@@ -44,13 +42,12 @@ class WorkletThreadHolder {
     s_threadHolderInstance->initialize(WorkerBackingThread::create(thread));
   }
 
-  static void createForTest(const char* threadName,
-                            BlinkGC::ThreadHeapMode threadHeapMode) {
+  static void createForTest(const char* threadName) {
     MutexLocker locker(holderInstanceMutex());
     DCHECK(!s_threadHolderInstance);
     s_threadHolderInstance = new WorkletThreadHolder<DerivedWorkletThread>;
     s_threadHolderInstance->initialize(
-        WorkerBackingThread::createForTest(threadName, threadHeapMode));
+        WorkerBackingThread::createForTest(threadName));
   }
 
   static void createForTest(WebThread* thread) {

third_party/WebKit/Source/modules/serviceworkers/ServiceWorkerThread.cpp

@@ -50,8 +50,7 @@ ServiceWorkerThread::ServiceWorkerThread(
     WorkerReportingProxy& workerReportingProxy)
     : WorkerThread(std::move(workerLoaderProxy), workerReportingProxy),
       m_workerBackingThread(
-          WorkerBackingThread::create("ServiceWorker Thread",
-                                      BlinkGC::PerThreadHeapMode)) {}
+          WorkerBackingThread::create("ServiceWorker Thread")) {}
 
 ServiceWorkerThread::~ServiceWorkerThread() {}
 

third_party/WebKit/Source/modules/webaudio/AudioWorkletThread.cpp

@@ -63,8 +63,7 @@ void AudioWorkletThread::collectAllGarbage() {
 
 void AudioWorkletThread::ensureSharedBackingThread() {
   DCHECK(isMainThread());
-  WorkletThreadHolder<AudioWorkletThread>::ensureInstance(
-      "AudioWorkletThread", BlinkGC::PerThreadHeapMode);
+  WorkletThreadHolder<AudioWorkletThread>::ensureInstance("AudioWorkletThread");
 }
 
 void AudioWorkletThread::clearSharedBackingThread() {
@@ -73,8 +72,7 @@ void AudioWorkletThread::clearSharedBackingThread() {
 }
 
 void AudioWorkletThread::createSharedBackingThreadForTest() {
-  WorkletThreadHolder<AudioWorkletThread>::createForTest(
-      "AudioWorkletThread", BlinkGC::PerThreadHeapMode);
+  WorkletThreadHolder<AudioWorkletThread>::createForTest("AudioWorkletThread");
 }
 
 WorkerOrWorkletGlobalScope* AudioWorkletThread::createWorkerGlobalScope(