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

ui/views/layout/box_layout.cc

 // 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.
 
 #include "ui/views/layout/box_layout.h"
 
 #include "ui/gfx/rect.h"
 #include "ui/views/view.h"
 
 namespace views {
@@ skipping 80 matching lines @@
         if (bounds.height() > 0)
           y += bounds.height() + between_child_spacing_;
       }
       // Clamp child view bounds to |child_area|.
       bounds.Intersect(child_area);
       child->SetBoundsRect(bounds);
     }
   }
 }
 
-gfx::Size BoxLayout::GetPreferredSize(View* host) {
+gfx::Size BoxLayout::GetPreferredSize(const View* host) const {
   // Calculate the child views' preferred width.
   int width = 0;
   if (orientation_ == kVertical) {
     for (int i = 0; i < host->child_count(); ++i) {
-      View* child = host->child_at(i);
+      const View* child = host->child_at(i);
       if (!child->visible())
         continue;
 
       width = std::max(width, child->GetPreferredSize().width());
     }
   }
 
   return GetPreferredSizeForChildWidth(host, width);
 }
 
-int BoxLayout::GetPreferredHeightForWidth(View* host, int width) {
+int BoxLayout::GetPreferredHeightForWidth(const View* host, int width) const {
   int child_width = width - NonChildSize(host).width();
   return GetPreferredSizeForChildWidth(host, child_width).height();
 }
 
 int BoxLayout::MainAxisSize(const gfx::Rect& child_area) const {
   return orientation_ == kHorizontal ? child_area.width() : child_area.height();
 }
 
 int BoxLayout::MainAxisPosition(const gfx::Rect& child_area) const {
   return orientation_ == kHorizontal ? child_area.x() : child_area.y();
 }
 
 void BoxLayout::SetMainAxisSize(int size, gfx::Rect* child_area) const {
   if (orientation_ == kHorizontal)
     child_area->set_width(size);
   else
     child_area->set_height(size);
 }
 
 void BoxLayout::SetMainAxisPosition(int position, gfx::Rect* child_area) const {
   if (orientation_ == kHorizontal)
     child_area->set_x(position);
   else
     child_area->set_y(position);
 }
 
-gfx::Size BoxLayout::GetPreferredSizeForChildWidth(View* host,
-                                                   int child_area_width) {
+gfx::Size BoxLayout::GetPreferredSizeForChildWidth(const View* host,
+                                                   int child_area_width) const {
   gfx::Rect child_area_bounds;
 
   if (orientation_ == kHorizontal) {
     // Horizontal layouts ignore |child_area_width|, meaning they mimic the
     // default behavior of GridLayout::GetPreferredHeightForWidth().
     // TODO(estade): fix this if it ever becomes a problem.
     int position = 0;
     for (int i = 0; i < host->child_count(); ++i) {
-      View* child = host->child_at(i);
+      const View* child = host->child_at(i);
       if (!child->visible())
         continue;
 
       gfx::Size size(child->GetPreferredSize());
       if (size.IsEmpty())
         continue;
 
       gfx::Rect child_bounds(position, 0, size.width(), size.height());
       child_area_bounds.Union(child_bounds);
       position += size.width() + between_child_spacing_;
     }
   } else {
     int height = 0;
     for (int i = 0; i < host->child_count(); ++i) {
-      View* child = host->child_at(i);
+      const View* child = host->child_at(i);
       if (!child->visible())
         continue;
 
       int extra_height = child->GetHeightForWidth(child_area_width);
       // Only add |between_child_spacing_| if this is not the only child.
       if (height != 0 && extra_height > 0)
         height += between_child_spacing_;
       height += extra_height;
     }
 
     child_area_bounds.set_width(child_area_width);
     child_area_bounds.set_height(height);
   }
 
   gfx::Size non_child_size = NonChildSize(host);
   return gfx::Size(child_area_bounds.width() + non_child_size.width(),
                    child_area_bounds.height() + non_child_size.height());
 }
 
-gfx::Size BoxLayout::NonChildSize(View* host) {
+gfx::Size BoxLayout::NonChildSize(const View* host) const {
   gfx::Insets insets(host->GetInsets());
   return gfx::Size(insets.width() + inside_border_insets_.width(),
                    insets.height() + inside_border_insets_.height());
 }
 
 } // namespace views