Unset CompositorWorkerGlobalScope during WorkerGlobalScope::dipose.

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

Index: third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThreadTest.cpp
diff --git a/third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThreadTest.cpp b/third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThreadTest.cpp
index 9220ccc44d39e2dbd92972069dd7b515e88551e9..3c06a9b90afa9a61339b87635f37434c1d988b86 100644
--- a/third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThreadTest.cpp
+++ b/third_party/WebKit/Source/modules/compositorworker/CompositorWorkerThreadTest.cpp
@@ -16,6 +16,7 @@
 #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"
@@ -68,11 +69,23 @@ class TestCompositorProxyClient
     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 {
@@ -112,11 +125,13 @@ public:
         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",
@@ -143,6 +158,14 @@ public:
         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)
     {
@@ -152,6 +175,11 @@ private:
         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;
@@ -165,6 +193,21 @@ TEST_F(CompositorWorkerThreadTest, Basic)
     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)
 {