Convert GetPreferredSize from:...

chrome/browser/views/old_frames/vista_frame.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/old_frames/vista_frame.h"
 
 #include <windows.h>
 #include <atlbase.h>
 #include <atlapp.h>
 #include <atltheme.h>
@@ skipping 163 matching lines @@
   int height = client_rect.Height();
 
   root_view_.SetBounds(0, 0, width, height);
   frame_view_->SetBounds(0, 0, width, height);
 
   if (IsTabStripVisible()) {
     tabstrip_->SetVisible(true);
     int tabstrip_x = g_bitmaps[CT_LEFT_SIDE]->width();
     if (is_off_the_record_) {
       off_the_record_image_->SetVisible(true);
-      CSize otr_image_size;
-      off_the_record_image_->GetPreferredSize(&otr_image_size);
-      tabstrip_x += otr_image_size.cx + (2 * kOTRImageHorizMargin);
+      gfx::Size otr_image_size = off_the_record_image_->GetPreferredSize();
+      tabstrip_x += otr_image_size.width() + (2 * kOTRImageHorizMargin);
       gfx::Rect off_the_record_bounds;
       if (IsZoomed()) {
         off_the_record_bounds.SetRect(g_bitmaps[CT_LEFT_SIDE]->width(),
                                       kResizeBorder,
-                                      otr_image_size.cx,
+                                      otr_image_size.width(),
                                       tabstrip_->GetPreferredHeight() -
                                       kToolbarOverlapVertOffset + 1);
       } else {
         off_the_record_bounds.SetRect(g_bitmaps[CT_LEFT_SIDE]->width(),
                                       kResizeBorder + kTitlebarHeight +
                                       tabstrip_->GetPreferredHeight() -
-                                      otr_image_size.cy -
+                                      otr_image_size.height() -
                                       kToolbarOverlapVertOffset + 1,
-                                      otr_image_size.cx,
-                                      otr_image_size.cy);
+                                      otr_image_size.width(),
+                                      otr_image_size.height());
       }
 
       if (frame_view_->UILayoutIsRightToLeft())
         off_the_record_bounds.set_x(frame_view_->MirroredLeftPointForRect(
             off_the_record_bounds));
       off_the_record_image_->SetBounds(off_the_record_bounds.x(),
                                        off_the_record_bounds.y(),
                                        off_the_record_bounds.width(),
                                        off_the_record_bounds.height());
 
@@ skipping 14 matching lines @@
     // If we are maxmized, the tab strip will be in line with the window
     // controls, so we need to make sure they don't overlap.
     int zoomed_offset = 0;
     if (distributor_logo_) {
       if(IsZoomed()) {
         zoomed_offset = std::max(min_offset, kWindowControlsMinOffset);
 
         // Hide the distributor logo if we're zoomed.
         distributor_logo_->SetVisible(false);
       } else {
-        CSize distributor_logo_size;
-        distributor_logo_->GetPreferredSize(&distributor_logo_size);
+        gfx::Size distributor_logo_size =
+            distributor_logo_->GetPreferredSize();
 
         int logo_x;
         // Because of Bug 1128173, our Window controls aren't actually flipped 
         // on Vista, yet all our math and layout presumes that they are.
         if (frame_view_->UILayoutIsRightToLeft())
-          logo_x = width - distributor_logo_size.cx;
+          logo_x = width - distributor_logo_size.width();
         else
-          logo_x = width - min_offset - distributor_logo_size.cx;
+          logo_x = width - min_offset - distributor_logo_size.width();
 
         distributor_logo_->SetVisible(true);
         distributor_logo_->SetBounds(logo_x,
             kDistributorLogoVerticalOffset,
-            distributor_logo_size.cx,
-            distributor_logo_size.cy);
+            distributor_logo_size.width(),
+            distributor_logo_size.height());
       }
     }
 
     gfx::Rect tabstrip_bounds(tabstrip_x,
                               kResizeBorder + (IsZoomed() ?
                                   kDwmBorderSize : kTitlebarHeight),
                               width - tabstrip_x - kTabStripRightHorizOffset -
                               zoomed_offset,
                               tabstrip_->GetPreferredHeight());
     if (frame_view_->UILayoutIsRightToLeft() &&
@@ skipping 40 matching lines @@
     browser_w = width - g_bitmaps[CT_LEFT_SIDE]->width() -
         g_bitmaps[CT_RIGHT_SIDE]->width();
     browser_h = height - browser_y - g_bitmaps[CT_BOTTOM_CENTER]->height();
   } else {
     browser_x = 0;
     browser_y = toolbar_bottom;
     browser_w = width;
     browser_h = height;
   }
 
-  CSize preferred_size;
+  gfx::Size preferred_size;
   if (shelf_view_) {
-    shelf_view_->GetPreferredSize(&preferred_size);
+    preferred_size = shelf_view_->GetPreferredSize();
     shelf_view_->SetBounds(browser_x,
                            height - g_bitmaps[CT_BOTTOM_CENTER]->height() -
-                           preferred_size.cy,
+                           preferred_size.height(),
                            browser_w,
-                           preferred_size.cy);
-    browser_h -= preferred_size.cy;
+                           preferred_size.height());
+    browser_h -= preferred_size.height();
   }
 
-  CSize bookmark_bar_size;
-  CSize info_bar_size;
+  gfx::Size bookmark_bar_size;
+  gfx::Size info_bar_size;
 
   if (bookmark_bar_view_.get())
-    bookmark_bar_view_->GetPreferredSize(&bookmark_bar_size);
+    bookmark_bar_size = bookmark_bar_view_->GetPreferredSize();
 
   if (info_bar_view_)
