Remove ScopedVector from chrome/browser/ui.

chrome/browser/ui/cocoa/autofill/simple_grid_layout.mm

 // Copyright (c) 2013 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/ui/cocoa/autofill/simple_grid_layout.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
-#include "base/logging.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 
 namespace {
 const int kAutoColumnIdStart = 1000000;  // Starting ID for autogeneration.
 }
 
 // Encapsulates state for a single NSView in the layout
 class ViewState {
  public:
   ViewState(NSView* view, ColumnSet* column_set, int row, int column);
 
@@ skipping 17 matching lines @@
   int column_;
   float pref_height_;
 };
 
 class LayoutElement {
  public:
   LayoutElement(float resize_percent, int fixed_width);
   virtual ~LayoutElement() {}
 
   template <class T>
-      static void ResetSizes(ScopedVector<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();
+  }
+
+  template <class T>
+  static void CalculateLocationsFromSize(
+      std::vector<std::unique_ptr<T>>* elements) {
+    // Reset the layout width of each column.
+    int location = 0;
+    for (const auto& element : *elements) {
+      element->SetLocation(location);
+      location += element->Size();
     }
   }
 
-  template <class T>
-      static void CalculateLocationsFromSize(ScopedVector<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();
-    }
-  }
-
   float Size() { return size_; }
 
   void ResetSize() {
       size_ = fixed_width_;
   }
 
   void SetSize(float size) {
     size_ = size;
   }
 
