Some cleanup, using gfx::Size instead of CSize for ...

chrome/views/grid_layout.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/grid_layout.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "chrome/views/view.h"
@@ skipping 745 matching lines @@
 }
 
 void GridLayout::ViewRemoved(View* host, View* view) {
   DCHECK(host_ == host);
 }
 
 void GridLayout::Layout(View* host) {
   DCHECK(host_ == host);
   // SizeRowsAndColumns sets the size and location of each row/column, but
   // not of the views.
-  CSize pref;
+  gfx::Size pref;
   SizeRowsAndColumns(true, host_->width(), host_->height(), &pref);
 
   // Size each view.
   for (std::vector<ViewState*>::iterator i = view_states_.begin();
        i != view_states_.end(); ++i) {
     ViewState* view_state = *i;
     ColumnSet* column_set = view_state->column_set;
     View* view = (*i)->view;
     DCHECK(view);
     int x = column_set->columns_[view_state->start_col]->Location() +
             left_inset_;
     int width = column_set->GetColumnWidth(view_state->start_col,
                                            view_state->col_span);
     CalculateSize(view_state->pref_width, view_state->h_align,
                   &x, &width);
     int y = rows_[view_state->start_row]->Location() + top_inset_;
     int height = LayoutElement::TotalSize(view_state->start_row,
                                           view_state->row_span, &rows_);
     CalculateSize(view_state->pref_height, view_state->v_align,
                   &y, &height);
     view->SetBounds(x, y, width, height);
   }
 }
 
 gfx::Size GridLayout::GetPreferredSize(View* host) {
   DCHECK(host_ == host);
-  CSize out;
+  gfx::Size out;
   SizeRowsAndColumns(false, 0, 0, &out);
-  return gfx::Size(out.cx, out.cy);
+  return out;
 }
 
 int GridLayout::GetPreferredHeightForWidth(View* host, int width) {
   DCHECK(host_ == host);
-  CSize pref;
+  gfx::Size pref;
   SizeRowsAndColumns(false, width, 0, &pref);
-  return pref.cy;
+  return pref.height();
 }
 
 void GridLayout::SizeRowsAndColumns(bool layout, int width, int height,
-                                    CSize* pref) {
+                                    gfx::Size* pref) {
   // Make sure the master columns have been calculated.
   CalculateMasterColumnsIfNecessary();
-  pref->cx = pref->cy = 0;
+  pref->SetSize(0, 0);
   if (rows_.empty())
     return;
 
   // Calculate the size of each of the columns. Some views preferred heights are
   // derived from their width, as such we need to calculate the size of the
   // columns first.
   for (std::vector<ColumnSet*>::iterator i = column_sets_.begin();
        i != column_sets_.end(); ++i) {
     (*i)->CalculateSize();
     if (layout || width > 0) {
       // We're doing a layout, divy up any extra space.
       (*i)->Resize(width - (*i)->LayoutWidth() - left_inset_ - right_inset_);
       // And reset the x coordinates.
       (*i)->ResetColumnXCoordinates();
     }
-    pref->cx = std::max(static_cast<int>(pref->cx), (*i)->LayoutWidth());
+    pref->set_width(std::max(pref->width(), (*i)->LayoutWidth()));
   }
-  pref->cx += left_inset_ + right_inset_;
+  pref->set_width(pref->width() + left_inset_ + right_inset_);
 
   // Reset the height of each row.
   LayoutElement::ResetSizes(&rows_);
 
   // Do two things:
   // . Reset the remaining_height of each view state.
   // . If the width the view will be given is different than it's pref, ask
   //   for the height given a particularly width.
   for (std::vector<ViewState*>::iterator i= view_states_.begin();
        i != view_states_.end() ; ++i) {
@@ skipping 34 matching lines @@
     UpdateRemainingHeightFromRows(view_state);
 
     // Distribute the remaining height.
     DistributeRemainingHeight(view_state);
   }
 
   // Update the location of each of the rows.
   LayoutElement::CalculateLocationsFromSize(&rows_);
 
   // We now know the preferred height, set it here.
-  pref->cy = rows_[rows_.size() - 1]->Location() +
-             rows_[rows_.size() - 1]->Size() + top_inset_ + bottom_inset_;
+  pref->set_height(rows_[rows_.size() - 1]->Location() +
+             rows_[rows_.size() - 1]->Size() + top_inset_ + bottom_inset_);
 
-  if (layout && height != pref->cy) {
+  if (layout && height != pref->height()) {
     // We're doing a layout, and the height differs from the preferred height,
     // divy up the extra space.
-    LayoutElement::DistributeDelta(height - pref->cy, &rows_);
+    LayoutElement::DistributeDelta(height - pref->height(), &rows_);
 
     // Reset y locations.
     LayoutElement::CalculateLocationsFromSize(&rows_);
   }
 }
 
 void GridLayout::CalculateMasterColumnsIfNecessary() {
   if (!calculated_master_columns_) {
     calculated_master_columns_ = true;
     for (std::vector<ColumnSet*>::iterator i = column_sets_.begin();
@@ skipping 106 matching lines @@
 ColumnSet* GridLayout::GetLastValidColumnSet() {
   for (int i = current_row_ - 1; i >= 0; --i) {
     if (rows_[i]->column_set())
       return rows_[i]->column_set();
   }
   return NULL;
 }
 
 }  // namespace views