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

chrome/browser/ui/views/toolbar/wrench_menu.cc

 // Copyright 2013 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 "chrome/browser/ui/views/toolbar/wrench_menu.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 
@@ skipping 80 matching lines @@
       command_id <= WrenchMenuModel::kMaxRecentTabsCommandId;
 }
 
 // Subclass of ImageButton whose preferred size includes the size of the border.
 class FullscreenButton : public ImageButton {
  public:
   explicit FullscreenButton(views::ButtonListener* listener)
       : ImageButton(listener) { }
 
   // Overridden from ImageButton.
-  virtual gfx::Size GetPreferredSize() OVERRIDE {
+  virtual gfx::Size GetPreferredSize() const OVERRIDE {
     gfx::Size pref = ImageButton::GetPreferredSize();
     if (border()) {
       gfx::Insets insets = border()->GetInsets();
       pref.Enlarge(insets.width(), insets.height());
     }
     return pref;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FullscreenButton);
@@ skipping 316 matching lines @@
   virtual void WrenchMenuDestroyed() OVERRIDE {
     menu_->RemoveObserver(this);
     menu_ = NULL;
     menu_model_ = NULL;
   }
 
  protected:
   WrenchMenu* menu() { return menu_; }
   MenuModel* menu_model() { return menu_model_; }
 
+  bool use_new_menu() const { return menu_->use_new_menu(); }
+
  private:
   // Hosting WrenchMenu.
   // WARNING: this may be NULL during shutdown.
   WrenchMenu* menu_;
 
   // The menu model containing the increment/decrement/reset items.
   // WARNING: this may be NULL during shutdown.
   MenuModel* menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(WrenchMenuView);
 };
 
 class ButtonContainerMenuItemView : public MenuItemView {
  public:
   // Constructor for use with button containing menu items which have a
   // different height then normal items.
   ButtonContainerMenuItemView(MenuItemView* parent, int command_id, int height)
       : MenuItemView(parent, command_id, MenuItemView::NORMAL),
         height_(height) {
   };
 
   // Overridden from MenuItemView.
-  virtual gfx::Size GetChildPreferredSize() OVERRIDE {
+  virtual gfx::Size GetChildPreferredSize() const OVERRIDE {
     gfx::Size size = MenuItemView::GetChildPreferredSize();
     // When there is a height override given, we need to deduct our spacing
     // above and below to get to the correct height to return here for the
     // child item.
     int height = height_ - GetTopMargin() - GetBottomMargin();
     if (height > size.height())
       size.set_height(height);
     return size;
   }
 
@@ skipping 66 matching lines @@
         IDS_PASTE,
         menu->use_new_menu() && menu->supports_new_separators_ ?
             MenuButtonBackground::CENTER_BUTTON :
             MenuButtonBackground::RIGHT_BUTTON,
         paste_index,
         NULL);
     copy_background->SetOtherButtons(cut, paste);
   }
 
   // Overridden from View.
-  virtual gfx::Size GetPreferredSize() OVERRIDE {
+  virtual gfx::Size GetPreferredSize() const OVERRIDE {
     // Returned height doesn't matter as MenuItemView forces everything to the
     // height of the menuitemview.
     return gfx::Size(GetMaxChildViewPreferredWidth() * child_count(), 0);
   }
 
   virtual void Layout() OVERRIDE {
     // All buttons are given the same width.
     int width = GetMaxChildViewPreferredWidth();
     for (int i = 0; i < child_count(); ++i)
       child_at(i)->SetBounds(i * width, 0, width, height());
   }
 
   // Overridden from ButtonListener.
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE {
     menu()->CancelAndEvaluate(menu_model(), sender->tag());
   }
 
  private:
   // Returns the max preferred width of all the children.
-  int GetMaxChildViewPreferredWidth() {
+  int GetMaxChildViewPreferredWidth() const {
     int width = 0;
     for (int i = 0; i < child_count(); ++i)
       width = std::max(width, child_at(i)->GetPreferredSize().width());
     return width;
   }
 
   DISALLOW_COPY_AND_ASSIGN(CutCopyPasteView);
 };
 
 // ZoomView --------------------------------------------------------------------
@@ skipping 101 matching lines @@
         GetAccessibleNameForWrenchMenuItem(
             menu_model, fullscreen_index, IDS_ACCNAME_FULLSCREEN));
     AddChildView(fullscreen_button_);
 
     UpdateZoomControls();
   }
 
   virtual ~ZoomView() {}
 
   // Overridden from View.
