base::Bind: Finish conversion in ServiceProcessControl.

chrome/browser/service/service_process_control.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/service/service_process_control.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/process_util.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/upgrade_detector.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 120 matching lines @@
     cmd_line->AppendSwitch(switches::kWaitForDebugger);
 
   if (browser_command_line.HasSwitch(switches::kEnableLogging))
     cmd_line->AppendSwitch(switches::kEnableLogging);
 
   std::string locale = g_browser_process->GetApplicationLocale();
   cmd_line->AppendSwitchASCII(switches::kLang, locale);
 
   // And then start the process asynchronously.
   launcher_ = new Launcher(this, cmd_line);
-  launcher_->Run(
-      NewRunnableMethod(this, &ServiceProcessControl::OnProcessLaunched));
+  launcher_->Run(base::Bind(&ServiceProcessControl::OnProcessLaunched,
+                            base::Unretained(this)));
 }
 
 void ServiceProcessControl::Disconnect() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   channel_.reset();
 }
 
 void ServiceProcessControl::OnProcessLaunched() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (launcher_->launched()) {
@@ skipping 94 matching lines @@
                                           CommandLine* cmd_line)
     : process_(process),
       cmd_line_(cmd_line),
       launched_(false),
       retry_count_(0) {
 }
 
 // Execute the command line to start the process asynchronously.
 // After the command is executed, |task| is called with the process handle on
 // the UI thread.
-void ServiceProcessControl::Launcher::Run(Task* task) {
+void ServiceProcessControl::Launcher::Run(const base::Closure& task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  notify_task_.reset(task);
+  notify_task_ = task;
   BrowserThread::PostTask(BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
-                         NewRunnableMethod(this, &Launcher::DoRun));
+                          base::Bind(&Launcher::DoRun, this));
 }
 
 ServiceProcessControl::Launcher::~Launcher() {}
 
 void ServiceProcessControl::Launcher::Notify() {
-  DCHECK(notify_task_.get());
-  notify_task_->Run();
-  notify_task_.reset();
+  DCHECK_EQ(false, notify_task_.is_null());
+  notify_task_.Run();
+  notify_task_.Reset();
 }
 
 #if !defined(OS_MACOSX)
 void ServiceProcessControl::Launcher::DoDetectLaunched() {
-  DCHECK(notify_task_.get());
+  DCHECK_EQ(false, notify_task_.is_null());
+
   const uint32 kMaxLaunchDetectRetries = 10;
   launched_ = CheckServiceProcessReady();
   if (launched_ || (retry_count_ >= kMaxLaunchDetectRetries)) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        NewRunnableMethod(this, &Launcher::Notify));
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE, base::Bind(&Launcher::Notify, this));
     return;
   }
   retry_count_++;
 
   // If the service process is not launched yet then check again in 2 seconds.
   const int kDetectLaunchRetry = 2000;
   MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      NewRunnableMethod(this, &Launcher::DoDetectLaunched),
+      FROM_HERE, base::Bind(&Launcher::DoDetectLaunched, this),
       kDetectLaunchRetry);
 }
 
 void ServiceProcessControl::Launcher::DoRun() {
-  DCHECK(notify_task_.get());
+  DCHECK_EQ(false, notify_task_.is_null());
+
   base::LaunchOptions options;
 #if defined(OS_WIN)
   options.start_hidden = true;
 #endif
   if (base::LaunchProcess(*cmd_line_, options, NULL)) {
-    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                            NewRunnableMethod(this,
-                                              &Launcher::DoDetectLaunched));
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&Launcher::DoDetectLaunched, this));
   } else {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            NewRunnableMethod(this, &Launcher::Notify));
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE, base::Bind(&Launcher::Notify, this));
   }
 }
 #endif  // !OS_MACOSX