Convert GetPreferredSize from:...

chrome/views/bitmap_scroll_bar.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/views/bitmap_scroll_bar.h"
 
 #include "base/message_loop.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/views/menu.h"
 #include "chrome/views/scroll_view.h"
 #include "chrome/views/view_container.h"
 #include "skia/include/SkBitmap.h"
 
 #include "generated_resources.h"
 
+#undef min
+#undef max
+
 namespace ChromeViews {
 
 namespace {
 
 // The distance the mouse can be dragged outside the bounds of the thumb during
 // dragging before the scrollbar will snap back to its regular position.
 static const int kScrollThumbDragOutSnap = 100;
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ skipping 51 matching lines @@
         drag_start_position_(-1),
         mouse_offset_(-1),
         state_(BaseButton::BS_NORMAL) {
   }
   virtual ~BitmapScrollBarThumb() { }
 
   // Sets the size (width or height) of the thumb to the specified value.
   void SetSize(int size) {
     // Make sure the thumb is never sized smaller than its minimum possible
     // display size.
-    CSize prefsize;
-    GetPreferredSize(&prefsize);
+    gfx::Size prefsize = GetPreferredSize();
     size = std::max(size,
                     static_cast<int>(scroll_bar_->IsHorizontal() ?
-                        prefsize.cx : prefsize.cy));
+                        prefsize.width() : prefsize.height()));
     gfx::Rect thumb_bounds = bounds();
     if (scroll_bar_->IsHorizontal()) {
       thumb_bounds.set_width(size);
     } else {
       thumb_bounds.set_height(size);
     }
     SetBounds(thumb_bounds.ToRECT());
   }
 
   // Retrieves the size (width or height) of the thumb.
@@ skipping 17 matching lines @@
 
   // Gets the position of the thumb on the x or y axis.
   int GetPosition() const {
     gfx::Rect track_bounds = scroll_bar_->GetTrackBounds();
     if (scroll_bar_->IsHorizontal())
       return x() - track_bounds.x();
     return y() - track_bounds.y();
   }
 
   // View overrides:
-  virtual void GetPreferredSize(CSize* preferred_size) {
-    DCHECK(preferred_size);
-    preferred_size->cx = background_bitmap()->width();
-    preferred_size->cy = start_cap_bitmap()->height() +
-        end_cap_bitmap()->height() + grippy_bitmap()->height();
+  virtual gfx::Size GetPreferredSize() {
+    return gfx::Size(background_bitmap()->width(),
+                     start_cap_bitmap()->height() +
+                         end_cap_bitmap()->height() +
+                         grippy_bitmap()->height());
   }
 
  protected:
   // View overrides:
   virtual void Paint(ChromeCanvas* canvas) {
     canvas->DrawBitmapInt(*start_cap_bitmap(), 0, 0);
     int top_cap_height = start_cap_bitmap()->height();
     int bottom_cap_height = end_cap_bitmap()->height();
     int thumb_body_height = height() - top_cap_height - bottom_cap_height;
     canvas->TileImageInt(*background_bitmap(), 0, top_cap_height,
@@ skipping 128 matching lines @@
   AddChildView(next_button_);
   AddChildView(thumb_);
 
   SetContextMenuController(this);
   prev_button_->SetContextMenuController(this);
   next_button_->SetContextMenuController(this);
   thumb_->SetContextMenuController(this);
 }
 
 gfx::Rect BitmapScrollBar::GetTrackBounds() const {
-  CSize prefsize;
-  prev_button_->GetPreferredSize(&prefsize);
+  gfx::Size prefsize = prev_button_->GetPreferredSize();
   if (IsHorizontal()) {
     if (!show_scroll_buttons_)
-      prefsize.cx = 0;
-    int new_width = std::max(0,
-                             static_cast<int>(width() - (prefsize.cx * 2)));
-    gfx::Rect track_bounds(prefsize.cx, 0, new_width, prefsize.cy);
+      prefsize.set_width(0);
+    int new_width =
+        std::max(0, static_cast<int>(width() - (prefsize.width() * 2)));
+    gfx::Rect track_bounds(prefsize.width(), 0, new_width, prefsize.height());
     return track_bounds;
   }
   if (!show_scroll_buttons_)
-    prefsize.cy = 0;
-  gfx::Rect track_bounds(0, prefsize.cy, prefsize.cx,
-                         std::max(0l, height() - (prefsize.cy * 2)));
+    prefsize.set_height(0);
+  gfx::Rect track_bounds(0, prefsize.height(), prefsize.width(),
+                         std::max(0, height() - (prefsize.height() * 2)));
   return track_bounds;
 }
 
 void BitmapScrollBar::SetImage(ScrollBarPart part,
                                BaseButton::ButtonState state,
                                SkBitmap* bitmap) {
   DCHECK(part < PART_COUNT);
   DCHECK(state < BaseButton::kButtonStateCount);
   switch (part) {
     case PREV_BUTTON:
@@ skipping 67 matching lines @@
 }
 
 void BitmapScrollBar::TrackClicked() {
   if (last_scroll_amount_ != SCROLL_NONE)
     ScrollByAmount(last_scroll_amount_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BitmapScrollBar, View implementation:
 
-void BitmapScrollBar::GetPreferredSize(CSize* preferred_size) {
-  DCHECK(preferred_size);
-
+gfx::Size BitmapScrollBar::GetPreferredSize() {
   // In this case, we're returning the desired width of the scrollbar and its
   // minimum allowable height.
-  CSize button_prefsize;
-  prev_button_->GetPreferredSize(&button_prefsize);
-  preferred_size->cx = button_prefsize.cx;
-  preferred_size->cy = button_prefsize.cy * 2;
+  gfx::Size button_prefsize = prev_button_->GetPreferredSize();
+  return gfx::Size(button_prefsize.width(), button_prefsize.height() * 2);
 }
 
 void BitmapScrollBar::Paint(ChromeCanvas* canvas) {
   // Paint the track.
   gfx::Rect track_bounds = GetTrackBounds();
   canvas->TileImageInt(*images_[THUMB_TRACK][thumb_track_state_],
                        track_bounds.x(), track_bounds.y(),
                        track_bounds.width(), track_bounds.height());
 }
 
 void BitmapScrollBar::Layout() {
   // Size and place the two scroll buttons.
   if (show_scroll_buttons_) {
-    CSize prefsize;
-    prev_button_->GetPreferredSize(&prefsize);
-    prev_button_->SetBounds(0, 0, prefsize.cx, prefsize.cy);
-    next_button_->GetPreferredSize(&prefsize);
+    gfx::Size prefsize = prev_button_->GetPreferredSize();
+    prev_button_->SetBounds(gfx::Point(), prefsize);
+    prefsize = next_button_->GetPreferredSize();
     if (IsHorizontal()) {
-      next_button_->SetBounds(width() - prefsize.cx, 0, prefsize.cx,
-                              prefsize.cy);
+      next_button_->SetBounds(width() - prefsize.width(), 0, prefsize.width(),
+                              prefsize.height());
     } else {
-      next_button_->SetBounds(0, height() - prefsize.cy, prefsize.cx,
-                              prefsize.cy);
+      next_button_->SetBounds(0, height() - prefsize.height(), prefsize.width(),
+                              prefsize.height());
     }
   } else {
     prev_button_->SetBounds(0, 0, 0, 0);
     next_button_->SetBounds(0, 0, 0, 0);
   }
 
   // Size and place the thumb
-  CSize thumb_prefsize;
-  thumb_->GetPreferredSize(&thumb_prefsize);
+  gfx::Size thumb_prefsize = thumb_->GetPreferredSize();
   gfx::Rect track_bounds = GetTrackBounds();
 
   // Preserve the height/width of the thumb (depending on orientation) as set
   // by the last call to |Update|, but coerce the width/height to be the
   // appropriate value for the bitmaps provided.
   if (IsHorizontal()) {
     thumb_->SetBounds(thumb_->x(), thumb_->y(), thumb_->width(),
-                      thumb_prefsize.cy);
+                      thumb_prefsize.height());
   } else {
-    thumb_->SetBounds(thumb_->x(), thumb_->y(), thumb_prefsize.cx,
+    thumb_->SetBounds(thumb_->x(), thumb_->y(), thumb_prefsize.width(),
                       thumb_->height());
   }
 
   // Hide the thumb if the track isn't tall enough to display even a tiny
   // thumb. The user can only use the mousewheel, scroll buttons or keyboard
   // in this scenario.
-  if ((IsHorizontal() && (track_bounds.width() < thumb_prefsize.cx)) ||
-      (!IsHorizontal() && (track_bounds.height() < thumb_prefsize.cy))) {
+  if ((IsHorizontal() && (track_bounds.width() < thumb_prefsize.width()) ||
+      (!IsHorizontal() && (track_bounds.height() < thumb_prefsize.height())))) {
     thumb_->SetVisible(false);
   } else if (!thumb_->IsVisible()) {
     thumb_->SetVisible(true);
   }
 }
 
 void BitmapScrollBar::DidChangeBounds(const CRect& previous,
                                       const CRect& current) {
   Layout();
 }
@@ skipping 212 matching lines @@
   // content size multiplied by the height of the thumb track.
   double ratio = static_cast<double>(viewport_size) / contents_size_;
   int thumb_size = static_cast<int>(ratio * GetTrackSize());
   thumb_->SetSize(thumb_size);
 
   int thumb_position = CalculateThumbPosition(contents_scroll_offset);
   thumb_->SetPosition(thumb_position);
 }
 
 int BitmapScrollBar::GetLayoutSize() const {
-  CSize prefsize;
-  prev_button_->GetPreferredSize(&prefsize);
-  return IsHorizontal() ? prefsize.cy : prefsize.cx;
+  gfx::Size prefsize = prev_button_->GetPreferredSize();
+  return IsHorizontal() ? prefsize.height() : prefsize.width();
 }
 
 int BitmapScrollBar::GetPosition() const {
   return thumb_->GetPosition();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BitmapScrollBar, private:
 
 void BitmapScrollBar::ScrollContentsToOffset() {
@@ skipping 17 matching lines @@
   return (thumb_position * contents_size_) / GetTrackSize();
 }
 
 void BitmapScrollBar::SetThumbTrackState(BaseButton::ButtonState state) {
   thumb_track_state_ = state;
   SchedulePaint();
 }
 
 }