Convert GetPreferredSize from:...

chrome/views/text_button.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/text_button.h"
 
 #include "chrome/app/theme/theme_resources.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/resource_bundle.h"
 #include "chrome/common/throb_animation.h"
@@ skipping 125 matching lines @@
               kPreferredPaddingVertical, kPreferredPaddingHorizontal);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TextButton - Implementation
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TextButton::TextButton(const std::wstring& text)
-    : max_text_size_(CSize(0, 0)),
-      font_(ResourceBundle::GetSharedInstance().GetFont(
+    : font_(ResourceBundle::GetSharedInstance().GetFont(
           ResourceBundle::BaseFont)),
       color_(kEnabledColor),
       BaseButton(),
       max_width_(0),
       alignment_(ALIGN_LEFT) {
   SetText(text);
   SetBorder(new TextButtonBorder);
   SetAnimationDuration(kHoverAnimationDurationMs);
 }
 
 TextButton::~TextButton() {
 }
 
-void TextButton::GetPreferredSize(CSize *result) {
+gfx::Size TextButton::GetPreferredSize() {
   gfx::Insets insets = GetInsets();
 
   // Use the max size to set the button boundaries.
-  result->cx = max_text_size_.cx + icon_.width() + insets.width();
-  result->cy = std::max(static_cast<int>(max_text_size_.cy), icon_.height()) +
-               insets.height();
+  gfx::Size prefsize(max_text_size_.width() + icon_.width() + insets.width(),
+                     std::max(max_text_size_.height(), icon_.height()) +
+                         insets.height());
 
   if (icon_.width() > 0 && !text_.empty())
-    result->cx += kIconTextPadding;
+    prefsize.Enlarge(kIconTextPadding, 0);
 
   if (max_width_ > 0)
-    result->cx = std::min(max_width_, static_cast<int>(result->cx));
+    prefsize.set_width(std::min(max_width_, prefsize.width()));
+  
+  return prefsize;
 }
 
-void TextButton::GetMinimumSize(CSize *result) {
-  result->cx = max_text_size_.cx;
-  result->cy = max_text_size_.cy;
+gfx::Size TextButton::GetMinimumSize() {
+  return max_text_size_;
 }
 
 bool TextButton::OnMousePressed(const ChromeViews::MouseEvent& e) {
   return true;
 }
 
 void TextButton::SetText(const std::wstring& text) {
   text_ = text;
   // Update our new current and max text size
-  text_size_.cx = font_.GetStringWidth(text_);
-  text_size_.cy = font_.height();
-  max_text_size_.cx = std::max(max_text_size_.cx, text_size_.cx);
-  max_text_size_.cy = std::max(max_text_size_.cy, text_size_.cy);
+  text_size_.SetSize(font_.GetStringWidth(text_), font_.height());
+  max_text_size_.SetSize(std::max(max_text_size_.width(), text_size_.width()),
+                         std::max(max_text_size_.height(),
+                                  text_size_.height()));
 }
 
 void TextButton::SetIcon(const SkBitmap& icon) {
   icon_ = icon;
 }
 
 void TextButton::ClearMaxTextSize() {
   max_text_size_ = text_size_;
 }
 
@@ skipping 18 matching lines @@
       PaintBorder(canvas);
     }
 
     PaintFocusBorder(canvas);
   }
 
   gfx::Insets insets = GetInsets();
   int available_width = width() - insets.width();
   int available_height = height() - insets.height();
   // Use the actual text (not max) size to properly center the text.
-  int content_width = text_size_.cx;
+  int content_width = text_size_.width();
   if (icon_.width() > 0) {
     content_width += icon_.width();
     if (!text_.empty())
       content_width += kIconTextPadding;
   }
   // Place the icon along the left edge.
   int icon_x;
   if (alignment_ == ALIGN_LEFT) {
     icon_x = insets.left();
   } else if (alignment_ == ALIGN_RIGHT) {
     icon_x = available_width - content_width;
   } else {
     icon_x =
         std::max(0, (available_width - content_width) / 2) + insets.left();
   }
   int text_x = icon_x;
   if (icon_.width() > 0)
     text_x += icon_.width() + kIconTextPadding;
-  const int text_width = std::min(static_cast<int>(text_size_.cx),
+  const int text_width = std::min(text_size_.width(),
                                   width() - insets.right() - text_x);
-  int text_y = (available_height - text_size_.cy) / 2 + insets.top();
+  int text_y = (available_height - text_size_.height()) / 2 + insets.top();
 
   if (text_width > 0) {
     // Because the text button can (at times) draw multiple elements on the
     // canvas, we can not mirror the button by simply flipping the canvas as
     // doing this will mirror the text itself. Flipping the canvas will also
     // make the icons look wrong because icons are almost always represented as
     // direction insentisive bitmaps and such bitmaps should never be flipped
     // horizontally.
     //
     // Due to the above, we must perform the flipping manually for RTL UIs.
-    gfx::Rect text_bounds(text_x, text_y, text_width, text_size_.cy);
+    gfx::Rect text_bounds(text_x, text_y, text_width, text_size_.height());
     text_bounds.set_x(MirroredLeftPointForRect(text_bounds));
 
     // Draw bevel highlight
     canvas->DrawStringInt(text_,
                           font_,
                           kHighlightColor,
                           text_bounds.x() + 1,
                           text_bounds.y() + 1,
                           text_bounds.width(),
                           text_bounds.height());
@@ skipping 20 matching lines @@
 void TextButton::SetEnabled(bool enabled) {
   if (enabled == IsEnabled())
     return;
   BaseButton::SetEnabled(enabled);
   color_ = enabled ? kEnabledColor : kDisabledColor;
   SchedulePaint();
 }
 
 }  // namespace ChromeViews