Move throttling of background timers into the renderer scheduler

components/scheduler/renderer/web_frame_scheduler_impl.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/renderer/web_frame_scheduler_impl.h"
 
+#include "components/scheduler/base/real_time_domain.h"
+#include "components/scheduler/base/virtual_time_domain.h"
 #include "components/scheduler/child/web_task_runner_impl.h"
 #include "components/scheduler/renderer/renderer_scheduler_impl.h"
 #include "components/scheduler/renderer/web_view_scheduler_impl.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace scheduler {
 
 WebFrameSchedulerImpl::WebFrameSchedulerImpl(
     RendererSchedulerImpl* renderer_scheduler,
     WebViewSchedulerImpl* parent_web_view_scheduler)
     : renderer_scheduler_(renderer_scheduler),
       parent_web_view_scheduler_(parent_web_view_scheduler),
-      visible_(true) {}
+      visible_(true),
+      page_in_background_(false) {}
 
 WebFrameSchedulerImpl::~WebFrameSchedulerImpl() {
   if (loading_task_queue_.get())
     loading_task_queue_->UnregisterTaskQueue();
 
   if (timer_task_queue_.get())
     timer_task_queue_->UnregisterTaskQueue();
 
   if (parent_web_view_scheduler_)
     parent_web_view_scheduler_->Unregister(this);
+
+  renderer_scheduler_->throttling_helper()->Unregister(this);
 }
 
 void WebFrameSchedulerImpl::DetachFromWebViewScheduler() {
   parent_web_view_scheduler_ = nullptr;
 }
 
 void WebFrameSchedulerImpl::setFrameVisible(bool visible) {
   visible_ = visible;
   // TODO(alexclarke): Do something with this flag.
 }
 
 blink::WebTaskRunner* WebFrameSchedulerImpl::loadingTaskRunner() {
   if (!loading_web_task_runner_) {
     loading_task_queue_ =
         renderer_scheduler_->NewLoadingTaskRunner("frame_loading_tq");
     loading_web_task_runner_.reset(new WebTaskRunnerImpl(loading_task_queue_));
   }
   return loading_web_task_runner_.get();
 }
 
 blink::WebTaskRunner* WebFrameSchedulerImpl::timerTaskRunner() {
   if (!timer_web_task_runner_) {
     timer_task_queue_ =
         renderer_scheduler_->NewTimerTaskRunner("frame_timer_tq");
+    ApplyPolicyToTimerQueue();
     timer_web_task_runner_.reset(new WebTaskRunnerImpl(timer_task_queue_));
   }
   return timer_web_task_runner_.get();
 }
 
 void WebFrameSchedulerImpl::setFrameOrigin(
     const blink::WebSecurityOrigin* origin) {
   DCHECK(origin);
   origin_ = *origin;
   // TODO(skyostil): Associate the task queues with this origin.
 }
 
+void WebFrameSchedulerImpl::SetPageInBackground(bool page_in_background) {
+  if (page_in_background_ == page_in_background)
+    return;
+
+  page_in_background_ = page_in_background;
+
+  if (!timer_task_queue_)
+    return;
+
+  ApplyPolicyToTimerQueue();
+}
+
+void WebFrameSchedulerImpl::ApplyPolicyToTimerQueue() {
+  if (page_in_background_) {
+    timer_task_queue_->SetTimeDomain(
+        renderer_scheduler_->throttling_helper()->time_domain());
+  } else {
+    timer_task_queue_->SetTimeDomain(renderer_scheduler_->real_time_domain());
+  }
+  timer_task_queue_->SetPumpPolicy(page_in_background_
+                                       ? TaskQueue::PumpPolicy::MANUAL
+                                       : TaskQueue::PumpPolicy::AUTO);
+}
+
+bool WebFrameSchedulerImpl::PumpBackgroundTasks() {
+  DCHECK(page_in_background_);
+  if (!timer_task_queue_ || (timer_task_queue_->IsQueueEmpty() &&
+                             !timer_task_queue_->HasPendingDelayedTask()))
+    return false;
+
+  timer_task_queue_->PumpQueue();
+  return true;
+}
+
+bool WebFrameSchedulerImpl::PendingBackgroundTasks() {
+  if (!timer_task_queue_)
+    return false;
+
+  return !timer_task_queue_->IsQueueEmpty() ||
+         timer_task_queue_->HasPendingDelayedTask();
+}
+
 }  // namespace scheduler