Remove ScopedVector from components/sessions.

components/sessions/core/session_service_commands.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 "components/sessions/core/session_service_commands.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <utility>
@@ skipping 305 matching lines @@
   tabs->clear();
 }
 
 // Creates tabs and windows from the commands specified in |data|. The created
 // tabs and windows are added to |tabs| and |windows| respectively, with the
 // id of the active window set in |active_window_id|. It is up to the caller
 // to delete the tabs and windows added to |tabs| and |windows|.
 //
 // This does NOT add any created SessionTabs to SessionWindow.tabs, that is
 // done by AddTabsToWindows.
-bool CreateTabsAndWindows(const ScopedVector<SessionCommand>& data,
-                          IdToSessionTab* tabs,
-                          IdToSessionWindow* windows,
-                          SessionID::id_type* active_window_id) {
+bool CreateTabsAndWindows(
+    const std::vector<std::unique_ptr<SessionCommand>>& data,
+    IdToSessionTab* tabs,
+    IdToSessionWindow* windows,
+    SessionID::id_type* active_window_id) {
   // If the file is corrupt (command with wrong size, or unknown command), we
   // still return true and attempt to restore what we we can.
   DVLOG(1) << "CreateTabsAndWindows";
 
-  for (auto i = data.begin(); i != data.end(); ++i) {
+  for (const auto& command_ptr : data) {
     const SessionCommand::id_type kCommandSetWindowBounds2 = 10;
-    const SessionCommand* command = *i;
+    const SessionCommand* command = command_ptr.get();
 
     DVLOG(1) << "Read command " << (int) command->id();
     switch (command->id()) {
       case kCommandSetTabWindow: {
         SessionID::id_type payload[2];
         if (!command->GetPayload(payload, sizeof(payload))) {
           DVLOG(1) << "Failed reading command " << command->id();
           return true;
         }
         GetTab(payload[1], tabs)->window_id.set_id(payload[0]);
@@ skipping 471 matching lines @@
 }
 
 bool ReplacePendingCommand(BaseSessionService* base_session_service,
                            std::unique_ptr<SessionCommand>* command) {
   // We optimize page navigations, which can happen quite frequently and
   // is expensive. And activation is like Highlander, there can only be one!
   if ((*command)->id() != kCommandUpdateTabNavigation &&
       (*command)->id() != kCommandSetActiveWindow) {
     return false;
   }
-  for (ScopedVector<SessionCommand>::const_reverse_iterator i =
-           base_session_service->pending_commands().rbegin();
+  for (auto i = base_session_service->pending_commands().rbegin();
        i != base_session_service->pending_commands().rend(); ++i) {
-    SessionCommand* existing_command = *i;
+    SessionCommand* existing_command = i->get();
     if ((*command)->id() == kCommandUpdateTabNavigation &&
         existing_command->id() == kCommandUpdateTabNavigation) {
       std::unique_ptr<base::Pickle> command_pickle(
           (*command)->PayloadAsPickle());
       base::PickleIterator iterator(*command_pickle);
       SessionID::id_type command_tab_id;
       int command_nav_index;
       if (!iterator.ReadInt(&command_tab_id) ||
           !iterator.ReadInt(&command_nav_index)) {
         return false;
@@ skipping 10 matching lines @@
         if (!iterator.ReadInt(&existing_tab_id) ||
             !iterator.ReadInt(&existing_nav_index)) {
           return false;
         }
       }
       if (existing_tab_id == command_tab_id &&
           existing_nav_index == command_nav_index) {
         // existing_command is an update for the same tab/index pair. Replace
         // it with the new one. We need to add to the end of the list just in
         // case there is a prune command after the update command.
-        base_session_service->EraseCommand(*(i.base() - 1));
-        base_session_service->AppendRebuildCommand((std::move(*command)));
+        base_session_service->EraseCommand((i.base() - 1)->get());
+        base_session_service->AppendRebuildCommand(std::move(*command));
         return true;
       }
       return false;
     }
     if ((*command)->id() == kCommandSetActiveWindow &&
         existing_command->id() == kCommandSetActiveWindow) {
       base_session_service->SwapCommand(existing_command,
                                         (std::move(*command)));
       return true;
     }
   }
   return false;
 }
 
 bool IsClosingCommand(SessionCommand* command) {
   return command->id() == kCommandTabClosed ||
          command->id() == kCommandWindowClosed;
 }
 
 void RestoreSessionFromCommands(
-    const ScopedVector<SessionCommand>& commands,
+    const std::vector<std::unique_ptr<SessionCommand>>& commands,
     std::vector<std::unique_ptr<SessionWindow>>* valid_windows,
     SessionID::id_type* active_window_id) {
   IdToSessionTab tabs;
   IdToSessionWindow windows;
 
   DVLOG(1) << "RestoreSessionFromCommands " << commands.size();
   if (CreateTabsAndWindows(commands, &tabs, &windows, active_window_id)) {
     AddTabsToWindows(&tabs, &windows);
     SortTabsBasedOnVisualOrderAndClear(&windows, valid_windows);
     UpdateSelectedTabIndex(valid_windows);
   }
   // AddTabsToWindows should have processed all the tabs.
   DCHECK_EQ(0u, tabs.size());
   // SortTabsBasedOnVisualOrderAndClear should have processed all the windows.
   DCHECK_EQ(0u, windows.size());
 }
 
 }  // namespace sessions