Convert GetPreferredSize from:...

chrome/browser/views/download_tab_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_tab_view.h"
 
 #include <time.h>
 
 #include <algorithm>
 #include <functional>
@@ skipping 176 matching lines @@
 }
 
 void DownloadItemTabView::SetModel(DownloadItem* model,
                                    DownloadTabView* parent) {
   DCHECK(model && parent);
   model_ = model;
   parent_ = parent;
   parent_->LookupIcon(model_);
 }
 
-void DownloadItemTabView::GetPreferredSize(CSize* out) {
-  CSize pause_size;
-  pause_->GetPreferredSize(&pause_size);
-  CSize cancel_size;
-  cancel_->GetPreferredSize(&cancel_size);
-  CSize show_size;
-  show_->GetPreferredSize(&show_size);
-
-  out->cx = download_util::kBigProgressIconSize +
-            2 * kSpacer +
-            kHorizontalLinkPadding +
-            kFilenameSize +
-            std::max(pause_size.cx + cancel_size.cx + kHorizontalLinkPadding,
-                     show_size.cx);
-
-  out->cy = download_util::kBigProgressIconSize;
+gfx::Size DownloadItemTabView::GetPreferredSize() {
+  gfx::Size pause_size = pause_->GetPreferredSize();
+  gfx::Size cancel_size = cancel_->GetPreferredSize();
+  gfx::Size show_size = show_->GetPreferredSize();
+  return gfx::Size(
+      download_util::kBigProgressIconSize +
+          2 * kSpacer +
+          kHorizontalLinkPadding +
+          kFilenameSize +
+          std::max(pause_size.width() + cancel_size.width() +
+                       kHorizontalLinkPadding,
+                   show_size.width()),
+      download_util::kBigProgressIconSize);
 }
 
 // Each DownloadItemTabView has reasonably complex layout requirements
 // that are based on the state of its model. To make the code much simpler
 // to read, Layout() is split into state specific code which will result
 // in some redundant code.
 void DownloadItemTabView::Layout() {
   DCHECK(model_);
   switch (model_->state()) {
     case DownloadItem::COMPLETE:
@@ skipping 20 matching lines @@
 
 // Only display the date if the download is the last that occurred
 // on a given day.
 void DownloadItemTabView::LayoutDate() {
   if (!parent_->ShouldDrawDateForDownload(model_)) {
     since_->SetVisible(false);
     date_->SetVisible(false);
     return;
   }
 
-  CSize since_size;
-
   since_->SetText(TimeFormat::RelativeDate(model_->start_time(), NULL));
-  since_->GetPreferredSize(&since_size);
+  gfx::Size since_size = since_->GetPreferredSize();
   since_->SetBounds(kLeftMargin, download_util::kBigProgressIconOffset,
-                    kDateSize, since_size.cy);
+                    kDateSize, since_size.height());
   since_->SetVisible(true);
 
-  CSize date_size;
   date_->SetText(base::TimeFormatShortDate(model_->start_time()));
-  date_->GetPreferredSize(&date_size);
-  date_->SetBounds(kLeftMargin, since_size.cy + kVerticalPadding +
-                      download_util::kBigProgressIconOffset,
-                   kDateSize, date_size.cy);
+  gfx::Size date_size = date_->GetPreferredSize();
+  date_->SetBounds(kLeftMargin, since_size.height() + kVerticalPadding +
+                       download_util::kBigProgressIconOffset,
+                   kDateSize, date_size.height());
   date_->SetVisible(true);
 }
 
 // DownloadItem::COMPLETE state layout
 void DownloadItemTabView::LayoutComplete() {
   // Hide unused UI elements
   pause_->SetVisible(false);
   pause_->SetEnabled(false);
   cancel_->SetVisible(false);
   cancel_->SetEnabled(false);
   time_remaining_->SetVisible(false);
   download_progress_->SetVisible(false);
   dangerous_download_warning_->SetVisible(false);
   save_button_->SetVisible(false);
   save_button_->SetEnabled(false);
   discard_button_->SetVisible(false);
   discard_button_->SetEnabled(false);
 
   LayoutDate();
   int dx = kDownloadIconOffset - download_util::kBigProgressIconOffset +
            download_util::kBigProgressIconSize + kInfoPadding;
 
   // File name and URL
-  CSize file_name_size;
   file_name_->SetText(model_->file_name());
-  file_name_->GetPreferredSize(&file_name_size);
+  gfx::Size file_name_size = file_name_->GetPreferredSize();
   file_name_->SetBounds(dx, download_util::kBigProgressIconOffset,
                         std::min(kFilenameSize,
-                                 static_cast<int>(file_name_size.cx)),
-                        file_name_size.cy);
+                                 static_cast<int>(file_name_size.width())),
+                        file_name_size.height());
   file_name_->SetVisible(true);
   file_name_->SetEnabled(true);
 
   GURL url(model_->url());
   download_url_->SetURL(url);
-  CSize url_size;
-  download_url_->GetPreferredSize(&url_size);
+  gfx::Size url_size = download_url_->GetPreferredSize();
   download_url_->SetBounds(dx,
-                           file_name_size.cy + kVerticalPadding +
-                              download_util::kBigProgressIconOffset,
+                           file_name_size.height() + kVerticalPadding +
+                               download_util::kBigProgressIconOffset,
                            std::min(kFilenameSize,
                                     static_cast<int>(width() - dx)),
-                           url_size.cy);
+                           url_size.height());
   download_url_->SetVisible(true);
   dx += kFilenameSize + kSpacer;
 
   // Action button (text is constant and set in constructor)
