Convert GetPreferredSize from:...

chrome/browser/views/download_shelf_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/download_shelf_view.h"
 
 #include <algorithm>
 
 #include "chrome/app/theme/theme_resources.h"
 #include "chrome/browser/browser.h"
@@ skipping 42 matching lines @@
 static const SkColor kBorderColor = SkColorSetRGB(214, 214, 214);
 
 // New download item animation speed in milliseconds.
 static const int kNewItemAnimationDurationMs = 800;
 
 // Shelf show/hide speed.
 static const int kShelfAnimationDurationMs = 120;
 
 namespace {
 
-// Sets size->cx to view's preferred width + size->cx.
-// Sets size->cy to the max of the view's preferred height and size->cy;
-void AdjustSize(ChromeViews::View* view, CSize* size) {
-  CSize view_preferred;
-  view->GetPreferredSize(&view_preferred);
-  size->cx += view_preferred.cx;
-  size->cy = std::max(view_preferred.cy, size->cy);
+// Sets size->width() to view's preferred width + size->width().s
+// Sets size->height() to the max of the view's preferred height and
+// size->height();
+void AdjustSize(ChromeViews::View* view, gfx::Size* size) {
+  gfx::Size view_preferred = view->GetPreferredSize();
+  size->Enlarge(view_preferred.width(), 0);

[Elliot Glaysher, 2008/10/15 17:21:46]

One general comment: I haven't seen a case yet where one of the parameters to
Enlarge( ) isn't 0. Have you thought about separating Enlarge() into
EnlargeWidth() and EnlargeHeight()?

[Ben Goodger (Google), 2008/10/15 17:37:32]

OK I tried EnlargeWidth and EnlargeHeight. But I don't like them. The purpose of
having these functions is to make some operations possible with less typing.
Otherwise we'd always use the setter/getters for the properties being adjusted.
While it might seem like it's simpler because it's only operating on one value,
EnlargeWidth/EnlargeHeight actually force wraps in some places where it's
awkward, because they're frequently longer than Enlarge(value, 0); or Enlarge(0,
value);

So I decided not to add EnlargeWidth and EnlargeHeight :-P

+  size->set_height(std::max(view_preferred.height(), size->height()));
 }
 
 int CenterPosition(int size, int target_size) {
   return std::max((target_size - size) / 2, kTopBottomPadding);
 }
 
 } // namespace
 
 DownloadShelfView::DownloadShelfView(TabContents* tab_contents)
     : tab_contents_(tab_contents) {
@@ skipping 72 matching lines @@
 
 void DownloadShelfView::Paint(ChromeCanvas* canvas) {
   PaintBackground(canvas);
   PaintBorder(canvas);
 }
 
 void DownloadShelfView::PaintBorder(ChromeCanvas* canvas) {
   canvas->FillRectInt(kBorderColor, 0, 0, width(), 1);
 }
 
-void DownloadShelfView::GetPreferredSize(CSize *out) {
-  out->cx = kRightPadding + kLeftPadding + kCloseAndLinkPadding;
-  out->cy = 0;
-  AdjustSize(close_button_, out);
-  AdjustSize(show_all_view_, out);
+gfx::Size DownloadShelfView::GetPreferredSize() {
+  gfx::Size prefsize(kRightPadding + kLeftPadding + kCloseAndLinkPadding, 0);
+  AdjustSize(close_button_, &prefsize);
+  AdjustSize(show_all_view_, &prefsize);
   // Add one download view to the preferred size.
   if (download_views_.size() > 0) {
-    AdjustSize(*download_views_.begin(), out);
-    out->cx += kDownloadPadding;
+    AdjustSize(*download_views_.begin(), &prefsize);
+    prefsize.Enlarge(kDownloadPadding, 0);
   }
-  out->cy += kTopBottomPadding + kTopBottomPadding;
+  prefsize.Enlarge(0, kTopBottomPadding + kTopBottomPadding);
   if (shelf_animation_->IsAnimating()) {
-    out->cy = static_cast<int>(static_cast<double>(out->cy) *
-              shelf_animation_->GetCurrentValue());
+    prefsize.set_height(static_cast<int>(
+        static_cast<double>(prefsize.height()) *
+                            shelf_animation_->GetCurrentValue()));
   }
+  return prefsize;
 }
 
 void DownloadShelfView::DidChangeBounds(const CRect& previous,
                                         const CRect& current) {
   Layout();
 }
 
 void DownloadShelfView::AnimationProgressed(const Animation *animation) {
   if (animation == new_item_animation_.get()) {
     Layout();
     SchedulePaint();
   } else if (animation == shelf_animation_.get()) {
     // Force a re-layout of the parent, which will call back into
     // GetPreferredSize, where we will do our animation. In the  case where the
     // animation is hiding, we do a full resize - the fast resizing would
     // otherwise leave blank white areas where the shelf was and where the
     // user's eye is. Thankfully bottom-resizing is a lot faster than
     // top-resizing.
     tab_contents_->ToolbarSizeChanged(shelf_animation_->IsShowing());
   }
 }
 
 void DownloadShelfView::AnimationEnded(const Animation *animation) {
   if (animation == shelf_animation_.get()) {
     tab_contents_->SetDownloadShelfVisible(shelf_animation_->IsShowing());
   }
 }
 
 void DownloadShelfView::Layout() {
-  CSize image_size;
-  arrow_image_->GetPreferredSize(&image_size);
-  CSize close_button_size;
-  close_button_->GetPreferredSize(&close_button_size);
-  CSize show_all_size;
-  show_all_view_->GetPreferredSize(&show_all_size);
+  gfx::Size image_size = arrow_image_->GetPreferredSize();
+  gfx::Size close_button_size = close_button_->GetPreferredSize();
+  gfx::Size show_all_size = show_all_view_->GetPreferredSize();
   int max_download_x =
-      std::max<int>(0, width() - kRightPadding - close_button_size.cx -
-                       kCloseAndLinkPadding - show_all_size.cx -
-                       image_size.cx - kDownloadPadding);
+      std::max<int>(0, width() - kRightPadding - close_button_size.width() -
+                       kCloseAndLinkPadding - show_all_size.width() -
+                       image_size.width() - kDownloadPadding);
   int next_x = max_download_x + kDownloadPadding;
   // Align vertically with show_all_view_.
-  arrow_image_->SetBounds(next_x, CenterPosition(show_all_size.cy, height()),
-                          image_size.cx, image_size.cy);
-  next_x += image_size.cx + kDownloadsTitlePadding;
+  arrow_image_->SetBounds(next_x,
+                          CenterPosition(show_all_size.height(), height()),
+                          image_size.width(), image_size.height());
+  next_x += image_size.width() + kDownloadsTitlePadding;
   show_all_view_->SetBounds(next_x,
-                            CenterPosition(show_all_size.cy, height()),
-                            show_all_size.cx,
-                            show_all_size.cy);
-  next_x += show_all_size.cx + kCloseAndLinkPadding;
+                            CenterPosition(show_all_size.height(), height()),
+                            show_all_size.width(),
+                            show_all_size.height());
+  next_x += show_all_size.width() + kCloseAndLinkPadding;
   close_button_->SetBounds(next_x,
-                           CenterPosition(close_button_size.cy, height()),
-                           close_button_size.cx,
-                           close_button_size.cy);
+                           CenterPosition(close_button_size.height(), height()),
+                           close_button_size.width(),
+                           close_button_size.height());
 
   next_x = kLeftPadding;
   std::vector<View*>::reverse_iterator ri;
   for (ri = download_views_.rbegin(); ri != download_views_.rend(); ++ri) {
-    CSize view_size;
-    (*ri)->GetPreferredSize(&view_size);
+    gfx::Size view_size = (*ri)->GetPreferredSize();
 
     int x = next_x;
 
     // Figure out width of item.
-    int item_width = view_size.cx;
+    int item_width = view_size.width();
     if (new_item_animation_->IsAnimating() && ri == download_views_.rbegin()) {
-       item_width = static_cast<int>(static_cast<double>(view_size.cx) *
+       item_width = static_cast<int>(static_cast<double>(view_size.width()) *
                      new_item_animation_->GetCurrentValue());
     }
 
     next_x += (item_width + kDownloadPadding);
 
     // Make sure our item can be contained within the shelf.
     if (next_x < max_download_x) {
       (*ri)->SetVisible(true);
-      (*ri)->SetBounds(x, CenterPosition(view_size.cy, height()), item_width,
-                       view_size.cy);
+      (*ri)->SetBounds(x, CenterPosition(view_size.height(), height()),
+                       item_width, view_size.height());
     } else {
       (*ri)->SetVisible(false);
     }
   }
 }
 
 // Open the download page.
 void DownloadShelfView::LinkActivated(ChromeViews::Link* source,
                                       int event_flags) {
   int index;
   NavigationController* controller = tab_contents_->controller();
   Browser* browser = Browser::GetBrowserForController(controller, &index);
   DCHECK(browser);
   browser->ShowNativeUI(DownloadTabUI::GetURL());
 }
 
 void DownloadShelfView::ButtonPressed(ChromeViews::BaseButton* button) {
   shelf_animation_->Hide();
 }