Project Eraser: Kill chrome://memory.

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 <stddef.h>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
@@ skipping 16 matching lines @@
 #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.h"
 #include "ui/base/models/table_model_observer.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/canvas.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/controls/button/label_button.h"
-#include "ui/views/controls/link.h"
-#include "ui/views/controls/link_listener.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/controls/table/table_grouper.h"
 #include "ui/views/controls/table/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(USE_ASH)
 #include "ash/shelf/shelf_util.h"
@@ skipping 94 matching lines @@
 
 void TaskManagerTableModel::OnItemsRemoved(int start, int length) {
   if (observer_)
     observer_->OnItemsRemoved(start, length);
 }
 
 // The Task Manager UI container.
 class TaskManagerView : public views::ButtonListener,
                         public views::DialogDelegateView,
                         public views::TableViewObserver,
-                        public views::LinkListener,
                         public views::ContextMenuController,
                         public ui::SimpleMenuModel::Delegate {
  public:
   TaskManagerView();
   ~TaskManagerView() override;
 
   // Shows the Task Manager window, or re-activates an existing one.
   static void Show(Browser* browser);
 
   // Hides the Task Manager if it is showing.
@@ skipping 18 matching lines @@
   std::string GetWindowName() const override;
   int GetDialogButtons() const override;
   void WindowClosing() override;
   bool UseNewStyleForThisDialog() const override;
 
   // views::TableViewObserver:
   void OnSelectionChanged() override;
   void OnDoubleClick() override;
   void OnKeyDown(ui::KeyboardCode keycode) override;
 
-  // views::LinkListener:
-  void LinkClicked(views::Link* source, int event_flags) override;
-
   // views::ContextMenuController:
   void ShowContextMenuForView(views::View* source,
                               const gfx::Point& point,
                               ui::MenuSourceType source_type) override;
 
   // ui::SimpleMenuModel::Delegate:
   bool IsCommandIdChecked(int id) const override;
   bool IsCommandIdEnabled(int id) const override;
   bool GetAcceleratorForCommandId(int command_id,
                                   ui::Accelerator* accelerator) override;
   void ExecuteCommand(int id, int event_flags) 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.
   void ActivateFocusedTab();
 
   // Restores saved always on top state from a previous session.
   bool GetSavedAlwaysOnTopState(bool* always_on_top) const;
 
   views::LabelButton* kill_button_;
-  views::Link* about_memory_link_;
   views::TableView* tab_table_;
   views::View* tab_table_parent_;
 
   TaskManager* task_manager_;
 
   TaskManagerModel* model_;
 
   // all possible columns, not necessarily visible
   std::vector<ui::TableColumn> columns_;
 
@@ skipping 12 matching lines @@
   scoped_ptr<views::MenuRunner> menu_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerView);
 };
 
 // static
 TaskManagerView* TaskManagerView::instance_ = NULL;
 
 TaskManagerView::TaskManagerView()
     : kill_button_(NULL),
-      about_memory_link_(NULL),
       tab_table_(NULL),
       tab_table_parent_(NULL),
       task_manager_(TaskManager::GetInstance()),
       model_(TaskManager::GetInstance()->model()),
       is_always_on_top_(false) {
   Init();
 }
 
 TaskManagerView::~TaskManagerView() {
   // Delete child views now, while our table model still exists.
@@ skipping 107 matching lines @@
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_GDI_HANDLES_COLUMN, false);
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_USER_HANDLES_COLUMN, false);
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_IDLE_WAKEUPS_COLUMN, false);
 
   tab_table_->SetObserver(this);
   tab_table_->set_context_menu_controller(this);
   set_context_menu_controller(this);
   kill_button_ = new views::LabelButton(this,
       l10n_util::GetStringUTF16(IDS_TASK_MANAGER_KILL));
   kill_button_->SetStyle(views::Button::STYLE_BUTTON);
-  about_memory_link_ = new views::Link(
-      l10n_util::GetStringUTF16(IDS_TASK_MANAGER_ABOUT_MEMORY_LINK));
-  about_memory_link_->set_listener(this);
 
   // Makes sure our state is consistent.
   OnSelectionChanged();
 
   ui::Accelerator ctrl_w(ui::VKEY_W, ui::EF_CONTROL_DOWN);
   AddAccelerator(ctrl_w);
 }
 
 void TaskManagerView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   views::DialogDelegateView::ViewHierarchyChanged(details);
-  // 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.
+  // Since we want the Kill button to show up in the same visual row as the
+  // close button, which is provided by the framework, we must add it 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 that item.
   if (details.child == this) {
     if (details.is_add) {
-      details.parent->AddChildView(about_memory_link_);
       details.parent->AddChildView(kill_button_);
       tab_table_parent_ = tab_table_->CreateParentIfNecessary();
       AddChildView(tab_table_parent_);
     } else {
       details.parent->RemoveChildView(kill_button_);
-      details.parent->RemoveChildView(about_memory_link_);
     }
   }
 }
 
 void TaskManagerView::Layout() {
   gfx::Size size = kill_button_->GetPreferredSize();
   gfx::Rect parent_bounds = parent()->GetContentsBounds();
   const int horizontal_margin = views::kPanelHorizMargin;
   const int vertical_margin = views::kButtonVEdgeMargin;
   int x = width() - size.width() - horizontal_margin;
   int y_buttons = parent_bounds.bottom() - size.height() - vertical_margin;
   kill_button_->SetBounds(x, y_buttons, size.width(), size.height());
 
-  size = about_memory_link_->GetPreferredSize();
-  about_memory_link_->SetBounds(
-      horizontal_margin,
-      y_buttons + (kill_button_->height() - size.height()) / 2,
-      size.width(), size.height());
-
   gfx::Rect rect = GetLocalBounds();
   rect.Inset(horizontal_margin, views::kPanelVertMargin);
   rect.Inset(0, 0, 0,
              kill_button_->height() + views::kUnrelatedControlVerticalSpacing);
   tab_table_parent_->SetBoundsRect(rect);
 }
 
 gfx::Size TaskManagerView::GetPreferredSize() const {
   return gfx::Size(460, 270);
 }
@@ skipping 124 matching lines @@
 
 void TaskManagerView::OnDoubleClick() {
   ActivateFocusedTab();
 }
 
 void TaskManagerView::OnKeyDown(ui::KeyboardCode keycode) {
   if (keycode == ui::VKEY_RETURN)
     ActivateFocusedTab();
 }
 
-void TaskManagerView::LinkClicked(views::Link* source, int event_flags) {
-  DCHECK_EQ(about_memory_link_, source);
-  task_manager_->OpenAboutMemory();
-}
-
 void TaskManagerView::ShowContextMenuForView(views::View* source,
                                              const gfx::Point& point,
                                              ui::MenuSourceType source_type) {
   ui::SimpleMenuModel menu_model(this);
   for (std::vector<ui::TableColumn>::iterator i(columns_.begin());
        i != columns_.end(); ++i) {
     menu_model.AddCheckItem(i->id, l10n_util::GetStringUTF16(i->id));
   }
   menu_runner_.reset(
       new views::MenuRunner(&menu_model, views::MenuRunner::CONTEXT_MENU));
@@ skipping 63 matching lines @@
 void HideTaskManager() {
   if (switches::NewTaskManagerEnabled()) {
     task_management::NewTaskManagerView::Hide();
     return;
   }
 
   TaskManagerView::Hide();
 }
 
 }  // namespace chrome