NOT FOR COMMIT: Move background pausing to the WebView level

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc

 // Copyright 2014 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/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 101 matching lines @@
                         helper_.scheduler_tqm_delegate().get(),
                         helper_.scheduler_tqm_delegate()->NowTicks()),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   task_queue_throttler_.reset(new TaskQueueThrottler(this));
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_factory_.GetWeakPtr());
   end_renderer_hidden_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr()));
 
-  suspend_timers_when_backgrounded_closure_.Reset(
-      base::Bind(&RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded,
-                 weak_factory_.GetWeakPtr()));
-
   default_loading_task_queue_ =
       NewLoadingTaskQueue(TaskQueue::QueueType::DEFAULT_LOADING);
   default_timer_task_queue_ =
       NewTimerTaskQueue(TaskQueue::QueueType::DEFAULT_TIMER);
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
   helper_.SetObserver(this);
@@ skipping 59 matching lines @@
           now,
           base::Bind(&ReportForegroundRendererTaskLoad),
           kThreadLoadTrackerReportingInterval,
           kThreadLoadTrackerWaitingPeriodBeforeReporting),
       current_use_case(UseCase::NONE),
       timer_queue_suspend_count(0),
       navigation_task_expected_count(0),
       expensive_task_policy(ExpensiveTaskPolicy::RUN),
       renderer_hidden(false),
       renderer_backgrounded(false),
-      renderer_suspended(false),
-      timer_queue_suspension_when_backgrounded_enabled(false),
-      timer_queue_suspended_when_backgrounded(false),
       was_shutdown(false),
       loading_tasks_seem_expensive(false),
       timer_tasks_seem_expensive(false),
       touchstart_expected_soon(false),
       have_seen_a_begin_main_frame(false),
       have_reported_blocking_intervention_in_current_policy(false),
       have_reported_blocking_intervention_since_navigation(false),
       has_visible_render_widget_with_touch_handler(false),
       begin_frame_not_expected_soon(false),
       in_idle_period_for_testing(false),
@@ skipping 305 matching lines @@
   if (helper_.IsShutdown() || GetMainThreadOnly().renderer_backgrounded)
     return;
 
   GetMainThreadOnly().renderer_backgrounded = true;
 
   UpdatePolicy();
 
   base::TimeTicks now = tick_clock()->NowTicks();
   GetMainThreadOnly().foreground_main_thread_load_tracker.Pause(now);
   GetMainThreadOnly().background_main_thread_load_tracker.Resume(now);
-
-  if (!GetMainThreadOnly().timer_queue_suspension_when_backgrounded_enabled)
-    return;
-
-  suspend_timers_when_backgrounded_closure_.Cancel();
-  base::TimeDelta suspend_timers_when_backgrounded_delay =
-      base::TimeDelta::FromMilliseconds(
-          kSuspendTimersWhenBackgroundedDelayMillis);
-  control_task_queue_->PostDelayedTask(
-      FROM_HERE, suspend_timers_when_backgrounded_closure_.GetCallback(),
-      suspend_timers_when_backgrounded_delay);
 }
 
 void RendererSchedulerImpl::OnRendererForegrounded() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnRendererForegrounded");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown() || !GetMainThreadOnly().renderer_backgrounded)
     return;
 
   GetMainThreadOnly().renderer_backgrounded = false;
-  GetMainThreadOnly().renderer_suspended = false;
 
   UpdatePolicy();
 
   base::TimeTicks now = tick_clock()->NowTicks();
   GetMainThreadOnly().foreground_main_thread_load_tracker.Resume(now);
   GetMainThreadOnly().background_main_thread_load_tracker.Pause(now);
-
-  suspend_timers_when_backgrounded_closure_.Cancel();
-  ResumeTimerQueueWhenForegroundedOrResumed();
 }
 
 void RendererSchedulerImpl::OnAudioStateChanged() {
   bool is_audio_playing = false;
   for (WebViewSchedulerImpl* web_view_scheduler :
        GetMainThreadOnly().web_view_schedulers) {
     is_audio_playing = is_audio_playing || web_view_scheduler->IsAudioPlaying();
   }
 
   if (is_audio_playing == GetMainThreadOnly().is_audio_playing)
     return;
 
   GetMainThreadOnly().last_audio_state_change =
       helper_.scheduler_tqm_delegate()->NowTicks();
   GetMainThreadOnly().is_audio_playing = is_audio_playing;
 
   UpdatePolicy();
 }
 
