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

chrome/renderer/render_process.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_RENDERER_RENDER_PROCESS_H__
 #define CHROME_RENDERER_RENDER_PROCESS_H__
 
 #include <objidl.h>
 #include <mlang.h>
 
@@ skipping 12 matching lines @@
   static void GlobalCleanup();
 
   // Returns true if plugins should be loaded in-process.
   static bool ShouldLoadPluginsInProcess();
 
   // Allocates shared memory.  When no longer needed, you should pass the
   // SharedMemory pointer to FreeSharedMemory so it can be recycled.  The size
   // reported in the resulting SharedMemory object will be greater than or
   // equal to the requested size.  This method returns NULL if unable to
   // allocate memory for some reason.
-  static SharedMemory* AllocSharedMemory(size_t size);
+  static base::SharedMemory* AllocSharedMemory(size_t size);
 
   // Frees shared memory allocated by AllocSharedMemory.  You should only use
   // this function to free the SharedMemory object.
-  static void FreeSharedMemory(SharedMemory* mem);
+  static void FreeSharedMemory(base::SharedMemory* mem);
 
   // Deletes the shared memory allocated by AllocSharedMemory.
-  static void DeleteSharedMem(SharedMemory* mem);
+  static void DeleteSharedMem(base::SharedMemory* mem);
 
  private:
   friend class ChildProcessFactory<RenderProcess>;
   RenderProcess(const std::wstring& channel_name);
   ~RenderProcess();
 
   // Returns a pointer to the RenderProcess singleton instance.  This is
   // guaranteed to be non-NULL between calls to GlobalInit and GlobalCleanup.
   static RenderProcess* self() {
     return static_cast<RenderProcess*>(child_process_);
   }
 
   static ChildProcess* ClassFactory(const std::wstring& channel_name);
 
   // Look in the shared memory cache for a suitable object to reuse.  Returns
   // NULL if there is none.
-  SharedMemory* GetSharedMemFromCache(size_t size);
+  base::SharedMemory* GetSharedMemFromCache(size_t size);
 
   // Maybe put the given shared memory into the shared memory cache.  Returns
   // true if the SharedMemory object was stored in the cache; otherwise, false
   // is returned.
-  bool PutSharedMemInCache(SharedMemory* mem);
+  bool PutSharedMemInCache(base::SharedMemory* mem);
 
   void ClearSharedMemCache();
 
   // We want to lazily clear the shared memory cache if no one has requested
   // memory.  This methods are used to schedule a deferred call to
   // RenderProcess::ClearSharedMemCache.
   void ScheduleCacheClearer();
 
   // ChildProcess implementation
   virtual void Cleanup();
 
   // The one render thread (to be replaced with a set of render threads).
   RenderThread render_thread_;
 
   // A very simplistic and small cache.  If an entry in this array is non-null,
   // then it points to a SharedMemory object that is available for reuse.
-  SharedMemory* shared_mem_cache_[2];
+  base::SharedMemory* shared_mem_cache_[2];
 
   // This factory is used to lazily invoke ClearSharedMemCache.
   ScopedRunnableMethodFactory<RenderProcess> clearer_factory_;
 
   static bool load_plugins_in_process_;
 
   DISALLOW_EVIL_CONSTRUCTORS(RenderProcess);
 };
 
 #endif  // CHROME_RENDERER_RENDER_PROCESS_H__