Avoid exiting the renderer process if it has a pending render view.

content/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2011 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/browser_render_process_host.h"
 
 #include <algorithm>
@@ skipping 169 matching lines @@
 
   scoped_refptr<net::URLRequestContextGetter> request_context_;
   scoped_refptr<net::URLRequestContextGetter> media_request_context_;
 };
 
 }  // namespace
 
 BrowserRenderProcessHost::BrowserRenderProcessHost(Profile* profile)
     : RenderProcessHost(profile),
       visible_widgets_(0),
+      pending_views_(0),
       backgrounded_(true),
       ALLOW_THIS_IN_INITIALIZER_LIST(cached_dibs_cleaner_(
             base::TimeDelta::FromSeconds(5),
             this, &BrowserRenderProcessHost::ClearTransportDIBCache)),
       accessibility_enabled_(false),
       extension_process_(false) {
   widget_helper_ = new RenderWidgetHelper();
 
   WebCacheManager::GetInstance()->Add(id());
   ChildProcessSecurityPolicy::GetInstance()->Add(id());
@@ skipping 256 matching lines @@
   if (visible_widgets_ == 0) {
     DCHECK(!backgrounded_);
     SetBackgrounded(true);
   }
 }
 
 int BrowserRenderProcessHost::VisibleWidgetCount() const {
   return visible_widgets_;
 }
 
+void BrowserRenderProcessHost::AddPendingView() {
+  pending_views_++;
+}
+
+void BrowserRenderProcessHost::RemovePendingView() {
+  DCHECK(pending_views_);
+  pending_views_--;

[Matt Perry, 2011/05/10 01:14:50]

does this need to send a shutdown if pending_views_ reaches 0?

[Charlie Reis, 2011/05/10 01:33:09]

Nope-- it'll also reach 0 if we commit the view and have it showing.  The only
period of risk (once we do the rest of the swapping changes in the other CL) is
while it's pending.

+}
+
 void BrowserRenderProcessHost::AppendRendererCommandLine(
     CommandLine* command_line) const {
   // Pass the process type first, so it shows first in process listings.
   // Extensions use a special pseudo-process type to make them distinguishable,
   // even though they're just renderers.
   command_line->AppendSwitchASCII(switches::kProcessType,
       extension_process_ ? switches::kExtensionProcess :
                            switches::kRendererProcess);
 
   if (logging::DialogsAreSuppressed())
@@ skipping 301 matching lines @@
   // If we're about to be deleted, we can no longer trust that our profile is
   // valid, so we ignore incoming messages.
   if (deleting_soon_)
     return false;
 
   mark_child_process_activity_time();
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     // Dispatch control messages.
     bool msg_is_ok = true;
     IPC_BEGIN_MESSAGE_MAP_EX(BrowserRenderProcessHost, msg, msg_is_ok)
+      IPC_MESSAGE_HANDLER(ChildProcessHostMsg_ShutdownRequest,
+                          OnShutdownRequest)
       IPC_MESSAGE_HANDLER(ViewHostMsg_UpdatedCacheStats,
                           OnUpdatedCacheStats)
       IPC_MESSAGE_HANDLER(ViewHostMsg_SuddenTerminationChanged,
                           SuddenTerminationChanged)
       IPC_MESSAGE_HANDLER(ViewHostMsg_UserMetricsRecordAction,
                           OnUserMetricsRecordAction)
       IPC_MESSAGE_UNHANDLED_ERROR()
     IPC_END_MESSAGE_MAP_EX()
 
     if (!msg_is_ok) {
@@ skipping 19 matching lines @@
     return true;
   }
   return listener->OnMessageReceived(msg);
 }
 
 void BrowserRenderProcessHost::OnChannelConnected(int32 peer_pid) {
 #if defined(IPC_MESSAGE_LOG_ENABLED)
   Send(new ChildProcessMsg_SetIPCLoggingEnabled(
       IPC::Logging::GetInstance()->Enabled()));
 #endif
+
+  // Make sure the child checks with us before exiting, so that we do not try
+  // to schedule a new navigation in a swapped out and exiting renderer.
+  Send(new ChildProcessMsg_AskBeforeShutdown());
 }
 
 void BrowserRenderProcessHost::OnChannelError() {
   // Our child process has died.  If we didn't expect it, it's a crash.
   // In any case, we need to let everyone know it's gone.
   // The OnChannelError notification can fire multiple times due to nested sync
   // calls to a renderer. If we don't have a valid channel here it means we
   // already handled the error.
   if (!channel_.get())
     return;
@@ skipping 35 matching lines @@
                                    exit_code));
     iter.Advance();
   }
 
   ClearTransportDIBCache();
 
   // this object is not deleted at this point and may be reused later.
   // TODO(darin): clean this up
 }
 
+void BrowserRenderProcessHost::OnShutdownRequest() {
+  // Don't shutdown if there are pending RenderViews being swapped back in.
+  if (pending_views_)
+    return;
+
+  // Notify any tabs that might have swapped out renderers from this process.
+  // They should not attempt to swap them back in.
+  NotificationService::current()->Notify(
+      NotificationType::RENDERER_PROCESS_CLOSING,
+      Source<RenderProcessHost>(this), NotificationService::NoDetails());
+
+  Send(new ChildProcessMsg_Shutdown());
+}
+
 void BrowserRenderProcessHost::OnUpdatedCacheStats(
     const WebCache::UsageStats& stats) {
   WebCacheManager::GetInstance()->ObserveStats(id(), stats);
 }
 
 void BrowserRenderProcessHost::SuddenTerminationChanged(bool enabled) {
   set_sudden_termination_allowed(enabled);
 }
 
 void BrowserRenderProcessHost::SetBackgrounded(bool backgrounded) {
@@ skipping 48 matching lines @@
   while (!queued_messages_.empty()) {
     Send(queued_messages_.front());
     queued_messages_.pop();
   }
 }
 
 void BrowserRenderProcessHost::OnUserMetricsRecordAction(
     const std::string& action) {
   UserMetrics::RecordComputedAction(action);
 }