jingle: Use base::MessageLoop.

jingle/glue/chrome_async_socket.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 "jingle/glue/chrome_async_socket.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <cstring>
 
@@ skipping 99 matching lines @@
       resolving_client_socket_factory_->CreateTransportClientSocket(
           dest_host_port_pair));
   int status = transport_socket_->Connect(
       base::Bind(&ChromeAsyncSocket::ProcessConnectDone,
                  weak_ptr_factory_.GetWeakPtr()));
   if (status != net::ERR_IO_PENDING) {
     // We defer execution of ProcessConnectDone instead of calling it
     // 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,
         base::Bind(&ChromeAsyncSocket::ProcessConnectDone,
                    weak_ptr_factory_.GetWeakPtr(), status));
   }
   return true;
 }
 
 // STATE_CONNECTING -> STATE_OPEN
@@ skipping 16 matching lines @@
   SignalConnected();
 }
 
 // read_state_ == IDLE -> read_state_ == POSTED
 
 void ChromeAsyncSocket::PostDoRead() {
   DCHECK(IsOpen());
   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,
       base::Bind(&ChromeAsyncSocket::DoRead,
                  weak_ptr_factory_.GetWeakPtr()));
   read_state_ = POSTED;
 }
 
 // read_state_ == POSTED -> read_state_ == PENDING
 
@@ skipping 113 matching lines @@
   }
   return true;
 }
 
 // write_state_ == IDLE -> write_state_ == POSTED
 
 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,
       base::Bind(&ChromeAsyncSocket::DoWrite,
                  weak_ptr_factory_.GetWeakPtr()));
   write_state_ = POSTED;
 }
 
 // write_state_ == POSTED -> write_state_ == PENDING
 
@@ skipping 103 matching lines @@
   scoped_ptr<net::ClientSocketHandle> socket_handle(
       new net::ClientSocketHandle());
   socket_handle->set_socket(transport_socket_.release());
   transport_socket_.reset(
       resolving_client_socket_factory_->CreateSSLClientSocket(
           socket_handle.release(), net::HostPortPair(domain_name, 443)));
   int status = transport_socket_->Connect(
       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,
         base::Bind(&ChromeAsyncSocket::ProcessSSLConnectDone,
                    weak_ptr_factory_.GetWeakPtr(), status));
   }
   return true;
 }
 
 // STATE_TLS_CONNECTING -> STATE_TLS_OPEN
@@ skipping 15 matching lines @@
   }
   state_ = STATE_TLS_OPEN;
   PostDoRead();
   if (write_end_ > 0U) {
     PostDoWrite();
   }
   SignalSSLConnected();
 }
 
 }  // namespace jingle_glue