Made MessagePump a non-thread safe class.

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/message_loop_proxy_impl.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/win/scoped_handle.h"
 #endif
 
 namespace base {
 
 class MessageLoopLockTest {
  public:
   static void LockWaitUnLock(MessageLoop* loop,
                              WaitableEvent* caller_wait,
                              WaitableEvent* caller_signal) {
 
-    loop->incoming_queue_lock_.Acquire();
+    loop->message_loop_proxy_->incoming_queue_lock_.Acquire();
     caller_wait->Signal();
     caller_signal->Wait();
-    loop->incoming_queue_lock_.Release();
+    loop->message_loop_proxy_->incoming_queue_lock_.Release();
   }
 };
 
 // TODO(darin): Platform-specific MessageLoop tests should be grouped together
 // to avoid chopping this file up with so many #ifdefs.
 
 namespace {
 
 class Foo : public RefCounted<Foo> {
  public:
@@ skipping 1839 matching lines @@
 TEST(MessageLoopTest, WaitForIO) {
   RunTest_WaitForIO();
 }
 
 TEST(MessageLoopTest, HighResolutionTimer) {
   MessageLoop loop;
 
   const TimeDelta kFastTimer = TimeDelta::FromMilliseconds(5);
   const TimeDelta kSlowTimer = TimeDelta::FromMilliseconds(100);
 
-  EXPECT_FALSE(loop.high_resolution_timers_enabled());
+  EXPECT_FALSE(loop.IsHishResolutionTimersEnabledForTest());
 
   // Post a fast task to enable the high resolution timers.
   loop.PostDelayedTask(FROM_HERE, Bind(&PostNTasksThenQuit, 1),
                        kFastTimer);
   loop.Run();
-  EXPECT_TRUE(loop.high_resolution_timers_enabled());
+  EXPECT_TRUE(loop.IsHishResolutionTimersEnabledForTest());
 
   // Post a slow task and verify high resolution timers
   // are still enabled.
   loop.PostDelayedTask(FROM_HERE, Bind(&PostNTasksThenQuit, 1),
                        kSlowTimer);
   loop.Run();
-  EXPECT_TRUE(loop.high_resolution_timers_enabled());
+  EXPECT_TRUE(loop.IsHishResolutionTimersEnabledForTest());
 
   // Wait for a while so that high-resolution mode elapses.
   PlatformThread::Sleep(TimeDelta::FromMilliseconds(
       MessageLoop::kHighResolutionTimerModeLeaseTimeMs));
 
   // Post a slow task to disable the high resolution timers.
   loop.PostDelayedTask(FROM_HERE, Bind(&PostNTasksThenQuit, 1),
                        kSlowTimer);
   loop.Run();
-  EXPECT_FALSE(loop.high_resolution_timers_enabled());
+  EXPECT_FALSE(loop.IsHishResolutionTimersEnabledForTest());
 }
 
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 
 namespace {
 
 class QuitDelegate : public MessageLoopForIO::Watcher {
  public:
@@ skipping 175 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