Convert GetPreferredSize from:...

chrome/browser/views/tabs/tab_strip.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/tabs/tab_strip.h"
 
 #include "base/gfx/size.h"
 #include "chrome/app/theme/theme_resources.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents.h"
@@ skipping 179 matching lines @@
   // Figure out the desired start and end widths for the specified pre- and
   // post- animation tab counts.
   void GenerateStartAndEndWidths(int start_tab_count, int end_tab_count) {
     tabstrip_->GetDesiredTabWidths(start_tab_count, &start_unselected_width_,
                                    &start_selected_width_);
     double standard_tab_width =
         static_cast<double>(TabRenderer::GetStandardSize().width());
     if (start_tab_count < end_tab_count &&
         start_unselected_width_ < standard_tab_width) {
       double minimum_tab_width =
-          static_cast<double>(TabRenderer::GetMinimumSize().width());
+          static_cast<double>(TabRenderer::GetMinimumUnselectedSize().width());
       start_unselected_width_ -= minimum_tab_width / start_tab_count;
     }
     tabstrip_->GenerateIdealBounds();
     tabstrip_->GetDesiredTabWidths(end_tab_count,
                                    &end_unselected_width_,
                                    &end_selected_width_);
   }
 
   TabStrip* tabstrip_;
   SlideAnimation animation_;
@@ skipping 29 matching lines @@
   virtual ~InsertTabAnimation() {}
 
  protected:
   // Overridden from TabStrip::TabAnimation:
   virtual double GetWidthForTab(int index) const {
     if (index == index_) {
       bool is_selected = tabstrip_->model()->selected_index() == index;
       double target_width =
           is_selected ? end_unselected_width_ : end_selected_width_;
       double start_width = is_selected ? Tab::GetMinimumSelectedSize().width() :
-          Tab::GetMinimumSize().width();
+          Tab::GetMinimumUnselectedSize().width();
       double delta = target_width - start_width;
       if (delta > 0)
         return start_width + (delta * animation_.GetCurrentValue());
       return start_width;
     }
     if (tabstrip_->GetTabAt(index)->IsSelected()) {
       double delta = end_selected_width_ - start_selected_width_;
       return start_selected_width_ + (delta * animation_.GetCurrentValue());
     }
     double delta = end_unselected_width_ - start_unselected_width_;
@@ skipping 26 matching lines @@
 
  protected:
   // Overridden from TabStrip::TabAnimation:
   virtual double GetWidthForTab(int index) const {
     Tab* tab = tabstrip_->GetTabAt(index);
     if (index == index_) {
       // The tab(s) being removed are gradually shrunken depending on the state
       // of the animation.
       // Removed animated Tabs are never selected.
       double start_width = start_unselected_width_;
-      double target_width = Tab::GetMinimumSize().width() + kTabHOffset;
+      double target_width =
+          Tab::GetMinimumUnselectedSize().width() + kTabHOffset;
       double delta = start_width - target_width;
       return start_width - (delta * animation_.GetCurrentValue());
     }
     if (tabstrip_->available_width_for_tabs_ != -1 &&
         index_ != tabstrip_->GetTabCount() - 1) {
       return TabStrip::TabAnimation::GetWidthForTab(index);
     }
     // All other tabs are sized according to the start/end widths specified at
     // the start of the animation.
     if (tab->IsSelected()) {
@@ skipping 193 matching lines @@
   // TODO(beng): remove this if it doesn't work to fix the TabSelectedAt bug.
   drag_controller_.reset(NULL);
 
   // Make sure we unhook ourselves as a message loop observer so that we don't
   // crash in the case where the user closes the window after closing a tab
   // but before moving the mouse.
   RemoveMessageLoopObserver();
 }
 
 int TabStrip::GetPreferredHeight() {
-  CSize preferred_size;
-  GetPreferredSize(&preferred_size);
-  return preferred_size.cy;
+  return GetPreferredSize().height();
 }
 
 bool TabStrip::HasAvailableDragActions() const {
   return model_->delegate()->GetDragActions() != 0;
 }
 
 void TabStrip::ShowApplicationMenu(const gfx::Point& p) {
   TabStripModelDelegate* delegate = model_->delegate();
   if (delegate)
     delegate->ShowApplicationMenu(p);
@@ skipping 145 matching lines @@
   for (int i = 0; i < tab_count; ++i) {
     const gfx::Rect& bounds = tab_data_.at(i).ideal_bounds;
     GetTabAt(i)->SetBounds(bounds.x(), bounds.y(), bounds.width(),
                            bounds.height());
     tab_right = bounds.right() + kTabHOffset;
   }
   LayoutNewTabButton(static_cast<double>(tab_right), current_unselected_width_);
   SchedulePaint();
 }
 
-void TabStrip::GetPreferredSize(CSize* preferred_size) {
-  DCHECK(preferred_size);
-  preferred_size->cx = 0;
-  preferred_size->cy = Tab::GetMinimumSize().height();
+gfx::Size TabStrip::GetPreferredSize() {
+  return gfx::Size(0, Tab::GetMinimumUnselectedSize().height());
 }
 
 void TabStrip::OnDragEntered(const DropTargetEvent& event) {
   UpdateDropIndex(event);
 }
 
 int TabStrip::OnDragUpdated(const DropTargetEvent& event) {
   UpdateDropIndex(event);
   return GetDropEffect(event);
 }
@@ skipping 457 matching lines @@
 
 void TabStrip::GetCurrentTabWidths(double* unselected_width,
                                    double* selected_width) const {
   *unselected_width = current_unselected_width_;
   *selected_width = current_selected_width_;
 }
 
 void TabStrip::GetDesiredTabWidths(int tab_count,
                                    double* unselected_width,
                                    double* selected_width) const {
-  const double min_unselected_width = Tab::GetMinimumSize().width();
+  const double min_unselected_width = Tab::GetMinimumUnselectedSize().width();
   const double min_selected_width = Tab::GetMinimumSelectedSize().width();
   if (tab_count == 0) {
     // Return immediately to avoid divide-by-zero below.
     *unselected_width = min_unselected_width;
     *selected_width = min_selected_width;
     return;
   }
 
   // Determine how much space we can actually allocate to tabs.
   int available_width;
@@ skipping 395 matching lines @@
   return last_tab->x() + last_tab->width();
 }
 
 bool TabStrip::IsPointInTab(Tab* tab,
                             const gfx::Point& point_in_tabstrip_coords) {
   gfx::Point point_in_tab_coords(point_in_tabstrip_coords);
   View::ConvertPointToView(this, tab, &point_in_tab_coords);
   return tab->HitTest(point_in_tab_coords);
 }