Changing SessionService to have a BaseSessionService, not being one.

chrome/browser/sessions/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 "chrome/browser/sessions/session_service_commands.h"
 
 #include <vector>
 
 #include "base/pickle.h"
 #include "chrome/browser/sessions/base_session_service_commands.h"
@@ skipping 737 matching lines @@
 }
 
 scoped_ptr<SessionCommand> CreateSetWindowAppNameCommand(
     const SessionID& window_id,
     const std::string& app_name) {
   return CreateSetWindowAppNameCommand(kCommandSetWindowAppName,
                                          window_id.id(),
                                          app_name);
 }
 
-bool ReplacePendingCommand(ScopedVector<SessionCommand>& pending_commands,
+bool ReplacePendingCommand(BaseSessionService* base_session_service,
                            scoped_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>::reverse_iterator i =
-       pending_commands.rbegin(); i != pending_commands.rend(); ++i) {
+  for (ScopedVector<SessionCommand>::const_reverse_iterator i =
+           base_session_service->pending_commands().rbegin();
+       i != base_session_service->pending_commands().rend(); ++i) {
     SessionCommand* existing_command = *i;
     if ((*command)->id() == kCommandUpdateTabNavigation &&
         existing_command->id() == kCommandUpdateTabNavigation) {
       scoped_ptr<Pickle> command_pickle((*command)->PayloadAsPickle());
       PickleIterator iterator(*command_pickle);
       SessionID::id_type command_tab_id;
       int command_nav_index;
       if (!command_pickle->ReadInt(&iterator, &command_tab_id) ||
           !command_pickle->ReadInt(&iterator, &command_nav_index)) {
         return false;
       }
       SessionID::id_type existing_tab_id;
       int existing_nav_index;
       {
         // Creating a pickle like this means the Pickle references the data from
         // the command. Make sure we delete the pickle before the command, else
         // the pickle references deleted memory.
         scoped_ptr<Pickle> existing_pickle(existing_command->PayloadAsPickle());
         iterator = PickleIterator(*existing_pickle);
         if (!existing_pickle->ReadInt(&iterator, &existing_tab_id) ||
             !existing_pickle->ReadInt(&iterator, &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.
-        // Note: ScopedVector::erase will also delete the element.
-        pending_commands.erase(i.base() - 1);
-        pending_commands.push_back((*command).release());
+        base_session_service->EraseCommand(*(i.base() - 1));
+        base_session_service->AppendRebuildCommand((*command).Pass());
         return true;
       }
       return false;
     }
     if ((*command)->id() == kCommandSetActiveWindow &&
         existing_command->id() == kCommandSetActiveWindow) {
-      *i = (*command).release();
-      delete existing_command;
+      base_session_service->SwapCommand(existing_command, (*command).Pass());
       return true;
     }
   }
   return false;
 }
 
 bool IsClosingCommand(SessionCommand* command) {
   return command->id() == kCommandTabClosed ||
          command->id() == kCommandWindowClosed;
 }
 
 void RestoreSessionFromCommands(const ScopedVector<SessionCommand>& commands,
                                 std::vector<SessionWindow*>* valid_windows,
                                 SessionID::id_type* active_window_id) {
   std::map<int, SessionTab*> tabs;
   std::map<int, SessionWindow*> windows;
 
   VLOG(1) << "RestoreSessionFromCommands " << commands.size();
   if (CreateTabsAndWindows(commands, &tabs, &windows, active_window_id)) {
     AddTabsToWindows(&tabs, &windows);
     SortTabsBasedOnVisualOrderAndPrune(&windows, valid_windows);
     UpdateSelectedTabIndex(valid_windows);
   }
   STLDeleteValues(&tabs);
   // Don't delete contents of windows, that is done by the caller as all
   // valid windows are added to valid_windows.
 }