Revert of base: Remove use of MessageLoopProxy

base/async_socket_io_handler_unittest.cc

 // Copyright 2013 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 "base/async_socket_io_handler.h"
 
 #include "base/bind.h"
-#include "base/location.h"
-#include "base/single_thread_task_runner.h"
-#include "base/thread_task_runner_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 const char kAsyncSocketIoTestString[] = "Hello, AsyncSocketIoHandler";
 const size_t kAsyncSocketIoTestStringLength =
     arraysize(kAsyncSocketIoTestString);
 
 class TestSocketReader {
  public:
   // Set |number_of_reads_before_quit| to >0 when you expect a specific number
@@ skipping 79 matching lines @@
 // won't trip us off and that the synchronous case works as well.
 TEST(AsyncSocketIoHandlerTest, SynchronousReadWithMessageLoop) {
   base::MessageLoopForIO loop;
 
   base::CancelableSyncSocket pair[2];
   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));
 
   TestSocketReader reader(&pair[0], -1, false, false);
 
   pair[1].Send(kAsyncSocketIoTestString, kAsyncSocketIoTestStringLength);
-  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::MessageLoop::QuitClosure(),
+  base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
+      base::MessageLoop::QuitClosure(),
       base::TimeDelta::FromMilliseconds(100));
   base::MessageLoop::current()->Run();
 
   EXPECT_TRUE(reader.IssueRead());
   EXPECT_EQ(strcmp(reader.buffer(), kAsyncSocketIoTestString), 0);
   // We've now verified that the read happened synchronously, but it's not
   // guaranteed that the callback has been issued since the callback will be
   // called asynchronously even though the read may have been done.
   // So we call RunUntilIdle() to allow any event notifications or APC's on
   // Windows, to execute before checking the count of how many callbacks we've
   // received.
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1, reader.callbacks_received());
 }
 
 // Calls Read() from within a callback to test that simple read "loops" work.
 TEST(AsyncSocketIoHandlerTest, ReadFromCallback) {
   base::MessageLoopForIO loop;
 
   base::CancelableSyncSocket pair[2];
   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));
 
   const int kReadOperationCount = 10;
   TestSocketReader reader(&pair[0], kReadOperationCount, true, false);
   EXPECT_TRUE(reader.IssueRead());
 
   // Issue sends on an interval to satisfy the Read() requirements.
   int64 milliseconds = 0;
   for (int i = 0; i < kReadOperationCount; ++i) {
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE, base::Bind(&SendData, &pair[1], kAsyncSocketIoTestString,
-                              kAsyncSocketIoTestStringLength),
+    base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
+        base::Bind(&SendData, &pair[1], kAsyncSocketIoTestString,
+            kAsyncSocketIoTestStringLength),
         base::TimeDelta::FromMilliseconds(milliseconds));
     milliseconds += 10;
   }
 
-  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, base::MessageLoop::QuitClosure(),
+  base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
+      base::MessageLoop::QuitClosure(),
       base::TimeDelta::FromMilliseconds(100 + milliseconds));
 
   base::MessageLoop::current()->Run();
   EXPECT_EQ(kReadOperationCount, reader.callbacks_received());
 }
 
 // Calls Read() then close other end, check that a correct callback is received.
 TEST(AsyncSocketIoHandlerTest, ReadThenClose) {
   base::MessageLoopForIO loop;
 
   base::CancelableSyncSocket pair[2];
   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));
 
   const int kReadOperationCount = 1;
   TestSocketReader reader(&pair[0], kReadOperationCount, false, true);
   EXPECT_TRUE(reader.IssueRead());
 
   pair[1].Close();
 
   base::MessageLoop::current()->Run();
   EXPECT_EQ(kReadOperationCount, reader.callbacks_received());
 }