Convert SessionService to use new CancelableTaskTracker

chrome/browser/sessions/base_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/base_session_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/pickle.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_backend.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/common/referrer.h"
 #include "webkit/glue/webkit_glue.h"
 
 using content::BrowserThread;
 using content::NavigationEntry;
 
-// InternalGetCommandsRequest -------------------------------------------------
-
-BaseSessionService::InternalGetCommandsRequest::InternalGetCommandsRequest(
-    const CallbackType& callback)
-    : CancelableRequest<InternalGetCommandsCallback>(callback) {
-}
-
-BaseSessionService::InternalGetCommandsRequest::~InternalGetCommandsRequest() {
-  STLDeleteElements(&commands);
-}
-
 // BaseSessionService ---------------------------------------------------------
 
 namespace {
 
 // Helper used by CreateUpdateTabNavigationCommand(). It writes |str| to
 // |pickle|, if and only if |str| fits within (|max_bytes| - |*bytes_written|).
 // |bytes_written| is incremented to reflect the data written.
 void WriteStringToPickle(Pickle& pickle, int* bytes_written, int max_bytes,
                          const std::string& str) {
   int num_bytes = str.size() * sizeof(char);
   if (*bytes_written + num_bytes < max_bytes) {
     *bytes_written += num_bytes;
     pickle.WriteString(str);
   } else {
     pickle.WriteString(std::string());
   }
 }
 
+// Helper used by ScheduleGetLastSessionCommands. It runs callback on TaskRunner
+// thread if it's not canceled.
+void RunIfNotCanceled(
+    const CancelableTaskTracker::IsCanceledCallback& is_canceled,
+    base::TaskRunner* task_runner,
+    const BaseSessionService::InternalGetCommandsCallback& callback,
+    ScopedVector<SessionCommand> commands) {
+  if (is_canceled.Run())
+    return;
+
+  if (task_runner->RunsTasksOnCurrentThread()) {
+    callback.Run(commands.Pass());
+  } else {
+    task_runner->PostTask(FROM_HERE,
+                          base::Bind(callback, base::Passed(&commands)));
+  }
+}
+
 }  // namespace
 
 // Delay between when a command is received, and when we save it to the
 // backend.
 static const int kSaveDelayMS = 2500;
 
 // static
 const int BaseSessionService::max_persist_navigation_count = 6;
 
 BaseSessionService::BaseSessionService(SessionType type,
@@ skipping 188 matching lines @@
 
   PickleIterator iterator(*pickle);
   return pickle->ReadInt(&iterator, window_id) &&
       pickle->ReadString(&iterator, app_name);
 }
 
 bool BaseSessionService::ShouldTrackEntry(const GURL& url) {
   return url.is_valid();
 }
 
-BaseSessionService::Handle BaseSessionService::ScheduleGetLastSessionCommands(
-    InternalGetCommandsRequest* request,
-    CancelableRequestConsumerBase* consumer) {
-  scoped_refptr<InternalGetCommandsRequest> request_wrapper(request);
-  AddRequest(request, consumer);
+CancelableTaskTracker::TaskId
+    BaseSessionService::ScheduleGetLastSessionCommands(
+    const InternalGetCommandsCallback& callback,
+    CancelableTaskTracker* tracker) {
+  CancelableTaskTracker::IsCanceledCallback is_canceled;
+  CancelableTaskTracker::TaskId id = tracker->NewTrackedTaskId(&is_canceled);
+
+  InternalGetCommandsCallback callback_runner =
+      base::Bind(&RunIfNotCanceled,
+                 is_canceled, base::MessageLoopProxy::current(), callback);
+
   RunTaskOnBackendThread(
       FROM_HERE,
       base::Bind(&SessionBackend::ReadLastSessionCommands, backend(),
-                 request_wrapper));
-  return request->handle();
+                 is_canceled, callback_runner));
+  return id;
 }
 
 bool BaseSessionService::RunTaskOnBackendThread(
     const tracked_objects::Location& from_here,
     const base::Closure& task) {
   if (profile_ && BrowserThread::IsMessageLoopValid(BrowserThread::FILE)) {
     return BrowserThread::PostTask(BrowserThread::FILE, from_here, task);
   } else {
     // Fall back to executing on the main thread if the file thread
     // has gone away (around shutdown time) or if we're running as
     // part of a unit test that does not set profile_.
     task.Run();
     return true;
   }
 }
 
 bool BaseSessionService::RunningInProduction() const {
   return profile_ && BrowserThread::IsMessageLoopValid(BrowserThread::FILE);
 }