Remove calls to deprecated MessageLoop methods in jingle.

jingle/glue/chrome_async_socket.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/chrome_async_socket.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <cstdlib>
 #include <cstring>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "jingle/glue/resolving_client_socket_factory.h"
 #include "net/base/address_list.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/ssl/ssl_config_service.h"
 #include "third_party/webrtc/base/socketaddress.h"
 
@@ skipping 83 matching lines @@
       resolving_client_socket_factory_->CreateTransportClientSocket(
           dest_host_port_pair);
   int status = transport_socket_->Connect(
       base::Bind(&ChromeAsyncSocket::ProcessConnectDone,
                  weak_ptr_factory_.GetWeakPtr()));
   if (status != net::ERR_IO_PENDING) {
     // We defer execution of ProcessConnectDone instead of calling it
     // directly here as the caller may not expect an error/close to
     // happen here.  This is okay, as from the caller's point of view,
     // the connect always happens asynchronously.
-    base::MessageLoop* message_loop = base::MessageLoop::current();
-    CHECK(message_loop);
-    message_loop->PostTask(
-        FROM_HERE,
-        base::Bind(&ChromeAsyncSocket::ProcessConnectDone,
-                   weak_ptr_factory_.GetWeakPtr(), status));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&ChromeAsyncSocket::ProcessConnectDone,
+                              weak_ptr_factory_.GetWeakPtr(), status));
   }
   return true;
 }
 
 // STATE_CONNECTING -> STATE_OPEN
 // read_state_ == IDLE -> read_state_ == POSTED (via PostDoRead())
 
 void ChromeAsyncSocket::ProcessConnectDone(int status) {
   DCHECK_NE(status, net::ERR_IO_PENDING);
   DCHECK_EQ(read_state_, IDLE);
@@ skipping 11 matching lines @@
   SignalConnected();
 }
 
 // read_state_ == IDLE -> read_state_ == POSTED
 
 void ChromeAsyncSocket::PostDoRead() {
   DCHECK(IsOpen());
   DCHECK_EQ(read_state_, IDLE);
   DCHECK_EQ(read_start_, 0U);
   DCHECK_EQ(read_end_, 0U);
-  base::MessageLoop* message_loop = base::MessageLoop::current();
-  CHECK(message_loop);
-  message_loop->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(&ChromeAsyncSocket::DoRead,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::Bind(&ChromeAsyncSocket::DoRead, weak_ptr_factory_.GetWeakPtr()));
   read_state_ = POSTED;
 }
 
 // read_state_ == POSTED -> read_state_ == PENDING
 
 void ChromeAsyncSocket::DoRead() {
   DCHECK(IsOpen());
   DCHECK_EQ(read_state_, POSTED);
   DCHECK_EQ(read_start_, 0U);
   DCHECK_EQ(read_end_, 0U);
@@ skipping 108 matching lines @@
   }
   return true;
 }
 
 // write_state_ == IDLE -> write_state_ == POSTED
 
 void ChromeAsyncSocket::PostDoWrite() {
   DCHECK(IsOpen());
   DCHECK_EQ(write_state_, IDLE);
   DCHECK_GT(write_end_, 0U);
-  base::MessageLoop* message_loop = base::MessageLoop::current();
-  CHECK(message_loop);
-  message_loop->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(&ChromeAsyncSocket::DoWrite,
-                 weak_ptr_factory_.GetWeakPtr()));
+      base::Bind(&ChromeAsyncSocket::DoWrite, weak_ptr_factory_.GetWeakPtr()));
   write_state_ = POSTED;
 }
 
 // write_state_ == POSTED -> write_state_ == PENDING
 
 void ChromeAsyncSocket::DoWrite() {
   DCHECK(IsOpen());
   DCHECK_EQ(write_state_, POSTED);
   DCHECK_GT(write_end_, 0U);
   // Once we call Write(), we cannot call StartTls() until the write
@@ skipping 97 matching lines @@
   DCHECK(transport_socket_.get());
   std::unique_ptr<net::ClientSocketHandle> socket_handle(
       new net::ClientSocketHandle());
   socket_handle->SetSocket(std::move(transport_socket_));
   transport_socket_ = resolving_client_socket_factory_->CreateSSLClientSocket(
       std::move(socket_handle), net::HostPortPair(domain_name, 443));
   int status = transport_socket_->Connect(
       base::Bind(&ChromeAsyncSocket::ProcessSSLConnectDone,
                  weak_ptr_factory_.GetWeakPtr()));
   if (status != net::ERR_IO_PENDING) {
-    base::MessageLoop* message_loop = base::MessageLoop::current();
-    CHECK(message_loop);
-    message_loop->PostTask(
-        FROM_HERE,
-        base::Bind(&ChromeAsyncSocket::ProcessSSLConnectDone,
-                   weak_ptr_factory_.GetWeakPtr(), status));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&ChromeAsyncSocket::ProcessSSLConnectDone,
+                              weak_ptr_factory_.GetWeakPtr(), status));
   }
   return true;
 }
 
 // STATE_TLS_CONNECTING -> STATE_TLS_OPEN
 // read_state_ == IDLE -> read_state_ == POSTED (via PostDoRead())
 // (maybe) write_state_ == IDLE -> write_state_ == POSTED (via
 // PostDoWrite())
 
 void ChromeAsyncSocket::ProcessSSLConnectDone(int status) {
@@ skipping 10 matching lines @@
   }
   state_ = STATE_TLS_OPEN;
   PostDoRead();
   if (write_end_ > 0U) {
     PostDoWrite();
   }
   SignalSSLConnected();
 }
 
 }  // namespace jingle_glue