chrome/browser/ui/views/task_manager_view.cc

   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/task_manager/task_manager.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/prefs/pref_service.h"
   9 #include "base/prefs/scoped_user_pref_update.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "chrome/app/chrome_command_ids.h"
  12 #include "chrome/browser/browser_process.h"
  13 #include "chrome/browser/ui/browser.h"
  14 #include "chrome/browser/ui/browser_list.h"
  15 #include "chrome/browser/ui/browser_window.h"
  16 #include "chrome/browser/ui/host_desktop.h"
  17 #include "chrome/browser/ui/views/browser_dialogs.h"
  18 #include "chrome/common/pref_names.h"
  19 #include "chrome/grit/chromium_strings.h"
  20 #include "chrome/grit/generated_resources.h"
  21 #include "ui/base/accelerators/accelerator.h"
  22 #include "ui/base/l10n/l10n_util.h"
  23 #include "ui/base/models/simple_menu_model.h"
  24 #include "ui/base/models/table_model.h"
  25 #include "ui/base/models/table_model_observer.h"
  26 #include "ui/events/event_constants.h"
  27 #include "ui/events/keycodes/keyboard_codes.h"
  28 #include "ui/gfx/canvas.h"
  29 #include "ui/views/context_menu_controller.h"
  30 #include "ui/views/controls/button/label_button.h"
  31 #include "ui/views/controls/link.h"
  32 #include "ui/views/controls/link_listener.h"
  33 #include "ui/views/controls/menu/menu_runner.h"
  34 #include "ui/views/controls/table/table_grouper.h"
  35 #include "ui/views/controls/table/table_view.h"
  36 #include "ui/views/controls/table/table_view_observer.h"
  37 #include "ui/views/layout/layout_constants.h"
  38 #include "ui/views/widget/widget.h"
  39 #include "ui/views/window/dialog_delegate.h"
  40
  41 #if defined(USE_ASH)
  42 #include "ash/shelf/shelf_util.h"
  43 #include "ash/wm/window_util.h"
  44 #include "grit/ash_resources.h"
  45 #endif
  46
  47 #if defined(OS_WIN)
  48 #include "chrome/browser/shell_integration.h"
  49 #include "ui/base/win/shell.h"
  50 #include "ui/views/win/hwnd_util.h"
  51 #endif
  52
  53 namespace {
  54
  55 ////////////////////////////////////////////////////////////////////////////////
  56 // TaskManagerTableModel class
  57 ////////////////////////////////////////////////////////////////////////////////
  58
  59 class TaskManagerTableModel
  60     : public ui::TableModel,
  61       public views::TableGrouper,
  62       public TaskManagerModelObserver {
  63  public:
  64   explicit TaskManagerTableModel(TaskManagerModel* model)
  65       : model_(model),
  66         observer_(NULL) {
  67     model_->AddObserver(this);
  68   }
  69
  70   ~TaskManagerTableModel() override { model_->RemoveObserver(this); }
  71
  72   // TableModel overrides:
  73   int RowCount() override;
  74   base::string16 GetText(int row, int column) override;
  75   gfx::ImageSkia GetIcon(int row) override;
  76   void SetObserver(ui::TableModelObserver* observer) override;
  77   int CompareValues(int row1, int row2, int column_id) override;
  78
  79   // TableGrouper overrides:
  80   void GetGroupRange(int model_index, views::GroupRange* range) override;
  81
  82   // TaskManagerModelObserver overrides:
  83   void OnModelChanged() override;
  84   void OnItemsChanged(int start, int length) override;
  85   void OnItemsAdded(int start, int length) override;
  86   void OnItemsRemoved(int start, int length) override;
  87
  88  private:
  89   TaskManagerModel* model_;
  90   ui::TableModelObserver* observer_;
  91
  92   DISALLOW_COPY_AND_ASSIGN(TaskManagerTableModel);
  93 };
  94
  95 int TaskManagerTableModel::RowCount() {
  96   return model_->ResourceCount();
  97 }
  98
  99 base::string16 TaskManagerTableModel::GetText(int row, int col_id) {
 100   return model_->GetResourceById(row, col_id);
 101 }
 102
 103 gfx::ImageSkia TaskManagerTableModel::GetIcon(int row) {
 104   return model_->GetResourceIcon(row);
 105 }
 106
 107 void TaskManagerTableModel::SetObserver(ui::TableModelObserver* observer) {
 108   observer_ = observer;
 109 }
 110
 111 int TaskManagerTableModel::CompareValues(int row1, int row2, int column_id) {
 112   return model_->CompareValues(row1, row2, column_id);
 113 }
 114
 115 void TaskManagerTableModel::GetGroupRange(int model_index,
 116                                           views::GroupRange* range) {
 117   TaskManagerModel::GroupRange range_pair =
 118       model_->GetGroupRangeForResource(model_index);
 119   range->start = range_pair.first;
 120   range->length = range_pair.second;
 121 }
 122
 123 void TaskManagerTableModel::OnModelChanged() {
 124   if (observer_)
 125     observer_->OnModelChanged();
 126 }
 127
 128 void TaskManagerTableModel::OnItemsChanged(int start, int length) {
 129   if (observer_)
 130     observer_->OnItemsChanged(start, length);
 131 }
 132
 133 void TaskManagerTableModel::OnItemsAdded(int start, int length) {
 134   if (observer_)
 135     observer_->OnItemsAdded(start, length);
 136 }
 137
 138 void TaskManagerTableModel::OnItemsRemoved(int start, int length) {
 139   if (observer_)
 140     observer_->OnItemsRemoved(start, length);
 141 }
 142
 143 // The Task Manager UI container.
 144 class TaskManagerView : public views::ButtonListener,
 145                         public views::DialogDelegateView,
 146                         public views::TableViewObserver,
 147                         public views::LinkListener,
 148                         public views::ContextMenuController,
 149                         public ui::SimpleMenuModel::Delegate {
 150  public:
 151   explicit TaskManagerView(chrome::HostDesktopType desktop_type);
 152   ~TaskManagerView() override;
 153
 154   // Shows the Task Manager window, or re-activates an existing one.
 155   static void Show(Browser* browser);
 156
 157   // Hides the Task Manager if it is showing.
 158   static void Hide();
 159
 160   // views::View:
 161   void Layout() override;
 162   gfx::Size GetPreferredSize() const override;
 163   bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
 164   void ViewHierarchyChanged(
 165       const ViewHierarchyChangedDetails& details) override;
 166
 167   // views::ButtonListener:
 168   void ButtonPressed(views::Button* sender, const ui::Event& event) override;
 169
 170   // views::DialogDelegateView:
 171   bool CanResize() const override;
 172   bool CanMaximize() const override;
 173   bool CanMinimize() const override;
 174   bool ExecuteWindowsCommand(int command_id) override;
 175   base::string16 GetWindowTitle() const override;
 176   std::string GetWindowName() const override;
 177   int GetDialogButtons() const override;
 178   void WindowClosing() override;
 179   bool UseNewStyleForThisDialog() const override;
 180
 181   // views::TableViewObserver:
 182   void OnSelectionChanged() override;
 183   void OnDoubleClick() override;
 184   void OnKeyDown(ui::KeyboardCode keycode) override;
 185
 186   // views::LinkListener:
 187   void LinkClicked(views::Link* source, int event_flags) override;
 188
 189   // views::ContextMenuController:
 190   void ShowContextMenuForView(views::View* source,
 191                               const gfx::Point& point,
 192                               ui::MenuSourceType source_type) override;
 193
 194   // ui::SimpleMenuModel::Delegate:
 195   bool IsCommandIdChecked(int id) const override;
 196   bool IsCommandIdEnabled(int id) const override;
 197   bool GetAcceleratorForCommandId(int command_id,
 198                                   ui::Accelerator* accelerator) override;
 199   void ExecuteCommand(int id, int event_flags) override;
 200
 201  private:
 202   // Creates the child controls.
 203   void Init();
 204
 205   // Initializes the state of the always-on-top setting as the window is shown.
 206   void InitAlwaysOnTopState();
 207
 208   // Activates the tab associated with the focused row.
 209   void ActivateFocusedTab();
 210
 211   // Restores saved always on top state from a previous session.
 212   bool GetSavedAlwaysOnTopState(bool* always_on_top) const;
 213
 214   views::LabelButton* kill_button_;
 215   views::Link* about_memory_link_;
 216   views::TableView* tab_table_;
 217   views::View* tab_table_parent_;
 218
 219   TaskManager* task_manager_;
 220
 221   TaskManagerModel* model_;
 222
 223   // all possible columns, not necessarily visible
 224   std::vector<ui::TableColumn> columns_;
 225
 226   scoped_ptr<TaskManagerTableModel> table_model_;
 227
 228   // True when the Task Manager window should be shown on top of other windows.
 229   bool is_always_on_top_;
 230
 231   // The host desktop type this task manager belongs to.
 232   const chrome::HostDesktopType desktop_type_;
 233
 234   // We need to own the text of the menu, the Windows API does not copy it.
 235   base::string16 always_on_top_menu_text_;
 236
 237   // An open Task manager window. There can only be one open at a time. This
 238   // is reset to NULL when the window is closed.
 239   static TaskManagerView* instance_;
 240
 241   scoped_ptr<views::MenuRunner> menu_runner_;
 242
 243   DISALLOW_COPY_AND_ASSIGN(TaskManagerView);
 244 };
 245
 246 // static
 247 TaskManagerView* TaskManagerView::instance_ = NULL;
 248
 249
 250 TaskManagerView::TaskManagerView(chrome::HostDesktopType desktop_type)
 251     : kill_button_(NULL),
 252       about_memory_link_(NULL),
 253       tab_table_(NULL),
 254       tab_table_parent_(NULL),
 255       task_manager_(TaskManager::GetInstance()),
 256       model_(TaskManager::GetInstance()->model()),
 257       is_always_on_top_(false),
 258       desktop_type_(desktop_type) {
 259   Init();
 260 }
 261
 262 TaskManagerView::~TaskManagerView() {
 263   // Delete child views now, while our table model still exists.
 264   RemoveAllChildViews(true);
 265 }
 266
 267 void TaskManagerView::Init() {
 268   table_model_.reset(new TaskManagerTableModel(model_));
 269
 270   // Page column has no header label.
 271   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_TASK_COLUMN,
 272                                      ui::TableColumn::LEFT, -1, 1));
 273   columns_.back().sortable = true;
 274   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_PROFILE_NAME_COLUMN,
 275                                      ui::TableColumn::LEFT, -1, 0));
 276   columns_.back().sortable = true;
 277   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN,
 278                                      ui::TableColumn::RIGHT, -1, 0));
 279   columns_.back().sortable = true;
 280   columns_.back().initial_sort_is_ascending = false;
 281   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_SHARED_MEM_COLUMN,
 282                                      ui::TableColumn::RIGHT, -1, 0));
 283   columns_.back().sortable = true;
 284   columns_.back().initial_sort_is_ascending = false;
 285   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN,
 286                                      ui::TableColumn::RIGHT, -1, 0));
 287   columns_.back().sortable = true;
 288   columns_.back().initial_sort_is_ascending = false;
 289   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_CPU_COLUMN,
 290                                      ui::TableColumn::RIGHT, -1, 0));
 291   columns_.back().sortable = true;
 292   columns_.back().initial_sort_is_ascending = false;
 293   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_NET_COLUMN,
 294                                      ui::TableColumn::RIGHT, -1, 0));
 295   columns_.back().sortable = true;
 296   columns_.back().initial_sort_is_ascending = false;
 297   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_PROCESS_ID_COLUMN,
 298                                      ui::TableColumn::RIGHT, -1, 0));
 299   columns_.back().sortable = true;
 300 #if defined(OS_WIN)
 301   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_GDI_HANDLES_COLUMN,
 302                                      ui::TableColumn::RIGHT, -1, 0));
 303   columns_.back().sortable = true;
 304   columns_.back().initial_sort_is_ascending = false;
 305   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_USER_HANDLES_COLUMN,
 306                                      ui::TableColumn::RIGHT, -1, 0));
 307   columns_.back().sortable = true;
 308   columns_.back().initial_sort_is_ascending = false;
 309 #endif
 310   columns_.push_back(ui::TableColumn(
 311       IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN,
 312       ui::TableColumn::RIGHT, -1, 0));
 313   columns_.back().sortable = true;
 314   columns_.back().initial_sort_is_ascending = false;
 315   columns_.push_back(ui::TableColumn(
 316       IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN,
 317       ui::TableColumn::RIGHT, -1, 0));
 318   columns_.back().sortable = true;
 319   columns_.back().initial_sort_is_ascending = false;
 320   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN,
 321                                      ui::TableColumn::RIGHT, -1, 0));
 322   columns_.back().sortable = true;
 323   columns_.back().initial_sort_is_ascending = false;
 324   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_VIDEO_MEMORY_COLUMN,
 325                                      ui::TableColumn::RIGHT, -1, 0));
 326   columns_.back().sortable = true;
 327   columns_.back().initial_sort_is_ascending = false;
 328   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN,
 329                                      ui::TableColumn::RIGHT, -1, 0));
 330   columns_.back().sortable = true;
 331   columns_.back().initial_sort_is_ascending = false;
 332   columns_.push_back(ui::TableColumn(
 333       IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN,
 334       ui::TableColumn::RIGHT, -1, 0));
 335   columns_.back().sortable = true;
 336   columns_.push_back(
 337       ui::TableColumn(IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN,
 338                       ui::TableColumn::RIGHT, -1, 0));
 339   columns_.back().sortable = true;
 340   columns_.back().initial_sort_is_ascending = false;
 341   // TODO(port) http://crbug.com/120488 for non-Linux.
 342 #if defined(OS_LINUX)
 343   columns_.push_back(ui::TableColumn(IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN,
 344                                      ui::TableColumn::RIGHT, -1, 0));
 345   columns_.back().sortable = true;
 346   columns_.back().initial_sort_is_ascending = false;
 347 #endif
 348
 349   tab_table_ = new views::TableView(
 350       table_model_.get(), columns_, views::ICON_AND_TEXT, false);
 351   tab_table_->SetGrouper(table_model_.get());
 352
 353   // Hide some columns by default
 354   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_PROFILE_NAME_COLUMN, false);
 355   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_SHARED_MEM_COLUMN, false);
 356   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN, false);
 357   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN,
 358                                   false);
 359   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN,
 360                                   false);
 361   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN,
 362                                   false);
 363   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_VIDEO_MEMORY_COLUMN,
 364                                   false);
 365   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN,
 366                                   false);
 367   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_NACL_DEBUG_STUB_PORT_COLUMN,
 368                                   false);
 369   tab_table_->SetColumnVisibility(
 370       IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN, false);
 371   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_GDI_HANDLES_COLUMN, false);
 372   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_USER_HANDLES_COLUMN, false);
 373   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN, false);
 374
 375   tab_table_->SetObserver(this);
 376   tab_table_->set_context_menu_controller(this);
 377   set_context_menu_controller(this);
 378   kill_button_ = new views::LabelButton(this,
 379       l10n_util::GetStringUTF16(IDS_TASK_MANAGER_KILL));
 380   kill_button_->SetStyle(views::Button::STYLE_BUTTON);
 381   about_memory_link_ = new views::Link(
 382       l10n_util::GetStringUTF16(IDS_TASK_MANAGER_ABOUT_MEMORY_LINK));
 383   about_memory_link_->set_listener(this);
 384
 385   // Makes sure our state is consistent.
 386   OnSelectionChanged();
 387
 388   ui::Accelerator ctrl_w(ui::VKEY_W, ui::EF_CONTROL_DOWN);
 389   AddAccelerator(ctrl_w);
 390 }
 391
 392 void TaskManagerView::ViewHierarchyChanged(
 393     const ViewHierarchyChangedDetails& details) {
 394   views::DialogDelegateView::ViewHierarchyChanged(details);
 395   // Since we want the Kill button and the Memory Details link to show up in
 396   // the same visual row as the close button, which is provided by the
 397   // framework, we must add the buttons to the non-client view, which is the
 398   // parent of this view. Similarly, when we're removed from the view
 399   // hierarchy, we must take care to clean up those items as well.
 400   if (details.child == this) {
 401     if (details.is_add) {
 402       details.parent->AddChildView(about_memory_link_);
 403       details.parent->AddChildView(kill_button_);
 404       tab_table_parent_ = tab_table_->CreateParentIfNecessary();
 405       AddChildView(tab_table_parent_);
 406     } else {
 407       details.parent->RemoveChildView(kill_button_);
 408       details.parent->RemoveChildView(about_memory_link_);
 409     }
 410   }
 411 }
 412
 413 void TaskManagerView::Layout() {
 414   gfx::Size size = kill_button_->GetPreferredSize();
 415   gfx::Rect parent_bounds = parent()->GetContentsBounds();
 416   const int horizontal_margin = views::kPanelHorizMargin;
 417   const int vertical_margin = views::kButtonVEdgeMargin;
 418   int x = width() - size.width() - horizontal_margin;
 419   int y_buttons = parent_bounds.bottom() - size.height() - vertical_margin;
 420   kill_button_->SetBounds(x, y_buttons, size.width(), size.height());
 421
 422   size = about_memory_link_->GetPreferredSize();
 423   about_memory_link_->SetBounds(
 424       horizontal_margin,
 425       y_buttons + (kill_button_->height() - size.height()) / 2,
 426       size.width(), size.height());
 427
 428   gfx::Rect rect = GetLocalBounds();
 429   rect.Inset(horizontal_margin, views::kPanelVertMargin);
 430   rect.Inset(0, 0, 0,
 431              kill_button_->height() + views::kUnrelatedControlVerticalSpacing);
 432   tab_table_parent_->SetBoundsRect(rect);
 433 }
 434
 435 gfx::Size TaskManagerView::GetPreferredSize() const {
 436   return gfx::Size(460, 270);
 437 }
 438
 439 bool TaskManagerView::AcceleratorPressed(const ui::Accelerator& accelerator) {
 440   DCHECK_EQ(ui::VKEY_W, accelerator.key_code());
 441   DCHECK_EQ(ui::EF_CONTROL_DOWN, accelerator.modifiers());
 442   GetWidget()->Close();
 443   return true;
 444 }
 445
 446 // static
 447 void TaskManagerView::Show(Browser* browser) {
 448   // In ash we can come here through the ChromeShellDelegate. If there is no
 449   // browser window at that time of the call, browser could be passed as NULL.
 450   const chrome::HostDesktopType desktop_type =
 451       browser ? browser->host_desktop_type() : chrome::HOST_DESKTOP_TYPE_ASH;
 452
 453   if (instance_) {
 454     // If there's a Task manager window open already, just activate it.
 455     instance_->GetWidget()->Activate();
 456     return;
 457   }
 458   instance_ = new TaskManagerView(desktop_type);
 459   gfx::NativeWindow window =
 460       browser ? browser->window()->GetNativeWindow() : NULL;
 461 #if defined(USE_ASH)
 462   if (!window)
 463     window = ash::wm::GetActiveWindow();
 464 #endif
 465   DialogDelegate::CreateDialogWidget(instance_, window, NULL);
 466   instance_->InitAlwaysOnTopState();
 467   instance_->model_->StartUpdating();
 468 #if defined(OS_WIN)
 469   // Set the app id for the task manager to the app id of its parent browser. If
 470   // no parent is specified, the app id will default to that of the initial
 471   // process.
 472   if (browser) {
 473     ui::win::SetAppIdForWindow(
 474         ShellIntegration::GetChromiumModelIdForProfile(
 475             browser->profile()->GetPath()),
 476         views::HWNDForWidget(instance_->GetWidget()));
 477   }
 478 #endif
 479   instance_->GetWidget()->Show();
 480
 481   // Set the initial focus to the list of tasks.
 482   views::FocusManager* focus_manager = instance_->GetFocusManager();
 483   if (focus_manager)
 484     focus_manager->SetFocusedView(instance_->tab_table_);
 485
 486 #if defined(USE_ASH)
 487   gfx::NativeWindow native_window = instance_->GetWidget()->GetNativeWindow();
 488   ash::SetShelfItemDetailsForDialogWindow(
 489       native_window, IDR_ASH_SHELF_ICON_TASK_MANAGER, native_window->title());
 490 #endif
 491 }
 492
 493 // static
 494 void TaskManagerView::Hide() {
 495   if (instance_)
 496     instance_->GetWidget()->Close();
 497 }
 498
 499 // ButtonListener implementation.
 500 void TaskManagerView::ButtonPressed(
 501     views::Button* sender,
 502     const ui::Event& event) {
 503   typedef ui::ListSelectionModel::SelectedIndices SelectedIndices;
 504   DCHECK_EQ(kill_button_, sender);
 505   SelectedIndices selection(tab_table_->selection_model().selected_indices());
 506   for (SelectedIndices::const_reverse_iterator i = selection.rbegin();
 507         i != selection.rend(); ++i) {
 508     task_manager_->KillProcess(*i);
 509   }
 510 }
 511
 512 // DialogDelegate implementation.
 513 bool TaskManagerView::CanResize() const {
 514   return true;
 515 }
 516
 517 bool TaskManagerView::CanMaximize() const {
 518   return true;
 519 }
 520
 521 bool TaskManagerView::CanMinimize() const {
 522   return true;
 523 }
 524
 525 bool TaskManagerView::ExecuteWindowsCommand(int command_id) {
 526   return false;
 527 }
 528
 529 base::string16 TaskManagerView::GetWindowTitle() const {
 530   return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_TITLE);
 531 }
 532
 533 std::string TaskManagerView::GetWindowName() const {
 534   return prefs::kTaskManagerWindowPlacement;
 535 }
 536
 537 int TaskManagerView::GetDialogButtons() const {
 538   return ui::DIALOG_BUTTON_NONE;
 539 }
 540
 541 void TaskManagerView::WindowClosing() {
 542   // Now that the window is closed, we can allow a new one to be opened.
 543   // (WindowClosing comes in asynchronously from the call to Close() and we
 544   // may have already opened a new instance).
 545   if (instance_ == this)
 546     instance_ = NULL;
 547   task_manager_->OnWindowClosed();
 548 }
 549
 550 bool TaskManagerView::UseNewStyleForThisDialog() const {
 551   return false;
 552 }
 553
 554 // views::TableViewObserver implementation.
 555 void TaskManagerView::OnSelectionChanged() {
 556   const ui::ListSelectionModel::SelectedIndices& selection(
 557       tab_table_->selection_model().selected_indices());
 558   bool selection_contains_browser_process = false;
 559   for (size_t i = 0; i < selection.size(); ++i) {
 560     if (task_manager_->IsBrowserProcess(selection[i])) {
 561       selection_contains_browser_process = true;
 562       break;
 563     }
 564   }
 565   kill_button_->SetEnabled(!selection_contains_browser_process &&
 566                            !selection.empty());
 567 }
 568
 569 void TaskManagerView::OnDoubleClick() {
 570   ActivateFocusedTab();
 571 }
 572
 573 void TaskManagerView::OnKeyDown(ui::KeyboardCode keycode) {
 574   if (keycode == ui::VKEY_RETURN)
 575     ActivateFocusedTab();
 576 }
 577
 578 void TaskManagerView::LinkClicked(views::Link* source, int event_flags) {
 579   DCHECK_EQ(about_memory_link_, source);
 580   task_manager_->OpenAboutMemory(desktop_type_);
 581 }
 582
 583 void TaskManagerView::ShowContextMenuForView(views::View* source,
 584                                              const gfx::Point& point,
 585                                              ui::MenuSourceType source_type) {
 586   ui::SimpleMenuModel menu_model(this);
 587   for (std::vector<ui::TableColumn>::iterator i(columns_.begin());
 588        i != columns_.end(); ++i) {
 589     menu_model.AddCheckItem(i->id, l10n_util::GetStringUTF16(i->id));
 590   }
 591   menu_runner_.reset(
 592       new views::MenuRunner(&menu_model, views::MenuRunner::CONTEXT_MENU));
 593   if (menu_runner_->RunMenuAt(GetWidget(),
 594                               NULL,
 595                               gfx::Rect(point, gfx::Size()),
 596                               views::MENU_ANCHOR_TOPLEFT,
 597                               source_type) == views::MenuRunner::MENU_DELETED) {
 598     return;
 599   }
 600 }
 601
 602 bool TaskManagerView::IsCommandIdChecked(int id) const {
 603   return tab_table_->IsColumnVisible(id);
 604 }
 605
 606 bool TaskManagerView::IsCommandIdEnabled(int id) const {
 607   return true;
 608 }
 609
 610 bool TaskManagerView::GetAcceleratorForCommandId(
 611     int command_id,
 612     ui::Accelerator* accelerator) {
 613   return false;
 614 }
 615
 616 void TaskManagerView::ExecuteCommand(int id, int event_flags) {
 617   tab_table_->SetColumnVisibility(id, !tab_table_->IsColumnVisible(id));
 618 }
 619
 620 void TaskManagerView::InitAlwaysOnTopState() {
 621   is_always_on_top_ = false;
 622   if (GetSavedAlwaysOnTopState(&is_always_on_top_))
 623     GetWidget()->SetAlwaysOnTop(is_always_on_top_);
 624 }
 625
 626 void TaskManagerView::ActivateFocusedTab() {
 627   const int active_row = tab_table_->selection_model().active();
 628   if (active_row != -1)
 629     task_manager_->ActivateProcess(active_row);
 630 }
 631
 632 bool TaskManagerView::GetSavedAlwaysOnTopState(bool* always_on_top) const {
 633   if (!g_browser_process->local_state())
 634     return false;
 635
 636   const base::DictionaryValue* dictionary =
 637       g_browser_process->local_state()->GetDictionary(GetWindowName().c_str());
 638   return dictionary &&
 639       dictionary->GetBoolean("always_on_top", always_on_top) && always_on_top;
 640 }
 641
 642 }  // namespace
 643
 644 namespace chrome {
 645
 646 // Declared in browser_dialogs.h so others don't need to depend on our header.
 647 void ShowTaskManager(Browser* browser) {
 648   TaskManagerView::Show(browser);
 649 }
 650
 651 void HideTaskManager() {
 652   TaskManagerView::Hide();
 653 }
 654
 655 }  // namespace chrome