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

chrome/browser/render_process_host.h

 // 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.
 
 #ifndef CHROME_BROWSER_RENDER_PROCESS_HOST_H_
 #define CHROME_BROWSER_RENDER_PROCESS_HOST_H_
 
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 84 matching lines @@
   // Listeners should call this when they've sent a "Close" message and
   // they're waiting for a "Close_ACK", so that if the renderer process
   // goes away we'll know that it was intentional rather than a crash.
   void ReportExpectingClose(int32 listener_id);
 
   // May return NULL if there is no connection.
   IPC::SyncChannel* channel() {
     return channel_.get();
   }
 
-  const Process& process() const {
+  const base::Process& process() const {
     return process_;
   }
 
   // Try to shutdown the associated renderer process as fast as possible.
   // If this renderer has any RenderViews with unload handlers, then this
   // function does nothing.  The current implementation uses TerminateProcess.
   // Returns True if it was able to do fast shutdown.
   bool FastShutdownIfPossible();
 
   IPC::Channel::Listener* GetListenerByID(int routing_id) {
@@ skipping 55 matching lines @@
 
   // Returns the user profile associated with this renderer process.
   Profile* profile() const { return profile_; }
 
   RenderWidgetHelper* widget_helper() const { return widget_helper_; }
 
   // Track the count of visible widgets.  Called by listeners
   // to register/unregister visibility.
   void WidgetRestored();
   void WidgetHidden();
-  
+
   // Add a word in the spellchecker.
   void AddWord(const std::wstring& word);
 
   // NotificationObserver implementation.
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
  private:
   // control message handlers
   void OnPageContents(const GURL& url, int32 page_id,
                       const std::wstring& contents);
   // Clipboard messages
   void OnClipboardWriteHTML(const std::wstring& markup, const GURL& src_url);
   void OnClipboardWriteBookmark(const std::wstring& title, const GURL& url);
-  void OnClipboardWriteBitmap(SharedMemoryHandle bitmap, gfx::Size size);
+  void OnClipboardWriteBitmap(base::SharedMemoryHandle bitmap, gfx::Size size);
   void OnClipboardIsFormatAvailable(unsigned int format, bool* result);
   void OnClipboardReadText(std::wstring* result);
   void OnClipboardReadAsciiText(std::string* result);
   void OnClipboardReadHTML(std::wstring* markup, GURL* src_url);
   void OnUpdatedCacheStats(const CacheManager::UsageStats& stats);
 
   // Initialize support for visited links. Send the renderer process its initial
   // set of visited links.
   void InitVisitedLinks();
 
   // Initialize support for Greasemonkey scripts. Send the renderer process its
   // initial set of scripts and listen for updates to scripts.
   void InitGreasemonkeyScripts();
 
   // Sends the renderer process a new set of Greasemonkey scripts.
-  void SendGreasemonkeyScriptsUpdate(SharedMemory* shared_memory);
+  void SendGreasemonkeyScriptsUpdate(base::SharedMemory* shared_memory);
 
   // Gets a handle to the renderer process, normalizing the case where we were
   // started with --single-process.
-  HANDLE GetRendererProcessHandle();
+  base::ProcessHandle GetRendererProcessHandle();
 
   // Callers can reduce the RenderProcess' priority.
   // Returns true if the priority is backgrounded; false otherwise.
   void SetBackgrounded(bool boost);
 
   // Unregister this object from all globals that reference it.
   // This would naturally be part of the destructor, but we destruct
   // asynchronously.
   void Unregister();
 
   // the registered listeners. When this list is empty or all NULL, we should
   // delete ourselves
   IDMap<IPC::Channel::Listener> listeners_;
 
   // set of listeners that expect the renderer process to close
   std::set<int> listeners_expecting_close_;
 
   // A proxy for our IPC::Channel that lives on the IO thread (see
   // browser_process.h)
   scoped_ptr<IPC::SyncChannel> channel_;
 
   // Our renderer process.
-  Process process_;
+  base::Process process_;
 
   // Used to watch the renderer process handle.
   base::ObjectWatcher watcher_;
 
   // The profile associated with this renderer process.
   Profile* profile_;
 
   // Our ID into the IDMap.
   int host_id_;
 
@@ skipping 31 matching lines @@
   // process can't cause denial of service by causing future named pipe creation
   // to fail.
   return StringPrintf(L"%d.%x.%d",
                       GetCurrentProcessId(), instance,
                       base::RandInt(0, std::numeric_limits<int>::max()));
 }
 
 
 #endif  // CHROME_BROWSER_RENDER_PROCESS_HOST_H_