-void RendererSchedulerImpl::SuspendRenderer() {
-  helper_.CheckOnValidThread();
-  if (helper_.IsShutdown())
-    return;
-  if (!GetMainThreadOnly().renderer_backgrounded)
-    return;
-  suspend_timers_when_backgrounded_closure_.Cancel();
-
-  UMA_HISTOGRAM_COUNTS("PurgeAndSuspend.PendingTaskCount",
-                       helper_.GetNumberOfPendingTasks());
-
-  // TODO(hajimehoshi): We might need to suspend not only timer queue but also
-  // e.g. loading tasks or postMessage.
-  GetMainThreadOnly().renderer_suspended = true;
-  SuspendTimerQueueWhenBackgrounded();
-}
-
-void RendererSchedulerImpl::ResumeRenderer() {
-  helper_.CheckOnValidThread();
-  if (helper_.IsShutdown())
-    return;
-  if (!GetMainThreadOnly().renderer_backgrounded)
-    return;
-  suspend_timers_when_backgrounded_closure_.Cancel();
-  GetMainThreadOnly().renderer_suspended = false;
-  ResumeTimerQueueWhenForegroundedOrResumed();
-}
-
 void RendererSchedulerImpl::EndIdlePeriod() {
   if (GetMainThreadOnly().in_idle_period_for_testing)
     return;
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::EndIdlePeriod");
   helper_.CheckOnValidThread();
   idle_helper_.EndIdlePeriod();
 }
 
 void RendererSchedulerImpl::EndIdlePeriodForTesting(
@@ skipping 480 matching lines @@
             TimeDomainType::THROTTLED;
       }
       if (timer_tasks_seem_expensive) {
         new_policy.timer_queue_policy.time_domain_type =
             TimeDomainType::THROTTLED;
       }
       break;
   }
   GetMainThreadOnly().expensive_task_policy = expensive_task_policy;
 
-  if (GetMainThreadOnly().timer_queue_suspend_count != 0 ||
-      GetMainThreadOnly().timer_queue_suspended_when_backgrounded) {
+  if (GetMainThreadOnly().timer_queue_suspend_count != 0) {
     new_policy.timer_queue_policy.is_enabled = false;
     // TODO(alexclarke): Figure out if we really need to do this.
     new_policy.timer_queue_policy.time_domain_type = TimeDomainType::REAL;
   }
 
-  if (GetMainThreadOnly().renderer_suspended) {
-    new_policy.loading_queue_policy.is_enabled = false;
-    DCHECK(!new_policy.timer_queue_policy.is_enabled);
-  }
-
   if (GetMainThreadOnly().use_virtual_time) {
     new_policy.compositor_queue_policy.time_domain_type =
         TimeDomainType::VIRTUAL;
     new_policy.default_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
     new_policy.loading_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
     new_policy.timer_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
   }
 
   new_policy.should_disable_throttling =
       ShouldDisableThrottlingBecauseOfAudio(now) ||
@@ skipping 231 matching lines @@
   }
 #endif
 }
 
 void RendererSchedulerImpl::ResumeTimerQueue() {
   GetMainThreadOnly().timer_queue_suspend_count--;
   DCHECK_GE(GetMainThreadOnly().timer_queue_suspend_count, 0);
   ForceUpdatePolicy();
 }
 
-void RendererSchedulerImpl::SetTimerQueueSuspensionWhenBackgroundedEnabled(
-    bool enabled) {
-  // Note that this will only take effect for the next backgrounded signal.
-  GetMainThreadOnly().timer_queue_suspension_when_backgrounded_enabled =
-      enabled;
-}
-
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 RendererSchedulerImpl::AsValue(base::TimeTicks optional_now) const {
   base::AutoLock lock(any_thread_lock_);
   return AsValueLocked(optional_now);
 }
 
 void RendererSchedulerImpl::CreateTraceEventObjectSnapshot() const {
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValue(helper_.scheduler_tqm_delegate()->NowTicks()));
@@ skipping 54 matching lines @@
   state->SetBoolean("have_seen_input_since_navigation",
                     GetAnyThread().have_seen_input_since_navigation);
   state->SetBoolean("have_reported_blocking_intervention_in_current_policy",
                     GetMainThreadOnly()
                         .have_reported_blocking_intervention_in_current_policy);
   state->SetBoolean(
       "have_reported_blocking_intervention_since_navigation",
       GetMainThreadOnly().have_reported_blocking_intervention_since_navigation);
   state->SetBoolean("renderer_backgrounded",
                     GetMainThreadOnly().renderer_backgrounded);
