Revert 206507 "Move message_pump to base/message_loop."

trunk/src/base/message_loop/message_loop_unittest.cc

 // Copyright 2013 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/message_loop.h"
+#include "base/message_loop.h"
 #include "base/pending_task.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.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_loop/message_pump_win.h"
+#include "base/message_pump_win.h"
 #include "base/win/scoped_handle.h"
 #endif
 
 namespace base {
 
 class MessageLoopLockTest {
  public:
   static void LockWaitUnLock(MessageLoop* loop,
-                             WaitableEvent* caller_wait,
-                             WaitableEvent* caller_signal) {
+                             base::WaitableEvent* caller_wait,
+                             base::WaitableEvent* caller_signal) {
 
     loop->incoming_queue_lock_.Acquire();
     caller_wait->Signal();
     caller_signal->Wait();
     loop->incoming_queue_lock_.Release();
   }
 };
 
 // TODO(darin): Platform-specific MessageLoop tests should be grouped together
 // to avoid chopping this file up with so many #ifdefs.
@@ skipping 70 matching lines @@
 
   // TryPost with simulated contention. It must fail. We wait for a helper
   // thread to lock the queue, we TryPost on this thread and finally we
   // signal the helper to unlock and exit.
   WaitableEvent wait(true, false);
   WaitableEvent signal(true, false);
   Thread thread("RunTest_PostTask_helper");
   thread.Start();
   thread.message_loop()->PostTask(
       FROM_HERE,
-      Bind(&MessageLoopLockTest::LockWaitUnLock,
+      base::Bind(&MessageLoopLockTest::LockWaitUnLock,
       MessageLoop::current(),
       &wait,
       &signal));
 
   wait.Wait();
   EXPECT_FALSE(MessageLoop::current()->TryPostTask(FROM_HERE, Bind(
       &Foo::Test2Mixed, foo.get(), a, &d)));
   signal.Signal();
 
   // After all tests, post a message that will shut down the message loop
@@ skipping 1277 matching lines @@
 
 void RunTest_RecursivePosts(MessageLoop::Type message_loop_type,
                             int num_times) {
   MessageLoop loop(message_loop_type);
   loop.PostTask(FROM_HERE, Bind(&PostNTasksThenQuit, num_times));
   loop.Run();
 }
 
 #if defined(OS_WIN)
 
-class DispatcherImpl : public MessageLoopForUI::Dispatcher {
+class DispatcherImpl : public base::MessageLoopForUI::Dispatcher {
  public:
   DispatcherImpl() : dispatch_count_(0) {}
 
   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_;
@@ skipping 674 matching lines @@
   // 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