Remove stl_util's deletion function use from ui/views/.

ui/views/layout/grid_layout.cc

 // Copyright (c) 2012 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 "ui/views/layout/grid_layout.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/view.h"
 #include "ui/views/window/dialog_delegate.h"
 
 namespace views {
 
 // LayoutElement ------------------------------------------------------
 
 // A LayoutElement has a size and location along one axis. It contains
 // methods that are used along both axis.
 class LayoutElement {
  public:
   // Invokes ResetSize on all the layout elements.
   template <class T>
-  static void ResetSizes(std::vector<T*>* elements) {
+  static void ResetSizes(std::vector<std::unique_ptr<T>>* elements) {
     // Reset the layout width of each column.
-    for (typename std::vector<T*>::iterator i = elements->begin();
-         i != elements->end(); ++i) {
-      (*i)->ResetSize();
-    }
+    for (const auto& element : *elements)
+      element->ResetSize();
   }
 
   // Sets the location of each element to be the sum of the sizes of the
   // preceding elements.
   template <class T>
-  static void CalculateLocationsFromSize(std::vector<T*>* elements) {
+  static void CalculateLocationsFromSize(
+      std::vector<std::unique_ptr<T>>* elements) {
     // Reset the layout width of each column.
     int location = 0;
-    for (typename std::vector<T*>::iterator i = elements->begin();
-         i != elements->end(); ++i) {
-      (*i)->SetLocation(location);
-      location += (*i)->Size();
+    for (const auto& element : *elements) {
+      element->SetLocation(location);
+      location += element->Size();
     }
   }
 
   // Distributes delta among the resizable elements.
   // Each resizable element is given ResizePercent / total_percent * delta
   // pixels extra of space.
   template <class T>
-  static void DistributeDelta(int delta, std::vector<T*>* elements) {
+  static void DistributeDelta(int delta,
+                              std::vector<std::unique_ptr<T>>* elements) {
     if (delta == 0)
       return;
 
     float total_percent = 0;
     int resize_count = 0;
-    for (typename std::vector<T*>::iterator i = elements->begin();
-         i != elements->end(); ++i) {
-      total_percent += (*i)->ResizePercent();
-      if ((*i)->ResizePercent() > 0)
+    for (const auto& element : *elements) {
+      total_percent += element->ResizePercent();
+      if (element->ResizePercent() > 0)
         resize_count++;
     }
     if (total_percent == 0) {
       // None of the elements are resizable, return.
       return;
     }
     int remaining = delta;
     int resized = resize_count;
-    for (typename std::vector<T*>::iterator i = elements->begin();
-         i != elements->end(); ++i) {
-      T* element = *i;
+    for (const auto& element : *elements) {
       if (element->ResizePercent() > 0) {
         int to_give;
         if (--resized == 0) {
           to_give = remaining;
         } else {
           to_give = static_cast<int>(delta *
                                     (element->resize_percent_ / total_percent));
           remaining -= to_give;
         }
         element->SetSize(element->Size() + to_give);
       }
     }
   }
 
   // Returns the sum of the size of the elements from start to start + length.
   template <class T>
-  static int TotalSize(int start, int length, std::vector<T*>* elements) {
+  static int TotalSize(int start,
+                       int length,
+                       std::vector<std::unique_ptr<T>>* elements) {
     DCHECK(start >= 0 && length > 0 &&
            start + length <= static_cast<int>(elements->size()));
     int size = 0;
     for (int i = start, max = start + length; i < max; ++i) {
       size += (*elements)[i]->Size();
     }
     return size;
   }
 
   explicit LayoutElement(float resize_percent)
@@ skipping 57 matching lines @@
 // values for views originating in this column.
 class Column : public LayoutElement {
  public:
   Column(GridLayout::Alignment h_align,
          GridLayout::Alignment v_align,
          float resize_percent,
          GridLayout::SizeType size_type,
          int fixed_width,
          int min_width,
          bool is_padding)
-    : LayoutElement(resize_percent),
-      h_align_(h_align),
-      v_align_(v_align),
-      size_type_(size_type),
-      same_size_column_(-1),
-      fixed_width_(fixed_width),
-      min_width_(min_width),
-      is_padding_(is_padding),
-      master_column_(NULL) {}
+      : LayoutElement(resize_percent),
+        h_align_(h_align),
+        v_align_(v_align),
+        size_type_(size_type),
+        same_size_column_(-1),
+        fixed_width_(fixed_width),
+        min_width_(min_width),
+        is_padding_(is_padding),
+        master_column_(nullptr) {}
 
   ~Column() override {}
 
   GridLayout::Alignment h_align() { return h_align_; }
   GridLayout::Alignment v_align() { return v_align_; }
 
   void ResetSize() override;
 
  private:
   friend class ColumnSet;
@@ skipping 32 matching lines @@
 
 void Column::ResetSize() {
   if (size_type_ == GridLayout::FIXED) {
     SetSize(fixed_width_);
   } else {
     SetSize(min_width_);
   }
 }
 
 Column* Column::GetLastMasterColumn() {
-  if (master_column_ == NULL) {
-    return NULL;
+  if (master_column_ == nullptr) {
+    return nullptr;
   }
   if (master_column_ == this) {
     return this;
   }
   return master_column_->GetLastMasterColumn();
 }
 
 void Column::UnifySameSizedColumnSizes() {
   DCHECK(master_column_ == this);
 
   // Accumulate the size first.
   int size = 0;
-  for (std::vector<Column*>::iterator i = same_size_columns_.begin();
-       i != same_size_columns_.end(); ++i) {
-      size = std::max(size, (*i)->Size());
-  }
+  for (auto column : same_size_columns_)
+    size = std::max(size, column->Size());
 
   // Then apply it.
-  for (std::vector<Column*>::iterator i = same_size_columns_.begin();
-       i != same_size_columns_.end(); ++i) {
-      (*i)->SetSize(size);
-  }
+  for (auto column : same_size_columns_)
+    column->SetSize(size);
 }
 
 void Column::AdjustSize(int size) {
   if (size_type_ == GridLayout::USE_PREF)
     LayoutElement::AdjustSize(size);
 }
 
 // Row -------------------------------------------------------------
 
 class Row : public LayoutElement {
@@ skipping 10 matching lines @@
 
   void ResetSize() override {
     max_ascent_ = max_descent_ = 0;
     SetSize(height_);
   }
 
   ColumnSet* column_set() {
     return column_set_;
   }
 
-  // Adjusts the size to accomodate the specified ascent/descent.
+  // Adjusts the size to accommodate the specified ascent/descent.
   void AdjustSizeForBaseline(int ascent, int descent) {
     max_ascent_ = std::max(ascent, max_ascent_);
     max_descent_ = std::max(descent, max_descent_);
     AdjustSize(max_ascent_ + max_descent_);
   }
 
   int max_ascent() const {
     return max_ascent_;
   }
 
@@ skipping 65 matching lines @@
 
   // The baseline. Only used if the view is vertically aligned along the
   // baseline.
   int baseline;
 };
 
 static bool CompareByColumnSpan(const ViewState* v1, const ViewState* v2) {
   return v1->col_span < v2->col_span;
 }
 
-static bool CompareByRowSpan(const ViewState* v1, const ViewState* v2) {
+static bool CompareByRowSpan(const std::unique_ptr<ViewState>& v1,
+                             const ViewState* v2) {
   return v1->row_span < v2->row_span;
 }
 
 // ColumnSet -------------------------------------------------------------
 
 ColumnSet::ColumnSet(int id) : id_(id) {
 }
 
 ColumnSet::~ColumnSet() {
-  base::STLDeleteElements(&columns_);
 }
 
 void ColumnSet::AddPaddingColumn(float resize_percent, int width) {
   AddColumn(GridLayout::FILL, GridLayout::FILL, resize_percent,
             GridLayout::FIXED, width, width, true);
 }
 
 void ColumnSet::AddColumn(GridLayout::Alignment h_align,
                           GridLayout::Alignment v_align,
                           float resize_percent,
@@ skipping 18 matching lines @@
   va_end(marker);
 }
 
 void ColumnSet::AddColumn(GridLayout::Alignment h_align,
                           GridLayout::Alignment v_align,
                           float resize_percent,
                           GridLayout::SizeType size_type,
                           int fixed_width,
                           int min_width,
                           bool is_padding) {
-  Column* column = new Column(h_align, v_align, resize_percent, size_type,
-                              fixed_width, min_width, is_padding);
-  columns_.push_back(column);
+  columns_.push_back(base::MakeUnique<Column>(h_align, v_align, resize_percent,
+                                              size_type, fixed_width, min_width,
+                                              is_padding));
 }
 
 void ColumnSet::AddViewState(ViewState* view_state) {
   // view_states are ordered by column_span (in ascending order).
-  std::vector<ViewState*>::iterator i = std::lower_bound(view_states_.begin(),
-                                                         view_states_.end(),
-                                                         view_state,
-                                                         CompareByColumnSpan);
+  auto i = std::lower_bound(view_states_.begin(), view_states_.end(),
+                            view_state, CompareByColumnSpan);
   view_states_.insert(i, view_state);
 }
 
 void ColumnSet::CalculateMasterColumns() {
-  for (std::vector<Column*>::iterator i = columns_.begin();
-       i != columns_.end(); ++i) {
-    Column* column = *i;
+  for (const auto& column : columns_) {
     int same_size_column_index = column->same_size_column_;
     if (same_size_column_index != -1) {
       DCHECK(same_size_column_index >= 0 &&
              same_size_column_index < static_cast<int>(columns_.size()));
       Column* master_column = column->master_column_;
-      Column* same_size_column = columns_[same_size_column_index];
+      Column* same_size_column = columns_[same_size_column_index].get();
       Column* same_size_column_master = same_size_column->master_column_;
-      if (master_column == NULL) {
+      if (master_column == nullptr) {
         // Current column is not linked to any other column.
-        if (same_size_column_master == NULL) {
+        if (same_size_column_master == nullptr) {
           // Both columns are not linked.
-          column->master_column_ = column;
-          same_size_column->master_column_ = column;
+          column->master_column_ = column.get();
+          same_size_column->master_column_ = column.get();
           column->same_size_columns_.push_back(same_size_column);
-          column->same_size_columns_.push_back(column);
+          column->same_size_columns_.push_back(column.get());
         } else {
           // Column to link to is linked with other columns.
           // Add current column to list of linked columns in other columns
           // master column.
-          same_size_column->GetLastMasterColumn()->
-              same_size_columns_.push_back(column);
+          same_size_column->GetLastMasterColumn()->same_size_columns_.push_back(
+              column.get());
           // And update the master column for the current column to that
           // of the same sized column.
           column->master_column_ = same_size_column;
         }
       } else {
         // Current column is already linked with another column.
-        if (same_size_column_master == NULL) {
+        if (same_size_column_master == nullptr) {
           // Column to link with is not linked to any other columns.
           // Update it's master_column.
-          same_size_column->master_column_ = column;
+          same_size_column->master_column_ = column.get();
           // Add linked column to list of linked column.
           column->GetLastMasterColumn()->same_size_columns_.
               push_back(same_size_column);
         } else if (column->GetLastMasterColumn() !=
                    same_size_column->GetLastMasterColumn()) {
           // The two columns are already linked with other columns.
           std::vector<Column*>* same_size_columns =
               &(column->GetLastMasterColumn()->same_size_columns_);
           std::vector<Column*>* other_same_size_columns =
               &(same_size_column->GetLastMasterColumn()->same_size_columns_);
           // Add all the columns from the others master to current columns
           // master.
           same_size_columns->insert(same_size_columns->end(),
                                      other_same_size_columns->begin(),
                                      other_same_size_columns->end());
           // The other master is no longer a master, clear its vector of
           // linked columns, and reset its master_column.
           other_same_size_columns->clear();
-          same_size_column->GetLastMasterColumn()->master_column_ = column;
+          same_size_column->GetLastMasterColumn()->master_column_ =
+              column.get();
         }
       }
     }
   }
   AccumulateMasterColumns();
 }
 
 void ColumnSet::AccumulateMasterColumns() {
   DCHECK(master_columns_.empty());
-  for (std::vector<Column*>::iterator i = columns_.begin();
-       i != columns_.end(); ++i) {
-    Column* column = *i;
+  for (const auto& column : columns_) {
     Column* master_column = column->GetLastMasterColumn();
     if (master_column &&
         std::find(master_columns_.begin(), master_columns_.end(),
                   master_column) == master_columns_.end()) {
       master_columns_.push_back(master_column);
     }
     // At this point, GetLastMasterColumn may not == master_column
     // (may have to go through a few Columns)_. Reset master_column to
     // avoid hops.
     column->master_column_ = master_column;
   }
 }
 
 void ColumnSet::UnifySameSizedColumnSizes() {
-  for (std::vector<Column*>::iterator i = master_columns_.begin();
-       i != master_columns_.end(); ++i) {
-    (*i)->UnifySameSizedColumnSizes();
-  }
+  for (auto column : master_columns_)
+    column->UnifySameSizedColumnSizes();
 }
 
 void ColumnSet::UpdateRemainingWidth(ViewState* view_state) {
   for (int i = view_state->start_col,
        max_col = view_state->start_col + view_state->col_span;
        i < max_col; ++i) {
     view_state->remaining_width -= columns_[i]->Size();
   }
 }
 
@@ skipping 48 matching lines @@
         if (width < to_distribute)
           to_distribute += width;
         columns_[i]->SetSize(columns_[i]->Size() + to_distribute);
       }
     }
   }
 }
 
 int ColumnSet::LayoutWidth() {
   int width = 0;
-  for (std::vector<Column*>::iterator i = columns_.begin();
-       i != columns_.end(); ++i) {
-    width += (*i)->Size();
-  }
+  for (const auto& column : columns_)
+    width += column->Size();
+
   return width;
 }
 
 int ColumnSet::GetColumnWidth(int start_col, int col_span) {
   return LayoutElement::TotalSize(start_col, col_span, &columns_);
 }
 
 void ColumnSet::ResetColumnXCoordinates() {
   LayoutElement::CalculateLocationsFromSize(&columns_);
 }
 
 void ColumnSet::CalculateSize() {
   gfx::Size pref;
   // Reset the preferred and remaining sizes.
-  for (std::vector<ViewState*>::iterator i = view_states_.begin();
-       i != view_states_.end(); ++i) {
-    ViewState* view_state = *i;
+  for (const auto& view_state : view_states_) {
     if (!view_state->pref_width_fixed || !view_state->pref_height_fixed) {
       pref = view_state->view->GetPreferredSize();
       if (!view_state->pref_width_fixed)
         view_state->pref_width = pref.width();
       if (!view_state->pref_height_fixed)
         view_state->pref_height = pref.height();
     }
     view_state->remaining_width = pref.width();
     view_state->remaining_height = pref.height();
   }
 
   // Let layout element reset the sizes for us.
   LayoutElement::ResetSizes(&columns_);
 
   // Distribute the size of each view with a col span == 1.
-  std::vector<ViewState*>::iterator view_state_iterator =
-      view_states_.begin();
+  auto view_state_iterator = view_states_.begin();
   for (; view_state_iterator != view_states_.end() &&
          (*view_state_iterator)->col_span == 1; ++view_state_iterator) {
     ViewState* view_state = *view_state_iterator;
-    Column* column = columns_[view_state->start_col];
+    Column* column = columns_[view_state->start_col].get();
     column->AdjustSize(view_state->pref_width);
     view_state->remaining_width -= column->Size();
   }
 
   // Make sure all linked columns have the same size.
   UnifySameSizedColumnSizes();
 
   // Distribute the size of each view with a column span > 1.
   for (; view_state_iterator != view_states_.end(); ++view_state_iterator) {
     ViewState* view_state = *view_state_iterator;
@@ skipping 15 matching lines @@
 }
 
 // GridLayout -------------------------------------------------------------
 
 GridLayout::GridLayout(View* host)
     : host_(host),
       calculated_master_columns_(false),
       remaining_row_span_(0),
       current_row_(-1),
       next_column_(0),
-      current_row_col_set_(NULL),
+      current_row_col_set_(nullptr),
       adding_view_(false) {
   DCHECK(host);
 }
 
 GridLayout::~GridLayout() {
-  base::STLDeleteElements(&column_sets_);
-  base::STLDeleteElements(&view_states_);
-  base::STLDeleteElements(&rows_);
 }
 
 // static
 GridLayout* GridLayout::CreatePanel(View* host) {
   GridLayout* layout = new GridLayout(host);
   layout->SetInsets(kPanelVertMargin, kButtonHEdgeMarginNew,
                     kPanelVertMargin, kButtonHEdgeMarginNew);
   return layout;
 }
 
 void GridLayout::SetInsets(int top, int left, int bottom, int right) {
   insets_.Set(top, left, bottom, right);
 }
 
 void GridLayout::SetInsets(const gfx::Insets& insets) {
   insets_ = insets;
 }
 
 ColumnSet* GridLayout::AddColumnSet(int id) {
-  DCHECK(GetColumnSet(id) == NULL);
-  ColumnSet* column_set = new ColumnSet(id);
-  column_sets_.push_back(column_set);
-  return column_set;
+  DCHECK(GetColumnSet(id) == nullptr);
+  column_sets_.push_back(base::WrapUnique(new ColumnSet(id)));
+  return column_sets_.back().get();
 }
 
 ColumnSet* GridLayout::GetColumnSet(int id) {
-  for (std::vector<ColumnSet*>::iterator i = column_sets_.begin();
-       i != column_sets_.end(); ++i) {
-    if ((*i)->id_ == id) {
-      return *i;
+  for (const auto& column_set : column_sets_) {
+    if (column_set->id_ == id) {
+      return column_set.get();
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 void GridLayout::StartRowWithPadding(float vertical_resize, int column_set_id,
                                      float padding_resize, int padding) {
   AddPaddingRow(padding_resize, padding);
   StartRow(vertical_resize, column_set_id);
 }
 
 void GridLayout::StartRow(float vertical_resize, int column_set_id) {
   ColumnSet* column_set = GetColumnSet(column_set_id);
   DCHECK(column_set);
-  AddRow(new Row(0, vertical_resize, column_set));
+  AddRow(base::MakeUnique<Row>(0, vertical_resize, column_set));
 }
 
 void GridLayout::AddPaddingRow(float vertical_resize, int pixel_count) {
-  AddRow(new Row(pixel_count, vertical_resize, NULL));
+  AddRow(base::MakeUnique<Row>(pixel_count, vertical_resize, nullptr));
 }
 
 void GridLayout::SkipColumns(int col_count) {
   DCHECK(col_count > 0);
   next_column_ += col_count;
   DCHECK(current_row_col_set_ &&
          next_column_ <= current_row_col_set_->num_columns());
   SkipPaddingColumns();
 }
 
 void GridLayout::AddView(View* view) {
   AddView(view, 1, 1);
 }
 
 void GridLayout::AddView(View* view, int col_span, int row_span) {
   DCHECK(current_row_col_set_ &&
          next_column_ < current_row_col_set_->num_columns());
-  Column* column = current_row_col_set_->columns_[next_column_];
+  Column* column = current_row_col_set_->columns_[next_column_].get();
   AddView(view, col_span, row_span, column->h_align(), column->v_align());
 }
 
 void GridLayout::AddView(View* view, int col_span, int row_span,
                          Alignment h_align, Alignment v_align) {
   AddView(view, col_span, row_span, h_align, v_align, 0, 0);
 }
 
 void GridLayout::AddView(View* view, int col_span, int row_span,
                          Alignment h_align, Alignment v_align,
                          int pref_width, int pref_height) {
   DCHECK(current_row_col_set_ && col_span > 0 && row_span > 0 &&
          (next_column_ + col_span) <= current_row_col_set_->num_columns());
   // We don't support baseline alignment of views spanning rows. Please add if
   // you need it.
   DCHECK(v_align != BASELINE || row_span == 1);
-  ViewState* state =
-      new ViewState(current_row_col_set_, view, next_column_, current_row_,
-                    col_span, row_span, h_align, v_align, pref_width,
-                    pref_height);
-  AddViewState(state);
+  AddViewState(base::MakeUnique<ViewState>(
+      current_row_col_set_, view, next_column_, current_row_, col_span,
+      row_span, h_align, v_align, pref_width, pref_height));
 }
 
 static void CalculateSize(int pref_size, GridLayout::Alignment alignment,
                           int* location, int* size) {
   if (alignment != GridLayout::FILL) {
     int available_size = *size;
     *size = std::min(*size, pref_size);
     switch (alignment) {
       case GridLayout::LEADING:
         // Nothing to do, location already points to start.
@@ skipping 26 matching lines @@
 }
 
 void GridLayout::Layout(View* host) {
   DCHECK(host_ == host);
   // SizeRowsAndColumns sets the size and location of each row/column, but
   // not of the views.
   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;
+  for (const auto& view_state : view_states_) {
     ColumnSet* column_set = view_state->column_set;
-    View* view = (*i)->view;
+    View* view = view_state->view;
     DCHECK(view);
     int x = column_set->columns_[view_state->start_col]->Location() +
             insets_.left();
     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() + insets_.top();
     int height = LayoutElement::TotalSize(view_state->start_row,
                                           view_state->row_span, &rows_);
@@ skipping 27 matching lines @@
                                     gfx::Size* pref) const {
   // Make sure the master columns have been calculated.
   CalculateMasterColumnsIfNecessary();
   pref->SetSize(0, 0);
   if (rows_.empty())
     return;
 
   // Calculate the preferred width 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();
-    pref->set_width(std::max(pref->width(), (*i)->LayoutWidth()));
+  for (const auto& column_set : column_sets_) {
+    column_set->CalculateSize();
+    pref->set_width(std::max(pref->width(), column_set->LayoutWidth()));
   }
   pref->set_width(pref->width() + insets_.width());
 
   // Go over the columns again and set them all to the size we settled for.
   width = width ? width : pref->width();
-  for (std::vector<ColumnSet*>::iterator i = column_sets_.begin();
-       i != column_sets_.end(); ++i) {
-    // We're doing a layout, divy up any extra space.
-    (*i)->Resize(width - (*i)->LayoutWidth() - insets_.left() -
-                 insets_.right());
+  for (const auto& column_set : column_sets_) {
+    // We're doing a layout, divvy up any extra space.
+    column_set->Resize(width - column_set->LayoutWidth() - insets_.left() -
+                       insets_.right());
     // And reset the x coordinates.
-    (*i)->ResetColumnXCoordinates();
+    column_set->ResetColumnXCoordinates();
   }
 
   // Reset the height of each row.
   LayoutElement::ResetSizes(&rows_);
 
   // Do the following:
   // . If the view is aligned along it's baseline, obtain the baseline from the
   //   view and update the rows ascent/descent.
   // . 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) {
-    ViewState* view_state = *i;
+  for (const auto& view_state : view_states_) {
     view_state->remaining_height = view_state->pref_height;
 
     if (view_state->v_align == BASELINE)
       view_state->baseline = view_state->view->GetBaseline();
 
     if (view_state->h_align == FILL) {
       // The view is resizable. As the pref height may vary with the width,
       // ask for the pref again.
       int actual_width =
           view_state->column_set->GetColumnWidth(view_state->start_col,
                                                  view_state->col_span);
       if (actual_width != view_state->pref_width &&
           !view_state->pref_height_fixed) {
         // The width this view will get differs from its preferred. Some Views
         // pref height varies with its width; ask for the preferred again.
         view_state->pref_height =
             view_state->view->GetHeightForWidth(actual_width);
         view_state->remaining_height = view_state->pref_height;
       }
     }
   }
 
   // Update the height/ascent/descent of each row from the views.
-  std::vector<ViewState*>::iterator view_states_iterator = view_states_.begin();
+  auto view_states_iterator = view_states_.begin();
   for (; view_states_iterator != view_states_.end() &&
       (*view_states_iterator)->row_span == 1; ++view_states_iterator) {
-    ViewState* view_state = *view_states_iterator;
-    Row* row = rows_[view_state->start_row];
+    ViewState* view_state = view_states_iterator->get();
+    Row* row = rows_[view_state->start_row].get();
     row->AdjustSize(view_state->remaining_height);
     if (view_state->baseline != -1 &&
         view_state->baseline <= view_state->pref_height) {
       row->AdjustSizeForBaseline(view_state->baseline,
           view_state->pref_height - view_state->baseline);
     }
     view_state->remaining_height = 0;
   }
 
   // Distribute the height of each view with a row span > 1.
   for (; view_states_iterator != view_states_.end(); ++view_states_iterator) {
-    ViewState* view_state = *view_states_iterator;
+    ViewState* view_state = view_states_iterator->get();
 
     // Update the remaining_width from columns this view_state touches.
     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->set_height(rows_.back()->Location() + rows_.back()->Size() +
                    insets_.height());
 
   if (layout && height != pref->height()) {
     // We're doing a layout, and the height differs from the preferred height,
-    // divy up the extra space.
+    // divvy up the extra space.
     LayoutElement::DistributeDelta(height - pref->height(), &rows_);
 
     // Reset y locations.
     LayoutElement::CalculateLocationsFromSize(&rows_);
   }
 }
 
 void GridLayout::CalculateMasterColumnsIfNecessary() const {
   if (!calculated_master_columns_) {
     calculated_master_columns_ = true;
-    for (std::vector<ColumnSet*>::iterator i = column_sets_.begin();
-         i != column_sets_.end(); ++i) {
-      (*i)->CalculateMasterColumns();
+    for (const auto& column_set : column_sets_) {
+      column_set->CalculateMasterColumns();
     }
   }
 }
 
-void GridLayout::AddViewState(ViewState* view_state) {
-  DCHECK(view_state->view && (view_state->view->parent() == NULL ||
+void GridLayout::AddViewState(std::unique_ptr<ViewState> view_state) {
+  DCHECK(view_state->view && (view_state->view->parent() == nullptr ||
                               view_state->view->parent() == host_));
   if (!view_state->view->parent()) {
     adding_view_ = true;
     host_->AddChildView(view_state->view);
     adding_view_ = false;
   }
   remaining_row_span_ = std::max(remaining_row_span_, view_state->row_span);
   next_column_ += view_state->col_span;
-  current_row_col_set_->AddViewState(view_state);
+  current_row_col_set_->AddViewState(view_state.get());
   // view_states are ordered by row_span (in ascending order).
-  std::vector<ViewState*>::iterator i = std::lower_bound(view_states_.begin(),
-                                                         view_states_.end(),
-                                                         view_state,
-                                                         CompareByRowSpan);
-  view_states_.insert(i, view_state);
+  auto i = std::lower_bound(view_states_.begin(), view_states_.end(),
+                            view_state.get(), CompareByRowSpan);
+  view_states_.insert(i, std::move(view_state));
   SkipPaddingColumns();
 }
 
-void GridLayout::AddRow(Row* row) {
+void GridLayout::AddRow(std::unique_ptr<Row> row) {
   current_row_++;
   remaining_row_span_--;
   // GridLayout requires that if you add a View with a row span you use the same
   // column set for each of the rows the view lands it. This DCHECK verifies
   // that.
-  DCHECK(remaining_row_span_ <= 0 ||
-         row->column_set() == NULL ||
+  DCHECK(remaining_row_span_ <= 0 || row->column_set() == nullptr ||
          row->column_set() == GetLastValidColumnSet());
   next_column_ = 0;
-  rows_.push_back(row);
   current_row_col_set_ = row->column_set();
+  rows_.push_back(std::move(row));
   SkipPaddingColumns();
 }
 
 void GridLayout::UpdateRemainingHeightFromRows(ViewState* view_state) const {
   for (int i = 0, start_row = view_state->start_row;
        i < view_state->row_span; ++i) {
     view_state->remaining_height -= rows_[i + start_row]->Size();
   }
 }
 
@@ skipping 19 matching lines @@
       if (rows_[i]->IsResizable()) {
         height -= to_distribute;
         if (height < to_distribute) {
           // Give all slop to the last column.
           to_distribute += height;
         }
         rows_[i]->SetSize(rows_[i]->Size() + to_distribute);
       }
     }
   } else {
-    // None of the rows are resizable, divy the remaining height up equally
+    // None of the rows are resizable, divvy the remaining height up equally
     // among all rows the view touches.
     int each_row_height = height / view_state->row_span;
     for (int i = start_row; i < max_row; ++i) {
       height -= each_row_height;
       if (height < each_row_height)
         each_row_height += height;
       rows_[i]->SetSize(rows_[i]->Size() + each_row_height);
     }
     view_state->remaining_height = 0;
   }
 }
 
 void GridLayout::SkipPaddingColumns() {
   if (!current_row_col_set_)
     return;
   while (next_column_ < current_row_col_set_->num_columns() &&
          current_row_col_set_->columns_[next_column_]->is_padding_) {
     next_column_++;
   }
 }
 
 ColumnSet* GridLayout::GetLastValidColumnSet() {
   for (int i = current_row_ - 1; i >= 0; --i) {
     if (rows_[i]->column_set())
       return rows_[i]->column_set();
   }
-  return NULL;
+  return nullptr;
 }
 
 }  // namespace views