-  virtual gfx::Size GetPreferredSize() OVERRIDE {
+  virtual gfx::Size GetPreferredSize() const OVERRIDE {
     // The increment/decrement button are forced to the same width.
     int button_width = std::max(increment_button_->GetPreferredSize().width(),
                                 decrement_button_->GetPreferredSize().width());
-    int zoom_padding = menu()->use_new_menu() ?
+    int zoom_padding = use_new_menu() ?
         kTouchZoomPadding : kZoomPadding;
     int fullscreen_width = fullscreen_button_->GetPreferredSize().width() +
                            zoom_padding;
     // Returned height doesn't matter as MenuItemView forces everything to the
     // height of the menuitemview. Note that we have overridden the height when
     // constructing the menu.
     return gfx::Size(button_width + zoom_label_width_ + button_width +
                      fullscreen_width, 0);
   }
 
   virtual void Layout() OVERRIDE {
     int x = 0;
     int button_width = std::max(increment_button_->GetPreferredSize().width(),
                                 decrement_button_->GetPreferredSize().width());
     gfx::Rect bounds(0, 0, button_width, height());
 
     decrement_button_->SetBoundsRect(bounds);
 
     x += bounds.width();
     bounds.set_x(x);
     bounds.set_width(zoom_label_width_);
     zoom_label_->SetBoundsRect(bounds);
 
     x += bounds.width();
     bounds.set_x(x);
     bounds.set_width(button_width);
     increment_button_->SetBoundsRect(bounds);
 
-    x += bounds.width() + (menu()->use_new_menu() ? 0 : kZoomPadding);
+    x += bounds.width() + (use_new_menu() ? 0 : kZoomPadding);
     bounds.set_x(x);
     bounds.set_width(fullscreen_button_->GetPreferredSize().width() +
-                     (menu()->use_new_menu() ? kTouchZoomPadding : 0));
+                     (use_new_menu() ? kTouchZoomPadding : 0));
     fullscreen_button_->SetBoundsRect(bounds);
   }
 
   // Overridden from ButtonListener.
   virtual void ButtonPressed(views::Button* sender,
                              const ui::Event& event) OVERRIDE {
     if (sender->tag() == fullscreen_index_) {
       menu()->CancelAndEvaluate(menu_model(), sender->tag());
     } else {
       // Zoom buttons don't close the menu.
@@ skipping 404 matching lines @@
     // These items are represented by child views. If ExecuteCommand is invoked
     // it means the user clicked on the area around the buttons and we should
     // not do anyting.
     return;
   }
 
   const Entry& entry = command_id_to_entry_.find(command_id)->second;
   return entry.first->ActivatedAt(entry.second, mouse_event_flags);
 }
 
-bool WrenchMenu::GetAccelerator(int command_id, ui::Accelerator* accelerator) {
+bool WrenchMenu::GetAccelerator(int command_id,
+                                ui::Accelerator* accelerator) const {
   if (IsBookmarkCommand(command_id))
     return false;
 
   if (command_id == IDC_CUT || command_id == IDC_ZOOM_MINUS) {
     // These have special child views; don't show the accelerator for them.
     return false;
   }
 
-  CommandIDToEntry::iterator ix = command_id_to_entry_.find(command_id);
+  CommandIDToEntry::const_iterator ix = command_id_to_entry_.find(command_id);
   const Entry& entry = ix->second;
   ui::Accelerator menu_accelerator;
   if (!entry.first->GetAcceleratorAt(entry.second, &menu_accelerator))
     return false;
 
   *accelerator = ui::Accelerator(menu_accelerator.key_code(),
                                  menu_accelerator.modifiers());
   return true;
 }
 
@@ skipping 188 matching lines @@
                                 0,
                                 BookmarkMenuDelegate::SHOW_PERMANENT_FOLDERS,
                                 BOOKMARK_LAUNCH_LOCATION_WRENCH_MENU);
 }
 
 int WrenchMenu::ModelIndexFromCommandId(int command_id) const {
   CommandIDToEntry::const_iterator ix = command_id_to_entry_.find(command_id);
   DCHECK(ix != command_id_to_entry_.end());
   return ix->second.second;
 }