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

chrome/browser/first_run.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.
 
 #include <windows.h>
 #include <shlobj.h>
 
 #include <sstream>
 
 #include "chrome/browser/first_run.h"
@@ skipping 188 matching lines @@
   exe = L"Global\\" + exe;
   if (handle != NULL)
     CloseHandle(handle);
   handle = CreateEvent(NULL, TRUE, TRUE, exe.c_str());
   int error = GetLastError();
   return (error == ERROR_ALREADY_EXISTS || error == ERROR_ACCESS_DENIED);
 }
 
 bool Upgrade::RelaunchChromeBrowser(const CommandLine& command_line) {
   ::SetEnvironmentVariable(google_update::kEnvProductVersionKey, NULL);
-  return process_util::LaunchApp(command_line.command_line_string(),
-                                 false, false, NULL);
+  return base::LaunchApp(command_line.command_line_string(),
+                         false, false, NULL);
 }
 
 bool Upgrade::SwapNewChromeExeIfPresent() {
   std::wstring new_chrome_exe;
   if (!GetNewerChromeFile(&new_chrome_exe))
     return false;
   if (!file_util::PathExists(new_chrome_exe))
     return false;
   std::wstring old_chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &old_chrome_exe))
     return false;
   RegKey key;
   HKEY reg_root = InstallUtil::IsPerUserInstall(old_chrome_exe.c_str()) ?
       HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
   BrowserDistribution *dist = BrowserDistribution::GetDistribution();
   std::wstring rename_cmd;
   if (key.Open(reg_root, dist->GetVersionKey().c_str(), KEY_READ) &&
       key.ReadValue(google_update::kRegRenameCmdField, &rename_cmd)) {
-    ProcessHandle handle;
-    if (process_util::LaunchApp(rename_cmd, true, true, &handle)) {
+    base::ProcessHandle handle;
+    if (base::LaunchApp(rename_cmd, true, true, &handle)) {
       DWORD exit_code;
       ::GetExitCodeProcess(handle, &exit_code);
       ::CloseHandle(handle);
       if (exit_code == installer_util::RENAME_SUCCESSFUL)
         return true;
     }
   }
   std::wstring backup_exe;
   if (!GetBackupChromeFile(&backup_exe))
     return false;
@@ skipping 19 matching lines @@
 
 // This class is used by FirstRun::ImportSettings to determine when the import
 // process has ended and what was the result of the operation as reported by
 // the process exit code. This class executes in the context of the main chrome
 // process.
 class ImportProcessRunner : public base::ObjectWatcher::Delegate {
  public:
   // The constructor takes the importer process to watch and then it does a
   // message loop blocking wait until the process ends. This object now owns
   // the import_process handle.
-  explicit ImportProcessRunner(ProcessHandle import_process)
+  explicit ImportProcessRunner(base::ProcessHandle import_process)
       : import_process_(import_process),
         exit_code_(ResultCodes::NORMAL_EXIT) {
     watcher_.StartWatching(import_process, this);
     MessageLoop::current()->Run();
   }
   virtual ~ImportProcessRunner() {
     ::CloseHandle(import_process_);
   }
   // Returns the child process exit code. There are 3 expected values:
   // NORMAL_EXIT, IMPORTER_CANCEL or IMPORTER_HUNG.
   int exit_code() const {
     return exit_code_;
   }
   // The child process has terminated. Find the exit code and quit the loop.
   virtual void OnObjectSignaled(HANDLE object) {
     DCHECK(object == import_process_);
     if (!::GetExitCodeProcess(import_process_, &exit_code_)) {
       NOTREACHED();
     }
     MessageLoop::current()->Quit();
   }
 
  private:
   base::ObjectWatcher watcher_;
-  ProcessHandle import_process_;
+  base::ProcessHandle import_process_;
   DWORD exit_code_;
 };
 
 // Check every 3 seconds if the importer UI has hung.
 const int kPollHangFrequency = 3000;
 
 // This class specializes on finding hung 'owned' windows. Unfortunately, the
 // HungWindowDetector class cannot be used here because it assumes child
 // windows and not owned top-level windows.
 // This code is executed in the context of the main browser process and will
 // terminate the importer process if it is hung.
 class HungImporterMonitor : public WorkerThreadTicker::Callback {
  public:
   // The ctor takes the owner popup window and the process handle of the
   // process to kill in case the popup or its owned active popup become
   // unresponsive.
-  HungImporterMonitor(HWND owner_window, ProcessHandle import_process)
+  HungImporterMonitor(HWND owner_window, base::ProcessHandle import_process)
       : owner_window_(owner_window),
         import_process_(import_process),
         ticker_(kPollHangFrequency) {
     ticker_.RegisterTickHandler(this);
     ticker_.Start();
   }
   virtual ~HungImporterMonitor() {
     ticker_.Stop();
     ticker_.UnregisterTickHandler(this);
   }
 
  private:
   virtual void OnTick() {
     if (!import_process_)
       return;
     // We find the top active popup that we own, this will be either the
     // owner_window_ itself or the dialog window of the other process. In
     // both cases it is worth hung testing because both windows share the
     // same message queue and at some point the other window could be gone
     // while the other process still not pumping messages.
     HWND active_window = ::GetLastActivePopup(owner_window_);
     if (::IsHungAppWindow(active_window) || ::IsHungAppWindow(owner_window_)) {
       ::TerminateProcess(import_process_, ResultCodes::IMPORTER_HUNG);
       import_process_ = NULL;
     }
   }
 
   HWND owner_window_;
-  ProcessHandle import_process_;
+  base::ProcessHandle import_process_;
   WorkerThreadTicker ticker_;
   DISALLOW_EVIL_CONSTRUCTORS(HungImporterMonitor);
 };
 
 // This class is used by FirstRun::ImportNow to get notified of the outcome of
 // the import operation. It differs from ImportProcessRunner in that this
 // class executes in the context of importing child process.
 // The values that it handles are meant to be used as the process exit code.
 class FirstRunImportObserver : public ImportObserver {
  public:
@@ skipping 59 matching lines @@
     if (cmdline.HasSwitch(switch_names[i])) {
       CommandLine::AppendSwitchWithValue(
           &import_cmd, switch_names[i],
           cmdline.GetSwitchValue(switch_names[i]));
     }
   }
   CommandLine::AppendSwitchWithValue(&import_cmd, switches::kImport,
       EncodeImportParams(browser, items_to_import, parent_window));
 
   // Time to launch the process that is going to do the import.
-  ProcessHandle import_process;
-  if (!process_util::LaunchApp(import_cmd, false, false, &import_process))
+  base::ProcessHandle import_process;
+  if (!base::LaunchApp(import_cmd, false, false, &import_process))
     return false;
 
   // Activate the importer monitor. It awakes periodically in another thread
   // and checks that the importer UI is still pumping messages.
   if (parent_window)
     HungImporterMonitor hang_monitor(parent_window, import_process);
 
   // We block inside the import_runner ctor, pumping messages until the
   // importer process ends. This can happen either by completing the import
   // or by hang_monitor killing it.
@@ skipping 56 matching lines @@
 bool FirstRun::SetShowWelcomePagePref() {
   PrefService* local_state = g_browser_process->local_state();
   if (!local_state)
     return false;
   if (!local_state->IsPrefRegistered(prefs::kShouldShowWelcomePage)) {
     local_state->RegisterBooleanPref(prefs::kShouldShowWelcomePage, false);
     local_state->SetBoolean(prefs::kShouldShowWelcomePage, true);
   }
   return true;
 }