Remove all remaining traces of MessageLoopProxy.

chrome/common/service_process_util_unittest.cc

 // Copyright (c) 2012 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 <memory>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 59 matching lines @@
                              base::CompareCase::SENSITIVE));
   EXPECT_NE(std::string::npos,
             scoped_name.find(version_info::GetVersionNumber()));
 }
 
 class ServiceProcessStateTest : public base::MultiProcessTest {
  public:
   ServiceProcessStateTest();
   ~ServiceProcessStateTest() override;
   void SetUp() override;
-  base::SingleThreadTaskRunner* IOMessageLoopProxy() {
+  base::SingleThreadTaskRunner* IOTaskRunner() {
     return io_thread_.task_runner().get();
   }
   void LaunchAndWait(const std::string& name);
 
  private:
   // This is used to release the ServiceProcessState singleton after each test.
   base::ShadowingAtExitManager at_exit_manager_;
   base::Thread io_thread_;
 };
 
@@ skipping 21 matching lines @@
   ServiceProcessState state;
   ASSERT_TRUE(state.Initialize());
   LaunchAndWait("ServiceProcessStateTestSingleton");
 }
 
 // http://crbug.com/396390
 TEST_F(ServiceProcessStateTest, DISABLED_ReadyState) {
   ASSERT_FALSE(CheckServiceProcessReady());
   ServiceProcessState state;
   ASSERT_TRUE(state.Initialize());
-  ASSERT_TRUE(state.SignalReady(IOMessageLoopProxy(), base::Closure()));
+  ASSERT_TRUE(state.SignalReady(IOTaskRunner(), base::Closure()));
   LaunchAndWait("ServiceProcessStateTestReadyTrue");
   state.SignalStopped();
   LaunchAndWait("ServiceProcessStateTestReadyFalse");
 }
 
 TEST_F(ServiceProcessStateTest, AutoRun) {
   ServiceProcessState state;
   ASSERT_TRUE(state.AddToAutoRun());
   std::unique_ptr<base::CommandLine> autorun_command_line;
 #if defined(OS_WIN)
@@ skipping 153 matching lines @@
     loop_.task_runner()->PostDelayedTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
         TestTimeouts::action_max_timeout());
   }
 
   const MockLaunchd* mock_launchd() const { return mock_launchd_.get(); }
   const base::FilePath& executable_path() const { return executable_path_; }
   const base::FilePath& bundle_path() const { return bundle_path_; }
   const base::FilePath& GetTempDirPath() const { return temp_dir_.path(); }
 
-  base::SingleThreadTaskRunner* GetIOMessageLoopProxy() {
+  base::SingleThreadTaskRunner* GetIOTaskRunner() {
     return io_thread_.task_runner().get();
   }
   void Run() { loop_.Run(); }
 
  private:
   base::ScopedTempDir temp_dir_;
   base::MessageLoopForUI loop_;
   base::Thread io_thread_;
   base::FilePath executable_path_, bundle_path_;
   std::unique_ptr<MockLaunchd> mock_launchd_;
@@ skipping 53 matching lines @@
   cl.AppendArg("limit");
 
   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,
-      base::Bind(&DeleteFunc, executable_path()));
+  GetIOTaskRunner()->PostTask(FROM_HERE,
+                              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,
-      base::Bind(&DeleteFunc, bundle_path()));
+  GetIOTaskRunner()->PostTask(FROM_HERE,
+                              base::Bind(&DeleteFunc, bundle_path()));
   Run();
   ASSERT_TRUE(mock_launchd()->remove_called());
   ASSERT_TRUE(mock_launchd()->delete_called());
 }
 
 TEST_F(ServiceProcessStateFileManipulationTest, MoveBundle) {
   base::FilePath new_loc = GetTempDirPath().AppendASCII("MoveBundle");
-  GetIOMessageLoopProxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&MoveFunc, bundle_path(), new_loc));
+  GetIOTaskRunner()->PostTask(FROM_HERE,
+                              base::Bind(&MoveFunc, bundle_path(), new_loc));
   Run();
   ASSERT_TRUE(mock_launchd()->restart_called());
   ASSERT_TRUE(mock_launchd()->write_called());
 }
 
 TEST_F(ServiceProcessStateFileManipulationTest, MoveFile) {
   base::FilePath new_loc = GetTempDirPath().AppendASCII("MoveFile");
-  GetIOMessageLoopProxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&MoveFunc, executable_path(), new_loc));
+  GetIOTaskRunner()->PostTask(
+      FROM_HERE, 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,
-      base::Bind(&TrashFunc, bundle_path()));
+  GetIOTaskRunner()->PostTask(FROM_HERE, 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));
   base::FilePath file_path(path);
   ASSERT_TRUE(base::DeleteFile(file_path, true));
 }
 
 TEST_F(ServiceProcessStateFileManipulationTest, ChangeAttr) {
   ScopedAttributesRestorer restorer(bundle_path(), 0777);
-  GetIOMessageLoopProxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&ChangeAttr, bundle_path(), 0222));
+  GetIOTaskRunner()->PostTask(FROM_HERE,
+                              base::Bind(&ChangeAttr, bundle_path(), 0222));
   Run();
   ASSERT_TRUE(mock_launchd()->remove_called());
   ASSERT_TRUE(mock_launchd()->delete_called());
 }
 
 #endif  // !OS_MACOSX