chrome: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/test/chromedriver/net/websocket_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "chrome/test/chromedriver/net/test_http_server.h"
 #include "chrome/test/chromedriver/net/websocket.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
 
 void OnConnectFinished(base::RunLoop* run_loop, int* save_error, int error) {
   *save_error = error;
   run_loop->Quit();
 }
 
 void RunPending(base::MessageLoop* loop) {
   base::RunLoop run_loop;
-  loop->PostTask(FROM_HERE, run_loop.QuitClosure());
+  loop->task_runner()->PostTask(FROM_HERE, run_loop.QuitClosure());
   run_loop.Run();
 }
 
 class Listener : public WebSocketListener {
  public:
   explicit Listener(const std::vector<std::string>& messages)
       : messages_(messages) {}
 
   ~Listener() override { EXPECT_TRUE(messages_.empty()); }
 
@@ skipping 40 matching lines @@
 
   void TearDown() override { server_.Stop(); }
 
  protected:
   scoped_ptr<WebSocket> CreateWebSocket(const GURL& url,
                                         WebSocketListener* listener) {
     int error;
     scoped_ptr<WebSocket> sock(new WebSocket(url, listener));
     base::RunLoop run_loop;
     sock->Connect(base::Bind(&OnConnectFinished, &run_loop, &error));
-    loop_.PostDelayedTask(
-        FROM_HERE, run_loop.QuitClosure(),
-        base::TimeDelta::FromSeconds(10));
+    loop_.task_runner()->PostDelayedTask(FROM_HERE, run_loop.QuitClosure(),
+                                         base::TimeDelta::FromSeconds(10));
     run_loop.Run();
     if (error == net::OK)
       return sock.Pass();
     return scoped_ptr<WebSocket>();
   }
 
   scoped_ptr<WebSocket> CreateConnectedWebSocket(WebSocketListener* listener) {
     return CreateWebSocket(server_.web_socket_url(), listener);
   }
 
   void SendReceive(const std::vector<std::string>& messages) {
     Listener listener(messages);
     scoped_ptr<WebSocket> sock(CreateConnectedWebSocket(&listener));
     ASSERT_TRUE(sock);
     for (size_t i = 0; i < messages.size(); ++i) {
       ASSERT_TRUE(sock->Send(messages[i]));
     }
     base::RunLoop run_loop;
-    loop_.PostDelayedTask(
-        FROM_HERE, run_loop.QuitClosure(),
-        base::TimeDelta::FromSeconds(10));
+    loop_.task_runner()->PostDelayedTask(FROM_HERE, run_loop.QuitClosure(),
+                                         base::TimeDelta::FromSeconds(10));
     run_loop.Run();
   }
 
   base::MessageLoopForIO loop_;
   TestHttpServer server_;
 };
 
 }  // namespace
 
 TEST_F(WebSocketTest, CreateDestroy) {
@@ skipping 27 matching lines @@
   ASSERT_FALSE(CreateWebSocket(server_.web_socket_url(), &listener));
 }
 
 TEST_F(WebSocketTest, CloseOnReceive) {
   server_.SetMessageAction(TestHttpServer::kCloseOnMessage);
   base::RunLoop run_loop;
   CloseListener listener(&run_loop);
   scoped_ptr<WebSocket> sock(CreateConnectedWebSocket(&listener));
   ASSERT_TRUE(sock);
   ASSERT_TRUE(sock->Send("hi"));
-  loop_.PostDelayedTask(
-      FROM_HERE, run_loop.QuitClosure(),
-      base::TimeDelta::FromSeconds(10));
+  loop_.task_runner()->PostDelayedTask(FROM_HERE, run_loop.QuitClosure(),
+                                       base::TimeDelta::FromSeconds(10));
   run_loop.Run();
 }
 
 TEST_F(WebSocketTest, CloseOnSend) {
   base::RunLoop run_loop;
   CloseListener listener(&run_loop);
   scoped_ptr<WebSocket> sock(CreateConnectedWebSocket(&listener));
   ASSERT_TRUE(sock);
   server_.Stop();
 
   sock->Send("hi");
-  loop_.PostDelayedTask(
-      FROM_HERE, run_loop.QuitClosure(),
-      base::TimeDelta::FromSeconds(10));
+  loop_.task_runner()->PostDelayedTask(FROM_HERE, run_loop.QuitClosure(),
+                                       base::TimeDelta::FromSeconds(10));
   run_loop.Run();
   ASSERT_FALSE(sock->Send("hi"));
 }
 
 TEST_F(WebSocketTest, SendReceive) {
   std::vector<std::string> messages;
   messages.push_back("hello");
   SendReceive(messages);
 }
 
 TEST_F(WebSocketTest, SendReceiveLarge) {
   std::vector<std::string> messages;
   messages.push_back(std::string(10 << 20, 'a'));
   SendReceive(messages);
 }
 
 TEST_F(WebSocketTest, SendReceiveMultiple) {
   std::vector<std::string> messages;
   messages.push_back("1");
   messages.push_back("2");
   messages.push_back("3");
   SendReceive(messages);
 }