views: Fix a couple of other trivial TODOs.

views/controls/table/table_view2.cc

-
-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 "views/controls/table/table_view2.h"
 
 #include "base/logging.h"
 #include "ui/base/models/table_model.h"
 #include "views/controls/native/native_view_host.h"
 #include "views/controls/table/table_view_observer.h"
 
-using ui::TableColumn;
-
 namespace views {
 
 // TableView2 ------------------------------------------------------------------
 
-TableView2::TableView2(TableModel* model,
-                       const std::vector<TableColumn>& columns,
+TableView2::TableView2(ui::TableModel* model,
+                       const std::vector<ui::TableColumn>& columns,
                        TableTypes table_type,
                        int options)
     : model_(model),
       table_type_(table_type),
       table_view_observer_(NULL),
       visible_columns_(),
       all_columns_(),
       column_count_(static_cast<int>(columns.size())),
       single_selection_((options & SINGLE_SELECTION) != 0),
       resizable_columns_((options & RESIZABLE_COLUMNS) != 0),
       autosize_columns_((options & AUTOSIZE_COLUMNS) != 0),
       horizontal_lines_((options & HORIZONTAL_LINES) != 0),
       vertical_lines_((options & VERTICAL_LINES) != 0),
       native_wrapper_(NULL) {
   Init(columns);
 }
 
 TableView2::~TableView2() {
   if (model_)
     model_->SetObserver(NULL);
 }
 
-void TableView2::SetModel(TableModel* model) {
+void TableView2::SetModel(ui::TableModel* model) {
   if (model == model_)
     return;
 
   if (model_)
     model_->SetObserver(NULL);
   model_ = model;
   if (model_)
     model_->SetObserver(this);
   if (native_wrapper_)
     OnModelChanged();
@@ skipping 98 matching lines @@
 void TableView2::OnItemsRemoved(int start, int length) {
   if (!native_wrapper_)
     return;
 
   DCHECK(start >= 0 && length >= 0 &&
          start + length <= native_wrapper_->GetRowCount());
 
   native_wrapper_->OnRowsRemoved(start, length);
 }
 
-void TableView2::AddColumn(const TableColumn& col) {
+void TableView2::AddColumn(const ui::TableColumn& col) {
   DCHECK_EQ(0U, all_columns_.count(col.id));
   all_columns_[col.id] = col;
 }
 
-void TableView2::SetColumns(const std::vector<TableColumn>& columns) {
+void TableView2::SetColumns(const std::vector<ui::TableColumn>& columns) {
   // Remove the currently visible columns.
   while (!visible_columns_.empty())
     SetColumnVisibility(visible_columns_.front(), false);
 
   all_columns_.clear();
-  for (std::vector<TableColumn>::const_iterator i = columns.begin();
+  for (std::vector<ui::TableColumn>::const_iterator i = columns.begin();
        i != columns.end(); ++i) {
     AddColumn(*i);
   }
 }
 
 void TableView2::OnColumnsChanged() {
   column_count_ = static_cast<int>(visible_columns_.size());
   ResetColumnSizes();
 }
 
@@ skipping 19 matching lines @@
           native_wrapper_->RemoveColumn(index);
         visible_columns_.erase(i);
         changed = true;
         break;
       }
     }
   }
   if (is_visible) {
     DCHECK(native_wrapper_);
     visible_columns_.push_back(id);
-    TableColumn& column = all_columns_[id];
+    ui::TableColumn& column = all_columns_[id];
     native_wrapper_->InsertColumn(column, column_count_);
     changed = true;
   }
   if (changed)
     OnColumnsChanged();
 
 }
 
 bool TableView2::IsColumnVisible(int id) const {
   for (std::vector<int>::const_iterator i = visible_columns_.begin();
@@ skipping 18 matching lines @@
       width = native_bounds.width();
     }
   }
 
   float percent = 0;
   int fixed_width = 0;
   int autosize_width = 0;
 
   for (std::vector<int>::const_iterator i = visible_columns_.begin();
        i != visible_columns_.end(); ++i) {
-    TableColumn& col = all_columns_[*i];
+    ui::TableColumn& col = all_columns_[*i];
     int col_index = static_cast<int>(i - visible_columns_.begin());
     if (col.width == -1) {
       if (col.percent > 0) {
         percent += col.percent;
       } else {
         autosize_width += col.min_visible_width;
       }
     } else {
       fixed_width += native_wrapper_->GetColumnWidth(col_index);
     }
   }
 
   // Now do a pass to set the actual sizes of auto-sized and
   // percent-sized columns.
   int available_width = width - fixed_width - autosize_width;
   for (std::vector<int>::const_iterator i = visible_columns_.begin();
        i != visible_columns_.end(); ++i) {
-    TableColumn& col = all_columns_[*i];
+    ui::TableColumn& col = all_columns_[*i];
     if (col.width == -1) {
       int col_index = static_cast<int>(i - visible_columns_.begin());
       if (col.percent > 0) {
         if (available_width > 0) {
           int col_width =
             static_cast<int>(available_width * (col.percent / percent));
           available_width -= col_width;
           percent -= col.percent;
           native_wrapper_->SetColumnWidth(col_index, col_width);
         }
@@ skipping 28 matching lines @@
 
 void TableView2::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
   if (is_add && !native_wrapper_ && GetWidget()) {
     // The native wrapper's lifetime will be managed by the view hierarchy after
     // we call AddChildView.
     native_wrapper_ = CreateWrapper();
     AddChildView(native_wrapper_->GetView());
   }
 }
 
-void TableView2::Init(const std::vector<TableColumn>& columns) {
-  for (std::vector<TableColumn>::const_iterator i = columns.begin();
+void TableView2::Init(const std::vector<ui::TableColumn>& columns) {
+  for (std::vector<ui::TableColumn>::const_iterator i = columns.begin();
       i != columns.end(); ++i) {
     AddColumn(*i);
     visible_columns_.push_back(i->id);
   }
 }
 
 gfx::NativeView TableView2::GetTestingHandle() {
   return native_wrapper_->GetTestingHandle();
 }
 
-TableColumn TableView2::GetVisibleColumnAt(int index) {
+ui::TableColumn TableView2::GetVisibleColumnAt(int index) {
   DCHECK(index < static_cast<int>(visible_columns_.size()));
-  std::map<int, TableColumn>::iterator iter =
+  std::map<int, ui::TableColumn>::iterator iter =
       all_columns_.find(index);
   DCHECK(iter != all_columns_.end());
   return iter->second;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeTable2, protected:
 
 NativeTableWrapper* TableView2::CreateWrapper() {
   return NativeTableWrapper::CreateNativeWrapper(this);
 }
 
 }  // namespace views