Move TableModel out of views/ and into app/....

chrome/browser/task_manager_win.cc

 // Copyright (c) 2009 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.h"
 
 #include "app/l10n_util.h"
+#include "app/table_model_observer.h"
 #include "base/stats_table.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/accelerator.h"
 #include "views/background.h"
 #include "views/controls/button/native_button.h"
 #include "views/controls/link.h"
 #include "views/controls/menu/menu.h"
 #include "views/controls/table/group_table_view.h"
-#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;
 
 // An id for the most important column, made sufficiently large so as not to
@@ skipping 17 matching lines @@
         observer_(NULL) {
     model->SetObserver(this);
   }
   ~TaskManagerTableModel() {}
 
   // GroupTableModel.
   int RowCount();
   std::wstring GetText(int row, int column);
   SkBitmap GetIcon(int row);
   void GetGroupRangeForItem(int item, views::GroupRange* range);
-  void SetObserver(views::TableModelObserver* observer);
+  void SetObserver(TableModelObserver* observer);
   virtual int CompareValues(int row1, int row2, int column_id);
 
   // 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:
   const TaskManagerModel* model_;
-  views::TableModelObserver* observer_;
+  TableModelObserver* observer_;
 };
 
 int TaskManagerTableModel::RowCount() {
   return model_->ResourceCount();
 }
 
 std::wstring TaskManagerTableModel::GetText(int row, int col_id) {
   switch (col_id) {
     case IDS_TASK_MANAGER_PAGE_COLUMN:  // Process
       return model_->GetResourceTitle(row);
@@ skipping 38 matching lines @@
   return model_->GetResourceIcon(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(views::TableModelObserver* observer) {
+void TaskManagerTableModel::SetObserver(TableModelObserver* observer) {
   observer_ = observer;
 }
 
 int TaskManagerTableModel::CompareValues(int row1, int row2, int column_id) {
   return model_->CompareValues(row1, row2, column_id);
 }
 
 void TaskManagerTableModel::OnModelChanged() {
   if (observer_)
     observer_->OnModelChanged();
@@ skipping 93 matching lines @@
 
   views::NativeButton* kill_button_;
   views::Link* about_memory_link_;
   views::GroupTableView* tab_table_;
 
   TaskManager* task_manager_;
 
   TaskManagerModel* model_;
 
   // all possible columns, not necessarily visible
-  std::vector<views::TableColumn> columns_;
+  std::vector<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_;
 
   // We need to own the text of the menu, the Windows API does not copy it.
   std::wstring always_on_top_menu_text_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerViewImpl);
@@ skipping 12 matching lines @@
   RemoveAllChildViews(true);
 
   // Prevent the table from accessing the model as part of its destruction, as
   // the model might already be destroyed.
   tab_table_->SetModel(NULL);
 }
 
 void TaskManagerViewImpl::Init() {
   table_model_.reset(new TaskManagerTableModel(model_));
 
-  columns_.push_back(views::TableColumn(IDS_TASK_MANAGER_PAGE_COLUMN,
-                                        views::TableColumn::LEFT, -1, 1));
+  columns_.push_back(TableColumn(IDS_TASK_MANAGER_PAGE_COLUMN,
+                                 TableColumn::LEFT, -1, 1));
   columns_.back().sortable = true;
-  columns_.push_back(views::TableColumn(IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN,
-                                        views::TableColumn::RIGHT, -1, 0));
+  columns_.push_back(TableColumn(IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN,
+                                 TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
-  columns_.push_back(views::TableColumn(IDS_TASK_MANAGER_SHARED_MEM_COLUMN,
-                                        views::TableColumn::RIGHT, -1, 0));
+  columns_.push_back(TableColumn(IDS_TASK_MANAGER_SHARED_MEM_COLUMN,
+                                 TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
-  columns_.push_back(views::TableColumn(IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN,
-                                        views::TableColumn::RIGHT, -1, 0));
+  columns_.push_back(TableColumn(IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN,
+                                 TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
-  columns_.push_back(views::TableColumn(IDS_TASK_MANAGER_CPU_COLUMN,
-                                        views::TableColumn::RIGHT, -1, 0));
+  columns_.push_back(TableColumn(IDS_TASK_MANAGER_CPU_COLUMN,
+                                 TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
-  columns_.push_back(views::TableColumn(IDS_TASK_MANAGER_NET_COLUMN,
-                                        views::TableColumn::RIGHT, -1, 0));
+  columns_.push_back(TableColumn(IDS_TASK_MANAGER_NET_COLUMN,
+                                 TableColumn::RIGHT, -1, 0));
   columns_.back().sortable = true;
-  columns_.push_back(views::TableColumn(IDS_TASK_MANAGER_PROCESS_ID_COLUMN,
-                                        views::TableColumn::RIGHT, -1, 0));
+  columns_.push_back(TableColumn(IDS_TASK_MANAGER_PROCESS_ID_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);
   tab_table_->SetParentOwned(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);
 
   UpdateStatsCounters();
-  views::TableColumn col(kGoatsTeleportedColumn, L"Goats Teleported",
-                         views::TableColumn::RIGHT, -1, 0);
+  TableColumn col(kGoatsTeleportedColumn, L"Goats Teleported",
+                  TableColumn::RIGHT, -1, 0);
   col.sortable = true;
   columns_.push_back(col);
   tab_table_->AddColumn(col);
   tab_table_->SetObserver(this);
   SetContextMenuController(this);
   kill_button_ = new views::NativeButton(
       this, l10n_util::GetString(IDS_TASK_MANAGER_KILL));
   kill_button_->AddAccelerator(views::Accelerator('E', false, false, false));
   kill_button_->SetAccessibleKeyboardShortcut(L"E");
   about_memory_link_ = new views::Link(
@@ skipping 10 matching lines @@
     int max = stats->GetMaxCounters();
     // skip the first row (it's header data)
     for (int i = 1; i < max; i++) {
       const char* row = stats->GetRowName(i);
       if (row != NULL && row[0] != '\0' && !tab_table_->HasColumn(i)) {
         // TODO(erikkay): Use l10n to get display names for stats.  Right
         // now we're just displaying the internal counter name.  Perhaps
         // stat names not in the string table would be filtered out.
         // TODO(erikkay): Width is hard-coded right now, so many column
         // names are clipped.
-        views::TableColumn col(i, ASCIIToWide(row), views::TableColumn::RIGHT,
-                               90, 0);
+        TableColumn col(i, ASCIIToWide(row), TableColumn::RIGHT, 90, 0);
         col.sortable = true;
         columns_.push_back(col);
         tab_table_->AddColumn(col);
       }
     }
   }
 }
 
 void TaskManagerViewImpl::ViewHierarchyChanged(bool is_add,
                                                views::View* parent,
@@ skipping 199 matching lines @@
   browser->window()->Show();
 }
 
 void TaskManagerViewImpl::ShowContextMenu(views::View* source,
                                           int x,
                                           int y,
                                           bool is_mouse_gesture) {
   UpdateStatsCounters();
   scoped_ptr<views::Menu> menu(views::Menu::Create(
       this, views::Menu::TOPLEFT, source->GetWidget()->GetNativeView()));
-  for (std::vector<views::TableColumn>::iterator i =
+  for (std::vector<TableColumn>::iterator i =
        columns_.begin(); i != columns_.end(); ++i) {
     menu->AppendMenuItem(i->id, i->title, views::Menu::CHECKBOX);
   }
   menu->RunMenuAt(x, y);
 }
 
 bool TaskManagerViewImpl::IsItemChecked(int id) const {
   return tab_table_->IsColumnVisible(id);
 }
 
@@ skipping 48 matching lines @@
   return dictionary &&
       dictionary->GetBoolean(L"always_on_top", always_on_top) && always_on_top;
 }
 
 }  // namespace
 
 void TaskManager::CreateView() {
   DCHECK(!view_);
   view_ = new TaskManagerViewImpl(this, model_.get());
 }