Move MessageLoop to base namespace.

base/message_loop_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 <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/pending_task.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/message_pump_win.h"
 #include "base/win/scoped_handle.h"
 #endif
 
-using base::PlatformThread;
-using base::Thread;
-using base::Time;
-using base::TimeDelta;
-using base::TimeTicks;
+namespace base {
 
 // TODO(darin): Platform-specific MessageLoop tests should be grouped together
 // to avoid chopping this file up with so many #ifdefs.
 
 namespace {
 
-class Foo : public base::RefCounted<Foo> {
+class Foo : public RefCounted<Foo> {
  public:
   Foo() : test_count_(0) {
   }
 
   void Test0() {
     ++test_count_;
   }
 
   void Test1ConstRef(const std::string& a) {
     ++test_count_;
@@ skipping 18 matching lines @@
   void Test2Mixed(const std::string& a, std::string* b) {
     ++test_count_;
     result_.append(a);
     result_.append(*b);
   }
 
   int test_count() const { return test_count_; }
   const std::string& result() const { return result_; }
 
  private:
-  friend class base::RefCounted<Foo>;
+  friend class RefCounted<Foo>;
 
   ~Foo() {}
 
   int test_count_;
   std::string result_;
 };
 
 void RunTest_PostTask(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Add tests to message loop
   scoped_refptr<Foo> foo(new Foo());
   std::string a("a"), b("b"), c("c"), d("d");
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test0, foo.get()));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
     &Foo::Test1ConstRef, foo.get(), a));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test1Ptr, foo.get(), &b));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test1Int, foo.get(), 100));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test2Ptr, foo.get(), &a, &c));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test2Mixed, foo.get(), a, &d));
 
   // After all tests, post a message that will shut down the message loop
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &MessageLoop::Quit, base::Unretained(MessageLoop::current())));
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
+      &MessageLoop::Quit, Unretained(MessageLoop::current())));
 
   // Now kick things off
   MessageLoop::current()->Run();
 
   EXPECT_EQ(foo->test_count(), 105);
   EXPECT_EQ(foo->result(), "abacad");
 }
 
 void RunTest_PostTask_SEH(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Add tests to message loop
   scoped_refptr<Foo> foo(new Foo());
   std::string a("a"), b("b"), c("c"), d("d");
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test0, foo.get()));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test1ConstRef, foo.get(), a));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test1Ptr, foo.get(), &b));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test1Int, foo.get(), 100));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test2Ptr, foo.get(), &a, &c));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
       &Foo::Test2Mixed, foo.get(), a, &d));
 
   // After all tests, post a message that will shut down the message loop
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &MessageLoop::Quit, base::Unretained(MessageLoop::current())));
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
+      &MessageLoop::Quit, Unretained(MessageLoop::current())));
 
   // Now kick things off with the SEH block active.
   MessageLoop::current()->set_exception_restoration(true);
   MessageLoop::current()->Run();
   MessageLoop::current()->set_exception_restoration(false);
 
   EXPECT_EQ(foo->test_count(), 105);
   EXPECT_EQ(foo->result(), "abacad");
 }
 
