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

chrome/renderer/render_process.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 <objidl.h>
 #include <mlang.h>
 
 #include "chrome/renderer/render_process.h"
 
@@ skipping 90 matching lines @@
 void RenderProcess::GlobalCleanup() {
   ChildProcess::GlobalCleanup();
 }
 
 // static
 bool RenderProcess::ShouldLoadPluginsInProcess() {
   return load_plugins_in_process_;
 }
 
 // static
-SharedMemory* RenderProcess::AllocSharedMemory(size_t size) {
+base::SharedMemory* RenderProcess::AllocSharedMemory(size_t size) {
   self()->clearer_factory_.RevokeAll();
 
-  SharedMemory* mem = self()->GetSharedMemFromCache(size);
+  base::SharedMemory* mem = self()->GetSharedMemFromCache(size);
   if (mem)
     return mem;
 
   // Round-up size to allocation granularity
   SYSTEM_INFO info;
   GetSystemInfo(&info);
 
   size = size / info.dwAllocationGranularity + 1;
   size = size * info.dwAllocationGranularity;
 
-  mem = new SharedMemory();
+  mem = new base::SharedMemory();
   if (!mem)
     return NULL;
   if (!mem->Create(L"", false, true, size)) {
     delete mem;
     return NULL;
   }
 
   return mem;
 }
 
 // static
-void RenderProcess::FreeSharedMemory(SharedMemory* mem) {
+void RenderProcess::FreeSharedMemory(base::SharedMemory* mem) {
   if (self()->PutSharedMemInCache(mem)) {
     self()->ScheduleCacheClearer();
     return;
   }
   DeleteSharedMem(mem);
 }
 
 // static
-void RenderProcess::DeleteSharedMem(SharedMemory* mem) {
+void RenderProcess::DeleteSharedMem(base::SharedMemory* mem) {
   delete mem;
 }
 
-SharedMemory* RenderProcess::GetSharedMemFromCache(size_t size) {
+base::SharedMemory* RenderProcess::GetSharedMemFromCache(size_t size) {
   // look for a cached object that is suitable for the requested size.
   for (int i = 0; i < arraysize(shared_mem_cache_); ++i) {
-    SharedMemory* mem = shared_mem_cache_[i];
+    base::SharedMemory* mem = shared_mem_cache_[i];
     if (mem && mem->max_size() >= size) {
       shared_mem_cache_[i] = NULL;
       return mem;
     }
   }
   return NULL;
 }
 
-bool RenderProcess::PutSharedMemInCache(SharedMemory* mem) {
+bool RenderProcess::PutSharedMemInCache(base::SharedMemory* mem) {
   // simple algorithm:
   //  - look for an empty slot to store mem, or
   //  - if full, then replace any existing cache entry that is smaller than the
   //    given shared memory object.
   for (int i = 0; i < arraysize(shared_mem_cache_); ++i) {
     if (!shared_mem_cache_[i]) {
       shared_mem_cache_[i] = mem;
       return true;
     }
   }
   for (int i = 0; i < arraysize(shared_mem_cache_); ++i) {
-    SharedMemory* cached_mem = shared_mem_cache_[i];
+    base::SharedMemory* cached_mem = shared_mem_cache_[i];
     if (cached_mem->max_size() < mem->max_size()) {
       shared_mem_cache_[i] = mem;
       DeleteSharedMem(cached_mem);
       return true;
     }
   }
   return false;
 }
 
 void RenderProcess::ClearSharedMemCache() {
@@ skipping 15 matching lines @@
       5000 /* 5 seconds */);
 }
 
 void RenderProcess::Cleanup() {
 #ifndef NDEBUG
   // log important leaked objects
   webkit_glue::CheckForLeaks();
 #endif
 }