WebUI Task manager: prevent to kill the wrong process or none

chrome/browser/ui/webui/task_manager_handler.cc

 // Copyright (c) 2011 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/ui/webui/task_manager_handler.h"
 
 #include <algorithm>
 #include <functional>
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 289 matching lines @@
   std::vector<int>::iterator it_last = it_first + length - 1;
   resource_to_group_table_.erase(it_first, it_last);
 
   OnGroupRemoved(group_start, group_end - group_start + 1);
 }
 
 void TaskManagerHandler::Init() {
 }
 
 void TaskManagerHandler::RegisterMessages() {
-  web_ui_->RegisterMessageCallback("killProcess",
-      base::Bind(&TaskManagerHandler::HandleKillProcess,
+  web_ui_->RegisterMessageCallback("killProcesses",
+      base::Bind(&TaskManagerHandler::HandleKillProcesses,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("inspect",
       base::Bind(&TaskManagerHandler::HandleInspect,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("activatePage",
       base::Bind(&TaskManagerHandler::HandleActivatePage,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("openAboutMemory",
       base::Bind(&TaskManagerHandler::OpenAboutMemory,
                  base::Unretained(this)));
@@ skipping 12 matching lines @@
   if (value->GetAsString(&string16_index)) {
     base::StringToInt(string16_index, &index);
   } else if (value->GetAsDouble(&double_index)) {
     index = static_cast<int>(double_index);
   } else {
     value->GetAsInteger(&index);
   }
   return index;
 }
 
-void TaskManagerHandler::HandleKillProcess(const ListValue* indexes) {
-  for (ListValue::const_iterator i = indexes->begin();
-       i != indexes->end(); i++) {
-    int index = parseIndex(*i);
-    if (index == -1)
-      continue;
+void TaskManagerHandler::HandleKillProcesses(const ListValue* indexes) {
+  for (int resource_index = 0; resource_index < model_->ResourceCount();

[James Hawkins, 2011/12/13 17:44:22]

Is there not a better way to do this?  It seems like there should be a way to
KillProcess(pid).

[yoshiki, 2011/12/14 09:06:47]

I changed to use unique_id to determine the process instead of pid. This is same
way as the other manipulate methods (HandleActivatePage() and HandleInspect()).
I think it is safer way to determine the process, because there are no
confidence to be able to convert "PID" into "int" without degradation on any
platform.

On 2011/12/13 17:44:22, James Hawkins wrote:

+       ++resource_index) {
+    int resource_pid = model_->GetProcessId(resource_index);
 
-    int resource_index = model_->GetResourceIndexForGroup(index, 0);
-    if (resource_index == -1)
-      continue;
+    for (ListValue::const_iterator i = indexes->begin(); i != indexes->end();
+         ++i) {
+      int pid = parseIndex(*i);
+      if (pid == -1)
+        continue;
 
-    LOG(INFO) << "kill PID:" << model_->GetResourceProcessId(resource_index);
-    task_manager_->KillProcess(resource_index);
+      if (resource_pid == pid) {
+        LOG(INFO) << "kill PID:" << pid;

[James Hawkins, 2011/12/13 17:44:22]

Remove log spam.

[yoshiki, 2011/12/14 09:06:47]

Done.

+        task_manager_->KillProcess(resource_index);
+        break;
+      }
+    }
   }
 }
 
 void TaskManagerHandler::HandleActivatePage(const ListValue* resource_index) {
   for (ListValue::const_iterator i = resource_index->begin();
        i != resource_index->end(); ++i) {
     int unique_id = parseIndex(*i);
     if (unique_id == -1)
       continue;
 
@@ skipping 116 matching lines @@
   }
 }
 
 void TaskManagerHandler::OnGroupRemoved(const int group_start,
                                         const int group_length) {
   base::FundamentalValue start_value(group_start);
   base::FundamentalValue length_value(group_length);
   if (is_enabled_ && is_alive())
     web_ui_->CallJavascriptFunction("taskRemoved", start_value, length_value);
 }