Eliminate BaseSessionServiceDelegateImpl

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>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/background/background_mode_manager.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/browser/sessions/base_session_service_delegate_impl.h"
+#include "chrome/browser/sessions/session_common_utils.h"
 #include "chrome/browser/sessions/session_data_deleter.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/session_service_utils.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.h"
@@ skipping 19 matching lines @@
 using content::WebContents;
 using sessions::ContentSerializedNavigationBuilder;
 using sessions::SerializedNavigationEntry;
 
 // Every kWritesPerReset commands triggers recreating the file.
 static const int kWritesPerReset = 250;
 
 // SessionService -------------------------------------------------------------
 
 SessionService::SessionService(Profile* profile)
-    : BaseSessionServiceDelegateImpl(true),
-      profile_(profile),
-      base_session_service_(
-        new sessions::BaseSessionService(
-            sessions::BaseSessionService::SESSION_RESTORE,
-            profile->GetPath(),
-            this)),
+    : profile_(profile),
+      should_use_delayed_save_(true),
+      base_session_service_(new sessions::BaseSessionService(
+          sessions::BaseSessionService::SESSION_RESTORE,
+          profile->GetPath(),
+          this)),
       has_open_trackable_browsers_(false),
       move_on_new_browser_(false),
       save_delay_in_millis_(base::TimeDelta::FromMilliseconds(2500)),
       save_delay_in_mins_(base::TimeDelta::FromMinutes(10)),
       save_delay_in_hrs_(base::TimeDelta::FromHours(8)),
       force_browser_not_alive_with_no_windows_(false),
       weak_factory_(this) {
   // We should never be created when incognito.
   DCHECK(!profile->IsOffTheRecord());
   Init();
 }
 
 SessionService::SessionService(const base::FilePath& save_path)
-    : BaseSessionServiceDelegateImpl(false),
-      profile_(NULL),
-      base_session_service_(
-        new sessions::BaseSessionService(
-            sessions::BaseSessionService::SESSION_RESTORE,
-            save_path,
-            this)),
+    : profile_(NULL),
+      should_use_delayed_save_(false),
+      base_session_service_(new sessions::BaseSessionService(
+          sessions::BaseSessionService::SESSION_RESTORE,
+          save_path,
+          this)),
       has_open_trackable_browsers_(false),
       move_on_new_browser_(false),
       save_delay_in_millis_(base::TimeDelta::FromMilliseconds(2500)),
       save_delay_in_mins_(base::TimeDelta::FromMinutes(10)),
       save_delay_in_hrs_(base::TimeDelta::FromHours(8)),
       force_browser_not_alive_with_no_windows_(false),
       weak_factory_(this) {
   Init();
 }
 
@@ skipping 302 matching lines @@
   }
 
   ScheduleCommand(sessions::CreateTabNavigationPathPrunedFromFrontCommand(
                       tab_id, count).Pass());
 }
 
 void SessionService::UpdateTabNavigation(
     const SessionID& window_id,
     const SessionID& tab_id,
     const SerializedNavigationEntry& navigation) {
-  if (!ShouldTrackEntry(navigation.virtual_url()) ||
+  if (!ShouldTrackURLForRestore(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);
   }
@@ skipping 75 matching lines @@
     base::CancelableTaskTracker* tracker) {
   // OnGotSessionCommands maps the SessionCommands to browser state, then run
   // the callback.
   return base_session_service_->ScheduleGetLastSessionCommands(
       base::Bind(&SessionService::OnGotSessionCommands,
                  weak_factory_.GetWeakPtr(),
                  callback),
       tracker);
 }
 
+base::SequencedWorkerPool* SessionService::GetBlockingPool() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  return content::BrowserThread::GetBlockingPool();
+}
+
+bool SessionService::ShouldUseDelayedSave() {
+  return should_use_delayed_save_;
+}
+
 void SessionService::OnSavedCommands() {
   RecordSessionUpdateHistogramData(chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
                                    &last_updated_save_time_);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
       content::Source<Profile>(profile()),
       content::NotificationService::NoDetails());
 }
 
 void SessionService::Init() {
@@ skipping 235 matching lines @@
     base_session_service_->AppendRebuildCommand(
         sessions::CreateSetTabUserAgentOverrideCommand(session_id,
                                                        ua_override));
   }
 
   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())) {
+    if (ShouldTrackURLForRestore(entry->GetVirtualURL())) {
       const SerializedNavigationEntry navigation =
           ContentSerializedNavigationBuilder::FromNavigationEntry(i, *entry);
       base_session_service_->AppendRebuildCommand(
           CreateUpdateTabNavigationCommand(session_id, navigation));
     }
   }
   base_session_service_->AppendRebuildCommand(
       sessions::CreateSetSelectedNavigationIndexCommand(session_id,
                                                         current_index));
 
@@ skipping 331 matching lines @@
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     if ((*it)->profile() == profile())
       return;
   }
   DeleteSessionOnlyData(profile());
 }
 
 sessions::BaseSessionService* SessionService::GetBaseSessionServiceForTest() {
   return base_session_service_.get();
 }