base::Bind: Convert more of chrome/browser/sessions.

chrome/browser/sessions/session_service.cc

 // Copyright (c) 2011 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 <limits>
 #include <set>
 #include <vector>
 
+#include "base/bind.h"
+#include "base/bind_helpers.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/extension_tab_helper.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
@@ skipping 47 matching lines @@
 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(
-      CallbackType* callback,
+      const CallbackType& callback,
       SessionService::SessionCallback* real_callback)
       : BaseSessionService::InternalGetCommandsRequest(callback),
         real_callback(real_callback) {
   }
 
   // The callback supplied to GetLastSession and GetCurrentSession.
   scoped_ptr<SessionService::SessionCallback> real_callback;
 
  private:
   ~InternalSessionRequest() {}
@@ skipping 86 matching lines @@
 void SessionService::MoveCurrentSessionToLastSession() {
   pending_tab_close_ids_.clear();
   window_closing_ids_.clear();
   pending_window_close_ids_.clear();
 
   Save();
 
   if (!backend_thread()) {
     backend()->MoveCurrentSessionToLastSession();
   } else {
-    backend_thread()->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        backend(), &SessionBackend::MoveCurrentSessionToLastSession));
+    backend_thread()->message_loop()->PostTask(
+        FROM_HERE, base::Bind(&SessionBackend::MoveCurrentSessionToLastSession,
+                              backend()));
   }
 }
 
 void SessionService::SetTabWindow(const SessionID& window_id,
                                   const SessionID& tab_id) {
   if (!ShouldTrackChangesToWindow(window_id))
     return;
 
   ScheduleCommand(CreateSetTabWindowCommand(window_id, tab_id));
 }
@@ skipping 214 matching lines @@
     return;
 
   ScheduleCommand(CreateSetSelectedTabInWindow(window_id, index));
 }
 
 SessionService::Handle SessionService::GetLastSession(
     CancelableRequestConsumerBase* consumer,
     SessionCallback* callback) {
   return ScheduleGetLastSessionCommands(
       new InternalSessionRequest(
-          NewCallback(this, &SessionService::OnGotSessionCommands),
-          callback), consumer);
+          base::Bind(&SessionService::OnGotSessionCommands,
+                     base::Unretained(this)),
+          callback),
+      consumer);
 }
 
 SessionService::Handle SessionService::GetCurrentSession(
     CancelableRequestConsumerBase* consumer,
     SessionCallback* callback) {
   if (pending_window_close_ids_.empty()) {
     // If there are no pending window closes, we can get the current session
     // from memory.
     scoped_refptr<InternalSessionRequest> request(new InternalSessionRequest(
-        NewCallback(this, &SessionService::OnGotSessionCommands),
+        base::Bind(&SessionService::OnGotSessionCommands,
+                   base::Unretained(this)),
         callback));
     AddRequest(request, consumer);
     IdToRange tab_to_available_range;
     std::set<SessionID::id_type> windows_to_track;
     BuildCommandsFromBrowsers(&(request->commands),
                               &tab_to_available_range,
                               &windows_to_track);
-    request->ForwardResult(
-        BaseSessionService::InternalGetCommandsRequest::TupleType(
-            request->handle(), request));
+    request->ForwardResult(request->handle(), request);
     return request->handle();
   } else {
     // If there are pending window closes, read the current session from disk.
     return ScheduleGetCurrentSessionCommands(
         new InternalSessionRequest(
-            NewCallback(this, &SessionService::OnGotSessionCommands),
-            callback), consumer);
+            base::Bind(&SessionService::OnGotSessionCommands,
+                       base::Unretained(this)),
+            callback),
+        consumer);
   }
 }
 
 void SessionService::Save() {
   bool had_commands = !pending_commands().empty();
   BaseSessionService::Save();
   if (had_commands) {
     RecordSessionUpdateHistogramData(
         chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
         &last_updated_save_time_);
@@ skipping 1072 matching lines @@
       50);
   if (use_long_period) {
     std::string long_name_("SessionRestore.SaveLongPeriod");
     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
         delta,
         save_delay_in_mins_,
         save_delay_in_hrs_,
         50);
   }
 }