Convert GetPreferredSize from:...

chrome/browser/views/bookmark_bar_view.cc

 // Copyright (c) 2006-2008 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/views/bookmark_bar_view.h"
 
 #include <limits>
 
 #include "base/base_drag_source.h"
 #include "base/gfx/skia_utils.h"
@@ skipping 610 matching lines @@
     paint_down.setShader(gfx::CreateGradientShader(height() / 2,
         height(),
         kSeparatorColor,
         kBackgroundColor))->safeUnref();
     SkRect rc_down = {
         SkIntToScalar(kSeparatorStartX),  SkIntToScalar(height() / 2),
         SkIntToScalar(1), SkIntToScalar(height() - 1) };
     canvas->drawRect(rc_down, paint_down);
   }
 
-  virtual void GetPreferredSize(CSize* out) {
+  virtual gfx::Size GetPreferredSize() {
     // We get the full height of the bookmark bar, so that the height returned
     // here doesn't matter.
-    out->SetSize(kSeparatorWidth, 1);
+    return gfx::Size(kSeparatorWidth, 1);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ButtonSeparatorView);
 };
 
 }  // namespace
 
 // BookmarkBarView ------------------------------------------------------------
 
@@ skipping 87 matching lines @@
   if (model_->IsLoaded())
     Loaded(model_);
   // else case: we'll receive notification back from the BookmarkModel when done
   // loading, then we'll populate the bar.
 }
 
 void BookmarkBarView::SetPageNavigator(PageNavigator* navigator) {
   page_navigator_ = navigator;
 }
 
