Experimental 'purging and suspending' backgrounded tabs behind the flag

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 793 matching lines @@
   // We may not have a MojoShellConnection object in tests that directly
   // instantiate a RenderThreadImpl.
   if (MojoShellConnection::Get() &&
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseMusInRenderer))
     CreateRenderWidgetWindowTreeClientFactory();
 #endif
 
   service_registry()->ConnectToRemoteService(
       mojo::GetProxy(&storage_partition_service_));
+
+  is_backgrounded_ = false;
+  is_cache_purged_ = false;
 }
 
 RenderThreadImpl::~RenderThreadImpl() {
 }
 
 void RenderThreadImpl::Shutdown() {
   FOR_EACH_OBSERVER(
       RenderThreadObserver, observers_, OnRenderProcessShutdown());
 
   if (memory_observer_) {
@@ skipping 848 matching lines @@
     IPC_MESSAGE_HANDLER(ViewMsg_PurgePluginListCache, OnPurgePluginListCache)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void RenderThreadImpl::OnProcessBackgrounded(bool backgrounded) {
   ChildThreadImpl::OnProcessBackgrounded(backgrounded);
 
-  if (backgrounded)
+  is_backgrounded_ = backgrounded;
+  if (backgrounded) {
     renderer_scheduler_->OnRendererBackgrounded();
-  else
+  } else {
     renderer_scheduler_->OnRendererForegrounded();
+    is_cache_purged_ = false;
+  }
+}
+
+void RenderThreadImpl::OnProcessPurgeAndSuspend() {
+  ChildThreadImpl::OnProcessPurgeAndSuspend();
+  if (!is_backgrounded_)
+    return;
+  if (is_cache_purged_)
+    return;
+  // TODO(hajimehoshi): Implement purging e.g. cache (crbug/607077)
+  is_cache_purged_ = true;
+  renderer_scheduler_->SuspendRendererWhenBackgrounded();

[dcheng, 2016/05/11 17:42:22]

Sorry, to clarify my earlier comment: it seems like in task_manager.cc, we'll
never send this IPC if the renderer is still foreground. So why do we need to
call this? If we get the purge and suspend IPC message, won't the renderer
already have been backgrounded by the ChildProcessMsg_SetProcessBackgrounded
message?

[hajimehoshi, 2016/05/12 05:20:14]

I understood that checking |is_backgrounded| is not needed here, but assuming
the renderer is backgrounded, SuspendRendererWhenBackgrounded is still needed to
stop the timer queue in the renderer to prevent the return of purged cache
memory.

I was not sure if a tab becomes foregrounded again (e.g. when another tab
sharing the renderer is activated) before the purging IPC arrives to the
renderer, but this never happens, right?

[hajimehoshi, 2016/05/12 08:33:18]

OK, renamed SuspendRendererWhenBackgrounded to SuspendRenderer to clarify the
purpose. also removed |is_backgrounded_|.

 }
 
 void RenderThreadImpl::OnCreateNewFrame(FrameMsg_NewFrame_Params params) {
   CompositorDependencies* compositor_deps = this;
   RenderFrameImpl::CreateFrame(
       params.routing_id, params.proxy_routing_id, params.opener_routing_id,
       params.parent_routing_id, params.previous_sibling_routing_id,
       params.replication_state, compositor_deps, params.widget_params,
       params.frame_owner_properties);
 }
@@ skipping 350 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content