Unset CompositorWorkerGlobalScope during WorkerGlobalScope::dipose.

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"
 #include "core/dom/CompositorProxyClient.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/testing/DummyPageHolder.h"
 #include "core/workers/InProcessWorkerObjectProxy.h"
 #include "core/workers/WorkerBackingThread.h"
 #include "core/workers/WorkerLoaderProxy.h"
 #include "core/workers/WorkerOrWorkletGlobalScope.h"
 #include "core/workers/WorkerThreadStartupData.h"
+#include "modules/compositorworker/CompositorWorkerGlobalScope.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "platform/heap/Handle.h"
 #include "platform/testing/TestingPlatformSupport.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAddressSpace.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/PtrUtil.h"
@@ skipping 32 matching lines @@
 
     Persistent<ExecutionContext> m_executionContext;
 };
 
 class TestCompositorProxyClient
     : public GarbageCollected<TestCompositorProxyClient>
     , public CompositorProxyClient {
     USING_GARBAGE_COLLECTED_MIXIN(TestCompositorProxyClient);
 public:
     TestCompositorProxyClient() {}
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        CompositorProxyClient::trace(visitor);
+        visitor->trace(m_globalScope);
+    }
 
-    void setGlobalScope(WorkerGlobalScope*) override {}
+    void setGlobalScope(WorkerGlobalScope* scope) override
+    {
+        m_globalScope = static_cast<CompositorWorkerGlobalScope*>(scope);
+    }
+    CompositorWorkerGlobalScope* globalScope() { return m_globalScope; }
     void requestAnimationFrame() override {}
     void registerCompositorProxy(CompositorProxy*) override {}
     void unregisterCompositorProxy(CompositorProxy*) override {}
+
+private:
+    Member<CompositorWorkerGlobalScope> m_globalScope;
 };
 
 class CompositorWorkerTestPlatform : public TestingPlatformSupport {
 public:
     CompositorWorkerTestPlatform()
         : m_thread(wrapUnique(m_oldPlatform->createThread("Compositor")))
     {
     }
 
     WebThread* compositorThread() const override
@@ skipping 19 matching lines @@
         m_objectProxy = TestCompositorWorkerObjectProxy::create(&m_page->document());
         m_securityOrigin = SecurityOrigin::create(KURL(ParsedURLString, "http://fake.url/"));
     }
 
     void TearDown() override
     {
         m_page.reset();
         CompositorWorkerThread::clearSharedBackingThread();
     }
 
-    std::unique_ptr<CompositorWorkerThread> createCompositorWorker()
+    std::unique_ptr<CompositorWorkerThread> createCompositorWorker(CompositorProxyClient* client = nullptr)
     {
         std::unique_ptr<CompositorWorkerThread> workerThread = CompositorWorkerThread::create(nullptr, *m_objectProxy, 0);
         WorkerClients* clients = WorkerClients::create();
-        provideCompositorProxyClientTo(clients, new TestCompositorProxyClient);
+        if (!client)
+            client = new TestCompositorProxyClient();
+        provideCompositorProxyClientTo(clients, client);
         workerThread->start(WorkerThreadStartupData::create(
             KURL(ParsedURLString, "http://fake.url/"),
             "fake user agent",
             "//fake source code",
             nullptr,
             DontPauseWorkerGlobalScopeOnStart,
             nullptr,
             "",
             m_securityOrigin.get(),
             clients,
             WebAddressSpaceLocal,
             nullptr,
             nullptr,
             V8CacheOptionsDefault));
         return workerThread;
     }
 
     // Attempts to run some simple script for |worker|.
     void checkWorkerCanExecuteScript(WorkerThread* worker)
     {
         std::unique_ptr<WaitableEvent> waitEvent = wrapUnique(new WaitableEvent());
         worker->workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, crossThreadBind(&CompositorWorkerThreadTest::executeScriptInWorker, crossThreadUnretained(this),
             crossThreadUnretained(worker), crossThreadUnretained(waitEvent.get())));
         waitEvent->wait();
     }
 
+    void waitForWorker(WorkerThread* worker)
+    {
+        std::unique_ptr<WaitableEvent> waitEvent = wrapUnique(new WaitableEvent());
+        worker->workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, crossThreadBind(&CompositorWorkerThreadTest::signalFromWorker, crossThreadUnretained(this),
+            crossThreadUnretained(worker), crossThreadUnretained(waitEvent.get())));
+        waitEvent->wait();
+    }
+
 private:
     void executeScriptInWorker(WorkerThread* worker, WaitableEvent* waitEvent)
     {
         WorkerOrWorkletScriptController* scriptController = worker->globalScope()->scriptController();
         bool evaluateResult = scriptController->evaluate(ScriptSourceCode("var counter = 0; ++counter;"));
         ASSERT_UNUSED(evaluateResult, evaluateResult);
         waitEvent->signal();
     }
 
+    void signalFromWorker(WorkerThread* worker, WaitableEvent* waitEvent)
+    {
+        waitEvent->signal();
+    }
+
     std::unique_ptr<DummyPageHolder> m_page;
     RefPtr<SecurityOrigin> m_securityOrigin;
     std::unique_ptr<InProcessWorkerObjectProxy> m_objectProxy;
     CompositorWorkerTestPlatform m_testPlatform;
 };
 
 TEST_F(CompositorWorkerThreadTest, Basic)
 {
     std::unique_ptr<CompositorWorkerThread> compositorWorker = createCompositorWorker();
     checkWorkerCanExecuteScript(compositorWorker.get());
     compositorWorker->terminateAndWait();
 }
 
+TEST_F(CompositorWorkerThreadTest, Shutdown)
+{
+    TestCompositorProxyClient* testClient = new TestCompositorProxyClient;
+    std::unique_ptr<CompositorWorkerThread> compositorWorker = createCompositorWorker(testClient);
+    waitForWorker(compositorWorker.get());
+    // Once the worker has started, we should have a valid global scope.
+    EXPECT_NE(nullptr, testClient->globalScope());
+
+    // After terminating the worker, we should no longer have a reference to the global scope
+    // in the client so that we don't try to execute animation frame callbacks on a terminated
+    // worker.
+    compositorWorker->terminateAndWait();
+    EXPECT_EQ(nullptr, testClient->globalScope());
+}
+
 // 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.
     std::unique_ptr<CompositorWorkerThread> firstWorker = createCompositorWorker();
     WebThreadSupportingGC* firstThread = &firstWorker->workerBackingThread().backingThread();
     checkWorkerCanExecuteScript(firstWorker.get());
     v8::Isolate* firstIsolate = firstWorker->isolate();
     ASSERT_TRUE(firstIsolate);
 
@@ skipping 59 matching lines @@
     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