[device] Replace MessageLoopProxy usage with ThreadTaskRunnerHandle

device/serial/serial_io_handler.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 "device/serial/serial_io_handler.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 
 namespace device {
 
 SerialIoHandler::SerialIoHandler(
-    scoped_refptr<base::MessageLoopProxy> file_thread_message_loop,
-    scoped_refptr<base::MessageLoopProxy> ui_thread_message_loop)
+    scoped_refptr<base::SingleThreadTaskRunner> file_thread_message_loop,
+    scoped_refptr<base::SingleThreadTaskRunner> ui_thread_message_loop)
     : file_thread_message_loop_(file_thread_message_loop),
       ui_thread_message_loop_(ui_thread_message_loop) {
   options_.bitrate = 9600;
   options_.data_bits = serial::DATA_BITS_EIGHT;
   options_.parity_bit = serial::PARITY_BIT_NO;
   options_.stop_bits = serial::STOP_BITS_ONE;
   options_.cts_flow_control = false;
   options_.has_cts_flow_control = true;
 }
 
 SerialIoHandler::~SerialIoHandler() {
   DCHECK(CalledOnValidThread());
   Close();
 }
 
 void SerialIoHandler::Open(const std::string& port,
                            const serial::ConnectionOptions& options,
                            const OpenCompleteCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(open_complete_.is_null());
   open_complete_ = callback;
   DCHECK(file_thread_message_loop_.get());
   DCHECK(ui_thread_message_loop_.get());
   MergeConnectionOptions(options);
   RequestAccess(port, file_thread_message_loop_, ui_thread_message_loop_);
 }
 
 void SerialIoHandler::RequestAccess(
     const std::string& port,
-    scoped_refptr<base::MessageLoopProxy> file_message_loop,
-    scoped_refptr<base::MessageLoopProxy> ui_message_loop) {
+    scoped_refptr<base::SingleThreadTaskRunner> file_message_loop,
+    scoped_refptr<base::SingleThreadTaskRunner> ui_message_loop) {
   OnRequestAccessComplete(port, true /* success */);
 }
 
 void SerialIoHandler::OnRequestAccessComplete(const std::string& port,
                                               bool success) {
   DCHECK(CalledOnValidThread());
   if (success) {
     DCHECK(file_thread_message_loop_.get());
     file_thread_message_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&SerialIoHandler::StartOpen,
-                   this,
-                   port,
-                   base::MessageLoopProxy::current()));
+        FROM_HERE, base::Bind(&SerialIoHandler::StartOpen, this, port,
+                              base::ThreadTaskRunnerHandle::Get()));
     return;
   } else {
     DCHECK(!open_complete_.is_null());
     OpenCompleteCallback callback = open_complete_;
     open_complete_.Reset();
     callback.Run(false);
     return;
   }
 }
 
@@ skipping 12 matching lines @@
     options_.stop_bits = options.stop_bits;
   }
   if (options.has_cts_flow_control) {
     DCHECK(options_.has_cts_flow_control);
     options_.cts_flow_control = options.cts_flow_control;
   }
 }
 
 void SerialIoHandler::StartOpen(
     const std::string& port,
-    scoped_refptr<base::MessageLoopProxy> io_message_loop) {
+    scoped_refptr<base::SingleThreadTaskRunner> io_message_loop) {
   DCHECK(!open_complete_.is_null());
   DCHECK(file_thread_message_loop_->RunsTasksOnCurrentThread());
   DCHECK(!file_.IsValid());
   // It's the responsibility of the API wrapper around SerialIoHandler to
   // validate the supplied path against the set of valid port names, and
   // it is a reasonable assumption that serial port names are ASCII.
   DCHECK(base::IsStringASCII(port));
   base::FilePath path(base::FilePath::FromUTF8Unsafe(MaybeFixUpPortName(port)));
   int flags = base::File::FLAG_OPEN | base::File::FLAG_READ |
               base::File::FLAG_EXCLUSIVE_READ | base::File::FLAG_WRITE |
@@ skipping 131 matching lines @@
 }
 
 void SerialIoHandler::QueueWriteCompleted(int bytes_written,
                                           serial::SendError error) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&SerialIoHandler::WriteCompleted, this, bytes_written, error));
 }
 
 }  // namespace device