Move throttling of background timers into the renderer scheduler

components/scheduler/renderer/web_view_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_view_scheduler_impl.h"
 
 #include "base/logging.h"
+#include "components/scheduler/renderer/renderer_scheduler_impl.h"
 #include "components/scheduler/renderer/web_frame_scheduler_impl.h"
 #include "third_party/WebKit/public/platform/WebFrameScheduler.h"
 
 namespace scheduler {
 
 WebViewSchedulerImpl::WebViewSchedulerImpl(
     blink::WebView* web_view,
-    RendererSchedulerImpl* renderer_scheduler)
+    RendererSchedulerImpl* renderer_scheduler,
+    const char* tracing_category)
     : web_view_(web_view),
       renderer_scheduler_(renderer_scheduler),
-      background_(false) {}
+      tracing_category_(tracing_category),
+      background_(false),
+      weak_factory_(this) {
+  pump_throttled_tasks_closure_.Reset(base::Bind(

[Sami, 2015/11/17 10:12:21]

Doing this here is fine for now, but I wonder how we're going to do something
similar for out-of-view frames? I guess we can refactor this into a generic
throttling helper once we get there.

[alex clarke (OOO till 29th), 2015/11/23 17:13:45]

Yes we probably will add a helper.

+      &WebViewSchedulerImpl::PumpThrottledTasks, weak_factory_.GetWeakPtr()));
+}
 
 WebViewSchedulerImpl::~WebViewSchedulerImpl() {
   // TODO(alexclarke): Find out why we can't rely on the web view outliving the
   // frame.
   for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
     frame_scheduler->DetachFromWebViewScheduler();
   }
 }
 
 void WebViewSchedulerImpl::setPageInBackground(bool background) {
+  if (background_ == background)
+    return;
+
   background_ = background;
-  // TODO(alexclarke): Do something with this flag.
+
+  for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
+    frame_scheduler->SetPageInBackground(background);
+  }
+
+  if (background) {
+    SchedulePumpThrottledTasks();
+  } else {
+    pump_throttled_tasks_closure_.Cancel();
+  }
 }
 
 blink::WebPassOwnPtr<blink::WebFrameScheduler>
 WebViewSchedulerImpl::createFrameScheduler() {
   scoped_ptr<WebFrameSchedulerImpl> frame_scheduler(
       new WebFrameSchedulerImpl(renderer_scheduler_, this));
+  frame_scheduler->SetPageInBackground(background_);
   frame_schedulers_.insert(frame_scheduler.get());
   return blink::adoptWebPtr(frame_scheduler.release());
 }
 
 void WebViewSchedulerImpl::Unregister(WebFrameSchedulerImpl* frame_scheduler) {
   DCHECK(frame_schedulers_.find(frame_scheduler) != frame_schedulers_.end());
   frame_schedulers_.erase(frame_scheduler);
 }
 
+void WebViewSchedulerImpl::PumpThrottledTasks() {
+  TRACE_EVENT0(tracing_category_, "WebViewSchedulerImpl::PumpThrottledTasks");
+  DCHECK(background_);
+  for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
+    frame_scheduler->PumpBackgroundTasks();
+  }
+  SchedulePumpThrottledTasks();

[Sami, 2015/11/17 10:12:21]

Will this ever stop ticking if there's no work to do?

[alex clarke (OOO till 29th), 2015/11/23 17:13:45]

I've changed it so it does.

+}
+
+/* static */
+double WebViewSchedulerImpl::DelayToNextRunTimeInSeconds(
+    double now_in_seconds) {
+  return ceilf(now_in_seconds + 0.2) - now_in_seconds;

[Sami, 2015/11/17 10:12:21]

This probably deserves a comment and a named constant. Wasn't the previous
throttling interval 1s?

[alex clarke (OOO till 29th), 2015/11/23 17:13:45]

Yes and this also ticks once per second too.

+}
+
+void WebViewSchedulerImpl::SchedulePumpThrottledTasks() {
+  pump_throttled_tasks_closure_.Cancel();
+  renderer_scheduler_->ControlTaskRunner()->PostDelayedTask(
+      FROM_HERE, pump_throttled_tasks_closure_.callback(),
+      base::TimeDelta::FromSecondsD(DelayToNextRunTimeInSeconds(

[Sami, 2015/11/17 10:12:21]

Is there a way to do this calculation only using TimeTicks/TimeDelta? I hope we
can limit the double time math to blink.

[alex clarke (OOO till 29th), 2015/11/23 17:13:45]

Done.

+          renderer_scheduler_->MonotonicallyIncreasingTimeSeconds())));
+}
+
 }  // namespace scheduler