-    info_bar_view_->GetPreferredSize(&info_bar_size);
+    info_bar_size = info_bar_view_->GetPreferredSize();
 
   // If we're showing a bookmarks bar in the new tab page style and we
   // have an infobar showing, we need to flip them.
   if (info_bar_view_ &&
       bookmark_bar_view_.get() &&
       bookmark_bar_view_->IsNewTabPage() &&
       !bookmark_bar_view_->IsAlwaysShown()) {
     info_bar_view_->SetBounds(browser_x,
                               browser_y,
                               browser_w,
-                              info_bar_size.cy);
-    browser_h -= info_bar_size.cy;
+                              info_bar_size.height());
+    browser_h -= info_bar_size.height();
 
-    browser_y += info_bar_size.cy - kSeparationLineHeight;
+    browser_y += info_bar_size.height() - kSeparationLineHeight;
 
     bookmark_bar_view_->SetBounds(browser_x,
                                   browser_y,
                                   browser_w,
-                                  bookmark_bar_size.cy);
-    browser_h -= bookmark_bar_size.cy - kSeparationLineHeight;
-    browser_y += bookmark_bar_size.cy;
+                                  bookmark_bar_size.height());
+    browser_h -= bookmark_bar_size.height() - kSeparationLineHeight;
+    browser_y += bookmark_bar_size.height();
   } else {
     if (bookmark_bar_view_.get()) {
       // We want our bookmarks bar to be responsible for drawing its own
       // separator, so we let it overlap ours.
       browser_y -= kSeparationLineHeight;
 
       bookmark_bar_view_->SetBounds(browser_x,
                                     browser_y,
                                     browser_w,
-                                    bookmark_bar_size.cy);
-      browser_h -= bookmark_bar_size.cy - kSeparationLineHeight;
-      browser_y += bookmark_bar_size.cy;
+                                    bookmark_bar_size.height());
+      browser_h -= bookmark_bar_size.height() - kSeparationLineHeight;
+      browser_y += bookmark_bar_size.height();
     }
 
     if (info_bar_view_) {
       info_bar_view_->SetBounds(browser_x,
                                 browser_y,
                                 browser_w,
-                                info_bar_size.cy);
-      browser_h -= info_bar_size.cy;
-      browser_y += info_bar_size.cy;
+                                info_bar_size.height());
+      browser_h -= info_bar_size.height();
+      browser_y += info_bar_size.height();
     }
   }
 
   // While our OnNCCalcSize handler does a good job of covering most of the
   // cases where we need to do this, it unfortunately doesn't cover the
   // case where we're returning from maximized mode.
   ResetDWMFrame();
 
   tab_contents_container_->SetBounds(browser_x,
                                      browser_y,
@@ skipping 267 matching lines @@
 void VistaFrame::FocusToolbar() {
 }
 
 bool VistaFrame::IsBookmarkBarVisible() const {
   if (!bookmark_bar_view_.get())
     return false;
 
   if (bookmark_bar_view_->IsNewTabPage() || bookmark_bar_view_->IsAnimating())
     return true;
 
-  CSize sz;
-  bookmark_bar_view_->GetPreferredSize(&sz);
   // 1 is the minimum in GetPreferredSize for the bookmark bar.
-  return sz.cy > 1;
+  return bookmark_bar_view_->GetPreferredSize().height() > 1;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Events
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 LRESULT VistaFrame::OnSettingChange(UINT u_msg, WPARAM w_param, LPARAM l_param,
                                     BOOL& handled) {
@@ skipping 765 matching lines @@
     tab_contents_container_->UpdateHWNDBounds();
   }
 }
 
 bool VistaFrame::UpdateChildViewAndLayout(ChromeViews::View* new_view,
                                           ChromeViews::View** view) {
   DCHECK(view);
   if (*view == new_view) {
     // The views haven't changed, if the views pref changed schedule a layout.
     if (new_view) {
-      CSize pref_size;
-      new_view->GetPreferredSize(&pref_size);
-      if (pref_size.cy != new_view->height())
+      if (new_view->GetPreferredSize().height() != new_view->height())
         return true;
     }
     return false;
   }
 
   // The views differ, and one may be null (but not both). Remove the old
   // view (if it non-null), and add the new one (if it is non-null). If the
   // height has changed, schedule a layout, otherwise reuse the existing
   // bounds to avoid scheduling a layout.
 
   int current_height = 0;
   if (*view) {
     current_height = (*view)->height();
     root_view_.RemoveChildView(*view);
   }
 
   int new_height = 0;
   if (new_view) {
-    CSize preferred_size;
-    new_view->GetPreferredSize(&preferred_size);
-    new_height = preferred_size.cy;
+    new_height = new_view->GetPreferredSize().height();
     root_view_.AddChildView(new_view);
   }
 
   bool changed = false;
   if (new_height != current_height) {
     changed = true;
   } else if (new_view && *view) {
     // The view changed, but the new view wants the same size, give it the
     // bounds of the last view and have it repaint.
     new_view->SetBounds((*view)->bounds().ToRECT());
@@ skipping 144 matching lines @@
                                       &active_bookmark_bar_);
 
   // Only do a layout if the current contents is non-null. We assume that if the
   // contents is NULL, we're either being destroyed, or ShowTabContents is going
   // to be invoked with a non-null TabContents again so that there is no need
   // in doing a layout now (and would result in extra work/invalidation on
   // tab switches).
   if (changed && current_tab)
     Layout();
 }