NewRunnable* conversion to base::Bind for service process utils.

chrome/common/service_process_util_unittest.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/common/service_process_util.h"
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/process_util.h"
 
 #if !defined(OS_MACOSX)
 #include "base/at_exit.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
@@ skipping 85 matching lines @@
 TEST_F(ServiceProcessStateTest, Singleton) {
   ServiceProcessState state;
   ASSERT_TRUE(state.Initialize());
   LaunchAndWait("ServiceProcessStateTestSingleton");
 }
 
 TEST_F(ServiceProcessStateTest, ReadyState) {
   ASSERT_FALSE(CheckServiceProcessReady());
   ServiceProcessState state;
   ASSERT_TRUE(state.Initialize());
-  ASSERT_TRUE(state.SignalReady(IOMessageLoopProxy(), NULL));
+  ASSERT_TRUE(state.SignalReady(IOMessageLoopProxy(), base::Closure()));
   LaunchAndWait("ServiceProcessStateTestReadyTrue");
   state.SignalStopped();
   LaunchAndWait("ServiceProcessStateTestReadyFalse");
 }
 
 TEST_F(ServiceProcessStateTest, AutoRun) {
   ServiceProcessState state;
   ASSERT_TRUE(state.AddToAutoRun());
   scoped_ptr<CommandLine> autorun_command_line;
 #if defined(OS_WIN)
@@ skipping 92 matching lines @@
 
 MULTIPROCESS_TEST_MAIN(ServiceProcessStateTestShutdown) {
   MessageLoop message_loop;
   message_loop.set_thread_name("ServiceProcessStateTestShutdownMainThread");
   base::Thread io_thread_("ServiceProcessStateTestShutdownIOThread");
   base::Thread::Options options(MessageLoop::TYPE_IO, 0);
   EXPECT_TRUE(io_thread_.StartWithOptions(options));
   ServiceProcessState state;
   EXPECT_TRUE(state.Initialize());
   EXPECT_TRUE(state.SignalReady(io_thread_.message_loop_proxy(),
-                                NewRunnableFunction(&ShutdownTask,
-                                                    MessageLoop::current())));
+                                base::Bind(&ShutdownTask,
+                                           MessageLoop::current())));
   message_loop.PostDelayedTask(FROM_HERE,
                                new MessageLoop::QuitTask(),
                                TestTimeouts::action_max_timeout_ms());
   EXPECT_FALSE(g_good_shutdown);
   message_loop.Run();
   EXPECT_TRUE(g_good_shutdown);
   return 0;
 }
 
 #else  // !OS_MACOSX
@@ skipping 134 matching lines @@
     ASSERT_TRUE(MakeABundle(GetTempDirPath(),
                             "Test",
                             &bundle_path_,
                             &executable_path_));
     mock_launchd_.reset(new MockLaunchd(executable_path_, &loop_));
     scoped_launchd_instance_.reset(
         new Launchd::ScopedInstance(mock_launchd_.get()));
     ASSERT_TRUE(service_process_state_.Initialize());
     ASSERT_TRUE(service_process_state_.SignalReady(
         io_thread_.message_loop_proxy(),
-        NULL));
+        base::Closure()));
     loop_.PostDelayedTask(FROM_HERE,
                           new MessageLoop::QuitTask,
                           TestTimeouts::action_max_timeout_ms());
   }
 
   bool MakeABundle(const FilePath& dst,
                    const std::string& name,
                    FilePath* bundle_root,
                    FilePath* executable) {
     *bundle_root = dst.Append(name + std::string(".app"));
@@ skipping 121 matching lines @@
   std::string output;
   int exit_code = -1;
   ASSERT_TRUE(base::GetAppOutputWithExitCode(cl, &output, &exit_code)
               && exit_code == 0)
       << " exit_code:" << exit_code << " " << output;
 }
 
 TEST_F(ServiceProcessStateFileManipulationTest, DeleteFile) {
   GetIOMessageLoopProxy()->PostTask(
       FROM_HERE,
-      NewRunnableFunction(&DeleteFunc, executable_path()));
+      base::Bind(&DeleteFunc, executable_path()));
   Run();
   ASSERT_TRUE(mock_launchd()->remove_called());
   ASSERT_TRUE(mock_launchd()->delete_called());
 }
 
 TEST_F(ServiceProcessStateFileManipulationTest, DeleteBundle) {
   GetIOMessageLoopProxy()->PostTask(
       FROM_HERE,
-      NewRunnableFunction(&DeleteFunc, bundle_path()));
+      base::Bind(&DeleteFunc, bundle_path()));
   Run();
   ASSERT_TRUE(mock_launchd()->remove_called());
   ASSERT_TRUE(mock_launchd()->delete_called());
 }
 
 TEST_F(ServiceProcessStateFileManipulationTest, MoveBundle) {
   FilePath new_loc = GetTempDirPath().AppendASCII("MoveBundle");
   GetIOMessageLoopProxy()->PostTask(
       FROM_HERE,
-      NewRunnableFunction(&MoveFunc, bundle_path(), new_loc));
+      base::Bind(&MoveFunc, bundle_path(), new_loc));
   Run();
   ASSERT_TRUE(mock_launchd()->restart_called());
   ASSERT_TRUE(mock_launchd()->write_called());
 }
 
 TEST_F(ServiceProcessStateFileManipulationTest, MoveFile) {
   FilePath new_loc = GetTempDirPath().AppendASCII("MoveFile");
   GetIOMessageLoopProxy()->PostTask(
       FROM_HERE,
-      NewRunnableFunction(&MoveFunc, executable_path(), new_loc));
+      base::Bind(&MoveFunc, executable_path(), new_loc));
   Run();
   ASSERT_TRUE(mock_launchd()->remove_called());
   ASSERT_TRUE(mock_launchd()->delete_called());
 }
 
 TEST_F(ServiceProcessStateFileManipulationTest, TrashBundle) {
   FSRef bundle_ref;
   ASSERT_TRUE(base::mac::FSRefFromPath(bundle_path().value(), &bundle_ref));
   GetIOMessageLoopProxy()->PostTask(
       FROM_HERE,
-      NewRunnableFunction(&TrashFunc, bundle_path()));
+      base::Bind(&TrashFunc, bundle_path()));
   Run();
   ASSERT_TRUE(mock_launchd()->remove_called());
   ASSERT_TRUE(mock_launchd()->delete_called());
   std::string path(base::mac::PathFromFSRef(bundle_ref));
   FilePath file_path(path);
   ASSERT_TRUE(file_util::Delete(file_path, true));
 }
 
 TEST_F(ServiceProcessStateFileManipulationTest, ChangeAttr) {
   ScopedAttributesRestorer restorer(bundle_path(), 0777);
   GetIOMessageLoopProxy()->PostTask(
       FROM_HERE,
-      NewRunnableFunction(&ChangeAttr, bundle_path(), 0222));
+      base::Bind(&ChangeAttr, bundle_path(), 0222));
   Run();
   ASSERT_TRUE(mock_launchd()->remove_called());
   ASSERT_TRUE(mock_launchd()->delete_called());
 }
 
 #endif  // !OS_MACOSX