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

chrome/browser/ui/views/bookmarks/bookmark_bar_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 "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 377 matching lines @@
   virtual ~ButtonSeparatorView() {}
 
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
     DetachableToolbarView::PaintVerticalDivider(
         canvas, kSeparatorStartX, height(), 1,
         DetachableToolbarView::kEdgeDividerColor,
         DetachableToolbarView::kMiddleDividerColor,
         GetThemeProvider()->GetColor(ThemeProperties::COLOR_TOOLBAR));
   }
 
-  virtual gfx::Size GetPreferredSize() OVERRIDE {
+  virtual gfx::Size GetPreferredSize() const OVERRIDE {
     // We get the full height of the bookmark bar, so that the height returned
     // here doesn't matter.
     return gfx::Size(kSeparatorWidth, 1);
   }
 
   virtual void GetAccessibleState(ui::AXViewState* state) OVERRIDE {
     state->name = l10n_util::GetStringUTF16(IDS_ACCNAME_SEPARATOR);
     state->role = ui::AX_ROLE_SPLITTER;
   }
 
@@ skipping 248 matching lines @@
   if (infobar_visible_)
     return detached_overlap;
 
   // When detached with no infobar, animate the overlap between the attached and
   // detached states.
   return detached_overlap + static_cast<int>(
       (attached_overlap - detached_overlap) *
           size_animation_->GetCurrentValue());
 }
 
