Reorganize the way the task manager is constructed....

chrome/browser/views/task_manager_view.cc

 // Copyright (c) 2009 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/task_manager.h"
 
 #include "app/l10n_util.h"
 #include "app/table_model_observer.h"
 #include "base/stats_table.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_window.h"
+#include "chrome/browser/views/browser_dialogs.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/accelerator.h"
 #include "views/background.h"
 #include "views/controls/button/native_button.h"
 #include "views/controls/link.h"
 #include "views/controls/menu/menu.h"
@@ skipping 127 matching lines @@
 void TaskManagerTableModel::OnItemsAdded(int start, int length) {
   if (observer_)
     observer_->OnItemsAdded(start, length);
 }
 
 void TaskManagerTableModel::OnItemsRemoved(int start, int length) {
   if (observer_)
     observer_->OnItemsRemoved(start, length);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// TaskManagerViewImpl class
-//
-// The view containing the different widgets.
-//
-////////////////////////////////////////////////////////////////////////////////
+// The Task manager UI container.
+class TaskManagerView : public views::View,
+                        public views::ButtonListener,
+                        public views::DialogDelegate,
+                        public views::TableViewObserver,
+                        public views::LinkController,
+                        public views::ContextMenuController,
+                        public views::Menu::Delegate {
+ public:
+  TaskManagerView();
+  virtual ~TaskManagerView();
 
-class TaskManagerViewImpl : public TaskManagerView,
-                            public views::View,
-                            public views::ButtonListener,
-                            public views::DialogDelegate,
-                            public views::TableViewObserver,
-                            public views::LinkController,
-                            public views::ContextMenuController,
-                            public views::Menu::Delegate {
- public:
-  TaskManagerViewImpl(TaskManager* task_manager,
-                      TaskManagerModel* model);
-  virtual ~TaskManagerViewImpl();
+  // Shows the Task manager window, or re-activates an existing one.
+  static void Show();
 
-  void Init();
+  // views::View
   virtual void Layout();
   virtual gfx::Size GetPreferredSize();
   virtual void ViewHierarchyChanged(bool is_add, views::View* parent,
                                     views::View* child);
 
-  // TaskManagerView
-  virtual void GetSelection(std::vector<int>* selection);
-  virtual void GetFocused(std::vector<int>* focused);
-  virtual void OpenWindow();
-  virtual void ActivateWindow();
-  virtual void CloseWindow();
-
   // ButtonListener implementation.
   virtual void ButtonPressed(views::Button* sender);
 
   // views::DialogDelegate
   virtual bool CanResize() const;
   virtual bool CanMaximize() const;
   virtual bool ExecuteWindowsCommand(int command_id);
   virtual std::wstring GetWindowTitle() const;
   virtual std::wstring GetWindowName() const;
   virtual int GetDialogButtons() const;
@@ skipping 15 matching lines @@
 
   // Menu::Delegate
   virtual void ShowContextMenu(views::View* source,
                                int x,
                                int y,
                                bool is_mouse_gesture);
   virtual bool IsItemChecked(int id) const;
   virtual void ExecuteCommand(int id);
 
  private:
+  // Creates the child controls.
+  void Init();
+
   // Initializes the state of the always-on-top setting as the window is shown.
   void InitAlwaysOnTopState();
 
+  // Activates the tab associated with the focused row.
+  void ActivateFocusedTab();
+
   // Adds an always on top item to the window's system menu.
   void AddAlwaysOnTopSystemMenuItem();
 
   // Restores saved always on top state from a previous session.
   bool GetSavedAlwaysOnTopState(bool* always_on_top) const;
 
   views::NativeButton* kill_button_;
   views::Link* about_memory_link_;
   views::GroupTableView* tab_table_;
 
   TaskManager* task_manager_;
 
   TaskManagerModel* model_;
 
   // all possible columns, not necessarily visible
   std::vector<TableColumn> columns_;
 
   scoped_ptr<TaskManagerTableModel> table_model_;
 
   // True when the Task Manager window should be shown on top of other windows.
   bool is_always_on_top_;
 
   // We need to own the text of the menu, the Windows API does not copy it.
   std::wstring always_on_top_menu_text_;
 
-  DISALLOW_COPY_AND_ASSIGN(TaskManagerViewImpl);
+  // An open Task manager window. There can only be one open at a time. This
+  // is reset to NULL when the window is closed.
+  static TaskManagerView* instance_;
+
+  DISALLOW_COPY_AND_ASSIGN(TaskManagerView);
 };
 
-TaskManagerViewImpl::TaskManagerViewImpl(TaskManager* task_manager,
-                                         TaskManagerModel* model)
-    : task_manager_(task_manager),
-      model_(model),
+// static
+TaskManagerView* TaskManagerView::instance_ = NULL;
+
+
+TaskManagerView::TaskManagerView()
+    : task_manager_(TaskManager::GetInstance()),
+      model_(TaskManager::GetInstance()->model()),
       is_always_on_top_(false) {
   Init();
 }
 
-TaskManagerViewImpl::~TaskManagerViewImpl() {
+TaskManagerView::~TaskManagerView() {
   // Delete child views now, while our table model still exists.
   RemoveAllChildViews(true);
 
   // Prevent the table from accessing the model as part of its destruction, as
   // the model might already be destroyed.
   tab_table_->SetModel(NULL);
 }
 
-void TaskManagerViewImpl::Init() {
+void TaskManagerView::Init() {
   table_model_.reset(new TaskManagerTableModel(model_));
 
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_PAGE_COLUMN,
                                  TableColumn::LEFT, -1, 1));
   columns_.back().sortable = true;
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN,
                                  TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_SHARED_MEM_COLUMN,
                                  TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN,
                                  TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_CPU_COLUMN,
                                  TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_NET_COLUMN,
                                  TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_PROCESS_ID_COLUMN,
                                  TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
 
   tab_table_ = new views::GroupTableView(table_model_.get(), columns_,
                                          views::ICON_AND_TEXT, false, true,
                                          true);
-  tab_table_->SetParentOwned(false);
 
   // Hide some columns by default
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_PROCESS_ID_COLUMN, false);
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_SHARED_MEM_COLUMN, false);
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN, false);
 
   UpdateStatsCounters();
   TableColumn col(kGoatsTeleportedColumn, L"Goats Teleported",
                   TableColumn::RIGHT, -1, 0);
   col.sortable = true;
   columns_.push_back(col);
   tab_table_->AddColumn(col);
   tab_table_->SetObserver(this);
   SetContextMenuController(this);
   kill_button_ = new views::NativeButton(
       this, l10n_util::GetString(IDS_TASK_MANAGER_KILL));
   kill_button_->AddAccelerator(views::Accelerator('E', false, false, false));
   kill_button_->SetAccessibleKeyboardShortcut(L"E");
   about_memory_link_ = new views::Link(
       l10n_util::GetString(IDS_TASK_MANAGER_ABOUT_MEMORY_LINK));
   about_memory_link_->SetController(this);
 
   // Makes sure our state is consistent.
   OnSelectionChanged();
 }
 
-void TaskManagerViewImpl::UpdateStatsCounters() {
+void TaskManagerView::UpdateStatsCounters() {
   StatsTable* stats = StatsTable::current();
   if (stats != NULL) {
     int max = stats->GetMaxCounters();
     // skip the first row (it's header data)
     for (int i = 1; i < max; i++) {
       const char* row = stats->GetRowName(i);
       if (row != NULL && row[0] != '\0' && !tab_table_->HasColumn(i)) {
         // TODO(erikkay): Use l10n to get display names for stats.  Right
         // now we're just displaying the internal counter name.  Perhaps
         // stat names not in the string table would be filtered out.
         // TODO(erikkay): Width is hard-coded right now, so many column
         // names are clipped.
         TableColumn col(i, ASCIIToWide(row), TableColumn::RIGHT, 90, 0);
         col.sortable = true;
         columns_.push_back(col);
         tab_table_->AddColumn(col);
       }
     }
   }
 }
 
-void TaskManagerViewImpl::ViewHierarchyChanged(bool is_add,
-                                               views::View* parent,
-                                               views::View* child) {
+void TaskManagerView::ViewHierarchyChanged(bool is_add,
+                                           views::View* parent,
+                                           views::View* child) {
   // Since we want the Kill button and the Memory Details link to show up in
   // the same visual row as the close button, which is provided by the
   // framework, we must add the buttons to the non-client view, which is the
   // parent of this view. Similarly, when we're removed from the view
   // hierarchy, we must take care to clean up those items as well.
   if (child == this) {
     if (is_add) {
       parent->AddChildView(kill_button_);
       parent->AddChildView(about_memory_link_);
       AddChildView(tab_table_);
     } else {
       parent->RemoveChildView(kill_button_);
       parent->RemoveChildView(about_memory_link_);
     }
   }
 }
 
-void TaskManagerViewImpl::Layout() {
+void TaskManagerView::Layout() {
   // kPanelHorizMargin is too big.
   const int kTableButtonSpacing = 12;
 
   gfx::Size size = kill_button_->GetPreferredSize();
   int prefered_width = size.width();
   int prefered_height = size.height();
 
   tab_table_->SetBounds(x() + kPanelHorizMargin,
                         y() + kPanelVertMargin,
                         width() - 2 * kPanelHorizMargin,
@@ skipping 14 matching lines @@
   // center between the two buttons horizontally, and line up with
   // bottom of buttons vertically.
   int link_y_offset = std::max(0, prefered_height - link_prefered_height) / 2;
   about_memory_link_->SetBounds(
       x() + kPanelHorizMargin,
       y_buttons + prefered_height - link_prefered_height - link_y_offset,
       link_prefered_width,
       link_prefered_height);
 }
 
-gfx::Size TaskManagerViewImpl::GetPreferredSize() {
+gfx::Size TaskManagerView::GetPreferredSize() {
   return gfx::Size(kDefaultWidth, kDefaultHeight);
 }
 
-void TaskManagerViewImpl::GetSelection(std::vector<int>* selection) {
-  DCHECK(selection);
-  for (views::TableSelectionIterator iter  = tab_table_->SelectionBegin();
-       iter != tab_table_->SelectionEnd(); ++iter) {
-    // The TableView returns the selection starting from the end.
-    selection->insert(selection->begin(), *iter);
+// static
+void TaskManagerView::Show() {
+  if (instance_) {
+    // If there's a Task manager window open already, just activate it.
+    instance_->window()->Activate();
+  } else {
+    instance_ = new TaskManagerView;
+    views::Window::CreateChromeWindow(NULL, gfx::Rect(), instance_);
+    instance_->InitAlwaysOnTopState();
+    instance_->model_->StartUpdating();
+    instance_->window()->Show();
   }
 }
 
-void TaskManagerViewImpl::GetFocused(std::vector<int>* focused) {
-  DCHECK(focused);
-  int row_count = tab_table_->RowCount();
-  for (int i = 0; i < row_count; ++i) {
-    // The TableView returns the selection starting from the end.
-    if (tab_table_->ItemHasTheFocus(i))
-      focused->insert(focused->begin(), i);
+// ButtonListener implementation.
+void TaskManagerView::ButtonPressed(views::Button* sender) {
+  DCHECK(sender == kill_button_);
+  for (views::TableSelectionIterator iter  = tab_table_->SelectionBegin();
+       iter != tab_table_->SelectionEnd(); ++iter) {
+    task_manager_->KillProcess(*iter);
   }
 }
 
-void TaskManagerViewImpl::OpenWindow() {
-  DCHECK(!window());
-  views::Window::CreateChromeWindow(NULL, gfx::Rect(), this);
-  InitAlwaysOnTopState();
-  model_->StartUpdating();
-  window()->Show();
-}
-
-void TaskManagerViewImpl::ActivateWindow() {
-  DCHECK(window());
-  window()->Activate();
-}
-
-void TaskManagerViewImpl::CloseWindow() {
-  if (!window())
-    return;
-  // TODO(phajdan.jr): Destroy the window, not just hide it.
-  window()->HideWindow();
-}
-
-// ButtonListener implementation.
-void TaskManagerViewImpl::ButtonPressed(views::Button* sender) {
-  if (sender == kill_button_)
-    task_manager_->KillSelectedProcesses();
-}
-
 // DialogDelegate implementation.
-bool TaskManagerViewImpl::CanResize() const {
+bool TaskManagerView::CanResize() const {
   return true;
 }
 
-bool TaskManagerViewImpl::CanMaximize() const {
+bool TaskManagerView::CanMaximize() const {
   return true;
 }
 
-bool TaskManagerViewImpl::ExecuteWindowsCommand(int command_id) {
+bool TaskManagerView::ExecuteWindowsCommand(int command_id) {
   if (command_id == IDC_ALWAYS_ON_TOP) {
     is_always_on_top_ = !is_always_on_top_;
 
     // Change the menu check state.
     HMENU system_menu = GetSystemMenu(GetWindow()->GetNativeWindow(), FALSE);
     MENUITEMINFO menu_info;
     memset(&menu_info, 0, sizeof(MENUITEMINFO));
     menu_info.cbSize = sizeof(MENUITEMINFO);
     BOOL r = GetMenuItemInfo(system_menu, IDC_ALWAYS_ON_TOP,
                              FALSE, &menu_info);
@@ skipping 11 matching lines @@
       DictionaryValue* window_preferences =
           g_browser_process->local_state()->GetMutableDictionary(
               GetWindowName().c_str());
       window_preferences->SetBoolean(L"always_on_top", is_always_on_top_);
     }
     return true;
   }
   return false;
 }
 
-std::wstring TaskManagerViewImpl::GetWindowTitle() const {
+std::wstring TaskManagerView::GetWindowTitle() const {
   return l10n_util::GetString(IDS_TASK_MANAGER_TITLE);
 }
 
-std::wstring TaskManagerViewImpl::GetWindowName() const {
+std::wstring TaskManagerView::GetWindowName() const {
   return prefs::kTaskManagerWindowPlacement;
 }
 
-int TaskManagerViewImpl::GetDialogButtons() const {
+int TaskManagerView::GetDialogButtons() const {
   return MessageBoxFlags::DIALOGBUTTON_NONE;
 }
 
-void TaskManagerViewImpl::WindowClosing() {
+void TaskManagerView::WindowClosing() {
+  // Now that the window is closed, we can allow a new one to be opened.
+  instance_ = NULL;
   task_manager_->OnWindowClosed();
 }
 
-void TaskManagerViewImpl::DeleteDelegate() {
+void TaskManagerView::DeleteDelegate() {
   ReleaseWindow();
 }
 
-views::View* TaskManagerViewImpl::GetContentsView() {
+views::View* TaskManagerView::GetContentsView() {
   return this;
 }
 
 // views::TableViewObserver implementation.
-void TaskManagerViewImpl::OnSelectionChanged() {
-  kill_button_->SetEnabled(!task_manager_->BrowserProcessIsSelected() &&
+void TaskManagerView::OnSelectionChanged() {
+  bool selection_contains_browser_process = false;
+  for (views::TableSelectionIterator iter  = tab_table_->SelectionBegin();
+       iter != tab_table_->SelectionEnd(); ++iter) {
+    if (task_manager_->IsBrowserProcess(*iter)) {
+      selection_contains_browser_process = true;
+      break;
+    }
+  }
+  kill_button_->SetEnabled(!selection_contains_browser_process &&
                            tab_table_->SelectedRowCount() > 0);
 }
 
-void TaskManagerViewImpl::OnDoubleClick() {
-  task_manager_->ActivateFocusedTab();
+void TaskManagerView::OnDoubleClick() {
+  ActivateFocusedTab();
 }
 
-void TaskManagerViewImpl::OnKeyDown(unsigned short virtual_keycode) {
+void TaskManagerView::OnKeyDown(unsigned short virtual_keycode) {
   if (virtual_keycode == VK_RETURN)
-    task_manager_->ActivateFocusedTab();
+    ActivateFocusedTab();
 }
 
 // views::LinkController implementation
-void TaskManagerViewImpl::LinkActivated(views::Link* source,
-                                        int event_flags) {
+void TaskManagerView::LinkActivated(views::Link* source, int event_flags) {
   DCHECK(source == about_memory_link_);
   Browser* browser = BrowserList::GetLastActive();
   DCHECK(browser);
   browser->OpenURL(GURL("about:memory"), GURL(), NEW_FOREGROUND_TAB,
                    PageTransition::LINK);
   // In case the browser window is minimzed, show it. If this is an application
   // or popup, we can only have one tab, hence we need to process this in a
   // tabbed browser window. Currently, |browser| is pointing to the application,
   // popup window. Therefore, we have to retrieve the last active tab again,
   // since a new window has been used.
   if (browser->type() & Browser::TYPE_APP_POPUP) {
     browser = BrowserList::GetLastActive();
     DCHECK(browser);
   }
   browser->window()->Show();
 }
 
-void TaskManagerViewImpl::ShowContextMenu(views::View* source,
-                                          int x,
-                                          int y,
-                                          bool is_mouse_gesture) {
+void TaskManagerView::ShowContextMenu(views::View* source, int x, int y,
+                                      bool is_mouse_gesture) {
   UpdateStatsCounters();
   scoped_ptr<views::Menu> menu(views::Menu::Create(
       this, views::Menu::TOPLEFT, source->GetWidget()->GetNativeView()));
   for (std::vector<TableColumn>::iterator i =
        columns_.begin(); i != columns_.end(); ++i) {
     menu->AppendMenuItem(i->id, i->title, views::Menu::CHECKBOX);
   }
   menu->RunMenuAt(x, y);
 }
 
-bool TaskManagerViewImpl::IsItemChecked(int id) const {
+bool TaskManagerView::IsItemChecked(int id) const {
   return tab_table_->IsColumnVisible(id);
 }
 
-void TaskManagerViewImpl::ExecuteCommand(int id) {
+void TaskManagerView::ExecuteCommand(int id) {
   tab_table_->SetColumnVisibility(id, !tab_table_->IsColumnVisible(id));
 }
 
-void TaskManagerViewImpl::InitAlwaysOnTopState() {
+void TaskManagerView::InitAlwaysOnTopState() {
   is_always_on_top_ = false;
   if (GetSavedAlwaysOnTopState(&is_always_on_top_))
     window()->SetIsAlwaysOnTop(is_always_on_top_);
   AddAlwaysOnTopSystemMenuItem();
 }
 
-void TaskManagerViewImpl::AddAlwaysOnTopSystemMenuItem() {
+void TaskManagerView::ActivateFocusedTab() {
+  int row_count = tab_table_->RowCount();
+  for (int i = 0; i < row_count; ++i) {
+    if (tab_table_->ItemHasTheFocus(i)) {
+      task_manager_->ActivateProcess(i);
+      break;
+    }
+  }
+}
+
+void TaskManagerView::AddAlwaysOnTopSystemMenuItem() {
   // The Win32 API requires that we own the text.
   always_on_top_menu_text_ = l10n_util::GetString(IDS_ALWAYS_ON_TOP);
 
   // Let's insert a menu to the window.
   HMENU system_menu = ::GetSystemMenu(GetWindow()->GetNativeWindow(), FALSE);
   int index = ::GetMenuItemCount(system_menu) - 1;
   if (index < 0) {
     // Paranoia check.
     NOTREACHED();
     index = 0;
@@ skipping 10 matching lines @@
   menu_info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING | MIIM_STATE;
   menu_info.fType = MFT_STRING;
   menu_info.fState = MFS_ENABLED;
   if (is_always_on_top_)
     menu_info.fState |= MFS_CHECKED;
   menu_info.wID = IDC_ALWAYS_ON_TOP;
   menu_info.dwTypeData = const_cast<wchar_t*>(always_on_top_menu_text_.c_str());
   ::InsertMenuItem(system_menu, index, TRUE, &menu_info);
 }
 
-bool TaskManagerViewImpl::GetSavedAlwaysOnTopState(bool* always_on_top) const {
+bool TaskManagerView::GetSavedAlwaysOnTopState(bool* always_on_top) const {
   if (!g_browser_process->local_state())
     return false;
 
   const DictionaryValue* dictionary =
       g_browser_process->local_state()->GetDictionary(GetWindowName().c_str());
   return dictionary &&
       dictionary->GetBoolean(L"always_on_top", always_on_top) && always_on_top;
 }
 
 }  // namespace
 
-void TaskManager::CreateView() {
-  DCHECK(!view_);
-  view_ = new TaskManagerViewImpl(this, model_.get());
+namespace browser {
+
+// Declared in browser_dialogs.h so others don't need to depend on our header.
+void ShowTaskManager() {
+  TaskManagerView::Show();
 }
+
+}  // namespace browser
+