-void BookmarkBarView::GetPreferredSize(CSize *out) {
+gfx::Size BookmarkBarView::GetPreferredSize() {
   if (!prefButtonHeight) {
     ChromeViews::TextButton text_button(L"X");
-    CSize text_button_pref;
-    text_button.GetMinimumSize(&text_button_pref);
-    prefButtonHeight = static_cast<int>(text_button_pref.cy);
+    gfx::Size text_button_pref = text_button.GetMinimumSize();
+    prefButtonHeight = static_cast<int>(text_button_pref.height());
   }
 
+  gfx::Size prefsize;
   if (IsNewTabPage()) {
-    out->cy = kBarHeight + static_cast<int>(static_cast<double>
-              (kNewtabBarHeight - kBarHeight) *
-              (1 - size_animation_->GetCurrentValue()));
+    prefsize.set_height(kBarHeight + static_cast<int>(static_cast<double>
+                        (kNewtabBarHeight - kBarHeight) *
+                        (1 - size_animation_->GetCurrentValue())));
   } else {
-    out->cy = std::max(static_cast<int>(static_cast<double>(kBarHeight) *
-              size_animation_->GetCurrentValue()), 1);
+    prefsize.set_height(
+        std::max(static_cast<int>(static_cast<double>(kBarHeight) *
+                 size_animation_->GetCurrentValue()), 1));
   }
 
-  // Width doesn't matter, we're always given a width based on the browser size.
-  out->cx = 1;
+  // Width doesn't matter, we're always given a width based on the browser
+  // size.
+  prefsize.set_width(1);
+
+  return prefsize;
 }
 
 void BookmarkBarView::Layout() {
   if (!GetParent())
     return;
 
   // First layout out the buttons. Any buttons that are placed beyond the
   // visible region and made invisible.
   int x = kLeftMargin;
   int y = kTopMargin;
   int width = View::width() - kRightMargin - kLeftMargin;
   int height = View::height() - kTopMargin - kBottomMargin;
   int separator_margin = kSeparatorMargin;
 
   if (IsNewTabPage()) {
     double current_state = 1 - size_animation_->GetCurrentValue();
     x += static_cast<int>(static_cast<double>
         (kNewtabHorizontalPadding) * current_state);
     y += static_cast<int>(static_cast<double>
         (kNewtabVerticalPadding) * current_state);
     width -= static_cast<int>(static_cast<double>
         (kNewtabHorizontalPadding) * current_state);
     height -= static_cast<int>(static_cast<double>
         (kNewtabVerticalPadding * 2) * current_state);
     separator_margin -= static_cast<int>(static_cast<double>
         (kSeparatorMargin) * current_state);
   }
 
-  CSize other_bookmarked_pref;
-  other_bookmarked_button_->GetPreferredSize(&other_bookmarked_pref);
-  CSize overflow_pref;
-  overflow_button_->GetPreferredSize(&overflow_pref);
-  CSize bookmarks_separator_pref;
-  bookmarks_separator_view_->GetPreferredSize(&bookmarks_separator_pref);
-  const int max_x = width - other_bookmarked_pref.cx - kButtonPadding -
-              overflow_pref.cx - kButtonPadding -
-              bookmarks_separator_pref.cx;
+  gfx::Size other_bookmarked_pref =
+      other_bookmarked_button_->GetPreferredSize();
+  gfx::Size overflow_pref = overflow_button_->GetPreferredSize();
+  gfx::Size bookmarks_separator_pref =
+      bookmarks_separator_view_->GetPreferredSize();
+  const int max_x = width - other_bookmarked_pref.width() - kButtonPadding -
+              overflow_pref.width() - kButtonPadding -
+              bookmarks_separator_pref.width();
 
   if (GetBookmarkButtonCount() == 0 && model_ && model_->IsLoaded()) {
-    CSize pref;
-    instructions_->GetPreferredSize(&pref);
-    instructions_->SetBounds(x + kInstructionsPadding, y,
-                             std::min(static_cast<int>(pref.cx), max_x - x),
-                             height);
+    gfx::Size pref = instructions_->GetPreferredSize();
+    instructions_->SetBounds(
+        x + kInstructionsPadding, y,
+        std::min(static_cast<int>(pref.width()),
+        max_x - x),
+        height);
     instructions_->SetVisible(true);
   } else {
     instructions_->SetVisible(false);
 
     for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
       ChromeViews::View* child = GetChildViewAt(i);
-      CSize pref;
-      child->GetPreferredSize(&pref);
-      int next_x = x + pref.cx + kButtonPadding;
+      gfx::Size pref = child->GetPreferredSize();
+      int next_x = x + pref.width() + kButtonPadding;
       child->SetVisible(next_x < max_x);
-      child->SetBounds(x, y, pref.cx, height);
+      child->SetBounds(x, y, pref.width(), height);
       x = next_x;
     }
   }
 
   // Layout the right side of the bar.
   const bool all_visible =
       (GetBookmarkButtonCount() == 0 ||
        GetChildViewAt(GetBookmarkButtonCount() - 1)->IsVisible());
 
   // Layout the recently bookmarked button.
   x = max_x + kButtonPadding;
 
   // The overflow button.
-  overflow_button_->SetBounds(x, y, overflow_pref.cx, height);
+  overflow_button_->SetBounds(x, y, overflow_pref.width(), height);
   overflow_button_->SetVisible(!all_visible);
 
-  x += overflow_pref.cx;
+  x += overflow_pref.height();
 
   // Separator.
   bookmarks_separator_view_->SetBounds(x,
                                        y - kTopMargin,
-                                       bookmarks_separator_pref.cx,
+                                       bookmarks_separator_pref.width(),
                                        height + kTopMargin + kBottomMargin -
                                        separator_margin);
-  x += bookmarks_separator_pref.cx;
+  x += bookmarks_separator_pref.width();
 
-  other_bookmarked_button_->SetBounds(x, y, other_bookmarked_pref.cx, height);
-  x += other_bookmarked_pref.cx + kButtonPadding;
+  other_bookmarked_button_->SetBounds(x, y, other_bookmarked_pref.width(),
+                                      height);
+  x += other_bookmarked_pref.width() + kButtonPadding;
 }
 
 void BookmarkBarView::DidChangeBounds(const CRect& previous,
                                       const CRect& current) {
   Layout();
 }
 
 void BookmarkBarView::ViewHierarchyChanged(bool is_add,
                                            View* parent, View* child) {
   if (is_add && child == this && height() > 0) {
@@ skipping 437 matching lines @@
 
 void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
                                               BookmarkNode* node) {
   if (node->GetParent() != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   int index = model_->GetBookmarkBarNode()->IndexOfChild(node);
   DCHECK(index != -1);
   ChromeViews::TextButton* button = GetBookmarkButton(index);
-  CSize old_pref;
-  button->GetPreferredSize(&old_pref);
+  gfx::Size old_pref = button->GetPreferredSize();
   ConfigureButton(node, button);
-  CSize new_pref;
-  button->GetPreferredSize(&new_pref);
-  if (old_pref.cx != new_pref.cx) {
+  gfx::Size new_pref = button->GetPreferredSize();
+  if (old_pref.width() != new_pref.width()) {
     Layout();
     SchedulePaint();
   } else if (button->IsVisible()) {
     button->SchedulePaint();
   }
 }
 
 void BookmarkBarView::BookmarkNodeFavIconLoaded(BookmarkModel* model,
                                                 BookmarkNode* node) {
   if (menu_runner_.get())
@@ skipping 539 matching lines @@
 }
 
 void BookmarkBarView::StopThrobbing(bool immediate) {
   if (!throbbing_view_)
     return;
 
   // If not immediate, cycle through 2 more complete cycles.
   throbbing_view_->StartThrobbing(immediate ? 0 : 4);
   throbbing_view_ = NULL;
 }