jingle: Use base::MessageLoop.

jingle/glue/fake_socket_factory.cc

 // Copyright (c) 2011 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 "jingle/glue/fake_socket_factory.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "jingle/glue/utils.h"
 #include "third_party/libjingle/source/talk/base/asyncsocket.h"
@@ skipping 97 matching lines @@
     // We should always be able to convert address here because we
     // don't expect IPv6 address on IPv4 connections.
     NOTREACHED();
     return;
   }
 
   SignalReadPacket(this, &data[0], data.size(), address);
 }
 
 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,
       base::Bind(&FakeSocketManager::DeliverPacket, this, from, to, data));
 }
 
 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);
   if (it == endpoints_.end()) {
     LOG(WARNING) << "Dropping packet with unknown destination: "
                  << to.ToString();
     return;
   }
   it->second->DeliverPacket(from, data);
 }
 
 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());
 }
 
 FakeSocketFactory::FakeSocketFactory(FakeSocketManager* socket_manager,
                                      const net::IPAddressNumber& address)
     : socket_manager_(socket_manager),
       address_(address),
       last_allocated_port_(0) {
 }
@@ skipping 21 matching lines @@
     const talk_base::SocketAddress& local_address,
     const talk_base::SocketAddress& remote_address,
     const talk_base::ProxyInfo& proxy_info, const std::string& user_agent,
     bool ssl) {
   // TODO(sergeyu): Implement fake TCP sockets.
   NOTIMPLEMENTED();
   return NULL;
 }
 
 }  // namespace jingle_glue