views: Make view::Views::GetPreferredSize() const.

ui/views/layout/grid_layout.h

 // 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.
 
 #ifndef UI_VIEWS_LAYOUT_GRID_LAYOUT_H_
 #define UI_VIEWS_LAYOUT_GRID_LAYOUT_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 160 matching lines @@
   // Notification that a view has been added.
   virtual void ViewAdded(View* host, View* view) OVERRIDE;
 
   // Notification that a view has been removed.
   virtual void ViewRemoved(View* host, View* view) OVERRIDE;
 
   // Layouts out the components.
   virtual void Layout(View* host) OVERRIDE;
 
   // Returns the preferred size for the GridLayout.
-  virtual gfx::Size GetPreferredSize(View* host) OVERRIDE;
+  virtual gfx::Size GetPreferredSize(const View* host) const OVERRIDE;
 
-  virtual int GetPreferredHeightForWidth(View* host, int width) OVERRIDE;
+  virtual int GetPreferredHeightForWidth(const View* host,
+                                         int width) const OVERRIDE;
 
   void set_minimum_size(const gfx::Size& size) { minimum_size_ = size; }
 
  private:
   // As both Layout and GetPreferredSize need to do nearly the same thing,
   // they both call into this method. This sizes the Columns/Rows as
   // appropriate. If layout is true, width/height give the width/height the
   // of the host, otherwise they are ignored.
-  void SizeRowsAndColumns(bool layout, int width, int height, gfx::Size* pref);
+  void SizeRowsAndColumns(bool layout,
+                          int width,
+                          int height,
+                          gfx::Size* pref) const;
 
   // Calculates the master columns of all the column sets. See Column for
   // a description of what a master column is.
-  void CalculateMasterColumnsIfNecessary();
+  void CalculateMasterColumnsIfNecessary() const;
 
   // This is called internally from AddView. It adds the ViewState to the
   // appropriate structures, and updates internal fields such as next_column_.
   void AddViewState(ViewState* view_state);
 
   // Adds the Row to rows_, as well as updating next_column_,
   // current_row_col_set ...
   void AddRow(Row* row);
 
   // As the name says, updates the remaining_height of the ViewState for
   // all Rows the supplied ViewState touches.
-  void UpdateRemainingHeightFromRows(ViewState* state);
+  void UpdateRemainingHeightFromRows(ViewState* state) const;
 
   // If the view state's remaining height is > 0, it is distributed among
   // the rows the view state touches. This is used during layout to make
   // sure the Rows can accommodate a view.
-  void DistributeRemainingHeight(ViewState* state);
+  void DistributeRemainingHeight(ViewState* state) const;
 
   // Advances next_column_ past any padding columns.
   void SkipPaddingColumns();
 
   // Returns the column set of the last non-padding row.
   ColumnSet* GetLastValidColumnSet();
 
   // The view we were created with. We don't own this.
   View* const host_;
 
   // Whether or not we've calculated the master/linked columns.
-  bool calculated_master_columns_;
+  mutable bool calculated_master_columns_;
 
   // Used to verify a view isn't added with a row span that expands into
   // another column structure.
   int remaining_row_span_;
 
   // Current row.
   int current_row_;
 
   // Current column.
   int next_column_;
 
   // Column set for the current row. This is null for padding rows.
   ColumnSet* current_row_col_set_;
 
   // Insets.
   gfx::Insets insets_;
 
   // Set to true when adding a View.
   bool adding_view_;
 
   // ViewStates. This is ordered by row_span in ascending order.
-  std::vector<ViewState*> view_states_;
+  mutable std::vector<ViewState*> view_states_;
 
   // ColumnSets.
-  std::vector<ColumnSet*> column_sets_;
+  mutable std::vector<ColumnSet*> column_sets_;
 
   // Rows.
-  std::vector<Row*> rows_;
+  mutable std::vector<Row*> rows_;
 
   // Minimum preferred size.
   gfx::Size minimum_size_;
 
   DISALLOW_COPY_AND_ASSIGN(GridLayout);
 };
 
 // ColumnSet is used to define a set of columns. GridLayout may have any
 // number of ColumnSets. You don't create a ColumnSet directly, instead
 // use the AddColumnSet method of GridLayout.
@@ skipping 99 matching lines @@
   // The master column of those columns that are linked. See Column
   // for a description of what the master column is.
   std::vector<Column*> master_columns_;
 
   DISALLOW_COPY_AND_ASSIGN(ColumnSet);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_LAYOUT_GRID_LAYOUT_H_