Remove STACK_ALLOCATED() from ScopedTestingPlatformSupport

third_party/WebKit/Source/modules/compositorworker/AnimationWorkletThreadTest.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/AnimationWorkletThread.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 110 matching lines @@
  private:
   void executeScriptInWorklet(WorkerThread* thread, WaitableEvent* waitEvent) {
     WorkerOrWorkletScriptController* scriptController =
         thread->globalScope()->scriptController();
     scriptController->evaluate(ScriptSourceCode("var counter = 0; ++counter;"));
     waitEvent->signal();
   }
 
   RefPtr<SecurityOrigin> m_securityOrigin;
   std::unique_ptr<WorkerReportingProxy> m_reportingProxy;
+  ScopedTestingPlatformSupport<AnimationWorkletTestPlatform> m_platform;
 };
 
 TEST_F(AnimationWorkletThreadTest, Basic) {
   ScopedTestingPlatformSupport<AnimationWorkletTestPlatform> platform;
 
   std::unique_ptr<AnimationWorkletThread> worklet =
       createAnimationWorkletThread();
   checkWorkletCanExecuteScript(worklet.get());
   worklet->terminateAndWait();
 }
 
 // Tests that the same WebThread is used for new worklets if the WebThread is
 // still alive.
 TEST_F(AnimationWorkletThreadTest, CreateSecondAndTerminateFirst) {
-  ScopedTestingPlatformSupport<AnimationWorkletTestPlatform> platform;
-
   // Create the first worklet and wait until it is initialized.
   std::unique_ptr<AnimationWorkletThread> firstWorklet =
       createAnimationWorkletThread();
   WebThreadSupportingGC* firstThread =
       &firstWorklet->workerBackingThread().backingThread();
   checkWorkletCanExecuteScript(firstWorklet.get());
   v8::Isolate* firstIsolate = firstWorklet->isolate();
   ASSERT_TRUE(firstIsolate);
 
   // Create the second worklet and immediately destroy the first worklet.
@@ skipping 15 matching lines @@
 
   // Verify that the worklet can still successfully execute script.
   checkWorkletCanExecuteScript(secondWorklet.get());
 
   secondWorklet->terminateAndWait();
 }
 
 // Tests that a new WebThread is created if all existing worklets are
 // terminated before a new worklet is created.
 TEST_F(AnimationWorkletThreadTest, TerminateFirstAndCreateSecond) {
-  ScopedTestingPlatformSupport<AnimationWorkletTestPlatform> platform;
-
   // Create the first worklet, wait until it is initialized, and terminate it.
   std::unique_ptr<AnimationWorkletThread> worklet =
       createAnimationWorkletThread();
   WebThreadSupportingGC* firstThread =
       &worklet->workerBackingThread().backingThread();
   checkWorkletCanExecuteScript(worklet.get());
 
   // We don't use terminateAndWait here to avoid forcible termination.
   worklet->terminate();
   worklet->waitForShutdownForTesting();
 
   // Create the second worklet. The backing thread is same.
   worklet = createAnimationWorkletThread();
   WebThreadSupportingGC* secondThread =
       &worklet->workerBackingThread().backingThread();
   EXPECT_EQ(firstThread, secondThread);
   checkWorkletCanExecuteScript(worklet.get());
 
   worklet->terminateAndWait();
 }
 
 // Tests that v8::Isolate and WebThread are correctly set-up if a worklet is
 // created while another is terminating.
 TEST_F(AnimationWorkletThreadTest, CreatingSecondDuringTerminationOfFirst) {
-  ScopedTestingPlatformSupport<AnimationWorkletTestPlatform> platform;
-
   std::unique_ptr<AnimationWorkletThread> firstWorklet =
       createAnimationWorkletThread();
   checkWorkletCanExecuteScript(firstWorklet.get());
   v8::Isolate* firstIsolate = firstWorklet->isolate();
   ASSERT_TRUE(firstIsolate);
 
   // Request termination of the first worklet and create the second worklet
   // as soon as possible.
   firstWorklet->terminate();
   // We don't wait for its termination.
   // Note: We rely on the assumption that the termination steps don't run
   // on the worklet thread so quickly. This could be a source of flakiness.
 
   std::unique_ptr<AnimationWorkletThread> secondWorklet =
       createAnimationWorkletThread();
 
   v8::Isolate* secondIsolate = secondWorklet->isolate();
   ASSERT_TRUE(secondIsolate);
   EXPECT_EQ(firstIsolate, secondIsolate);
 
   // Verify that the isolate can run some scripts correctly in the second
   // worklet.
   checkWorkletCanExecuteScript(secondWorklet.get());
   secondWorklet->terminateAndWait();
 }
 
 }  // namespace blink