Remove STACK_ALLOCATED() from ScopedTestingPlatformSupport

third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThreadTest.cpp

 // Copyright 2015 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 "modules/compositorworker/CompositorWorkerThread.h"
 
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
@@ skipping 125 matching lines @@
     WorkerOrWorkletScriptController* scriptController =
         worker->globalScope()->scriptController();
     bool evaluateResult = scriptController->evaluate(
         ScriptSourceCode("var counter = 0; ++counter;"));
     DCHECK(evaluateResult);
     waitEvent->signal();
   }
 
   RefPtr<SecurityOrigin> m_securityOrigin;
   std::unique_ptr<InProcessWorkerObjectProxy> m_objectProxy;
+  ScopedTestingPlatformSupport<CompositorWorkerTestPlatform> m_platform;
 };
 
 TEST_F(CompositorWorkerThreadTest, Basic) {
-  ScopedTestingPlatformSupport<CompositorWorkerTestPlatform> platform;
-
   std::unique_ptr<CompositorWorkerThread> compositorWorker =
       createCompositorWorker();
   checkWorkerCanExecuteScript(compositorWorker.get());
   compositorWorker->terminateAndWait();
 }
 
 // Tests that the same WebThread is used for new workers if the WebThread is
 // still alive.
 TEST_F(CompositorWorkerThreadTest, CreateSecondAndTerminateFirst) {
-  ScopedTestingPlatformSupport<CompositorWorkerTestPlatform> platform;
-
   // Create the first worker and wait until it is initialized.
   std::unique_ptr<CompositorWorkerThread> firstWorker =
       createCompositorWorker();
   WebThreadSupportingGC* firstThread =
       &firstWorker->workerBackingThread().backingThread();
   checkWorkerCanExecuteScript(firstWorker.get());
   v8::Isolate* firstIsolate = firstWorker->isolate();
   ASSERT_TRUE(firstIsolate);
 
   // Create the second worker and immediately destroy the first worker.
@@ skipping 15 matching lines @@
 
   // Verify that the worker can still successfully execute script.
   checkWorkerCanExecuteScript(secondWorker.get());
 
   secondWorker->terminateAndWait();
 }
 
 // Tests that a new WebThread is created if all existing workers are terminated
 // before a new worker is created.
 TEST_F(CompositorWorkerThreadTest, TerminateFirstAndCreateSecond) {
-  ScopedTestingPlatformSupport<CompositorWorkerTestPlatform> platform;
-
   // Create the first worker, wait until it is initialized, and terminate it.
   std::unique_ptr<CompositorWorkerThread> compositorWorker =
       createCompositorWorker();
   WebThreadSupportingGC* firstThread =
       &compositorWorker->workerBackingThread().backingThread();
   checkWorkerCanExecuteScript(compositorWorker.get());
 
   // We don't use terminateAndWait here to avoid forcible termination.
   compositorWorker->terminate();
   compositorWorker->waitForShutdownForTesting();
 
   // Create the second worker. The backing thread is same.
   compositorWorker = createCompositorWorker();
   WebThreadSupportingGC* secondThread =
       &compositorWorker->workerBackingThread().backingThread();
   EXPECT_EQ(firstThread, secondThread);
   checkWorkerCanExecuteScript(compositorWorker.get());
 
   compositorWorker->terminateAndWait();
 }
 
 // Tests that v8::Isolate and WebThread are correctly set-up if a worker is
 // created while another is terminating.
 TEST_F(CompositorWorkerThreadTest, CreatingSecondDuringTerminationOfFirst) {
-  ScopedTestingPlatformSupport<CompositorWorkerTestPlatform> platform;
-
   std::unique_ptr<CompositorWorkerThread> firstWorker =
       createCompositorWorker();
   checkWorkerCanExecuteScript(firstWorker.get());
   v8::Isolate* firstIsolate = firstWorker->isolate();
   ASSERT_TRUE(firstIsolate);
 
   // Request termination of the first worker and create the second worker
   // as soon as possible.
   firstWorker->terminate();
   // We don't wait for its termination.
   // Note: We rely on the assumption that the termination steps don't run
   // on the worker thread so quickly. This could be a source of flakiness.
 
   std::unique_ptr<CompositorWorkerThread> secondWorker =
       createCompositorWorker();
 
   v8::Isolate* secondIsolate = secondWorker->isolate();
   ASSERT_TRUE(secondIsolate);
   EXPECT_EQ(firstIsolate, secondIsolate);
 
   // Verify that the isolate can run some scripts correctly in the second
   // worker.
   checkWorkerCanExecuteScript(secondWorker.get());
   secondWorker->terminateAndWait();
 }
 
 }  // namespace blink