Convert GetPreferredSize from:...

chrome/views/custom_frame_window.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/custom_frame_window.h"
 
 #include "base/gfx/point.h"
 #include "base/gfx/size.h"
 #include "base/win_util.h"
 #include "chrome/app/theme/theme_resources.h"
@@ skipping 226 matching lines @@
   virtual gfx::Size CalculateWindowSizeForClientSize(int width,
                                                      int height) const;
   virtual CPoint GetSystemMenuPoint() const;
   virtual int NonClientHitTest(const gfx::Point& point);
   virtual void GetWindowMask(const gfx::Size& size, gfx::Path* window_mask);
   virtual void EnableClose(bool enable);
 
   // View overrides:
   virtual void Paint(ChromeCanvas* canvas);
   virtual void Layout();
-  virtual void GetPreferredSize(CSize* out);
+  virtual gfx::Size GetPreferredSize();
   virtual void ViewHierarchyChanged(bool is_add, View* parent, View* child);
 
   // BaseButton::ButtonListener implementation:
   virtual void ButtonPressed(BaseButton* sender);
 
  private:
   // Updates the system menu icon button.
   void SetWindowIcon(SkBitmap window_icon);
 
   // Returns the height of the non-client area at the top of the window (the
@@ skipping 250 matching lines @@
   }
 }
 
 void DefaultNonClientView::Layout() {
   LayoutWindowControls();
   LayoutTitleBar();
   LayoutClientView();
   SchedulePaint();
 }
 
