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

chrome/browser/task_manager.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/task_manager.h"
 
 #include "base/process_util.h"
 #include "base/stats_table.h"
 #include "base/string_util.h"
 #include "chrome/app/theme/theme_resources.h"
@@ skipping 78 matching lines @@
 int TaskManagerTableModel::RowCount() {
   return static_cast<int>(resources_.size());
 }
 
 std::wstring TaskManagerTableModel::GetText(int row, int col_id) {
   // Let's find out if we are the first item in our group.
   TaskManager::Resource* resource = resources_[row];
   ResourceList* group = group_map_[resource->GetProcess()];
   DCHECK(group && !group->empty());
   bool first_in_group = ((*group)[0] == resource);
-  process_util::ProcessMetrics* process_metrics = NULL;
+  base::ProcessMetrics* process_metrics = NULL;
   if (first_in_group) {
     MetricsMap::iterator iter = metrics_map_.find(resource->GetProcess());
     DCHECK(iter != metrics_map_.end());
     process_metrics = iter->second;
   }
 
   switch (col_id) {
     case IDS_TASK_MANAGER_PAGE_COLUMN:  // Process
       return resource->GetTitle();
 
@@ skipping 31 matching lines @@
     case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN:  // Memory
       if (!first_in_group)
         return std::wstring();
       return l10n_util::GetStringF(
           IDS_TASK_MANAGER_MEM_CELL_TEXT,
           FormatNumber(GetPhysicalMemory(process_metrics)));
 
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
       if (!first_in_group)
         return std::wstring();
-      return IntToWString(process_util::GetProcId(resource->GetProcess()));
+      return IntToWString(base::GetProcId(resource->GetProcess()));
       
     case kGoatsTeleportedColumn:  // Goats Teleported.
       goats_teleported_ += rand();
       return FormatNumber(goats_teleported_);
 
     default:
       return IntToWString(GetStatsValue(resource, col_id));
   }
 }
 
 int64 TaskManagerTableModel::GetNetworkUsage(TaskManager::Resource* resource) {
   int64 net_usage = GetNetworkUsageForResource(resource);
   if (net_usage == 0 && !resource->SupportNetworkUsage())
     return -1;
   return net_usage;
 }
 
 int TaskManagerTableModel::GetCPUUsage(TaskManager::Resource* resource) {
   CPUUsageMap::const_iterator iter =
       cpu_usage_map_.find(resource->GetProcess());
    if (iter == cpu_usage_map_.end())
      return 0;
    return iter->second;
 }
 
 size_t TaskManagerTableModel::GetPrivateMemory(
-    process_util::ProcessMetrics* process_metrics) {
+    base::ProcessMetrics* process_metrics) {
   return process_metrics->GetPrivateBytes() / 1024;
 }
 
 size_t TaskManagerTableModel::GetSharedMemory(
-    process_util::ProcessMetrics* process_metrics) {
-  process_util::WorkingSetKBytes ws_usage;
+    base::ProcessMetrics* process_metrics) {
+  base::WorkingSetKBytes ws_usage;
   process_metrics->GetWorkingSetKBytes(&ws_usage);
   return ws_usage.shared;
 }
 
 size_t TaskManagerTableModel::GetPhysicalMemory(
-    process_util::ProcessMetrics* process_metrics) {
+    base::ProcessMetrics* process_metrics) {
   // Memory = working_set.private + working_set.shareable.
   // We exclude the shared memory.
   size_t total_kbytes = process_metrics->GetWorkingSetSize() / 1024;
-  process_util::WorkingSetKBytes ws_usage;
+  base::WorkingSetKBytes ws_usage;
   process_metrics->GetWorkingSetKBytes(&ws_usage);
   total_kbytes -= ws_usage.shared;
   return total_kbytes;
 }
 
 int TaskManagerTableModel::GetStatsValue(TaskManager::Resource* resource,
                                          int col_id) {
   StatsTable* table = StatsTable::current();
   if (table != NULL) {
     const wchar_t* counter = table->GetRowName(col_id);
     if (counter != NULL && counter[0] != '\0') {
       return table->GetCounterValue(counter,
-          process_util::GetProcId(resource->GetProcess()));
+          base::GetProcId(resource->GetProcess()));
      } else {
         NOTREACHED() << "Invalid column.";
      }
   }
   return 0;
 }
 
 SkBitmap TaskManagerTableModel::GetIcon(int row) {
   DCHECK(row < RowCount());
   SkBitmap icon = resources_[row]->GetIcon();
@@ skipping 119 matching lines @@
 
     // Insert the new entry right after the last entry of its group.
     ResourceList::iterator iter =
         std::find(resources_.begin(),
                   resources_.end(),
                   (*group_entries)[group_entries->size() - 2]);
     DCHECK(iter != resources_.end());
     new_entry_index = static_cast<int>(iter - resources_.begin());
     resources_.insert(++iter, resource);
   }