@@ skipping 19 matching lines @@
   MessageLoop loop(message_loop_type);
 
   // Test that PostDelayedTask results in a delayed task.
 
   const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
 
   int num_tasks = 1;
   Time run_time;
 
   loop.PostDelayedTask(
-      FROM_HERE, base::Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
+      FROM_HERE, Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
       kDelay);
 
   Time time_before_run = Time::Now();
   loop.Run();
   Time time_after_run = Time::Now();
 
   EXPECT_EQ(0, num_tasks);
   EXPECT_LT(kDelay, time_after_run - time_before_run);
 }
 
 void RunTest_PostDelayedTask_InDelayOrder(
     MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that two tasks with different delays run in the right order.
   int num_tasks = 2;
   Time run_time1, run_time2;
 
   loop.PostDelayedTask(
       FROM_HERE,
-      base::Bind(&RecordRunTimeFunc, &run_time1, &num_tasks),
+      Bind(&RecordRunTimeFunc, &run_time1, &num_tasks),
       TimeDelta::FromMilliseconds(200));
   // If we get a large pause in execution (due to a context switch) here, this
   // test could fail.
   loop.PostDelayedTask(
       FROM_HERE,
-      base::Bind(&RecordRunTimeFunc, &run_time2, &num_tasks),
+      Bind(&RecordRunTimeFunc, &run_time2, &num_tasks),
       TimeDelta::FromMilliseconds(10));
 
   loop.Run();
   EXPECT_EQ(0, num_tasks);
 
   EXPECT_TRUE(run_time2 < run_time1);
 }
 
 void RunTest_PostDelayedTask_InPostOrder(
     MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that two tasks with the same delay run in the order in which they
   // were posted.
   //
   // NOTE: This is actually an approximate test since the API only takes a
   // "delay" parameter, so we are not exactly simulating two tasks that get
   // posted at the exact same time.  It would be nice if the API allowed us to
   // specify the desired run time.
 
   const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
 
   int num_tasks = 2;
   Time run_time1, run_time2;
 
   loop.PostDelayedTask(
       FROM_HERE,
-      base::Bind(&RecordRunTimeFunc, &run_time1, &num_tasks), kDelay);
+      Bind(&RecordRunTimeFunc, &run_time1, &num_tasks), kDelay);
   loop.PostDelayedTask(
       FROM_HERE,
-      base::Bind(&RecordRunTimeFunc, &run_time2, &num_tasks), kDelay);
+      Bind(&RecordRunTimeFunc, &run_time2, &num_tasks), kDelay);
 
   loop.Run();
   EXPECT_EQ(0, num_tasks);
 
   EXPECT_TRUE(run_time1 < run_time2);
 }
 
 void RunTest_PostDelayedTask_InPostOrder_2(
     MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that a delayed task still runs after a normal tasks even if the
   // normal tasks take a long time to run.
 
   const TimeDelta kPause = TimeDelta::FromMilliseconds(50);
 
   int num_tasks = 2;
   Time run_time;
 
-  loop.PostTask(FROM_HERE, base::Bind(&SlowFunc, kPause, &num_tasks));
+  loop.PostTask(FROM_HERE, Bind(&SlowFunc, kPause, &num_tasks));
   loop.PostDelayedTask(
       FROM_HERE,
-      base::Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
+      Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
       TimeDelta::FromMilliseconds(10));
 
   Time time_before_run = Time::Now();
   loop.Run();
   Time time_after_run = Time::Now();
 
   EXPECT_EQ(0, num_tasks);
 
   EXPECT_LT(kPause, time_after_run - time_before_run);
 }
 
 void RunTest_PostDelayedTask_InPostOrder_3(
     MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that a delayed task still runs after a pile of normal tasks.  The key
   // difference between this test and the previous one is that here we return
   // the MessageLoop a lot so we give the MessageLoop plenty of opportunities
   // to maybe run the delayed task.  It should know not to do so until the
   // delayed task's delay has passed.
 
   int num_tasks = 11;
   Time run_time1, run_time2;
 
   // Clutter the ML with tasks.
   for (int i = 1; i < num_tasks; ++i)
     loop.PostTask(FROM_HERE,
-                  base::Bind(&RecordRunTimeFunc, &run_time1, &num_tasks));
+                  Bind(&RecordRunTimeFunc, &run_time1, &num_tasks));
 
   loop.PostDelayedTask(
-      FROM_HERE, base::Bind(&RecordRunTimeFunc, &run_time2, &num_tasks),
+      FROM_HERE, Bind(&RecordRunTimeFunc, &run_time2, &num_tasks),
       TimeDelta::FromMilliseconds(1));
 
   loop.Run();
   EXPECT_EQ(0, num_tasks);
 
   EXPECT_TRUE(run_time2 > run_time1);
 }
 
 void RunTest_PostDelayedTask_SharedTimer(
     MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that the interval of the timer, used to run the next delayed task, is
   // set to a value corresponding to when the next delayed task should run.
 
   // By setting num_tasks to 1, we ensure that the first task to run causes the
   // run loop to exit.
   int num_tasks = 1;
   Time run_time1, run_time2;
 
   loop.PostDelayedTask(
       FROM_HERE,
-      base::Bind(&RecordRunTimeFunc, &run_time1, &num_tasks),
+      Bind(&RecordRunTimeFunc, &run_time1, &num_tasks),
       TimeDelta::FromSeconds(1000));
   loop.PostDelayedTask(
       FROM_HERE,
-      base::Bind(&RecordRunTimeFunc, &run_time2, &num_tasks),
+      Bind(&RecordRunTimeFunc, &run_time2, &num_tasks),
       TimeDelta::FromMilliseconds(10));
 
   Time start_time = Time::Now();
 
   loop.Run();
   EXPECT_EQ(0, num_tasks);
 
   // Ensure that we ran in far less time than the slower timer.
   TimeDelta total_time = Time::Now() - start_time;
   EXPECT_GT(5000, total_time.InMilliseconds());
 
   // In case both timers somehow run at nearly the same time, sleep a little
   // and then run all pending to force them both to have run.  This is just
   // encouraging flakiness if there is any.
   PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
-  base::RunLoop().RunUntilIdle();
+  RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(run_time1.is_null());
   EXPECT_FALSE(run_time2.is_null());
 }
 
 #if defined(OS_WIN)
 
 void SubPumpFunc() {
   MessageLoop::current()->SetNestableTasksAllowed(true);
   MSG msg;
   while (GetMessage(&msg, NULL, 0, 0)) {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   MessageLoop::current()->QuitWhenIdle();
 }
 
 void RunTest_PostDelayedTask_SharedTimer_SubPump() {
   MessageLoop loop(MessageLoop::TYPE_UI);
 
   // Test that the interval of the timer, used to run the next delayed task, is
   // set to a value corresponding to when the next delayed task should run.
 
   // By setting num_tasks to 1, we ensure that the first task to run causes the
   // run loop to exit.
   int num_tasks = 1;
   Time run_time;
 
-  loop.PostTask(FROM_HERE, base::Bind(&SubPumpFunc));
+  loop.PostTask(FROM_HERE, Bind(&SubPumpFunc));
 
   // This very delayed task should never run.
   loop.PostDelayedTask(
       FROM_HERE,
-      base::Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
+      Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
       TimeDelta::FromSeconds(1000));
 
   // This slightly delayed task should run from within SubPumpFunc).
   loop.PostDelayedTask(
       FROM_HERE,
-      base::Bind(&PostQuitMessage, 0),
+      Bind(&PostQuitMessage, 0),
       TimeDelta::FromMilliseconds(10));
 
   Time start_time = Time::Now();
 
   loop.Run();
   EXPECT_EQ(1, num_tasks);
 
   // Ensure that we ran in far less time than the slower timer.
   TimeDelta total_time = Time::Now() - start_time;
   EXPECT_GT(5000, total_time.InMilliseconds());
 
   // In case both timers somehow run at nearly the same time, sleep a little
   // and then run all pending to force them both to have run.  This is just
   // encouraging flakiness if there is any.
   PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
-  base::RunLoop().RunUntilIdle();
+  RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(run_time.is_null());
 }
 
 #endif  // defined(OS_WIN)
 
 // This is used to inject a test point for recording the destructor calls for
 // Closure objects send to MessageLoop::PostTask(). It is awkward usage since we
 // are trying to hook the actual destruction, which is not a common operation.
-class RecordDeletionProbe : public base::RefCounted<RecordDeletionProbe> {
+class RecordDeletionProbe : public RefCounted<RecordDeletionProbe> {
  public:
   RecordDeletionProbe(RecordDeletionProbe* post_on_delete, bool* was_deleted)
       : post_on_delete_(post_on_delete), was_deleted_(was_deleted) {
   }
   void Run() {}
 
  private:
-  friend class base::RefCounted<RecordDeletionProbe>;
+  friend class RefCounted<RecordDeletionProbe>;
 
   ~RecordDeletionProbe() {
     *was_deleted_ = true;
     if (post_on_delete_)
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&RecordDeletionProbe::Run, post_on_delete_.get()));
+          Bind(&RecordDeletionProbe::Run, post_on_delete_.get()));
   }
 
   scoped_refptr<RecordDeletionProbe> post_on_delete_;
   bool* was_deleted_;
 };
 
 void RunTest_EnsureDeletion(MessageLoop::Type message_loop_type) {
   bool a_was_deleted = false;
   bool b_was_deleted = false;
   {
     MessageLoop loop(message_loop_type);
     loop.PostTask(
-        FROM_HERE, base::Bind(&RecordDeletionProbe::Run,
+        FROM_HERE, Bind(&RecordDeletionProbe::Run,
                               new RecordDeletionProbe(NULL, &a_was_deleted)));
     // TODO(ajwong): Do we really need 1000ms here?
     loop.PostDelayedTask(
-        FROM_HERE, base::Bind(&RecordDeletionProbe::Run,
+        FROM_HERE, Bind(&RecordDeletionProbe::Run,
                               new RecordDeletionProbe(NULL, &b_was_deleted)),
         TimeDelta::FromMilliseconds(1000));
   }
   EXPECT_TRUE(a_was_deleted);
   EXPECT_TRUE(b_was_deleted);
 }
 
 void RunTest_EnsureDeletion_Chain(MessageLoop::Type message_loop_type) {
   bool a_was_deleted = false;
   bool b_was_deleted = false;
   bool c_was_deleted = false;
   {
     MessageLoop loop(message_loop_type);
     // The scoped_refptr for each of the below is held either by the chained
     // RecordDeletionProbe, or the bound RecordDeletionProbe::Run() callback.
     RecordDeletionProbe* a = new RecordDeletionProbe(NULL, &a_was_deleted);
     RecordDeletionProbe* b = new RecordDeletionProbe(a, &b_was_deleted);
     RecordDeletionProbe* c = new RecordDeletionProbe(b, &c_was_deleted);
-    loop.PostTask(FROM_HERE, base::Bind(&RecordDeletionProbe::Run, c));
+    loop.PostTask(FROM_HERE, Bind(&RecordDeletionProbe::Run, c));
   }
   EXPECT_TRUE(a_was_deleted);
   EXPECT_TRUE(b_was_deleted);
   EXPECT_TRUE(c_was_deleted);
 }
 
 void NestingFunc(int* depth) {
   if (*depth > 0) {
     *depth -= 1;
     MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(&NestingFunc, depth));
+                                     Bind(&NestingFunc, depth));
 
     MessageLoop::current()->SetNestableTasksAllowed(true);
     MessageLoop::current()->Run();
   }
   MessageLoop::current()->QuitWhenIdle();
 }
 
 #if defined(OS_WIN)
 
 LONG WINAPI BadExceptionHandler(EXCEPTION_POINTERS *ex_info) {
   ADD_FAILURE() << "bad exception handler";
   ::ExitProcess(ex_info->ExceptionRecord->ExceptionCode);
   return EXCEPTION_EXECUTE_HANDLER;
 }
 
 // This task throws an SEH exception: initially write to an invalid address.
 // If the right SEH filter is installed, it will fix the error.
