Introduce TabRestoreServiceClient and //chrome implementation.

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>
@@ skipping 19 matching lines @@
 #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"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "components/sessions/content/content_serialized_navigation_builder.h"
+#include "components/sessions/core/session_constants.h"
 #include "components/sessions/session_command.h"
 #include "components/sessions/session_types.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/session_storage_namespace.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/extension.h"
 
@@ skipping 440 matching lines @@
                                        const SessionID& tab_id,
                                        base::TimeTicks last_active_time) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   ScheduleCommand(
       sessions::CreateLastActiveTimeCommand(tab_id, last_active_time).Pass());
 }
 
 base::CancelableTaskTracker::TaskId SessionService::GetLastSession(
-    const SessionCallback& callback,
+    const sessions::GetLastSessionCallback& callback,
     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);
 }
 
@@ skipping 177 matching lines @@
   }
 }
 
 void SessionService::OnBrowserSetLastActive(Browser* browser) {
   if (ShouldTrackBrowser(browser))
     ScheduleCommand(sessions::CreateSetActiveWindowCommand(
         browser->session_id()).Pass());
 }
 
 void SessionService::OnGotSessionCommands(
-    const SessionCallback& callback,
+    const sessions::GetLastSessionCallback& callback,
     ScopedVector<sessions::SessionCommand> commands) {
   ScopedVector<sessions::SessionWindow> valid_windows;
   SessionID::id_type active_window_id = 0;
 
   sessions::RestoreSessionFromCommands(
       commands, &valid_windows.get(), &active_window_id);
   RemoveUnusedRestoreWindows(&valid_windows.get());
 
   callback.Run(valid_windows.Pass(), active_window_id);
 }
 
 void SessionService::BuildCommandsForTab(const SessionID& window_id,
                                          WebContents* tab,
                                          int index_in_window,
                                          bool is_pinned,
                                          IdToRange* tab_to_available_range) {
   DCHECK(tab && window_id.id());
   SessionTabHelper* session_tab_helper = SessionTabHelper::FromWebContents(tab);
   const SessionID& session_id(session_tab_helper->session_id());
   base_session_service_->AppendRebuildCommand(
       sessions::CreateSetTabWindowCommand(window_id, session_id));
 
   const int current_index = tab->GetController().GetCurrentEntryIndex();
-  const int min_index = std::max(current_index - gMaxPersistNavigationCount, 0);
-  const int max_index = std::min(current_index + gMaxPersistNavigationCount,
-                                 tab->GetController().GetEntryCount());
+  const int min_index =
+      std::max(current_index - sessions::gMaxPersistNavigationCount, 0);
+  const int max_index =
+      std::min(current_index + sessions::gMaxPersistNavigationCount,
+               tab->GetController().GetEntryCount());
   const int pending_index = tab->GetController().GetPendingEntryIndex();
   if (tab_to_available_range) {
     (*tab_to_available_range)[session_id.id()] =
         std::pair<int, int>(min_index, max_index);
   }
 
   if (is_pinned) {
     base_session_service_->AppendRebuildCommand(
         sessions::CreatePinnedStateCommand(session_id, true));
   }
@@ skipping 371 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();
 }