Convert SessionService to use new CancelableTaskTracker

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/file_util.h"
-#include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/threading/thread.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/sessions/session_backend.h"
 #include "chrome/browser/sessions/session_command.h"
 #include "chrome/browser/sessions/session_restore.h"
@@ skipping 49 matching lines @@
 static const SessionCommand::id_type kCommandWindowClosed = 17;
 static const SessionCommand::id_type kCommandSetTabUserAgentOverride = 18;
 static const SessionCommand::id_type kCommandSessionStorageAssociated = 19;
 static const SessionCommand::id_type kCommandSetActiveWindow = 20;
 
 // Every kWritesPerReset commands triggers recreating the file.
 static const int kWritesPerReset = 250;
 
 namespace {
 
-// The callback from GetLastSession is internally routed to SessionService
-// first and then the caller. This is done so that the SessionWindows can be
-// recreated from the SessionCommands and the SessionWindows passed to the
-// caller. The following class is used for this.
-class InternalSessionRequest
-    : public BaseSessionService::InternalGetCommandsRequest {
- public:
-  InternalSessionRequest(
-      const CallbackType& callback,
-      const SessionService::SessionCallback& real_callback)
-      : BaseSessionService::InternalGetCommandsRequest(callback),
-        real_callback(real_callback) {
-  }
-
-  // The callback supplied to GetLastSession.
-  SessionService::SessionCallback real_callback;
-
- private:
-  ~InternalSessionRequest() {}
-
-  DISALLOW_COPY_AND_ASSIGN(InternalSessionRequest);
-};
-
 // Various payload structures.
 struct ClosedPayload {
   SessionID::id_type id;
   int64 close_time;
 };
 
 struct WindowBoundsPayload2 {
   SessionID::id_type window_id;
   int32 x;
   int32 y;
@@ skipping 374 matching lines @@
     const SessionID& window_id,
     const SessionID& tab_id,
     const std::string& user_agent_override) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   ScheduleCommand(CreateSetTabUserAgentOverrideCommand(
       kCommandSetTabUserAgentOverride, tab_id.id(), user_agent_override));
 }
 
-SessionService::Handle SessionService::GetLastSession(
-    CancelableRequestConsumerBase* consumer,
-    const SessionCallback& callback) {
+CancelableTaskTracker::TaskId SessionService::GetLastSession(
+    const SessionCallback& callback,
+    CancelableTaskTracker* tracker) {
+  // OnGotSessionCommands maps the SessionCommands to browser state, then run
+  // the callback.
   return ScheduleGetLastSessionCommands(
-      new InternalSessionRequest(
-          base::Bind(&SessionService::OnGotSessionCommands,
-                     base::Unretained(this)),
-          callback),
-      consumer);
+      base::Bind(&SessionService::OnGotSessionCommands,
+                 base::Unretained(this), callback),
+      tracker);
 }
 
 void SessionService::Save() {
   bool had_commands = !pending_commands().empty();
   BaseSessionService::Save();
   if (had_commands) {
     RecordSessionUpdateHistogramData(chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
                                      &last_updated_save_time_);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
@@ skipping 324 matching lines @@
     const SessionID& window_id) {
   ActiveWindowPayload payload = 0;
   payload = window_id.id();
   SessionCommand* command =
       new SessionCommand(kCommandSetActiveWindow, sizeof(payload));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 void SessionService::OnGotSessionCommands(
-    Handle handle,
-    scoped_refptr<InternalGetCommandsRequest> request) {
-  if (request->canceled())
-    return;
-
+    const SessionCallback& callback,
+    ScopedVector<SessionCommand> commands) {
   ScopedVector<SessionWindow> valid_windows;
   SessionID::id_type active_window_id = 0;
+
   RestoreSessionFromCommands(
-      request->commands, &(valid_windows.get()), &active_window_id);
-  static_cast<InternalSessionRequest*>(request.get())->real_callback.Run(
-      request->handle(), &(valid_windows.get()), active_window_id);
+      commands.get(), &valid_windows.get(), &active_window_id);
+  callback.Run(valid_windows.Pass(), active_window_id);
 }
 
 void SessionService::RestoreSessionFromCommands(
     const std::vector<SessionCommand*>& commands,
     std::vector<SessionWindow*>* valid_windows,
     SessionID::id_type* active_window_id) {
   std::map<int, SessionTab*> tabs;
   std::map<int, SessionWindow*> windows;
 
   VLOG(1) << "RestoreSessionFromCommands " << commands.size();
@@ skipping 899 matching lines @@
       contents->GetController().GetDefaultSessionStorageNamespace();
   session_storage_namespace->SetShouldPersist(false);
   SessionTabHelper* session_tab_helper =
       SessionTabHelper::FromWebContents(contents);
   TabClosed(session_tab_helper->window_id(),
             session_tab_helper->session_id(),
             contents->GetClosedByUserGesture());
   RecordSessionUpdateHistogramData(content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                                    &last_updated_tab_closed_time_);
 }