[Reland] Make canceling Timers fast.

third_party/WebKit/Source/platform/Timer.cpp

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 25 matching lines @@
 #include <algorithm>
 #include <limits.h>
 #include <limits>
 #include <math.h>
 
 namespace blink {
 
 TimerBase::TimerBase(WebTaskRunner* webTaskRunner)
     : m_nextFireTime(0)
     , m_repeatInterval(0)
-    , m_cancellableTimerTask(nullptr)
     , m_webTaskRunner(webTaskRunner->clone())
 #if DCHECK_IS_ON()
     , m_thread(currentThread())
 #endif
+    , m_weakPtrFactory(this)
 {
     ASSERT(m_webTaskRunner);
 }
 
 TimerBase::~TimerBase()
 {
     stop();
 }
 
 void TimerBase::start(double nextFireInterval, double repeatInterval, const WebTraceLocation& caller)
 {
     ASSERT(m_thread == currentThread());
 
     m_location = caller;
     m_repeatInterval = repeatInterval;
     setNextFireTime(timerMonotonicallyIncreasingTime(), nextFireInterval);
 }
 
 void TimerBase::stop()
 {
     ASSERT(m_thread == currentThread());
 
     m_repeatInterval = 0;
     m_nextFireTime = 0;
-    if (m_cancellableTimerTask)
-        m_cancellableTimerTask->cancel();
-    m_cancellableTimerTask = nullptr;
+    m_weakPtrFactory.revokeAll();
 }
 
 double TimerBase::nextFireInterval() const
 {
     ASSERT(isActive());
     double current = timerMonotonicallyIncreasingTime();
     if (m_nextFireTime < current)
         return 0;
     return m_nextFireTime - current;
 }
@@ skipping 16 matching lines @@
 }
 
 void TimerBase::setNextFireTime(double now, double delay)
 {
     ASSERT(m_thread == currentThread());
 
     double newTime = now + delay;
 
     if (m_nextFireTime != newTime) {
         m_nextFireTime = newTime;
-        if (m_cancellableTimerTask)
-            m_cancellableTimerTask->cancel();
-        m_cancellableTimerTask = new CancellableTimerTask(this);
+
+        // Cancel any previously posted task.
+        m_weakPtrFactory.revokeAll();
 
         double delayMs = 1000.0 * (newTime - now);
-        timerTaskRunner()->postDelayedTask(m_location, m_cancellableTimerTask, delayMs);
+        timerTaskRunner()->postDelayedTask(m_location, base::Bind(&TimerBase::runInternal, m_weakPtrFactory.createWeakPtr()), delayMs);
     }
 }
 
 NO_LAZY_SWEEP_SANITIZE_ADDRESS
 void TimerBase::runInternal()
 {
     if (!canFire())
         return;
 
+    m_weakPtrFactory.revokeAll();

[haraken, 2016/09/09 02:34:07]

Maybe do we want to move this to above line 124?

However, I'm not sure if we really need to call revokeAll() here. Given that
it's guaranteed that only one timer is scheduled in the task queue (can we add
DCHECK about this fact?), there should be no active weak pointers when
runInternal() is fired.

[alex clarke (OOO till 29th), 2016/09/09 09:40:58]

We do need to call it here to match the previous behavior of TimerBase::isActive

[alex clarke (OOO till 29th), 2016/09/12 11:07:18]

It looks moving this above caused the bot failures.  Lets try with it below. 
Considering it's about to get swept away maybe the result of TimerBase::isActive
doesn't matter?

+
     TRACE_EVENT0("blink", "TimerBase::run");
 #if DCHECK_IS_ON()
     DCHECK_EQ(m_thread, currentThread()) << "Timer posted by " << m_location.function_name() << " " << m_location.file_name() << " was run on a different thread";
 #endif
     TRACE_EVENT_SET_SAMPLING_STATE("blink", "BlinkInternal");
 
     if (m_repeatInterval) {
         double now = timerMonotonicallyIncreasingTime();
         // This computation should be drift free, and it will cope if we miss a beat,
         // which can easily happen if the thread is busy.  It will also cope if we get
@@ skipping 13 matching lines @@
     return a->m_nextFireTime < b->m_nextFireTime;
 }
 
 // static
 double TimerBase::timerMonotonicallyIncreasingTime() const
 {
     return timerTaskRunner()->monotonicallyIncreasingVirtualTimeSeconds();
 }
 
 } // namespace blink