Remove use of deprecated MessageLoop methods in extensions.

extensions/browser/api/cast_channel/cast_transport.cc

 // Copyright 2014 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 "extensions/browser/api/cast_channel/cast_transport.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
-#include "base/message_loop/message_loop.h"
+#include "base/location.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "extensions/browser/api/cast_channel/cast_framer.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/api/cast_channel/logger.h"
 #include "extensions/browser/api/cast_channel/logger_util.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket.h"
 
 #define VLOG_WITH_CONNECTION(level)                                           \
   VLOG(level) << "[" << ip_endpoint_.ToString() << ", auth=" << channel_auth_ \
@@ skipping 121 matching lines @@
   DCHECK(delegate);
   delegate_ = std::move(delegate);
   if (started_) {
     delegate_->Start();
   }
 }
 
 void CastTransportImpl::FlushWriteQueue() {
   for (; !write_queue_.empty(); write_queue_.pop()) {
     net::CompletionCallback& callback = write_queue_.front().callback;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, net::ERR_FAILED));
     callback.Reset();
   }
 }
 
 void CastTransportImpl::SendMessage(const CastMessage& message,
                                     const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   std::string serialized_message;
   if (!MessageFramer::Serialize(message, &serialized_message)) {
     logger_->LogSocketEventForMessage(channel_id_, proto::SEND_MESSAGE_FAILED,
                                       message.namespace_(),
                                       "Error when serializing message.");
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, net::ERR_FAILED));
     return;
   }
   WriteRequest write_request(
       message.namespace_(), serialized_message, callback);
 
   write_queue_.push(write_request);
   logger_->LogSocketEventForMessage(
       channel_id_, proto::MESSAGE_ENQUEUED, message.namespace_(),
       base::StringPrintf("Queue size: %" PRIuS, write_queue_.size()));
@@ skipping 134 matching lines @@
 
 int CastTransportImpl::DoWriteCallback() {
   VLOG_WITH_CONNECTION(2) << "DoWriteCallback";
   DCHECK(!write_queue_.empty());
 
   WriteRequest& request = write_queue_.front();
   int bytes_consumed = request.io_buffer->BytesConsumed();
   logger_->LogSocketEventForMessage(
       channel_id_, proto::MESSAGE_WRITTEN, request.message_namespace,
       base::StringPrintf("Bytes: %d", bytes_consumed));
-  base::MessageLoop::current()->PostTask(FROM_HERE,
-                                         base::Bind(&base::DoNothing));
-  base::MessageLoop::current()->PostTask(FROM_HERE,
-                                         base::Bind(request.callback, net::OK));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                base::Bind(&base::DoNothing));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(request.callback, net::OK));
 
   write_queue_.pop();
   if (write_queue_.empty()) {
     SetWriteState(WRITE_STATE_IDLE);
   } else {
     SetWriteState(WRITE_STATE_WRITE);
   }
 
   return net::OK;
 }
@@ skipping 126 matching lines @@
   VLOG_WITH_CONNECTION(2) << "DoReadHandleError";
   DCHECK_NE(CHANNEL_ERROR_NONE, error_state_);
   DCHECK_LE(result, 0);
   SetReadState(READ_STATE_ERROR);
   return net::ERR_FAILED;
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions