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

ui/views/layout/grid_layout.h

 // 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.
 
 #ifndef UI_VIEWS_LAYOUT_GRID_LAYOUT_H_
 #define UI_VIEWS_LAYOUT_GRID_LAYOUT_H_
 
 #include <stddef.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/views/layout/layout_manager.h"
 
 // GridLayout is a LayoutManager that positions child Views in a grid. You
 // define the structure of the Grid first, then add the Views.
 // The following creates a trivial grid with two columns separated by
@@ skipping 170 matching lines @@
                           int width,
                           int height,
                           gfx::Size* pref) const;
 
   // Calculates the master columns of all the column sets. See Column for
   // a description of what a master column is.
   void CalculateMasterColumnsIfNecessary() const;
 
   // This is called internally from AddView. It adds the ViewState to the
   // appropriate structures, and updates internal fields such as next_column_.
-  void AddViewState(ViewState* view_state);
+  void AddViewState(std::unique_ptr<ViewState> view_state);
 
   // Adds the Row to rows_, as well as updating next_column_,
   // current_row_col_set ...
-  void AddRow(Row* row);
+  void AddRow(std::unique_ptr<Row> row);
 
   // As the name says, updates the remaining_height of the ViewState for
   // all Rows the supplied ViewState touches.
   void UpdateRemainingHeightFromRows(ViewState* state) const;
 
   // If the view state's remaining height is > 0, it is distributed among
   // the rows the view state touches. This is used during layout to make
   // sure the Rows can accommodate a view.
   void DistributeRemainingHeight(ViewState* state) const;
 
@@ skipping 22 matching lines @@
   // Column set for the current row. This is null for padding rows.
   ColumnSet* current_row_col_set_;
 
   // Insets.
   gfx::Insets insets_;
 
   // Set to true when adding a View.
   bool adding_view_;
 
   // ViewStates. This is ordered by row_span in ascending order.
-  mutable std::vector<ViewState*> view_states_;
+  mutable std::vector<std::unique_ptr<ViewState>> view_states_;
 
   // ColumnSets.
-  mutable std::vector<ColumnSet*> column_sets_;
+  mutable std::vector<std::unique_ptr<ColumnSet>> column_sets_;
 
   // Rows.
-  mutable std::vector<Row*> rows_;
+  mutable std::vector<std::unique_ptr<Row>> rows_;
 
   // Minimum preferred size.
   gfx::Size minimum_size_;
 
   DISALLOW_COPY_AND_ASSIGN(GridLayout);
 };
 
 // ColumnSet is used to define a set of columns. GridLayout may have any
 // number of ColumnSets. You don't create a ColumnSet directly, instead
 // use the AddColumnSet method of GridLayout.
@@ skipping 76 matching lines @@
   int GetColumnWidth(int start_col, int col_span);
 
   // Updates the x coordinate of each column from the previous ones.
   // NOTE: this doesn't include the insets.
   void ResetColumnXCoordinates();
 
   // Calculate the preferred width of each view in this column set, as well
   // as updating the remaining_width.
   void CalculateSize();
 
-  // Distributes delta amoung the resizable columns.
+  // Distributes delta among the resizable columns.
   void Resize(int delta);
 
   // ID for this columnset.
   const int id_;
 
   // The columns.
-  std::vector<Column*> columns_;
+  std::vector<std::unique_ptr<Column>> columns_;
 
   // The ViewStates. This is sorted based on column_span in ascending
   // order.
   std::vector<ViewState*> view_states_;
 
   // The master column of those columns that are linked. See Column
   // for a description of what the master column is.
   std::vector<Column*> master_columns_;
 
   DISALLOW_COPY_AND_ASSIGN(ColumnSet);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_LAYOUT_GRID_LAYOUT_H_