-  CSize show_size;
-  show_->GetPreferredSize(&show_size);
-  show_->SetBounds(dx, ((file_name_size.cy + url_size.cy) / 2) +
+  gfx::Size show_size = show_->GetPreferredSize();
+  show_->SetBounds(dx, ((file_name_size.height() + url_size.height()) / 2) +
                       download_util::kBigProgressIconOffset,
-                   show_size.cx, show_size.cy);
+                   show_size.width(), show_size.height());
   show_->SetVisible(true);
   show_->SetEnabled(true);
 }
 
 // DownloadItem::CANCELLED state layout
 void DownloadItemTabView::LayoutCancelled() {
   // Hide unused UI elements
   show_->SetVisible(false);
   show_->SetEnabled(false);
   pause_->SetVisible(false);
   pause_->SetEnabled(false);
   cancel_->SetVisible(false);
   cancel_->SetEnabled(false);
   dangerous_download_warning_->SetVisible(false);
   save_button_->SetVisible(false);
   save_button_->SetEnabled(false);
   discard_button_->SetVisible(false);
   discard_button_->SetEnabled(false);
 
   LayoutDate();
   int dx = kDownloadIconOffset - download_util::kBigProgressIconOffset +
       download_util::kBigProgressIconSize + kInfoPadding;
 
   // File name and URL, truncated to show cancelled status
-  CSize file_name_size;
   file_name_->SetText(model_->file_name());
-  file_name_->GetPreferredSize(&file_name_size);
+  gfx::Size file_name_size = file_name_->GetPreferredSize();
   file_name_->SetBounds(dx, download_util::kBigProgressIconOffset,
                         kFilenameSize - kProgressSize - kSpacer,
-                        file_name_size.cy);
+                        file_name_size.height());
   file_name_->SetVisible(true);
   file_name_->SetEnabled(false);
 
   GURL url(model_->url());
   download_url_->SetURL(url);
-  CSize url_size;
-  download_url_->GetPreferredSize(&url_size);
+  gfx::Size url_size = download_url_->GetPreferredSize();
   download_url_->SetBounds(dx,
-                           file_name_size.cy + kVerticalPadding +
+                           file_name_size.height() + kVerticalPadding +
                               download_util::kBigProgressIconOffset,
                            std::min(kFilenameSize - kProgressSize - kSpacer,
                                     static_cast<int>(width() - dx)),
-                           url_size.cy);
+                           url_size.height());
   download_url_->SetVisible(true);
 
   dx += kFilenameSize - kProgressSize;
 
   // Display cancelled status
