base::Bind() conversion for ProcessSingletonTest

chrome/browser/process_singleton_uitest.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.
 
 // This test validates that the ProcessSingleton class properly makes sure
 // that there is only one main browser process.
 //
 // It is currently compiled and run on Windows and Posix(non-Mac) platforms.
 // Mac uses system services and ProcessSingletonMac is a noop.  (Maybe it still
 // makes sense to test that the system services are giving the behavior we
 // want?)
 
 #include <list>
 
+#include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/scoped_temp_dir.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/test_launcher_utils.h"
 #include "chrome/test/ui/ui_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // This is for the code that is to be ran in multiple threads at once,
 // to stress a race condition on first process start.
 // We use the thread safe ref counted base class so that we can use the
-// NewRunnableMethod class to run the StartChrome methods in many threads.
+// base::Bind to run the StartChrome methods in many threads.
 class ChromeStarter : public base::RefCountedThreadSafe<ChromeStarter> {
  public:
   ChromeStarter(int timeout_ms, const FilePath& user_data_dir)
       : ready_event_(false /* manual */, false /* signaled */),
         done_event_(false /* manual */, false /* signaled */),
         process_handle_(base::kNullProcessHandle),
         process_terminated_(false),
         timeout_ms_(timeout_ms),
         user_data_dir_(user_data_dir) {
   }
@@ skipping 202 matching lines @@
     // our signal to launch its chrome process.
     for (size_t i = 0; i < kNbThreads; ++i) {
       ASSERT_NE(static_cast<ChromeStarter*>(NULL), chrome_starters_[i].get());
       chrome_starters_[i]->Reset();
 
       ASSERT_TRUE(chrome_starter_threads_[i]->IsRunning());
       ASSERT_NE(static_cast<MessageLoop*>(NULL),
                 chrome_starter_threads_[i]->message_loop());
 
       chrome_starter_threads_[i]->message_loop()->PostTask(
-          FROM_HERE, NewRunnableMethod(chrome_starters_[i].get(),
-                                       &ChromeStarter::StartChrome,
-                                       &threads_waker_,
-                                       first_run));
+          FROM_HERE, base::Bind(&ChromeStarter::StartChrome,
+                                chrome_starters_[i].get(),
+                                &threads_waker_,
+                                first_run));
     }
 
     // Wait for all the starters to be ready.
     // We could replace this loop if we ever implement a WaitAll().
     for (size_t i = 0; i < kNbThreads; ++i) {
       SCOPED_TRACE(testing::Message() << "Waiting on thread: " << i << ".");
       chrome_starters_[i]->ready_event_.Wait();
     }
     // GO!
     threads_waker_.Signal();
@@ skipping 44 matching lines @@
     pending_starters.empty();
     if (chrome_starters_[last_index]->process_handle_ !=
         base::kNullProcessHandle) {
       KillProcessTree(chrome_starters_[last_index]->process_handle_);
       chrome_starters_[last_index]->done_event_.Wait();
     }
   }
 }
 
 }  // namespace