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