// Tests that v8::Isolate and WebThread are correctly set-up if a worker is created while another is terminating.
TEST_F(CompositorWorkerThreadTest, CreatingSecondDuringTerminationOfFirst)
{
OwnPtr<WaitableEvent> firstCreationEvent = adoptPtr(new WaitableEvent());
OwnPtr<TestCompositorWorkerThread> firstWorker = createCompositorWorker(firstCreationEvent.get());
waitForWaitableEventAfterIteratingCurrentLoop(firstCreationEvent.get());
v8::Isolate* firstIsolate = firstWorker->isolate();
ASSERT(firstIsolate);
// Request termination of the first worker, and set-up to make sure the second worker is created right as
// the first worker terminates its isolate.
OwnPtr<WaitableEvent> secondCreationEvent = adoptPtr(new WaitableEvent());
OwnPtr<CompositorWorkerThread> secondWorker;
firstWorker->setCallbackAfterV8Termination(bind(&CompositorWorkerThreadTest::createWorkerAdapter, this, &secondWorker, secondCreationEvent.get()));
firstWorker->terminateAndWait();
ASSERT(secondWorker);
waitForWaitableEventAfterIteratingCurrentLoop(secondCreationEvent.get());
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();
}
// Tests that a new WebThread is created if all existing workers are terminated before a new worker is created.
TEST_F(CompositorWorkerThreadTest, TerminateFirstAndCreateSecond)
{
// Create the first worker, wait until it is initialized, and terminate it.
OwnPtr<WaitableEvent> creationEvent = adoptPtr(new WaitableEvent());
OwnPtr<CompositorWorkerThread> compositorWorker = createCompositorWorker(creationEvent.get());
WebThreadSupportingGC* firstThread = CompositorWorkerThread::sharedBackingThread();
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(new WaitableEvent());
compositorWorker = createCompositorWorker(creationEvent.get());
WebThreadSupportingGC* secondThread = CompositorWorkerThread::sharedBackingThread();
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<WaitableEvent> checkEvent = adoptPtr(new WaitableEvent());
secondThread->platformThread().getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&checkCurrentIsolate, AllowCrossThreadAccess(compositorWorker->isolate()), AllowCrossThreadAccess(checkEvent.get())));
waitForWaitableEventAfterIteratingCurrentLoop(checkEvent.get());
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)
{
// Create the first worker and wait until it is initialized.
OwnPtr<WaitableEvent> firstCreationEvent = adoptPtr(new WaitableEvent());
OwnPtr<CompositorWorkerThread> firstWorker = createCompositorWorker(firstCreationEvent.get());
WebThreadSupportingGC* firstThread = CompositorWorkerThread::sharedBackingThread();
ASSERT(firstThread);
waitForWaitableEventAfterIteratingCurrentLoop(firstCreationEvent.get());
v8::Isolate* firstIsolate = firstWorker->isolate();
ASSERT(firstIsolate);
// Create the second worker and immediately destroy the first worker.
OwnPtr<WaitableEvent> secondCreationEvent = adoptPtr(new WaitableEvent());
OwnPtr<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 = CompositorWorkerThread::sharedBackingThread();
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();
}
TEST_F(CompositorWorkerThreadTest, Basic)
{
OwnPtr<WaitableEvent> creationEvent = adoptPtr(new WaitableEvent());
OwnPtr<CompositorWorkerThread> compositorWorker = createCompositorWorker(creationEvent.get());
waitForWaitableEventAfterIteratingCurrentLoop(creationEvent.get());
checkWorkerCanExecuteScript(compositorWorker.get());
compositorWorker->terminateAndWait();
}
TEST_F(CompositorWorkerManagerTest, Basic)
{
OwnPtr<WebWaitableEvent> creationEvent = adoptPtr(Platform::current()->createWaitableEvent());
RefPtr<CompositorWorkerThread> compositorWorker = createCompositorWorker(creationEvent.get());
waitForWaitableEventAfterIteratingCurrentLoop(creationEvent.get());
checkWorkerCanExecuteScript(compositorWorker.get());
compositorWorker->terminateAndWait();
}
