Fix memory leak with ScriptedIdleTaskController

third_party/WebKit/Source/core/dom/ScriptedIdleTaskController.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 "core/dom/ScriptedIdleTaskController.h"
 
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/IdleRequestCallback.h"
 #include "core/dom/IdleRequestOptions.h"
 #include "core/frame/PerformanceMonitor.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "platform/Histogram.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/Functional.h"
 #include "wtf/RefCounted.h"
 
 namespace blink {
 
 namespace internal {
 
 class IdleRequestCallbackWrapper
     : public RefCounted<IdleRequestCallbackWrapper> {
  public:
   static PassRefPtr<IdleRequestCallbackWrapper> create(
       ScriptedIdleTaskController::CallbackId id,
-      ScriptedIdleTaskController* controller) {
+      WTF::WeakPtr<ScriptedIdleTaskController> controller) {
     return adoptRef(new IdleRequestCallbackWrapper(id, controller));
   }
   virtual ~IdleRequestCallbackWrapper() {}
 
   static void idleTaskFired(
       PassRefPtr<IdleRequestCallbackWrapper> callbackWrapper,
       double deadlineSeconds) {
     // TODO(rmcilroy): Implement clamping of deadline in some form.
     if (ScriptedIdleTaskController* controller = callbackWrapper->controller())
       controller->callbackFired(callbackWrapper->id(), deadlineSeconds,
                                 IdleDeadline::CallbackType::CalledWhenIdle);
     callbackWrapper->cancel();
   }
 
   static void timeoutFired(
       PassRefPtr<IdleRequestCallbackWrapper> callbackWrapper) {
     if (ScriptedIdleTaskController* controller = callbackWrapper->controller())
       controller->callbackFired(callbackWrapper->id(),
                                 monotonicallyIncreasingTime(),
                                 IdleDeadline::CallbackType::CalledByTimeout);
     callbackWrapper->cancel();
   }
 
   void cancel() { m_controller = nullptr; }
 
   ScriptedIdleTaskController::CallbackId id() const { return m_id; }
-  ScriptedIdleTaskController* controller() const { return m_controller; }
+  ScriptedIdleTaskController* controller() const { return m_controller.get(); }
 
  private:
-  IdleRequestCallbackWrapper(ScriptedIdleTaskController::CallbackId id,
-                             ScriptedIdleTaskController* controller)
+  IdleRequestCallbackWrapper(
+      ScriptedIdleTaskController::CallbackId id,
+      WTF::WeakPtr<ScriptedIdleTaskController> controller)
       : m_id(id), m_controller(controller) {}
 
   ScriptedIdleTaskController::CallbackId m_id;
-  Persistent<ScriptedIdleTaskController> m_controller;
+  WTF::WeakPtr<ScriptedIdleTaskController> m_controller;

[sof, 2017/01/06 09:31:04]

WeakPersistent<> is used to hold onto GC-managed objects weakly.

[Xiaocheng, 2017/01/06 09:56:28]

Done.

Thanks!

 };
 
 }  // namespace internal
 
 ScriptedIdleTaskController::ScriptedIdleTaskController(
     ExecutionContext* context)
     : SuspendableObject(context),
       m_scheduler(Platform::current()->currentThread()->scheduler()),
       m_nextCallbackId(0),
+      m_weakPtrFactory(this),
       m_suspended(false) {
   suspendIfNeeded();
 }
 
 ScriptedIdleTaskController::~ScriptedIdleTaskController() {}
 
 DEFINE_TRACE(ScriptedIdleTaskController) {
   visitor->trace(m_callbacks);
   SuspendableObject::trace(visitor);
 }
@@ skipping 12 matching lines @@
 
 ScriptedIdleTaskController::CallbackId
 ScriptedIdleTaskController::registerCallback(
     IdleRequestCallback* callback,
     const IdleRequestOptions& options) {
   CallbackId id = nextCallbackId();
   m_callbacks.set(id, callback);
   long long timeoutMillis = options.timeout();
 
   RefPtr<internal::IdleRequestCallbackWrapper> callbackWrapper =
-      internal::IdleRequestCallbackWrapper::create(id, this);
+      internal::IdleRequestCallbackWrapper::create(
+          id, m_weakPtrFactory.createWeakPtr());
   m_scheduler->postIdleTask(
       BLINK_FROM_HERE,
       WTF::bind(&internal::IdleRequestCallbackWrapper::idleTaskFired,
                 callbackWrapper));
   if (timeoutMillis > 0)
     m_scheduler->timerTaskRunner()->postDelayedTask(
         BLINK_FROM_HERE,
         WTF::bind(&internal::IdleRequestCallbackWrapper::timeoutFired,
                   callbackWrapper),
         timeoutMillis);
@@ skipping 65 matching lines @@
       std::max((monotonicallyIncreasingTime() - deadlineSeconds) * 1000, 0.0);
 
   DEFINE_STATIC_LOCAL(
       CustomCountHistogram, idleCallbackOverrunHistogram,
       ("WebCore.ScriptedIdleTaskController.IdleCallbackOverrun", 0, 10000, 50));
   idleCallbackOverrunHistogram.count(overrunMillis);
 }
 
 void ScriptedIdleTaskController::contextDestroyed() {
   m_callbacks.clear();
+  m_weakPtrFactory.revokeAll();
 }
 
 void ScriptedIdleTaskController::suspend() {
   m_suspended = true;
 }
 
 void ScriptedIdleTaskController::resume() {
   DCHECK(m_suspended);
   m_suspended = false;
 
   // Run any pending timeouts.
   Vector<CallbackId> pendingTimeouts;
   m_pendingTimeouts.swap(pendingTimeouts);
   for (auto& id : pendingTimeouts)
     runCallback(id, monotonicallyIncreasingTime(),
                 IdleDeadline::CallbackType::CalledByTimeout);
 
   // Repost idle tasks for any remaining callbacks.
   for (auto& callback : m_callbacks) {
     RefPtr<internal::IdleRequestCallbackWrapper> callbackWrapper =
-        internal::IdleRequestCallbackWrapper::create(callback.key, this);
+        internal::IdleRequestCallbackWrapper::create(
+            callback.key, m_weakPtrFactory.createWeakPtr());
     m_scheduler->postIdleTask(
         BLINK_FROM_HERE,
         WTF::bind(&internal::IdleRequestCallbackWrapper::idleTaskFired,
                   callbackWrapper));
   }
 }
 
 }  // namespace blink