-class Crasher : public base::RefCounted<Crasher> {
+class Crasher : public RefCounted<Crasher> {
  public:
   // Ctor. If trash_SEH_handler is true, the task will override the unhandled
   // exception handler with one sure to crash this test.
   explicit Crasher(bool trash_SEH_handler)
       : trash_SEH_handler_(trash_SEH_handler) {
   }
 
   void Run() {
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
     if (trash_SEH_handler_)
@@ skipping 58 matching lines @@
   MessageLoop loop(message_loop_type);
 
   if (::IsDebuggerPresent())
     return;
 
   LPTOP_LEVEL_EXCEPTION_FILTER old_SEH_filter =
       ::SetUnhandledExceptionFilter(&HandleCrasherException);
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&Crasher::Run, new Crasher(false)));
+      Bind(&Crasher::Run, new Crasher(false)));
   MessageLoop::current()->set_exception_restoration(true);
   MessageLoop::current()->Run();
   MessageLoop::current()->set_exception_restoration(false);
 
   ::SetUnhandledExceptionFilter(old_SEH_filter);
 }
 
 void RunTest_CrasherNasty(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   if (::IsDebuggerPresent())
     return;
 
   LPTOP_LEVEL_EXCEPTION_FILTER old_SEH_filter =
       ::SetUnhandledExceptionFilter(&HandleCrasherException);
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&Crasher::Run, new Crasher(true)));
+      Bind(&Crasher::Run, new Crasher(true)));
   MessageLoop::current()->set_exception_restoration(true);
   MessageLoop::current()->Run();
   MessageLoop::current()->set_exception_restoration(false);
 
   ::SetUnhandledExceptionFilter(old_SEH_filter);
 }
 
 #endif  // defined(OS_WIN)
 
 void RunTest_Nesting(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   int depth = 100;
   MessageLoop::current()->PostTask(FROM_HERE,
-                                   base::Bind(&NestingFunc, &depth));
+                                   Bind(&NestingFunc, &depth));
   MessageLoop::current()->Run();
   EXPECT_EQ(depth, 0);
 }
 
 const wchar_t* const kMessageBoxTitle = L"MessageLoop Unit Test";
 
 enum TaskType {
   MESSAGEBOX,
   ENDDIALOG,
   RECURSIVE,
@@ skipping 107 matching lines @@
 #endif  // defined(OS_WIN)
 
 void RecursiveFunc(TaskList* order, int cookie, int depth,
                    bool is_reentrant) {
   order->RecordStart(RECURSIVE, cookie);
   if (depth > 0) {
     if (is_reentrant)
       MessageLoop::current()->SetNestableTasksAllowed(true);
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&RecursiveFunc, order, cookie, depth - 1, is_reentrant));
+        Bind(&RecursiveFunc, order, cookie, depth - 1, is_reentrant));
   }
   order->RecordEnd(RECURSIVE, cookie);
 }
 
 void RecursiveSlowFunc(TaskList* order, int cookie, int depth,
                        bool is_reentrant) {
   RecursiveFunc(order, cookie, depth, is_reentrant);
   PlatformThread::Sleep(TimeDelta::FromMilliseconds(10));
 }
 
 void QuitFunc(TaskList* order, int cookie) {
   order->RecordStart(QUITMESSAGELOOP, cookie);
   MessageLoop::current()->QuitWhenIdle();
   order->RecordEnd(QUITMESSAGELOOP, cookie);
 }
 
 void SleepFunc(TaskList* order, int cookie, TimeDelta delay) {
   order->RecordStart(SLEEP, cookie);
   PlatformThread::Sleep(delay);
   order->RecordEnd(SLEEP, cookie);
 }
 
 #if defined(OS_WIN)
 void RecursiveFuncWin(MessageLoop* target,
                       HANDLE event,
                       bool expect_window,
                       TaskList* order,
                       bool is_reentrant) {
   target->PostTask(FROM_HERE,
-                   base::Bind(&RecursiveFunc, order, 1, 2, is_reentrant));
+                   Bind(&RecursiveFunc, order, 1, 2, is_reentrant));
   target->PostTask(FROM_HERE,
-                   base::Bind(&MessageBoxFunc, order, 2, is_reentrant));
+                   Bind(&MessageBoxFunc, order, 2, is_reentrant));
   target->PostTask(FROM_HERE,
-                   base::Bind(&RecursiveFunc, order, 3, 2, is_reentrant));
+                   Bind(&RecursiveFunc, order, 3, 2, is_reentrant));
   // The trick here is that for recursive task processing, this task will be
   // ran _inside_ the MessageBox message loop, dismissing the MessageBox
   // without a chance.
   // For non-recursive task processing, this will be executed _after_ the
   // MessageBox will have been dismissed by the code below, where
   // expect_window_ is true.
   target->PostTask(FROM_HERE,
-                   base::Bind(&EndDialogFunc, order, 4));
+                   Bind(&EndDialogFunc, order, 4));
   target->PostTask(FROM_HERE,
-                   base::Bind(&QuitFunc, order, 5));
+                   Bind(&QuitFunc, order, 5));
 
   // Enforce that every tasks are sent before starting to run the main thread
   // message loop.
   ASSERT_TRUE(SetEvent(event));
 
   // Poll for the MessageBox. Don't do this at home! At the speed we do it,
   // you will never realize one MessageBox was shown.
   for (; expect_window;) {
     HWND window = FindWindow(L"#32770", kMessageBoxTitle);
     if (window) {
@@ skipping 13 matching lines @@
 
 #endif  // defined(OS_WIN)
 
 void RunTest_RecursiveDenial1(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
   TaskList order;
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&RecursiveFunc, &order, 1, 2, false));
+      Bind(&RecursiveFunc, &order, 1, 2, false));
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&RecursiveFunc, &order, 2, 2, false));
+      Bind(&RecursiveFunc, &order, 2, 2, false));
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&QuitFunc, &order, 3));
+      Bind(&QuitFunc, &order, 3));
 
   MessageLoop::current()->Run();
 
   // FIFO order.
   ASSERT_EQ(14U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
   EXPECT_EQ(order.Get(6), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false));
 }
 
 void RunTest_RecursiveDenial3(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
   TaskList order;
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&RecursiveSlowFunc, &order, 1, 2, false));
+      FROM_HERE, Bind(&RecursiveSlowFunc, &order, 1, 2, false));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&RecursiveSlowFunc, &order, 2, 2, false));
+      FROM_HERE, Bind(&RecursiveSlowFunc, &order, 2, 2, false));
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&OrderedFunc, &order, 3),
+      Bind(&OrderedFunc, &order, 3),
       TimeDelta::FromMilliseconds(5));
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&QuitFunc, &order, 4),
+      Bind(&QuitFunc, &order, 4),
       TimeDelta::FromMilliseconds(5));
 
   MessageLoop::current()->Run();
 
   // FIFO order.
   ASSERT_EQ(16U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 3, true));
   EXPECT_EQ(order.Get(7), TaskItem(ORDERED, 3, false));
   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 4, true));
   EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 4, false));
   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 2, false));
 }
 
 void RunTest_RecursiveSupport1(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&RecursiveFunc, &order, 1, 2, true));
+      FROM_HERE, Bind(&RecursiveFunc, &order, 1, 2, true));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&RecursiveFunc, &order, 2, 2, true));
+      FROM_HERE, Bind(&RecursiveFunc, &order, 2, 2, true));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&QuitFunc, &order, 3));
+      FROM_HERE, Bind(&QuitFunc, &order, 3));
 
   MessageLoop::current()->Run();
 
   // FIFO order.
   ASSERT_EQ(14U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
@@ skipping 14 matching lines @@
 
 // A side effect of this test is the generation a beep. Sorry.
 void RunTest_RecursiveDenial2(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   Thread worker("RecursiveDenial2_worker");
   Thread::Options options;
   options.message_loop_type = message_loop_type;
   ASSERT_EQ(true, worker.StartWithOptions(options));
   TaskList order;
-  base::win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
+  win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
   worker.message_loop()->PostTask(FROM_HERE,
-                                  base::Bind(&RecursiveFuncWin,
+                                  Bind(&RecursiveFuncWin,
                                              MessageLoop::current(),
                                              event.Get(),
                                              true,
                                              &order,
                                              false));
   // Let the other thread execute.
   WaitForSingleObject(event, INFINITE);
   MessageLoop::current()->Run();
 
   ASSERT_EQ(order.Size(), 17);
@@ skipping 21 matching lines @@
 // A side effect of this test is the generation a beep. Sorry.  This test also
 // needs to process windows messages on the current thread.
 void RunTest_RecursiveSupport2(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   Thread worker("RecursiveSupport2_worker");
   Thread::Options options;
   options.message_loop_type = message_loop_type;
   ASSERT_EQ(true, worker.StartWithOptions(options));
   TaskList order;
-  base::win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
+  win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
   worker.message_loop()->PostTask(FROM_HERE,
-                                  base::Bind(&RecursiveFuncWin,
+                                  Bind(&RecursiveFuncWin,
                                              MessageLoop::current(),
                                              event.Get(),
                                              false,
                                              &order,
                                              true));
   // Let the other thread execute.
   WaitForSingleObject(event, INFINITE);
   MessageLoop::current()->Run();
 
   ASSERT_EQ(order.Size(), 18);
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(MESSAGEBOX, 2, true));
   // Note that this executes in the MessageBox modal loop.
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 3, true));
   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 3, false));
   EXPECT_EQ(order.Get(5), TaskItem(ENDDIALOG, 4, true));
   EXPECT_EQ(order.Get(6), TaskItem(ENDDIALOG, 4, false));
   EXPECT_EQ(order.Get(7), TaskItem(MESSAGEBOX, 2, false));
   /* The order can subtly change here. The reason is that when RecursiveFunc(1)
      is called in the main thread, if it is faster than getting to the
-     PostTask(FROM_HERE, base::Bind(&QuitFunc) execution, the order of task
+     PostTask(FROM_HERE, Bind(&QuitFunc) execution, the order of task
      execution can change. We don't care anyway that the order isn't correct.
   EXPECT_EQ(order.Get(8), TaskItem(QUITMESSAGELOOP, 5, true));
   EXPECT_EQ(order.Get(9), TaskItem(QUITMESSAGELOOP, 5, false));
   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
   */
   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 3, true));
   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 3, false));
   EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(16), TaskItem(RECURSIVE, 3, true));
   EXPECT_EQ(order.Get(17), TaskItem(RECURSIVE, 3, false));
 }
 
 #endif  // defined(OS_WIN)
 
 void FuncThatPumps(TaskList* order, int cookie) {
   order->RecordStart(PUMPS, cookie);
   {
     MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
-    base::RunLoop().RunUntilIdle();
+    RunLoop().RunUntilIdle();
   }
   order->RecordEnd(PUMPS, cookie);
 }
 
-void FuncThatRuns(TaskList* order, int cookie, base::RunLoop* run_loop) {
+void FuncThatRuns(TaskList* order, int cookie, RunLoop* run_loop) {
   order->RecordStart(RUNS, cookie);
   {
     MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
     run_loop->Run();
   }
   order->RecordEnd(RUNS, cookie);
 }
 
 void FuncThatQuitsNow() {
   MessageLoop::current()->QuitNow();
 }
 
 // Tests that non nestable tasks run in FIFO if there are no nested loops.
 void RunTest_NonNestableWithNoNesting(
     MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
   MessageLoop::current()->PostNonNestableTask(
       FROM_HERE,
-      base::Bind(&OrderedFunc, &order, 1));
+      Bind(&OrderedFunc, &order, 1));
   MessageLoop::current()->PostTask(FROM_HERE,
-                                   base::Bind(&OrderedFunc, &order, 2));
+                                   Bind(&OrderedFunc, &order, 2));
   MessageLoop::current()->PostTask(FROM_HERE,
-                                   base::Bind(&QuitFunc, &order, 3));
+                                   Bind(&QuitFunc, &order, 3));
   MessageLoop::current()->Run();
 
   // FIFO order.
   ASSERT_EQ(6U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(ORDERED, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
 }
 
 // Tests that non nestable tasks don't run when there's code in the call stack.
 void RunTest_NonNestableInNestedLoop(MessageLoop::Type message_loop_type,
                                      bool use_delayed) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&FuncThatPumps, &order, 1));
