Revert of base: Remove use of MessageLoopProxy

base/threading/thread_perftest.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 "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
-#include "base/location.h"
 #include "base/memory/scoped_vector.h"
-#include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
 
@@ skipping 28 matching lines @@
   virtual void Reset() {}
 
   void TimeOnThread(base::TimeTicks* ticks, base::WaitableEvent* done) {
     *ticks = base::TimeTicks::ThreadNow();
     done->Signal();
   }
 
   base::TimeTicks ThreadNow(base::Thread* thread) {
     base::WaitableEvent done(false, false);
     base::TimeTicks ticks;
-    thread->task_runner()->PostTask(
-        FROM_HERE, base::Bind(&ThreadPerfTest::TimeOnThread,
-                              base::Unretained(this), &ticks, &done));
+    thread->message_loop_proxy()->PostTask(
+        FROM_HERE,
+        base::Bind(&ThreadPerfTest::TimeOnThread,
+                   base::Unretained(this),
+                   &ticks,
+                   &done));
     done.Wait();
     return ticks;
   }
 
   void RunPingPongTest(const std::string& name, unsigned num_threads) {
     // Create threads and collect starting cpu-time for each thread.
     std::vector<base::TimeTicks> thread_starts;
     while (threads_.size() < num_threads) {
       threads_.push_back(new base::Thread("PingPonger"));
       threads_.back()->Start();
@@ skipping 48 matching lines @@
 class TaskPerfTest : public ThreadPerfTest {
   base::Thread* NextThread(int count) {
     return threads_[count % threads_.size()];
   }
 
   void PingPong(int hops) override {
     if (!hops) {
       FinishMeasurement();
       return;
     }
-    NextThread(hops)->task_runner()->PostTask(
-        FROM_HERE, base::Bind(&ThreadPerfTest::PingPong, base::Unretained(this),
-                              hops - 1));
+    NextThread(hops)->message_loop_proxy()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &ThreadPerfTest::PingPong, base::Unretained(this), hops - 1));
   }
 };
 
 // This tries to test the 'best-case' as well as the 'worst-case' task posting
 // performance. The best-case keeps one thread alive such that it never yeilds,
 // while the worse-case forces a context switch for every task. Four threads are
 // used to ensure the threads do yeild (with just two it might be possible for
 // both threads to stay awake if they can signal each other fast enough).
 TEST_F(TaskPerfTest, TaskPingPong) {
   RunPingPongTest("1_Task_Threads", 1);
@@ skipping 46 matching lines @@
     } while (my_hops > 0);
     // Once we are done, all threads will signal as hops passes zero.
     // We only signal completion once, on the thread that reaches zero.
     if (!my_hops)
       FinishMeasurement();
   }
 
   void PingPong(int hops) override {
     remaining_hops_ = hops;
     for (size_t i = 0; i < threads_.size(); i++) {
-      threads_[i]->task_runner()->PostTask(
-          FROM_HERE, base::Bind(&EventPerfTest::WaitAndSignalOnThread,
-                                base::Unretained(this), i));
+      threads_[i]->message_loop_proxy()->PostTask(
+          FROM_HERE,
+          base::Bind(&EventPerfTest::WaitAndSignalOnThread,
+                     base::Unretained(this),
+                     i));
     }
 
     // Kick off the Signal ping-ponging.
     events_.front()->Signal();
   }
 
   int remaining_hops_;
   ScopedVector<WaitableEventType> events_;
 };
 
@@ skipping 87 matching lines @@
 typedef EventPerfTest<PthreadEvent> PthreadEventPerfTest;
 TEST_F(PthreadEventPerfTest, EventPingPong) {
   RunPingPongTest("4_PthreadCondVar_Threads", 4);
 }
 
 #endif
 
 }  // namespace
 
 }  // namespace base