Handling |SessionCommand|s as scoped_ptr's

chrome/browser/sessions/session_service.cc

 // Copyright (c) 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 "chrome/browser/sessions/session_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 136 matching lines @@
   RunTaskOnBackendThread(
       FROM_HERE, base::Bind(&SessionBackend::MoveCurrentSessionToLastSession,
                             backend()));
 }
 
 void SessionService::SetTabWindow(const SessionID& window_id,
                                   const SessionID& tab_id) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
-  ScheduleCommand(CreateSetTabWindowCommand(window_id, tab_id));
+  ScheduleCommand(CreateSetTabWindowCommand(window_id, tab_id).Pass());
 }
 
 void SessionService::SetWindowBounds(const SessionID& window_id,
                                      const gfx::Rect& bounds,
                                      ui::WindowShowState show_state) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
-  ScheduleCommand(CreateSetWindowBoundsCommand(window_id, bounds, show_state));
+  ScheduleCommand(
+      CreateSetWindowBoundsCommand(window_id, bounds, show_state).Pass());
 }
 
 void SessionService::SetTabIndexInWindow(const SessionID& window_id,
                                          const SessionID& tab_id,
                                          int new_index) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
-  ScheduleCommand(CreateSetTabIndexInWindowCommand(tab_id, new_index));
+  ScheduleCommand(CreateSetTabIndexInWindowCommand(tab_id, new_index).Pass());
 }
 
 void SessionService::SetPinnedState(const SessionID& window_id,
                                     const SessionID& tab_id,
                                     bool is_pinned) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
-  ScheduleCommand(CreatePinnedStateCommand(tab_id, is_pinned));
+  ScheduleCommand(CreatePinnedStateCommand(tab_id, is_pinned).Pass());
 }
 
 void SessionService::TabClosed(const SessionID& window_id,
                                const SessionID& tab_id,
                                bool closed_by_user_gesture) {
   if (!tab_id.id())
     return;  // Hapens when the tab is replaced.
 
   if (!ShouldTrackChangesToWindow(window_id))
     return;
@@ skipping 10 matching lines @@
     pending_tab_close_ids_.insert(tab_id.id());
   } else if (find(window_closing_ids_.begin(), window_closing_ids_.end(),
                   window_id.id()) != window_closing_ids_.end() ||
              !IsOnlyOneTabLeft() ||
              closed_by_user_gesture) {
     // Close is the result of one of the following:
     // . window close (and it isn't the last window).
     // . closing a tab and there are other windows/tabs open.
     // . closed by a user gesture.
     // In all cases we need to mark the tab as explicitly closed.
-    ScheduleCommand(CreateTabClosedCommand(tab_id.id()));
+    ScheduleCommand(CreateTabClosedCommand(tab_id.id()).Pass());
   } else {
     // User closed the last tab in the last tabbed browser. Don't mark the
     // tab closed.
     pending_tab_close_ids_.insert(tab_id.id());
     has_open_trackable_browsers_ = false;
   }
 }
 
 void SessionService::WindowOpened(Browser* browser) {
   if (!ShouldTrackBrowser(browser))
@@ skipping 53 matching lines @@
   if (!ShouldTrackChangesToWindow(window_id)) {
     // The last window may be one that is not tracked.
     MaybeDeleteSessionOnlyData();
     return;
   }
 
   windows_tracking_.erase(window_id.id());
 
   if (window_closing_ids_.find(window_id.id()) != window_closing_ids_.end()) {
     window_closing_ids_.erase(window_id.id());
-    ScheduleCommand(CreateWindowClosedCommand(window_id.id()));
+    ScheduleCommand(CreateWindowClosedCommand(window_id.id()).Pass());
   } else if (pending_window_close_ids_.find(window_id.id()) ==
              pending_window_close_ids_.end()) {
     // We'll hit this if user closed the last tab in a window.
     has_open_trackable_browsers_ = HasOpenTrackableBrowsers(window_id);
     if (!has_open_trackable_browsers_)
       pending_window_close_ids_.insert(window_id.id());
     else
-      ScheduleCommand(CreateWindowClosedCommand(window_id.id()));
+      ScheduleCommand(CreateWindowClosedCommand(window_id.id()).Pass());
   }
   MaybeDeleteSessionOnlyData();
 }
 
 void SessionService::TabInserted(WebContents* contents) {
   SessionTabHelper* session_tab_helper =
       SessionTabHelper::FromWebContents(contents);
   if (!ShouldTrackChangesToWindow(session_tab_helper->window_id()))
     return;
   SetTabWindow(session_tab_helper->window_id(),
@@ skipping 11 matching lines @@
   // Record the association between the SessionStorageNamespace and the
   // tab.
   //
   // TODO(ajwong): This should be processing the whole map rather than
   // just the default. This in particular will not work for tabs with only
   // isolated apps which won't have a default partition.
   content::SessionStorageNamespace* session_storage_namespace =
       contents->GetController().GetDefaultSessionStorageNamespace();
   ScheduleCommand(CreateSessionStorageAssociatedCommand(
       session_tab_helper->session_id(),
-      session_storage_namespace->persistent_id()));
+      session_storage_namespace->persistent_id()).Pass());
   session_storage_namespace->SetShouldPersist(true);
 }
 
 void SessionService::TabClosing(WebContents* contents) {
   // Allow the associated sessionStorage to get deleted; it won't be needed
   // in the session restore.
   content::SessionStorageNamespace* session_storage_namespace =
       contents->GetController().GetDefaultSessionStorageNamespace();
   session_storage_namespace->SetShouldPersist(false);
   SessionTabHelper* session_tab_helper =
@@ skipping 14 matching lines @@
 
   windows_tracking_.insert(window_id.id());
 
   // The user created a new tabbed browser with our profile. Commit any
   // pending closes.
   CommitPendingCloses();
 
   has_open_trackable_browsers_ = true;
   move_on_new_browser_ = true;
 
-  ScheduleCommand(CreateSetWindowTypeCommand(window_id, window_type));
+  ScheduleCommand(CreateSetWindowTypeCommand(window_id, window_type).Pass());
 }
 
 void SessionService::SetWindowAppName(
     const SessionID& window_id,
     const std::string& app_name) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
-  ScheduleCommand(CreateSetWindowAppNameCommand(window_id, app_name));
+  ScheduleCommand(CreateSetWindowAppNameCommand(window_id, app_name).Pass());
 }
 
 void SessionService::TabNavigationPathPrunedFromBack(const SessionID& window_id,
                                                      const SessionID& tab_id,
                                                      int count) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
-  ScheduleCommand(CreateTabNavigationPathPrunedFromBackCommand(tab_id, count));
+  ScheduleCommand(
+      CreateTabNavigationPathPrunedFromBackCommand(tab_id, count).Pass());
 }
 
 void SessionService::TabNavigationPathPrunedFromFront(
     const SessionID& window_id,
     const SessionID& tab_id,
     int count) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   // Update the range of indices.
   if (tab_to_available_range_.find(tab_id.id()) !=
       tab_to_available_range_.end()) {
     std::pair<int, int>& range = tab_to_available_range_[tab_id.id()];
     range.first = std::max(0, range.first - count);
     range.second = std::max(0, range.second - count);
   }
 
-  ScheduleCommand(CreateTabNavigationPathPrunedFromFrontCommand(tab_id, count));
+  ScheduleCommand(
+      CreateTabNavigationPathPrunedFromFrontCommand(tab_id, count).Pass());
 }
 
 void SessionService::UpdateTabNavigation(
     const SessionID& window_id,
     const SessionID& tab_id,
     const SerializedNavigationEntry& navigation) {
   if (!ShouldTrackEntry(navigation.virtual_url()) ||
       !ShouldTrackChangesToWindow(window_id)) {
     return;
   }
 
   if (tab_to_available_range_.find(tab_id.id()) !=
       tab_to_available_range_.end()) {
     std::pair<int, int>& range = tab_to_available_range_[tab_id.id()];
     range.first = std::min(navigation.index(), range.first);
     range.second = std::max(navigation.index(), range.second);
   }
-  ScheduleCommand(CreateUpdateTabNavigationCommand(tab_id, navigation));
+  ScheduleCommand(CreateUpdateTabNavigationCommand(tab_id, navigation).Pass());
 }
 
 void SessionService::TabRestored(WebContents* tab, bool pinned) {
   SessionTabHelper* session_tab_helper = SessionTabHelper::FromWebContents(tab);
   if (!ShouldTrackChangesToWindow(session_tab_helper->window_id()))
     return;
 
-  BuildCommandsForTab(session_tab_helper->window_id(), tab, -1,
-                      pinned, &pending_commands(), NULL);
+  BuildCommandsForTab(session_tab_helper->window_id(),
+                      tab,
+                      -1,
+                      pinned,
+                      &pending_commands(),
+                      NULL);
   StartSaveTimer();
 }
 
 void SessionService::SetSelectedNavigationIndex(const SessionID& window_id,
                                                 const SessionID& tab_id,
                                                 int index) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   if (tab_to_available_range_.find(tab_id.id()) !=
       tab_to_available_range_.end()) {
     if (index < tab_to_available_range_[tab_id.id()].first ||
         index > tab_to_available_range_[tab_id.id()].second) {
       // The new index is outside the range of what we've archived, schedule
       // a reset.
       ResetFromCurrentBrowsers();
       return;
     }
   }
-  ScheduleCommand(CreateSetSelectedNavigationIndexCommand(tab_id, index));
+  ScheduleCommand(
+    CreateSetSelectedNavigationIndexCommand(tab_id, index).Pass());
 }
 
 void SessionService::SetSelectedTabInWindow(const SessionID& window_id,
                                             int index) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
-  ScheduleCommand(CreateSetSelectedTabInWindowCommand(window_id, index));
+  ScheduleCommand(CreateSetSelectedTabInWindowCommand(window_id, index).Pass());
 }
 
 void SessionService::SetTabUserAgentOverride(
     const SessionID& window_id,
     const SessionID& tab_id,
     const std::string& user_agent_override) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
-  ScheduleCommand(CreateSetTabUserAgentOverrideCommand(tab_id,
-                                                       user_agent_override));
+  ScheduleCommand(
+    CreateSetTabUserAgentOverrideCommand(tab_id, user_agent_override).Pass());
 }
 
 void SessionService::SetTabExtensionAppID(
     const SessionID& window_id,
     const SessionID& tab_id,
     const std::string& extension_app_id) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
-  ScheduleCommand(CreateSetTabExtensionAppIDCommand(tab_id, extension_app_id));
+  ScheduleCommand(
+    CreateSetTabExtensionAppIDCommand(tab_id, extension_app_id).Pass());
 }
 
 base::CancelableTaskTracker::TaskId SessionService::GetLastSession(
     const SessionCallback& callback,
     base::CancelableTaskTracker* tracker) {
   // OnGotSessionCommands maps the SessionCommands to browser state, then run
   // the callback.
   return ScheduleGetLastSessionCommands(
       base::Bind(&SessionService::OnGotSessionCommands,
-                 weak_factory_.GetWeakPtr(), callback),
+                 weak_factory_.GetWeakPtr(),
+                 callback),
       tracker);
 }
 
 void SessionService::Save() {
   bool had_commands = !pending_commands().empty();
   BaseSessionService::Save();
   if (had_commands) {
     RecordSessionUpdateHistogramData(chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
                                      &last_updated_save_time_);
     content::NotificationService::current()->Notify(
@@ skipping 172 matching lines @@
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 void SessionService::OnBrowserSetLastActive(Browser* browser) {
   if (ShouldTrackBrowser(browser))
-    ScheduleCommand(CreateSetActiveWindowCommand(browser->session_id()));
+    ScheduleCommand(CreateSetActiveWindowCommand(browser->session_id()).Pass());
 }
 
 void SessionService::OnGotSessionCommands(
     const SessionCallback& callback,
     ScopedVector<SessionCommand> commands) {
   ScopedVector<SessionWindow> valid_windows;
   SessionID::id_type active_window_id = 0;
 
   startup_metric_utils::ScopedSlowStartupUMA
       scoped_timer("Startup.SlowStartupSessionServiceCreateTabsAndWindows");
 
-  RestoreSessionFromCommands(
-      commands.get(), &valid_windows.get(), &active_window_id);
+  RestoreSessionFromCommands(commands, &valid_windows.get(), &active_window_id);
   RemoveUnusedRestoreWindows(&valid_windows.get());
 
   callback.Run(valid_windows.Pass(), active_window_id);
 }
 
 void SessionService::BuildCommandsForTab(const SessionID& window_id,
                                          WebContents* tab,
                                          int index_in_window,
                                          bool is_pinned,
-                                         std::vector<SessionCommand*>* commands,
+                                         ScopedVector<SessionCommand>* commands,
                                          IdToRange* tab_to_available_range) {
   DCHECK(tab && commands && window_id.id());
   SessionTabHelper* session_tab_helper = SessionTabHelper::FromWebContents(tab);
   const SessionID& session_id(session_tab_helper->session_id());
-  commands->push_back(CreateSetTabWindowCommand(window_id, session_id));
+  commands->push_back(
+    CreateSetTabWindowCommand(window_id, session_id).release());
 
   const int current_index = tab->GetController().GetCurrentEntryIndex();
   const int min_index = std::max(0,
                                  current_index - max_persist_navigation_count);
   const int max_index =
       std::min(current_index + max_persist_navigation_count,
                tab->GetController().GetEntryCount());
   const int pending_index = tab->GetController().GetPendingEntryIndex();
   if (tab_to_available_range) {
     (*tab_to_available_range)[session_id.id()] =
         std::pair<int, int>(min_index, max_index);
   }
 
   if (is_pinned)
-    commands->push_back(CreatePinnedStateCommand(session_id, true));
+    commands->push_back(CreatePinnedStateCommand(session_id, true).release());
 
   extensions::TabHelper* extensions_tab_helper =
       extensions::TabHelper::FromWebContents(tab);
   if (extensions_tab_helper->extension_app()) {
     commands->push_back(CreateSetTabExtensionAppIDCommand(
         session_id,
-        extensions_tab_helper->extension_app()->id()));
+        extensions_tab_helper->extension_app()->id()).release());
   }
 
   const std::string& ua_override = tab->GetUserAgentOverride();
   if (!ua_override.empty()) {
-    commands->push_back(CreateSetTabUserAgentOverrideCommand(session_id,
-                                                             ua_override));
+    commands->push_back(
+      CreateSetTabUserAgentOverrideCommand(session_id, ua_override).release());
   }
 
   for (int i = min_index; i < max_index; ++i) {
     const NavigationEntry* entry = (i == pending_index) ?
         tab->GetController().GetPendingEntry() :
         tab->GetController().GetEntryAtIndex(i);
     DCHECK(entry);
     if (ShouldTrackEntry(entry->GetVirtualURL())) {
       const SerializedNavigationEntry navigation =
           ContentSerializedNavigationBuilder::FromNavigationEntry(i, *entry);
       commands->push_back(
-          CreateUpdateTabNavigationCommand(session_id, navigation));
+          CreateUpdateTabNavigationCommand(session_id, navigation).release());
     }
   }
   commands->push_back(
-      CreateSetSelectedNavigationIndexCommand(session_id, current_index));
+      CreateSetSelectedNavigationIndexCommand(session_id,
+                                              current_index).release());
 
   if (index_in_window != -1) {
-    commands->push_back(
-        CreateSetTabIndexInWindowCommand(session_id, index_in_window));
+    commands->push_back(CreateSetTabIndexInWindowCommand(
+                            session_id,
+                            index_in_window).release());
   }
 
   // Record the association between the sessionStorage namespace and the tab.
   content::SessionStorageNamespace* session_storage_namespace =
       tab->GetController().GetDefaultSessionStorageNamespace();
   ScheduleCommand(CreateSessionStorageAssociatedCommand(
       session_tab_helper->session_id(),
-      session_storage_namespace->persistent_id()));
+      session_storage_namespace->persistent_id()).Pass());
 }
 
 void SessionService::BuildCommandsForBrowser(
     Browser* browser,
-    std::vector<SessionCommand*>* commands,
+    ScopedVector<SessionCommand>* commands,
     IdToRange* tab_to_available_range,
     std::set<SessionID::id_type>* windows_to_track) {
   DCHECK(browser && commands);
   DCHECK(browser->session_id().id());
 
-  commands->push_back(
-      CreateSetWindowBoundsCommand(browser->session_id(),
-                                   browser->window()->GetRestoredBounds(),
-                                   browser->window()->GetRestoredState()));
+  commands->push_back(CreateSetWindowBoundsCommand(
+                          browser->session_id(),
+                          browser->window()->GetRestoredBounds(),
+                          browser->window()->GetRestoredState()).release());
 
   commands->push_back(CreateSetWindowTypeCommand(
-      browser->session_id(),
-      WindowTypeForBrowserType(browser->type())));
+                          browser->session_id(),
+                          WindowTypeForBrowserType(browser->type())).release());
 
   if (!browser->app_name().empty()) {
-    commands->push_back(CreateSetWindowAppNameCommand(browser->session_id(),
-                                                      browser->app_name()));
+    commands->push_back(CreateSetWindowAppNameCommand(
+                            browser->session_id(),
+                            browser->app_name()).release());
   }
 
   windows_to_track->insert(browser->session_id().id());
   TabStripModel* tab_strip = browser->tab_strip_model();
   for (int i = 0; i < tab_strip->count(); ++i) {
     WebContents* tab = tab_strip->GetWebContentsAt(i);
     DCHECK(tab);
     BuildCommandsForTab(browser->session_id(), tab, i,
                         tab_strip->IsTabPinned(i),
                         commands, tab_to_available_range);
   }
 
   commands->push_back(CreateSetSelectedTabInWindowCommand(
-                          browser->session_id(),
-                          browser->tab_strip_model()->active_index()));
+          browser->session_id(),
+          browser->tab_strip_model()->active_index()).release());
 }
 
 void SessionService::BuildCommandsFromBrowsers(
-    std::vector<SessionCommand*>* commands,
+    ScopedVector<SessionCommand>* commands,
     IdToRange* tab_to_available_range,
     std::set<SessionID::id_type>* windows_to_track) {
   DCHECK(commands);
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     Browser* browser = *it;
     // Make sure the browser has tabs and a window. Browser's destructor
     // removes itself from the BrowserList. When a browser is closed the
     // destructor is not necessarily run immediately. This means it's possible
     // for us to get a handle to a browser that is about to be removed. If
     // the tab count is 0 or the window is NULL, the browser is about to be
     // deleted, so we ignore it.
     if (ShouldTrackBrowser(browser) && browser->tab_strip_model()->count() &&
         browser->window()) {
       BuildCommandsForBrowser(browser, commands, tab_to_available_range,
                               windows_to_track);
     }
   }
 }
 
 void SessionService::ScheduleResetCommands() {
   set_pending_reset(true);
-  STLDeleteElements(&pending_commands());
+  pending_commands().clear();
   tab_to_available_range_.clear();
   windows_tracking_.clear();
-  BuildCommandsFromBrowsers(&pending_commands(), &tab_to_available_range_,
+  BuildCommandsFromBrowsers(&pending_commands(),
+                            &tab_to_available_range_,
                             &windows_tracking_);
   if (!windows_tracking_.empty()) {
     // We're lazily created on startup and won't get an initial batch of
     // SetWindowType messages. Set these here to make sure our state is correct.
     has_open_trackable_browsers_ = true;
     move_on_new_browser_ = true;
   }
   StartSaveTimer();
 }
 
-void SessionService::ScheduleCommand(SessionCommand* command) {
+void SessionService::ScheduleCommand(scoped_ptr<SessionCommand> command) {
   DCHECK(command);
-  if (ReplacePendingCommand(command, pending_commands()))
+  if (ReplacePendingCommand(pending_commands(), &command))
     return;
-  BaseSessionService::ScheduleCommand(command);
+  bool is_closing_command = IsClosingCommand(command.get());
+  BaseSessionService::ScheduleCommand(command.Pass());
   // Don't schedule a reset on tab closed/window closed. Otherwise we may
   // lose tabs/windows we want to restore from if we exit right after this.
   if (!pending_reset() && pending_window_close_ids_.empty() &&
-      commands_since_reset() >= kWritesPerReset && !IsClosingCommand(command)) {
+      commands_since_reset() >= kWritesPerReset && is_closing_command) {
     ScheduleResetCommands();
   }
 }
 
 void SessionService::CommitPendingCloses() {
   for (PendingTabCloseIDs::iterator i = pending_tab_close_ids_.begin();
        i != pending_tab_close_ids_.end(); ++i) {
-    ScheduleCommand(CreateTabClosedCommand(*i));
+    ScheduleCommand(CreateTabClosedCommand(*i).Pass());
   }
   pending_tab_close_ids_.clear();
 
   for (PendingWindowCloseIDs::iterator i = pending_window_close_ids_.begin();
        i != pending_window_close_ids_.end(); ++i) {
-    ScheduleCommand(CreateWindowClosedCommand(*i));
+    ScheduleCommand(CreateWindowClosedCommand(*i).Pass());
   }
   pending_window_close_ids_.clear();
 }
 
 bool SessionService::IsOnlyOneTabLeft() const {
   if (!profile() || profile()->AsTestingProfile()) {
     // We're testing, always return false.
     return false;
   }
 
@@ skipping 197 matching lines @@
     return;
   }
 
   // Check for any open windows for the current profile that we aren't tracking.
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     if ((*it)->profile() == profile())
       return;
   }
   DeleteSessionOnlyData(profile());
 }