Revert of base: Remove use of MessageLoopProxy

base/observer_list_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 "base/observer_list.h"
 #include "base/observer_list_threadsafe.h"
 
 #include <vector>
 
 #include "base/compiler_specific.h"
-#include "base/location.h"
 #include "base/memory/weak_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace {
 
 class Foo {
  public:
   virtual void Observe(int x) = 0;
   virtual ~Foo() {}
@@ skipping 76 matching lines @@
         count_observes_(0),
         count_addtask_(0),
         do_notifies_(notify),
         weak_factory_(this) {
   }
 
   ~AddRemoveThread() override {}
 
   void ThreadMain() override {
     loop_ = new MessageLoop();  // Fire up a message loop.
-    loop_->task_runner()->PostTask(
+    loop_->PostTask(
         FROM_HERE,
         base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
     loop_->Run();
     //LOG(ERROR) << "Loop 0x" << std::hex << loop_ << " done. " <<
     //    count_observes_ << ", " << count_addtask_;
     delete loop_;
     loop_ = reinterpret_cast<MessageLoop*>(0xdeadbeef);
     delete this;
   }
 
   // This task just keeps posting to itself in an attempt
   // to race with the notifier.
   void AddTask() {
     count_addtask_++;
 
     if ((Time::Now() - start_).InMilliseconds() > kThreadRunTime) {
       VLOG(1) << "DONE!";
       return;
     }
 
     if (!in_list_) {
       list_->AddObserver(this);
       in_list_ = true;
     }
 
     if (do_notifies_) {
       list_->Notify(FROM_HERE, &Foo::Observe, 10);
     }
 
-    loop_->task_runner()->PostTask(
+    loop_->PostTask(
         FROM_HERE,
         base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
   }
 
   void Quit() {
-    loop_->task_runner()->PostTask(FROM_HERE,
-                                   MessageLoop::QuitWhenIdleClosure());
+    loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
   }
 
   void Observe(int x) override {
     count_observes_++;
 
     // If we're getting called after we removed ourselves from
     // the list, that is very bad!
     DCHECK(in_list_);
 
     // This callback should fire on the appropriate thread
@@ skipping 377 matching lines @@
   ListDestructor a(observer_list);
   observer_list->AddObserver(&a);
 
   FOR_EACH_OBSERVER(Foo, *observer_list, Observe(0));
   // If this test fails, there'll be Valgrind errors when this function goes out
   // of scope.
 }
 
 }  // namespace
 }  // namespace base