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