Changing SessionService to have a BaseSessionService, not being one.

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"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/logging.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 "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/base_session_service.h"
 #include "chrome/browser/sessions/base_session_service_commands.h"
 #include "chrome/browser/sessions/base_session_service_delegate_impl.h"
 #include "chrome/browser/sessions/session_command.h"
-#include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "content/public/browser/session_storage_namespace.h"
 
 namespace {
 
 // Only written if the tab is pinned.
 typedef bool PinnedStatePayload;
 
 typedef int32 RestoredEntryPayload;
@@ skipping 71 matching lines @@
 // Number of entries (not commands) before we clobber the file and write
 // everything.
 const int kEntriesPerReset = 40;
 
 const size_t kMaxEntries = TabRestoreServiceHelper::kMaxEntries;
 
 }  // namespace
 
 // PersistentTabRestoreService::Delegate ---------------------------------------
 
-// Implements the link between the tab restore service and the session backend.
+// This restore service will create and own a BaseSessionService and implement
+// the required BaseSessionServiceDelegateImpl.
 class PersistentTabRestoreService::Delegate
-    : public BaseSessionService,
+    : public BaseSessionServiceDelegateImpl,
       public TabRestoreServiceHelper::Observer {
  public:
   explicit Delegate(Profile* profile);
 
   ~Delegate() override;
 
-  // BaseSessionService:
-  void Save() override;
+  // BaseSessionServiceDelegateImpl:
+  void OnWillSaveCommands() override;
 
   // TabRestoreServiceHelper::Observer:
   void OnClearEntries() override;
   void OnRestoreEntryById(SessionID::id_type id,
                           Entries::const_iterator entry_iterator) override;
   void OnAddEntry() override;
 
   void set_tab_restore_service_helper(
       TabRestoreServiceHelper* tab_restore_service_helper) {
     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);
 
   void Shutdown();
 
   // Schedules the commands for a window close.
   void ScheduleCommandsForWindow(const Window& window);
@@ skipping 30 matching lines @@
   void OnGotLastSessionCommands(ScopedVector<SessionCommand> commands);
 
   // Populates |loaded_entries| with Entries from |commands|.
   void CreateEntriesFromCommands(const std::vector<SessionCommand*>& commands,
                                  std::vector<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);
 
-  // Callback from SessionService when we've received the windows from the
+  // 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:
+  scoped_ptr<BaseSessionService> base_session_service_;
+
   // The associated profile.
   Profile* profile_;
 
   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_;
 
   // Used when loading previous tabs/session and open tabs/session.
   base::CancelableTaskTracker cancelable_task_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
 PersistentTabRestoreService::Delegate::Delegate(Profile* profile)
-    : BaseSessionService(
-        BaseSessionService::TAB_RESTORE,
-        profile->GetPath(),
-        scoped_ptr<BaseSessionServiceDelegate>(
-          new BaseSessionServiceDelegateImpl(true))),
+    : BaseSessionServiceDelegateImpl(true),
+      base_session_service_(
+          new BaseSessionService(BaseSessionService::TAB_RESTORE,
+                                 profile->GetPath(),
+                                 this)),
       profile_(profile),
       tab_restore_service_helper_(NULL),
       entries_to_write_(0),
       entries_written_(0),
       load_state_(NOT_LOADED) {
   // We should never be created when incognito.
   DCHECK(!profile->IsOffTheRecord());
 }
 
 PersistentTabRestoreService::Delegate::~Delegate() {}
 
-void PersistentTabRestoreService::Delegate::Save() {
+void PersistentTabRestoreService::Delegate::OnWillSaveCommands() {
   const Entries& entries = tab_restore_service_helper_->entries();
   int to_write_count = std::min(entries_to_write_,
                                 static_cast<int>(entries.size()));
   entries_to_write_ = 0;
   if (entries_written_ + to_write_count > kEntriesPerReset) {
     to_write_count = entries.size();
-    set_pending_reset(true);
+    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));
       }
       entries_written_++;
     }
   }
-  if (pending_reset())
+  if (base_session_service_->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).Pass());
+    base_session_service_->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);
+  base_session_service_->set_pending_reset(true);
 
   // Schedule a command, otherwise if there are no pending commands Save does
   // nothing.
-  ScheduleCommand(CreateRestoredEntryCommand(1).Pass());
+  base_session_service_->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).Pass());
+  base_session_service_->ScheduleCommand(CreateRestoredEntryCommand(id).Pass());
 }
 
 void PersistentTabRestoreService::Delegate::OnAddEntry() {
   // Start the save timer, when it fires we'll generate the commands.
-  StartSaveTimer();
+  base_session_service_->StartSaveTimer();
   entries_to_write_++;
 }
 
 void PersistentTabRestoreService::Delegate::LoadTabsFromLastSession() {
   if (load_state_ != NOT_LOADED)
     return;
 
   if (tab_restore_service_helper_->entries().size() == kMaxEntries) {
     // We already have the max number of entries we can take. There is no point
     // in attempting to load since we'll just drop the results. Skip to loaded.
@@ skipping 23 matching lines @@
         base::Bind(&Delegate::OnGotPreviousSession, base::Unretained(this)),
         &cancelable_task_tracker_);
   } else {
     load_state_ |= LOADED_LAST_SESSION;
   }
 #endif
 
   // Request the tabs closed in the last session. If the last session crashed,
   // this won't contain the tabs/window that were open at the point of the
   // crash (the call to GetLastSession above requests those).
