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

chrome/browser/visitedlink_master.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 "chrome/browser/visitedlink_master.h"
 
 #include <windows.h>
 #include <shlobj.h>
 #include <algorithm>
 
@@ skipping 240 matching lines @@
                       GetCurrentProcessId(), shared_memory_serial_,
                       profile_id.c_str());
 }
 
 bool VisitedLinkMaster::Init() {
   if (!InitFromFile())
     return InitFromScratch(suppress_rebuild_);
   return true;
 }
 
-bool VisitedLinkMaster::ShareToProcess(ProcessHandle process,
-                                       SharedMemoryHandle *new_handle) {
+bool VisitedLinkMaster::ShareToProcess(base::ProcessHandle process,
+                                       base::SharedMemoryHandle *new_handle) {
   if (shared_memory_)
     return shared_memory_->ShareToProcess(process, new_handle);
 
   NOTREACHED();
   return false;
 }
 
-SharedMemoryHandle VisitedLinkMaster::GetSharedMemoryHandle() {
+base::SharedMemoryHandle VisitedLinkMaster::GetSharedMemoryHandle() {
   return shared_memory_->handle();
 }
 
 VisitedLinkMaster::Hash VisitedLinkMaster::TryToAddURL(const GURL& url) {
   // Extra check that we are not off the record. This should not happen.
   if (profile_ && profile_->IsOffTheRecord()) {
     NOTREACHED();
     return null_hash_;
   }
 
@@ skipping 386 matching lines @@
   return true;
 }
 
 // Initializes the shared memory structure. The salt should already be filled
 // in so that it can be written to the shared memory
 bool VisitedLinkMaster::CreateURLTable(int32 num_entries, bool init_to_empty) {
   // The table is the size of the table followed by the entries.
   int32 alloc_size = num_entries * sizeof(Fingerprint) + sizeof(SharedHeader);
 
   // Create the shared memory object.
-  shared_memory_ = new SharedMemory();
+  shared_memory_ = new base::SharedMemory();
   if (!shared_memory_)
     return false;
 
   if (!shared_memory_->Create(GetSharedMemoryName().c_str(),
       false, false, alloc_size))
     return false;
 
   // Map into our process.
   if (!shared_memory_->Map(alloc_size)) {
     delete shared_memory_;
@@ skipping 17 matching lines @@
       static_cast<char*>(shared_memory_->memory()) + sizeof(SharedHeader));
 
 #ifndef NDEBUG
   DebugValidate();
 #endif
 
   return true;
 }
 
 bool VisitedLinkMaster::BeginReplaceURLTable(int32 num_entries) {
-  SharedMemory *old_shared_memory = shared_memory_;
+  base::SharedMemory *old_shared_memory = shared_memory_;
   Fingerprint* old_hash_table = hash_table_;
   int32 old_table_length = table_length_;
   if (!CreateURLTable(num_entries, true)) {
     // Try to put back the old state.
     shared_memory_ = old_shared_memory;
     hash_table_ = old_hash_table;
     table_length_ = old_table_length;
     return false;
   }
   return true;
@@ skipping 38 matching lines @@
 }
 
 void VisitedLinkMaster::ResizeTable(int32 new_size) {
   DCHECK(shared_memory_ && shared_memory_->memory() && hash_table_);
   shared_memory_serial_++;
 
 #ifndef NDEBUG
   DebugValidate();
 #endif
 
-  SharedMemory* old_shared_memory = shared_memory_;
+  base::SharedMemory* old_shared_memory = shared_memory_;
   Fingerprint* old_hash_table = hash_table_;
   int32 old_table_length = table_length_;
   if (!BeginReplaceURLTable(new_size))
     return;
 
   // Now we have two tables, our local copy which is the old one, and the new
   // one loaded into this object where we need to copy the data.
   for (int32 i = 0; i < old_table_length; i++) {
     Fingerprint cur = old_hash_table[i];
     if (cur)
@@ skipping 78 matching lines @@
 // See the TableBuilder definition in the header file for how this works.
 void VisitedLinkMaster::OnTableRebuildComplete(
     bool success,
     const std::vector<Fingerprint>& fingerprints) {
   if (success) {
     // Replace the old table with a new blank one.
     shared_memory_serial_++;
 
     // We are responsible for freeing it AFTER it has been replaced if
     // replacement succeeds.
-    SharedMemory* old_shared_memory = shared_memory_;
+    base::SharedMemory* old_shared_memory = shared_memory_;
 
     int new_table_size = NewTableSizeForCount(
         static_cast<int>(fingerprints.size()));
     if (BeginReplaceURLTable(new_table_size)) {
       // Free the old table.
       delete old_shared_memory;
 
       // Add the stored fingerprints to the hash table.
       for (size_t i = 0; i < fingerprints.size(); i++)
         AddFingerprint(fingerprints[i]);
@@ skipping 118 matching lines @@
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 
   // WILL (generally) DELETE THIS! This balances the AddRef in
   // VisitedLinkMaster::RebuildTableFromHistory.
   Release();
 }