Remove "View Background Pages".

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/prefs/pref_service.h"
@@ skipping 11 matching lines @@
 #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.h"
 #include "ui/base/models/table_model_observer.h"
 #include "ui/gfx/canvas.h"
-#include "ui/views/background.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/controls/table/table_view_row_background_painter.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/wm/window_util.h"
 #endif
 
 #if defined(OS_WIN)
 #include "win8/util/win8_util.h"
 #endif
 
-// Yellow highlight used when highlighting background resources.
-static const SkColor kBackgroundResourceHighlight =
-    SkColorSetRGB(0xff, 0xf1, 0xcd);
-
 namespace {
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerTableModel class
 ////////////////////////////////////////////////////////////////////////////////
 
 class TaskManagerTableModel
     : public ui::TableModel,
       public views::TableGrouper,
       public TaskManagerModelObserver {
@@ skipping 18 matching lines @@
   // TableGrouper overrides:
   virtual void GetGroupRange(int model_index,
                              views::GroupRange* range) OVERRIDE;
 
   // TaskManagerModelObserver overrides:
   virtual void OnModelChanged() OVERRIDE;
   virtual void OnItemsChanged(int start, int length) OVERRIDE;
   virtual void OnItemsAdded(int start, int length) OVERRIDE;
   virtual void OnItemsRemoved(int start, int length) OVERRIDE;
 
-  // 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();
 }
@@ skipping 54 matching lines @@
 
 void TaskManagerTableModel::OnItemsRemoved(int start, int length) {
   if (observer_)
     observer_->OnItemsRemoved(start, length);
 
   // We may need to change the indentation of some items if the topmost item
   // in the group was removed, so update the view.
   OnModelChanged();
 }
 
-bool TaskManagerTableModel::IsBackgroundResource(int row) {
-  return model_->IsBackgroundResource(row);
-}
-
-class BackgroundPainter : public views::TableViewRowBackgroundPainter {
- public:
-  explicit BackgroundPainter(TaskManagerTableModel* model) : model_(model) {}
-  virtual ~BackgroundPainter() {}
-
-  virtual void PaintRowBackground(int model_index,
-                                  const gfx::Rect& row_bounds,
-                                  gfx::Canvas* canvas) OVERRIDE {
-    if (model_->IsBackgroundResource(model_index))
-      canvas->FillRect(row_bounds, kBackgroundResourceHighlight);
-  }
-
- private:
-  TaskManagerTableModel* model_;
-
-  DISALLOW_COPY_AND_ASSIGN(BackgroundPainter);
-};
-
 // 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(bool highlight_background_resources,
-                  chrome::HostDesktopType desktop_type);
+  explicit TaskManagerView(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, Browser* browser);
+  // Shows the Task manager window, or re-activates an existing one.
+  static void Show(Browser* browser);
 
   // views::View:
   virtual void Layout() OVERRIDE;
   virtual gfx::Size GetPreferredSize() OVERRIDE;
   virtual void ViewHierarchyChanged(
       const ViewHierarchyChangedDetails& details) OVERRIDE;
 
   // views::ButtonListener:
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE;
@@ skipping 60 matching lines @@
   TaskManagerModel* model_;
 
   // all possible columns, not necessarily visible
   std::vector<ui::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_;
 
-  // True when the Task Manager should highlight background resources.
-  const bool highlight_background_resources_;
-
   // 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)
+TaskManagerView::TaskManagerView(chrome::HostDesktopType desktop_type)
     : purge_memory_button_(NULL),
       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),
-      highlight_background_resources_(highlight_background_resources),
       desktop_type_(desktop_type) {
   Init();
 }
 
 TaskManagerView::~TaskManagerView() {
   // Delete child views now, while our table model still exists.
   RemoveAllChildViews(true);
 }
 
 void TaskManagerView::Init() {
@@ skipping 53 matching lines @@
                                      ui::TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
   columns_.push_back(
       ui::TableColumn(IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN,
                       ui::TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
 
   tab_table_ = new views::TableView(
       table_model_.get(), columns_, views::ICON_AND_TEXT, false);
   tab_table_->SetGrouper(table_model_.get());
-  if (highlight_background_resources_) {
-    scoped_ptr<BackgroundPainter> painter(
-        new BackgroundPainter(table_model_.get()));
-    tab_table_->SetRowBackgroundPainter(
-        painter.PassAs<views::TableViewRowBackgroundPainter>());
-  }
 
   // Hide some columns by default
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_PROFILE_NAME_COLUMN, false);
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_SHARED_MEM_COLUMN, false);
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN, false);
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_WEBCORE_IMAGE_CACHE_COLUMN,
                                   false);
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_WEBCORE_SCRIPTS_CACHE_COLUMN,
                                   false);
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_WEBCORE_CSS_CACHE_COLUMN,
@@ skipping 109 matching lines @@
   rect.Inset(0, 0, 0,
              kill_button_->height() + views::kUnrelatedControlVerticalSpacing);
   tab_table_parent_->SetBoundsRect(rect);
 }
 
 gfx::Size TaskManagerView::GetPreferredSize() {
   return gfx::Size(460, 270);
 }
 
 // static
-void TaskManagerView::Show(bool highlight_background_resources,
-                           Browser* browser) {
+void TaskManagerView::Show(Browser* browser) {
 #if defined(OS_WIN)
   // In Windows Metro it's not good to open this native window.
   DCHECK(!win8::IsSingleWindowMetroMode());
 #endif
   // In ash we can come here through the ChromeShellDelegate. If there is no
   // browser window at that time of the call, browser could be passed as NULL.
   const chrome::HostDesktopType desktop_type =
       browser ? browser->host_desktop_type() : chrome::HOST_DESKTOP_TYPE_ASH;
 
   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;
-    }
+    // 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(desktop_type);
   gfx::NativeWindow window =
       browser ? browser->window()->GetNativeWindow() : NULL;
 #if defined(USE_ASH)
   if (!window)
     window = ash::wm::GetActiveWindow();
 #endif
   DialogDelegate::CreateDialogWidget(instance_, window, NULL);
   instance_->InitAlwaysOnTopState();
   instance_->model_->StartUpdating();
   instance_->GetWidget()->Show();
@@ skipping 207 matching lines @@
       g_browser_process->local_state()->GetDictionary(GetWindowName().c_str());
   return dictionary &&
       dictionary->GetBoolean("always_on_top", always_on_top) && always_on_top;
 }
 
 }  // namespace
 
 namespace chrome {
 
 // Declared in browser_dialogs.h so others don't need to depend on our header.
-void ShowTaskManager(Browser* browser, bool highlight_background_resources) {
-  TaskManagerView::Show(highlight_background_resources, browser);
+void ShowTaskManager(Browser* browser) {
+  TaskManagerView::Show(browser);
 }
 
 }  // namespace chrome