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

base/stats_table.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 "base/stats_table.h"
 
 #include "base/logging.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
@@ skipping 94 matching lines @@
     int size;
     int max_counters;
     int max_threads;
   };
 
   // Construct a new StatsTablePrivate based on expected size parameters, or
   // return NULL on failure.
   static StatsTablePrivate* New(const std::wstring& name, int size,
                                 int max_threads, int max_counters);
 
-  SharedMemory* shared_memory() { return &shared_memory_; }
+  base::SharedMemory* shared_memory() { return &shared_memory_; }
 
   // Accessors for our header pointers
   TableHeader* table_header() const { return table_header_; }
   int version() const { return table_header_->version; }
   int size() const { return table_header_->size; }
   int max_counters() const { return table_header_->max_counters; }
   int max_threads() const { return table_header_->max_threads; }
 
   // Accessors for our tables
   wchar_t* thread_name(int slot_id) const {
@@ skipping 19 matching lines @@
   StatsTablePrivate() {}
 
   // Initializes the table on first access.  Sets header values
   // appropriately and zeroes all counters.
   void InitializeTable(void* memory, int size, int max_counters,
                        int max_threads);
 
   // Initializes our in-memory pointers into a pre-created StatsTable.
   void ComputeMappedPointers(void* memory);
 
-  SharedMemory shared_memory_;
+  base::SharedMemory shared_memory_;
   TableHeader* table_header_;
   wchar_t* thread_names_table_;
   int* thread_tid_table_;
   int* thread_pid_table_;
   wchar_t* counter_names_table_;
   int* data_table_;
 };
 
 // static
 StatsTablePrivate* StatsTablePrivate::New(const std::wstring& name,
@@ skipping 116 matching lines @@
     global_table_ = NULL;
 }
 
 int StatsTable::RegisterThread(const std::wstring& name) {
   int slot = 0;
 
   // Registering a thread requires that we lock the shared memory
   // so that two threads don't grab the same slot.  Fortunately,
   // thread creation shouldn't happen in inner loops.
   {
-    SharedMemoryAutoLock lock(impl_->shared_memory());
+    base::SharedMemoryAutoLock lock(impl_->shared_memory());
     slot = FindEmptyThread();
     if (!slot) {
       return 0;
     }
 
     DCHECK(impl_);
 
     // We have space, so consume a column in the table.
     std::wstring thread_name = name;
     if (name.empty())
       thread_name = kUnknownName;
     base::wcslcpy(impl_->thread_name(slot), thread_name.c_str(),
                   kMaxThreadNameLength);
     *(impl_->thread_tid(slot)) = PlatformThread::CurrentId();
-    *(impl_->thread_pid(slot)) = process_util::GetCurrentProcId();
+    *(impl_->thread_pid(slot)) = base::GetCurrentProcId();
   }
 
   // Set our thread local storage.
   StatsTableTLSData* data = new StatsTableTLSData;
   data->table = this;
   data->slot = slot;
   tls_index_.Set(data);
   return slot;
 }
 
@@ skipping 129 matching lines @@
 int StatsTable::AddCounter(const std::wstring& name) {
   DCHECK(impl_);
 
   if (!impl_)
     return 0;
 
   int counter_id = 0;
   {
     // To add a counter to the shared memory, we need the
     // shared memory lock.
-    SharedMemoryAutoLock lock(impl_->shared_memory());
+    base::SharedMemoryAutoLock lock(impl_->shared_memory());
 
     // We have space, so create a new counter.
     counter_id = FindCounterOrEmptyRow(name);
     if (!counter_id)
       return 0;
 
     std::wstring counter_name = name;
     if (name.empty())
       counter_name = kUnknownName;
     base::wcslcpy(impl_->counter_name(counter_id), counter_name.c_str(),
@@ skipping 81 matching lines @@
       return NULL;
 
   // Find the counter id for the counter.
   std::wstring str_name(name);
   int counter = table->FindCounter(str_name);
 
   // Now we can find the location in the table.
   return table->GetLocation(counter, slot);
 }