Introduce TabRestoreServiceClient and //chrome implementation.

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/profiles/profile.h"
 #include "chrome/browser/sessions/base_session_service_delegate_impl.h"
-#include "chrome/browser/sessions/session_service_factory.h"
-#include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "components/sessions/base_session_service.h"
 #include "components/sessions/base_session_service_commands.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;
 
@@ skipping 78 matching lines @@
 }  // namespace
 
 // PersistentTabRestoreService::Delegate ---------------------------------------
 
 // This restore service will create and own a BaseSessionService and implement
 // the required BaseSessionServiceDelegateImpl.
 class PersistentTabRestoreService::Delegate
     : public BaseSessionServiceDelegateImpl,
       public TabRestoreServiceHelper::Observer {
  public:
-  explicit Delegate(Profile* profile);
+  explicit Delegate(Profile* profile,

[sky, 2015/09/08 23:44:59]

nit: remove explicit.

[blundell, 2015/09/09 10:27:10]

Done.

+                    sessions::TabRestoreServiceClient* client);
 
   ~Delegate() override;
 
   // BaseSessionServiceDelegateImpl:
   void OnWillSaveCommands() override;
 
   // TabRestoreServiceHelper::Observer:
   void OnClearEntries() override;
   void OnRestoreEntryById(SessionID::id_type id,
                           Entries::const_iterator entry_iterator) override;
@@ skipping 87 matching lines @@
   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 profile.
   Profile* profile_;
 
+  // The associated client.
+  sessions::TabRestoreServiceClient* client_;
+
   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)
+PersistentTabRestoreService::Delegate::Delegate(
+    Profile* profile,
+    sessions::TabRestoreServiceClient* client)
     : BaseSessionServiceDelegateImpl(true),
-      base_session_service_(
-          new sessions::BaseSessionService(
-              sessions::BaseSessionService::TAB_RESTORE,
-              profile->GetPath(),
-              this)),
+      base_session_service_(new sessions::BaseSessionService(
+          sessions::BaseSessionService::TAB_RESTORE,
+          profile->GetPath(),
+          this)),
       profile_(profile),
+      client_(client),
       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() {}
 
@@ skipping 72 matching lines @@
     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.
     load_state_ = (LOADING | LOADED_LAST_SESSION | LOADED_LAST_TABS);
     LoadStateChanged();
     return;
   }
 
-#if !defined(ENABLE_SESSION_SERVICE)
-  // If sessions are not stored in the SessionService, default to
-  // |LOADED_LAST_SESSION| state.
-  load_state_ = LOADING | LOADED_LAST_SESSION;
-#else
   load_state_ = LOADING;
-
-  SessionService* session_service =
-      SessionServiceFactory::GetForProfile(profile_);
-  Profile::ExitType exit_type = profile_->GetLastSessionExitType();
-  if (!profile_->restored_last_session() && session_service &&
-      (exit_type == Profile::EXIT_CRASHED ||
-       exit_type == Profile::EXIT_SESSION_ENDED)) {
-    // The previous session crashed and wasn't restored, or was a forced
-    // shutdown. Both of which won't have notified us of the browser close so
-    // that we need to load the windows from session service (which will have
-    // saved them).
-    session_service->GetLastSession(
+  if (client_->HasLastSession()) {
+    client_->GetLastSession(
         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).
   base_session_service_->ScheduleGetLastSessionCommands(
       base::Bind(&Delegate::OnGotLastSessionCommands, base::Unretained(this)),
       &cancelable_task_tracker_);
 }
 
 void PersistentTabRestoreService::Delegate::DeleteLastSession() {
@@ skipping 58 matching lines @@
 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 < gMaxPersistNavigationCount; --i) {
+  for (int i = selected_index - 1;
+       i >= 0 &&
+       valid_count_before_selected < client_->GetMaxPersistNavigationCount();
+       --i) {
     if (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,
@@ skipping 18 matching lines @@
   if (!tab.user_agent_override.empty()) {
     base_session_service_->ScheduleCommand(
         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 * gMaxPersistNavigationCount && i < max_index; ++i) {
+       wrote_count < 2 * client_->GetMaxPersistNavigationCount() &&
+       i < max_index;
+       ++i) {
     if (ShouldTrackEntry(navigations[i].virtual_url())) {
       base_session_service_->ScheduleCommand(
           CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation,
                                            tab.id,
                                            navigations[i]));
     }
   }
 }
 
 // static
@@ skipping 421 matching lines @@
         }
       }
     }
   }
 }
 
 // PersistentTabRestoreService -------------------------------------------------
 
 PersistentTabRestoreService::PersistentTabRestoreService(
     Profile* profile,
+    scoped_ptr<sessions::TabRestoreServiceClient> client,
     TimeFactory* time_factory)
-    : delegate_(new Delegate(profile)),
+    : client_(client.Pass()),
+      delegate_(new Delegate(profile, client_.get())),
       helper_(this, delegate_.get(), profile, time_factory) {
   delegate_->set_tab_restore_service_helper(&helper_);
 }
 
 PersistentTabRestoreService::~PersistentTabRestoreService() {}
 
 void PersistentTabRestoreService::AddObserver(
     TabRestoreServiceObserver* observer) {
   helper_.AddObserver(observer);
 }
@@ skipping 64 matching lines @@
   delegate_->LoadTabsFromLastSession();
 }
 
 TabRestoreService::Entries* PersistentTabRestoreService::mutable_entries() {
   return &helper_.entries_;
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
-
-KeyedService* TabRestoreServiceFactory::BuildServiceInstanceFor(
-    content::BrowserContext* profile) const {
-  return new PersistentTabRestoreService(static_cast<Profile*>(profile), NULL);
-}