TaskManager: introduce Resource::(Can)Inspect; support tabs, apps, extensions and notifications.

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"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "webkit/glue/webpreferences.h"
 
 namespace {
 
 static Value* CreateColumnValue(const TaskManagerModel* tm,
                                 const std::string column_name,
                                 const int i) {
+  if (column_name == "resourceIndex")
+    return Value::CreateIntegerValue(i);
   if (column_name == "processId")
     return Value::CreateStringValue(tm->GetResourceProcessId(i));
   if (column_name == "processIdValue")
     return Value::CreateIntegerValue(tm->GetProcessId(i));
   if (column_name == "cpuUsage")
     return Value::CreateStringValue(tm->GetResourceCPUUsage(i));
   if (column_name == "cpuUsageValue")
     return Value::CreateDoubleValue(tm->GetCPUUsage(i));
   if (column_name == "privateMemory")
     return Value::CreateStringValue(tm->GetResourcePrivateMemory(i));
@@ skipping 66 matching lines @@
     return Value::CreateStringValue(tm->GetResourceGoatsTeleported(i));
   if (column_name == "goatsTeleportedValue")
     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));
 
   NOTREACHED();
   return NULL;
 }
 
 static void CreateGroupColumnList(const TaskManagerModel* tm,
                                   const std::string column_name,
                                   const int index,
                                   const int length,
                                   DictionaryValue* val) {
@@ skipping 11 matching lines @@
   const int group_count = tm->GroupCount();
   if (group_index >= group_count)
      return val;
 
   int index = tm->GetResourceIndexForGroup(group_index, 0);
   std::pair<int, int> group_range;
   group_range = tm->GetGroupRangeForResource(index);
   int length = group_range.second;
 
   val->SetInteger("index", index);
-  val->SetInteger("group_range_start", group_range.first);
-  val->SetInteger("group_range_length", group_range.second);
-  val->SetInteger("index_in_group", index - group_range.first);
-  val->SetBoolean("is_resource_first_in_group",
-                  tm->IsResourceFirstInGroup(index));
   val->SetBoolean("isBackgroundResource",
                   tm->IsBackgroundResource(index));
 
   // Columns which have one datum in each group.
   CreateGroupColumnList(tm, "processId", index, 1, val);
   CreateGroupColumnList(tm, "processIdValue", index, 1, val);
   CreateGroupColumnList(tm, "cpuUsage", index, 1, val);
   CreateGroupColumnList(tm, "cpuUsageValue", index, 1, val);
   CreateGroupColumnList(tm, "physicalMemory", index, 1, val);
   CreateGroupColumnList(tm, "physicalMemoryValue", index, 1, val);
   CreateGroupColumnList(tm, "sharedMemory", index, 1, val);
   CreateGroupColumnList(tm, "sharedMemoryValue", index, 1, val);
   CreateGroupColumnList(tm, "privateMemory", index, 1, val);
   CreateGroupColumnList(tm, "privateMemoryValue", index, 1, val);
   CreateGroupColumnList(tm, "webCoreImageCacheSize", index, 1, val);
   CreateGroupColumnList(tm, "webCoreImageCacheSizeValue", index, 1, val);
   CreateGroupColumnList(tm, "webCoreScriptsCacheSize", index, 1, val);
   CreateGroupColumnList(tm, "webCoreScriptsCacheSizeValue", index, 1, val);
   CreateGroupColumnList(tm, "webCoreCSSCacheSize", index, 1, val);
   CreateGroupColumnList(tm, "webCoreCSSCacheSizeValue", index, 1, val);
   CreateGroupColumnList(tm, "sqliteMemoryUsed", index, 1, val);
   CreateGroupColumnList(tm, "sqliteMemoryUsedValue", index, 1, val);
   CreateGroupColumnList(tm, "v8MemoryAllocatedSize", index, 1, val);
   CreateGroupColumnList(tm, "v8MemoryAllocatedSizeValue", index, 1, val);
 
   // Columns which have some data in each group.
+  CreateGroupColumnList(tm, "resourceIndex", index, length, val);
   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);
 
   return val;
 }
 
 }  // namespace
 
 TaskManagerHandler::TaskManagerHandler(TaskManager* tm)
     : task_manager_(tm),
       model_(tm->model()),
       is_enabled_(false) {
@@ skipping 98 matching lines @@
   OnGroupRemoved(group_start, group_end - group_start + 1);
 }
 
 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("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)));
 }
 
+static int parseIndex(const Value* value) {
+  int index = -1;
+  string16 string16_index;
+  double double_index;
+  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 = -1;
-    string16 string16_index;
-    double double_index;
-    if ((*i)->GetAsString(&string16_index)) {
-      base::StringToInt(string16_index, &index);
-    } else if ((*i)->GetAsDouble(&double_index)) {
-      index = static_cast<int>(double_index);
-    } else {
-      (*i)->GetAsInteger(&index);
-    }
+    int index = parseIndex(*i);
     if (index == -1)
       continue;
 
     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::HandleInspect(const ListValue* resource_index) {
+  for (ListValue::const_iterator i = resource_index->begin();
+       i != resource_index->end(); i++) {

[yurys, 2011/10/26 14:33:44]

++i

+    int resource_index = parseIndex(*i);
+    if (resource_index == -1)
+      continue;
+    if (model_->CanInspect(resource_index))
+      model_->Inspect(resource_index);
+    break;
+  }
+}
+
 void TaskManagerHandler::DisableTaskManager(const ListValue* indexes) {
   if (!is_enabled_)
     return;
 
   is_enabled_ = false;
   model_->StopUpdating();
   model_->RemoveObserver(this);
 }
 
 void TaskManagerHandler::EnableTaskManager(const ListValue* indexes) {
@@ skipping 70 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_)
     web_ui_->CallJavascriptFunction("taskRemoved", start_value, length_value);
 }