LeakDetector should run a GC on the compositor thread

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

 // Copyright 2016 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/AbstractAnimationWorkletThread.h"
 
 #include "core/workers/WorkerBackingThread.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/WebThreadSupportingGC.h"
 #include "public/platform/Platform.h"
 #include "wtf/Assertions.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 // This is a singleton class holding the animation worklet thread in this
 // renderer process. BackingThreadHolder::m_thread is cleared by
 // ModulesInitializer::shutdown.
 // See WorkerThread::terminateAndWaitForAllWorkers for the process shutdown
 // case.
 class BackingThreadHolder {
 public:
-    static BackingThreadHolder& instance()
+    static BackingThreadHolder* instance()
     {
         MutexLocker locker(holderInstanceMutex());
-        return *s_instance;
+        return s_instance;
     }
 
     static void ensureInstance()
     {
         if (!s_instance)
             s_instance = new BackingThreadHolder;
     }
 
     static void clear()
     {
@@ skipping 64 matching lines @@
     : WorkerThread(std::move(workerLoaderProxy), workerReportingProxy)
 {
 }
 
 AbstractAnimationWorkletThread::~AbstractAnimationWorkletThread()
 {
 }
 
 WorkerBackingThread& AbstractAnimationWorkletThread::workerBackingThread()
 {
-    return *BackingThreadHolder::instance().thread();
+    return *BackingThreadHolder::instance()->thread();
+}
+
+void collectAllGarbageOnThread(WaitableEvent* doneEvent)
+{
+    blink::ThreadState::current()->collectAllGarbage();
+    doneEvent->signal();
+}
+
+void AbstractAnimationWorkletThread::collectAllGarbage()
+{
+    DCHECK(isMainThread());
+    WaitableEvent doneEvent;
+    BackingThreadHolder* instance = BackingThreadHolder::instance();
+    if (!instance)
+        return;
+    instance->thread()->backingThread().postTask(BLINK_FROM_HERE, crossThreadBind(&collectAllGarbageOnThread, crossThreadUnretained(&doneEvent)));
+    doneEvent.wait();
 }
 
 void AbstractAnimationWorkletThread::ensureSharedBackingThread()
 {
     DCHECK(isMainThread());
     BackingThreadHolder::ensureInstance();
 }
 
 void AbstractAnimationWorkletThread::clearSharedBackingThread()
 {
     DCHECK(isMainThread());
     BackingThreadHolder::clear();
 }
 
 void AbstractAnimationWorkletThread::createSharedBackingThreadForTest()
 {
     BackingThreadHolder::createForTest();
 }
 
 } // namespace blink