+      Bind(&FuncThatPumps, &order, 1));
   if (use_delayed) {
     MessageLoop::current()->PostNonNestableDelayedTask(
         FROM_HERE,
-        base::Bind(&OrderedFunc, &order, 2),
+        Bind(&OrderedFunc, &order, 2),
         TimeDelta::FromMilliseconds(1));
   } else {
     MessageLoop::current()->PostNonNestableTask(
         FROM_HERE,
-        base::Bind(&OrderedFunc, &order, 2));
+        Bind(&OrderedFunc, &order, 2));
   }
   MessageLoop::current()->PostTask(FROM_HERE,
-                                   base::Bind(&OrderedFunc, &order, 3));
+                                   Bind(&OrderedFunc, &order, 3));
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&SleepFunc, &order, 4, TimeDelta::FromMilliseconds(50)));
+      Bind(&SleepFunc, &order, 4, TimeDelta::FromMilliseconds(50)));
   MessageLoop::current()->PostTask(FROM_HERE,
-                                   base::Bind(&OrderedFunc, &order, 5));
+                                   Bind(&OrderedFunc, &order, 5));
   if (use_delayed) {
     MessageLoop::current()->PostNonNestableDelayedTask(
         FROM_HERE,
-        base::Bind(&QuitFunc, &order, 6),
+        Bind(&QuitFunc, &order, 6),
         TimeDelta::FromMilliseconds(2));
   } else {
     MessageLoop::current()->PostNonNestableTask(
         FROM_HERE,
-        base::Bind(&QuitFunc, &order, 6));
+        Bind(&QuitFunc, &order, 6));
   }
 
   MessageLoop::current()->Run();
 
   // FIFO order.
   ASSERT_EQ(12U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(PUMPS, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 3, true));
   EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 3, false));
   EXPECT_EQ(order.Get(3), TaskItem(SLEEP, 4, true));
   EXPECT_EQ(order.Get(4), TaskItem(SLEEP, 4, false));
   EXPECT_EQ(order.Get(5), TaskItem(ORDERED, 5, true));
   EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 5, false));
   EXPECT_EQ(order.Get(7), TaskItem(PUMPS, 1, false));
   EXPECT_EQ(order.Get(8), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(9), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 6, true));
   EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 6, false));
 }
 
 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 void RunTest_QuitNow(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
-  base::RunLoop run_loop;
+  RunLoop run_loop;
 
   MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&FuncThatRuns, &order, 1, base::Unretained(&run_loop)));
+      Bind(&FuncThatRuns, &order, 1, Unretained(&run_loop)));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+      FROM_HERE, Bind(&OrderedFunc, &order, 2));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&FuncThatQuitsNow));
+      FROM_HERE, Bind(&FuncThatQuitsNow));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 3));
+      FROM_HERE, Bind(&OrderedFunc, &order, 3));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&FuncThatQuitsNow));
+      FROM_HERE, Bind(&FuncThatQuitsNow));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 4)); // never runs
+      FROM_HERE, Bind(&OrderedFunc, &order, 4)); // never runs
 
   MessageLoop::current()->Run();
 
   ASSERT_EQ(6U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit works before RunWithID.
 void RunTest_RunLoopQuitOrderBefore(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
-  base::RunLoop run_loop;
+  RunLoop run_loop;
 
   run_loop.Quit();
 
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 1)); // never runs
+      FROM_HERE, Bind(&OrderedFunc, &order, 1)); // never runs
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&FuncThatQuitsNow)); // never runs
+      FROM_HERE, Bind(&FuncThatQuitsNow)); // never runs
 
   run_loop.Run();
 
   ASSERT_EQ(0U, order.Size());
 }
 
 // Tests RunLoopQuit works during RunWithID.
 void RunTest_RunLoopQuitOrderDuring(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
-  base::RunLoop run_loop;
+  RunLoop run_loop;
 
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 1));
+      FROM_HERE, Bind(&OrderedFunc, &order, 1));
   MessageLoop::current()->PostTask(
       FROM_HERE, run_loop.QuitClosure());
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 2)); // never runs
+      FROM_HERE, Bind(&OrderedFunc, &order, 2)); // never runs
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&FuncThatQuitsNow)); // never runs
+      FROM_HERE, Bind(&FuncThatQuitsNow)); // never runs
 
   run_loop.Run();
 
   ASSERT_EQ(2U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit works after RunWithID.
 void RunTest_RunLoopQuitOrderAfter(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
-  base::RunLoop run_loop;
+  RunLoop run_loop;
 
   MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&FuncThatRuns, &order, 1, base::Unretained(&run_loop)));
+      Bind(&FuncThatRuns, &order, 1, Unretained(&run_loop)));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+      FROM_HERE, Bind(&OrderedFunc, &order, 2));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&FuncThatQuitsNow));
+      FROM_HERE, Bind(&FuncThatQuitsNow));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 3));
+      FROM_HERE, Bind(&OrderedFunc, &order, 3));
   MessageLoop::current()->PostTask(
       FROM_HERE, run_loop.QuitClosure()); // has no affect
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 4));
+      FROM_HERE, Bind(&OrderedFunc, &order, 4));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&FuncThatQuitsNow));
+      FROM_HERE, Bind(&FuncThatQuitsNow));
 
-  base::RunLoop outer_run_loop;
+  RunLoop outer_run_loop;
   outer_run_loop.Run();
 
   ASSERT_EQ(8U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 void RunTest_RunLoopQuitTop(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
-  base::RunLoop outer_run_loop;
-  base::RunLoop nested_run_loop;
+  RunLoop outer_run_loop;
+  RunLoop nested_run_loop;
 
   MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&FuncThatRuns, &order, 1, base::Unretained(&nested_run_loop)));
+      Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
   MessageLoop::current()->PostTask(
       FROM_HERE, outer_run_loop.QuitClosure());
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+      FROM_HERE, Bind(&OrderedFunc, &order, 2));
   MessageLoop::current()->PostTask(
       FROM_HERE, nested_run_loop.QuitClosure());
 
   outer_run_loop.Run();
 
   ASSERT_EQ(4U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 void RunTest_RunLoopQuitNested(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
-  base::RunLoop outer_run_loop;
-  base::RunLoop nested_run_loop;
+  RunLoop outer_run_loop;
+  RunLoop nested_run_loop;
 
   MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&FuncThatRuns, &order, 1, base::Unretained(&nested_run_loop)));
+      Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
   MessageLoop::current()->PostTask(
       FROM_HERE, nested_run_loop.QuitClosure());
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+      FROM_HERE, Bind(&OrderedFunc, &order, 2));
   MessageLoop::current()->PostTask(
       FROM_HERE, outer_run_loop.QuitClosure());
 
   outer_run_loop.Run();
 
   ASSERT_EQ(4U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 void RunTest_RunLoopQuitBogus(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
-  base::RunLoop outer_run_loop;
-  base::RunLoop nested_run_loop;
-  base::RunLoop bogus_run_loop;
+  RunLoop outer_run_loop;
+  RunLoop nested_run_loop;
+  RunLoop bogus_run_loop;
 
   MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&FuncThatRuns, &order, 1, base::Unretained(&nested_run_loop)));
