jingle: Use base::MessageLoop.

BUG=236029
R=ajwong@chromium.org

Review URL: https://chromiumcodereview.appspot.com/14307021

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@196960 0039d316-1c4b-4281-b951-d872f2087c98

22 files changed, 58 insertions, 58 deletions

diff --git a/jingle/glue/channel_socket_adapter.cc b/jingle/glue/channel_socket_adapter.cc
index b68a5fbc..72b45a3 100644
--- a/jingle/glue/channel_socket_adapter.cc
+++ b/jingle/glue/channel_socket_adapter.cc
@@ -17,7 +17,7 @@ namespace jingle_glue {
 
 TransportChannelSocketAdapter::TransportChannelSocketAdapter(
     cricket::TransportChannel* channel)
-    : message_loop_(MessageLoop::current()),
+    : message_loop_(base::MessageLoop::current()),
       channel_(channel),
       closed_error_code_(net::OK) {
   DCHECK(channel_);
@@ -44,7 +44,7 @@ int TransportChannelSocketAdapter::Read(
     net::IOBuffer* buf,
     int buffer_size,
     const net::CompletionCallback& callback) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   DCHECK(buf);
   DCHECK(!callback.is_null());
   CHECK(read_callback_.is_null());
@@ -65,7 +65,7 @@ int TransportChannelSocketAdapter::Write(
     net::IOBuffer* buffer,
     int buffer_size,
     const net::CompletionCallback& callback) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   DCHECK(buffer);
   DCHECK(!callback.is_null());
   CHECK(write_callback_.is_null());
@@ -99,17 +99,17 @@ int TransportChannelSocketAdapter::Write(
 }
 
 bool TransportChannelSocketAdapter::SetReceiveBufferSize(int32 size) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   return channel_->SetOption(talk_base::Socket::OPT_RCVBUF, size) == 0;
 }
 
 bool TransportChannelSocketAdapter::SetSendBufferSize(int32 size) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   return channel_->SetOption(talk_base::Socket::OPT_SNDBUF, size) == 0;
 }
 
 void TransportChannelSocketAdapter::Close(int error_code) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   if (!channel_)  // Already closed.
     return;
