Don't shutdown render "process" in single process mode

content/browser/renderer_host/render_process_host_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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 339 matching lines @@
   g_all_hosts.Get().set_check_on_null_data(true);
   // Initialize |child_process_activity_time_| to a reasonable value.
   mark_child_process_activity_time();
   // Note: When we create the RenderProcessHostImpl, it's technically
   //       backgrounded, because it has no visible listeners.  But the process
   //       doesn't actually exist yet, so we'll Background it later, after
   //       creation.
 }
 
 RenderProcessHostImpl::~RenderProcessHostImpl() {
+  DCHECK(!run_renderer_in_process());
   ChildProcessSecurityPolicyImpl::GetInstance()->Remove(GetID());
 
   // We may have some unsent messages at this point, but that's OK.
   channel_.reset();
   while (!queued_messages_.empty()) {
     delete queued_messages_.front();
     queued_messages_.pop();
   }
 
-  if (run_renderer_in_process()) {
-    // In single process mode, need to set IO allowed in browser main thread
-    // before joining the renderer thread
-    base::ThreadRestrictions::ScopedAllowIO allow_io;
-    in_process_renderer_.reset();
-  }
-
   ClearTransportDIBCache();
   UnregisterHost(GetID());
 }
 
 void RenderProcessHostImpl::EnableSendQueue() {
   is_initialized_ = false;
 }
 
 bool RenderProcessHostImpl::Init() {
   // calling Init() more than once does nothing, this makes it more convenient
@@ skipping 483 matching lines @@
     return base::Process::Current().handle();
 
   if (!child_process_launcher_.get() || child_process_launcher_->IsStarting())
     return base::kNullProcessHandle;
 
   return child_process_launcher_->GetHandle();
 }
 
 bool RenderProcessHostImpl::FastShutdownIfPossible() {
   if (run_renderer_in_process())
-    return false;  // Single process mode can't do fast shutdown.
+    return false;  // Single process mode never shutdown the renderer.
 
   if (!GetContentClient()->browser()->IsFastShutdownPossible())
     return false;
 
   if (!child_process_launcher_.get() ||
       child_process_launcher_->IsStarting() ||
       !GetHandle())
     return false;  // Render process hasn't started or is probably crashed.
 
   // Test if there's an unload listener.
@@ skipping 236 matching lines @@
       *CommandLine::ForCurrentProcess();
   if (browser_command_line.HasSwitch(switches::kAuditHandles) ||
       browser_command_line.HasSwitch(switches::kAuditAllHandles)) {
     DumpHandles();
 
     // We wait to close the channels until the child process has finished
     // dumping handles and sends us ChildProcessHostMsg_DumpHandlesDone.
     return;
   }
 #endif
-  Cleanup();
+  // Keep the one renderer thread around forever in single process mode.

[Jeffrey Yasskin, 2012/12/14 22:10:51]

I'm now seeing a DCHECK-failure when running `xvfb-run out/Debug/browser_tests
--single-process --gtest_filter=DeclarativeApiTest.DeclarativeApi` at
chrome/browser/profiles/profile_destroyer.cc:40: "DCHECK(hosts.empty() ||
profile->IsOffTheRecord());" It showed up about the time this CL was committed,
but I haven't rolled back to be sure. Any suggestions for how to fix it?

[joth, 2012/12/14 22:34:12]

Good question. Most of the logic in the DestroyProfileWhenAppropriate() function
is incorrect for single process mode, as single process does not support off the
record. (It cannot: it only supports one profile as there's only one renderer).
Also 'render' process shutdown was never reliable in single process mode (it was
race prone). The simplest 'solution' (?) maybe to add "if
(CommandLine::HasSwitch(kSingleProcess)) return;" prior to that DCHECK. (i.e.
leak the profile too when running in unsupported mdoe) .. I haven't tried that
though, maybe something else will break...

+  if (!run_renderer_in_process())
+    Cleanup();
 }
 
 void RenderProcessHostImpl::Cleanup() {
   // When no other owners of this object, we can delete ourselves
   if (render_widget_hosts_.IsEmpty()) {
     DCHECK_EQ(0, pending_views_);
     NotificationService::current()->Notify(
         NOTIFICATION_RENDERER_PROCESS_TERMINATED,
         Source<RenderProcessHost>(this),
         NotificationService::NoDetails());
@@ skipping 332 matching lines @@
         RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
     if (!static_cast<RenderViewHostImpl*>(rvh)->is_swapped_out())
       num_active_views++;
   }
   return num_active_views;
 }
 
 void RenderProcessHostImpl::OnShutdownRequest() {
   // Don't shut down if there are more active RenderViews than the one asking
   // to close, or if there are pending RenderViews being swapped back in.
+  // In single process mode, we never shutdown the renderer.
   int num_active_views = GetActiveViewCount();
-  if (pending_views_ || num_active_views > 1)
+  if (pending_views_ || num_active_views > 1 || run_renderer_in_process())

[joth, 2012/11/29 23:00:24]

I did consider doing this check in render process instead, but
ChildThread::OnProcessFinalRelease specifically comments the protocol is to
always defer to the host (browser) opinion on this, and also, at this point we
only want to alter the renderer behavior not all possible child processes.

     return;
 
   // Notify any contents that might have swapped out renderers from this
   // process. They should not attempt to swap them back in.
   NotificationService::current()->Notify(
       NOTIFICATION_RENDERER_PROCESS_CLOSING,
       Source<RenderProcessHost>(this),
       NotificationService::NoDetails());
 
   Send(new ChildProcessMsg_Shutdown());
@@ skipping 81 matching lines @@
       int32 gpu_process_host_id) {
   TRACE_EVENT0("renderer_host",
                "RenderWidgetHostImpl::OnCompositorSurfaceBuffersSwappedNoHost");
   RenderWidgetHostImpl::AcknowledgeBufferPresent(route_id,
                                                  gpu_process_host_id,
                                                  false,
                                                  0);
 }
 
 }  // namespace content