Resume a backgrounded renderer that was purged and suspended

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 463 matching lines @@
     return;
 
   MainThreadOnly().renderer_backgrounded = false;
   MainThreadOnly().renderer_suspended = false;
 
   base::TimeTicks now = tick_clock()->NowTicks();
   MainThreadOnly().foreground_main_thread_load_tracker.Resume(now);
   MainThreadOnly().background_main_thread_load_tracker.Pause(now);
 
   suspend_timers_when_backgrounded_closure_.Cancel();
-  ResumeTimerQueueWhenForegrounded();
+  ResumeTimerQueueWhenForegroundedOrResumed();
 }
 
 void RendererSchedulerImpl::SuspendRenderer() {
   helper_.CheckOnValidThread();
   DCHECK(MainThreadOnly().renderer_backgrounded);
   if (helper_.IsShutdown())
     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.
   MainThreadOnly().renderer_suspended = true;
   SuspendTimerQueueWhenBackgrounded();
 }
 
+void RendererSchedulerImpl::ResumeRenderer() {
+  helper_.CheckOnValidThread();
+  DCHECK(MainThreadOnly().renderer_backgrounded);
+  if (helper_.IsShutdown())
+    return;
+  suspend_timers_when_backgrounded_closure_.Cancel();
+  MainThreadOnly().renderer_suspended = false;
+  ResumeTimerQueueWhenForegroundedOrResumed();
+}
+
 void RendererSchedulerImpl::EndIdlePeriod() {
   if (MainThreadOnly().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 856 matching lines @@
 
 void RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded() {
   DCHECK(MainThreadOnly().renderer_backgrounded);
   if (MainThreadOnly().timer_queue_suspended_when_backgrounded)
     return;
 
   MainThreadOnly().timer_queue_suspended_when_backgrounded = true;
   ForceUpdatePolicy();
 }
 
-void RendererSchedulerImpl::ResumeTimerQueueWhenForegrounded() {
-  DCHECK(!MainThreadOnly().renderer_backgrounded);
+void RendererSchedulerImpl::ResumeTimerQueueWhenForegroundedOrResumed() {
+  DCHECK(!MainThreadOnly().renderer_backgrounded ||
+         (MainThreadOnly().renderer_backgrounded &&
+          !MainThreadOnly().renderer_suspended));
   if (!MainThreadOnly().timer_queue_suspended_when_backgrounded)
     return;
 
   MainThreadOnly().timer_queue_suspended_when_backgrounded = false;
   ForceUpdatePolicy();
 }
 
 void RendererSchedulerImpl::ResetForNavigationLocked() {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
@@ skipping 199 matching lines @@
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink