Remove calls to deprecated MessageLoop methods in remoting.

remoting/protocol/pseudotcp_adapter_unittest.cc

 // Copyright 2015 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/pseudotcp_adapter.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "remoting/protocol/p2p_datagram_socket.h"
 #include "remoting/protocol/p2p_stream_socket.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 124 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(base::MessageLoop* message_loop,

[Sergey Ulanov, 2016/06/22 17:50:15]

nit: this can be replaced with scoped_refptr<base::SingleThreadTaskRunner>. But
feel free to keep it as is - I'll fix it later myself.

[fdoray, 2016/06/22 18:12:48]

Done. Might as well do it now.

[Sergey Ulanov, 2016/06/22 18:35:22]

Thanks!

                    P2PStreamSocket* client_socket,
                    P2PStreamSocket* host_socket)
       : message_loop_(message_loop),
         host_socket_(host_socket),
         client_socket_(client_socket),
         done_(false),
         write_errors_(0),
         read_errors_(0) {}
 
   void Start() {
-    message_loop_->PostTask(
+    message_loop_->task_runner()->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,
-                            base::MessageLoop::QuitWhenIdleClosure());
+    message_loop_->task_runner()->PostTask(
+        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }
 
   void DoStart() {
     InitBuffers();
     DoRead();
     DoWrite();
   }
 
   void InitBuffers() {
     output_buffer_ = new net::DrainableIOBuffer(
@@ skipping 120 matching lines @@
   if (rv2 == net::ERR_IO_PENDING)
     rv2 = client_connect_cb.WaitForResult();
   ASSERT_EQ(net::OK, rv1);
   ASSERT_EQ(net::OK, rv2);
 
   scoped_refptr<TCPChannelTester> tester =
       new TCPChannelTester(&message_loop_, host_pseudotcp_.get(),
                            client_pseudotcp_.get());
 
   tester->Start();
-  message_loop_.Run();
+  base::RunLoop().Run();
   tester->CheckResults();
 }
 
 TEST_F(PseudoTcpAdapterTest, LimitedChannel) {
   const int kLatencyMs = 20;
   const int kPacketsPerSecond = 400;
   const int kBurstPackets = 10;
 
   LeakyBucket host_limiter(kBurstPackets, kPacketsPerSecond);
   host_socket_->set_latency(kLatencyMs);
@@ skipping 14 matching lines @@
   if (rv2 == net::ERR_IO_PENDING)
     rv2 = client_connect_cb.WaitForResult();
   ASSERT_EQ(net::OK, rv1);
   ASSERT_EQ(net::OK, rv2);
 
   scoped_refptr<TCPChannelTester> tester =
       new TCPChannelTester(&message_loop_, host_pseudotcp_.get(),
                            client_pseudotcp_.get());
 
   tester->Start();
-  message_loop_.Run();
+  base::RunLoop().Run();
   tester->CheckResults();
 }
 
 class DeleteOnConnected {
  public:
   DeleteOnConnected(base::MessageLoop* message_loop,
                     std::unique_ptr<PseudoTcpAdapter>* adapter)
       : message_loop_(message_loop), adapter_(adapter) {}
   void OnConnected(int error) {
     adapter_->reset();
-    message_loop_->PostTask(FROM_HERE,
-                            base::MessageLoop::QuitWhenIdleClosure());
+    message_loop_->task_runner()->PostTask(
+        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }
   base::MessageLoop* message_loop_;
   std::unique_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_);
 
   host_pseudotcp_->Connect(base::Bind(&DeleteOnConnected::OnConnected,
                                       base::Unretained(&host_delete)));
   client_pseudotcp_->Connect(client_connect_cb.callback());
-  message_loop_.Run();
+  base::RunLoop().Run();
 
   ASSERT_EQ(NULL, host_pseudotcp_.get());
 }
 
 // Verify that we can send/receive data with the write-waits-for-send
 // flag set.
 TEST_F(PseudoTcpAdapterTest, WriteWaitsForSendLetsDataThrough) {
   net::TestCompletionCallback host_connect_cb;
   net::TestCompletionCallback client_connect_cb;
 
@@ skipping 12 matching lines @@
   if (rv2 == net::ERR_IO_PENDING)
     rv2 = client_connect_cb.WaitForResult();
   ASSERT_EQ(net::OK, rv1);
   ASSERT_EQ(net::OK, rv2);
 
   scoped_refptr<TCPChannelTester> tester =
       new TCPChannelTester(&message_loop_, host_pseudotcp_.get(),
                            client_pseudotcp_.get());
 
   tester->Start();
-  message_loop_.Run();
+  base::RunLoop().Run();
   tester->CheckResults();
 }
 
 }  // namespace
 
 }  // namespace protocol
 }  // namespace remoting