views: Fix a couple of other trivial TODOs.

views/controls/table/table_view.h

 // 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.
 
 #ifndef VIEWS_CONTROLS_TABLE_TABLE_VIEW_H_
 #define VIEWS_CONTROLS_TABLE_TABLE_VIEW_H_
 #pragma once
 
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-typedef struct tagNMLVCUSTOMDRAW NMLVCUSTOMDRAW;
-#endif  // defined(OS_WIN)
-
 #include <map>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
+#include "build/build_config.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/models/table_model_observer.h"
 #include "views/views_export.h"
 
 #if defined(OS_WIN)
+#include <windows.h>
+
 // TODO(port): remove the ifdef when native_control.h is ported.
 #include "views/controls/native_control.h"
+
+typedef struct tagNMLVCUSTOMDRAW NMLVCUSTOMDRAW;
 #endif  // defined(OS_WIN)
 
 class SkBitmap;
 
+namespace gfx {
+class Font;
+}
+
 namespace ui {
 struct TableColumn;
 class TableModel;
 }
-using ui::TableColumn;
-using ui::TableModel;
-using ui::TableModelObserver; // TODO(beng): remove these.
-
-namespace gfx {
-class Font;
-}
 
 // A TableView is a view that displays multiple rows with any number of columns.
 // TableView is driven by a TableModel. The model returns the contents
 // to display. TableModel also has an Observer which is used to notify
 // TableView of changes to the model so that the display may be updated
 // appropriately.
 //
 // TableView itself has an observer that is notified when the selection
 // changes.
 //
@@ skipping 44 matching lines @@
   int view_index_;
 
   // The index in terms of the model. This is returned from the * operator. This
   // is cached to avoid dependencies on the view_to_model mapping.
   int model_index_;
 };
 
 #if defined(OS_WIN)
 // TODO(port): Port TableView.
 class VIEWS_EXPORT TableView : public NativeControl,
