Purge memory before suspending timer queues when backgrounded.

content/renderer/render_thread_impl.cc

 // Copyright (c) 2012 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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 880 matching lines @@
       categorized_worker_pool_->background_worker_thread_id(),
       base::ThreadPriority::BACKGROUND);
 #endif
 
   record_purge_suspend_metric_closure_.Reset(base::Bind(
       &RenderThreadImpl::RecordPurgeAndSuspendMetrics, base::Unretained(this)));
   record_purge_suspend_growth_metric_closure_.Reset(
       base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMemoryGrowthMetrics,
                  base::Unretained(this)));
 
+  purge_before_suspend_timers_closure_.Reset(base::Bind(
+      &RenderThreadImpl::PurgeBeforeSuspendTimerQueueWhenBackgrounded,
+      base::Unretained(this)));
+  suspend_timers_when_backgrounded_closure_.Reset(
+      base::Bind(&RenderThreadImpl::SuspendTimerQueueWhenBackgrounded,
+                 base::Unretained(this)));

[haraken, 2017/02/03 04:30:49]

Can we call this just before calling PostDelayedTask?

[tasak, 2017/02/03 05:55:26]

Done.

+
   base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 
   // If this renderer doesn't run inside the browser process, enable
   // SequencedWorkerPool. Otherwise, it should already have been enabled.
   // TODO(fdoray): Remove this once the SequencedWorkerPool to TaskScheduler
   // redirection experiment concludes https://crbug.com/622400.
   if (!command_line.HasSwitch(switches::kSingleProcess))
     base::SequencedWorkerPool::EnableForProcess();
 }
 
@@ skipping 285 matching lines @@
   AddFilter(devtools_agent_message_filter_.get());
 
   if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden()) {
     ScheduleIdleHandler(kLongIdleHandlerDelayMs);
   } else {
     // If we do not track widget visibility, then assume conservatively that
     // the isolate is in background. This reduces memory usage.
     isolate->IsolateInBackgroundNotification();
   }
 
-  renderer_scheduler_->SetTimerQueueSuspensionWhenBackgroundedEnabled(
-      GetContentClient()
-          ->renderer()
-          ->AllowTimerSuspensionWhenProcessBackgrounded());
-
   SkGraphics::SetResourceCacheSingleAllocationByteLimit(
       kImageCacheSingleAllocationByteLimit);
 
   // Hook up blink's codecs so skia can call them
   SkGraphics::SetImageGeneratorFromEncodedFactory(
       blink::WebImageGenerator::create);
 
   if (command_line.HasSwitch(switches::kMemoryMetrics)) {
     memory_observer_.reset(new MemoryObserver());
     message_loop()->AddTaskObserver(memory_observer_.get());
@@ skipping 413 matching lines @@
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void RenderThreadImpl::OnProcessBackgrounded(bool backgrounded) {
   ChildThreadImpl::OnProcessBackgrounded(backgrounded);
 
   if (backgrounded) {
     renderer_scheduler_->OnRendererBackgrounded();
+
+    if (GetContentClient()
+            ->renderer()
+            ->AllowTimerSuspensionWhenProcessBackgrounded()) {
+      base::TimeDelta suspend_timers_when_backgrounded_delay =
+          base::TimeDelta::FromMilliseconds(
+              kSuspendTimersWhenBackgroundedDelayMillis);
+      GetRendererScheduler()->DefaultTaskRunner()->PostDelayedTask(
+          FROM_HERE, purge_before_suspend_timers_closure_.callback(),
+          suspend_timers_when_backgrounded_delay);
+    }
   } else {
     renderer_scheduler_->OnRendererForegrounded();
+
+    purge_before_suspend_timers_closure_.Cancel();
+    purge_before_suspend_timers_closure_.Reset(base::Bind(
+        &RenderThreadImpl::PurgeBeforeSuspendTimerQueueWhenBackgrounded,
+        base::Unretained(this)));
+    suspend_timers_when_backgrounded_closure_.Cancel();
+    suspend_timers_when_backgrounded_closure_.Reset(
+        base::Bind(&RenderThreadImpl::SuspendTimerQueueWhenBackgrounded,
+                   base::Unretained(this)));

[haraken, 2017/02/03 04:30:49]

Ditto. Maybe can we Reset the closure just before calling PostDelayedTask?

[tasak, 2017/02/03 05:55:26]

Done.

+
     // TODO(tasak): after enabling MemoryCoordinator, remove this Notify
     // and follow MemoryCoordinator's request.
     if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend))
       base::MemoryCoordinatorClientRegistry::GetInstance()->Notify(
           base::MemoryState::NORMAL);
 
     record_purge_suspend_metric_closure_.Cancel();
     record_purge_suspend_metric_closure_.Reset(
         base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMetrics,
                    base::Unretained(this)));
     record_purge_suspend_growth_metric_closure_.Cancel();
     record_purge_suspend_growth_metric_closure_.Reset(
         base::Bind(&RenderThreadImpl::RecordPurgeAndSuspendMemoryGrowthMetrics,
                    base::Unretained(this)));
   }
 }
 
+void RenderThreadImpl::PurgeBeforeSuspendTimerQueueWhenBackgrounded() {
+  DCHECK(IsMainThread());
+  if (!RendererIsHidden())
+    return;
+  // TODO(tasak): use purge method instead of notifying SUSPENDED
+  // when MemoryCoordinator supports.
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Notify(
+      base::MemoryState::SUSPENDED);
+
+  // Since purging is not a synchronous task (e.g. v8 GC, oilpan GC, ...),
+  // we need to wait until the task is finished. So wait 5 seconds and
+  // update purge+suspend UMA histogram.
+  // TODO(tasak): use MemoryCoordinator's callback to report purge+suspend
+  // UMA when MemoryCoordinator is available.
+  GetRendererScheduler()->DefaultTaskRunner()->PostDelayedTask(
+      FROM_HERE, suspend_timers_when_backgrounded_closure_.callback(),
+      base::TimeDelta::FromSeconds(5));
+}
+
+void RenderThreadImpl::SuspendTimerQueueWhenBackgrounded() {
+  DCHECK(IsMainThread());
+  if (!RendererIsHidden())
+    return;
+  renderer_scheduler_->SuspendRenderer();
+}
+
 void RenderThreadImpl::OnProcessPurgeAndSuspend() {
   ChildThreadImpl::OnProcessPurgeAndSuspend();
   if (!RendererIsHidden())
     return;
 
   // TODO(bashi): Enable the tab suspension when MemoryCoordinator is enabled.
   if (base::FeatureList::IsEnabled(features::kMemoryCoordinator))
     return;
 
   if (base::FeatureList::IsEnabled(features::kPurgeAndSuspend)) {
@@ skipping 767 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content