+      Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
   MessageLoop::current()->PostTask(
       FROM_HERE, bogus_run_loop.QuitClosure());
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+      FROM_HERE, Bind(&OrderedFunc, &order, 2));
   MessageLoop::current()->PostTask(
       FROM_HERE, outer_run_loop.QuitClosure());
   MessageLoop::current()->PostTask(
       FROM_HERE, nested_run_loop.QuitClosure());
 
   outer_run_loop.Run();
 
   ASSERT_EQ(4U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 void RunTest_RunLoopQuitDeep(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
-  base::RunLoop outer_run_loop;
-  base::RunLoop nested_loop1;
-  base::RunLoop nested_loop2;
-  base::RunLoop nested_loop3;
-  base::RunLoop nested_loop4;
+  RunLoop outer_run_loop;
+  RunLoop nested_loop1;
+  RunLoop nested_loop2;
+  RunLoop nested_loop3;
+  RunLoop nested_loop4;
 
   MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&FuncThatRuns, &order, 1, base::Unretained(&nested_loop1)));
+      Bind(&FuncThatRuns, &order, 1, Unretained(&nested_loop1)));
   MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&FuncThatRuns, &order, 2, base::Unretained(&nested_loop2)));
+      Bind(&FuncThatRuns, &order, 2, Unretained(&nested_loop2)));
   MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&FuncThatRuns, &order, 3, base::Unretained(&nested_loop3)));
+      Bind(&FuncThatRuns, &order, 3, Unretained(&nested_loop3)));
   MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&FuncThatRuns, &order, 4, base::Unretained(&nested_loop4)));
+      Bind(&FuncThatRuns, &order, 4, Unretained(&nested_loop4)));
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 5));
+      FROM_HERE, Bind(&OrderedFunc, &order, 5));
   MessageLoop::current()->PostTask(
       FROM_HERE, outer_run_loop.QuitClosure());
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 6));
+      FROM_HERE, Bind(&OrderedFunc, &order, 6));
   MessageLoop::current()->PostTask(
       FROM_HERE, nested_loop1.QuitClosure());
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 7));
+      FROM_HERE, Bind(&OrderedFunc, &order, 7));
   MessageLoop::current()->PostTask(
       FROM_HERE, nested_loop2.QuitClosure());
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 8));
+      FROM_HERE, Bind(&OrderedFunc, &order, 8));
   MessageLoop::current()->PostTask(
       FROM_HERE, nested_loop3.QuitClosure());
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 9));
+      FROM_HERE, Bind(&OrderedFunc, &order, 9));
   MessageLoop::current()->PostTask(
       FROM_HERE, nested_loop4.QuitClosure());
   MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&OrderedFunc, &order, 10));
+      FROM_HERE, Bind(&OrderedFunc, &order, 10));
 
   outer_run_loop.Run();
 
   ASSERT_EQ(18U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, true));
@@ skipping 10 matching lines @@
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 void PostNTasksThenQuit(int posts_remaining) {
   if (posts_remaining > 1) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&PostNTasksThenQuit, posts_remaining - 1));
+        Bind(&PostNTasksThenQuit, posts_remaining - 1));
   } else {
     MessageLoop::current()->QuitWhenIdle();
   }
 }
 
 void RunTest_RecursivePosts(MessageLoop::Type message_loop_type,
                             int num_times) {
   MessageLoop loop(message_loop_type);
-  loop.PostTask(FROM_HERE, base::Bind(&PostNTasksThenQuit, num_times));
+  loop.PostTask(FROM_HERE, Bind(&PostNTasksThenQuit, num_times));
   loop.Run();
 }
 
 #if defined(OS_WIN)
 
 class DispatcherImpl : public MessageLoopForUI::Dispatcher {
  public:
   DispatcherImpl() : dispatch_count_(0) {}
 
-  virtual bool Dispatch(const base::NativeEvent& msg) OVERRIDE {
+  virtual bool Dispatch(const NativeEvent& msg) OVERRIDE {
     ::TranslateMessage(&msg);
     ::DispatchMessage(&msg);
     // Do not count WM_TIMER since it is not what we post and it will cause
     // flakiness.
     if (msg.message != WM_TIMER)
       ++dispatch_count_;
     // We treat WM_LBUTTONUP as the last message.
     return msg.message != WM_LBUTTONUP;
   }
 
   int dispatch_count_;
 };
 
 void MouseDownUp() {
   PostMessage(NULL, WM_LBUTTONDOWN, 0, 0);
   PostMessage(NULL, WM_LBUTTONUP, 'A', 0);
 }
 
 void RunTest_Dispatcher(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&MouseDownUp),
+      Bind(&MouseDownUp),
       TimeDelta::FromMilliseconds(100));
   DispatcherImpl dispatcher;
-  base::RunLoop run_loop(&dispatcher);
+  RunLoop run_loop(&dispatcher);
   run_loop.Run();
   ASSERT_EQ(2, dispatcher.dispatch_count_);
 }
 
 LRESULT CALLBACK MsgFilterProc(int code, WPARAM wparam, LPARAM lparam) {
-  if (code == base::MessagePumpForUI::kMessageFilterCode) {
+  if (code == MessagePumpForUI::kMessageFilterCode) {
     MSG* msg = reinterpret_cast<MSG*>(lparam);
     if (msg->message == WM_LBUTTONDOWN)
       return TRUE;
   }
   return FALSE;
 }
 
 void RunTest_DispatcherWithMessageHook(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&MouseDownUp),
+      Bind(&MouseDownUp),
       TimeDelta::FromMilliseconds(100));
   HHOOK msg_hook = SetWindowsHookEx(WH_MSGFILTER,
                                     MsgFilterProc,
                                     NULL,
                                     GetCurrentThreadId());
   DispatcherImpl dispatcher;