-void DefaultNonClientView::GetPreferredSize(CSize* out) {
-  DCHECK(out);
-  container_->client_view()->GetPreferredSize(out);
-  out->cx += 2 * kWindowHorizontalBorderSize;
-  out->cy += CalculateContentsTop() + kWindowVerticalBorderSize;
+gfx::Size DefaultNonClientView::GetPreferredSize() {
+  gfx::Size prefsize = container_->client_view()->GetPreferredSize();
+  prefsize.Enlarge(2 * kWindowHorizontalBorderSize,
+                   CalculateContentsTop() + kWindowVerticalBorderSize);
+  return prefsize;
 }
 
 void DefaultNonClientView::ViewHierarchyChanged(bool is_add,
                                                 View* parent,
                                                 View* child) {
   // Add our Client View as we are added to the ViewContainer so that if we are
   // subsequently resized all the parent-child relationships are established.
   if (is_add && GetViewContainer() && child == this)
     AddChildView(container_->client_view());
 }
@@ skipping 119 matching lines @@
   canvas->DrawBitmapInt(*bottom_left,
                         client_area_bounds.x() - bottom_left->width(),
                         client_area_bounds.bottom());
   canvas->TileImageInt(*left, client_area_bounds.x() - left->width(),
                        client_area_bounds.y() - top->height() +
                            top_left->height(),
                        left->width(), client_area_bounds.height());
 }
 
 void DefaultNonClientView::LayoutWindowControls() {
-  CSize ps;
+  gfx::Size ps;
   if (container_->IsMaximized() || container_->IsMinimized()) {
     maximize_button_->SetVisible(false);
     restore_button_->SetVisible(true);
   }
 
   if (container_->IsMaximized()) {
-    close_button_->GetPreferredSize(&ps);
+    ps = close_button_->GetPreferredSize();
     close_button_->SetImageAlignment(Button::ALIGN_LEFT, Button::ALIGN_BOTTOM);
     close_button_->SetBounds(
-        width() - ps.cx - kWindowControlsRightZoomedOffset,
-        0, ps.cx + kWindowControlsRightZoomedOffset,
-        ps.cy + kWindowControlsTopZoomedOffset);
+        width() - ps.width() - kWindowControlsRightZoomedOffset,
+        0, ps.width() + kWindowControlsRightZoomedOffset,
+        ps.height() + kWindowControlsTopZoomedOffset);
 
     if (should_show_minmax_buttons_) {
-      restore_button_->GetPreferredSize(&ps);
+      ps = restore_button_->GetPreferredSize();
       restore_button_->SetImageAlignment(Button::ALIGN_LEFT,
                                          Button::ALIGN_BOTTOM);
-      restore_button_->SetBounds(close_button_->x() - ps.cx, 0, ps.cx,
-                                 ps.cy + kWindowControlsTopZoomedOffset);
+      restore_button_->SetBounds(close_button_->x() - ps.width(), 0,
+                                 ps.width(),
+                                 ps.height() + kWindowControlsTopZoomedOffset);
 
-      minimize_button_->GetPreferredSize(&ps);
+      ps = minimize_button_->GetPreferredSize();
       minimize_button_->SetImageAlignment(Button::ALIGN_LEFT,
                                           Button::ALIGN_BOTTOM);
-      minimize_button_->SetBounds(restore_button_->x() - ps.cx, 0, ps.cx,
-                                  ps.cy + kWindowControlsTopZoomedOffset);
+      minimize_button_->SetBounds(restore_button_->x() - ps.width(), 0,
+                                  ps.width(),
+                                  ps.height() + kWindowControlsTopZoomedOffset);
     }
   } else if (container_->IsMinimized()) {
-    close_button_->GetPreferredSize(&ps);
+    ps = close_button_->GetPreferredSize();
     close_button_->SetImageAlignment(Button::ALIGN_LEFT, Button::ALIGN_BOTTOM);
     close_button_->SetBounds(
-        width() - ps.cx - kWindowControlsRightZoomedOffset,
-        0, ps.cx + kWindowControlsRightZoomedOffset,
-        ps.cy + kWindowControlsTopZoomedOffset);
+        width() - ps.width() - kWindowControlsRightZoomedOffset,
+        0, ps.width() + kWindowControlsRightZoomedOffset,
+        ps.height() + kWindowControlsTopZoomedOffset);
 
     if (should_show_minmax_buttons_) {
-      restore_button_->GetPreferredSize(&ps);
+      ps = restore_button_->GetPreferredSize();
       restore_button_->SetImageAlignment(Button::ALIGN_LEFT,
                                          Button::ALIGN_BOTTOM);
-      restore_button_->SetBounds(close_button_->x() - ps.cx, 0, ps.cx,
-                                 ps.cy + kWindowControlsTopZoomedOffset);
+      restore_button_->SetBounds(close_button_->x() - ps.width(), 0,
+                                 ps.width(),
+                                 ps.height() + kWindowControlsTopZoomedOffset);
 
-      minimize_button_->GetPreferredSize(&ps);
+      ps = minimize_button_->GetPreferredSize();
       minimize_button_->SetImageAlignment(Button::ALIGN_LEFT,
                                           Button::ALIGN_BOTTOM);
-      minimize_button_->SetBounds(restore_button_->x() - ps.cx, 0, ps.cx,
-                                  ps.cy + kWindowControlsTopZoomedOffset);
+      minimize_button_->SetBounds(restore_button_->x() - ps.width(), 0,
+                                  ps.width(),
+                                  ps.height() +
+                                      kWindowControlsTopZoomedOffset);
     }
   } else {
-    close_button_->GetPreferredSize(&ps);
+    ps = close_button_->GetPreferredSize();
     close_button_->SetImageAlignment(Button::ALIGN_LEFT, Button::ALIGN_TOP);
-    close_button_->SetBounds(width() - kWindowControlsRightOffset - ps.cx,
-                             kWindowControlsTopOffset, ps.cx, ps.cy);
+    close_button_->SetBounds(width() - kWindowControlsRightOffset - ps.width(),
+                             kWindowControlsTopOffset, ps.width(),
+                             ps.height());
 
     if (should_show_minmax_buttons_) {
       close_button_->SetImage(
           Button::BS_NORMAL,
           active_resources_->GetPartBitmap(FRAME_CLOSE_BUTTON_ICON));
       close_button_->SetImage(
           Button::BS_HOT,
           active_resources_->GetPartBitmap(FRAME_CLOSE_BUTTON_ICON_H));
       close_button_->SetImage(
           Button::BS_PUSHED,
           active_resources_->GetPartBitmap(FRAME_CLOSE_BUTTON_ICON_P));
 
       restore_button_->SetVisible(false);
 
       maximize_button_->SetVisible(true);
-      maximize_button_->GetPreferredSize(&ps);
+      ps = maximize_button_->GetPreferredSize();
       maximize_button_->SetImageAlignment(Button::ALIGN_LEFT,
                                           Button::ALIGN_TOP);
-      maximize_button_->SetBounds(close_button_->x() - ps.cx,
-                                  kWindowControlsTopOffset, ps.cx, ps.cy);
+      maximize_button_->SetBounds(close_button_->x() - ps.width(),
+                                  kWindowControlsTopOffset, ps.width(),
+                                  ps.height());
 
-      minimize_button_->GetPreferredSize(&ps);
+      ps = minimize_button_->GetPreferredSize();
       minimize_button_->SetImageAlignment(Button::ALIGN_LEFT,
                                           Button::ALIGN_TOP);
-      minimize_button_->SetBounds(maximize_button_->x() - ps.cx,
-                                  kWindowControlsTopOffset, ps.cx, ps.cy);
+      minimize_button_->SetBounds(maximize_button_->x() - ps.width(),
+                                  kWindowControlsTopOffset, ps.width(),
+                                  ps.height());
     }
   }
   if (!should_show_minmax_buttons_) {
     close_button_->SetImage(
         Button::BS_NORMAL,
         active_resources_->GetPartBitmap(FRAME_CLOSE_BUTTON_ICON_SA));
     close_button_->SetImage(
         Button::BS_HOT,
         active_resources_->GetPartBitmap(FRAME_CLOSE_BUTTON_ICON_SA_H));
     close_button_->SetImage(
         Button::BS_PUSHED,
         active_resources_->GetPartBitmap(FRAME_CLOSE_BUTTON_ICON_SA_P));
 
     restore_button_->SetVisible(false);
     maximize_button_->SetVisible(false);
     minimize_button_->SetVisible(false);
   }
 }
 
 void DefaultNonClientView::LayoutTitleBar() {
   int top_offset = container_->IsMaximized() ? kWindowTopMarginZoomed : 0;
   WindowDelegate* d = container_->window_delegate();
 
   // Size the window icon, if visible.
   if (d->ShouldShowWindowIcon()) {
     system_menu_button_->SetVisible(true);
-    CSize ps;
-    system_menu_button_->GetPreferredSize(&ps);
+    gfx::Size ps = system_menu_button_->GetPreferredSize();
     system_menu_button_->SetBounds(
-        kWindowIconLeftOffset, kWindowIconTopOffset + top_offset, ps.cx, ps.cy);
+        kWindowIconLeftOffset, kWindowIconTopOffset + top_offset, ps.width(),
+        ps.height());
   } else {
     // Put the menu in the right place at least even if it is hidden so we
     // can size the title based on its position.
     system_menu_button_->SetBounds(kWindowIconLeftOffset,
                                    kWindowIconTopOffset, 0, 0);
   }
 
   // Size the title, if visible.
   if (d->ShouldShowWindowTitle()) {
     gfx::Rect system_menu_bounds = system_menu_button_->bounds();
@@ skipping 68 matching lines @@
   virtual void Layout(ChromeViews::View* host) {
     int horizontal_border_width =
         window_->IsMaximized() ? kBorderAndPadding : 0;
     int vertical_border_height =
         window_->IsMaximized() ? kBorderAndPadding : 0;
 
     child_->SetBounds(horizontal_border_width, vertical_border_height,
                       host->width() - (2 * horizontal_border_width),
                       host->height() - (2 * vertical_border_height));
   }
-  virtual void GetPreferredSize(ChromeViews::View* host, CSize* out) {
-    child_->GetPreferredSize(out);
+  virtual gfx::Size GetPreferredSize(ChromeViews::View* host) {
+    return child_->GetPreferredSize();
   }
 
  private:
   ChromeViews::View* child_;
   ChromeViews::Window* window_;
 
   DISALLOW_COPY_AND_ASSIGN(NonClientViewLayout);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 74 matching lines @@
 }
 
 void CustomFrameWindow::DisableInactiveRendering(bool disable) {
   Window::DisableInactiveRendering(disable);
   non_client_view_->set_paint_as_active(disable);
   if (!disable)
     non_client_view_->SchedulePaint();
 }
 
 void CustomFrameWindow::SizeWindowToDefault() {
-  CSize pref(0, 0);
-  client_view()->GetPreferredSize(&pref);
-  DCHECK(pref.cx > 0 && pref.cy > 0);
+  gfx::Size pref = client_view()->GetPreferredSize();
+  DCHECK(pref.width() > 0 && pref.height() > 0);
   gfx::Size window_size =
-      non_client_view_->CalculateWindowSizeForClientSize(pref.cx, pref.cy);
+      non_client_view_->CalculateWindowSizeForClientSize(pref.width(),
+                                                         pref.height());
   win_util::CenterAndSizeWindow(owning_window(), GetHWND(),
                                 window_size.ToSIZE(), false);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CustomFrameWindow, HWNDViewContainer overrides:
 
 void CustomFrameWindow::OnGetMinMaxInfo(MINMAXINFO* minmax_info) {
   // We handle this message so that we can make sure we interact nicely with
   // the taskbar on different edges of the screen and auto-hide taskbars.
@@ skipping 337 matching lines @@
     SetWindowRgn(new_region, TRUE);
   } else if (new_region) {
     DeleteObject(new_region);
   }
 
   DeleteObject(current_rgn);
 }
 
 }  // namespace ChromeViews