@@ skipping 78 matching lines @@
   return NSHeight([view_ frame]);
 }
 
 ColumnSet::ColumnSet(int id) : id_(id) {
 }
 
 ColumnSet::~ColumnSet() {
 }
 
 void ColumnSet::AddPaddingColumn(int fixed_width) {
-  columns_.push_back(new Column(0.0f, fixed_width, true));
+  columns_.push_back(base::MakeUnique<Column>(0.0f, fixed_width, true));
 }
 
 void ColumnSet::AddColumn(float resize_percent) {
-  columns_.push_back(new Column(resize_percent, 0, false));
+  columns_.push_back(base::MakeUnique<Column>(resize_percent, 0, false));
 }
 
 void ColumnSet::CalculateSize(float width) {
-  // Reset column widths
+  // Reset column widths.
   LayoutElement::ResetSizes(&columns_);
   width = CalculateRemainingWidth(width);
   DistributeRemainingWidth(width);
 }
 
 void ColumnSet::ResetColumnXCoordinates() {
   LayoutElement::CalculateLocationsFromSize(&columns_);
 }
 
 float ColumnSet::CalculateRemainingWidth(float width) {
-  for (size_t i = 0; i < columns_.size(); ++i)
-    width -= columns_[i]->Size();
+  for (const auto& column : columns_)
+    width -= column->Size();
 
   return width;
 }
 
 void ColumnSet::DistributeRemainingWidth(float width) {
   float total_resize = 0.0f;
   int resizable_columns = 0.0;
 
-  for (size_t i = 0; i < columns_.size(); ++i) {
-    if (columns_[i]->IsResizable()) {
-      total_resize += columns_[i]->ResizePercent();
+  for (const auto& column : columns_) {
+    if (column->IsResizable()) {
+      total_resize += column->ResizePercent();
       resizable_columns++;
     }
   }
 
   float remaining_width = width;
-  for (size_t i = 0; i < columns_.size(); ++i) {
-    if (columns_[i]->IsResizable()) {
-      float delta = (resizable_columns == 0) ? remaining_width :
-          (width * columns_[i]->ResizePercent() / total_resize);
+  for (const auto& column : columns_) {
+    if (column->IsResizable()) {
+      float delta = (resizable_columns == 0)
+                        ? remaining_width
+                        : (width * column->ResizePercent() / total_resize);
       remaining_width -= delta;
-      columns_[i]->SetSize(columns_[i]->Size() + delta);
+      column->SetSize(column->Size() + delta);
       resizable_columns--;
     }
   }
 }
 
 float ColumnSet::GetColumnWidth(int column_index) {
   if (column_index < 0 || column_index >= num_columns())
     return 0.0;
   return columns_[column_index]->Size();
 }
 
 float ColumnSet::ColumnLocation(int column_index) {
   if (column_index < 0 || column_index >= num_columns())
     return 0.0;
   return columns_[column_index]->Location();
 }
 
 SimpleGridLayout::SimpleGridLayout(NSView* host)
     : next_column_(0),
       current_auto_id_(kAutoColumnIdStart),
       host_(host) {
   [host_ frame];
 }
 
 SimpleGridLayout::~SimpleGridLayout() {
 }
 
 ColumnSet* SimpleGridLayout::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::MakeUnique<ColumnSet>(id));
+  return column_sets_.back().get();
 }
 
 ColumnSet* SimpleGridLayout::GetColumnSet(int id) {
-  for (ScopedVector<ColumnSet>::const_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 SimpleGridLayout::AddPaddingRow(int fixed_height) {
-  AddRow(new Row(0.0f, fixed_height, NULL));
+  AddRow(base::MakeUnique<Row>(0.0f, fixed_height, nullptr));
 }
 
 void SimpleGridLayout::StartRow(float vertical_resize, int column_set_id) {
   ColumnSet* column_set = GetColumnSet(column_set_id);
   DCHECK(column_set);
-  AddRow(new Row(vertical_resize, 0, column_set));
+  AddRow(base::MakeUnique<Row>(vertical_resize, 0, column_set));
 }
 
 ColumnSet* SimpleGridLayout::AddRow() {
-  AddRow(new Row(0, 0, AddColumnSet(current_auto_id_++)));
-  return column_sets_.back();
+  AddRow(base::MakeUnique<Row>(0, 0, AddColumnSet(current_auto_id_++)));
+  return column_sets_.back().get();
 }
 
 void SimpleGridLayout::SkipColumns(int col_count) {
   DCHECK(col_count > 0);
   next_column_ += col_count;
   ColumnSet* current_row_col_set_ = GetLastValidColumnSet();
   DCHECK(current_row_col_set_ &&
          next_column_ <= current_row_col_set_->num_columns());
   SkipPaddingColumns();
 }
 
 void SimpleGridLayout::AddView(NSView* view) {
   [host_ addSubview:view];
   DCHECK(next_column_ < GetLastValidColumnSet()->num_columns());
-  view_states_.push_back(
-      new ViewState(view,
-                    GetLastValidColumnSet(),
-                    rows_.size() - 1,
-                    next_column_++));
+  view_states_.push_back(base::MakeUnique<ViewState>(
+      view, GetLastValidColumnSet(), rows_.size() - 1, next_column_++));
   SkipPaddingColumns();
 }
 
 // Sizes elements to fit into the superViews bounds, according to constraints.
 void SimpleGridLayout::Layout(NSView* superView) {
   SizeRowsAndColumns(NSWidth([superView bounds]));
-  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_) {
     NSView* view = view_state->view();
     NSRect frame = NSMakeRect(view_state->GetColumn()->Location(),
                               rows_[view_state->row_index()]->Location(),
                               view_state->GetColumn()->Size(),
                               rows_[view_state->row_index()]->Size());
     [view setFrame:NSIntegralRect(frame)];
   }
 }
 
 void SimpleGridLayout::SizeRowsAndColumns(float width) {
   // Size all columns first.
-  for (ScopedVector<ColumnSet>::iterator i = column_sets_.begin();
-       i != column_sets_.end(); ++i) {
-    (*i)->CalculateSize(width);
-    (*i)->ResetColumnXCoordinates();
+  for (const auto& column_set : column_sets_) {
+    column_set->CalculateSize(width);
+    column_set->ResetColumnXCoordinates();
   }
 
   // Reset the height of each row.
   LayoutElement::ResetSizes(&rows_);
 
   // For each ViewState, obtain the preferred height
-  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_) {
     // The view is resizable. As the pref height may vary with the width,
     // ask for the pref again.
     int actual_width = view_state->GetColumnWidth();
 
     // 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->set_preferred_height(
         view_state->GetHeightForWidth(actual_width));
   }
 
 
   // Make sure each row can accommodate all contained ViewStates.
-  std::vector<ViewState*>::iterator view_states_iterator = view_states_.begin();
-  for (; view_states_iterator != view_states_.end(); ++view_states_iterator) {
-    ViewState* view_state = *view_states_iterator;
-    Row* row = rows_[view_state->row_index()];
+  for (const auto& view_state : view_states_) {
+    Row* row = rows_[view_state->row_index()].get();
     row->AdjustSize(view_state->preferred_height());
   }
 
   // Update the location of each of the rows.
   LayoutElement::CalculateLocationsFromSize(&rows_);
 }
 
 void SimpleGridLayout::SkipPaddingColumns() {
   ColumnSet* current_row_col_set_ = GetLastValidColumnSet();
   while (next_column_ < current_row_col_set_->num_columns() &&
          current_row_col_set_->GetColumn(next_column_)->is_padding()) {
     next_column_++;
   }
 }
 
 ColumnSet* SimpleGridLayout::GetLastValidColumnSet() {
   for (int i = num_rows() - 1; i >= 0; --i) {
     if (rows_[i]->column_set())
       return rows_[i]->column_set();
   }
-  return NULL;
+  return nullptr;
 }
 
 float SimpleGridLayout::GetRowHeight(int row_index) {
   if (row_index < 0 || row_index >= num_rows())
     return 0.0;
   return rows_[row_index]->Size();
 }
 
 float SimpleGridLayout::GetRowLocation(int row_index) const {
   if (row_index < 0 || row_index >= num_rows())
     return 0.0;
   return rows_[row_index]->Location();
 }
 
 float SimpleGridLayout::GetPreferredHeightForWidth(float width) {
   if (rows_.empty())
     return 0.0f;
 
   SizeRowsAndColumns(width);
   return rows_.back()->Location() + rows_.back()->Size();
 }
 
-void SimpleGridLayout::AddRow(Row* row) {
+void SimpleGridLayout::AddRow(std::unique_ptr<Row> row) {
   next_column_ = 0;
-  rows_.push_back(row);
+  rows_.push_back(std::move(row));
 }