@@ -140,7 +140,7 @@ void TransportChannelSocketAdapter::OnNewPacket(
     const char* data,
     size_t data_size,
     int flags) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   DCHECK_EQ(channel, channel_);
   if (!read_callback_.is_null()) {
     DCHECK(read_buffer_);
@@ -167,7 +167,7 @@ void TransportChannelSocketAdapter::OnNewPacket(
 
 void TransportChannelSocketAdapter::OnWritableState(
     cricket::TransportChannel* channel) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   // Try to send the packet if there is a pending write.
   if (!write_callback_.is_null()) {
     int result = channel_->SendPacket(write_buffer_->data(),
@@ -186,7 +186,7 @@ void TransportChannelSocketAdapter::OnWritableState(
 
 void TransportChannelSocketAdapter::OnChannelDestroyed(
     cricket::TransportChannel* channel) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   DCHECK_EQ(channel, channel_);
   Close(net::ERR_CONNECTION_ABORTED);
 }
diff --git a/jingle/glue/channel_socket_adapter_unittest.cc b/jingle/glue/channel_socket_adapter_unittest.cc
index e0ed566..a71b372 100644
--- a/jingle/glue/channel_socket_adapter_unittest.cc
+++ b/jingle/glue/channel_socket_adapter_unittest.cc
@@ -61,7 +61,7 @@ class TransportChannelSocketAdapterTest : public testing::Test {
   scoped_ptr<TransportChannelSocketAdapter> target_;
   net::CompletionCallback callback_;
   int callback_result_;
-  MessageLoopForIO message_loop_;
+  base::MessageLoopForIO message_loop_;
 };
 
 // Verify that Read() returns net::ERR_IO_PENDING.
diff --git a/jingle/glue/chrome_async_socket.cc b/jingle/glue/chrome_async_socket.cc
index b92972f..fb75143 100644
--- a/jingle/glue/chrome_async_socket.cc
+++ b/jingle/glue/chrome_async_socket.cc
@@ -117,7 +117,7 @@ bool ChromeAsyncSocket::Connect(const talk_base::SocketAddress& address) {
     // directly here as the caller may not expect an error/close to
     // happen here.  This is okay, as from the caller's point of view,
     // the connect always happens asynchronously.
-    MessageLoop* message_loop = MessageLoop::current();
+    base::MessageLoop* message_loop = base::MessageLoop::current();
     CHECK(message_loop);
     message_loop->PostTask(
         FROM_HERE,
@@ -154,7 +154,7 @@ void ChromeAsyncSocket::PostDoRead() {
   DCHECK_EQ(read_state_, IDLE);
   DCHECK_EQ(read_start_, 0U);
   DCHECK_EQ(read_end_, 0U);
-  MessageLoop* message_loop = MessageLoop::current();
+  base::MessageLoop* message_loop = base::MessageLoop::current();
   CHECK(message_loop);
   message_loop->PostTask(
       FROM_HERE,
@@ -288,7 +288,7 @@ void ChromeAsyncSocket::PostDoWrite() {
   DCHECK(IsOpen());
   DCHECK_EQ(write_state_, IDLE);
   DCHECK_GT(write_end_, 0U);
-  MessageLoop* message_loop = MessageLoop::current();
+  base::MessageLoop* message_loop = base::MessageLoop::current();
   CHECK(message_loop);
   message_loop->PostTask(
       FROM_HERE,
@@ -412,7 +412,7 @@ bool ChromeAsyncSocket::StartTls(const std::string& domain_name) {
       base::Bind(&ChromeAsyncSocket::ProcessSSLConnectDone,
                  weak_ptr_factory_.GetWeakPtr()));
   if (status != net::ERR_IO_PENDING) {
-    MessageLoop* message_loop = MessageLoop::current();
+    base::MessageLoop* message_loop = base::MessageLoop::current();
     CHECK(message_loop);
     message_loop->PostTask(
         FROM_HERE,
diff --git a/jingle/glue/chrome_async_socket_unittest.cc b/jingle/glue/chrome_async_socket_unittest.cc
index 1775a6d..a6f1487 100644
--- a/jingle/glue/chrome_async_socket_unittest.cc
+++ b/jingle/glue/chrome_async_socket_unittest.cc
@@ -411,7 +411,7 @@ class ChromeAsyncSocketTest
   }
 
   // ChromeAsyncSocket expects a message loop.
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 
   AsyncSocketDataProvider async_socket_data_provider_;
   net::SSLSocketDataProvider ssl_socket_data_provider_;
diff --git a/jingle/glue/fake_network_manager.cc b/jingle/glue/fake_network_manager.cc
index 3a3e0f0..6b03487 100644
--- a/jingle/glue/fake_network_manager.cc
+++ b/jingle/glue/fake_network_manager.cc
@@ -29,9 +29,10 @@ FakeNetworkManager::~FakeNetworkManager() {
 
 void FakeNetworkManager::StartUpdating() {
   started_ = true;
-  MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&FakeNetworkManager::SendNetworksChangedSignal,
-                            weak_factory_.GetWeakPtr()));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&FakeNetworkManager::SendNetworksChangedSignal,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void FakeNetworkManager::StopUpdating() {
diff --git a/jingle/glue/fake_socket_factory.cc b/jingle/glue/fake_socket_factory.cc
index f6812b3..2347bef 100644
--- a/jingle/glue/fake_socket_factory.cc
+++ b/jingle/glue/fake_socket_factory.cc
@@ -115,15 +115,14 @@ void FakeUDPPacketSocket::DeliverPacket(const net::IPEndPoint& from,
 }
 
 FakeSocketManager::FakeSocketManager()
-    : message_loop_(MessageLoop::current()) {
-}
+    : message_loop_(base::MessageLoop::current()) {}
 
 FakeSocketManager::~FakeSocketManager() { }
 
 void FakeSocketManager::SendPacket(const net::IPEndPoint& from,
                                    const net::IPEndPoint& to,
                                    const std::vector<char>& data) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   message_loop_->PostTask(
       FROM_HERE,
@@ -133,7 +132,7 @@ void FakeSocketManager::SendPacket(const net::IPEndPoint& from,
 void FakeSocketManager::DeliverPacket(const net::IPEndPoint& from,
                                       const net::IPEndPoint& to,
                                       const std::vector<char>& data) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   std::map<net::IPEndPoint, FakeUDPPacketSocket*>::iterator it =
       endpoints_.find(to);
@@ -146,13 +145,13 @@ void FakeSocketManager::DeliverPacket(const net::IPEndPoint& from,
 }
 
 void FakeSocketManager::AddSocket(FakeUDPPacketSocket* socket_factory) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   endpoints_[socket_factory->endpoint()] = socket_factory;
 }
 
 void FakeSocketManager::RemoveSocket(FakeUDPPacketSocket* socket_factory) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   endpoints_.erase(socket_factory->endpoint());
 }
diff --git a/jingle/glue/fake_ssl_client_socket_unittest.cc b/jingle/glue/fake_ssl_client_socket_unittest.cc
index 97cb3bb..6b87a17 100644
--- a/jingle/glue/fake_ssl_client_socket_unittest.cc
+++ b/jingle/glue/fake_ssl_client_socket_unittest.cc
@@ -261,7 +261,7 @@ class FakeSSLClientSocketTest : public testing::Test {
   }
 
   // MockTCPClientSocket needs a message loop.
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 
   net::MockClientSocketFactory mock_client_socket_factory_;
   scoped_ptr<net::StaticSocketDataProvider> static_socket_data_provider_;
diff --git a/jingle/glue/proxy_resolving_client_socket.cc b/jingle/glue/proxy_resolving_client_socket.cc
index 07c404e..8bc423b 100644
--- a/jingle/glue/proxy_resolving_client_socket.cc
+++ b/jingle/glue/proxy_resolving_client_socket.cc
@@ -138,7 +138,7 @@ int ProxyResolvingClientSocket::Connect(
     // We defer execution of ProcessProxyResolveDone instead of calling it
     // directly here for simplicity. From the caller's point of view,
     // the connect always happens asynchronously.
-    MessageLoop* message_loop = MessageLoop::current();
+    base::MessageLoop* message_loop = base::MessageLoop::current();
     CHECK(message_loop);
     message_loop->PostTask(
         FROM_HERE,
@@ -284,7 +284,7 @@ int ProxyResolvingClientSocket::ReconsiderProxyAfterError(int error) {
   // In both cases we want to post ProcessProxyResolveDone (in the error case
   // we might still want to fall back a direct connection).
   if (rv != net::ERR_IO_PENDING) {
-    MessageLoop* message_loop = MessageLoop::current();
+    base::MessageLoop* message_loop = base::MessageLoop::current();
     CHECK(message_loop);
     message_loop->PostTask(
         FROM_HERE,
diff --git a/jingle/glue/proxy_resolving_client_socket_unittest.cc b/jingle/glue/proxy_resolving_client_socket_unittest.cc
index 834d7d24..9c09a46 100644
--- a/jingle/glue/proxy_resolving_client_socket_unittest.cc
+++ b/jingle/glue/proxy_resolving_client_socket_unittest.cc
@@ -48,7 +48,7 @@ class ProxyResolvingClientSocketTest : public testing::Test {
     message_loop_.RunUntilIdle();
   }
 
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
   scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
 };
 
diff --git a/jingle/glue/pseudotcp_adapter_unittest.cc b/jingle/glue/pseudotcp_adapter_unittest.cc
index 6cdb554..f7bcf4e 100644
--- a/jingle/glue/pseudotcp_adapter_unittest.cc
+++ b/jingle/glue/pseudotcp_adapter_unittest.cc
@@ -136,7 +136,7 @@ class FakeSocket : public net::Socket {
                     const net::CompletionCallback& callback) OVERRIDE {
     DCHECK(buf);
     if (peer_socket_) {
-      MessageLoop::current()->PostDelayedTask(
+      base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&FakeSocket::AppendInputPacket,
                      base::Unretained(peer_socket_),
@@ -170,7 +170,7 @@ class FakeSocket : public net::Socket {
 
 class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
  public:
-  TCPChannelTester(MessageLoop* message_loop,
+  TCPChannelTester(base::MessageLoop* message_loop,
                    net::Socket* client_socket,
                    net::Socket* host_socket)
       : message_loop_(message_loop),
@@ -178,8 +178,7 @@ class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
         client_socket_(client_socket),
         done_(false),
         write_errors_(0),
-        read_errors_(0) {
-  }
+        read_errors_(0) {}
 
   void Start() {
     message_loop_->PostTask(
@@ -204,7 +203,7 @@ class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
 
   void Done() {
     done_ = true;
-    message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+    message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
   }
 
   void DoStart() {
@@ -288,7 +287,7 @@ class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
  private:
   friend class base::RefCountedThreadSafe<TCPChannelTester>;
 
-  MessageLoop* message_loop_;
+  base::MessageLoop* message_loop_;
   net::Socket* host_socket_;
   net::Socket* client_socket_;
   bool done_;
@@ -320,7 +319,7 @@ class PseudoTcpAdapterTest : public testing::Test {
 
   scoped_ptr<PseudoTcpAdapter> host_pseudotcp_;
   scoped_ptr<PseudoTcpAdapter> client_pseudotcp_;
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 };
 
 TEST_F(PseudoTcpAdapterTest, DataTransfer) {
@@ -383,14 +382,14 @@ TEST_F(PseudoTcpAdapterTest, LimitedChannel) {
 
 class DeleteOnConnected {
  public:
-  DeleteOnConnected(MessageLoop* message_loop,
+  DeleteOnConnected(base::MessageLoop* message_loop,
                     scoped_ptr<PseudoTcpAdapter>* adapter)
       : message_loop_(message_loop), adapter_(adapter) {}
   void OnConnected(int error) {
     adapter_->reset();
-    message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+    message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
   }
-  MessageLoop* message_loop_;
+  base::MessageLoop* message_loop_;
   scoped_ptr<PseudoTcpAdapter>* adapter_;
 };
 
diff --git a/jingle/glue/task_pump.cc b/jingle/glue/task_pump.cc
index 3b67c9f..b016cd5 100644
--- a/jingle/glue/task_pump.cc
+++ b/jingle/glue/task_pump.cc
@@ -20,7 +20,7 @@ TaskPump::~TaskPump() {
 void TaskPump::WakeTasks() {
   DCHECK(CalledOnValidThread());
   if (!stopped_ && !posted_wake_) {
-    MessageLoop* current_message_loop = MessageLoop::current();
+    base::MessageLoop* current_message_loop = base::MessageLoop::current();
     CHECK(current_message_loop);
     // Do the requested wake up.
     current_message_loop->PostTask(
diff --git a/jingle/glue/task_pump_unittest.cc b/jingle/glue/task_pump_unittest.cc
index 614de1e..1fae050 100644
--- a/jingle/glue/task_pump_unittest.cc
+++ b/jingle/glue/task_pump_unittest.cc
@@ -16,7 +16,7 @@ using ::testing::Return;
 
 class TaskPumpTest : public testing::Test {
  private:
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 };
 
 TEST_F(TaskPumpTest, Basic) {
@@ -28,7 +28,7 @@ TEST_F(TaskPumpTest, Basic) {
   EXPECT_CALL(*task, ProcessStart()).WillOnce(Return(TASK_STATE_DONE));
   task->Start();
 
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(TaskPumpTest, Stop) {
@@ -42,7 +42,7 @@ TEST_F(TaskPumpTest, Stop) {
   task->Start();
 
   task_pump.Stop();
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace
diff --git a/jingle/glue/thread_wrapper.cc b/jingle/glue/thread_wrapper.cc
index 3c0635f..f26bc3c 100644
--- a/jingle/glue/thread_wrapper.cc
+++ b/jingle/glue/thread_wrapper.cc
@@ -31,9 +31,9 @@ base::LazyInstance<base::ThreadLocalPointer<JingleThreadWrapper> >
 // static
 void JingleThreadWrapper::EnsureForCurrentMessageLoop() {
   if (JingleThreadWrapper::current() == NULL) {
-    MessageLoop* message_loop = MessageLoop::current();
-    g_jingle_thread_wrapper.Get().Set(new JingleThreadWrapper(
-        message_loop->message_loop_proxy()));
+    base::MessageLoop* message_loop = base::MessageLoop::current();
+    g_jingle_thread_wrapper.Get()
+        .Set(new JingleThreadWrapper(message_loop->message_loop_proxy()));
     message_loop->AddDestructionObserver(current());
   }
 
diff --git a/jingle/glue/thread_wrapper.h b/jingle/glue/thread_wrapper.h
index 3eb8488..a6916e9 100644
--- a/jingle/glue/thread_wrapper.h
+++ b/jingle/glue/thread_wrapper.h
@@ -27,9 +27,8 @@ namespace jingle_glue {
 // - Using JingleThreadWrapper() constructor. In this case the creating code
 //   must pass a valid task runner for the current thread and also delete the
 //   wrapper later.
-class JingleThreadWrapper
-    : public MessageLoop::DestructionObserver,
-      public talk_base::Thread {
+class JingleThreadWrapper : public base::MessageLoop::DestructionObserver,
+                            public talk_base::Thread {
  public:
   // Create JingleThreadWrapper for the current thread if it hasn't been created
   // yet. The thread wrapper is destroyed automatically when the current
diff --git a/jingle/glue/thread_wrapper_unittest.cc b/jingle/glue/thread_wrapper_unittest.cc
index a1716a9..70e5690 100644
--- a/jingle/glue/thread_wrapper_unittest.cc
+++ b/jingle/glue/thread_wrapper_unittest.cc
@@ -86,7 +86,7 @@ class ThreadWrapperTest : public testing::Test {
   }
 
   // ThreadWrapper destroyes itself when |message_loop_| is destroyed.
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
   talk_base::Thread* thread_;
   MockMessageHandler handler1_;
   MockMessageHandler handler2_;
@@ -148,7 +148,8 @@ TEST_F(ThreadWrapperTest, PostDelayed) {
       .WillOnce(DeleteMessageData());
 
   message_loop_.PostDelayedTask(
-      FROM_HERE, MessageLoop::QuitClosure(),
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
       base::TimeDelta::FromMilliseconds(kMaxTestDelay));
   message_loop_.Run();
 }
@@ -199,7 +200,8 @@ TEST_F(ThreadWrapperTest, ClearDelayed) {
       .WillOnce(DeleteMessageData());
 
   message_loop_.PostDelayedTask(
-      FROM_HERE, MessageLoop::QuitClosure(),
+      FROM_HERE,
+      base::MessageLoop::QuitClosure(),
       base::TimeDelta::FromMilliseconds(kMaxTestDelay));
   message_loop_.Run();
 }
diff --git a/jingle/notifier/base/weak_xmpp_client_unittest.cc b/jingle/notifier/base/weak_xmpp_client_unittest.cc
index d4d5043..b97f623 100644
--- a/jingle/notifier/base/weak_xmpp_client_unittest.cc
+++ b/jingle/notifier/base/weak_xmpp_client_unittest.cc
@@ -60,7 +60,7 @@ class WeakXmppClientTest : public testing::Test {
   }
 
   // Needed by TaskPump.
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 
   scoped_ptr<jingle_glue::TaskPump> task_pump_;
   MockXmppDelegate mock_xmpp_delegate_;
diff --git a/jingle/notifier/base/xmpp_connection.cc b/jingle/notifier/base/xmpp_connection.cc
index 603b474..2f926ec 100644
--- a/jingle/notifier/base/xmpp_connection.cc
+++ b/jingle/notifier/base/xmpp_connection.cc
@@ -80,7 +80,7 @@ XmppConnection::~XmppConnection() {
   DCHECK(CalledOnValidThread());
   ClearClient();
   task_pump_->Stop();
-  MessageLoop* current_message_loop = MessageLoop::current();
+  base::MessageLoop* current_message_loop = base::MessageLoop::current();
   CHECK(current_message_loop);
   // We do this because XmppConnection may get destroyed as a result
   // of a signal from XmppClient.  If we delete |task_pump_| here, bad
diff --git a/jingle/notifier/base/xmpp_connection_unittest.cc b/jingle/notifier/base/xmpp_connection_unittest.cc
index 686e949..3255fdc 100644
--- a/jingle/notifier/base/xmpp_connection_unittest.cc
+++ b/jingle/notifier/base/xmpp_connection_unittest.cc
@@ -86,7 +86,7 @@ class XmppConnectionTest : public testing::Test {
   }
 
   // Needed by XmppConnection.
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
   MockXmppConnectionDelegate mock_xmpp_connection_delegate_;
   scoped_ptr<MockPreXmppAuth> mock_pre_xmpp_auth_;
   scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
diff --git a/jingle/notifier/communicator/single_login_attempt_unittest.cc b/jingle/notifier/communicator/single_login_attempt_unittest.cc
index 4d009c2..fcfbe77 100644
--- a/jingle/notifier/communicator/single_login_attempt_unittest.cc
+++ b/jingle/notifier/communicator/single_login_attempt_unittest.cc
@@ -106,7 +106,7 @@ class SingleLoginAttemptTest : public ::testing::Test {
   }
 
  private:
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
   const LoginSettings login_settings_;
 
  protected:
diff --git a/jingle/notifier/listener/non_blocking_push_client_unittest.cc b/jingle/notifier/listener/non_blocking_push_client_unittest.cc
index fea26fe..46bb9b8 100644
--- a/jingle/notifier/listener/non_blocking_push_client_unittest.cc
+++ b/jingle/notifier/listener/non_blocking_push_client_unittest.cc
@@ -56,7 +56,7 @@ class NonBlockingPushClientTest : public testing::Test {
     return scoped_ptr<PushClient>(fake_push_client_);
   }
 
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
   FakePushClientObserver fake_observer_;
   scoped_ptr<NonBlockingPushClient> push_client_;
   // Owned by |push_client_|.
diff --git a/jingle/notifier/listener/push_client_unittest.cc b/jingle/notifier/listener/push_client_unittest.cc
index 44d4d98..d9677ae 100644
--- a/jingle/notifier/listener/push_client_unittest.cc
+++ b/jingle/notifier/listener/push_client_unittest.cc
@@ -29,7 +29,7 @@ class PushClientTest : public testing::Test {
   virtual ~PushClientTest() {}
 
   // The sockets created by the XMPP code expect an IO loop.
-  MessageLoopForIO message_loop_;
+  base::MessageLoopForIO message_loop_;
   NotifierOptions notifier_options_;
 };
 
diff --git a/jingle/notifier/listener/xmpp_push_client_unittest.cc b/jingle/notifier/listener/xmpp_push_client_unittest.cc
index 8d4c669..2e59ab2 100644
--- a/jingle/notifier/listener/xmpp_push_client_unittest.cc
+++ b/jingle/notifier/listener/xmpp_push_client_unittest.cc
@@ -53,7 +53,7 @@ class XmppPushClientTest : public testing::Test {
   }
 
   // The sockets created by the XMPP code expect an IO loop.
-  MessageLoopForIO message_loop_;
+  base::MessageLoopForIO message_loop_;
   NotifierOptions notifier_options_;
   StrictMock<MockObserver> mock_observer_;
   scoped_ptr<XmppPushClient> xmpp_push_client_;