Use FileDescriptorWatcher in SerialIoHandlerPosix.

device/serial/serial_io_handler_posix.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_posix.h"
 
 #include <sys/ioctl.h>
 #include <termios.h>
 
 #include "base/posix/eintr_wrapper.h"
@@ skipping 122 matching lines @@
 void SerialIoHandlerPosix::WriteImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(pending_write_buffer());
   DCHECK(file().IsValid());
 
   EnsureWatchingWrites();
 }
 
 void SerialIoHandlerPosix::CancelReadImpl() {
   DCHECK(CalledOnValidThread());
-  is_watching_reads_ = false;
-  file_read_watcher_.StopWatchingFileDescriptor();
+  file_read_watcher_.reset();
   QueueReadCompleted(0, read_cancel_reason());
 }
 
 void SerialIoHandlerPosix::CancelWriteImpl() {
   DCHECK(CalledOnValidThread());
-  is_watching_writes_ = false;
-  file_write_watcher_.StopWatchingFileDescriptor();
+  file_write_watcher_.reset();
   QueueWriteCompleted(0, write_cancel_reason());
 }
 
 bool SerialIoHandlerPosix::ConfigurePortImpl() {
 #if defined(OS_LINUX)
   struct termios2 config;
   if (ioctl(file().GetPlatformFile(), TCGETS2, &config) < 0) {
 #else
   struct termios config;
   if (tcgetattr(file().GetPlatformFile(), &config) != 0) {
@@ skipping 117 matching lines @@
     }
   }
 #endif
 
   return true;
 }
 
 SerialIoHandlerPosix::SerialIoHandlerPosix(
     scoped_refptr<base::SingleThreadTaskRunner> file_thread_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner)
-    : SerialIoHandler(file_thread_task_runner, ui_thread_task_runner),
-      is_watching_reads_(false),
-      is_watching_writes_(false) {
-}
+    : SerialIoHandler(file_thread_task_runner, ui_thread_task_runner) {}
 
 SerialIoHandlerPosix::~SerialIoHandlerPosix() {
 }
 
-void SerialIoHandlerPosix::OnFileCanReadWithoutBlocking(int fd) {
+void SerialIoHandlerPosix::AttemptRead(bool within_read) {
   DCHECK(CalledOnValidThread());
-  DCHECK_EQ(fd, file().GetPlatformFile());
 
-  AttemptRead(false);
-}
-
-bool SerialIoHandlerPosix::AttemptRead(bool within_read) {
   if (pending_read_buffer()) {
     int bytes_read = HANDLE_EINTR(read(file().GetPlatformFile(),
                                        pending_read_buffer(),
                                        pending_read_buffer_len()));
     if (bytes_read < 0) {
       if (errno == EAGAIN) {
         // The fd does not have data to read yet so continue waiting.
         EnsureWatchingReads();
       } else if (errno == ENXIO) {
         RunReadCompleted(within_read, 0, serial::ReceiveError::DEVICE_LOST);
@@ skipping 16 matching lines @@
         RunReadCompleted(within_read, new_bytes_read,
                          serial::ReceiveError::PARITY_ERROR);
       } else {
         RunReadCompleted(within_read, new_bytes_read,
                          serial::ReceiveError::NONE);
       }
     }
   } else {
     // Stop watching the fd if we get notifications with no pending
     // reads or writes to avoid starving the message loop.
-    is_watching_reads_ = false;
-    file_read_watcher_.StopWatchingFileDescriptor();
+    file_read_watcher_.reset();
   }
-
-  return true;
 }
 
 void SerialIoHandlerPosix::RunReadCompleted(bool within_read,
                                             int bytes_read,
                                             serial::ReceiveError error) {
   if (within_read) {
     // Stop watching the fd to avoid more reads until the queued ReadCompleted()
     // completes and releases the pending_read_buffer.
-    is_watching_reads_ = false;
-    file_read_watcher_.StopWatchingFileDescriptor();
+    file_read_watcher_.reset();
 
     QueueReadCompleted(bytes_read, error);
   } else {
     ReadCompleted(bytes_read, error);
   }
 }
 
-void SerialIoHandlerPosix::OnFileCanWriteWithoutBlocking(int fd) {
+void SerialIoHandlerPosix::OnFileCanWriteWithoutBlocking() {
   DCHECK(CalledOnValidThread());
-  DCHECK_EQ(fd, file().GetPlatformFile());
 
   if (pending_write_buffer()) {
     int bytes_written = HANDLE_EINTR(write(file().GetPlatformFile(),
                                            pending_write_buffer(),
                                            pending_write_buffer_len()));
     if (bytes_written < 0) {
       WriteCompleted(0, serial::SendError::SYSTEM_ERROR);
     } else {
       WriteCompleted(bytes_written, serial::SendError::NONE);
     }
   } else {
     // Stop watching the fd if we get notifications with no pending
     // writes to avoid starving the message loop.
-    is_watching_writes_ = false;
-    file_write_watcher_.StopWatchingFileDescriptor();
+    file_write_watcher_.reset();
   }
 }
 
 void SerialIoHandlerPosix::EnsureWatchingReads() {
   DCHECK(CalledOnValidThread());
   DCHECK(file().IsValid());
-  if (!is_watching_reads_) {
-    is_watching_reads_ = base::MessageLoopForIO::current()->WatchFileDescriptor(
-        file().GetPlatformFile(),
-        true,
-        base::MessageLoopForIO::WATCH_READ,
-        &file_read_watcher_,
-        this);
+  if (!file_read_watcher_) {
+    file_read_watcher_ = base::FileDescriptorWatcher::WatchReadable(
+        file().GetPlatformFile(), base::Bind(&SerialIoHandlerPosix::AttemptRead,
+                                             base::Unretained(this), false));
   }
 }
 
 void SerialIoHandlerPosix::EnsureWatchingWrites() {
   DCHECK(CalledOnValidThread());
   DCHECK(file().IsValid());
-  if (!is_watching_writes_) {
-    is_watching_writes_ =
-        base::MessageLoopForIO::current()->WatchFileDescriptor(
-            file().GetPlatformFile(),
-            true,
-            base::MessageLoopForIO::WATCH_WRITE,
-            &file_write_watcher_,
-            this);
+  if (!file_write_watcher_) {
+    file_write_watcher_ = base::FileDescriptorWatcher::WatchWritable(
+        file().GetPlatformFile(),
+        base::Bind(&SerialIoHandlerPosix::OnFileCanWriteWithoutBlocking,
+                   base::Unretained(this)));
   }
 }
 
 bool SerialIoHandlerPosix::Flush() const {
   if (tcflush(file().GetPlatformFile(), TCIOFLUSH) != 0) {
     VPLOG(1) << "Failed to flush port";
     return false;
   }
   return true;
 }
@@ skipping 225 matching lines @@
   memcpy(buffer, chars_stashed_, std::min(new_bytes_read, 2));
   memcpy(chars_stashed_, tmp, num_chars_stashed_);
   return new_bytes_read;
 }
 
 std::string SerialIoHandler::MaybeFixUpPortName(const std::string& port_name) {
   return port_name;
 }
 
 }  // namespace device