-gfx::Size BookmarkBarView::GetPreferredSize() {
-  return LayoutItems(true);
+gfx::Size BookmarkBarView::GetPreferredSize() const {
+  gfx::Size prefsize;
+  if (IsDetached()) {
+    prefsize.set_height(
+        chrome::kBookmarkBarHeight +
+        static_cast<int>(
+            (chrome::kNTPBookmarkBarHeight - chrome::kBookmarkBarHeight) *
+            (1 - size_animation_->GetCurrentValue())));
+  } else {
+    prefsize.set_height(static_cast<int>(chrome::kBookmarkBarHeight *
+                                         size_animation_->GetCurrentValue()));
+  }
+  return prefsize;
 }
 
 bool BookmarkBarView::HitTestRect(const gfx::Rect& rect) const {
   // If bookmark bar is attached and omnibox popup is open (on top of the bar),
   // force hit-testing to fail.  This prevents hovers/clicks just above the
   // omnibox popup from activating the top few pixels of items on the bookmark
   // bar.
   if (!IsDetached() && browser_view_ &&
       browser_view_->GetLocationBar()->GetOmniboxView()->model()->
           popup_model()->IsOpen()) {
     return false;
   }
   return DetachableToolbarView::HitTestRect(rect);
 }
 
-gfx::Size BookmarkBarView::GetMinimumSize() {
+gfx::Size BookmarkBarView::GetMinimumSize() const {
   // The minimum width of the bookmark bar should at least contain the overflow
   // button, by which one can access all the Bookmark Bar items, and the "Other
   // Bookmarks" folder, along with appropriate margins and button padding.
   int width = kLeftMargin;
 
   int height = chrome::kBookmarkBarHeight;
   if (IsDetached()) {
     double current_state = 1 - size_animation_->GetCurrentValue();
     width += 2 * static_cast<int>(kNewtabHorizontalPadding * current_state);
     height += static_cast<int>(
@@ skipping 16 matching lines @@
     apps_page_shortcut_pref = apps_page_shortcut_->GetPreferredSize();
   width += other_bookmarked_pref.width() + kButtonPadding +
       apps_page_shortcut_pref.width() + kButtonPadding +
       overflow_pref.width() + kButtonPadding +
       bookmarks_separator_pref.width();
 
   return gfx::Size(width, height);
 }
 
 void BookmarkBarView::Layout() {
-  LayoutItems(false);
+  LayoutItems();
 }
 
 void BookmarkBarView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   if (details.is_add && details.child == this) {
     // We may get inserted into a hierarchy with a profile - this typically
     // occurs when the bar's contents get populated fast enough that the
     // buttons are created before the bar is attached to a frame.
     UpdateColors();
 
@@ skipping 560 matching lines @@
   model_ = BookmarkModelFactory::GetForProfile(browser_->profile());
   if (model_) {
     model_->AddObserver(this);
     if (model_->loaded())
       BookmarkModelLoaded(model_, false);
     // else case: we'll receive notification back from the BookmarkModel when
     // done loading, then we'll populate the bar.
   }
 }
 
-int BookmarkBarView::GetBookmarkButtonCount() {
+int BookmarkBarView::GetBookmarkButtonCount() const {
   // We contain four non-bookmark button views: other bookmarks, bookmarks
   // separator, chevrons (for overflow), apps page, and the instruction label.
   return child_count() - 5;
 }
 
 views::TextButton* BookmarkBarView::GetBookmarkButton(int index) {
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
   return static_cast<views::TextButton*>(child_at(index));
 }
 
@@ skipping 394 matching lines @@
 }
 
 void BookmarkBarView::UpdateBookmarksSeparatorVisibility() {
   // Ash does not paint the bookmarks separator line because it looks odd on
   // the flat background.  We keep it present for layout, but don't draw it.
   bookmarks_separator_view_->SetVisible(
       browser_->host_desktop_type() != chrome::HOST_DESKTOP_TYPE_ASH &&
       other_bookmarked_button_->visible());
 }
 
-gfx::Size BookmarkBarView::LayoutItems(bool compute_bounds_only) {
-  gfx::Size prefsize;
-  if (!parent() && !compute_bounds_only)
-    return prefsize;
+void BookmarkBarView::LayoutItems() {
+  if (!parent())
+    return;
 
   int x = kLeftMargin;
   int top_margin = IsDetached() ? kDetachedTopMargin : 0;
   int y = top_margin;
   int width = View::width() - kRightMargin - kLeftMargin;
   int height = chrome::kBookmarkBarHeight - kBottomMargin;
   int separator_margin = kSeparatorMargin;
 
   if (IsDetached()) {
     double current_state = 1 - size_animation_->GetCurrentValue();
@@ skipping 19 matching lines @@
   int max_x = width - overflow_pref.width() - kButtonPadding -
       bookmarks_separator_pref.width();
   if (other_bookmarked_button_->visible())
     max_x -= other_bookmarked_pref.width() + kButtonPadding;
 
   // Next, layout out the buttons. Any buttons that are placed beyond the
   // visible region and made invisible.
 
   // Start with the apps page shortcut button.
   if (apps_page_shortcut_->visible()) {
-    if (!compute_bounds_only) {
-      apps_page_shortcut_->SetBounds(x, y, apps_page_shortcut_pref.width(),
-                                     height);
-    }
+    apps_page_shortcut_->SetBounds(x, y, apps_page_shortcut_pref.width(),
+                                   height);
     x += apps_page_shortcut_pref.width() + kButtonPadding;
   }
 
   // Then go through the bookmark buttons.
   if (GetBookmarkButtonCount() == 0 && model_ && model_->loaded()) {
     gfx::Size pref = instructions_->GetPreferredSize();
-    if (!compute_bounds_only) {
-      instructions_->SetBounds(
-          x + kInstructionsPadding, y,
-          std::min(static_cast<int>(pref.width()),
-          max_x - x),
-          height);
-      instructions_->SetVisible(true);
-    }
+    instructions_->SetBounds(
+        x + kInstructionsPadding, y,
+        std::min(static_cast<int>(pref.width()),
+                 max_x - x),
+        height);
+    instructions_->SetVisible(true);
   } else {
-    if (!compute_bounds_only)
-      instructions_->SetVisible(false);
+    instructions_->SetVisible(false);
 
     for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
       views::View* child = child_at(i);
       gfx::Size pref = child->GetPreferredSize();
       int next_x = x + pref.width() + kButtonPadding;
-      if (!compute_bounds_only) {
-        child->SetVisible(next_x < max_x);
-        child->SetBounds(x, y, pref.width(), height);
-      }
+      child->SetVisible(next_x < max_x);
+      child->SetBounds(x, y, pref.width(), height);
       x = next_x;
     }
   }
 
   // Layout the right side of the bar.
   const bool all_visible = (GetBookmarkButtonCount() == 0 ||
                             child_at(GetBookmarkButtonCount() - 1)->visible());
 
   // Layout the right side buttons.
-  if (!compute_bounds_only)
-    x = max_x + kButtonPadding;
-  else
-    x += kButtonPadding;
+  x = max_x + kButtonPadding;
 
   // The overflow button.
-  if (!compute_bounds_only) {
-    overflow_button_->SetBounds(x, y, overflow_pref.width(), height);
-    overflow_button_->SetVisible(!all_visible);
-  }
+  overflow_button_->SetBounds(x, y, overflow_pref.width(), height);
+  overflow_button_->SetVisible(!all_visible);
   x += overflow_pref.width();
 
   // Separator.
   if (bookmarks_separator_view_->visible()) {
-    if (!compute_bounds_only) {
-      bookmarks_separator_view_->SetBounds(x,
-                                           y - top_margin,
-                                           bookmarks_separator_pref.width(),
-                                           height + top_margin + kBottomMargin -
-                                           separator_margin);
-    }
+    bookmarks_separator_view_->SetBounds(x,
+                                         y - top_margin,
+                                         bookmarks_separator_pref.width(),
+                                         height + top_margin + kBottomMargin -
+                                         separator_margin);
 
     x += bookmarks_separator_pref.width();
   }
 
   // The other bookmarks button.
   if (other_bookmarked_button_->visible()) {
-    if (!compute_bounds_only) {
-      other_bookmarked_button_->SetBounds(x, y, other_bookmarked_pref.width(),
-                                          height);
-    }
+    other_bookmarked_button_->SetBounds(x, y, other_bookmarked_pref.width(),
+                                        height);
     x += other_bookmarked_pref.width() + kButtonPadding;
   }
-
-  // Set the preferred size computed so far.
-  if (compute_bounds_only) {
-    x += kRightMargin;
-    prefsize.set_width(x);
-    if (IsDetached()) {
-      x += static_cast<int>(kNewtabHorizontalPadding *
-          (1 - size_animation_->GetCurrentValue()));
-      prefsize.set_height(
-          chrome::kBookmarkBarHeight +
-          static_cast<int>(
-              (chrome::kNTPBookmarkBarHeight - chrome::kBookmarkBarHeight) *
-              (1 - size_animation_->GetCurrentValue())));
-    } else {
-      prefsize.set_height(static_cast<int>(chrome::kBookmarkBarHeight *
-                                           size_animation_->GetCurrentValue()));
-    }
-  }
-  return prefsize;
 }
 
 void BookmarkBarView::OnAppsPageShortcutVisibilityPrefChanged() {
   DCHECK(apps_page_shortcut_);
   // Only perform layout if required.
   bool visible = chrome::ShouldShowAppsShortcutInBookmarkBar(
       browser_->profile(), browser_->host_desktop_type());
   if (apps_page_shortcut_->visible() == visible)
     return;
   apps_page_shortcut_->SetVisible(visible);
   UpdateBookmarksSeparatorVisibility();
   Layout();
 }