Reduce the number of delayed tasks on chromium run loop

components/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 "components/scheduler/base/time_domain.h"
 
 #include <set>
 
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_manager_delegate.h"
 #include "components/scheduler/scheduler_export.h"
 
 namespace scheduler {
 
-TimeDomain::TimeDomain() : weak_factory_(this) {}
+TimeDomain::TimeDomain() {}
 
 TimeDomain::~TimeDomain() {}
 
 void TimeDomain::UnregisterQueue(internal::TaskQueueImpl* queue) {
   // We need to remove |task_queue| from delayed_wakeup_multimap_ which is a
   // little awkward since it's keyed by time. O(n) running time.
   for (DelayedWakeupMultimap::iterator iter = delayed_wakeup_multimap_.begin();
        iter != delayed_wakeup_multimap_.end();) {
     if (iter->second == queue) {
       DelayedWakeupMultimap::iterator temp = iter;
       iter++;
       // O(1) amortized.
       delayed_wakeup_multimap_.erase(temp);
     } else {
       iter++;
     }
   }
 
-  // |newly_updatable_| might contain |task_queue|, we use
+  // |newly_updatable_| might contain |queue|, we use
   // MoveNewlyUpdatableQueuesIntoUpdatableQueueSet to flush it out.
   MoveNewlyUpdatableQueuesIntoUpdatableQueueSet();
   updatable_queue_set_.erase(queue);
 }
 
 void TimeDomain::MigrateQueue(internal::TaskQueueImpl* queue,
                               TimeDomain* destination_time_domain) {
   LazyNow destination_lazy_now = destination_time_domain->CreateLazyNow();
   // We need to remove |task_queue| from delayed_wakeup_multimap_ which is a
   // little awkward since it's keyed by time. O(n) running time.
@@ skipping 14 matching lines @@
   // |newly_updatable_| might contain |queue|, we use
   // MoveNewlyUpdatableQueuesIntoUpdatableQueueSet to flush it out.
   MoveNewlyUpdatableQueuesIntoUpdatableQueueSet();
   updatable_queue_set_.erase(queue);
 }
 
 void TimeDomain::ScheduleDelayedWork(internal::TaskQueueImpl* queue,
                                      base::TimeTicks delayed_run_time,
                                      LazyNow* lazy_now) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  // Dedupe wakeups.
-  if (delayed_wakeup_multimap_.find(delayed_run_time) ==
-      delayed_wakeup_multimap_.end()) {
+
+  if (delayed_wakeup_multimap_.empty() ||
+      delayed_run_time < delayed_wakeup_multimap_.begin()->first) {
     base::TimeDelta delay =
         std::max(base::TimeDelta(), delayed_run_time - lazy_now->Now());
-    RequestWakeup(delay);
+    RequestWakeup(lazy_now, delay);
   }
   delayed_wakeup_multimap_.insert(std::make_pair(delayed_run_time, queue));
 }
 
 void TimeDomain::RegisterAsUpdatableTaskQueue(internal::TaskQueueImpl* queue) {
   base::AutoLock lock(newly_updatable_lock_);
   newly_updatable_.push_back(queue);
 }
 
 void TimeDomain::UnregisterAsUpdatableTaskQueue(
@@ skipping 84 matching lines @@
   state->SetString("name", GetName());
   state->BeginArray("updatable_queue_set");
   for (auto& queue : updatable_queue_set_)
     state->AppendString(queue->GetName());
   state->EndArray();
   AsValueIntoInternal(state);
   state->EndDictionary();
 }
 
 }  // namespace scheduler