Remove after wakeup logic and replace PumpTask with Fences

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 133 matching lines @@
       newly_updatable_[i] = newly_updatable_.back();
       newly_updatable_.pop_back();
       was_updatable = true;
     } else {
       i++;
     }
   }
   return was_updatable;
 }
 
-void TimeDomain::UpdateWorkQueues(
-    bool should_trigger_wakeup,
-    const internal::TaskQueueImpl::Task* previous_task,
-    LazyNow lazy_now) {
+void TimeDomain::UpdateWorkQueues(LazyNow lazy_now) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   // Move any ready delayed tasks into the Incoming queues.
-  WakeupReadyDelayedQueues(&lazy_now, should_trigger_wakeup, previous_task);
+  WakeupReadyDelayedQueues(&lazy_now);
 
   MoveNewlyUpdatableQueuesIntoUpdatableQueueSet();
 
   auto iter = updatable_queue_set_.begin();
   while (iter != updatable_queue_set_.end()) {
     internal::TaskQueueImpl* queue = *iter++;
     // NOTE Update work queue may erase itself from |updatable_queue_set_|.
     // This is fine, erasing an element won't invalidate any interator, as long
     // as the iterator isn't the element being delated.
     if (queue->immediate_work_queue()->Empty())
-      queue->UpdateImmediateWorkQueue(should_trigger_wakeup, previous_task);
+      queue->UpdateImmediateWorkQueue();
   }
 }
 
 void TimeDomain::MoveNewlyUpdatableQueuesIntoUpdatableQueueSet() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   base::AutoLock lock(newly_updatable_lock_);
   while (!newly_updatable_.empty()) {
     updatable_queue_set_.insert(newly_updatable_.back());
     newly_updatable_.pop_back();
   }
 }
 
-void TimeDomain::WakeupReadyDelayedQueues(
-    LazyNow* lazy_now,
-    bool should_trigger_wakeup,
-    const internal::TaskQueueImpl::Task* previous_task) {
+void TimeDomain::WakeupReadyDelayedQueues(LazyNow* lazy_now) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // Wake up any queues with pending delayed work.  Note std::multipmap stores
   // the elements sorted by key, so the begin() iterator points to the earliest
   // queue to wakeup.
   std::set<internal::TaskQueueImpl*> dedup_set;
   while (!delayed_wakeup_multimap_.empty()) {
     DelayedWakeupMultimap::iterator next_wakeup =
         delayed_wakeup_multimap_.begin();
     if (next_wakeup->first > lazy_now->Now())
       break;
     // A queue could have any number of delayed tasks pending so it's worthwhile
     // deduping calls to UpdateDelayedWorkQueue since it takes a lock.
     // NOTE the order in which these are called matters since the order
     // in which EnqueueTaskLocks is called is respected when choosing which
     // queue to execute a task from.
     if (dedup_set.insert(next_wakeup->second).second) {
-      next_wakeup->second->UpdateDelayedWorkQueue(
-          lazy_now, should_trigger_wakeup, previous_task);
+      next_wakeup->second->UpdateDelayedWorkQueue(lazy_now);
     }
     delayed_wakeup_multimap_.erase(next_wakeup);
   }
 }
 
 void TimeDomain::ClearExpiredWakeups() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   LazyNow lazy_now(CreateLazyNow());
   while (!delayed_wakeup_multimap_.empty()) {
     DelayedWakeupMultimap::iterator next_wakeup =
@@ skipping 33 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