jingle: Use base::MessageLoop.

jingle/glue/pseudotcp_adapter_unittest.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/pseudotcp_adapter.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 118 matching lines @@
       read_buffer_ = buf;
       read_buffer_size_ = buf_len;
       return net::ERR_IO_PENDING;
     }
   }
 
   virtual int Write(net::IOBuffer* buf, int buf_len,
                     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_),
                      std::vector<char>(buf->data(), buf->data() + buf_len)),
           base::TimeDelta::FromMilliseconds(latency_ms_));
     }
 
     return buf_len;
   }
 
@@ skipping 13 matching lines @@
 
   std::deque<std::vector<char> > incoming_packets_;
 
   FakeSocket* peer_socket_;
   RateLimiter* rate_limiter_;
   int latency_ms_;
 };
 
 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),
         host_socket_(host_socket),
         client_socket_(client_socket),
         done_(false),
         write_errors_(0),
-        read_errors_(0) {
-  }
+        read_errors_(0) {}
 
   void Start() {
     message_loop_->PostTask(
         FROM_HERE, base::Bind(&TCPChannelTester::DoStart, this));
   }
 
   void CheckResults() {
     EXPECT_EQ(0, write_errors_);
     EXPECT_EQ(0, read_errors_);
 
     ASSERT_EQ(kTestDataSize + kMessageSize, input_buffer_->capacity());
 
     output_buffer_->SetOffset(0);
     ASSERT_EQ(kTestDataSize, output_buffer_->size());
 
     EXPECT_EQ(0, memcmp(output_buffer_->data(),
                         input_buffer_->StartOfBuffer(), kTestDataSize));
   }
 
  protected:
   virtual ~TCPChannelTester() {}
 
   void Done() {
     done_ = true;
-    message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+    message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
   }
 
   void DoStart() {
     InitBuffers();
     DoRead();
     DoWrite();
   }
 
   void InitBuffers() {
     output_buffer_ = new net::DrainableIOBuffer(
@@ skipping 63 matching lines @@
       // Allocate memory for the next read.
       input_buffer_->SetCapacity(input_buffer_->capacity() + result);
       if (input_buffer_->capacity() == kTestDataSize + kMessageSize)
         Done();
     }
   }
 
  private:
   friend class base::RefCountedThreadSafe<TCPChannelTester>;
 
-  MessageLoop* message_loop_;
+  base::MessageLoop* message_loop_;
   net::Socket* host_socket_;
   net::Socket* client_socket_;
   bool done_;
 
   scoped_refptr<net::DrainableIOBuffer> output_buffer_;
   scoped_refptr<net::GrowableIOBuffer> input_buffer_;
 
   int write_errors_;
   int read_errors_;
 };
@@ skipping 11 matching lines @@
 
     host_pseudotcp_.reset(new PseudoTcpAdapter(host_socket_));
     client_pseudotcp_.reset(new PseudoTcpAdapter(client_socket_));
   }
 
   FakeSocket* host_socket_;
   FakeSocket* client_socket_;
 
   scoped_ptr<PseudoTcpAdapter> host_pseudotcp_;
   scoped_ptr<PseudoTcpAdapter> client_pseudotcp_;
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 };
 
 TEST_F(PseudoTcpAdapterTest, DataTransfer) {
   net::TestCompletionCallback host_connect_cb;
   net::TestCompletionCallback client_connect_cb;
 
   int rv1 = host_pseudotcp_->Connect(host_connect_cb.callback());
   int rv2 = client_pseudotcp_->Connect(client_connect_cb.callback());
 
   if (rv1 == net::ERR_IO_PENDING)
@@ skipping 42 matching lines @@
       new TCPChannelTester(&message_loop_, host_pseudotcp_.get(),
                            client_pseudotcp_.get());
 
   tester->Start();
   message_loop_.Run();
   tester->CheckResults();
 }
 
 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_;
 };
 
 TEST_F(PseudoTcpAdapterTest, DeleteOnConnected) {
   // This test verifies that deleting the adapter mid-callback doesn't lead
   // to deleted structures being touched as the stack unrolls, so the failure
   // mode is a crash rather than a normal test failure.
   net::TestCompletionCallback client_connect_cb;
   DeleteOnConnected host_delete(&message_loop_, &host_pseudotcp_);
 
@@ skipping 33 matching lines @@
                            client_pseudotcp_.get());
 
   tester->Start();
   message_loop_.Run();
   tester->CheckResults();
 }
 
 }  // namespace
 
 }  // namespace jingle_glue