Remove ScopedVector from components/sessions.

components/sessions/core/base_session_service.h

 // Copyright 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 COMPONENTS_SESSIONS_CORE_BASE_SESSION_SERVICE_H_
 #define COMPONENTS_SESSIONS_CORE_BASE_SESSION_SERVICE_H_
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "components/sessions/core/sessions_export.h"
 #include "url/gurl.h"
 
 
 namespace sessions {
 class BaseSessionServiceDelegate;
 class SessionCommand;
 class SessionBackend;
 
 // BaseSessionService is the super class of both tab restore service and
 // session service. It contains commonality needed by both, in particular
 // it manages a set of SessionCommands that are periodically sent to a
 // SessionBackend.
 class SESSIONS_EXPORT BaseSessionService {
  public:
   // Identifies the type of session service this is. This is used by the
   // backend to determine the name of the files.
   enum SessionType {
     SESSION_RESTORE,
     TAB_RESTORE
   };
 
-  typedef base::Callback<void(ScopedVector<SessionCommand>)>
+  typedef base::Callback<void(std::vector<std::unique_ptr<SessionCommand>>)>
       GetCommandsCallback;
 
   // Creates a new BaseSessionService. After creation you need to invoke
   // Init. |delegate| will remain owned by the creator and it is guaranteed
   // that its lifetime surpasses this class.
   // |type| gives the type of session service, |path| the path to save files to.
   BaseSessionService(SessionType type,
                      const base::FilePath& path,
                      BaseSessionServiceDelegate* delegate);
   ~BaseSessionService();
 
   // Moves the current session to the last session.
   void MoveCurrentSessionToLastSession();
 
   // Deletes the last session.
   void DeleteLastSession();
 
   // Returns the set of commands which were scheduled to be written. Once
   // committed to the backend, the commands are removed from here.
-  const ScopedVector<SessionCommand>& pending_commands() {
+  const std::vector<std::unique_ptr<SessionCommand>>& pending_commands() {
     return pending_commands_;
   }
 
   // Whether the next save resets the file before writing to it.
   void set_pending_reset(bool value) { pending_reset_ = value; }
   bool pending_reset() const { return pending_reset_; }
 
   // Returns the number of commands sent down since the last reset.
   int commands_since_reset() const { return commands_since_reset_; }
 
@@ skipping 36 matching lines @@
 
   // This posts the task to the SequencedWorkerPool, or run immediately
   // if the SequencedWorkerPool has been shutdown.
   void RunTaskOnBackendThread(const tracked_objects::Location& from_here,
                               const base::Closure& task);
 
   // The backend object which reads and saves commands.
   scoped_refptr<SessionBackend> backend_;
 
   // Commands we need to send over to the backend.
-  ScopedVector<SessionCommand> pending_commands_;
+  std::vector<std::unique_ptr<SessionCommand>> pending_commands_;
 
   // Whether the backend file should be recreated the next time we send
   // over the commands.
   bool pending_reset_;
 
   // The number of commands sent to the backend before doing a reset.
   int commands_since_reset_;
 
   BaseSessionServiceDelegate* delegate_;
 
   // A token to make sure that all tasks will be serialized.
   base::SequencedWorkerPool::SequenceToken sequence_token_;
 
   // Used to invoke Save.
   base::WeakPtrFactory<BaseSessionService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseSessionService);
 };
 
 }  // namespace sessions
 
 #endif  // COMPONENTS_SESSIONS_CORE_BASE_SESSION_SERVICE_H_