Remove some uses of stl_util's STLDeleteContainerPointers.

ui/views/controls/textfield/textfield_model.cc

 // Copyright 2014 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/controls/textfield/textfield_model.h"
 
 #include <algorithm>
 
 #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"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/gfx/range/range.h"
 #include "ui/gfx/utf16_indexing.h"
 
 namespace views {
@@ skipping 644 matching lines @@
     render_text_->SetCursorPosition(cursor + composition.selection.end());
   }
 }
 
 void TextfieldModel::ConfirmCompositionText() {
   DCHECK(HasCompositionText());
   base::string16 composition = text().substr(
       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_)
     delegate_->OnCompositionTextConfirmedOrCleared();
 }
 
 void TextfieldModel::CancelCompositionText() {
   DCHECK(HasCompositionText());
   gfx::Range range = composition_range_;
   ClearComposition();
@@ skipping 11 matching lines @@
 
 void TextfieldModel::GetCompositionTextRange(gfx::Range* range) const {
   *range = composition_range_;
 }
 
 bool TextfieldModel::HasCompositionText() const {
   return !composition_range_.is_empty();
 }
 
 void TextfieldModel::ClearEditHistory() {
-  base::STLDeleteElements(&edit_history_);
+  edit_history_.clear();
   current_edit_ = edit_history_.end();
 }
 
 /////////////////////////////////////////////////////////////////
 // TextfieldModel: private
 
 void TextfieldModel::InsertTextInternal(const base::string16& new_text,
                                         bool mergeable) {
   if (HasCompositionText()) {
     CancelCompositionText();
@@ skipping 28 matching lines @@
 
 void TextfieldModel::ClearRedoHistory() {
   if (edit_history_.begin() == edit_history_.end())
     return;
   if (current_edit_ == edit_history_.end()) {
     ClearEditHistory();
     return;
   }
   EditHistory::iterator delete_start = current_edit_;
   ++delete_start;
-  base::STLDeleteContainerPointers(delete_start, edit_history_.end());
   edit_history_.erase(delete_start, edit_history_.end());
 }
 
 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(
     MergeType merge_type,
     const base::string16& new_text) {
   size_t new_text_start = render_text_->selection().GetMin();
   size_t new_cursor_pos = new_text_start + new_text.length();
   ExecuteAndRecordReplace(merge_type,
                           GetCursorPosition(),
                           new_cursor_pos,
                           new_text,
                           new_text_start);
 }
 
 void TextfieldModel::ExecuteAndRecordReplace(MergeType merge_type,
                                              size_t old_cursor_pos,
                                              size_t new_cursor_pos,
                                              const base::string16& new_text,
                                              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.
     DCHECK_EQ(1u, edit_history_.size());
     current_edit_ = edit_history_.begin();
   } else {
     ++current_edit_;
   }
-  return false;
+  return nullptr;
 }
 
 void TextfieldModel::ModifyText(size_t delete_from,
                                 size_t delete_to,
                                 const base::string16& new_text,
                                 size_t new_text_insert_at,
                                 size_t new_cursor_pos) {
   DCHECK_LE(delete_from, delete_to);
   base::string16 old_text = text();
   ClearComposition();
   if (delete_from != delete_to)
     render_text_->SetText(old_text.erase(delete_from, delete_to - delete_from));
   if (!new_text.empty())
     render_text_->SetText(old_text.insert(new_text_insert_at, new_text));
   render_text_->SetCursorPosition(new_cursor_pos);
   // TODO(oshima): Select text that was just undone, like Mac (but not GTK).
 }
 
 // static
 void TextfieldModel::ClearKillBuffer() {
   SetKillBuffer(base::string16());
 }
 
 }  // namespace views