-  CSize cancel_size;
   time_remaining_->SetColor(kStatusColor);
   time_remaining_->SetText(l10n_util::GetString(IDS_DOWNLOAD_TAB_CANCELLED));
-  time_remaining_->GetPreferredSize(&cancel_size);
+  gfx::Size cancel_size = time_remaining_->GetPreferredSize();
   time_remaining_->SetBounds(dx, download_util::kBigProgressIconOffset,
-                             kProgressSize, cancel_size.cy);
+                             kProgressSize, cancel_size.height());
   time_remaining_->SetVisible(true);
 
   // Display received size, we may not know the total size if the server didn't
   // provide a content-length.
   int64 total = model_->total_bytes();
   int64 size = model_->received_bytes();
   DataUnits amount_units = GetByteDisplayUnits(size);
   std::wstring received_size = FormatBytes(size, amount_units, true);
   std::wstring amount = received_size;
 
@@ skipping 14 matching lines @@
                                                   &total_text_localized))
       total_text.assign(total_text_localized);
 
     // Note that there is no need to adjust the new amount string for the
     // locale direction as ChromeViews::Label does that for us.
     amount = l10n_util::GetStringF(IDS_DOWNLOAD_TAB_PROGRESS_SIZE,
                                    received_size,
                                    total_text);
   }
 
-  CSize byte_size;
   download_progress_->SetText(amount);
-  download_progress_->GetPreferredSize(&byte_size);
+  gfx::Size byte_size = download_progress_->GetPreferredSize();
   download_progress_->SetBounds(dx,
-                                file_name_size.cy + kVerticalPadding +
+                                file_name_size.height() + kVerticalPadding +
                                 download_util::kBigProgressIconOffset,
                                 kProgressSize,
-                                byte_size.cy);
+                                byte_size.height());
   download_progress_->SetVisible(true);
 }
 
 // DownloadItem::IN_PROGRESS state layout
 void DownloadItemTabView::LayoutInProgress() {
   // Hide unused UI elements
   show_->SetVisible(false);
   show_->SetEnabled(false);
   dangerous_download_warning_->SetVisible(false);
   save_button_->SetVisible(false);
   save_button_->SetEnabled(false);
   discard_button_->SetVisible(false);
   discard_button_->SetEnabled(false);
 
   LayoutDate();
   int dx = kDownloadIconOffset - download_util::kBigProgressIconOffset +
             download_util::kBigProgressIconSize +
            kInfoPadding;
 
   // File name and URL, truncated to show progress status
-  CSize file_name_size;
   file_name_->SetText(model_->GetFileName());
-  file_name_->GetPreferredSize(&file_name_size);
+  gfx::Size file_name_size = file_name_->GetPreferredSize();
   file_name_->SetBounds(dx, download_util::kBigProgressIconOffset,
                         kFilenameSize - kProgressSize - kSpacer,
-                        file_name_size.cy);
+                        file_name_size.height());
   file_name_->SetVisible(true);
   file_name_->SetEnabled(false);
 
   GURL url(model_->url());
   download_url_->SetURL(url);
-  CSize url_size;
-  download_url_->GetPreferredSize(&url_size);
-  download_url_->SetBounds(dx, file_name_size.cy + kVerticalPadding +
+  gfx::Size url_size = download_url_->GetPreferredSize();
+  download_url_->SetBounds(dx, file_name_size.height() + kVerticalPadding +
                            download_util::kBigProgressIconOffset,
                            std::min(kFilenameSize - kProgressSize - kSpacer,
                                     static_cast<int>(width() - dx)),
-                           url_size.cy);
+                           url_size.height());
   download_url_->SetVisible(true);
 
   dx += kFilenameSize - kProgressSize;
 
   // Set the time remaining and progress display strings. This can
   // be complicated by not having received the total download size
   // In that case, we can't calculate time remaining so we just
   // display speed and received size.
 
   // Size
