diff options
Diffstat (limited to 'chrome/browser/ui/webui/task_manager')
7 files changed, 826 insertions, 0 deletions
diff --git a/chrome/browser/ui/webui/task_manager/OWNERS b/chrome/browser/ui/webui/task_manager/OWNERS new file mode 100644 index 0000000..407b30d --- /dev/null +++ b/chrome/browser/ui/webui/task_manager/OWNERS @@ -0,0 +1 @@ +yoshiki@chromium.org diff --git a/chrome/browser/ui/webui/task_manager/task_manager_dialog.cc b/chrome/browser/ui/webui/task_manager/task_manager_dialog.cc new file mode 100644 index 0000000..1bbc780 --- /dev/null +++ b/chrome/browser/ui/webui/task_manager/task_manager_dialog.cc @@ -0,0 +1,205 @@ +// Copyright (c) 2012 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/task_manager_dialog.h" + +#include "base/bind.h" +#include "base/command_line.h" +#include "base/memory/singleton.h" +#include "base/utf_string_conversions.h" +#include "chrome/browser/browser_process.h" +#include "chrome/browser/defaults.h" +#include "chrome/browser/platform_util.h" +#include "chrome/browser/prefs/pref_service.h" +#include "chrome/browser/prefs/scoped_user_pref_update.h" +#include "chrome/browser/profiles/profile.h" +#include "chrome/browser/ui/browser.h" +#include "chrome/browser/ui/browser_dialogs.h" +#include "chrome/browser/ui/browser_list.h" +#include "chrome/browser/ui/dialog_style.h" +#include "chrome/browser/ui/webui/html_dialog_ui.h" +#include "chrome/common/chrome_switches.h" +#include "chrome/common/pref_names.h" +#include "chrome/common/url_constants.h" +#include "grit/google_chrome_strings.h" +#include "ui/base/l10n/l10n_util.h" + +#if defined(OS_CHROMEOS) +#include "ui/views/widget/widget.h" +#endif + +using content::BrowserThread; +using content::WebContents; +using content::WebUIMessageHandler; + +class TaskManagerDialogImpl : public HtmlDialogUIDelegate { + public: + TaskManagerDialogImpl(); + + static void Show(bool is_background_page_mode); + static TaskManagerDialogImpl* GetInstance(); + + protected: + friend struct DefaultSingletonTraits<TaskManagerDialogImpl>; + virtual ~TaskManagerDialogImpl(); + + void OnCloseDialog(); + + // Overridden from HtmlDialogUIDelegate: + virtual ui::ModalType GetDialogModalType() const OVERRIDE { + return ui::MODAL_TYPE_NONE; + } + virtual string16 GetDialogTitle() const OVERRIDE { + return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_TITLE); + } + virtual GURL GetDialogContentURL() const OVERRIDE { + std::string url_string(chrome::kChromeUITaskManagerURL); + url_string += "?"; + if (browser_defaults::kShowCancelButtonInTaskManager) + url_string += "showclose=1&"; + if (browser_defaults::kShowHtmlTitleBarInTaskManager) + url_string += "showtitle=1&"; + if (is_background_page_mode_) + url_string += "background=1"; + return GURL(url_string); + } + virtual void GetWebUIMessageHandlers( + std::vector<WebUIMessageHandler*>* handlers) const OVERRIDE { + } + virtual void GetDialogSize(gfx::Size* size) const OVERRIDE { + // If dialog's bounds are previously saved, use them. + if (g_browser_process->local_state()) { + const DictionaryValue* placement_pref = + g_browser_process->local_state()->GetDictionary( + prefs::kTaskManagerWindowPlacement); + int width, height; + if (placement_pref && + placement_pref->GetInteger("width", &width) && + placement_pref->GetInteger("height", &height)) { + size->SetSize(std::max(1, width), std::max(1, height)); + return; + } + } + + // Otherwise set default size. + size->SetSize(640, 480); + } + virtual std::string GetDialogArgs() const OVERRIDE { + return std::string(); + } + virtual void OnDialogClosed(const std::string& json_retval) OVERRIDE { + OnCloseDialog(); + } + virtual void OnCloseContents(WebContents* source, bool* out_close_dialog) + OVERRIDE { + *out_close_dialog = true; + } + virtual bool ShouldShowDialogTitle() const OVERRIDE { + return false; + } + virtual bool HandleContextMenu( + const content::ContextMenuParams& params) OVERRIDE { + return true; + } + virtual void StoreDialogSize(const gfx::Size& dialog_size) OVERRIDE { + // Store the dialog's bounds so that it can be restored with the same bounds + // the next time it's opened. + if (g_browser_process->local_state()) { + DictionaryPrefUpdate update(g_browser_process->local_state(), + prefs::kTaskManagerWindowPlacement); + DictionaryValue* placement_pref = update.Get(); + placement_pref->SetInteger("width", dialog_size.width()); + placement_pref->SetInteger("height", dialog_size.height()); + } + } + + private: + void ShowDialog(bool is_background_page_mode); + void OpenHtmlDialog(); + + int show_count_; + + gfx::NativeWindow window_; + bool is_background_page_mode_; + + DISALLOW_COPY_AND_ASSIGN(TaskManagerDialogImpl); +}; + +// **************************************************** + +// static +TaskManagerDialogImpl* TaskManagerDialogImpl::GetInstance() { + DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO)); + DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::FILE)); + return Singleton<TaskManagerDialogImpl>::get(); +} + +TaskManagerDialogImpl::TaskManagerDialogImpl() + : show_count_(0), + window_(NULL), + is_background_page_mode_(false) { +} + +TaskManagerDialogImpl::~TaskManagerDialogImpl() { +} + +// static +void TaskManagerDialogImpl::Show(bool is_background_page_mode) { + DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); + TaskManagerDialogImpl* dialog = TaskManagerDialogImpl::GetInstance(); + dialog->ShowDialog(is_background_page_mode); +} + +void TaskManagerDialogImpl::ShowDialog(bool is_background_page_mode) { + if (show_count_ > 0) { +#if defined(OS_CHROMEOS) + // Closes current TaskManager and Opens new one. + views::Widget::GetWidgetForNativeWindow(window_)->Close(); +#else + // TODO(yoshiki): Supports the other platforms. + platform_util::ActivateWindow(window_); + return; +#endif + } + is_background_page_mode_ = is_background_page_mode; + OpenHtmlDialog(); + ++show_count_; +} + +void TaskManagerDialogImpl::OnCloseDialog() { + if (show_count_ > 0) + --show_count_; +} + +void TaskManagerDialogImpl::OpenHtmlDialog() { + Browser* browser = BrowserList::GetLastActive(); + DCHECK(browser); + window_ = browser::ShowHtmlDialog(NULL, + browser->profile()->GetOriginalProfile(), + NULL, + this, + STYLE_GENERIC); +} + +// **************************************************** +// +// static +void TaskManagerDialog::Show() { + BrowserThread::PostTask( + BrowserThread::UI, FROM_HERE, + base::Bind(&TaskManagerDialogImpl::Show, false)); +} + +// static +void TaskManagerDialog::ShowBackgroundPages() { + BrowserThread::PostTask( + BrowserThread::UI, FROM_HERE, + base::Bind(&TaskManagerDialogImpl::Show, true)); +} + +// static +bool TaskManagerDialog::UseWebUITaskManager() { + return CommandLine::ForCurrentProcess()->HasSwitch( + switches::kWebUITaskManager); +} diff --git a/chrome/browser/ui/webui/task_manager/task_manager_dialog.h b/chrome/browser/ui/webui/task_manager/task_manager_dialog.h new file mode 100644 index 0000000..a02df59 --- /dev/null +++ b/chrome/browser/ui/webui/task_manager/task_manager_dialog.h @@ -0,0 +1,20 @@ +// Copyright (c) 2012 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. + +#ifndef CHROME_BROWSER_UI_WEBUI_TASK_MANAGER_TASK_MANAGER_DIALOG_H_ +#define CHROME_BROWSER_UI_WEBUI_TASK_MANAGER_TASK_MANAGER_DIALOG_H_ +#pragma once + +class TaskManagerDialog { + public: + static void Show(); + static void ShowBackgroundPages(); + + // Returns true if the flag for the experimental WebUI task manager is + // enabled. + static bool UseWebUITaskManager(); +}; + +#endif // CHROME_BROWSER_UI_WEBUI_TASK_MANAGER_TASK_MANAGER_DIALOG_H_ + diff --git a/chrome/browser/ui/webui/task_manager/task_manager_handler.cc b/chrome/browser/ui/webui/task_manager/task_manager_handler.cc new file mode 100644 index 0000000..efac8f5 --- /dev/null +++ b/chrome/browser/ui/webui/task_manager/task_manager_handler.cc @@ -0,0 +1,406 @@ +// Copyright (c) 2012 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/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/public/browser/notification_service.h" +#include "content/public/browser/notification_source.h" +#include "content/public/browser/render_view_host_delegate.h" +#include "content/public/browser/web_contents.h" +#include "content/public/browser/web_ui.h" +#include "third_party/skia/include/core/SkBitmap.h" +#include "webkit/glue/webpreferences.h" + +namespace { + +Value* CreateColumnValue(const TaskManagerModel* tm, + const std::string& column_name, + const int i) { + if (column_name == "uniqueId") + return Value::CreateIntegerValue(tm->GetResourceUniqueId(i)); + if (column_name == "type") + return Value::CreateStringValue( + TaskManager::Resource::GetResourceTypeAsString( + tm->GetResourceType(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)); + if (column_name == "privateMemoryValue") { + size_t private_memory; + tm->GetPrivateMemory(i, &private_memory); + return Value::CreateDoubleValue(private_memory); + } + if (column_name == "sharedMemory") + return Value::CreateStringValue(tm->GetResourceSharedMemory(i)); + if (column_name == "sharedMemoryValue") { + size_t shared_memory; + tm->GetSharedMemory(i, &shared_memory); + return Value::CreateDoubleValue(shared_memory); + } + if (column_name == "physicalMemory") + return Value::CreateStringValue(tm->GetResourcePhysicalMemory(i)); + if (column_name == "physicalMemoryValue") { + size_t physical_memory; + tm->GetPhysicalMemory(i, &physical_memory); + return Value::CreateDoubleValue(physical_memory); + } + if (column_name == "icon") + return Value::CreateStringValue( + web_ui_util::GetImageDataUrl(tm->GetResourceIcon(i))); + if (column_name == "title") + return Value::CreateStringValue(tm->GetResourceTitle(i)); + if (column_name == "profileName") + return Value::CreateStringValue(tm->GetResourceProfileName(i)); + if (column_name == "networkUsage") + return Value::CreateStringValue(tm->GetResourceNetworkUsage(i)); + if (column_name == "networkUsageValue") + return Value::CreateDoubleValue(tm->GetNetworkUsage(i)); + if (column_name == "webCoreImageCacheSize") + return Value::CreateStringValue(tm->GetResourceWebCoreImageCacheSize(i)); + if (column_name == "webCoreImageCacheSizeValue") { + WebKit::WebCache::ResourceTypeStats resource_stats; + tm->GetWebCoreCacheStats(i, &resource_stats); + return Value::CreateDoubleValue(resource_stats.images.size); + } + if (column_name == "webCoreScriptsCacheSize") + return Value::CreateStringValue(tm->GetResourceWebCoreScriptsCacheSize(i)); + if (column_name == "webCoreScriptsCacheSizeValue") { + WebKit::WebCache::ResourceTypeStats resource_stats; + tm->GetWebCoreCacheStats(i, &resource_stats); + return Value::CreateDoubleValue(resource_stats.scripts.size); + } + if (column_name == "webCoreCSSCacheSize") + return Value::CreateStringValue(tm->GetResourceWebCoreCSSCacheSize(i)); + if (column_name == "webCoreCSSCacheSizeValue") { + WebKit::WebCache::ResourceTypeStats resource_stats; + tm->GetWebCoreCacheStats(i, &resource_stats); + return Value::CreateDoubleValue(resource_stats.cssStyleSheets.size); + } + if (column_name == "fps") + return Value::CreateStringValue(tm->GetResourceFPS(i)); + if (column_name == "fpsValue") { + float fps; + tm->GetFPS(i, &fps); + return Value::CreateDoubleValue(fps); + } + if (column_name == "sqliteMemoryUsed") + return Value::CreateStringValue(tm->GetResourceSqliteMemoryUsed(i)); + if (column_name == "sqliteMemoryUsedValue") { + size_t sqlite_memory; + tm->GetSqliteMemoryUsedBytes(i, &sqlite_memory); + return Value::CreateDoubleValue(sqlite_memory); + } + if (column_name == "goatsTeleported") + 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)); + if (column_name == "canActivate") + return Value::CreateBooleanValue(tm->CanActivate(i)); + + NOTREACHED(); + return NULL; +} + +void CreateGroupColumnList(const TaskManagerModel* tm, + const std::string& column_name, + const int index, + const int length, + DictionaryValue* val) { + ListValue* list = new ListValue(); + for (int i = index; i < (index + length); ++i) { + list->Append(CreateColumnValue(tm, column_name, i)); + } + val->Set(column_name, list); +} + +struct ColumnType { + const char* column_id; + // Whether the column has the real value separately or not, instead of the + // formatted value to display. + const bool has_real_value; + // Whether the column has single datum or multiple data in each group. + const bool has_multiple_data; +}; + +const ColumnType kColumnsList[] = { + {"type", false, false}, + {"processId", true, false}, + {"cpuUsage", true, false}, + {"physicalMemory", true, false}, + {"sharedMemory", true, false}, + {"privateMemory", true, false}, + {"webCoreImageCacheSize", true, false}, + {"webCoreImageCacheSize", true, false}, + {"webCoreScriptsCacheSize", true, false}, + {"webCoreCSSCacheSize", true, false}, + {"sqliteMemoryUsed", true, false}, + {"v8MemoryAllocatedSize", true, false}, + {"icon", false, true}, + {"title", false, true}, + {"profileName", false, true}, + {"networkUsage", true, true}, + {"fps", true, true}, + {"goatsTeleported", true, true}, + {"canInspect", false, true}, + {"canActivate", false, true} +}; + +DictionaryValue* CreateTaskGroupValue( + const TaskManagerModel* tm, + const int group_index, + const std::set<std::string>& columns) { + DictionaryValue* val = new DictionaryValue(); + + const int group_count = tm->GroupCount(); + if (group_index >= group_count) + return val; + + int index = tm->GetResourceIndexForGroup(group_index, 0); + int length = tm->GetGroupRangeForResource(index).second; + + // Forces to set following 3 columns regardless of |enable_columns|. + val->SetInteger("index", index); + val->SetBoolean("isBackgroundResource", + tm->IsBackgroundResource(index)); + CreateGroupColumnList(tm, "processId", index, 1, val); + CreateGroupColumnList(tm, "type", index, length, val); + CreateGroupColumnList(tm, "uniqueId", index, length, val); + + for (size_t i = 0; i < arraysize(kColumnsList); ++i) { + const std::string column_id = kColumnsList[i].column_id; + + if (columns.find(column_id) == columns.end()) + continue; + + int column_length = kColumnsList[i].has_multiple_data ? length : 1; + CreateGroupColumnList(tm, column_id, index, column_length, val); + + if (kColumnsList[i].has_real_value) + CreateGroupColumnList(tm, column_id + "Value", index, column_length, val); + } + + return val; +} + +} // namespace + +TaskManagerHandler::TaskManagerHandler(TaskManager* tm) + : task_manager_(tm), + model_(tm->model()), + is_enabled_(false) { +} + +TaskManagerHandler::~TaskManagerHandler() { + DisableTaskManager(NULL); +} + +// TaskManagerHandler, public: ----------------------------------------------- + +void TaskManagerHandler::OnModelChanged() { + OnGroupChanged(0, model_->GroupCount()); +} + +void TaskManagerHandler::OnItemsChanged(const int start, const int length) { + OnGroupChanged(0, model_->GroupCount()); +} + +void TaskManagerHandler::OnItemsAdded(const int start, const int length) { +} + +void TaskManagerHandler::OnItemsRemoved(const int start, const int length) { +} + +void TaskManagerHandler::RegisterMessages() { + 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))); + web_ui()->RegisterMessageCallback("enableTaskManager", + base::Bind(&TaskManagerHandler::EnableTaskManager, + base::Unretained(this))); + web_ui()->RegisterMessageCallback("disableTaskManager", + base::Bind(&TaskManagerHandler::DisableTaskManager, + base::Unretained(this))); + web_ui()->RegisterMessageCallback("setUpdateColumn", + base::Bind(&TaskManagerHandler::HandleSetUpdateColumn, + base::Unretained(this))); +} + +static int parseIndex(const Value* value) { + int index = -1; + string16 string16_index; + double double_index; + if (value->GetAsString(&string16_index)) { + bool converted = base::StringToInt(string16_index, &index); + DCHECK(converted); + } else if (value->GetAsDouble(&double_index)) { + index = static_cast<int>(double_index); + } else { + value->GetAsInteger(&index); + } + return index; +} + +void TaskManagerHandler::HandleKillProcesses(const ListValue* unique_ids) { + for (ListValue::const_iterator i = unique_ids->begin(); + i != unique_ids->end(); ++i) { + int unique_id = parseIndex(*i); + int resource_index = model_->GetResourceIndexByUniqueId(unique_id); + if (resource_index == -1) + continue; + + task_manager_->KillProcess(resource_index); + } +} + +void TaskManagerHandler::HandleActivatePage(const ListValue* unique_ids) { + for (ListValue::const_iterator i = unique_ids->begin(); + i != unique_ids->end(); ++i) { + int unique_id = parseIndex(*i); + int resource_index = model_->GetResourceIndexByUniqueId(unique_id); + if (resource_index == -1) + continue; + + task_manager_->ActivateProcess(resource_index); + break; + } +} + +void TaskManagerHandler::HandleInspect(const ListValue* unique_ids) { + for (ListValue::const_iterator i = unique_ids->begin(); + i != unique_ids->end(); ++i) { + int unique_id = parseIndex(*i); + int resource_index = model_->GetResourceIndexByUniqueId(unique_id); + 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) { + if (is_enabled_) + return; + + is_enabled_ = true; + + OnGroupChanged(0, model_->GroupCount()); + + model_->AddObserver(this); + model_->StartUpdating(); + + content::NotificationService::current()->Notify( + chrome::NOTIFICATION_TASK_MANAGER_WINDOW_READY, + content::Source<TaskManagerModel>(model_), + content::NotificationService::NoDetails()); +} + +void TaskManagerHandler::OpenAboutMemory(const ListValue* indexes) { + RenderViewHost* rvh = web_ui()->GetWebContents()->GetRenderViewHost(); + if (rvh && rvh->GetDelegate()) { + WebPreferences webkit_prefs = rvh->GetDelegate()->GetWebkitPrefs(); + webkit_prefs.allow_scripts_to_close_windows = true; + rvh->UpdateWebkitPreferences(webkit_prefs); + } else { + DCHECK(false); + } + + task_manager_->OpenAboutMemory(); +} + +void TaskManagerHandler::HandleSetUpdateColumn(const ListValue* args) { + DCHECK_EQ(2U, args->GetSize()); + + bool ret = true; + std::string column_id; + ret &= args->GetString(0, &column_id); + bool is_enabled; + ret &= args->GetBoolean(1, &is_enabled); + DCHECK(ret); + + if (is_enabled) + enabled_columns_.insert(column_id); + else + enabled_columns_.erase(column_id); +} + +// TaskManagerHandler, private: ----------------------------------------------- + +bool TaskManagerHandler::is_alive() { + return web_ui()->GetWebContents()->GetRenderViewHost() != NULL; +} + +void TaskManagerHandler::OnGroupChanged(const int group_start, + const int group_length) { + base::FundamentalValue start_value(group_start); + base::FundamentalValue length_value(group_length); + base::ListValue tasks_value; + + for (int i = 0; i < group_length; ++i) + tasks_value.Append( + CreateTaskGroupValue(model_, group_start + i, enabled_columns_)); + + if (is_enabled_ && is_alive()) { + web_ui()->CallJavascriptFunction("taskChanged", + start_value, length_value, tasks_value); + } +} + +void TaskManagerHandler::OnGroupAdded(const int group_start, + const int group_length) { +} + +void TaskManagerHandler::OnGroupRemoved(const int group_start, + const int group_length) { +} + +void TaskManagerHandler::OnReadyPeriodicalUpdate() { +} diff --git a/chrome/browser/ui/webui/task_manager/task_manager_handler.h b/chrome/browser/ui/webui/task_manager/task_manager_handler.h new file mode 100644 index 0000000..9ab0b58 --- /dev/null +++ b/chrome/browser/ui/webui/task_manager/task_manager_handler.h @@ -0,0 +1,80 @@ +// Copyright (c) 2012 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. + +#ifndef CHROME_BROWSER_UI_WEBUI_TASK_MANAGER_TASK_MANAGER_HANDLER_H_ +#define CHROME_BROWSER_UI_WEBUI_TASK_MANAGER_TASK_MANAGER_HANDLER_H_ +#pragma once + +#include <set> +#include <string> +#include <vector> + +#include "content/public/browser/web_ui_message_handler.h" +#include "chrome/browser/task_manager/task_manager.h" + +namespace base { +class ListValue; +} + +class TaskManagerHandler : public content::WebUIMessageHandler, + public TaskManagerModelObserver { + public: + explicit TaskManagerHandler(TaskManager* tm); + virtual ~TaskManagerHandler(); + + // TaskManagerModelObserver implementation. + // Invoked when the model has been completely changed. + virtual void OnModelChanged() OVERRIDE; + // Invoked when a range of items has changed. + virtual void OnItemsChanged(int start, int length) OVERRIDE; + // Invoked when new items are added. + virtual void OnItemsAdded(int start, int length) OVERRIDE; + // Invoked when a range of items has been removed. + virtual void OnItemsRemoved(int start, int length) OVERRIDE; + + // Invoked when the initialization of the model has been finished and + // periodic updates is started. + virtual void OnReadyPeriodicalUpdate() OVERRIDE; + + // WebUIMessageHandler implementation. + virtual void RegisterMessages() OVERRIDE; + + // Callback for the "killProcesses" message. + void HandleKillProcesses(const base::ListValue* indexes); + + // Callback for the "activatePage" message. + void HandleActivatePage(const base::ListValue* resource_index); + + // Callback for the "inspect" message. + void HandleInspect(const base::ListValue* resource_index); + + void EnableTaskManager(const base::ListValue* indexes); + void DisableTaskManager(const base::ListValue* indexes); + void OpenAboutMemory(const base::ListValue* indexes); + + // Callback for the "setUpdateColumn" message. + void HandleSetUpdateColumn(const base::ListValue* args); + + private: + bool is_alive(); + + // Models + TaskManager* task_manager_; + TaskManagerModel* model_; + + bool is_enabled_; + + // Set to store the enabled columns. + std::set<std::string> enabled_columns_; + + // Invoked when group(s) are added/changed/removed. + // These method are called from OnItemAdded/-Changed/-Removed internally. + void OnGroupAdded(int start, int length); + void OnGroupChanged(int start, int length); + void OnGroupRemoved(int start, int length); + + DISALLOW_COPY_AND_ASSIGN(TaskManagerHandler); +}; + +#endif // CHROME_BROWSER_UI_WEBUI_TASK_MANAGER_TASK_MANAGER_HANDLER_H_ diff --git a/chrome/browser/ui/webui/task_manager/task_manager_ui.cc b/chrome/browser/ui/webui/task_manager/task_manager_ui.cc new file mode 100644 index 0000000..e5405dd --- /dev/null +++ b/chrome/browser/ui/webui/task_manager/task_manager_ui.cc @@ -0,0 +1,95 @@ +// Copyright (c) 2012 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/task_manager_ui.h" + +#include "base/values.h" +#include "chrome/browser/profiles/profile.h" +#include "chrome/browser/task_manager/task_manager.h" +#include "chrome/browser/ui/webui/chrome_url_data_manager.h" +#include "chrome/browser/ui/webui/chrome_web_ui_data_source.h" +#include "chrome/browser/ui/webui/task_manager/task_manager_handler.h" +#include "chrome/common/url_constants.h" +#include "content/public/browser/web_contents.h" +#include "content/public/browser/web_ui.h" +#include "grit/browser_resources.h" +#include "grit/generated_resources.h" +#include "grit/chromium_strings.h" +#include "grit/theme_resources.h" +#include "ui/base/l10n/l10n_util.h" +#include "ui/base/resource/resource_bundle.h" + +using content::WebContents; + +namespace { + +ChromeWebUIDataSource* CreateTaskManagerUIHTMLSource() { + ChromeWebUIDataSource* source = + new ChromeWebUIDataSource(chrome::kChromeUITaskManagerHost); + + source->AddLocalizedString("closeWindow", IDS_CLOSE); + source->AddLocalizedString("title",IDS_TASK_MANAGER_TITLE); + source->AddLocalizedString("aboutMemoryLink", + IDS_TASK_MANAGER_ABOUT_MEMORY_LINK); + source->AddLocalizedString("killChromeOS", IDS_TASK_MANAGER_KILL_CHROMEOS); + source->AddLocalizedString("processIDColumn", + IDS_TASK_MANAGER_PROCESS_ID_COLUMN); + source->AddLocalizedString("pageColumn", IDS_TASK_MANAGER_PAGE_COLUMN); + source->AddLocalizedString("profileNameColumn", + IDS_TASK_MANAGER_PROFILE_NAME_COLUMN); + source->AddLocalizedString("netColumn", IDS_TASK_MANAGER_NET_COLUMN); + source->AddLocalizedString("cpuColumn", IDS_TASK_MANAGER_CPU_COLUMN); + source->AddLocalizedString("physicalMemColumn", + IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN); + source->AddLocalizedString("sharedMemColumn", + IDS_TASK_MANAGER_SHARED_MEM_COLUMN); + source->AddLocalizedString("privateMemColumn", + IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN); + source->AddLocalizedString("goatsTeleportedColumn", + IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN); + source->AddLocalizedString("webcoreImageCacheColumn", + IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN); + source->AddLocalizedString("webcoreScriptsCacheColumn", + IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN); + source->AddLocalizedString("webcoreCSSCacheColumn", + IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN); + source->AddLocalizedString("fpsColumn",IDS_TASK_MANAGER_FPS_COLUMN); + source->AddLocalizedString("sqliteMemoryUsedColumn", + IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN); + source->AddLocalizedString( + "javascriptMemoryAllocatedColumn", + IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN); + source->AddLocalizedString("inspect", IDS_TASK_MANAGER_INSPECT); + source->AddLocalizedString("activate", IDS_TASK_MANAGER_ACTIVATE); + source->set_json_path("strings.js"); + source->add_resource_path("main.js", IDR_TASK_MANAGER_JS); + source->add_resource_path("commands.js", IDR_TASK_MANAGER_COMMANDS_JS); + source->add_resource_path("defines.js", IDR_TASK_MANAGER_DEFINES_JS); + source->add_resource_path("includes.js", IDR_TASK_MANAGER_INCLUDES_JS); + source->add_resource_path("preload.js", IDR_TASK_MANAGER_PRELOAD_JS); + source->add_resource_path("measure_time.js", + IDR_TASK_MANAGER_MEASURE_TIME_JS); + source->add_resource_path("measure_time_end.js", + IDR_TASK_MANAGER_MEASURE_TIME_END_JS); + source->set_default_resource(IDR_TASK_MANAGER_HTML); + + return source; +} + +} // namespace + +/////////////////////////////////////////////////////////////////////////////// +// +// TaskManagerUI +// +/////////////////////////////////////////////////////////////////////////////// + +TaskManagerUI::TaskManagerUI(content::WebUI* web_ui) : WebUIController(web_ui) { + web_ui->AddMessageHandler(new TaskManagerHandler(TaskManager::GetInstance())); + + // Set up the chrome://taskmanager/ source. + ChromeWebUIDataSource* html_source = CreateTaskManagerUIHTMLSource(); + Profile* profile = Profile::FromWebUI(web_ui); + profile->GetChromeURLDataManager()->AddDataSource(html_source); +} diff --git a/chrome/browser/ui/webui/task_manager/task_manager_ui.h b/chrome/browser/ui/webui/task_manager/task_manager_ui.h new file mode 100644 index 0000000..272704b --- /dev/null +++ b/chrome/browser/ui/webui/task_manager/task_manager_ui.h @@ -0,0 +1,19 @@ +// Copyright (c) 2012 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. + +#ifndef CHROME_BROWSER_UI_WEBUI_TASK_MANAGER_TASK_MANAGER_UI_H_ +#define CHROME_BROWSER_UI_WEBUI_TASK_MANAGER_TASK_MANAGER_UI_H_ +#pragma once + +#include "content/public/browser/web_ui_controller.h" + +class TaskManagerUI : public content::WebUIController { + public: + explicit TaskManagerUI(content::WebUI* web_ui); + + private: + DISALLOW_COPY_AND_ASSIGN(TaskManagerUI); +}; + +#endif // CHROME_BROWSER_UI_WEBUI_TASK_MANAGER_TASK_MANAGER_UI_H_ |