Don't throttle web views until they've been in the background for 10s

third_party/WebKit/Source/platform/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 "platform/scheduler/renderer/web_view_scheduler_impl.h"
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/WebFrameScheduler.h"
@@ skipping 12 matching lines @@
 // Given that we already align timers to 1Hz, do not report throttling if
 // it is under 3s.
 constexpr base::TimeDelta kMinimalBackgroundThrottlingDurationToReport =
     base::TimeDelta::FromSeconds(3);
 constexpr base::TimeDelta kDefaultMaxBackgroundBudgetLevel =
     base::TimeDelta::FromSeconds(3);
 constexpr base::TimeDelta kDefaultMaxBackgroundThrottlingDelay =
     base::TimeDelta::FromMinutes(1);
 constexpr base::TimeDelta kDefaultInitialBackgroundBudget =
     base::TimeDelta::FromSeconds(1);
-constexpr base::TimeDelta kBackgroundBudgetThrottlingGracePeriod =
+constexpr base::TimeDelta kBackgroundThrottlingGracePeriod =
     base::TimeDelta::FromSeconds(10);
 
 // Values coming from WebViewSchedulerSettings are interpreted as follows:
 //   -1 is "not set". Scheduler should use a reasonable default.
 //   0 is "none". base::nullopt will be used if value is optional.
 //   other values are left without changes.
 
 double GetBackgroundBudgetRecoveryRate(
     WebViewScheduler::WebViewSchedulerSettings* settings) {
   if (!settings)
@@ skipping 50 matching lines @@
 WebViewSchedulerImpl::WebViewSchedulerImpl(
     WebScheduler::InterventionReporter* intervention_reporter,
     WebViewScheduler::WebViewSchedulerSettings* settings,
     RendererSchedulerImpl* renderer_scheduler,
     bool disable_background_timer_throttling)
     : intervention_reporter_(intervention_reporter),
       renderer_scheduler_(renderer_scheduler),
       virtual_time_policy_(VirtualTimePolicy::ADVANCE),
       background_parser_count_(0),
       page_visible_(true),
+      should_throttle_frames_(false),
       disable_background_timer_throttling_(disable_background_timer_throttling),
       allow_virtual_time_to_advance_(true),
       have_seen_loading_task_(false),
       virtual_time_(false),
       is_audio_playing_(false),
       reported_background_throttling_since_navigation_(false),
       background_time_budget_pool_(nullptr),
       settings_(settings) {
   renderer_scheduler->AddWebViewScheduler(this);
 
-  delayed_background_budget_throttling_enabler_.Reset(
-      base::Bind(&WebViewSchedulerImpl::EnableBackgroundBudgetThrottling,
+  delayed_background_throttling_enabler_.Reset(
+      base::Bind(&WebViewSchedulerImpl::EnableBackgroundThrottling,
                  base::Unretained(this)));
 }
 
 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();
   }
   renderer_scheduler_->RemoveWebViewScheduler(this);
 
   if (background_time_budget_pool_)
     background_time_budget_pool_->Close();
 }
 
 void WebViewSchedulerImpl::setPageVisible(bool page_visible) {
   if (disable_background_timer_throttling_ || page_visible_ == page_visible)
     return;
 
   page_visible_ = page_visible;
 
-  for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
-    frame_scheduler->setPageVisible(page_visible_);
-  }
-
-  UpdateBackgroundBudgetThrottlingState();
+  UpdateBackgroundThrottlingState();
 }
 
 std::unique_ptr<WebFrameSchedulerImpl>
 WebViewSchedulerImpl::createWebFrameSchedulerImpl(
     base::trace_event::BlameContext* blame_context) {
   MaybeInitializeBackgroundTimeBudgetPool();
   std::unique_ptr<WebFrameSchedulerImpl> frame_scheduler(
       new WebFrameSchedulerImpl(renderer_scheduler_, this, blame_context));
-  frame_scheduler->setPageVisible(page_visible_);
+  frame_scheduler->setPageThrottled(should_throttle_frames_);
   frame_schedulers_.insert(frame_scheduler.get());
   return frame_scheduler;
 }
 
 std::unique_ptr<blink::WebFrameScheduler>
 WebViewSchedulerImpl::createFrameScheduler(blink::BlameContext* blame_context) {
   return createWebFrameSchedulerImpl(blame_context);
 }
 
 void WebViewSchedulerImpl::Unregister(WebFrameSchedulerImpl* frame_scheduler) {
@@ skipping 134 matching lines @@
     return;
 
   if (!RuntimeEnabledFeatures::expensiveBackgroundTimerThrottlingEnabled())
     return;
 
   background_time_budget_pool_ =
       renderer_scheduler_->task_queue_throttler()->CreateTimeBudgetPool(
           "background", GetMaxBudgetLevel(settings_),
           GetMaxThrottlingDelay(settings_));
 
-  UpdateBackgroundBudgetThrottlingState();
+  UpdateBackgroundThrottlingState();
 
   LazyNow lazy_now(renderer_scheduler_->tick_clock());
 
   background_time_budget_pool_->SetTimeBudgetRecoveryRate(
       lazy_now.Now(), GetBackgroundBudgetRecoveryRate(settings_));
 
   background_time_budget_pool_->GrantAdditionalBudget(
       lazy_now.Now(), GetInitialBudget(settings_));
 }
 
