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

third_party/WebKit/Source/platform/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 "platform/scheduler/renderer/web_frame_scheduler_impl.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/blame_context.h"
 #include "platform/scheduler/base/real_time_domain.h"
 #include "platform/scheduler/base/virtual_time_domain.h"
@@ skipping 18 matching lines @@
 }  // namespace
 
 WebFrameSchedulerImpl::WebFrameSchedulerImpl(
     RendererSchedulerImpl* renderer_scheduler,
     WebViewSchedulerImpl* parent_web_view_scheduler,
     base::trace_event::BlameContext* blame_context)
     : renderer_scheduler_(renderer_scheduler),
       parent_web_view_scheduler_(parent_web_view_scheduler),
       blame_context_(blame_context),
       frame_visible_(true),
-      page_visible_(true),
+      page_throttled_(true),
       frame_suspended_(false),
       cross_origin_(false) {}
 
 WebFrameSchedulerImpl::~WebFrameSchedulerImpl() {
   if (loading_task_queue_) {
     loading_task_queue_->UnregisterTaskQueue();
     loading_task_queue_->SetBlameContext(nullptr);
   }
 
   if (timer_task_queue_) {
@@ skipping 121 matching lines @@
     bool background_parser_active) {
   if (background_parser_active)
     parent_web_view_scheduler_->IncrementBackgroundParserCount();
   else
     parent_web_view_scheduler_->DecrementBackgroundParserCount();
 }
 
 void WebFrameSchedulerImpl::AsValueInto(
     base::trace_event::TracedValue* state) const {
   state->SetBoolean("frame_visible", frame_visible_);
-  state->SetBoolean("page_visible", page_visible_);
+  state->SetBoolean("page_throttled", page_throttled_);
   state->SetBoolean("cross_origin", cross_origin_);
   if (loading_task_queue_) {
     state->SetString("loading_task_queue",
                      PointerToId(loading_task_queue_.get()));
   }
   if (timer_task_queue_)
     state->SetString("timer_task_queue", PointerToId(timer_task_queue_.get()));
   if (unthrottled_task_queue_) {
     state->SetString("unthrottled_task_queue",
                      PointerToId(unthrottled_task_queue_.get()));
   }
   if (blame_context_) {
     state->BeginDictionary("blame_context");
     state->SetString(
         "id_ref", PointerToId(reinterpret_cast<void*>(blame_context_->id())));
     state->SetString("scope", blame_context_->scope());
     state->EndDictionary();
   }
 }
 
-void WebFrameSchedulerImpl::setPageVisible(bool page_visible) {
+void WebFrameSchedulerImpl::setPageThrottled(bool page_throttled) {
   DCHECK(parent_web_view_scheduler_);
-  if (page_visible_ == page_visible)
+  if (page_throttled_ == page_throttled)
     return;
   bool was_throttled = ShouldThrottleTimers();
-  page_visible_ = page_visible;
+  page_throttled_ = page_throttled;
   UpdateTimerThrottling(was_throttled);
 }
 
 void WebFrameSchedulerImpl::setSuspended(bool frame_suspended) {
   DCHECK(parent_web_view_scheduler_);
   if (frame_suspended_ == frame_suspended)
     return;
 
   frame_suspended_ = frame_suspended;
   if (loading_queue_enabled_voter_)
     loading_queue_enabled_voter_->SetQueueEnabled(!frame_suspended);
   if (timer_queue_enabled_voter_)
     timer_queue_enabled_voter_->SetQueueEnabled(!frame_suspended);
 }
 
 void WebFrameSchedulerImpl::onFirstMeaningfulPaint() {
   renderer_scheduler_->OnFirstMeaningfulPaint();
 }
 
 bool WebFrameSchedulerImpl::ShouldThrottleTimers() const {
-  if (!page_visible_)
+  if (page_throttled_)
     return true;
   return RuntimeEnabledFeatures::timerThrottlingForHiddenFramesEnabled() &&
          !frame_visible_ && cross_origin_;
 }
 
 void WebFrameSchedulerImpl::UpdateTimerThrottling(bool was_throttled) {
   bool should_throttle = ShouldThrottleTimers();
   if (was_throttled == should_throttle || !timer_web_task_runner_)
     return;
   if (should_throttle) {
     renderer_scheduler_->task_queue_throttler()->IncreaseThrottleRefCount(
         timer_task_queue_.get());
   } else {
     renderer_scheduler_->task_queue_throttler()->DecreaseThrottleRefCount(
         timer_task_queue_.get());
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink