Eliminate BaseSessionServiceDelegateImpl

chrome/browser/sessions/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 "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/sessions/base_session_service_delegate_impl.h"
 #include "components/sessions/base_session_service.h"
 #include "components/sessions/base_session_service_commands.h"
+#include "components/sessions/base_session_service_delegate.h"
 #include "components/sessions/core/session_constants.h"
 #include "components/sessions/session_command.h"
 #include "content/public/browser/session_storage_namespace.h"
 
 namespace {
 
 // Only written if the tab is pinned.
 typedef bool PinnedStatePayload;
 
 typedef int32 RestoredEntryPayload;
@@ skipping 72 matching lines @@
 // everything.
 const int kEntriesPerReset = 40;
 
 const size_t kMaxEntries = TabRestoreServiceHelper::kMaxEntries;
 
 }  // namespace
 
 // PersistentTabRestoreService::Delegate ---------------------------------------
 
 // This restore service will create and own a BaseSessionService and implement
-// the required BaseSessionServiceDelegateImpl.
+// the required sessions::BaseSessionServiceDelegate.
 class PersistentTabRestoreService::Delegate
-    : public BaseSessionServiceDelegateImpl,
+    : public sessions::BaseSessionServiceDelegate,
       public TabRestoreServiceHelper::Observer {
  public:
   explicit Delegate(sessions::TabRestoreServiceClient* client);
 
   ~Delegate() override;
 
-  // BaseSessionServiceDelegateImpl:
+  // sessions::BaseSessionServiceDelegate:
+  base::SequencedWorkerPool* GetBlockingPool() override;
+  bool ShouldUseDelayedSave() override;
   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) {
@@ skipping 78 matching lines @@
   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<sessions::BaseSessionService> base_session_service_;
-
   // The associated client.
   sessions::TabRestoreServiceClient* client_;
 
+  scoped_ptr<sessions::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_;
 
   // Used when loading previous tabs/session and open tabs/session.
   base::CancelableTaskTracker cancelable_task_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
 PersistentTabRestoreService::Delegate::Delegate(
     sessions::TabRestoreServiceClient* client)
-    : BaseSessionServiceDelegateImpl(true),
+    : client_(client),
       base_session_service_(new sessions::BaseSessionService(
           sessions::BaseSessionService::TAB_RESTORE,
-          client->GetPathToSaveTo(),
+          client_->GetPathToSaveTo(),
           this)),
-      client_(client),
       tab_restore_service_helper_(NULL),
       entries_to_write_(0),
       entries_written_(0),
       load_state_(NOT_LOADED) {}
 
 PersistentTabRestoreService::Delegate::~Delegate() {}
 
+base::SequencedWorkerPool*
+PersistentTabRestoreService::Delegate::GetBlockingPool() {
+  return client_->GetBlockingPool();
+}
+
+bool PersistentTabRestoreService::Delegate::ShouldUseDelayedSave() {
+  return true;
+}
+
 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();
     base_session_service_->set_pending_reset(true);
   }
   if (to_write_count) {
@@ skipping 152 matching lines @@
       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 < sessions::gMaxPersistNavigationCount;
        --i) {
-    if (ShouldTrackEntry(navigations[i].virtual_url())) {
+    if (client_->ShouldTrackEntry(navigations[i].virtual_url())) {
       first_index_to_persist = i;
       valid_count_before_selected++;
     }
   }
 
   // Write the command that identifies the selected tab.
   base_session_service_->ScheduleCommand(
       CreateSelectedNavigationInTabCommand(tab.id,
                                            valid_count_before_selected,
                                            tab.timestamp).Pass());
@@ skipping 19 matching lines @@
         sessions::CreateSetTabUserAgentOverrideCommand(
             kCommandSetTabUserAgentOverride,
             tab.id,
             tab.user_agent_override).Pass());
   }
 
   // Then write the navigations.
   for (int i = first_index_to_persist, wrote_count = 0;
        wrote_count < 2 * sessions::gMaxPersistNavigationCount && i < max_index;
        ++i) {
-    if (ShouldTrackEntry(navigations[i].virtual_url())) {
+    if (client_->ShouldTrackEntry(navigations[i].virtual_url())) {
       base_session_service_->ScheduleCommand(
           CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation,
                                            tab.id,
                                            navigations[i]));
     }
   }
 }
 
 // static
 scoped_ptr<sessions::SessionCommand>
@@ skipping 46 matching lines @@
 }
 
 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());
 
   // Find the first navigation to persist. We won't persist the selected
-  // navigation if ShouldTrackEntry returns false.
-  while (selected_index >= 0 &&
-         !ShouldTrackEntry(navigations[selected_index].virtual_url())) {
+  // navigation if client_->ShouldTrackEntry returns false.
+  while (
+      selected_index >= 0 &&
+      !client_->ShouldTrackEntry(navigations[selected_index].virtual_url())) {
     selected_index--;
   }
 
   if (selected_index != -1)
     return selected_index;
 
   // Couldn't find a navigation to persist going back, go forward.
   selected_index = tab.current_navigation_index + 1;
-  while (selected_index < max_index &&
-         !ShouldTrackEntry(navigations[selected_index].virtual_url())) {
+  while (
+      selected_index < max_index &&
+      !client_->ShouldTrackEntry(navigations[selected_index].virtual_url())) {
     selected_index++;
   }
 
   return (selected_index == max_index) ? -1 : selected_index;
 }
 
 void PersistentTabRestoreService::Delegate::OnGotLastSessionCommands(
     ScopedVector<sessions::SessionCommand> commands) {
   std::vector<Entry*> entries;
   CreateEntriesFromCommands(commands.get(), &entries);
@@ skipping 429 matching lines @@
   delegate_->LoadTabsFromLastSession();
 }
 
 TabRestoreService::Entries* PersistentTabRestoreService::mutable_entries() {
   return &helper_.entries_;
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }