Converts TaskManagerViews to use views menu instead of native. This

chrome/browser/ui/views/task_manager_view.cc

 // 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/task_manager/task_manager.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/stats_table.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/memory_purger.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/views/browser_dialogs.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/models/simple_menu_model.h"
 #include "ui/base/models/table_model_observer.h"
 #include "ui/views/background.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/controls/button/text_button.h"
 #include "ui/views/controls/link.h"
 #include "ui/views/controls/link_listener.h"
-#include "ui/views/controls/menu/menu.h"
+#include "ui/views/controls/menu/menu_model_adapter.h"
+#include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/table/group_table_model.h"
 #include "ui/views/controls/table/group_table_view.h"
 #include "ui/views/controls/table/table_view_observer.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/dialog_delegate.h"
 
 #if defined(OS_WIN)
 #include "win8/util/win8_util.h"
 #endif
@@ skipping 14 matching lines @@
 
 class TaskManagerTableModel : public views::GroupTableModel,
                               public TaskManagerModelObserver {
  public:
   explicit TaskManagerTableModel(TaskManagerModel* model)
       : model_(model),
         observer_(NULL) {
     model_->AddObserver(this);
   }
 
-  ~TaskManagerTableModel() {
+  virtual ~TaskManagerTableModel() {
     model_->RemoveObserver(this);
   }
 
   // GroupTableModel.
   int RowCount() OVERRIDE;
   string16 GetText(int row, int column) OVERRIDE;
   gfx::ImageSkia GetIcon(int row) OVERRIDE;
   void GetGroupRangeForItem(int item, views::GroupRange* range) OVERRIDE;
   void SetObserver(ui::TableModelObserver* observer) OVERRIDE;
   virtual int CompareValues(int row1, int row2, int column_id) OVERRIDE;
 
   // TaskManagerModelObserver.
   virtual void OnModelChanged();
   virtual void OnItemsChanged(int start, int length);
   virtual void OnItemsAdded(int start, int length);
   virtual void OnItemsRemoved(int start, int length);
 
   // Returns true if resource corresponding to |row| is a background resource.
   bool IsBackgroundResource(int row);
 
  private:
   TaskManagerModel* model_;
   ui::TableModelObserver* observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(TaskManagerTableModel);
 };
 
 int TaskManagerTableModel::RowCount() {
   return model_->ResourceCount();
 }
 
 string16 TaskManagerTableModel::GetText(int row, int col_id) {
   switch (col_id) {
     case IDS_TASK_MANAGER_TASK_COLUMN:  // Process
       return model_->GetResourceTitle(row);
@@ skipping 166 matching lines @@
 
   TaskManagerTableModel* model_;
 };
 
 // The Task manager UI container.
 class TaskManagerView : public views::ButtonListener,
                         public views::DialogDelegateView,
                         public views::TableViewObserver,
                         public views::LinkListener,
                         public views::ContextMenuController,
-                        public views::Menu::Delegate {
+                        public ui::SimpleMenuModel::Delegate {
  public:
   TaskManagerView(bool highlight_background_resources,
                   chrome::HostDesktopType desktop_type);
   virtual ~TaskManagerView();
 
   // Shows the Task manager window, or re-activates an existing one. If
   // |highlight_background_resources| is true, highlights the background
   // resources in the resource display.
   static void Show(bool highlight_background_resources,
                    chrome::HostDesktopType desktop_type);
@@ skipping 26 matching lines @@
   virtual void LinkClicked(views::Link* source, int event_flags) OVERRIDE;
 
   // Called by the column picker to pick up any new stat counters that
   // may have appeared since last time.
   void UpdateStatsCounters();
 
   // views::ContextMenuController:
   virtual void ShowContextMenuForView(views::View* source,
                                       const gfx::Point& point) OVERRIDE;
 
-  // views::Menu::Delegate:
-  virtual bool IsItemChecked(int id) const OVERRIDE;
+  // ui::SimpleMenuModel::Delegate:
+  virtual bool IsCommandIdChecked(int id) const OVERRIDE;
+  virtual bool IsCommandIdEnabled(int id) const OVERRIDE;
+  virtual bool GetAcceleratorForCommandId(
+      int command_id,
+      ui::Accelerator* accelerator) OVERRIDE;
   virtual void ExecuteCommand(int id) OVERRIDE;
 
  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.
@@ skipping 28 matching lines @@
   // The host desktop type this task manager belongs to.
   const chrome::HostDesktopType desktop_type_;
 
   // We need to own the text of the menu, the Windows API does not copy it.
   string16 always_on_top_menu_text_;
 
   // 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_;
 
+  scoped_ptr<views::MenuRunner> menu_runner_;
+
   DISALLOW_COPY_AND_ASSIGN(TaskManagerView);
 };
 
 // static
 TaskManagerView* TaskManagerView::instance_ = NULL;
 
 
 TaskManagerView::TaskManagerView(bool highlight_background_resources,
                                  chrome::HostDesktopType desktop_type)
     : purge_memory_button_(NULL),
+      kill_button_(NULL),
+      about_memory_link_(NULL),
+      tab_table_(NULL),
       task_manager_(TaskManager::GetInstance()),
       model_(TaskManager::GetInstance()->model()),
       is_always_on_top_(false),
       highlight_background_resources_(highlight_background_resources),
       desktop_type_(desktop_type) {
   Init();
 }
 
 TaskManagerView::~TaskManagerView() {
   // Delete child views now, while our table model still exists.
@@ skipping 138 matching lines @@
     } else {
       parent->RemoveChildView(kill_button_);
       if (purge_memory_button_)
         parent->RemoveChildView(purge_memory_button_);
       parent->RemoveChildView(about_memory_link_);
     }
   }
 }
 
 void TaskManagerView::Layout() {
-  // views::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() + views::kPanelHorizMargin,
       y() + views::kPanelVertMargin,
       width() - 2 * views::kPanelHorizMargin,
       height() - 2 * views::kPanelVertMargin - prefered_height);
 
@@ skipping 29 matching lines @@
       link_prefered_height);
 }
 
 gfx::Size TaskManagerView::GetPreferredSize() {
   return gfx::Size(kDefaultWidth, kDefaultHeight);
 }
 
 // static
 void TaskManagerView::Show(bool highlight_background_resources,
                            chrome::HostDesktopType desktop_type) {
+#if defined(OS_WIN)
   // In Windows Metro it's not good to open this native window.
   DCHECK(!win8::IsSingleWindowMetroMode());
+#endif
 
   if (instance_) {
     if (instance_->highlight_background_resources_ !=
         highlight_background_resources ||
         instance_->desktop_type_ != desktop_type) {
       instance_->GetWidget()->Close();
     } else {
       // If there's a Task manager window open already, just activate it.
       instance_->GetWidget()->Activate();
       return;
     }
   }
-  instance_ = new TaskManagerView(highlight_background_resources,
-                                  desktop_type);
+  instance_ = new TaskManagerView(highlight_background_resources, desktop_type);
   views::Widget::CreateWindow(instance_);
   instance_->InitAlwaysOnTopState();
   instance_->model_->StartUpdating();
   instance_->GetWidget()->Show();
 
   // Set the initial focus to the list of tasks.
   views::FocusManager* focus_manager = instance_->GetFocusManager();
   if (focus_manager)
     focus_manager->SetFocusedView(instance_->tab_table_);
 }
 
 // ButtonListener implementation.
 void TaskManagerView::ButtonPressed(
-    views::Button* sender, const ui::Event& event) {
+    views::Button* sender,
+    const ui::Event& event) {
   if (purge_memory_button_ && (sender == purge_memory_button_)) {
     MemoryPurger::PurgeAll();
   } else {
     DCHECK_EQ(kill_button_, sender);
     for (views::TableSelectionIterator iter  = tab_table_->SelectionBegin();
          iter != tab_table_->SelectionEnd(); ++iter)
       task_manager_->KillProcess(*iter);
   }
 }
 
