Remove ScopedVector in //component/undo

components/undo/undo_manager.cc

 // Copyright 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 "components/undo/undo_manager.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "components/undo/undo_manager_observer.h"
 #include "components/undo/undo_operation.h"
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 // Maximum number of changes that can be undone.
 const size_t kMaxUndoGroups = 100;
 
+std::vector<UndoOperation*> ConvertToRawPtrVector(
+    const std::vector<std::unique_ptr<UndoOperation>>& args) {
+  std::vector<UndoOperation*> args_rawptrs;
+  for (auto i = args.begin(); i != args.end(); ++i)
+    args_rawptrs.push_back(i->get());
+  return args_rawptrs;
+}
+
 }  // namespace
 
 // UndoGroup ------------------------------------------------------------------
 
 UndoGroup::UndoGroup()
     : undo_label_id_(IDS_BOOKMARK_BAR_UNDO),
       redo_label_id_(IDS_BOOKMARK_BAR_REDO) {
 }
 
 UndoGroup::~UndoGroup() {
 }
 
 void UndoGroup::AddOperation(std::unique_ptr<UndoOperation> operation) {
   if (operations_.empty()) {
     set_undo_label_id(operation->GetUndoLabelId());
     set_redo_label_id(operation->GetRedoLabelId());
   }
-  operations_.push_back(operation.release());
+  operations_.push_back(std::move(operation));
 }
 
 void UndoGroup::Undo() {
-  for (ScopedVector<UndoOperation>::reverse_iterator ri = operations_.rbegin();
-       ri != operations_.rend(); ++ri) {
+  for (auto ri = operations_.rbegin(); ri != operations_.rend(); ++ri)
     (*ri)->Undo();
-  }
 }
 
 // UndoManager ----------------------------------------------------------------
 
 UndoManager::UndoManager()
     : group_actions_count_(0),
       undo_in_progress_action_(NULL),
       undo_suspended_count_(0),
       performing_undo_(false),
       performing_redo_(false) {
@@ skipping 76 matching lines @@
 
 void UndoManager::ResumeUndoTracking() {
   DCHECK_GT(undo_suspended_count_, 0);
   --undo_suspended_count_;
 }
 
 bool UndoManager::IsUndoTrakingSuspended() const {
   return undo_suspended_count_ > 0;
 }
 
 std::vector<UndoOperation*> UndoManager::GetAllUndoOperations() const {

[sky, 2017/01/23 16:22:16]

This function is only used in tests. Please move to the test that needs it and
friend a class named UndoManagerTestApi that exposes this function.

[ke.he, 2017/01/24 09:01:13]

Done.
ConvertToRawPtrVector() is moved into test file too.

   std::vector<UndoOperation*> result;
   for (size_t i = 0; i < undo_actions_.size(); ++i) {
-    const std::vector<UndoOperation*>& operations =
-        undo_actions_[i]->undo_operations();
+    const std::vector<UndoOperation*> operations =
+        ConvertToRawPtrVector(undo_actions_[i]->undo_operations());
     result.insert(result.end(), operations.begin(), operations.end());
   }
   for (size_t i = 0; i < redo_actions_.size(); ++i) {
-    const std::vector<UndoOperation*>& operations =
-        redo_actions_[i]->undo_operations();
+    const std::vector<UndoOperation*> operations =
+        ConvertToRawPtrVector(redo_actions_[i]->undo_operations());
     result.insert(result.end(), operations.begin(), operations.end());
   }
   // Ensure that if an Undo is in progress the UndoOperations part of that
   // UndoGroup are included in the returned set. This will ensure that any
   // changes (such as renumbering) will be applied to any potentially
   // unprocessed UndoOperations.
   if (undo_in_progress_action_) {
-    const std::vector<UndoOperation*>& operations =
-        undo_in_progress_action_->undo_operations();
+    const std::vector<UndoOperation*> operations =
+        ConvertToRawPtrVector(undo_in_progress_action_->undo_operations());
     result.insert(result.end(), operations.begin(), operations.end());
   }
 
   return result;
 }
 
 void UndoManager::RemoveAllOperations() {
   DCHECK(!group_actions_count_);
   undo_actions_.clear();
   redo_actions_.clear();
 
   NotifyOnUndoManagerStateChange();
 }
 
 void UndoManager::AddObserver(UndoManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void UndoManager::RemoveObserver(UndoManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void UndoManager::Undo(bool* performing_indicator,
-                       ScopedVector<UndoGroup>* active_undo_group) {
+void UndoManager::Undo(
+    bool* performing_indicator,
+    std::vector<std::unique_ptr<UndoGroup>>* active_undo_group) {
   // Check that action grouping has been correctly ended.
   DCHECK(!group_actions_count_);
 
   if (active_undo_group->empty())
     return;
 
   base::AutoReset<bool> incoming_changes(performing_indicator, true);
-  std::unique_ptr<UndoGroup> action(active_undo_group->back());
+  std::unique_ptr<UndoGroup> action = std::move(active_undo_group->back());
   base::AutoReset<UndoGroup*> action_context(&undo_in_progress_action_,
       action.get());
-  active_undo_group->weak_erase(
-      active_undo_group->begin() + active_undo_group->size() - 1);
+  active_undo_group->erase(active_undo_group->begin() +
+                           active_undo_group->size() - 1);
 
   StartGroupingActions();
   action->Undo();
   EndGroupingActions();
 
   NotifyOnUndoManagerStateChange();
 }
 
 void UndoManager::NotifyOnUndoManagerStateChange() {
   for (auto& observer : observers_)
     observer.OnUndoManagerStateChange();
 }
 
 void UndoManager::AddUndoGroup(UndoGroup* new_undo_group) {
-  GetActiveUndoGroup()->push_back(new_undo_group);
+  GetActiveUndoGroup()->push_back(base::WrapUnique<UndoGroup>(new_undo_group));
 
   // User actions invalidate any available redo actions.
   if (is_user_action())
     redo_actions_.clear();
 
   // Limit the number of undo levels so the undo stack does not grow unbounded.
   if (GetActiveUndoGroup()->size() > kMaxUndoGroups)
     GetActiveUndoGroup()->erase(GetActiveUndoGroup()->begin());
 
   NotifyOnUndoManagerStateChange();
 }
 
-ScopedVector<UndoGroup>* UndoManager::GetActiveUndoGroup() {
+std::vector<std::unique_ptr<UndoGroup>>* UndoManager::GetActiveUndoGroup() {
   return performing_undo_ ? &redo_actions_ : &undo_actions_;
 }