Handling |SessionCommand|s as scoped_ptr's

chrome/browser/sessions/persistent_tab_restore_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/persistent_tab_restore_service.h"
 
 #include <cstring>  // memcpy
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 137 matching lines @@
   void Shutdown();
 
   // Schedules the commands for a window close.
   void ScheduleCommandsForWindow(const Window& window);
 
   // Schedules the commands for a tab close. |selected_index| gives the index of
   // the selected navigation.
   void ScheduleCommandsForTab(const Tab& tab, int selected_index);
 
   // Creates a window close command.
-  static SessionCommand* CreateWindowCommand(SessionID::id_type id,
-                                             int selected_tab_index,
-                                             int num_tabs,
-                                             base::Time timestamp);
+  static scoped_ptr<SessionCommand> CreateWindowCommand(SessionID::id_type id,
+                                                        int selected_tab_index,
+                                                        int num_tabs,
+                                                        base::Time timestamp);
 
   // Creates a tab close command.
-  static SessionCommand* CreateSelectedNavigationInTabCommand(
+  static scoped_ptr<SessionCommand> CreateSelectedNavigationInTabCommand(
       SessionID::id_type tab_id,
       int32 index,
       base::Time timestamp);
 
   // Creates a restore command.
-  static SessionCommand* CreateRestoredEntryCommand(
+  static scoped_ptr<SessionCommand> CreateRestoredEntryCommand(
     SessionID::id_type entry_id);
 
   // 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
@@ skipping 106 matching lines @@
   }
   if (pending_reset())
     entries_written_ = 0;
   BaseSessionService::Save();
 }
 
 void PersistentTabRestoreService::Delegate::OnClearEntries() {
   // Mark all the tabs as closed so that we don't attempt to restore them.
   const Entries& entries = tab_restore_service_helper_->entries();
   for (Entries::const_iterator i = entries.begin(); i != entries.end(); ++i)
-    ScheduleCommand(CreateRestoredEntryCommand((*i)->id));
+    ScheduleCommand(CreateRestoredEntryCommand((*i)->id).Pass());
 
   entries_to_write_ = 0;
 
   // Schedule a pending reset so that we nuke the file on next write.
   set_pending_reset(true);
 
   // Schedule a command, otherwise if there are no pending commands Save does
   // nothing.
-  ScheduleCommand(CreateRestoredEntryCommand(1));
+  ScheduleCommand(CreateRestoredEntryCommand(1).Pass());
 }
 
 void PersistentTabRestoreService::Delegate::OnRestoreEntryById(
     SessionID::id_type id,
     Entries::const_iterator entry_iterator) {
   size_t index = 0;
   const Entries& entries = tab_restore_service_helper_->entries();
   for (Entries::const_iterator j = entries.begin();
        j != entry_iterator && j != entries.end();
        ++j, ++index) {}
   if (static_cast<int>(index) < entries_to_write_)
     entries_to_write_--;
 
-  ScheduleCommand(CreateRestoredEntryCommand(id));
+  ScheduleCommand(CreateRestoredEntryCommand(id).Pass());
 }
 
 void PersistentTabRestoreService::Delegate::OnAddEntry() {
   // Start the save timer, when it fires we'll generate the commands.
   StartSaveTimer();
   entries_to_write_++;
 }
 
 void PersistentTabRestoreService::Delegate::LoadTabsFromLastSession() {
   if (load_state_ != NOT_LOADED)
@@ skipping 73 matching lines @@
       real_selected_tab--;
     }
   }
   if (valid_tab_count == 0)
     return;  // No tabs to persist.
 
   ScheduleCommand(
       CreateWindowCommand(window.id,
                           std::min(real_selected_tab, valid_tab_count - 1),
                           valid_tab_count,
-                          window.timestamp));
+                          window.timestamp).Pass());
 
   if (!window.app_name.empty()) {
     ScheduleCommand(CreateSetWindowAppNameCommand(kCommandSetWindowAppName,
                                                     window.id,
-                                                    window.app_name));
+                                                    window.app_name).Pass());
   }
 
   for (size_t i = 0; i < window.tabs.size(); ++i) {
     int selected_index = GetSelectedNavigationIndexToPersist(window.tabs[i]);
     if (selected_index != -1)
       ScheduleCommandsForTab(window.tabs[i], selected_index);
   }
 }
 
 void PersistentTabRestoreService::Delegate::ScheduleCommandsForTab(
@@ skipping 11 matching lines @@
     if (ShouldTrackEntry(navigations[i].virtual_url())) {
       first_index_to_persist = i;
       valid_count_before_selected++;
     }
   }
 
   // Write the command that identifies the selected tab.
   ScheduleCommand(
       CreateSelectedNavigationInTabCommand(tab.id,
                                            valid_count_before_selected,
-                                           tab.timestamp));
+                                           tab.timestamp).Pass());
 
   if (tab.pinned) {
     PinnedStatePayload payload = true;
-    SessionCommand* command =
-        new SessionCommand(kCommandPinnedState, sizeof(payload));
+    scoped_ptr<SessionCommand> command(
+        new SessionCommand(kCommandPinnedState, sizeof(payload)));
     memcpy(command->contents(), &payload, sizeof(payload));
-    ScheduleCommand(command);
+    ScheduleCommand(command.Pass());
   }
 
   if (!tab.extension_app_id.empty()) {
     ScheduleCommand(CreateSetTabExtensionAppIDCommand(
                           kCommandSetExtensionAppID,
                           tab.id,
-                          tab.extension_app_id));
+                          tab.extension_app_id).Pass());
   }
 
   if (!tab.user_agent_override.empty()) {
     ScheduleCommand(CreateSetTabUserAgentOverrideCommand(
                           kCommandSetTabUserAgentOverride,
                           tab.id,
-                          tab.user_agent_override));
+                          tab.user_agent_override).Pass());
   }
 
   // Then write the navigations.
   for (int i = first_index_to_persist, wrote_count = 0;
        i < max_index && wrote_count < 2 * max_persist_navigation_count; ++i) {
     if (ShouldTrackEntry(navigations[i].virtual_url())) {
       ScheduleCommand(CreateUpdateTabNavigationCommand(
                             kCommandUpdateTabNavigation,
                             tab.id,
                             navigations[i]));
     }
   }
 }
 
 // static
-SessionCommand* PersistentTabRestoreService::Delegate::CreateWindowCommand(
+scoped_ptr<SessionCommand>
+PersistentTabRestoreService::Delegate::CreateWindowCommand(
     SessionID::id_type id,
     int selected_tab_index,
     int num_tabs,
     base::Time timestamp) {
   WindowPayload2 payload;
   // |timestamp| is aligned on a 16 byte boundary, leaving 4 bytes of
   // uninitialized memory in the struct.
   memset(&payload, 0, sizeof(payload));
   payload.window_id = id;
   payload.selected_tab_index = selected_tab_index;
   payload.num_tabs = num_tabs;
   payload.timestamp = timestamp.ToInternalValue();
 
-  SessionCommand* command =
-      new SessionCommand(kCommandWindow, sizeof(payload));
+  scoped_ptr<SessionCommand> command(
+      new SessionCommand(kCommandWindow, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 // static
-SessionCommand*
+scoped_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateSelectedNavigationInTabCommand(
     SessionID::id_type tab_id,
     int32 index,
     base::Time timestamp) {
   SelectedNavigationInTabPayload2 payload;
   payload.id = tab_id;
   payload.index = index;
   payload.timestamp = timestamp.ToInternalValue();
-  SessionCommand* command =
-      new SessionCommand(kCommandSelectedNavigationInTab, sizeof(payload));
+  scoped_ptr<SessionCommand> command(
+      new SessionCommand(kCommandSelectedNavigationInTab, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 // static
-SessionCommand*
+scoped_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateRestoredEntryCommand(
     SessionID::id_type entry_id) {
   RestoredEntryPayload payload = entry_id;
-  SessionCommand* command =
-      new SessionCommand(kCommandRestoredEntry, sizeof(payload));
+  scoped_ptr<SessionCommand> command(
+      new SessionCommand(kCommandRestoredEntry, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 int PersistentTabRestoreService::Delegate::GetSelectedNavigationIndexToPersist(
     const Tab& tab) {
   const std::vector<sessions::SerializedNavigationEntry>& navigations =
       tab.navigations;
   int selected_index = tab.current_navigation_index;
   int max_index = static_cast<int>(navigations.size());
@@ skipping 457 matching lines @@
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 KeyedService* TabRestoreServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* profile) const {
   return new PersistentTabRestoreService(static_cast<Profile*>(profile), NULL);
 }