-                               public TableModelObserver {
+                               public ui::TableModelObserver {
  public:
   typedef TableSelectionIterator iterator;
 
   // A helper struct for GetCellColors. Set |color_is_set| to true if color is
   // set.  See OnCustomDraw for more details on why we need this.
   struct ItemColor {
     bool color_is_set;
     SkColor color;
   };
 
@@ skipping 20 matching lines @@
   // false, columns are not resized when the table is resized. An extra empty
   // column at the right fills the remaining space.
   // When resizable_columns is true, users can resize columns by dragging the
   // separator on the column header.  NOTE: Right now this is always true.  The
   // code to set it false is still in place to be a base for future, better
   // resizing behavior (see http://b/issue?id=874646 ), but no one uses or
   // tests the case where this flag is false.
   // Note that setting both resizable_columns and autosize_columns to false is
   // probably not a good idea, as there is no way for the user to increase a
   // column's size in that case.
-  TableView(TableModel* model, const std::vector<TableColumn>& columns,
+  TableView(ui::TableModel* model, const std::vector<ui::TableColumn>& columns,
             TableTypes table_type, bool single_selection,
             bool resizable_columns, bool autosize_columns);
   virtual ~TableView();
 
   // Assigns a new model to the table view, detaching the old one if present.
   // If |model| is NULL, the table view cannot be used after this call. This
   // should be called in the containing view's destructor to avoid destruction
   // issues when the model needs to be deleted before the table.
-  void SetModel(TableModel* model);
-  TableModel* model() const { return model_; }
+  void SetModel(ui::TableModel* model);
+  ui::TableModel* model() const { return model_; }
 
   // Resorts the contents.
   void SetSortDescriptors(const SortDescriptors& sort_descriptors);
 
   // Current sort.
   const SortDescriptors& sort_descriptors() const { return sort_descriptors_; }
 
   // Returns the number of rows in the TableView.
   int RowCount() const;
 
@@ skipping 21 matching lines @@
   bool ItemHasTheFocus(int model_row);
 
   // Returns an iterator over the selection. The iterator proceeds from the
   // last index to the first.
   //
   // NOTE: the iterator iterates over the visual order (but returns coordinates
   // in terms of the model).
   iterator SelectionBegin();
   iterator SelectionEnd();
 
-  // TableModelObserver methods.
+  // ui::TableModelObserver methods.
   virtual void OnModelChanged();
   virtual void OnItemsChanged(int start, int length);
   virtual void OnItemsAdded(int start, int length);
   virtual void OnItemsRemoved(int start, int length);
 
   void SetObserver(TableViewObserver* observer) {
     table_view_observer_ = observer;
   }
   TableViewObserver* observer() const { return table_view_observer_; }
 
   // Replaces the set of known columns without changing the current visible
   // columns.
-  void SetColumns(const std::vector<TableColumn>& columns);
-  void AddColumn(const TableColumn& col);
+  void SetColumns(const std::vector<ui::TableColumn>& columns);
+  void AddColumn(const ui::TableColumn& col);
   bool HasColumn(int id);
 
   // Sets which columns (by id) are displayed.  All transient size and position
   // information is lost.
   void SetVisibleColumns(const std::vector<int>& columns);
   void SetColumnVisibility(int id, bool is_visible);
   bool IsColumnVisible(int id) const;
 
   // Resets the size of the columns based on the sizes passed to the
   // constructor. Your normally needn't invoked this, it's done for you the
@@ skipping 142 matching lines @@
   // Method invoked by ListView when sorting back to natural state. Returns
   // model_index_1_p - model_index_2_p.
   static int CALLBACK NaturalSortFunc(LPARAM model_index_1_p,
                                       LPARAM model_index_2_p,
                                       LPARAM table_view_param);
 
   // Resets the sort image displayed for the specified column.
   void ResetColumnSortImage(int column_id, SortDirection direction);
 
   // Adds a new column.
-  void InsertColumn(const TableColumn& tc, int index);
+  void InsertColumn(const ui::TableColumn& tc, int index);
 
   // Update headers and internal state after columns have changed
   void OnColumnsChanged();
 
   // Updates the ListView with values from the model. See UpdateListViewCache0
   // for a complete description.
   // This turns off redrawing, and invokes UpdateListViewCache0 to do the
   // actual updating.
   void UpdateListViewCache(int start, int length, bool add);
 
   // Updates ListView with values from the model.
   // If add is true, this adds length items starting at index start.
   // If add is not true, the items are not added, the but the values in the
   // range start - [start + length] are updated from the model.
   void UpdateListViewCache0(int start, int length, bool add);
 
   // Returns the index of the selected item before |view_index|, or -1 if
   // |view_index| is the first selected item.
   //
   // WARNING: this returns coordinates in terms of the view, NOT the model.
   int PreviousSelectedViewIndex(int view_index);
 
   // Returns the last selected view index in the table view, or -1 if the table
   // is empty, or nothing is selected.
   //
   // WARNING: this returns coordinates in terms of the view, NOT the model.
   int LastSelectedViewIndex();
 
   // The TableColumn visible at position pos.
-  const TableColumn& GetColumnAtPosition(int pos);
+  const ui::TableColumn& GetColumnAtPosition(int pos);
 
   // Window procedure of the list view class. We subclass the list view to
   // ignore WM_ERASEBKGND, which gives smoother painting during resizing.
   static LRESULT CALLBACK TableWndProc(HWND window,
                                        UINT message,
                                        WPARAM w_param,
                                        LPARAM l_param);
 
   // Window procedure of the header class. We subclass the header of the table
   // to disable resizing of columns.
   static LRESULT CALLBACK TableHeaderWndProc(HWND window, UINT message,
                                              WPARAM w_param, LPARAM l_param);
 
   // Updates content_offset_ from the position of the header.
   void UpdateContentOffset();
 
   // Reloads the groups from the model if there is one and it has groups.
   void UpdateGroups();
 
   // Returns the bounds of the alt text.
   gfx::Rect GetAltTextBounds();
 
   // Returns the font used for alt text.
   gfx::Font GetAltTextFont();
 
   // Overriden in order to update the column sizes, which can only be sized
   // accurately when the native control is available.
   virtual void VisibilityChanged(View* starting_from, bool is_visible);
 
-  TableModel* model_;
+  ui::TableModel* model_;
   TableTypes table_type_;
   TableViewObserver* table_view_observer_;
 
-  // An ordered list of id's into all_columns_ representing current visible
+  // An ordered list of id's into |all_columns_| representing current visible
   // columns.
   std::vector<int> visible_columns_;
 
   // Mapping of an int id to a TableColumn representing all possible columns.
-  std::map<int, TableColumn> all_columns_;
+  std::map<int, ui::TableColumn> all_columns_;
 
   // Cached value of columns_.size()
   int column_count_;
 
   // Selection mode.
   bool single_selection_;
 
   // If true, any events that would normally be propagated to the observer
   // are ignored. For example, if this is true and the selection changes in
   // the listview, the observer is not notified.
@@ skipping 43 matching lines @@
 
   string16 alt_text_;
 
   DISALLOW_COPY_AND_ASSIGN(TableView);
 };
 #endif  // defined(OS_WIN)
 
 }  // namespace views
 
 #endif  // VIEWS_CONTROLS_TABLE_TABLE_VIEW_H_