chrome/browser: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/browser/process_singleton_posix_unittest.cc

 // Copyright 2014 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/process_singleton.h"
 
 #include <fcntl.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/un.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/message_loop/message_loop.h"
+#include "base/location.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/test/thread_test_helper.h"
 #include "base/threading/thread.h"
 #include "chrome/common/chrome_constants.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 55 matching lines @@
   }
 
   void TearDown() override {
     scoped_refptr<base::ThreadTestHelper> io_helper(new base::ThreadTestHelper(
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get()));
     ASSERT_TRUE(io_helper->Run());
 
     // Destruct the ProcessSingleton object before the IO thread so that its
     // internals are destructed properly.
     if (process_singleton_on_thread_) {
-      worker_thread_->message_loop()->PostTask(
+      worker_thread_->task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&ProcessSingletonPosixTest::DestructProcessSingleton,
                      base::Unretained(this)));
 
-      scoped_refptr<base::ThreadTestHelper> helper(new base::ThreadTestHelper(
-          worker_thread_->message_loop_proxy().get()));
+      scoped_refptr<base::ThreadTestHelper> helper(
+          new base::ThreadTestHelper(worker_thread_->task_runner().get()));
       ASSERT_TRUE(helper->Run());
     }
 
     io_thread_.Stop();
     testing::Test::TearDown();
   }
 
   void CreateProcessSingletonOnThread() {
     ASSERT_EQ(NULL, worker_thread_.get());
     worker_thread_.reset(new base::Thread("BlockingThread"));
     worker_thread_->Start();
 
-    worker_thread_->message_loop()->PostTask(
-       FROM_HERE,
-       base::Bind(&ProcessSingletonPosixTest::
-                      CreateProcessSingletonInternal,
-                  base::Unretained(this)));
+    worker_thread_->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ProcessSingletonPosixTest::CreateProcessSingletonInternal,
+                   base::Unretained(this)));
 
     scoped_refptr<base::ThreadTestHelper> helper(
-        new base::ThreadTestHelper(worker_thread_->message_loop_proxy().get()));
+        new base::ThreadTestHelper(worker_thread_->task_runner().get()));
     ASSERT_TRUE(helper->Run());
   }
 
   TestableProcessSingleton* CreateProcessSingleton() {
     return new TestableProcessSingleton(user_data_path_);
   }
 
   void VerifyFiles() {
     struct stat statbuf;
     ASSERT_EQ(0, lstat(lock_path_.value().c_str(), &statbuf));
@@ skipping 64 matching lines @@
           "about:blank") {
         found = true;
         break;
       }
     }
     ASSERT_TRUE(found);
     ASSERT_EQ(0, kill_callbacks_);
   }
 
   void BlockWorkerThread() {
-    worker_thread_->message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&ProcessSingletonPosixTest::BlockThread,
-                   base::Unretained(this)));
+    worker_thread_->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&ProcessSingletonPosixTest::BlockThread,
+                              base::Unretained(this)));
   }
 
   void UnblockWorkerThread() {
     wait_event_.Signal();  // Unblock the worker thread for shutdown.
     signal_event_.Wait();  // Ensure thread unblocks before continuing.
   }
 
   void BlockThread() {
     wait_event_.Wait();
     signal_event_.Signal();
@@ skipping 198 matching lines @@
 // Test that if there is an existing lock file, and it's not locked, we replace
 // it.
 TEST_F(ProcessSingletonPosixTest, CreateReplacesOldMacLock) {
   scoped_ptr<TestableProcessSingleton> process_singleton(
       CreateProcessSingleton());
   EXPECT_EQ(0, base::WriteFile(lock_path_, "", 0));
   EXPECT_TRUE(process_singleton->Create());
   VerifyFiles();
 }
 #endif  // defined(OS_MACOSX)