-  ScheduleGetLastSessionCommands(
+  base_session_service_->ScheduleGetLastSessionCommands(
       base::Bind(&Delegate::OnGotLastSessionCommands, base::Unretained(this)),
       &cancelable_task_tracker_);
 }
 
+void PersistentTabRestoreService::Delegate::DeleteLastSession() {
+  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) {
   for (size_t i = 0; i < windows->size(); ++i) {
     scoped_ptr<Window> window(new Window());
     if (ConvertSessionWindowToWindow((*windows)[i], window.get()))
       entries->push_back(window.release());
   }
 }
 
 void PersistentTabRestoreService::Delegate::Shutdown() {
-  if (backend())
-    Save();
+  base_session_service_->SaveNow();
 }
 
 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) {
       valid_tab_count++;
     } else if (static_cast<int>(i) < selected_tab) {
       real_selected_tab--;
     }
   }
   if (valid_tab_count == 0)
     return;  // No tabs to persist.
 
-  ScheduleCommand(
+  base_session_service_->ScheduleCommand(
       CreateWindowCommand(window.id,
                           std::min(real_selected_tab, valid_tab_count - 1),
                           valid_tab_count,
                           window.timestamp).Pass());
 
   if (!window.app_name.empty()) {
-    ScheduleCommand(CreateSetWindowAppNameCommand(kCommandSetWindowAppName,
-                                                    window.id,
-                                                    window.app_name).Pass());
+    base_session_service_->ScheduleCommand(
+        CreateSetWindowAppNameCommand(kCommandSetWindowAppName,
+                                      window.id,
+                                      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(
     const Tab& tab,
     int selected_index) {
   const std::vector<sessions::SerializedNavigationEntry>& navigations =
       tab.navigations;
   int max_index = static_cast<int>(navigations.size());
 
   // Determine the first navigation we'll persist.
   int valid_count_before_selected = 0;
   int first_index_to_persist = selected_index;
   for (int i = selected_index - 1; i >= 0 &&
-       valid_count_before_selected < max_persist_navigation_count; --i) {
+       valid_count_before_selected <
+           BaseSessionService::max_persist_navigation_count; --i) {
     if (ShouldTrackEntry(navigations[i].virtual_url())) {
       first_index_to_persist = i;
       valid_count_before_selected++;
     }
   }
 
   // Write the command that identifies the selected tab.
-  ScheduleCommand(
+  base_session_service_->ScheduleCommand(
       CreateSelectedNavigationInTabCommand(tab.id,
                                            valid_count_before_selected,
                                            tab.timestamp).Pass());
 
   if (tab.pinned) {
     PinnedStatePayload payload = true;
     scoped_ptr<SessionCommand> command(
         new SessionCommand(kCommandPinnedState, sizeof(payload)));
     memcpy(command->contents(), &payload, sizeof(payload));
-    ScheduleCommand(command.Pass());
+    base_session_service_->ScheduleCommand(command.Pass());
   }
 
   if (!tab.extension_app_id.empty()) {
-    ScheduleCommand(CreateSetTabExtensionAppIDCommand(
-                          kCommandSetExtensionAppID,
-                          tab.id,
-                          tab.extension_app_id).Pass());
+    base_session_service_->ScheduleCommand(
+        CreateSetTabExtensionAppIDCommand(kCommandSetExtensionAppID,
+                                          tab.id,
+                                          tab.extension_app_id).Pass());
   }
 
   if (!tab.user_agent_override.empty()) {
-    ScheduleCommand(CreateSetTabUserAgentOverrideCommand(
-                          kCommandSetTabUserAgentOverride,
-                          tab.id,
-                          tab.user_agent_override).Pass());
+    base_session_service_->ScheduleCommand(
+        CreateSetTabUserAgentOverrideCommand(kCommandSetTabUserAgentOverride,
+                                             tab.id,
+                                             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) {
+       wrote_count < 2 * BaseSessionService::max_persist_navigation_count &&
+       i < max_index; ++i) {
     if (ShouldTrackEntry(navigations[i].virtual_url())) {
-      ScheduleCommand(CreateUpdateTabNavigationCommand(
-                            kCommandUpdateTabNavigation,
-                            tab.id,
-                            navigations[i]));
+      base_session_service_->ScheduleCommand(
+          CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation,
+                                           tab.id,
+                                           navigations[i]));
     }
   }
 }
 
 // static
 scoped_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateWindowCommand(
     SessionID::id_type id,
     int selected_tab_index,
     int num_tabs,
@@ skipping 506 matching lines @@
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 KeyedService* TabRestoreServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* profile) const {
   return new PersistentTabRestoreService(static_cast<Profile*>(profile), NULL);
 }