compositor-worker: Get the thread to run compositor-workers from the Platform.

Source/modules/compositorworker/CompositorWorkerManagerTest.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 "config.h"
 #include "modules/compositorworker/CompositorWorkerManager.h"
 
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/testing/DummyPageHolder.h"
@@ skipping 106 matching lines @@
 
     void createWorkerAdapter(RefPtr<CompositorWorkerThread>* workerThread, WebWaitableEvent* creationEvent)
     {
         *workerThread = createCompositorWorker(creationEvent);
     }
 
     // Attempts to run some simple script for |worker|.
     void checkWorkerCanExecuteScript(WorkerThread* worker)
     {
         OwnPtr<WebWaitableEvent> waitEvent = adoptPtr(Platform::current()->createWaitableEvent());
-        worker->backingThread().platformThread().postTask(FROM_HERE, threadSafeBind(&CompositorWorkerManagerTest::executeScriptInWorker, AllowCrossThreadAccess(this),
+        worker->backingThread().postTask(FROM_HERE, threadSafeBind(&CompositorWorkerManagerTest::executeScriptInWorker, AllowCrossThreadAccess(this),
             AllowCrossThreadAccess(worker), AllowCrossThreadAccess(waitEvent.get())));
         waitEvent->wait();
     }
 
     void waitForWaitableEventAfterIteratingCurrentLoop(WebWaitableEvent* waitEvent)
     {
         testing::runPendingTasks();
         waitEvent->wait();
     }
 
@@ skipping 29 matching lines @@
     checkWorkerCanExecuteScript(compositorWorker.get());
     compositorWorker->terminateAndWait();
 }
 
 // Tests that the same WebThread is used for new workers if the WebThread is still alive.
 TEST_F(CompositorWorkerManagerTest, CreateSecondAndTerminateFirst)
 {
     // Create the first worker and wait until it is initialized.
     OwnPtr<WebWaitableEvent> firstCreationEvent = adoptPtr(Platform::current()->createWaitableEvent());
     RefPtr<CompositorWorkerThread> firstWorker = createCompositorWorker(firstCreationEvent.get());
-    WebThreadSupportingGC* firstThread = &CompositorWorkerManager::instance()->compositorWorkerThread();
+    WebThread* firstThread = &CompositorWorkerManager::instance()->compositorWorkerThread();
     ASSERT(firstThread);
     waitForWaitableEventAfterIteratingCurrentLoop(firstCreationEvent.get());
     v8::Isolate* firstIsolate = firstWorker->isolate();
     ASSERT(firstIsolate);
 
     // Create the second worker and immediately destroy the first worker.
     OwnPtr<WebWaitableEvent> secondCreationEvent = adoptPtr(Platform::current()->createWaitableEvent());
     RefPtr<CompositorWorkerThread> secondWorker = createCompositorWorker(secondCreationEvent.get());
     firstWorker->terminateAndWait();
 
     // Wait until the second worker is initialized. Verify that the second worker is using the same
     // thread and Isolate as the first worker.
-    WebThreadSupportingGC* secondThread = &CompositorWorkerManager::instance()->compositorWorkerThread();
+    WebThread* secondThread = &CompositorWorkerManager::instance()->compositorWorkerThread();
     ASSERT(secondThread);
     waitForWaitableEventAfterIteratingCurrentLoop(secondCreationEvent.get());
     EXPECT_EQ(firstThread, secondThread);
 
     v8::Isolate* secondIsolate = secondWorker->isolate();
     ASSERT(secondIsolate);
     EXPECT_EQ(firstIsolate, secondIsolate);
 
     // Verify that the worker can still successfully execute script.
     checkWorkerCanExecuteScript(secondWorker.get());
 
     secondWorker->terminateAndWait();
 }
 
 static void checkCurrentIsolate(v8::Isolate* isolate, WebWaitableEvent* event)
 {
     EXPECT_EQ(v8::Isolate::GetCurrent(), isolate);
     event->signal();
 }
 
 // Tests that a new WebThread is created if all existing workers are terminated before a new worker is created.
 TEST_F(CompositorWorkerManagerTest, TerminateFirstAndCreateSecond)
 {
     // Create the first worker, wait until it is initialized, and terminate it.
     OwnPtr<WebWaitableEvent> creationEvent = adoptPtr(Platform::current()->createWaitableEvent());
     RefPtr<CompositorWorkerThread> compositorWorker = createCompositorWorker(creationEvent.get());
-    WebThreadSupportingGC* firstThread = &CompositorWorkerManager::instance()->compositorWorkerThread();
+    WebThread* firstThread = &CompositorWorkerManager::instance()->compositorWorkerThread();
     waitForWaitableEventAfterIteratingCurrentLoop(creationEvent.get());
     ASSERT(compositorWorker->isolate());
     compositorWorker->terminateAndWait();
 
     // Create the second worker. Verify that the second worker lives in a different WebThread since the first
     // thread will have been destroyed after destroying the first worker.
     creationEvent = adoptPtr(Platform::current()->createWaitableEvent());
     compositorWorker = createCompositorWorker(creationEvent.get());
-    WebThreadSupportingGC* secondThread = &CompositorWorkerManager::instance()->compositorWorkerThread();
+    WebThread* secondThread = &CompositorWorkerManager::instance()->compositorWorkerThread();
     EXPECT_NE(firstThread, secondThread);
     waitForWaitableEventAfterIteratingCurrentLoop(creationEvent.get());
 
     // Jump over to the worker's thread to verify that the Isolate is set up correctly and execute script.
     OwnPtr<WebWaitableEvent> checkEvent = adoptPtr(Platform::current()->createWaitableEvent());
-    secondThread->platformThread().postTask(FROM_HERE, threadSafeBind(&checkCurrentIsolate, AllowCrossThreadAccess(compositorWorker->isolate()), AllowCrossThreadAccess(checkEvent.get())));
+    secondThread->postTask(FROM_HERE, threadSafeBind(&checkCurrentIsolate, AllowCrossThreadAccess(compositorWorker->isolate()), AllowCrossThreadAccess(checkEvent.get())));
     waitForWaitableEventAfterIteratingCurrentLoop(checkEvent.get());
     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(CompositorWorkerManagerTest, CreatingSecondDuringTerminationOfFirst)
 {
     OwnPtr<WebWaitableEvent> firstCreationEvent = adoptPtr(Platform::current()->createWaitableEvent());
@@ skipping 14 matching lines @@
     v8::Isolate* secondIsolate = secondWorker->isolate();
     ASSERT(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