remoting: Use base::MessageLoop.

remoting/protocol/buffered_socket_writer_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 "remoting/protocol/buffered_socket_writer.h"
 
 #include <stdlib.h>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
@@ skipping 11 matching lines @@
 const size_t kWriteChunkSize = 1024U;
 }  // namespace
 
 class BufferedSocketWriterTest : public testing::Test {
  public:
   BufferedSocketWriterTest()
       : write_error_(0) {
   }
 
   void OnDone() {
-    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::MessageLoop::QuitClosure());
   }
 
   void DestroyWriterAndQuit() {
     written_data_ = socket_->written_data();
     writer_.reset();
     socket_.reset();
-    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::MessageLoop::QuitClosure());
   }
 
   void Unexpected() {
     EXPECT_TRUE(false);
   }
 
  protected:
   virtual void SetUp() OVERRIDE {
     socket_.reset(new FakeSocket());
     writer_.reset(new BufferedSocketWriter());
@@ skipping 37 matching lines @@
     ASSERT_EQ(static_cast<size_t>(test_buffer_->size() +
                                   test_buffer_2_->size()),
               socket_->written_data().size());
     EXPECT_EQ(0, memcmp(test_buffer_->data(), socket_->written_data().data(),
                         test_buffer_->size()));
     EXPECT_EQ(0, memcmp(test_buffer_2_->data(),
                         socket_->written_data().data() + test_buffer_->size(),
                         test_buffer_2_->size()));
   }
 
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
   scoped_ptr<FakeSocket> socket_;
   scoped_ptr<BufferedSocketWriter> writer_;
   scoped_refptr<net::IOBufferWithSize> test_buffer_;
   scoped_refptr<net::IOBufferWithSize> test_buffer_2_;
   std::string written_data_;
   int write_error_;
 };
 
 // Test synchronous write.
 TEST_F(BufferedSocketWriterTest, WriteFull) {
@@ skipping 69 matching lines @@
   socket_->set_next_write_error(net::ERR_FAILED);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(net::ERR_FAILED, write_error_);
   EXPECT_EQ(static_cast<size_t>(test_buffer_->size()),
             socket_->written_data().size());
 }
 
 }  // namespace protocol
 }  // namespace remoting