Make tasks cancellable inside the blink scheduler.

third_party/WebKit/Source/platform/scheduler/base/time_domain.cc

 // 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 "platform/scheduler/base/time_domain.h"
 
 #include <set>
 
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/base/task_queue_manager_delegate.h"
@@ skipping 66 matching lines @@
       delayed_run_time < delayed_wakeup_multimap_.begin()->first) {
     base::TimeDelta delay = std::max(base::TimeDelta(), delayed_run_time - now);
     RequestWakeup(now, delay);
   }
 
   delayed_wakeup_multimap_.insert(std::make_pair(delayed_run_time, queue));
   if (observer_)
     observer_->OnTimeDomainHasDelayedWork();
 }
 
+void TimeDomain::CancelDelayedWork(internal::TaskQueueImpl* queue,
+                                   base::TimeTicks delayed_run_time) {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+
+  auto iterpair = delayed_wakeup_multimap_.equal_range(delayed_run_time);
+  for (auto it = iterpair.first; it != iterpair.second; ++it) {
+    if (it->second == queue) {
+      base::TimeTicks prev_first_wakeup =
+          delayed_wakeup_multimap_.begin()->first;
+      delayed_wakeup_multimap_.erase(it);
+
+      if (delayed_wakeup_multimap_.empty())
+        break;
+
+      base::TimeTicks first_wakeup = delayed_wakeup_multimap_.begin()->first;
+
+      if (first_wakeup == prev_first_wakeup)
+        break;
+
+      // The first wakeup has changed, we need to re-schedule.
+      base::TimeTicks now = Now();
+      base::TimeDelta delay = std::max(base::TimeDelta(), first_wakeup - now);
+      RequestWakeup(now, delay);
+      break;
+    }
+  }
+
+  // Note since the base TaskRunner does not support cancellation there's no
+  // point trying to cancel a wakeup requested via RequestWakeup :(
+}
+
 void TimeDomain::RegisterAsUpdatableTaskQueue(internal::TaskQueueImpl* queue) {
   {
     base::AutoLock lock(newly_updatable_lock_);
     newly_updatable_.push_back(queue);
   }
   if (observer_)
     observer_->OnTimeDomainHasImmediateWork();
 }
 
 bool TimeDomain::UnregisterAsUpdatableTaskQueue(
@@ skipping 116 matching lines @@
   if (!delayed_wakeup_multimap_.empty()) {
     base::TimeDelta delay = delayed_wakeup_multimap_.begin()->first - Now();
     state->SetDouble("next_delay_ms", delay.InMillisecondsF());
   }
   AsValueIntoInternal(state);
   state->EndDictionary();
 }
 
 }  // namespace scheduler
 }  // namespace blink