@@ skipping 85 matching lines @@
 }
 
 void TaskManagerView::LinkClicked(views::Link* source, int event_flags) {
   DCHECK_EQ(about_memory_link_, source);
   task_manager_->OpenAboutMemory(desktop_type_);
 }
 
 void TaskManagerView::ShowContextMenuForView(views::View* source,
                                              const gfx::Point& point) {
   UpdateStatsCounters();
-  scoped_ptr<views::Menu> menu(views::Menu::Create(
-      this, views::Menu::TOPLEFT, source->GetWidget()->GetNativeView()));
+  ui::SimpleMenuModel menu_model(this);
   for (std::vector<ui::TableColumn>::iterator i(columns_.begin());
        i != columns_.end(); ++i) {
-    menu->AppendMenuItem(i->id, l10n_util::GetStringUTF16(i->id),
-        views::Menu::CHECKBOX);
+    menu_model.AddCheckItem(i->id, l10n_util::GetStringUTF16(i->id));
   }
-  menu->RunMenuAt(point.x(), point.y());
+  views::MenuModelAdapter menu_adapter(&menu_model);
+  menu_runner_.reset(new views::MenuRunner(menu_adapter.CreateMenu()));
+  if (menu_runner_->RunMenuAt(GetWidget(), NULL, gfx::Rect(point, gfx::Size()),
+                              views::MenuItemView::TOPLEFT,
+                              views::MenuRunner::CONTEXT_MENU) ==
+      views::MenuRunner::MENU_DELETED)
+    return;
 }
 
-bool TaskManagerView::IsItemChecked(int id) const {
+bool TaskManagerView::IsCommandIdChecked(int id) const {
   return tab_table_->IsColumnVisible(id);
 }
 
+bool TaskManagerView::IsCommandIdEnabled(int id) const {
+  return true;
+}
+
+bool TaskManagerView::GetAcceleratorForCommandId(
+    int command_id,
+    ui::Accelerator* accelerator) {
+  return false;
+}
+
 void TaskManagerView::ExecuteCommand(int id) {
   tab_table_->SetColumnVisibility(id, !tab_table_->IsColumnVisible(id));
 }
 
 void TaskManagerView::InitAlwaysOnTopState() {
   is_always_on_top_ = false;
   if (GetSavedAlwaysOnTopState(&is_always_on_top_))
     GetWidget()->SetAlwaysOnTop(is_always_on_top_);
   AddAlwaysOnTopSystemMenuItem();
 }
@@ skipping 58 matching lines @@
 // Declared in browser_dialogs.h so others don't need to depend on our header.
 void ShowTaskManager(chrome::HostDesktopType desktop_type) {
   TaskManagerView::Show(false, desktop_type);
 }
 
 void ShowBackgroundPages(chrome::HostDesktopType desktop_type) {
   TaskManagerView::Show(true, desktop_type);
 }
 
 }  // namespace chrome