Remove after wakeup logic and replace PumpTask with Fences

third_party/WebKit/Source/platform/scheduler/renderer/throttling_helper.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/renderer/throttling_helper.h"
 
 #include "base/logging.h"
 #include "platform/scheduler/base/real_time_domain.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate.h"
 #include "platform/scheduler/renderer/auto_advancing_virtual_time_domain.h"
@@ skipping 22 matching lines @@
 
   renderer_scheduler_->RegisterTimeDomain(time_domain_.get());
 }
 
 ThrottlingHelper::~ThrottlingHelper() {
   // It's possible for queues to be still throttled, so we need to tidy up
   // before unregistering the time domain.
   for (const TaskQueueMap::value_type& map_entry : throttled_queues_) {
     TaskQueue* task_queue = map_entry.first;
     task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
-    task_queue->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO);
+    task_queue->RemoveFence();
   }
 
   renderer_scheduler_->UnregisterTimeDomain(time_domain_.get());
 }
 
 void ThrottlingHelper::SetQueueEnabled(TaskQueue* task_queue, bool enabled) {
   TaskQueueMap::iterator find_it = throttled_queues_.find(task_queue);
 
   if (find_it == throttled_queues_.end()) {
     task_queue->SetQueueEnabled(enabled);
@@ skipping 15 matching lines @@
   if (virtual_time_)
     return;
 
   std::pair<TaskQueueMap::iterator, bool> insert_result =
       throttled_queues_.insert(std::make_pair(
           task_queue, Metadata(1, task_queue->IsQueueEnabled())));
 
   if (insert_result.second) {
     // The insert was succesful so we need to throttle the queue.
     task_queue->SetTimeDomain(time_domain_.get());
-    task_queue->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL);
+    task_queue->RemoveFence();
     task_queue->SetQueueEnabled(false);
 
     if (!task_queue->IsEmpty()) {
       if (task_queue->HasPendingImmediateWork()) {
         OnTimeDomainHasImmediateWork();
       } else {
         OnTimeDomainHasDelayedWork();
       }
     }
   } else {
     // An entry already existed in the map so we need to increment the refcount.
     insert_result.first->second.throttling_ref_count++;
   }
 }
 
 void ThrottlingHelper::DecreaseThrottleRefCount(TaskQueue* task_queue) {
   if (virtual_time_)
     return;
 
   TaskQueueMap::iterator iter = throttled_queues_.find(task_queue);
 
   if (iter != throttled_queues_.end() &&
       --iter->second.throttling_ref_count == 0) {
     bool enabled = iter->second.enabled;
     // The refcount has become zero, we need to unthrottle the queue.
     throttled_queues_.erase(iter);
 
     task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
-    task_queue->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO);
+    task_queue->RemoveFence();
     task_queue->SetQueueEnabled(enabled);
   }
 }
 
+bool ThrottlingHelper::IsThrottled(TaskQueue* task_queue) const {
+  return throttled_queues_.find(task_queue) != throttled_queues_.end();
+}
+
 void ThrottlingHelper::UnregisterTaskQueue(TaskQueue* task_queue) {
   throttled_queues_.erase(task_queue);
 }
 
 void ThrottlingHelper::OnTimeDomainHasImmediateWork() {
   // Forward to the main thread if called from another thread.
   if (!task_runner_->RunsTasksOnCurrentThread()) {
     task_runner_->PostTask(FROM_HERE, forward_immediate_work_closure_);
     return;
   }
@@ skipping 15 matching lines @@
                                         next_scheduled_delayed_task);
 }
 
 void ThrottlingHelper::PumpThrottledTasks() {
   TRACE_EVENT0(tracing_category_, "ThrottlingHelper::PumpThrottledTasks");
   pending_pump_throttled_tasks_runtime_ = base::TimeTicks();
 
   LazyNow lazy_low(tick_clock_);
   for (const TaskQueueMap::value_type& map_entry : throttled_queues_) {
     TaskQueue* task_queue = map_entry.first;
-    if (task_queue->IsEmpty())
+    if (!map_entry.second.enabled || task_queue->IsEmpty())
       continue;
 
-    task_queue->SetQueueEnabled(map_entry.second.enabled);
-    task_queue->PumpQueue(&lazy_low, false);
+    task_queue->SetQueueEnabled(true);
+    task_queue->InsertFence();
   }
   // Make sure NextScheduledRunTime gives us an up-to date result.
   time_domain_->ClearExpiredWakeups();
 
   base::TimeTicks next_scheduled_delayed_task;
   // Maybe schedule a call to ThrottlingHelper::PumpThrottledTasks if there is
   // a pending delayed task. NOTE posting a non-delayed task in the future will
   // result in ThrottlingHelper::OnTimeDomainHasImmediateWork being called.
   if (time_domain_->NextScheduledRunTime(&next_scheduled_delayed_task)) {
     MaybeSchedulePumpThrottledTasksLocked(FROM_HERE, lazy_low.Now(),
@@ skipping 42 matching lines @@
 
   pump_throttled_tasks_closure_.Cancel();
 
   while (!throttled_queues_.empty()) {
     TaskQueue* task_queue = throttled_queues_.begin()->first;
     bool enabled = throttled_queues_.begin()->second.enabled;
 
     throttled_queues_.erase(throttled_queues_.begin());
 
     task_queue->SetTimeDomain(renderer_scheduler_->GetVirtualTimeDomain());
-    task_queue->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO);
+    task_queue->RemoveFence();
     task_queue->SetQueueEnabled(enabled);
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink