| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/ui/webui/task_manager_handler.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <functional> | |
| 9 #include "base/bind.h" | |
| 10 #include "base/bind_helpers.h" | |
| 11 #include "base/string_number_conversions.h" | |
| 12 #include "base/values.h" | |
| 13 #include "chrome/browser/profiles/profile.h" | |
| 14 #include "chrome/browser/task_manager/task_manager.h" | |
| 15 #include "chrome/browser/ui/webui/web_ui_util.h" | |
| 16 #include "chrome/common/chrome_notification_types.h" | |
| 17 #include "content/browser/renderer_host/render_view_host.h" | |
| 18 #include "content/public/browser/notification_service.h" | |
| 19 #include "content/public/browser/notification_source.h" | |
| 20 #include "content/public/browser/render_view_host_delegate.h" | |
| 21 #include "content/public/browser/web_contents.h" | |
| 22 #include "content/public/browser/web_ui.h" | |
| 23 #include "third_party/skia/include/core/SkBitmap.h" | |
| 24 #include "webkit/glue/webpreferences.h" | |
| 25 | |
| 26 namespace { | |
| 27 | |
| 28 Value* CreateColumnValue(const TaskManagerModel* tm, | |
| 29 const std::string column_name, | |
| 30 const int i) { | |
| 31 if (column_name == "uniqueId") | |
| 32 return Value::CreateIntegerValue(tm->GetResourceUniqueId(i)); | |
| 33 if (column_name == "type") | |
| 34 return Value::CreateStringValue( | |
| 35 TaskManager::Resource::GetResourceTypeAsString( | |
| 36 tm->GetResourceType(i))); | |
| 37 if (column_name == "processId") | |
| 38 return Value::CreateStringValue(tm->GetResourceProcessId(i)); | |
| 39 if (column_name == "processIdValue") | |
| 40 return Value::CreateIntegerValue(tm->GetProcessId(i)); | |
| 41 if (column_name == "cpuUsage") | |
| 42 return Value::CreateStringValue(tm->GetResourceCPUUsage(i)); | |
| 43 if (column_name == "cpuUsageValue") | |
| 44 return Value::CreateDoubleValue(tm->GetCPUUsage(i)); | |
| 45 if (column_name == "privateMemory") | |
| 46 return Value::CreateStringValue(tm->GetResourcePrivateMemory(i)); | |
| 47 if (column_name == "privateMemoryValue") { | |
| 48 size_t private_memory; | |
| 49 tm->GetPrivateMemory(i, &private_memory); | |
| 50 return Value::CreateDoubleValue(private_memory); | |
| 51 } | |
| 52 if (column_name == "sharedMemory") | |
| 53 return Value::CreateStringValue(tm->GetResourceSharedMemory(i)); | |
| 54 if (column_name == "sharedMemoryValue") { | |
| 55 size_t shared_memory; | |
| 56 tm->GetSharedMemory(i, &shared_memory); | |
| 57 return Value::CreateDoubleValue(shared_memory); | |
| 58 } | |
| 59 if (column_name == "physicalMemory") | |
| 60 return Value::CreateStringValue(tm->GetResourcePhysicalMemory(i)); | |
| 61 if (column_name == "physicalMemoryValue") { | |
| 62 size_t physical_memory; | |
| 63 tm->GetPhysicalMemory(i, &physical_memory); | |
| 64 return Value::CreateDoubleValue(physical_memory); | |
| 65 } | |
| 66 if (column_name == "icon") | |
| 67 return Value::CreateStringValue( | |
| 68 web_ui_util::GetImageDataUrl(tm->GetResourceIcon(i))); | |
| 69 if (column_name == "title") | |
| 70 return Value::CreateStringValue(tm->GetResourceTitle(i)); | |
| 71 if (column_name == "profileName") | |
| 72 return Value::CreateStringValue(tm->GetResourceProfileName(i)); | |
| 73 if (column_name == "networkUsage") | |
| 74 return Value::CreateStringValue(tm->GetResourceNetworkUsage(i)); | |
| 75 if (column_name == "networkUsageValue") | |
| 76 return Value::CreateDoubleValue(tm->GetNetworkUsage(i)); | |
| 77 if (column_name == "webCoreImageCacheSize") | |
| 78 return Value::CreateStringValue(tm->GetResourceWebCoreImageCacheSize(i)); | |
| 79 if (column_name == "webCoreImageCacheSizeValue") { | |
| 80 WebKit::WebCache::ResourceTypeStats resource_stats; | |
| 81 tm->GetWebCoreCacheStats(i, &resource_stats); | |
| 82 return Value::CreateDoubleValue(resource_stats.images.size); | |
| 83 } | |
| 84 if (column_name == "webCoreScriptsCacheSize") | |
| 85 return Value::CreateStringValue(tm->GetResourceWebCoreScriptsCacheSize(i)); | |
| 86 if (column_name == "webCoreScriptsCacheSizeValue") { | |
| 87 WebKit::WebCache::ResourceTypeStats resource_stats; | |
| 88 tm->GetWebCoreCacheStats(i, &resource_stats); | |
| 89 return Value::CreateDoubleValue(resource_stats.scripts.size); | |
| 90 } | |
| 91 if (column_name == "webCoreCSSCacheSize") | |
| 92 return Value::CreateStringValue(tm->GetResourceWebCoreCSSCacheSize(i)); | |
| 93 if (column_name == "webCoreCSSCacheSizeValue") { | |
| 94 WebKit::WebCache::ResourceTypeStats resource_stats; | |
| 95 tm->GetWebCoreCacheStats(i, &resource_stats); | |
| 96 return Value::CreateDoubleValue(resource_stats.cssStyleSheets.size); | |
| 97 } | |
| 98 if (column_name == "fps") | |
| 99 return Value::CreateStringValue(tm->GetResourceFPS(i)); | |
| 100 if (column_name == "fpsValue") { | |
| 101 float fps; | |
| 102 tm->GetFPS(i, &fps); | |
| 103 return Value::CreateDoubleValue(fps); | |
| 104 } | |
| 105 if (column_name == "sqliteMemoryUsed") | |
| 106 return Value::CreateStringValue(tm->GetResourceSqliteMemoryUsed(i)); | |
| 107 if (column_name == "sqliteMemoryUsedValue") { | |
| 108 size_t sqlite_memory; | |
| 109 tm->GetSqliteMemoryUsedBytes(i, &sqlite_memory); | |
| 110 return Value::CreateDoubleValue(sqlite_memory); | |
| 111 } | |
| 112 if (column_name == "goatsTeleported") | |
| 113 return Value::CreateStringValue(tm->GetResourceGoatsTeleported(i)); | |
| 114 if (column_name == "goatsTeleportedValue") | |
| 115 return Value::CreateIntegerValue(tm->GetGoatsTeleported(i)); | |
| 116 if (column_name == "v8MemoryAllocatedSize") | |
| 117 return Value::CreateStringValue(tm->GetResourceV8MemoryAllocatedSize(i)); | |
| 118 if (column_name == "v8MemoryAllocatedSizeValue") { | |
| 119 size_t v8_memory; | |
| 120 tm->GetV8Memory(i, &v8_memory); | |
| 121 return Value::CreateDoubleValue(v8_memory); | |
| 122 } | |
| 123 if (column_name == "canInspect") | |
| 124 return Value::CreateBooleanValue(tm->CanInspect(i)); | |
| 125 if (column_name == "canActivate") | |
| 126 return Value::CreateBooleanValue(tm->CanActivate(i)); | |
| 127 | |
| 128 NOTREACHED(); | |
| 129 return NULL; | |
| 130 } | |
| 131 | |
| 132 void CreateGroupColumnList(const TaskManagerModel* tm, | |
| 133 const std::string& column_name, | |
| 134 const int index, | |
| 135 const int length, | |
| 136 DictionaryValue* val) { | |
| 137 ListValue *list = new ListValue(); | |
| 138 for (int i = index; i < (index + length); ++i) { | |
| 139 list->Append(CreateColumnValue(tm, column_name, i)); | |
| 140 } | |
| 141 val->Set(column_name, list); | |
| 142 } | |
| 143 | |
| 144 struct ColumnType { | |
| 145 const char* column_id; | |
| 146 // Whether the column has the real value separately or not, instead of the | |
| 147 // formatted value to display. | |
| 148 const bool has_real_value; | |
| 149 // Whether the column has single datum or multiple data in each group. | |
| 150 const bool has_multiple_data; | |
| 151 }; | |
| 152 | |
| 153 const ColumnType kColumnsList[] = { | |
| 154 {"type", false, false}, | |
| 155 {"processId", true, false}, | |
| 156 {"cpuUsage", true, false}, | |
| 157 {"physicalMemory", true, false}, | |
| 158 {"sharedMemory", true, false}, | |
| 159 {"privateMemory", true, false}, | |
| 160 {"webCoreImageCacheSize", true, false}, | |
| 161 {"webCoreImageCacheSize", true, false}, | |
| 162 {"webCoreScriptsCacheSize", true, false}, | |
| 163 {"webCoreCSSCacheSize", true, false}, | |
| 164 {"sqliteMemoryUsed", true, false}, | |
| 165 {"v8MemoryAllocatedSize", true, false}, | |
| 166 {"icon", false, true}, | |
| 167 {"title", false, true}, | |
| 168 {"profileName", false, true}, | |
| 169 {"networkUsage", true, true}, | |
| 170 {"fps", true, true}, | |
| 171 {"goatsTeleported", true, true}, | |
| 172 {"canInspect", false, true}, | |
| 173 {"canActivate", false, true} | |
| 174 }; | |
| 175 | |
| 176 DictionaryValue* CreateTaskGroupValue( | |
| 177 const TaskManagerModel* tm, | |
| 178 const int group_index, | |
| 179 const std::set<std::string>& columns) { | |
| 180 DictionaryValue* val = new DictionaryValue(); | |
| 181 | |
| 182 const int group_count = tm->GroupCount(); | |
| 183 if (group_index >= group_count) | |
| 184 return val; | |
| 185 | |
| 186 int index = tm->GetResourceIndexForGroup(group_index, 0); | |
| 187 std::pair<int, int> group_range; | |
| 188 group_range = tm->GetGroupRangeForResource(index); | |
| 189 int length = group_range.second; | |
| 190 | |
| 191 // Forces to set following 3 columns regardless of |enable_columns|. | |
| 192 val->SetInteger("index", index); | |
| 193 val->SetBoolean("isBackgroundResource", | |
| 194 tm->IsBackgroundResource(index)); | |
| 195 CreateGroupColumnList(tm, "uniqueId", index, length, val); | |
| 196 CreateGroupColumnList(tm, "processId", index, 1, val); | |
| 197 | |
| 198 for (size_t i = 0; i < arraysize(kColumnsList); ++i) { | |
| 199 const std::string column_id = kColumnsList[i].column_id; | |
| 200 | |
| 201 if (columns.find(column_id) == columns.end()) | |
| 202 continue; | |
| 203 | |
| 204 int column_length = kColumnsList[i].has_multiple_data ? length : 1; | |
| 205 CreateGroupColumnList(tm, column_id, index, column_length, val); | |
| 206 | |
| 207 if (kColumnsList[i].has_real_value) | |
| 208 CreateGroupColumnList(tm, column_id + "Value", index, column_length, val); | |
| 209 } | |
| 210 | |
| 211 return val; | |
| 212 } | |
| 213 | |
| 214 } // namespace | |
| 215 | |
| 216 TaskManagerHandler::TaskManagerHandler(TaskManager* tm) | |
| 217 : task_manager_(tm), | |
| 218 model_(tm->model()), | |
| 219 is_enabled_(false) { | |
| 220 } | |
| 221 | |
| 222 TaskManagerHandler::~TaskManagerHandler() { | |
| 223 DisableTaskManager(NULL); | |
| 224 } | |
| 225 | |
| 226 // TaskManagerHandler, public: ----------------------------------------------- | |
| 227 | |
| 228 void TaskManagerHandler::OnModelChanged() { | |
| 229 OnGroupChanged(0, model_->GroupCount()); | |
| 230 } | |
| 231 | |
| 232 void TaskManagerHandler::OnItemsChanged(const int start, const int length) { | |
| 233 OnGroupChanged(0, model_->GroupCount()); | |
| 234 } | |
| 235 | |
| 236 void TaskManagerHandler::OnItemsAdded(const int start, const int length) { | |
| 237 } | |
| 238 | |
| 239 void TaskManagerHandler::OnItemsRemoved(const int start, const int length) { | |
| 240 } | |
| 241 | |
| 242 void TaskManagerHandler::RegisterMessages() { | |
| 243 web_ui()->RegisterMessageCallback("killProcesses", | |
| 244 base::Bind(&TaskManagerHandler::HandleKillProcesses, | |
| 245 base::Unretained(this))); | |
| 246 web_ui()->RegisterMessageCallback("inspect", | |
| 247 base::Bind(&TaskManagerHandler::HandleInspect, | |
| 248 base::Unretained(this))); | |
| 249 web_ui()->RegisterMessageCallback("activatePage", | |
| 250 base::Bind(&TaskManagerHandler::HandleActivatePage, | |
| 251 base::Unretained(this))); | |
| 252 web_ui()->RegisterMessageCallback("openAboutMemory", | |
| 253 base::Bind(&TaskManagerHandler::OpenAboutMemory, | |
| 254 base::Unretained(this))); | |
| 255 web_ui()->RegisterMessageCallback("enableTaskManager", | |
| 256 base::Bind(&TaskManagerHandler::EnableTaskManager, | |
| 257 base::Unretained(this))); | |
| 258 web_ui()->RegisterMessageCallback("disableTaskManager", | |
| 259 base::Bind(&TaskManagerHandler::DisableTaskManager, | |
| 260 base::Unretained(this))); | |
| 261 web_ui()->RegisterMessageCallback("setUpdateColumn", | |
| 262 base::Bind(&TaskManagerHandler::HandleSetUpdateColumn, | |
| 263 base::Unretained(this))); | |
| 264 } | |
| 265 | |
| 266 static int parseIndex(const Value* value) { | |
| 267 int index = -1; | |
| 268 string16 string16_index; | |
| 269 double double_index; | |
| 270 if (value->GetAsString(&string16_index)) { | |
| 271 bool converted = base::StringToInt(string16_index, &index); | |
| 272 DCHECK(converted); | |
| 273 } else if (value->GetAsDouble(&double_index)) { | |
| 274 index = static_cast<int>(double_index); | |
| 275 } else { | |
| 276 value->GetAsInteger(&index); | |
| 277 } | |
| 278 return index; | |
| 279 } | |
| 280 | |
| 281 void TaskManagerHandler::HandleKillProcesses(const ListValue* unique_ids) { | |
| 282 for (ListValue::const_iterator i = unique_ids->begin(); | |
| 283 i != unique_ids->end(); ++i) { | |
| 284 int unique_id = parseIndex(*i); | |
| 285 int resource_index = model_->GetResourceIndexByUniqueId(unique_id); | |
| 286 if (resource_index == -1) | |
| 287 continue; | |
| 288 | |
| 289 task_manager_->KillProcess(resource_index); | |
| 290 } | |
| 291 } | |
| 292 | |
| 293 void TaskManagerHandler::HandleActivatePage(const ListValue* unique_ids) { | |
| 294 for (ListValue::const_iterator i = unique_ids->begin(); | |
| 295 i != unique_ids->end(); ++i) { | |
| 296 int unique_id = parseIndex(*i); | |
| 297 int resource_index = model_->GetResourceIndexByUniqueId(unique_id); | |
| 298 if (resource_index == -1) | |
| 299 continue; | |
| 300 | |
| 301 task_manager_->ActivateProcess(resource_index); | |
| 302 break; | |
| 303 } | |
| 304 } | |
| 305 | |
| 306 void TaskManagerHandler::HandleInspect(const ListValue* unique_ids) { | |
| 307 for (ListValue::const_iterator i = unique_ids->begin(); | |
| 308 i != unique_ids->end(); ++i) { | |
| 309 int unique_id = parseIndex(*i); | |
| 310 int resource_index = model_->GetResourceIndexByUniqueId(unique_id); | |
| 311 if (resource_index == -1) | |
| 312 continue; | |
| 313 | |
| 314 if (model_->CanInspect(resource_index)) | |
| 315 model_->Inspect(resource_index); | |
| 316 break; | |
| 317 } | |
| 318 } | |
| 319 | |
| 320 void TaskManagerHandler::DisableTaskManager(const ListValue* indexes) { | |
| 321 if (!is_enabled_) | |
| 322 return; | |
| 323 | |
| 324 is_enabled_ = false; | |
| 325 model_->StopUpdating(); | |
| 326 model_->RemoveObserver(this); | |
| 327 } | |
| 328 | |
| 329 void TaskManagerHandler::EnableTaskManager(const ListValue* indexes) { | |
| 330 if (is_enabled_) | |
| 331 return; | |
| 332 | |
| 333 is_enabled_ = true; | |
| 334 | |
| 335 OnGroupChanged(0, model_->GroupCount()); | |
| 336 | |
| 337 model_->AddObserver(this); | |
| 338 model_->StartUpdating(); | |
| 339 | |
| 340 content::NotificationService::current()->Notify( | |
| 341 chrome::NOTIFICATION_TASK_MANAGER_WINDOW_READY, | |
| 342 content::Source<TaskManagerModel>(model_), | |
| 343 content::NotificationService::NoDetails()); | |
| 344 } | |
| 345 | |
| 346 void TaskManagerHandler::OpenAboutMemory(const ListValue* indexes) { | |
| 347 RenderViewHost* rvh = web_ui()->GetWebContents()->GetRenderViewHost(); | |
| 348 if (rvh && rvh->delegate()) { | |
| 349 WebPreferences webkit_prefs = rvh->delegate()->GetWebkitPrefs(); | |
| 350 webkit_prefs.allow_scripts_to_close_windows = true; | |
| 351 rvh->UpdateWebkitPreferences(webkit_prefs); | |
| 352 } else { | |
| 353 DCHECK(false); | |
| 354 } | |
| 355 | |
| 356 task_manager_->OpenAboutMemory(); | |
| 357 } | |
| 358 | |
| 359 void TaskManagerHandler::HandleSetUpdateColumn(const ListValue* args) { | |
| 360 DCHECK_EQ(2U, args->GetSize()); | |
| 361 | |
| 362 bool ret = true; | |
| 363 std::string column_id; | |
| 364 ret &= args->GetString(0, &column_id); | |
| 365 bool is_enabled; | |
| 366 ret &= args->GetBoolean(1, &is_enabled); | |
| 367 DCHECK(ret); | |
| 368 | |
| 369 if (is_enabled) | |
| 370 enabled_columns_.insert(column_id); | |
| 371 else | |
| 372 enabled_columns_.erase(column_id); | |
| 373 } | |
| 374 | |
| 375 // TaskManagerHandler, private: ----------------------------------------------- | |
| 376 | |
| 377 bool TaskManagerHandler::is_alive() { | |
| 378 return web_ui()->GetWebContents()->GetRenderViewHost() != NULL; | |
| 379 } | |
| 380 | |
| 381 void TaskManagerHandler::OnGroupChanged(const int group_start, | |
| 382 const int group_length) { | |
| 383 base::FundamentalValue start_value(group_start); | |
| 384 base::FundamentalValue length_value(group_length); | |
| 385 base::ListValue tasks_value; | |
| 386 | |
| 387 for (int i = 0; i < group_length; ++i) | |
| 388 tasks_value.Append( | |
| 389 CreateTaskGroupValue(model_, group_start + i, enabled_columns_)); | |
| 390 | |
| 391 if (is_enabled_ && is_alive()) { | |
| 392 web_ui()->CallJavascriptFunction("taskChanged", | |
| 393 start_value, length_value, tasks_value); | |
| 394 } | |
| 395 } | |
| 396 | |
| 397 void TaskManagerHandler::OnGroupAdded(const int group_start, | |
| 398 const int group_length) { | |
| 399 } | |
| 400 | |
| 401 void TaskManagerHandler::OnGroupRemoved(const int group_start, | |
| 402 const int group_length) { | |
| 403 } | |
| 404 | |
| 405 void TaskManagerHandler::OnReadyPeriodicalUpdate() { | |
| 406 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 9465014:
Added yoshiki@chromium.org to task-manager related OWNERS files. (Closed)
Base URL: http://git.chromium.org/git/chromium.git@trunk