-  state->SetBoolean(
-      "timer_queue_suspended_when_backgrounded",
-      GetMainThreadOnly().timer_queue_suspended_when_backgrounded);
   state->SetInteger("timer_queue_suspend_count",
                     GetMainThreadOnly().timer_queue_suspend_count);
   state->SetDouble("now", (optional_now - base::TimeTicks()).InMillisecondsF());
   state->SetDouble(
       "fling_compositor_escalation_deadline",
       (GetAnyThread().fling_compositor_escalation_deadline - base::TimeTicks())
           .InMillisecondsF());
   state->SetInteger("navigation_task_expected_count",
                     GetMainThreadOnly().navigation_task_expected_count);
   state->SetDouble(
@@ skipping 128 matching lines @@
 }
 
 void RendererSchedulerImpl::OnFirstMeaningfulPaint() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnFirstMeaningfulPaint");
   base::AutoLock lock(any_thread_lock_);
   GetAnyThread().waiting_for_meaningful_paint = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
-void RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded() {
-  DCHECK(GetMainThreadOnly().renderer_backgrounded);
-  if (GetMainThreadOnly().timer_queue_suspended_when_backgrounded)
-    return;
-
-  GetMainThreadOnly().timer_queue_suspended_when_backgrounded = true;
-  ForceUpdatePolicy();
-  Platform::Current()->RequestPurgeMemory();
-}
-
-void RendererSchedulerImpl::ResumeTimerQueueWhenForegroundedOrResumed() {
-  DCHECK(!GetMainThreadOnly().renderer_backgrounded ||
-         (GetMainThreadOnly().renderer_backgrounded &&
-          !GetMainThreadOnly().renderer_suspended));
-  if (!GetMainThreadOnly().timer_queue_suspended_when_backgrounded)
-    return;
-
-  GetMainThreadOnly().timer_queue_suspended_when_backgrounded = false;
-  ForceUpdatePolicy();
-}
-
 void RendererSchedulerImpl::ResetForNavigationLocked() {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
   GetAnyThread().user_model.Reset(helper_.scheduler_tqm_delegate()->NowTicks());
   GetAnyThread().have_seen_touchstart = false;
   GetAnyThread().waiting_for_meaningful_paint = true;
   GetAnyThread().have_seen_input_since_navigation = false;
   GetMainThreadOnly().loading_task_cost_estimator.Clear();
   GetMainThreadOnly().timer_task_cost_estimator.Clear();
   GetMainThreadOnly().idle_time_estimator.Clear();
@@ skipping 93 matching lines @@
   for (auto* web_view_scheduler : GetMainThreadOnly().web_view_schedulers)
     web_view_scheduler->ReportIntervention(message);
 }
 
 void RendererSchedulerImpl::OnTriedToExecuteBlockedTask(
     const TaskQueue& queue,
     const base::PendingTask& task) {
   if (GetMainThreadOnly().current_use_case == UseCase::TOUCHSTART ||
       GetMainThreadOnly().longest_jank_free_task_duration <
           base::TimeDelta::FromMilliseconds(kRailsResponseTimeMillis) ||
-      GetMainThreadOnly().timer_queue_suspend_count ||
-      GetMainThreadOnly().timer_queue_suspended_when_backgrounded) {
+      GetMainThreadOnly().timer_queue_suspend_count) {
     return;
   }
   if (!GetMainThreadOnly().timer_tasks_seem_expensive &&
       !GetMainThreadOnly().loading_tasks_seem_expensive) {
     return;
   }
   if (!GetMainThreadOnly()
            .have_reported_blocking_intervention_in_current_policy) {
     GetMainThreadOnly().have_reported_blocking_intervention_in_current_policy =
         true;
@@ skipping 205 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink