Make TabRestoreService::Entry noncopyable and fix up surrounding code.

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>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/time/time.h"
 #include "components/sessions/core/base_session_service.h"
 #include "components/sessions/core/base_session_service_commands.h"
 #include "components/sessions/core/base_session_service_delegate.h"
 #include "components/sessions/core/session_command.h"
 #include "components/sessions/core/session_constants.h"
 
 namespace sessions {
 
 namespace {
 
 // Only written if the tab is pinned.
 typedef bool PinnedStatePayload;
 
 typedef int32_t RestoredEntryPayload;
 
-typedef std::map<SessionID::id_type, TabRestoreService::Entry*> IDToEntry;
-
 // Payload used for the start of a tab close. This is the old struct that is
 // used for backwards compat when it comes to reading the session files.
 struct SelectedNavigationInTabPayload {
   SessionID::id_type id;
   int32_t index;
 };
 
 // Payload used for the start of a window close. This is the old struct that is
 // used for backwards compat when it comes to reading the session files. This
 // struct must be POD, because we memset the contents.
@@ skipping 54 matching lines @@
 const SessionCommand::id_type kCommandSetExtensionAppID = 6;
 const SessionCommand::id_type kCommandSetWindowAppName = 7;
 const SessionCommand::id_type kCommandSetTabUserAgentOverride = 8;
 
 // Number of entries (not commands) before we clobber the file and write
 // everything.
 const int kEntriesPerReset = 40;
 
 const size_t kMaxEntries = TabRestoreServiceHelper::kMaxEntries;
 
+void RemoveEntryByID(
+    SessionID::id_type id,
+    std::vector<std::unique_ptr<TabRestoreService::Entry>>* entries) {
+  // Look for the entry in the top-level collection.
+  for (auto it = entries->begin(); it != entries->end(); ++it) {
+    TabRestoreService::Entry& entry = **it;
+    // Erase it if it's our target.
+    if (entry.id == id) {
+      entries->erase(it);
+      return;
+    }
+    // If this entry is a window, look through its tabs.
+    if (entry.type == TabRestoreService::WINDOW) {
+      auto& window = static_cast<TabRestoreService::Window&>(entry);
+      for (auto it = window.tabs.begin(); it != window.tabs.end(); ++it) {
+        const TabRestoreService::Tab& tab = **it;
+        // Erase it if it's our target.
+        if (tab.id == id) {
+          window.tabs.erase(it);
+          return;
+        }
+      }
+    }
+  }
+}
+
 }  // namespace
 
 // PersistentTabRestoreService::Delegate ---------------------------------------
 
 // This restore service will create and own a BaseSessionService and implement
 // the required BaseSessionServiceDelegate.
 class PersistentTabRestoreService::Delegate
     : public BaseSessionServiceDelegate,
       public TabRestoreServiceHelper::Observer {
  public:
@@ skipping 17 matching lines @@
     tab_restore_service_helper_ = tab_restore_service_helper;
   }
 
   void LoadTabsFromLastSession();
 
   void DeleteLastSession();
 
   bool IsLoaded() const;
 
   // Creates and add entries to |entries| for each of the windows in |windows|.
-  static void CreateEntriesFromWindows(std::vector<SessionWindow*>* windows,
-                                       std::vector<Entry*>* entries);
+  static void CreateEntriesFromWindows(
+      std::vector<SessionWindow*>* windows,
+      std::vector<std::unique_ptr<Entry>>* entries);
 
   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);
 
@@ skipping 19 matching lines @@
   // |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);
 
   // Populates |loaded_entries| with Entries from |commands|.
-  void CreateEntriesFromCommands(const std::vector<SessionCommand*>& commands,
-                                 std::vector<Entry*>* loaded_entries);
+  void CreateEntriesFromCommands(
+      const std::vector<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<Entry*>* entries);
+  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
   // don't need to restore activation.
   void OnGotPreviousSession(ScopedVector<SessionWindow> windows,
                             SessionID::id_type ignored_active_window);
 
   // Converts a SessionWindow into a Window, returning true on success. We use 0
   // as the timestamp here since we do not know when the window/tab was closed.
   static bool ConvertSessionWindowToWindow(SessionWindow* session_window,
                                            Window* window);
 
   // Invoked when previous tabs or session is loaded. If both have finished
   // loading the entries in |staging_entries_| are added to entries and
   // observers are notified.
   void LoadStateChanged();
 
-  // If |id_to_entry| contains an entry for |id| the corresponding entry is
-  // deleted and removed from both |id_to_entry| and |entries|. This is used
-  // when creating entries from the backend file.
-  void RemoveEntryByID(SessionID::id_type id,
-                       IDToEntry* id_to_entry,
-                       std::vector<TabRestoreService::Entry*>* entries);
-
  private:
   // The associated client.
   TabRestoreServiceClient* client_;
 
   std::unique_ptr<BaseSessionService> base_session_service_;
 
   TabRestoreServiceHelper* tab_restore_service_helper_;
 
   // The number of entries to write.
   int entries_to_write_;
 
   // Number of entries we've written.
   int entries_written_;
 
   // Whether we've loaded the last session.
   int load_state_;
 
   // Results from previously closed tabs/sessions is first added here. When the
   // results from both us and the session restore service have finished loading
   // LoadStateChanged is invoked, which adds these entries to entries_.
-  ScopedVector<Entry> staging_entries_;
+  std::vector<std::unique_ptr<Entry>> staging_entries_;
 
   // Used when loading previous tabs/session and open tabs/session.
   base::CancelableTaskTracker cancelable_task_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
 PersistentTabRestoreService::Delegate::Delegate(TabRestoreServiceClient* client)
     : client_(client),
       base_session_service_(
@@ skipping 26 matching lines @@
     base_session_service_->set_pending_reset(true);
   }
   if (to_write_count) {
     // Write the to_write_count most recently added entries out. The most
     // recently added entry is at the front, so we use a reverse iterator to
     // write in the order the entries were added.
     Entries::const_reverse_iterator i = entries.rbegin();
     DCHECK(static_cast<size_t>(to_write_count) <= entries.size());
     std::advance(i, entries.size() - static_cast<int>(to_write_count));
     for (; i != entries.rend(); ++i) {
-      Entry* entry = *i;
-      if (entry->type == TAB) {
-        Tab* tab = static_cast<Tab*>(entry);
-        int selected_index = GetSelectedNavigationIndexToPersist(*tab);
-        if (selected_index != -1)
-          ScheduleCommandsForTab(*tab, selected_index);
-      } else {
-        ScheduleCommandsForWindow(*static_cast<Window*>(entry));
+      Entry& entry = **i;
+      switch (entry.type) {
+        case TAB: {
+          Tab& tab = static_cast<Tab&>(entry);
+          int selected_index = GetSelectedNavigationIndexToPersist(tab);
+          if (selected_index != -1)
+            ScheduleCommandsForTab(tab, selected_index);
+          break;
+        }
+        case WINDOW:
+          ScheduleCommandsForWindow(static_cast<Window&>(entry));
+          break;
       }
       entries_written_++;
     }
   }
   if (base_session_service_->pending_reset())
     entries_written_ = 0;
 }
 
 void PersistentTabRestoreService::Delegate::OnClearEntries() {
   // Mark all the tabs as closed so that we don't attempt to restore them.
@@ skipping 65 matching lines @@
   base_session_service_->DeleteLastSession();
 }
 
 bool PersistentTabRestoreService::Delegate::IsLoaded() const {
   return !(load_state_ & (NOT_LOADED | LOADING));
 }
 
 // static
 void PersistentTabRestoreService::Delegate::CreateEntriesFromWindows(
     std::vector<SessionWindow*>* windows,
-    std::vector<Entry*>* entries) {
+    std::vector<std::unique_ptr<Entry>>* entries) {
   for (size_t i = 0; i < windows->size(); ++i) {
     std::unique_ptr<Window> window(new Window());
     if (ConvertSessionWindowToWindow((*windows)[i], window.get()))
-      entries->push_back(window.release());
+      entries->push_back(std::move(window));
   }
 }
 
 void PersistentTabRestoreService::Delegate::Shutdown() {
   base_session_service_->Save();
 }
 
 void PersistentTabRestoreService::Delegate::ScheduleCommandsForWindow(
     const Window& window) {
   DCHECK(!window.tabs.empty());
   int selected_tab = window.selected_tab_index;
   int valid_tab_count = 0;
   int real_selected_tab = selected_tab;
   for (size_t i = 0; i < window.tabs.size(); ++i) {
-    if (GetSelectedNavigationIndexToPersist(window.tabs[i]) != -1) {
+    if (GetSelectedNavigationIndexToPersist(*window.tabs[i]) != -1) {
       valid_tab_count++;
     } else if (static_cast<int>(i) < selected_tab) {
       real_selected_tab--;
     }
   }
   if (valid_tab_count == 0)
     return;  // No tabs to persist.
 
   base_session_service_->ScheduleCommand(CreateWindowCommand(
       window.id, std::min(real_selected_tab, valid_tab_count - 1),
       valid_tab_count, window.timestamp));
 
   if (!window.app_name.empty()) {
     base_session_service_->ScheduleCommand(CreateSetWindowAppNameCommand(
         kCommandSetWindowAppName, window.id, window.app_name));
   }
 
   for (size_t i = 0; i < window.tabs.size(); ++i) {
-    int selected_index = GetSelectedNavigationIndexToPersist(window.tabs[i]);
+    int selected_index = GetSelectedNavigationIndexToPersist(*window.tabs[i]);
     if (selected_index != -1)
-      ScheduleCommandsForTab(window.tabs[i], selected_index);
+      ScheduleCommandsForTab(*window.tabs[i], selected_index);
   }
 }
 
 void PersistentTabRestoreService::Delegate::ScheduleCommandsForTab(
     const Tab& tab,
     int selected_index) {
   const std::vector<SerializedNavigationEntry>& navigations = tab.navigations;
   int max_index = static_cast<int>(navigations.size());
 
   // Determine the first navigation we'll persist.
@@ skipping 114 matching lines @@
          !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<Entry*> entries;
+  std::vector<std::unique_ptr<TabRestoreService::Entry>> entries;
   CreateEntriesFromCommands(commands.get(), &entries);
   // Closed tabs always go to the end.
-  staging_entries_.insert(staging_entries_.end(), entries.begin(),
-                          entries.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,
-    std::vector<Entry*>* loaded_entries) {
+    std::vector<std::unique_ptr<Entry>>* loaded_entries) {
   if (tab_restore_service_helper_->entries().size() == kMaxEntries)
     return;
 
-  // Iterate through the commands populating entries and id_to_entry.
-  ScopedVector<Entry> entries;
-  IDToEntry id_to_entry;
+  // 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 = NULL;
+  Tab* current_tab = nullptr;
   // If non-null we're processing the tabs of this window.
-  Window* current_window = NULL;
+  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) {
     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 = NULL;
-        current_window = NULL;
+        current_tab = nullptr;
+        current_window = nullptr;
 
         RestoredEntryPayload payload;
         if (!command.GetPayload(&payload, sizeof(payload)))
           return;
-        RemoveEntryByID(payload, &id_to_entry, &(entries.get()));
+        RemoveEntryByID(payload, &entries);
         break;
       }
 
       case kCommandWindow: {
         WindowPayload2 payload;
         if (pending_window_tabs > 0) {
           // Should never receive a window command while waiting for all the
           // tabs in a window.
           return;
         }
@@ skipping 13 matching lines @@
           // unknown timestamp.
           payload.timestamp = 0;
         }
 
         pending_window_tabs = payload.num_tabs;
         if (pending_window_tabs <= 0) {
           // Should always have at least 1 tab. Likely indicates corruption.
           return;
         }
 
-        RemoveEntryByID(payload.window_id, &id_to_entry, &(entries.get()));
+        RemoveEntryByID(payload.window_id, &entries);
 
-        current_window = new Window();
+        entries.push_back(base::MakeUnique<Window>());
+        current_window = static_cast<Window*>(entries.back().get());
         current_window->selected_tab_index = payload.selected_tab_index;
         current_window->timestamp =
             base::Time::FromInternalValue(payload.timestamp);
-        entries.push_back(current_window);
-        id_to_entry[payload.window_id] = current_window;
         break;
       }
 
       case kCommandSelectedNavigationInTab: {
         SelectedNavigationInTabPayload2 payload;
         if (!command.GetPayload(&payload, sizeof(payload))) {
           SelectedNavigationInTabPayload old_payload;
           if (!command.GetPayload(&old_payload, sizeof(old_payload)))
             return;
           payload.id = old_payload.id;
           payload.index = old_payload.index;
           // Since we don't have a time use time 0 which is used to mark as an
           // unknown timestamp.
           payload.timestamp = 0;
         }
 
         if (pending_window_tabs > 0) {
           if (!current_window) {
             // We should have created a window already.
             NOTREACHED();
             return;
           }
-          current_window->tabs.resize(current_window->tabs.size() + 1);
-          current_tab = &(current_window->tabs.back());
+          current_window->tabs.push_back(base::MakeUnique<Tab>());
+          current_tab = current_window->tabs.back().get();
           if (--pending_window_tabs == 0)
-            current_window = NULL;
+            current_window = nullptr;
         } else {
-          RemoveEntryByID(payload.id, &id_to_entry, &(entries.get()));
-          current_tab = new Tab();
-          id_to_entry[payload.id] = current_tab;
+          RemoveEntryByID(payload.id, &entries);
+          entries.push_back(base::MakeUnique<Tab>());
+          current_tab = static_cast<Tab*>(entries.back().get());
           current_tab->timestamp =
               base::Time::FromInternalValue(payload.timestamp);
-          entries.push_back(current_tab);
         }
         current_tab->current_navigation_index = payload.index;
         break;
       }
 
       case kCommandUpdateTabNavigation: {
         if (!current_tab) {
           // Should be in a tab when we get this.
           return;
         }
@@ skipping 66 matching lines @@
         break;
       }
 
       default:
         // Unknown type, usually indicates corruption of file. Ignore it.
         return;
     }
   }
 
   // If there was corruption some of the entries won't be valid.
-  ValidateAndDeleteEmptyEntries(&(entries.get()));
+  ValidateAndDeleteEmptyEntries(&entries);
 
-  loaded_entries->swap(entries.get());
+  loaded_entries->swap(entries);
 }
 
 // static
 void PersistentTabRestoreService::Delegate::ValidateAndDeleteEmptyEntries(
-    std::vector<Entry*>* entries) {
-  std::vector<Entry*> valid_entries;
-  std::vector<Entry*> invalid_entries;
+    std::vector<std::unique_ptr<Entry>>* entries) {
+  std::vector<std::unique_ptr<Entry>> valid_entries;
 
   // Iterate from the back so that we keep the most recently closed entries.
-  for (std::vector<Entry*>::reverse_iterator i = entries->rbegin();
-       i != entries->rend(); ++i) {
-    if (TabRestoreServiceHelper::ValidateEntry(*i))
-      valid_entries.push_back(*i);
-    else
-      invalid_entries.push_back(*i);
+  for (auto i = entries->rbegin(); i != entries->rend(); ++i) {
+    if (TabRestoreServiceHelper::ValidateEntry(**i))
+      valid_entries.push_back(std::move(*i));
   }
   // NOTE: at this point the entries are ordered with newest at the front.
   entries->swap(valid_entries);
-
-  // Delete the remaining entries.
-  STLDeleteElements(&invalid_entries);
 }
 
 void PersistentTabRestoreService::Delegate::OnGotPreviousSession(
     ScopedVector<SessionWindow> windows,
     SessionID::id_type ignored_active_window) {
-  std::vector<Entry*> entries;
+  std::vector<std::unique_ptr<Entry>> entries;
   CreateEntriesFromWindows(&windows.get(), &entries);
   // Previous session tabs go first.
-  staging_entries_.insert(staging_entries_.begin(), entries.begin(),
-                          entries.end());
+  staging_entries_.insert(staging_entries_.begin(),
+                          make_move_iterator(entries.begin()),
+                          make_move_iterator(entries.end()));
   load_state_ |= LOADED_LAST_SESSION;
   LoadStateChanged();
 }
 
 bool PersistentTabRestoreService::Delegate::ConvertSessionWindowToWindow(
     SessionWindow* session_window,
     Window* window) {
   for (size_t i = 0; i < session_window->tabs.size(); ++i) {
     if (!session_window->tabs[i]->navigations.empty()) {
-      window->tabs.resize(window->tabs.size() + 1);
-      Tab& tab = window->tabs.back();
+      window->tabs.push_back(base::MakeUnique<Tab>());
+      Tab& tab = *window->tabs.back();
       tab.pinned = session_window->tabs[i]->pinned;
       tab.navigations.swap(session_window->tabs[i]->navigations);
       tab.current_navigation_index =
           session_window->tabs[i]->current_navigation_index;
       tab.extension_app_id = session_window->tabs[i]->extension_app_id;
       tab.timestamp = base::Time();
     }
   }
   if (window->tabs.empty())
     return false;
@@ skipping 28 matching lines @@
     // kMaxEntries.
     int surplus = kMaxEntries - entries.size();
     CHECK_LE(0, surplus);
     CHECK_GE(static_cast<int>(staging_entries_.size()), surplus);
     staging_entries_.erase(
         staging_entries_.begin() + (kMaxEntries - entries.size()),
         staging_entries_.end());
   }
 
   // And add them.
-  for (size_t i = 0; i < staging_entries_.size(); ++i) {
-    staging_entries_[i]->from_last_session = true;
-    tab_restore_service_helper_->AddEntry(staging_entries_[i], false, false);
+  for (auto& staging_entry : staging_entries_) {
+    staging_entry->from_last_session = true;
+    tab_restore_service_helper_->AddEntry(std::move(staging_entry), false,
+                                          false);
   }
 
-  // AddEntry takes ownership of the entry, need to clear out entries so that
-  // it doesn't delete them.
-  staging_entries_.weak_clear();
-
-  // Make it so we rewrite all the tabs. We need to do this otherwise we won't
-  // correctly write out the entries when Save is invoked (Save starts from
-  // the front, not the end and we just added the entries to the end).
-  entries_to_write_ = staging_entries_.size();
+  staging_entries_.clear();
+  entries_to_write_ = 0;
 
   tab_restore_service_helper_->PruneEntries();
   tab_restore_service_helper_->NotifyTabsChanged();
 
   tab_restore_service_helper_->NotifyLoaded();
 }
 
-void PersistentTabRestoreService::Delegate::RemoveEntryByID(
-    SessionID::id_type id,
-    IDToEntry* id_to_entry,
-    std::vector<TabRestoreService::Entry*>* entries) {
-  // Look for the entry in the map. If it is present, erase it from both
-  // collections and return.
-  IDToEntry::iterator i = id_to_entry->find(id);
-  if (i != id_to_entry->end()) {
-    entries->erase(std::find(entries->begin(), entries->end(), i->second));
-    delete i->second;
-    id_to_entry->erase(i);
-    return;
-  }
-
-  // Otherwise, loop over all items in the map and see if any of the Windows
-  // have Tabs with the |id|.
-  for (IDToEntry::iterator i = id_to_entry->begin(); i != id_to_entry->end();
-       ++i) {
-    if (i->second->type == TabRestoreService::WINDOW) {
-      TabRestoreService::Window* window =
-          static_cast<TabRestoreService::Window*>(i->second);
-      std::vector<TabRestoreService::Tab>::iterator j = window->tabs.begin();
-      for ( ; j != window->tabs.end(); ++j) {
-        // If the ID matches one of this window's tabs, remove it from the
-        // list.
-        if ((*j).id == id) {
-          window->tabs.erase(j);
-          return;
-        }
-      }
-    }
-  }
-}
-
 // PersistentTabRestoreService -------------------------------------------------
 
 PersistentTabRestoreService::PersistentTabRestoreService(
     std::unique_ptr<TabRestoreServiceClient> client,
     TimeFactory* time_factory)
     : client_(std::move(client)),
       delegate_(new Delegate(client_.get())),
       helper_(this, delegate_.get(), client_.get(), time_factory) {
   delegate_->set_tab_restore_service_helper(&helper_);
 }
@@ skipping 29 matching lines @@
 
 const TabRestoreService::Entries& PersistentTabRestoreService::entries() const {
   return helper_.entries();
 }
 
 std::vector<LiveTab*> PersistentTabRestoreService::RestoreMostRecentEntry(
     LiveTabContext* context) {
   return helper_.RestoreMostRecentEntry(context);
 }
 
-TabRestoreService::Tab* PersistentTabRestoreService::RemoveTabEntryById(
-    SessionID::id_type id) {
+std::unique_ptr<TabRestoreService::Tab>
+PersistentTabRestoreService::RemoveTabEntryById(SessionID::id_type id) {
   return helper_.RemoveTabEntryById(id);
 }
 
 std::vector<LiveTab*> PersistentTabRestoreService::RestoreEntryById(
     LiveTabContext* context,
     SessionID::id_type id,
     WindowOpenDisposition disposition) {
   return helper_.RestoreEntryById(context, id, disposition);
 }
 
@@ skipping 15 matching lines @@
 
 TabRestoreService::Entries* PersistentTabRestoreService::mutable_entries() {
   return &helper_.entries_;
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 }  // namespace sessions