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

ash/shelf/shelf_view.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 "ash/shelf/shelf_view.h"
 
 #include <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
@@ skipping 684 matching lines @@
     // To track the dragging of |drag_view_| continuously, its visibility
     // should be always true regardless of its position.
     if (dragged_off_from_overflow_to_shelf_ &&
         view_model_->view_at(i) == drag_view_)
       view_model_->view_at(i)->SetVisible(true);
     else
       view_model_->view_at(i)->SetVisible(visible);
   }
 }
 
-void ShelfView::CalculateIdealBounds(IdealBounds* bounds) {
+void ShelfView::CalculateIdealBounds(IdealBounds* bounds) const {
   int available_size = layout_manager_->PrimaryAxisValue(width(), height());
   DCHECK(model_->item_count() == view_model_->view_size());
   if (!available_size)
     return;
 
   int first_panel_index = model_->FirstPanelIndex();
   int last_button_index = first_panel_index - 1;
 
   int x = 0;
   int y = 0;
   int button_size = kShelfButtonSize;
   int button_spacing = kShelfButtonSpacing;
 
   int w = layout_manager_->PrimaryAxisValue(button_size, width());
   int h = layout_manager_->PrimaryAxisValue(height(), button_size);
   for (int i = 0; i < view_model_->view_size(); ++i) {
     if (i < first_visible_index_) {
       view_model_->set_ideal_bounds(i, gfx::Rect(x, y, 0, 0));
       continue;
     }
 
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
     if (i != last_button_index) {
       x = layout_manager_->PrimaryAxisValue(x + w + button_spacing, x);
       y = layout_manager_->PrimaryAxisValue(y, y + h + button_spacing);
     }
   }
 
   if (is_overflow_mode()) {
-    UpdateAllButtonsVisibilityInOverflowMode();
+    const_cast<ShelfView*>(this)->UpdateAllButtonsVisibilityInOverflowMode();
     return;
   }
 
   // Right aligned icons.
   int end_position = available_size - button_spacing;
   x = layout_manager_->PrimaryAxisValue(end_position, 0);
   y = layout_manager_->PrimaryAxisValue(0, end_position);
   for (int i = view_model_->view_size() - 1;
        i >= first_panel_index; --i) {
     x = layout_manager_->PrimaryAxisValue(x - w - button_spacing, x);
@@ skipping 409 matching lines @@
       // When a canceling drag model is happening, the view model is diverged
       // from the menu model and movements / animations should not be done.
       model_->Move(current_index, start_drag_index_);
       AnimateToIdealBounds();
     }
     drag_view_->layer()->SetOpacity(1.0f);
   }
   DestroyDragIconProxy();
 }
 
-ShelfView::RemovableState ShelfView::RemovableByRipOff(int index) {
+ShelfView::RemovableState ShelfView::RemovableByRipOff(int index) const {
   DCHECK(index >= 0 && index < model_->item_count());
   ShelfItemType type = model_->items()[index].type;
   if (type == TYPE_APP_LIST || type == TYPE_DIALOG || !delegate_->CanPin())
     return NOT_REMOVABLE;
 
   std::string app_id = delegate_->GetAppIDForShelfID(model_->items()[index].id);
   // Note: Only pinned app shortcuts can be removed!
   return (type == TYPE_APP_SHORTCUT && delegate_->IsAppPinned(app_id)) ?
       REMOVABLE : DRAGGABLE;
 }
@@ skipping 70 matching lines @@
   if (overflow_button_->visible() && last_visible_index_ >= 0) {
     views::View* last_visible_view = view_model_->view_at(last_visible_index_);
     last_visible_view->layer()->SetOpacity(0);
     bounds_animator_->SetAnimationDelegate(
         last_visible_view,
         new ShelfView::StartFadeAnimationDelegate(this, last_visible_view),
         true);
   }
 }
 
-void ShelfView::UpdateOverflowRange(ShelfView* overflow_view) {
+void ShelfView::UpdateOverflowRange(ShelfView* overflow_view) const {
   const int first_overflow_index = last_visible_index_ + 1;
   const int last_overflow_index = last_hidden_index_;
   DCHECK_LE(first_overflow_index, last_overflow_index);
   DCHECK_LT(last_overflow_index, view_model_->view_size());
 
   overflow_view->first_visible_index_ = first_overflow_index;
   overflow_view->last_visible_index_ = last_overflow_index;
 }
 
 bool ShelfView::ShouldHideTooltip(const gfx::Point& cursor_location) {
@@ skipping 82 matching lines @@
       view_model_->view_at(modified_index) : NULL;
   model_->Move(drag_view_index, start_drag_index_);
 
   // If the modified view will be at the end of the list, return the new end of
   // the list.
   if (at_end)
     return view_model_->view_size();
   return modified_view ? view_model_->GetIndexOfView(modified_view) : -1;
 }
 
-gfx::Size ShelfView::GetPreferredSize() {
+gfx::Size ShelfView::GetPreferredSize() const {
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
 
   int last_button_index = is_overflow_mode() ?
       last_visible_index_ : view_model_->view_size() - 1;
 
   // When an item is dragged off from the overflow bubble, it is moved to last
   // position and and changed to invisible. Overflow bubble size should be
   // shrunk to fit only for visible items.
   // If |dragged_off_from_overflow_to_shelf_| is set, there will be no invisible
@@ skipping 546 matching lines @@
       distance = bounds.x() - coordinate.x();
       break;
     case SHELF_ALIGNMENT_TOP:
       distance = coordinate.y() - bounds.bottom();
       break;
   }
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash