Revert of base: Remove use of MessageLoopProxy

base/files/file_path_watcher_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/files/file_path_watcher.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <aclapi.h>
 #elif defined(OS_POSIX)
 #include <sys/stat.h>
 #endif
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/location.h"
+#include "base/message_loop/message_loop.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_file_util.h"
 #include "base/test/test_timeouts.h"
-#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/path_utils.h"
 #endif  // defined(OS_ANDROID)
 
 namespace base {
 
 namespace {
 
 class TestDelegate;
 
 // Aggregates notifications from the test delegates and breaks the message loop
 // the test thread is waiting on once they all came in.
 class NotificationCollector
     : public base::RefCountedThreadSafe<NotificationCollector> {
  public:
-  NotificationCollector() : task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
+  NotificationCollector()
+      : loop_(base::MessageLoopProxy::current()) {}
 
   // Called from the file thread by the delegates.
   void OnChange(TestDelegate* delegate) {
-    task_runner_->PostTask(
-        FROM_HERE, base::Bind(&NotificationCollector::RecordChange, this,
-                              base::Unretained(delegate)));
+    loop_->PostTask(FROM_HERE,
+                    base::Bind(&NotificationCollector::RecordChange, this,
+                               base::Unretained(delegate)));
   }
 
   void Register(TestDelegate* delegate) {
     delegates_.insert(delegate);
   }
 
   void Reset() {
     signaled_.clear();
   }
 
   bool Success() {
     return signaled_ == delegates_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<NotificationCollector>;
   ~NotificationCollector() {}
 
   void RecordChange(TestDelegate* delegate) {
     // Warning: |delegate| is Unretained. Do not dereference.
-    ASSERT_TRUE(task_runner_->BelongsToCurrentThread());
+    ASSERT_TRUE(loop_->BelongsToCurrentThread());
     ASSERT_TRUE(delegates_.count(delegate));
     signaled_.insert(delegate);
 
     // Check whether all delegates have been signaled.
     if (signaled_ == delegates_)
-      task_runner_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
+      loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
   }
 
   // Set of registered delegates.
   std::set<TestDelegate*> delegates_;
 
   // Set of signaled delegates.
   std::set<TestDelegate*> signaled_;
 
   // The loop we should break after all delegates signaled.
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<base::MessageLoopProxy> loop_;
 };
 
 class TestDelegateBase : public SupportsWeakPtr<TestDelegateBase> {
  public:
   TestDelegateBase() {}
   virtual ~TestDelegateBase() {}
 
   virtual void OnFileChanged(const FilePath& path, bool error) = 0;
 
  private:
@@ skipping 60 matching lines @@
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDirUnderPath(parent_dir));
 #else   // defined(OS_ANDROID)
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 #endif  // defined(OS_ANDROID)
     collector_ = new NotificationCollector();
   }
 
   void TearDown() override { RunLoop().RunUntilIdle(); }
 
   void DeleteDelegateOnFileThread(TestDelegate* delegate) {
-    file_thread_.task_runner()->DeleteSoon(FROM_HERE, delegate);
+    file_thread_.message_loop_proxy()->DeleteSoon(FROM_HERE, delegate);
   }
 
   FilePath test_file() {
     return temp_dir_.path().AppendASCII("FilePathWatcherTest");
   }
 
   FilePath test_link() {
     return temp_dir_.path().AppendASCII("FilePathWatcherTest.lnk");
   }
 
@@ skipping 24 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(FilePathWatcherTest);
 };
 
 bool FilePathWatcherTest::SetupWatch(const FilePath& target,
                                      FilePathWatcher* watcher,
                                      TestDelegateBase* delegate,
                                      bool recursive_watch) {
   base::WaitableEvent completion(false, false);
   bool result;
-  file_thread_.task_runner()->PostTask(
-      FROM_HERE, base::Bind(SetupWatchCallback, target, watcher, delegate,
-                            recursive_watch, &result, &completion));
+  file_thread_.message_loop_proxy()->PostTask(
+      FROM_HERE,
+      base::Bind(SetupWatchCallback, target, watcher, delegate, recursive_watch,
+                 &result, &completion));
   completion.Wait();
   return result;
 }
 
 // Basic test: Create the file and verify that we notice.
 TEST_F(FilePathWatcherTest, NewFile) {
   FilePathWatcher watcher;
   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
 
@@ skipping 49 matching lines @@
 class Deleter : public TestDelegateBase {
  public:
   Deleter(FilePathWatcher* watcher, MessageLoop* loop)
       : watcher_(watcher),
         loop_(loop) {
   }
   ~Deleter() override {}
 
   void OnFileChanged(const FilePath&, bool) override {
     watcher_.reset();
-    loop_->task_runner()->PostTask(FROM_HERE,
-                                   MessageLoop::QuitWhenIdleClosure());
+    loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
   }
 
   FilePathWatcher* watcher() const { return watcher_.get(); }
 
  private:
   scoped_ptr<FilePathWatcher> watcher_;
   MessageLoop* loop_;
 
   DISALLOW_COPY_AND_ASSIGN(Deleter);
 };
@@ skipping 14 matching lines @@
 }
 
 // Verify that deleting the watcher works even if there is a pending
 // notification.
 // Flaky on MacOS (and ARM linux): http://crbug.com/85930
 TEST_F(FilePathWatcherTest, DISABLED_DestroyWithPendingNotification) {
   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
   FilePathWatcher* watcher = new FilePathWatcher;
   ASSERT_TRUE(SetupWatch(test_file(), watcher, delegate.get(), false));
   ASSERT_TRUE(WriteFile(test_file(), "content"));
-  file_thread_.task_runner()->DeleteSoon(FROM_HERE, watcher);
+  file_thread_.message_loop_proxy()->DeleteSoon(FROM_HERE, watcher);
   DeleteDelegateOnFileThread(delegate.release());
 }
 
 TEST_F(FilePathWatcherTest, MultipleWatchersSingleFile) {
   FilePathWatcher watcher1, watcher2;
   scoped_ptr<TestDelegate> delegate1(new TestDelegate(collector()));
   scoped_ptr<TestDelegate> delegate2(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(test_file(), &watcher1, delegate1.get(), false));
   ASSERT_TRUE(SetupWatch(test_file(), &watcher2, delegate2.get(), false));
 
@@ skipping 561 matching lines @@
   ASSERT_TRUE(ChangeFilePermissions(test_dir1, Execute, false));
   ASSERT_TRUE(WaitForEvents());
   ASSERT_TRUE(ChangeFilePermissions(test_dir1, Execute, true));
   DeleteDelegateOnFileThread(delegate.release());
 }
 
 #endif  // OS_MACOSX
 }  // namespace
 
 }  // namespace base