Remove ScopedVector in //component/undo

components/undo/undo_manager_test.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 "base/auto_reset.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "components/undo/undo_manager_observer.h"
 #include "components/undo/undo_operation.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
+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
+
+// UndoManagerTestApi ----------------------------------------------------------
+
+class UndoManagerTestApi {
+ public:
+  // Returns all UndoOperations that are awaiting Undo or Redo.
+  static std::vector<UndoOperation*> GetAllUndoOperations(
+      const UndoManager& undo_manager);
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(UndoManagerTestApi);
+};
+
+std::vector<UndoOperation*> UndoManagerTestApi::GetAllUndoOperations(
+    const UndoManager& undo_manager) {
+  std::vector<UndoOperation*> result;
+  for (size_t i = 0; i < undo_manager.undo_actions_.size(); ++i) {
+    const std::vector<UndoOperation*> operations =
+        ConvertToRawPtrVector(undo_manager.undo_actions_[i]->undo_operations());
+    result.insert(result.end(), operations.begin(), operations.end());
+  }
+  for (size_t i = 0; i < undo_manager.redo_actions_.size(); ++i) {
+    const std::vector<UndoOperation*> operations =
+        ConvertToRawPtrVector(undo_manager.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_manager.undo_in_progress_action_) {
+    const std::vector<UndoOperation*> operations = ConvertToRawPtrVector(
+        undo_manager.undo_in_progress_action_->undo_operations());
+    result.insert(result.end(), operations.begin(), operations.end());
+  }
+
+  return result;
+}
+
+namespace {
+
 class TestUndoOperation;
 
 // TestUndoService -------------------------------------------------------------
 
 class TestUndoService {
  public:
   TestUndoService();
   ~TestUndoService();
 
   void Redo();
@@ skipping 198 matching lines @@
   undo_service.TriggerOperation();
   undo_service.undo_manager_.EndGroupingActions();
 
   undo_service.TriggerOperation();
 
   undo_service.undo_manager_.Undo();
   ASSERT_EQ(2U, undo_service.undo_manager_.undo_count());
   ASSERT_EQ(1U, undo_service.undo_manager_.redo_count());
 
   std::vector<UndoOperation*> all_operations =
-      undo_service.undo_manager_.GetAllUndoOperations();
+      UndoManagerTestApi::GetAllUndoOperations(undo_service.undo_manager_);
   EXPECT_EQ(4U, all_operations.size());
 }
 
 TEST(UndoServiceTest, ObserverCallbacks) {
   TestObserver observer;
   TestUndoService undo_service;
   undo_service.undo_manager_.AddObserver(&observer);
   EXPECT_EQ(0, observer.state_change_count());
 
   undo_service.TriggerOperation();
@@ skipping 14 matching lines @@
   undo_service.undo_manager_.Redo();
   int callback_count_after_redo = observer.state_change_count();
   EXPECT_GT(callback_count_after_redo, callback_count_after_undo);
 
   undo_service.undo_manager_.RemoveObserver(&observer);
   undo_service.undo_manager_.Undo();
   EXPECT_EQ(callback_count_after_redo, observer.state_change_count());
 }
 
 } // namespace