Remove some uses of stl_util's STLDeleteContainerPointers.

ui/views/controls/textfield/textfield_model.cc

Index: ui/views/controls/textfield/textfield_model.cc
diff --git a/ui/views/controls/textfield/textfield_model.cc b/ui/views/controls/textfield/textfield_model.cc
index 5738887b7256d5c84e2aa333472fae50bc42ec25..16f3939a16eb803a8b2b0c59fb89289cc532e4ca 100644
--- a/ui/views/controls/textfield/textfield_model.cc
+++ b/ui/views/controls/textfield/textfield_model.cc
@@ -8,6 +8,7 @@
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
@@ -672,8 +673,8 @@ void TextfieldModel::ConfirmCompositionText() {
       composition_range_.start(), composition_range_.length());
   // TODO(oshima): current behavior on ChromeOS is a bit weird and not
   // sure exactly how this should work. Find out and fix if necessary.
-  AddOrMergeEditHistory(
-      new InsertEdit(false, composition, composition_range_.start()));
+  AddOrMergeEditHistory(base::MakeUnique<InsertEdit>(
+      false, composition, composition_range_.start()));
   render_text_->SetCursorPosition(composition_range_.end());
   ClearComposition();
   if (delegate_)
@@ -705,7 +706,7 @@ bool TextfieldModel::HasCompositionText() const {
 }
 
 void TextfieldModel::ClearEditHistory() {
-  base::STLDeleteElements(&edit_history_);
+  edit_history_.clear();
   current_edit_ = edit_history_.end();
 }
 
@@ -754,7 +755,6 @@ void TextfieldModel::ClearRedoHistory() {
   }
   EditHistory::iterator delete_start = current_edit_;
   ++delete_start;
-  base::STLDeleteContainerPointers(delete_start, edit_history_.end());
   edit_history_.erase(delete_start, edit_history_.end());
 }
 
@@ -762,11 +762,12 @@ void TextfieldModel::ExecuteAndRecordDelete(gfx::Range range, bool mergeable) {
   size_t old_text_start = range.GetMin();
   const base::string16 old_text = text().substr(old_text_start, range.length());
   bool backward = range.is_reversed();
-  Edit* edit = new DeleteEdit(mergeable, old_text, old_text_start, backward);
-  bool delete_edit = AddOrMergeEditHistory(edit);
+  std::unique_ptr<Edit> edit_ptr = base::MakeUnique<DeleteEdit>(
+      mergeable, old_text, old_text_start, backward);
+  Edit* edit = edit_ptr.get();
+  std::unique_ptr<Edit> returned_edit =
+      AddOrMergeEditHistory(std::move(edit_ptr));
   edit->Redo(this);

[Nico, 2016/09/08 17:32:00]

Getting a raw ptr to a unique_ptr that's moved from and then calling something
on that pointer looks dangerous. The old code makes it clear that this is safe,
with the new code it's not clear.

[Avi (use Gerrit), 2016/09/13 14:36:13]

This entire code is insane re ownership. I would disagree that the old code is
clearly safe. I have zero idea what's going on from reading the old code. It
tosses around pointers, owned by who knows, and sometimes deletes them and
sometimes does not.

If you'd prefer, I'll remove these files from the patch and figure out a better
ownership rewrite.

-  if (delete_edit)
-    delete edit;
 }
 
 void TextfieldModel::ExecuteAndRecordReplaceSelection(
@@ -788,38 +789,36 @@ void TextfieldModel::ExecuteAndRecordReplace(MergeType merge_type,
                                              size_t new_text_start) {
   size_t old_text_start = render_text_->selection().GetMin();
   bool backward = render_text_->selection().is_reversed();
-  Edit* edit = new ReplaceEdit(merge_type,
-                               GetSelectedText(),
-                               old_cursor_pos,
-                               old_text_start,
-                               backward,
-                               new_cursor_pos,
-                               new_text,
-                               new_text_start);
-  bool delete_edit = AddOrMergeEditHistory(edit);
+  std::unique_ptr<Edit> edit_ptr = base::MakeUnique<ReplaceEdit>(
+      merge_type, GetSelectedText(), old_cursor_pos, old_text_start, backward,
+      new_cursor_pos, new_text, new_text_start);
+  Edit* edit = edit_ptr.get();
+  std::unique_ptr<Edit> returned_edit =
+      AddOrMergeEditHistory(std::move(edit_ptr));
   edit->Redo(this);

[Nico, 2016/09/08 17:32:00]

ditto

-  if (delete_edit)
-    delete edit;
 }
 
 void TextfieldModel::ExecuteAndRecordInsert(const base::string16& new_text,
                                             bool mergeable) {
-  Edit* edit = new InsertEdit(mergeable, new_text, GetCursorPosition());
-  bool delete_edit = AddOrMergeEditHistory(edit);
+  std::unique_ptr<Edit> edit_ptr =
+      base::MakeUnique<InsertEdit>(mergeable, new_text, GetCursorPosition());
+  Edit* edit = edit_ptr.get();
+  std::unique_ptr<Edit> returned_edit =
+      AddOrMergeEditHistory(std::move(edit_ptr));
   edit->Redo(this);
-  if (delete_edit)
-    delete edit;
 }
 
-bool TextfieldModel::AddOrMergeEditHistory(Edit* edit) {
+std::unique_ptr<internal::Edit> TextfieldModel::AddOrMergeEditHistory(
+    std::unique_ptr<Edit> edit) {
   ClearRedoHistory();
 
-  if (current_edit_ != edit_history_.end() && (*current_edit_)->Merge(edit)) {
+  if (current_edit_ != edit_history_.end() &&
+      (*current_edit_)->Merge(edit.get())) {
     // If a current edit exists and has been merged with a new edit, don't add
-    // to the history, and return true to delete |edit| after redo.
-    return true;
+    // to the history, and return the edit so that it is deleted after redo.
+    return edit;
   }
-  edit_history_.push_back(edit);
+  edit_history_.push_back(std::move(edit));
   if (current_edit_ == edit_history_.end()) {
     // If there is no redoable edit, this is the 1st edit because RedoHistory
     // has been already deleted.
@@ -828,7 +827,7 @@ bool TextfieldModel::AddOrMergeEditHistory(Edit* edit) {
   } else {
     ++current_edit_;
   }
-  return false;
+  return nullptr;
 }
 
 void TextfieldModel::ModifyText(size_t delete_from,