Remove ScopedVector from components/sessions.

components/sessions/core/persistent_tab_restore_service.cc

 // 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.
 
 #include "components/sessions/core/persistent_tab_restore_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <utility>
@@ skipping 193 matching lines @@
 
   // Returns the index to persist as the selected index. This is the same as
   // |tab.current_navigation_index| unless the entry at
   // |tab.current_navigation_index| shouldn't be persisted. Returns -1 if no
   // valid navigation to persist.
   int GetSelectedNavigationIndexToPersist(const Tab& tab);
 
   // Invoked when we've loaded the session commands that identify the previously
   // closed tabs. This creates entries, adds them to staging_entries_, and
   // invokes LoadState.
-  void OnGotLastSessionCommands(ScopedVector<SessionCommand> commands);
+  void OnGotLastSessionCommands(
+      std::vector<std::unique_ptr<SessionCommand>> commands);
 
   // Populates |loaded_entries| with Entries from |commands|.
   void CreateEntriesFromCommands(
-      const std::vector<SessionCommand*>& commands,
+      const std::vector<std::unique_ptr<SessionCommand>>& commands,
       std::vector<std::unique_ptr<Entry>>* loaded_entries);
 
   // Validates all entries in |entries|, deleting any with no navigations. This
   // also deletes any entries beyond the max number of entries we can hold.
   static void ValidateAndDeleteEmptyEntries(
       std::vector<std::unique_ptr<Entry>>* entries);
 
   // Callback from BaseSessionService when we've received the windows from the
   // previous session. This creates and add entries to |staging_entries_| and
   // invokes LoadStateChanged. |ignored_active_window| is ignored because we
@@ skipping 342 matching lines @@
   while (selected_index < max_index &&
          !client_->ShouldTrackURLForRestore(
              navigations[selected_index].virtual_url())) {
     selected_index++;
   }
 
   return (selected_index == max_index) ? -1 : selected_index;
 }
 
 void PersistentTabRestoreService::Delegate::OnGotLastSessionCommands(
-    ScopedVector<SessionCommand> commands) {
+    std::vector<std::unique_ptr<SessionCommand>> commands) {
   std::vector<std::unique_ptr<TabRestoreService::Entry>> entries;
-  CreateEntriesFromCommands(commands.get(), &entries);
+  CreateEntriesFromCommands(commands, &entries);
   // Closed tabs always go to the end.
   staging_entries_.insert(staging_entries_.end(),
                           make_move_iterator(entries.begin()),
                           make_move_iterator(entries.end()));
   load_state_ |= LOADED_LAST_TABS;
   LoadStateChanged();
 }
 
 void PersistentTabRestoreService::Delegate::CreateEntriesFromCommands(
-    const std::vector<SessionCommand*>& commands,
+    const std::vector<std::unique_ptr<SessionCommand>>& commands,
     std::vector<std::unique_ptr<Entry>>* loaded_entries) {
   if (tab_restore_service_helper_->entries().size() == kMaxEntries)
     return;
 
   // Iterate through the commands, populating |entries|.
   std::vector<std::unique_ptr<Entry>> entries;
   // If non-null we're processing the navigations of this tab.
   Tab* current_tab = nullptr;
   // If non-null we're processing the tabs of this window.
   Window* current_window = nullptr;
   // If > 0, we've gotten a window command but not all the tabs yet.
   int pending_window_tabs = 0;
-  for (std::vector<SessionCommand*>::const_iterator i = commands.begin();
-       i != commands.end(); ++i) {
+  for (auto i = commands.begin(); i != commands.end(); ++i) {
     const SessionCommand& command = *(*i);
     switch (command.id()) {
       case kCommandRestoredEntry: {
         if (pending_window_tabs > 0) {
           // Should never receive a restored command while waiting for all the
           // tabs in a window.
           return;
         }
 
         current_tab = nullptr;
@@ skipping 346 matching lines @@
 
 TabRestoreService::Entries* PersistentTabRestoreService::mutable_entries() {
   return &helper_.entries_;
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 }  // namespace sessions