Retry r27137. Create renderers for ExtensionHosts one at a time to avoid blocking the UI.

chrome/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2006-2009 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 "chrome/browser/renderer_host/browser_render_process_host.h"
 
 #include "build/build_config.h"
@@ skipping 175 matching lines @@
   VisitedLinkCommon::Fingerprints pending_;
 };
 
 BrowserRenderProcessHost::BrowserRenderProcessHost(Profile* profile)
     : RenderProcessHost(profile),
       visible_widgets_(0),
       backgrounded_(true),
       ALLOW_THIS_IN_INITIALIZER_LIST(cached_dibs_cleaner_(
             base::TimeDelta::FromSeconds(5),
             this, &BrowserRenderProcessHost::ClearTransportDIBCache)),
-      zygote_child_(false) {
+      zygote_child_(false),
+      fast_shutdown_(false) {
   widget_helper_ = new RenderWidgetHelper();
 
   registrar_.Add(this, NotificationType::USER_SCRIPTS_UPDATED,
                  NotificationService::AllSources());
   visited_link_updater_.reset(new VisitedLinkUpdater());
 
   WebCacheManager::GetInstance()->Add(id());
   ChildProcessSecurityPolicy::GetInstance()->Add(id());
 
   // Note: When we create the BrowserRenderProcessHost, it's technically
@@ skipping 226 matching lines @@
 #if defined(OS_LINUX)
     }
 #endif  // defined(OS_LINUX)
 #endif  // defined(OS_POSIX)
 
     if (!process) {
       channel_.reset();
       return false;
     }
     process_.set_handle(process);
+    fast_shutdown_ = false;
 
     // Log the launch time, separating out the first one (which will likely be
     // slower due to the rest of the browser initializing at the same time).
     static bool done_first_launch = false;
     if (done_first_launch) {
       UMA_HISTOGRAM_TIMES("MPArch.RendererLaunchSubsequent",
                           base::TimeTicks::Now() - begin_launch_time);
     } else {
       UMA_HISTOGRAM_TIMES("MPArch.RendererLaunchFirst",
                           base::TimeTicks::Now() - begin_launch_time);
@@ skipping 175 matching lines @@
       if (rvh->delegate()->IsExternalTabContainer())
         return false;
     }
 
     iter.Advance();
   }
 
   // Otherwise, we're allowed to just terminate the process. Using exit code 0
   // means that UMA won't treat this as a renderer crash.
   process_.Terminate(ResultCodes::NORMAL_EXIT);
+  process_.Close();
+  fast_shutdown_ = true;
   return true;
 }
 
 bool BrowserRenderProcessHost::SendWithTimeout(IPC::Message* msg,
                                                int timeout_ms) {
   if (!channel_.get()) {
     delete msg;
     return false;
   }
   return channel_->SendWithTimeout(msg, timeout_ms);
@@ skipping 106 matching lines @@
       Send(reply);
     }
     return;
   }
   listener->OnMessageReceived(msg);
 }
 
 void BrowserRenderProcessHost::OnChannelConnected(int32 peer_pid) {
   // process_ is not NULL if we created the renderer process
   if (!process_.handle()) {
-    if (base::GetCurrentProcId() == peer_pid) {
+    if (fast_shutdown_) {
+      // We terminated the process, but the ChannelConnected task was still
+      // in the queue. We can safely ignore it.
+      return;
+    } else if (base::GetCurrentProcId() == peer_pid) {
       // We are in single-process mode. In theory we should have access to
       // ourself but it may happen that we don't.
       process_.set_handle(base::GetCurrentProcessHandle());
     } else {
 #if defined(OS_WIN)
       // Request MAXIMUM_ALLOWED to match the access a handle
       // returned by CreateProcess() has to the process object.
       process_.set_handle(OpenProcess(MAXIMUM_ALLOWED, FALSE, peer_pid));
 #else
       NOTREACHED();
@@ skipping 28 matching lines @@
     // In single process mode it is better if we don't suicide but just crash.
     CHECK(false);
   }
   NOTREACHED();
   base::KillProcess(process, ResultCodes::KILLED_BAD_MESSAGE, false);
 }
 
 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.
-
-  DCHECK(process_.handle());
   DCHECK(channel_.get());
 
   bool child_exited;
   bool did_crash;
-  if (zygote_child_) {
+  if (!process_.handle()) {
+    // The process has been terminated (likely FastShutdownIfPossible).
+    did_crash = false;
+    child_exited = true;
+  } else if (zygote_child_) {
 #if defined(OS_LINUX)
     did_crash = Singleton<ZygoteHost>()->DidProcessCrash(
         process_.handle(), &child_exited);
 #else
     NOTREACHED();
     did_crash = true;
 #endif
   } else {
     did_crash = base::DidProcessCrash(&child_exited, process_.handle());
   }
@@ skipping 130 matching lines @@
     profile()->GetExtensionMessageService()->RemoveEventListener(
         event_name, id());
   }
 }
 
 void BrowserRenderProcessHost::OnExtensionCloseChannel(int port_id) {
   if (profile()->GetExtensionMessageService()) {
     profile()->GetExtensionMessageService()->CloseChannel(port_id);
   }
 }