-  process_util::ProcessMetrics* pm =
-      process_util::ProcessMetrics::CreateProcessMetrics(process);
+  base::ProcessMetrics* pm =
+      base::ProcessMetrics::CreateProcessMetrics(process);
   metrics_map_[process] = pm;
 
   // Notify the table that the contents have changed for it to redraw.
   DCHECK(observer_);
   observer_->OnItemsAdded(new_entry_index, 1);
 }
 
 void TaskManagerTableModel::RemoveResource(TaskManager::Resource* resource) {
   HANDLE process = resource->GetProcess();
 
@@ skipping 137 matching lines @@
 
     case IDS_TASK_MANAGER_NET_COLUMN:
       return ValueCompare<int64>(GetNetworkUsage(resources_[row1]),
                                  GetNetworkUsage(resources_[row2]));
 
     case IDS_TASK_MANAGER_CPU_COLUMN:
       return ValueCompare<int>(GetCPUUsage(resources_[row1]),
                                GetCPUUsage(resources_[row2]));
 
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN: {
-      process_util::ProcessMetrics* pm1;
-      process_util::ProcessMetrics* pm2;
+      base::ProcessMetrics* pm1;
+      base::ProcessMetrics* pm2;
       if (!GetProcessMetricsForRows(row1, row2, &pm1, &pm2))
         return 0;
       return ValueCompare<size_t>(GetPrivateMemory(pm1),
                                   GetPrivateMemory(pm2));
     }
 
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN: {
-      process_util::ProcessMetrics* pm1;
-      process_util::ProcessMetrics* pm2;
+      base::ProcessMetrics* pm1;
+      base::ProcessMetrics* pm2;
       if (!GetProcessMetricsForRows(row1, row2, &pm1, &pm2))
         return 0;
       return ValueCompare<size_t>(GetSharedMemory(pm1),
                                   GetSharedMemory(pm2));
     }
 
     case IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN: {
-      process_util::ProcessMetrics* pm1;
-      process_util::ProcessMetrics* pm2;
+      base::ProcessMetrics* pm1;
+      base::ProcessMetrics* pm2;
       if (!GetProcessMetricsForRows(row1, row2, &pm1, &pm2))
         return 0;
       return ValueCompare<size_t>(GetPhysicalMemory(pm1),
                                   GetPhysicalMemory(pm2));
     }
 
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN: {
-      int proc1_id = process_util::GetProcId(resources_[row1]->GetProcess());
-      int proc2_id = process_util::GetProcId(resources_[row2]->GetProcess());
+      int proc1_id = base::GetProcId(resources_[row1]->GetProcess());
+      int proc2_id = base::GetProcId(resources_[row2]->GetProcess());
       return ValueCompare<int>(proc1_id, proc2_id);
     }
       
     case kGoatsTeleportedColumn:
       return 0;  // Don't bother, numbers are random.
 
     default:
       return ValueCompare<int>(GetStatsValue(resources_[row1], column_id),
                                GetStatsValue(resources_[row2], column_id));
   }
@@ skipping 80 matching lines @@
                      NewRunnableMethod(
                         this,
                         &TaskManagerTableModel::BytesRead,
                         BytesReadParam(job->request()->origin_pid(),
                                        render_process_host_id, routing_id,
                                        byte_count)));
 }
 
 bool TaskManagerTableModel::GetProcessMetricsForRows(
     int row1, int row2,
-    process_util::ProcessMetrics** proc_metrics1,
-    process_util::ProcessMetrics** proc_metrics2) {
+    base::ProcessMetrics** proc_metrics1,
+    base::ProcessMetrics** proc_metrics2) {
 
   DCHECK(row1 < static_cast<int>(resources_.size()) &&
          row2 < static_cast<int>(resources_.size()));
   *proc_metrics1 = NULL;
   *proc_metrics2 = NULL;
 
   MetricsMap::iterator iter = metrics_map_.find(resources_[row1]->GetProcess());
   if (iter == metrics_map_.end())
     return false;
   *proc_metrics1 = iter->second;
@@ skipping 448 matching lines @@
 
 views::View* TaskManager::GetContentsView() {
   return contents_.get();
 }
 
 // static
 TaskManager* TaskManager::GetInstance() {
   return Singleton<TaskManager>::get();
 }