WebUI TaskManager: Add "Activate page" feature.

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 102 matching lines @@
     return Value::CreateIntegerValue(tm->GetGoatsTeleported(i));
   if (column_name == "v8MemoryAllocatedSize")
     return Value::CreateStringValue(tm->GetResourceV8MemoryAllocatedSize(i));
   if (column_name == "v8MemoryAllocatedSizeValue") {
     size_t v8_memory;
     tm->GetV8Memory(i, &v8_memory);
     return Value::CreateDoubleValue(v8_memory);
   }
   if (column_name == "canInspect")
     return Value::CreateBooleanValue(tm->CanInspect(i));
+  if (column_name == "canActivate")
+    return Value::CreateBooleanValue(tm->CanActivate(i));
 
   NOTREACHED();
   return NULL;
 }
 
 static void CreateGroupColumnList(const TaskManagerModel* tm,
                                   const std::string column_name,
                                   const int index,
                                   const int length,
                                   DictionaryValue* val) {
@@ skipping 49 matching lines @@
   CreateGroupColumnList(tm, "icon", index, length, val);
   CreateGroupColumnList(tm, "title", index, length, val);
   CreateGroupColumnList(tm, "profileName", index, length, val);
   CreateGroupColumnList(tm, "networkUsage", index, length, val);
   CreateGroupColumnList(tm, "networkUsageValue", index, length, val);
   CreateGroupColumnList(tm, "fps", index, length, val);
   CreateGroupColumnList(tm, "fpsValue", index, length, val);
   CreateGroupColumnList(tm, "goatsTeleported", index, length, val);
   CreateGroupColumnList(tm, "goatsTeleportedValue", index, length, val);
   CreateGroupColumnList(tm, "canInspect", index, length, val);
+  CreateGroupColumnList(tm, "canActivate", index, length, val);
 
   return val;
 }
 
 }  // namespace
 
 TaskManagerHandler::TaskManagerHandler(TaskManager* tm)
     : task_manager_(tm),
       model_(tm->model()),
       is_enabled_(false) {
@@ skipping 101 matching lines @@
 void TaskManagerHandler::Init() {
 }
 
 void TaskManagerHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback("killProcess",
       base::Bind(&TaskManagerHandler::HandleKillProcess,
                  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)));
   web_ui_->RegisterMessageCallback("enableTaskManager",
       base::Bind(&TaskManagerHandler::EnableTaskManager,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("disableTaskManager",
       base::Bind(&TaskManagerHandler::DisableTaskManager,
                  base::Unretained(this)));
 }
@@ skipping 21 matching lines @@
 
     int resource_index = model_->GetResourceIndexForGroup(index, 0);
     if (resource_index == -1)
       continue;
 
     LOG(INFO) << "kill PID:" << model_->GetResourceProcessId(resource_index);
     task_manager_->KillProcess(resource_index);
   }
 }
 
+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;
+
+    for (int resource_index = 0; resource_index < model_->ResourceCount();
+         ++resource_index) {
+      if (model_->GetResourceUniqueId(resource_index) == unique_id) {
+        task_manager_->ActivateProcess(resource_index);
+        break;
+      }
+    }
+
+    break;
+  }
+}
+
 void TaskManagerHandler::HandleInspect(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;
 
     for (int resource_index = 0; resource_index < model_->ResourceCount();
          ++resource_index) {
       if (model_->GetResourceUniqueId(resource_index) == unique_id) {
@@ skipping 94 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);
 }