-  base::RunLoop run_loop(&dispatcher);
+  RunLoop run_loop(&dispatcher);
   run_loop.Run();
   ASSERT_EQ(1, dispatcher.dispatch_count_);
   UnhookWindowsHookEx(msg_hook);
 }
 
 class TestIOHandler : public MessageLoopForIO::IOHandler {
  public:
   TestIOHandler(const wchar_t* name, HANDLE signal, bool wait);
 
   virtual void OnIOCompleted(MessageLoopForIO::IOContext* context,
                              DWORD bytes_transfered, DWORD error);
 
   void Init();
   void WaitForIO();
   OVERLAPPED* context() { return &context_.overlapped; }
   DWORD size() { return sizeof(buffer_); }
 
  private:
   char buffer_[48];
   MessageLoopForIO::IOContext context_;
   HANDLE signal_;
-  base::win::ScopedHandle file_;
+  win::ScopedHandle file_;
   bool wait_;
 };
 
 TestIOHandler::TestIOHandler(const wchar_t* name, HANDLE signal, bool wait)
     : signal_(signal), wait_(wait) {
   memset(buffer_, 0, sizeof(buffer_));
   memset(&context_, 0, sizeof(context_));
   context_.handler = this;
 
   file_.Set(CreateFile(name, GENERIC_READ, 0, NULL, OPEN_EXISTING,
@@ skipping 16 matching lines @@
   ASSERT_TRUE(context == &context_);
   ASSERT_TRUE(SetEvent(signal_));
 }
 
 void TestIOHandler::WaitForIO() {
   EXPECT_TRUE(MessageLoopForIO::current()->WaitForIOCompletion(300, this));
   EXPECT_TRUE(MessageLoopForIO::current()->WaitForIOCompletion(400, this));
 }
 
 void RunTest_IOHandler() {
-  base::win::ScopedHandle callback_called(CreateEvent(NULL, TRUE, FALSE, NULL));
+  win::ScopedHandle callback_called(CreateEvent(NULL, TRUE, FALSE, NULL));
   ASSERT_TRUE(callback_called.IsValid());
 
   const wchar_t* kPipeName = L"\\\\.\\pipe\\iohandler_pipe";
-  base::win::ScopedHandle server(
+  win::ScopedHandle server(
       CreateNamedPipe(kPipeName, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
   ASSERT_TRUE(server.IsValid());
 
   Thread thread("IOHandler test");
   Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   ASSERT_TRUE(thread.StartWithOptions(options));
 
   MessageLoop* thread_loop = thread.message_loop();
   ASSERT_TRUE(NULL != thread_loop);
 
   TestIOHandler handler(kPipeName, callback_called, false);
-  thread_loop->PostTask(FROM_HERE, base::Bind(&TestIOHandler::Init,
-                                              base::Unretained(&handler)));
+  thread_loop->PostTask(FROM_HERE, Bind(&TestIOHandler::Init,
+                                              Unretained(&handler)));
   // Make sure the thread runs and sleeps for lack of work.
-  base::PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
+  PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
 
   const char buffer[] = "Hello there!";
   DWORD written;
   EXPECT_TRUE(WriteFile(server, buffer, sizeof(buffer), &written, NULL));
 
   DWORD result = WaitForSingleObject(callback_called, 1000);
   EXPECT_EQ(WAIT_OBJECT_0, result);
 
   thread.Stop();
 }
 
 void RunTest_WaitForIO() {
-  base::win::ScopedHandle callback1_called(
+  win::ScopedHandle callback1_called(
       CreateEvent(NULL, TRUE, FALSE, NULL));
-  base::win::ScopedHandle callback2_called(
+  win::ScopedHandle callback2_called(
       CreateEvent(NULL, TRUE, FALSE, NULL));
   ASSERT_TRUE(callback1_called.IsValid());
   ASSERT_TRUE(callback2_called.IsValid());
 
   const wchar_t* kPipeName1 = L"\\\\.\\pipe\\iohandler_pipe1";
   const wchar_t* kPipeName2 = L"\\\\.\\pipe\\iohandler_pipe2";
-  base::win::ScopedHandle server1(
+  win::ScopedHandle server1(
       CreateNamedPipe(kPipeName1, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
-  base::win::ScopedHandle server2(
+  win::ScopedHandle server2(
       CreateNamedPipe(kPipeName2, PIPE_ACCESS_OUTBOUND, 0, 1, 0, 0, 0, NULL));
   ASSERT_TRUE(server1.IsValid());
   ASSERT_TRUE(server2.IsValid());
 
   Thread thread("IOHandler test");
   Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   ASSERT_TRUE(thread.StartWithOptions(options));
 
   MessageLoop* thread_loop = thread.message_loop();
   ASSERT_TRUE(NULL != thread_loop);
 
   TestIOHandler handler1(kPipeName1, callback1_called, false);
   TestIOHandler handler2(kPipeName2, callback2_called, true);
-  thread_loop->PostTask(FROM_HERE, base::Bind(&TestIOHandler::Init,
-                                              base::Unretained(&handler1)));
+  thread_loop->PostTask(FROM_HERE, Bind(&TestIOHandler::Init,
+                                              Unretained(&handler1)));
   // TODO(ajwong): Do we really need such long Sleeps in ths function?
   // Make sure the thread runs and sleeps for lack of work.
   TimeDelta delay = TimeDelta::FromMilliseconds(100);
-  base::PlatformThread::Sleep(delay);
-  thread_loop->PostTask(FROM_HERE, base::Bind(&TestIOHandler::Init,
-                                              base::Unretained(&handler2)));
-  base::PlatformThread::Sleep(delay);
+  PlatformThread::Sleep(delay);
+  thread_loop->PostTask(FROM_HERE, Bind(&TestIOHandler::Init,
+                                              Unretained(&handler2)));
+  PlatformThread::Sleep(delay);
 
   // At this time handler1 is waiting to be called, and the thread is waiting
   // on the Init method of handler2, filtering only handler2 callbacks.
 
   const char buffer[] = "Hello there!";
   DWORD written;
   EXPECT_TRUE(WriteFile(server1, buffer, sizeof(buffer), &written, NULL));
-  base::PlatformThread::Sleep(2 * delay);
+  PlatformThread::Sleep(2 * delay);
   EXPECT_EQ(WAIT_TIMEOUT, WaitForSingleObject(callback1_called, 0)) <<
       "handler1 has not been called";
 
   EXPECT_TRUE(WriteFile(server2, buffer, sizeof(buffer), &written, NULL));
 
   HANDLE objects[2] = { callback1_called.Get(), callback2_called.Get() };
   DWORD result = WaitForMultipleObjects(2, objects, TRUE, 1000);
   EXPECT_EQ(WAIT_OBJECT_0, result);
 
   thread.Stop();
@@ skipping 200 matching lines @@
 
 class DummyTaskObserver : public MessageLoop::TaskObserver {
  public:
   explicit DummyTaskObserver(int num_tasks)
       : num_tasks_started_(0),
         num_tasks_processed_(0),
         num_tasks_(num_tasks) {}
 
   virtual ~DummyTaskObserver() {}
 
-  virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+  virtual void WillProcessTask(const PendingTask& pending_task) OVERRIDE {
     num_tasks_started_++;
     EXPECT_TRUE(pending_task.time_posted != TimeTicks());
     EXPECT_LE(num_tasks_started_, num_tasks_);
     EXPECT_EQ(num_tasks_started_, num_tasks_processed_ + 1);
   }
 
-  virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {
+  virtual void DidProcessTask(const PendingTask& pending_task) OVERRIDE {
     num_tasks_processed_++;
     EXPECT_TRUE(pending_task.time_posted != TimeTicks());
     EXPECT_LE(num_tasks_started_, num_tasks_);
     EXPECT_EQ(num_tasks_started_, num_tasks_processed_);
   }
 
   int num_tasks_started() const { return num_tasks_started_; }
   int num_tasks_processed() const { return num_tasks_processed_; }
 
  private:
   int num_tasks_started_;
   int num_tasks_processed_;
   const int num_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(DummyTaskObserver);
 };
 
 TEST(MessageLoopTest, TaskObserver) {
   const int kNumPosts = 6;
   DummyTaskObserver observer(kNumPosts);
 
   MessageLoop loop;
   loop.AddTaskObserver(&observer);
-  loop.PostTask(FROM_HERE, base::Bind(&PostNTasksThenQuit, kNumPosts));
+  loop.PostTask(FROM_HERE, Bind(&PostNTasksThenQuit, kNumPosts));
   loop.Run();
   loop.RemoveTaskObserver(&observer);
 
   EXPECT_EQ(kNumPosts, observer.num_tasks_started());
   EXPECT_EQ(kNumPosts, observer.num_tasks_processed());
 }
 
 #if defined(OS_WIN)
 TEST(MessageLoopTest, Dispatcher) {
   // This test requires a UI loop
@@ skipping 15 matching lines @@
 
 TEST(MessageLoopTest, HighResolutionTimer) {
   MessageLoop loop;
 
   const TimeDelta kFastTimer = TimeDelta::FromMilliseconds(5);
   const TimeDelta kSlowTimer = TimeDelta::FromMilliseconds(100);
 
   EXPECT_FALSE(loop.high_resolution_timers_enabled());
 
   // Post a fast task to enable the high resolution timers.
-  loop.PostDelayedTask(FROM_HERE, base::Bind(&PostNTasksThenQuit, 1),
+  loop.PostDelayedTask(FROM_HERE, Bind(&PostNTasksThenQuit, 1),
                        kFastTimer);
   loop.Run();
   EXPECT_TRUE(loop.high_resolution_timers_enabled());
 
   // Post a slow task and verify high resolution timers
   // are still enabled.
-  loop.PostDelayedTask(FROM_HERE, base::Bind(&PostNTasksThenQuit, 1),
+  loop.PostDelayedTask(FROM_HERE, Bind(&PostNTasksThenQuit, 1),
                        kSlowTimer);
   loop.Run();
   EXPECT_TRUE(loop.high_resolution_timers_enabled());
 
   // Wait for a while so that high-resolution mode elapses.
-  base::PlatformThread::Sleep(TimeDelta::FromMilliseconds(
+  PlatformThread::Sleep(TimeDelta::FromMilliseconds(
       MessageLoop::kHighResolutionTimerModeLeaseTimeMs));
 
   // Post a slow task to disable the high resolution timers.
-  loop.PostDelayedTask(FROM_HERE, base::Bind(&PostNTasksThenQuit, 1),
+  loop.PostDelayedTask(FROM_HERE, Bind(&PostNTasksThenQuit, 1),
                        kSlowTimer);
   loop.Run();
   EXPECT_FALSE(loop.high_resolution_timers_enabled());
 }
 
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 
 namespace {
@@ skipping 64 matching lines @@
 
 }  // namespace
 
 #endif  // defined(OS_POSIX) && !defined(OS_NACL)
 
 namespace {
 // Inject a test point for recording the destructor calls for Closure objects
 // send to MessageLoop::PostTask(). It is awkward usage since we are trying to
 // hook the actual destruction, which is not a common operation.
 class DestructionObserverProbe :
-  public base::RefCounted<DestructionObserverProbe> {
+  public RefCounted<DestructionObserverProbe> {
  public:
   DestructionObserverProbe(bool* task_destroyed,
                            bool* destruction_observer_called)
       : task_destroyed_(task_destroyed),
         destruction_observer_called_(destruction_observer_called) {
   }
   virtual void Run() {
     // This task should never run.
     ADD_FAILURE();
   }
  private:
-  friend class base::RefCounted<DestructionObserverProbe>;
+  friend class RefCounted<DestructionObserverProbe>;
 
   virtual ~DestructionObserverProbe() {
     EXPECT_FALSE(*destruction_observer_called_);
     *task_destroyed_ = true;
   }
 
   bool* task_destroyed_;
   bool* destruction_observer_called_;
 };
 
@@ skipping 25 matching lines @@
   MessageLoop* loop = new MessageLoop;
   const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
 
   bool task_destroyed = false;
   bool destruction_observer_called = false;
 
   MLDestructionObserver observer(&task_destroyed, &destruction_observer_called);
   loop->AddDestructionObserver(&observer);
   loop->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&DestructionObserverProbe::Run,
+      Bind(&DestructionObserverProbe::Run,
                  new DestructionObserverProbe(&task_destroyed,
                                               &destruction_observer_called)),
       kDelay);
   delete loop;
   EXPECT_TRUE(observer.task_destroyed_before_message_loop());
   // The task should have been destroyed when we deleted the loop.
   EXPECT_TRUE(task_destroyed);
   EXPECT_TRUE(destruction_observer_called);
 }
 
 
 // Verify that MessageLoop sets ThreadMainTaskRunner::current() and it
 // posts tasks on that message loop.
 TEST(MessageLoopTest, ThreadMainTaskRunner) {
   MessageLoop loop;
 
   scoped_refptr<Foo> foo(new Foo());
   std::string a("a");
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, base::Bind(
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(
       &Foo::Test1ConstRef, foo.get(), a));
 
   // Post quit task;
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &MessageLoop::Quit, base::Unretained(MessageLoop::current())));
+  MessageLoop::current()->PostTask(FROM_HERE, Bind(
+      &MessageLoop::Quit, Unretained(MessageLoop::current())));
 
   // Now kick things off
   MessageLoop::current()->Run();
 
   EXPECT_EQ(foo->test_count(), 1);
   EXPECT_EQ(foo->result(), "a");
 }
 
 TEST(MessageLoopTest, IsType) {
   MessageLoop loop(MessageLoop::TYPE_UI);
   EXPECT_TRUE(loop.IsType(MessageLoop::TYPE_UI));
   EXPECT_FALSE(loop.IsType(MessageLoop::TYPE_IO));
   EXPECT_FALSE(loop.IsType(MessageLoop::TYPE_DEFAULT));
 }
 
 TEST(MessageLoopTest, RecursivePosts) {
   // There was a bug in the MessagePumpGLib where posting tasks recursively
   // caused the message loop to hang, due to the buffer of the internal pipe
   // becoming full. Test all MessageLoop types to ensure this issue does not
   // exist in other MessagePumps.
 
   // On Linux, the pipe buffer size is 64KiB by default. The bug caused one
   // byte accumulated in the pipe per two posts, so we should repeat 128K
   // times to reproduce the bug.
   const int kNumTimes = 1 << 17;
   RunTest_RecursivePosts(MessageLoop::TYPE_DEFAULT, kNumTimes);
   RunTest_RecursivePosts(MessageLoop::TYPE_UI, kNumTimes);
   RunTest_RecursivePosts(MessageLoop::TYPE_IO, kNumTimes);
 }
+
+}  // namespace base