@@ skipping 48 matching lines @@
     // causes Windows to ignore the 'LRE'/'RLE'/'PDF' Unicode formatting
     // characters within the string and this causes the string to be displayed
     // incorrectly on RTL UIs. Therefore, we add the Unicode right-to-left
     // override character (U+202E) if the locale is RTL in order to fix this
     // problem.
     if (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT)
       progress.insert(0, L"\x202E");
   }
 
   // Time remaining
-  int y_pos = file_name_size.cy + kVerticalPadding +
+  int y_pos = file_name_size.height() + kVerticalPadding +
               download_util::kBigProgressIconOffset;
-  CSize time_size;
+  gfx::Size time_size;
   time_remaining_->SetColor(kStatusColor);
   if (model_->is_paused()) {
     time_remaining_->SetColor(kPauseColor);
     time_remaining_->SetText(
         l10n_util::GetString(IDS_DOWNLOAD_PROGRESS_PAUSED));
-    time_remaining_->GetPreferredSize(&time_size);
+    time_size = time_remaining_->GetPreferredSize();
     time_remaining_->SetBounds(dx, download_util::kBigProgressIconOffset,
-                               kProgressSize, time_size.cy);
+                               kProgressSize, time_size.height());
     time_remaining_->SetVisible(true);
   } else if (total > 0)  {
     TimeDelta remaining;
     if (model_->TimeRemaining(&remaining))
       time_remaining_->SetText(TimeFormat::TimeRemaining(remaining));
-    time_remaining_->GetPreferredSize(&time_size);
+    time_size = time_remaining_->GetPreferredSize();
     time_remaining_->SetBounds(dx, download_util::kBigProgressIconOffset,
-                               kProgressSize, time_size.cy);
+                               kProgressSize, time_size.height());
     time_remaining_->SetVisible(true);
   } else {
     time_remaining_->SetText(L"");
-    y_pos = ((file_name_size.cy + url_size.cy) / 2) +
+    y_pos = ((file_name_size.height() + url_size.height()) / 2) +
             download_util::kBigProgressIconOffset;
   }
 
-  CSize byte_size;
   download_progress_->SetText(progress);
-  download_progress_->GetPreferredSize(&byte_size);
+  gfx::Size byte_size = download_progress_->GetPreferredSize();
   download_progress_->SetBounds(dx, y_pos,
-                                kProgressSize, byte_size.cy);
+                                kProgressSize, byte_size.height());
   download_progress_->SetVisible(true);
 
   dx += kProgressSize + kSpacer;
-  y_pos = ((file_name_size.cy + url_size.cy) / 2) +
+  y_pos = ((file_name_size.height() + url_size.height()) / 2) +
           download_util::kBigProgressIconOffset;
 
   // Pause (or Resume) / Cancel buttons.
   if (model_->is_paused())
     pause_->SetText(l10n_util::GetString(IDS_DOWNLOAD_LINK_RESUME));
   else
     pause_->SetText(l10n_util::GetString(IDS_DOWNLOAD_LINK_PAUSE));
 
-  CSize pause_size;
   pause_->SetVisible(true);
   pause_->SetEnabled(true);
-  pause_->GetPreferredSize(&pause_size);
-  pause_->SetBounds(dx, y_pos, pause_size.cx, pause_size.cy);
+  gfx::Size pause_size = pause_->GetPreferredSize();
+  pause_->SetBounds(dx, y_pos, pause_size.width(), pause_size.height());
 
-  dx += pause_size.cx + kHorizontalLinkPadding;
+  dx += pause_size.width() + kHorizontalLinkPadding;
 