@@ skipping 10 matching lines @@
       "Timer tasks have taken too much time while the page was in the "
       "background. "
       "As a result, they have been deferred for %.3f seconds. "
       "See https://www.chromestatus.com/feature/6172836527865856 "
       "for more details",
       throttling_duration.InSecondsF());
 
   intervention_reporter_->ReportIntervention(WebString::fromUTF8(message));
 }
 
-void WebViewSchedulerImpl::EnableBackgroundBudgetThrottling() {
-  if (!background_time_budget_pool_)
-    return;
-
-  LazyNow lazy_now(renderer_scheduler_->tick_clock());
-
-  background_time_budget_pool_->EnableThrottling(&lazy_now);
+void WebViewSchedulerImpl::EnableBackgroundThrottling() {
+  should_throttle_frames_ = true;
+  for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
+    frame_scheduler->setPageThrottled(true);
+  }
+  if (background_time_budget_pool_) {
+    LazyNow lazy_now(renderer_scheduler_->tick_clock());
+    background_time_budget_pool_->EnableThrottling(&lazy_now);
+  }
 }
 
-void WebViewSchedulerImpl::UpdateBackgroundBudgetThrottlingState() {
-  if (!background_time_budget_pool_)
-    return;
-
-  delayed_background_budget_throttling_enabler_.Cancel();
-
-  LazyNow lazy_now(renderer_scheduler_->tick_clock());
+void WebViewSchedulerImpl::UpdateBackgroundThrottlingState() {
+  delayed_background_throttling_enabler_.Cancel();
 
   if (page_visible_) {
-    background_time_budget_pool_->DisableThrottling(&lazy_now);
+    should_throttle_frames_ = false;
+    for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) {
+      frame_scheduler->setPageThrottled(false);
+    }
+    if (background_time_budget_pool_) {
+      LazyNow lazy_now(renderer_scheduler_->tick_clock());
+      background_time_budget_pool_->DisableThrottling(&lazy_now);
+    }
   } else {
     // TODO(altimin): Consider moving this logic into PumpThrottledTasks.
     renderer_scheduler_->ControlTaskRunner()->PostDelayedTask(
-        FROM_HERE, delayed_background_budget_throttling_enabler_.callback(),
-        kBackgroundBudgetThrottlingGracePeriod);
+        FROM_HERE, delayed_background_throttling_enabler_.callback(),
+        kBackgroundThrottlingGracePeriod);
   }
 }
 
 // static
 const char* WebViewSchedulerImpl::VirtualTimePolicyToString(
     VirtualTimePolicy virtual_time_policy) {
   switch (virtual_time_policy) {
     case VirtualTimePolicy::ADVANCE:
       return "ADVANCE";
     case VirtualTimePolicy::PAUSE:
       return "PAUSE";
     case VirtualTimePolicy::DETERMINISTIC_LOADING:
       return "DETERMINISTIC_LOADING";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink