Reduce usage of MessageLoopProxy in base/

base/files/file_path_watcher_browsertest.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/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
+#include "base/sequenced_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"
 
 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()
-      : loop_(base::MessageLoopProxy::current()) {}
+  NotificationCollector() : task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
   // Called from the file thread by the delegates.
   void OnChange(TestDelegate* delegate) {
-    loop_->PostTask(FROM_HERE,
-                    base::Bind(&NotificationCollector::RecordChange, this,
-                               base::Unretained(delegate)));
+    task_runner_->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(loop_->BelongsToCurrentThread());
+    ASSERT_TRUE(task_runner_->RunsTasksOnCurrentThread());
     ASSERT_TRUE(delegates_.count(delegate));
     signaled_.insert(delegate);
 
     // Check whether all delegates have been signaled.
     if (signaled_ == delegates_)
-      loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
+      task_runner_->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::MessageLoopProxy> loop_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 };
 
 class TestDelegateBase : public SupportsWeakPtr<TestDelegateBase> {
  public:
   TestDelegateBase() {}
   virtual ~TestDelegateBase() {}
 
   virtual void OnFileChanged(const FilePath& path, bool error) = 0;
 
  private:
@@ skipping 763 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