Implement new task manager mocks on windows.

chrome/browser/ui/views/task_manager_view.cc

 // Copyright (c) 2010 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 "app/l10n_util.h"
 #include "app/table_model_observer.h"
 #include "base/command_line.h"
 #include "base/metrics/stats_table.h"
@@ skipping 19 matching lines @@
 #include "views/controls/table/table_view_observer.h"
 #include "views/standard_layout.h"
 #include "views/widget/widget.h"
 #include "views/window/dialog_delegate.h"
 #include "views/window/window.h"
 
 // The task manager window default size.
 static const int kDefaultWidth = 460;
 static const int kDefaultHeight = 270;
 
+// The group IDs used to separate background pages from foreground tabs.
+static const int kBackgroundGroupId = 0;
+static const int kForegroundGroupId = 1;
+
 namespace {
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerTableModel class
 ////////////////////////////////////////////////////////////////////////////////
 
 class TaskManagerTableModel : public views::GroupTableModel,
                               public TaskManagerModelObserver {
  public:
   explicit TaskManagerTableModel(TaskManagerModel* model)
       : model_(model),
         observer_(NULL) {
     model_->AddObserver(this);
   }
 
   ~TaskManagerTableModel() {
     model_->RemoveObserver(this);
   }
 
   // GroupTableModel.
   int RowCount();
   std::wstring GetText(int row, int column);
   SkBitmap GetIcon(int row);
+  bool ShouldIndent(int row);
   void GetGroupRangeForItem(int item, views::GroupRange* range);
   void SetObserver(TableModelObserver* observer);
   virtual int CompareValues(int row1, int row2, int column_id);
+  virtual Groups GetGroups();
+  virtual bool HasGroups();
+  virtual int GetGroupID(int row);
 
   // 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);
 
  private:
   TaskManagerModel* model_;
   TableModelObserver* observer_;
@@ skipping 67 matching lines @@
     default:
       NOTREACHED();
       return std::wstring();
   }
 }
 
 SkBitmap TaskManagerTableModel::GetIcon(int row) {
   return model_->GetResourceIcon(row);
 }
 
+bool TaskManagerTableModel::ShouldIndent(int row) {
+  return !model_->IsResourceFirstInGroup(row);
+}
+
 void TaskManagerTableModel::GetGroupRangeForItem(int item,
                                                  views::GroupRange* range) {
   std::pair<int, int> range_pair = model_->GetGroupRangeForResource(item);
   range->start = range_pair.first;
   range->length = range_pair.second;
 }
 
 void TaskManagerTableModel::SetObserver(TableModelObserver* observer) {
   observer_ = observer;
 }
 
 int TaskManagerTableModel::CompareValues(int row1, int row2, int column_id) {
   return model_->CompareValues(row1, row2, column_id);
 }
 
+bool TaskManagerTableModel::HasGroups() {
+  return true;
+}
+
+int TaskManagerTableModel::GetGroupID(int row) {
+  // If there are any background resources in the group range, put the whole
+  // range in the background group.
+  std::pair<int, int> range_pair = model_->GetGroupRangeForResource(row);
+  for (int i = range_pair.first;
+       i < range_pair.first + range_pair.second;
+       ++i) {
+    if (model_->IsBackgroundResource(i))
+      return kBackgroundGroupId;
+  }
+  return kForegroundGroupId;
+}
+
+TableModel::Groups TaskManagerTableModel::GetGroups() {
+  Groups groups;
+
+  Group background_group;
+  background_group.title =
+      l10n_util::GetString(IDS_TASK_MANAGER_BACKGROUND_SEPARATOR);
+  background_group.id = kBackgroundGroupId;
+  groups.push_back(background_group);
+
+  Group foreground_group;
+  foreground_group.title =
+      l10n_util::GetString(IDS_TASK_MANAGER_FOREGROUND_SEPARATOR);
+  foreground_group.id = kForegroundGroupId;
+  groups.push_back(foreground_group);
+
+  return groups;
+}
+
 void TaskManagerTableModel::OnModelChanged() {
   if (observer_)
     observer_->OnModelChanged();
 }
 
 void TaskManagerTableModel::OnItemsChanged(int start, int length) {
   if (observer_)
     observer_->OnItemsChanged(start, length);
 }
 
 void TaskManagerTableModel::OnItemsAdded(int start, int length) {
   if (observer_)
     observer_->OnItemsAdded(start, length);
+  // There's a bug in the Windows ListView where inserting items with groups
+  // enabled puts them in the wrong position, so we just rebuild the list view
+  // in this case.
+  // (see: http://connect.microsoft.com/VisualStudio/feedback/details/115345/)
+  OnModelChanged();
 }
 
 void TaskManagerTableModel::OnItemsRemoved(int start, int length) {
   if (observer_)
     observer_->OnItemsRemoved(start, length);
 }
 
 // The Task manager UI container.
 class TaskManagerView : public views::View,
                         public views::ButtonListener,
@@ skipping 103 matching lines @@
 }
 
 TaskManagerView::~TaskManagerView() {
   // Delete child views now, while our table model still exists.
   RemoveAllChildViews(true);
 }
 
 void TaskManagerView::Init() {
   table_model_.reset(new TaskManagerTableModel(model_));
 
-  columns_.push_back(TableColumn(IDS_TASK_MANAGER_PAGE_COLUMN,
+  // Page column has no header label.
+  columns_.push_back(TableColumn(IDS_TASK_MANAGER_PAGE_COLUMN, L"",
                                  TableColumn::LEFT, -1, 1));
   columns_.back().sortable = true;
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN,
                                  TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_SHARED_MEM_COLUMN,
                                  TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN,
                                  TableColumn::RIGHT, -1, 0));
@@ skipping 19 matching lines @@
   columns_.push_back(TableColumn(IDS_TASK_MANAGER_SQLITE_MEMORY_USED_COLUMN,
                                  TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
   columns_.push_back(
       TableColumn(IDS_TASK_MANAGER_JAVASCRIPT_MEMORY_ALLOCATED_COLUMN,
                   TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
 
   tab_table_ = new views::GroupTableView(table_model_.get(), columns_,
                                          views::ICON_AND_TEXT, false, true,
-                                         true);
+                                         true, false);
 
   // Hide some columns by default
   tab_table_->SetColumnVisibility(IDS_TASK_MANAGER_PROCESS_ID_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 327 matching lines @@
 }  // namespace
 
 namespace browser {
 
 // Declared in browser_dialogs.h so others don't need to depend on our header.
 void ShowTaskManager() {
   TaskManagerView::Show();
 }
 
 }  // namespace browser