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

chrome/browser/sessions/base_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/base_session_service.h"
 
+#include "base/bind.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/url_constants.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "webkit/glue/webkit_glue.h"
@@ skipping 42 matching lines @@
 
 // static
 const int BaseSessionService::max_persist_navigation_count = 6;
 
 BaseSessionService::BaseSessionService(SessionType type,
                                        Profile* profile,
                                        const FilePath& path)
     : profile_(profile),
       path_(path),
       backend_thread_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(save_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       pending_reset_(false),
       commands_since_reset_(0) {
   if (profile) {
     // We should never be created when incognito.
     DCHECK(!profile->IsOffTheRecord());
   }
   backend_ = new SessionBackend(type,
       profile_ ? profile_->GetPath() : path_);
   DCHECK(backend_.get());
   backend_thread_ = g_browser_process->file_thread();
   if (!backend_thread_)
     backend_->Init();
   // If backend_thread is non-null, backend will init itself as appropriate.
 }
 
 BaseSessionService::~BaseSessionService() {
 }
 
 void BaseSessionService::DeleteLastSession() {
   if (!backend_thread()) {
     backend()->DeleteLastSession();
   } else {
-    backend_thread()->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        backend(), &SessionBackend::DeleteLastSession));
+    backend_thread()->message_loop()->PostTask(
+        FROM_HERE, base::Bind(&SessionBackend::DeleteLastSession, backend()));
   }
 }
 
 void BaseSessionService::ScheduleCommand(SessionCommand* command) {
   DCHECK(command);
   commands_since_reset_++;
   pending_commands_.push_back(command);
   StartSaveTimer();
 }
 
 void BaseSessionService::StartSaveTimer() {
   // Don't start a timer when testing (profile == NULL or
   // MessageLoop::current() is NULL).
-  if (MessageLoop::current() && profile() && save_factory_.empty()) {
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-        save_factory_.NewRunnableMethod(&BaseSessionService::Save),
+  if (MessageLoop::current() && profile() && !weak_factory_.HasWeakPtrs()) {
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&BaseSessionService::Save, weak_factory_.GetWeakPtr()),
         kSaveDelayMS);
   }
 }
 
 void BaseSessionService::Save() {
   DCHECK(backend());
 
   if (pending_commands_.empty())
     return;
 
   if (!backend_thread()) {
     backend()->AppendCommands(
         new std::vector<SessionCommand*>(pending_commands_), pending_reset_);
   } else {
-    backend_thread()->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        backend(), &SessionBackend::AppendCommands,
-        new std::vector<SessionCommand*>(pending_commands_),
-        pending_reset_));
+    backend_thread()->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&SessionBackend::AppendCommands, backend(),
+                   new std::vector<SessionCommand*>(pending_commands_),
+                   pending_reset_));
   }
   // Backend took ownership of commands.
   pending_commands_.clear();
 
   if (pending_reset_) {
     commands_since_reset_ = 0;
     pending_reset_ = false;
   }
 }
 
@@ skipping 114 matching lines @@
   // just display a non-functional print preview page.
   return url.is_valid() && url != GURL(chrome::kChromeUIPrintURL);
 }
 
 BaseSessionService::Handle BaseSessionService::ScheduleGetLastSessionCommands(
     InternalGetCommandsRequest* request,
     CancelableRequestConsumerBase* consumer) {
   scoped_refptr<InternalGetCommandsRequest> request_wrapper(request);
   AddRequest(request, consumer);
   if (backend_thread()) {
-    backend_thread()->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        backend(), &SessionBackend::ReadLastSessionCommands, request_wrapper));
+    backend_thread()->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&SessionBackend::ReadLastSessionCommands, backend(),
+                   request_wrapper));
   } else {
     backend()->ReadLastSessionCommands(request);
   }
   return request->handle();
 }
 
 BaseSessionService::Handle
     BaseSessionService::ScheduleGetCurrentSessionCommands(
         InternalGetCommandsRequest* request,
         CancelableRequestConsumerBase* consumer) {
   scoped_refptr<InternalGetCommandsRequest> request_wrapper(request);
   AddRequest(request, consumer);
   if (backend_thread()) {
-    backend_thread()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(backend(),
-                          &SessionBackend::ReadCurrentSessionCommands,
-                          request_wrapper));
+    backend_thread()->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&SessionBackend::ReadCurrentSessionCommands, backend(),
+                   request_wrapper));
   } else {
     backend()->ReadCurrentSessionCommands(request);
   }
   return request->handle();
 }