Convert SessionService to use new CancelableTaskTracker

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/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/time.h"
 #include "chrome/browser/common/cancelable_request.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/base_session_service.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 "chrome/common/cancelable_task_tracker.h"
 #include "content/public/browser/session_storage_namespace.h"
 
 namespace {
 
 // Only written if the tab is pinned.
 typedef bool PinnedStatePayload;
 
 typedef int32 RestoredEntryPayload;
 
 typedef std::map<SessionID::id_type, TabRestoreService::Entry*> IDToEntry;
@@ skipping 135 matching lines @@
 
   // Returns the index to persist as the selected index. This is the same as
   // |tab.current_navigation_index| unless the entry at
   // |tab.current_navigation_index| shouldn't be persisted. Returns -1 if no
   // valid navigation to persist.
   int GetSelectedNavigationIndexToPersist(const Tab& tab);
 
   // Invoked when we've loaded the session commands that identify the previously
   // closed tabs. This creates entries, adds them to staging_entries_, and
   // invokes LoadState.
-  void OnGotLastSessionCommands(
-      Handle handle,
-      scoped_refptr<InternalGetCommandsRequest> request);
+  void OnGotLastSessionCommands(ScopedVector<SessionCommand> commands);
 
-  // Populates |loaded_entries| with Entries from |request|.
-  void CreateEntriesFromCommands(
-      scoped_refptr<InternalGetCommandsRequest> request,
-      std::vector<Entry*>* loaded_entries);
+  // 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
   // 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(Handle handle,
-                            std::vector<SessionWindow*>* windows,
+  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.
@@ skipping 16 matching lines @@
   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_.
   std::vector<Entry*> staging_entries_;
 
-  // Used when loading previous tabs/session.
-  CancelableRequestConsumer load_consumer_;
-
-  // Used when loading open tabs/session when recovering from a crash.
-  CancelableRequestConsumer crash_consumer_;
+  // Used when loading previous tabs/session and open tabs/session.
+  CancelableTaskTracker cancelable_task_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
 PersistentTabRestoreService::Delegate::Delegate(Profile* profile)
     : BaseSessionService(BaseSessionService::TAB_RESTORE, profile,
                          FilePath()),
       tab_restore_service_helper_(NULL),
       entries_to_write_(0),
       entries_written_(0),
@@ skipping 90 matching lines @@
       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(
-        &crash_consumer_,
-        base::Bind(&Delegate::OnGotPreviousSession, base::Unretained(this)));
+        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(
-      new InternalGetCommandsRequest(
-          base::Bind(&Delegate::OnGotLastSessionCommands,
-                     base::Unretained(this))),
-      &load_consumer_);
+      base::Bind(&Delegate::OnGotLastSessionCommands, base::Unretained(this)),
+      &cancelable_task_tracker_);
 }
 
 bool PersistentTabRestoreService::Delegate::IsLoaded() const {
   return !(load_state_ & (NOT_LOADED | LOADING));
 }
 
 // static
 void PersistentTabRestoreService::Delegate::CreateEntriesFromWindows(
     std::vector<SessionWindow*>* windows,
     std::vector<Entry*>* entries) {
@@ skipping 167 matching lines @@
   selected_index = tab.current_navigation_index + 1;
   while (selected_index < max_index &&
          !ShouldTrackEntry(navigations[selected_index].virtual_url())) {
     selected_index++;
   }
 
   return (selected_index == max_index) ? -1 : selected_index;
 }
 
 void PersistentTabRestoreService::Delegate::OnGotLastSessionCommands(
-    Handle handle,
-    scoped_refptr<InternalGetCommandsRequest> request) {
+    ScopedVector<SessionCommand> commands) {
   std::vector<Entry*> entries;
-  CreateEntriesFromCommands(request, &entries);
+  CreateEntriesFromCommands(commands.get(), &entries);
   // Closed tabs always go to the end.
   staging_entries_.insert(staging_entries_.end(), entries.begin(),
                           entries.end());
   load_state_ |= LOADED_LAST_TABS;
   LoadStateChanged();
 }
 
 void PersistentTabRestoreService::Delegate::CreateEntriesFromCommands(
-    scoped_refptr<InternalGetCommandsRequest> request,
+    const std::vector<SessionCommand*>& commands,
     std::vector<Entry*>* loaded_entries) {
-  if (request->canceled() ||
-      tab_restore_service_helper_->entries().size() == kMaxEntries)
+  if (tab_restore_service_helper_->entries().size() == kMaxEntries)
     return;
 
-  std::vector<SessionCommand*>& commands = request->commands;
   // Iterate through the commands populating entries and id_to_entry.
   ScopedVector<Entry> entries;
   IDToEntry id_to_entry;
   // If non-null we're processing the navigations of this tab.
   Tab* current_tab = NULL;
   // If non-null we're processing the tabs of this window.
   Window* current_window = NULL;
   // If > 0, we've gotten a window command but not all the tabs yet.
   int pending_window_tabs = 0;
   for (std::vector<SessionCommand*>::const_iterator i = commands.begin();
@@ skipping 191 matching lines @@
       invalid_entries.push_back(*i);
   }
   // NOTE: at this point the entries are ordered with newest at the front.
   entries->swap(valid_entries);
 
   // Delete the remaining entries.
   STLDeleteElements(&invalid_entries);
 }
 
 void PersistentTabRestoreService::Delegate::OnGotPreviousSession(
-    Handle handle,
-    std::vector<SessionWindow*>* windows,
+    ScopedVector<SessionWindow> windows,
     SessionID::id_type ignored_active_window) {
   std::vector<Entry*> entries;
-  CreateEntriesFromWindows(windows, &entries);
+  CreateEntriesFromWindows(&windows.get(), &entries);
   // Previous session tabs go first.
   staging_entries_.insert(staging_entries_.begin(), entries.begin(),
                           entries.end());
   load_state_ |= LOADED_LAST_SESSION;
   LoadStateChanged();
 }
 
 bool PersistentTabRestoreService::Delegate::ConvertSessionWindowToWindow(
     SessionWindow* session_window,
     Window* window) {
@@ skipping 188 matching lines @@
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 ProfileKeyedService* TabRestoreServiceFactory::BuildServiceInstanceFor(
     Profile* profile) const {
   return new PersistentTabRestoreService(profile, NULL);
 }