Add Terminate() to the Process object, have RenderProcessHost use this to avo...

chrome/browser/render_process_host.cc

 // Copyright (c) 2006-2008 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/render_process_host.h"
 
 #include <windows.h>
@@ skipping 404 matching lines @@
         CloseHandle(target.hThread);
         process_.set_handle(target.hProcess);
 
         // Help the process a little. It can't start the debugger by itself if
         // the process is in a sandbox.
         if (child_needs_help)
             DebugUtil::SpawnDebuggerOnProcess(target.dwProcessId);
       } else {
         // spawn child process
         HANDLE process;
-        if (!process_util::LaunchApp(cmd_line, false, false, &process))
+        if (!base::LaunchApp(cmd_line, false, false, &process))
           return false;
         process_.set_handle(process);
       }
 
       watcher_.StartWatching(process_.handle(), this);
     }
   }
 
   // Now that the process is created, set it's backgrounding accordingly.
   SetBackgrounded(backgrounded_);
 
   InitVisitedLinks();
   InitGreasemonkeyScripts();
 
   if (max_page_id_ != -1)
     channel_->Send(new ViewMsg_SetNextPageID(max_page_id_ + 1));
 
   return true;
 }
 
-HANDLE RenderProcessHost::GetRendererProcessHandle() {
-  HANDLE result = process_.handle();
-  if (!result) {
-    // Renderer process can be null if it's started with the --single-process
-    // flag.
-    result = GetCurrentProcess();
-  }
-  return result;
+base::ProcessHandle RenderProcessHost::GetRendererProcessHandle() {
+  if (run_renderer_in_process_)
+    return base::Process::Current().handle();
+  return process_.handle();
 }
 
 void RenderProcessHost::InitVisitedLinks() {
   VisitedLinkMaster* visitedlink_master = profile_->GetVisitedLinkMaster();
   if (!visitedlink_master) {
     return;
   }
 
-  SharedMemoryHandle handle_for_process = NULL;
+  base::SharedMemoryHandle handle_for_process = NULL;
   visitedlink_master->ShareToProcess(GetRendererProcessHandle(),
                                      &handle_for_process);
   DCHECK(handle_for_process);
   if (handle_for_process) {
     channel_->Send(new ViewMsg_VisitedLink_NewTable(handle_for_process));
   }
 }
 
 void RenderProcessHost::InitGreasemonkeyScripts() {
   CommandLine command_line;
@@ skipping 15 matching lines @@
   if (!greasemonkey_master->ScriptsReady()) {
     // No scripts ready.  :(
     return;
   }
 
   // Update the renderer process with the current scripts.
   SendGreasemonkeyScriptsUpdate(greasemonkey_master->GetSharedMemory());
 }
 
 void RenderProcessHost::SendGreasemonkeyScriptsUpdate(
-    SharedMemory *shared_memory) {
-  SharedMemoryHandle handle_for_process = NULL;
+    base::SharedMemory *shared_memory) {
+  base::SharedMemoryHandle handle_for_process = NULL;
   shared_memory->ShareToProcess(GetRendererProcessHandle(),
                                 &handle_for_process);
   DCHECK(handle_for_process);
   if (handle_for_process) {
     channel_->Send(new ViewMsg_Greasemonkey_NewScripts(handle_for_process));
   }
 }
 
 void RenderProcessHost::Attach(IPC::Channel::Listener* listener,
                                int routing_id) {
@@ skipping 19 matching lines @@
     Unregister();
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 }
 
 void RenderProcessHost::ReportExpectingClose(int32 listener_id) {
   listeners_expecting_close_.insert(listener_id);
 }
 
 bool RenderProcessHost::FastShutdownIfPossible() {
-  HANDLE proc = process().handle();
-  if (!proc)
-    return false;
-  // If we're in single process mode, do nothing.
+  if (!process_.handle())
+    return false;  // Render process is probably crashed.
   if (RenderProcessHost::run_renderer_in_process())
-    return false;
+    return false;  // Since process mode can't do fast shutdown.
 
   // Test if there's an unload listener
   RenderProcessHost::listeners_iterator iter;
   // NOTE: This is a bit dangerous.  We know that for now, listeners are
   // always RenderWidgetHosts.  But in theory, they don't have to be.
   for (iter = listeners_begin(); iter != listeners_end(); ++iter) {
     RenderWidgetHost* widget = static_cast<RenderWidgetHost*>(iter->second);
     DCHECK(widget);
     if (!widget || !widget->IsRenderView())
       continue;
     RenderViewHost* rvh = static_cast<RenderViewHost*>(widget);
     if (rvh->HasUnloadListener()) {
       // NOTE: It's possible that an onunload listener may be installed
       // while we're shutting down, so there's a small race here.  Given that
       // the window is small, it's unlikely that the web page has much
       // state that will be lost by not calling its unload handlers properly.
       return false;
     }
   }
-  // Otherwise, call TerminateProcess.  Using exit code 0 means that UMA won't
-  // treat this as a renderer crash.
-  ::TerminateProcess(proc, ResultCodes::NORMAL_EXIT);
+
+  // 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);
   return true;
 }
 
 // Static. This function can be called from the IO Thread or from the UI thread.
 void RenderProcessHost::BadMessageTerminateProcess(uint16 msg_type,
                                                    HANDLE process) {
   LOG(ERROR) << "bad message " << msg_type << " terminating renderer.";
   if (RenderProcessHost::run_renderer_in_process()) {
     // In single process mode it is better if we don't suicide but just crash.
     CHECK(false);
@@ skipping 67 matching lines @@
     CHECK(peer_pid == process_.pid());
   }
 }
 
 // indicates the renderer process has exited
 void RenderProcessHost::OnObjectSignaled(HANDLE object) {
   DCHECK(process_.handle());
   DCHECK(channel_.get());
   DCHECK_EQ(object, process_.handle());
 
-  bool clean_shutdown = !process_util::DidProcessCrash(object);
+  bool clean_shutdown = !base::DidProcessCrash(object);
 
   process_.Close();
 
   channel_.reset();
 
   if (!notified_termination_) {
     // If |close_expected| is false, it means the renderer process went away
     // before the web views expected it; count it as a crash.
     NotificationService::current()->Notify(NOTIFY_RENDERER_PROCESS_TERMINATED,
                                            Source<RenderProcessHost>(this),
@@ skipping 152 matching lines @@
       DCHECK(Source<PrefService>(source).ptr() == profile()->GetPrefs());
       if (*pref_name_in == prefs::kBlockPopups) {
         widget_helper_->set_block_popups(
             profile()->GetPrefs()->GetBoolean(prefs::kBlockPopups));
       } else {
         NOTREACHED() << "unexpected pref change notification" << *pref_name_in;
       }
       break;
     }
     case NOTIFY_NEW_USER_SCRIPTS: {
-      SharedMemory* shared_memory = Details<SharedMemory>(details).ptr();
+      base::SharedMemory* shared_memory =
+          Details<base::SharedMemory>(details).ptr();
       DCHECK(shared_memory);
       if (shared_memory) {
         SendGreasemonkeyScriptsUpdate(shared_memory);
       }
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 // static
 bool RenderProcessHost::ShouldTryToUseExistingProcessHost() {
   unsigned int renderer_process_count =
       static_cast<unsigned int>(all_hosts.size());
 
   // NOTE: Sometimes it's necessary to create more render processes than
   //       GetMaxRendererProcessCount(), for instance when we want to create
   //       a renderer process for a profile that has no existing renderers.
   //       This is OK in moderation, since the GetMaxRendererProcessCount()
   //       is conservative.
 
   return run_renderer_in_process() ||
          (renderer_process_count >= GetMaxRendererProcessCount());
 }