-  CSize cancel_size;
-  cancel_->GetPreferredSize(&cancel_size);
-  cancel_->SetBounds(dx, y_pos, cancel_size.cx, cancel_size.cy);
+  gfx::Size cancel_size = cancel_->GetPreferredSize();
+  cancel_->SetBounds(dx, y_pos, cancel_size.width(), cancel_size.height());
   cancel_->SetVisible(true);
   cancel_->SetEnabled(true);
 }
 
 void DownloadItemTabView::LayoutPromptDangerousDownload() {
   // Hide unused UI elements
   show_->SetVisible(false);
   show_->SetEnabled(false);
   file_name_->SetVisible(false);
   file_name_->SetEnabled(false);
   pause_->SetVisible(false);
   pause_->SetEnabled(false);
   cancel_->SetVisible(false);
   cancel_->SetEnabled(false);
   time_remaining_->SetVisible(false);
   download_progress_->SetVisible(false);
 
   LayoutDate();
   int dx = kDownloadIconOffset - download_util::kBigProgressIconOffset +
            download_util::kBigProgressIconSize +
            kInfoPadding;
 
   // Warning message and URL.
-  CSize warning_size;
   std::wstring file_name;
   ElideString(model_->original_name(), kFileNameMaxLength, &file_name);
   dangerous_download_warning_->SetText(
       l10n_util::GetStringF(IDS_PROMPT_DANGEROUS_DOWNLOAD, file_name));
-  dangerous_download_warning_->GetPreferredSize(&warning_size);
+  gfx::Size warning_size = dangerous_download_warning_->GetPreferredSize();
   dangerous_download_warning_->SetBounds(dx, 0,
-                                         kFilenameSize, warning_size.cy);
+                                         kFilenameSize, warning_size.height());
   dangerous_download_warning_->SetVisible(true);
 
   GURL url(model_->url());
   download_url_->SetURL(url);
-  CSize url_size;
-  download_url_->GetPreferredSize(&url_size);
-  download_url_->SetBounds(dx, height() - url_size.cy,
+  gfx::Size url_size = download_url_->GetPreferredSize();
+  download_url_->SetBounds(dx, height() - url_size.height(),
                            std::min(kFilenameSize - kSpacer,
                                     static_cast<int>(width() - dx)),
-                           url_size.cy);
+                           url_size.height());
   download_url_->SetVisible(true);
 
   dx += kFilenameSize + kSpacer;
 
   // Save/Discard buttons.
-  CSize button_size;
-  save_button_->GetPreferredSize(&button_size);
-  save_button_->SetBounds(dx, (height() - button_size.cy) / 2,
-                          button_size.cx, button_size.cy);
+  gfx::Size button_size = save_button_->GetPreferredSize();
+  save_button_->SetBounds(dx, (height() - button_size.height()) / 2,
+                          button_size.width(), button_size.height());
   save_button_->SetVisible(true);
   save_button_->SetEnabled(true);
 
-  dx += button_size.cx + kHorizontalButtonPadding;
+  dx += button_size.width() + kHorizontalButtonPadding;
 
-  discard_button_->GetPreferredSize(&button_size);
-  discard_button_->SetBounds(dx, (height() - button_size.cy) / 2,
-                             button_size.cx, button_size.cy);
+  button_size = discard_button_->GetPreferredSize();
+  discard_button_->SetBounds(dx, (height() - button_size.height()) / 2,
+                             button_size.width(), button_size.height());
   discard_button_->SetVisible(true);
   discard_button_->SetEnabled(true);
 }
 
 void DownloadItemTabView::Paint(ChromeCanvas* canvas) {
   PaintBackground(canvas);
 
   if (model_->state() == DownloadItem::IN_PROGRESS  &&
       model_->safety_state() != DownloadItem::DANGEROUS) {
     download_util::PaintDownloadProgress(canvas,
@@ skipping 689 matching lines @@
       DCHECK(profile()->HasCreatedDownloadManager());
       contents_->SetIsLoading(
           profile()->GetDownloadManager()->in_progress_count() > 0,
           NULL);
       break;
     default:
       break;
   }
 }