[serial] Only add a watcher if if the immeidate read attempt fails.

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 105 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> ui_thread_task_runner) {
   return new SerialIoHandlerPosix(file_thread_task_runner,
                                   ui_thread_task_runner);
 }
 
 void SerialIoHandlerPosix::ReadImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(pending_read_buffer());
   DCHECK(file().IsValid());
 
-  EnsureWatchingReads();
-
   // Try to read immediately. This is needed because on some platforms
   // (e.g., OSX) there may not be a notification from the message loop
   // when the fd is ready to read immediately after it is opened. There
   // is no danger of blocking because the fd is opened with async flag.
   AttemptRead(true);
 }
 
 void SerialIoHandlerPosix::WriteImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(pending_write_buffer());
@@ skipping 158 matching lines @@
 SerialIoHandlerPosix::~SerialIoHandlerPosix() {
 }
 
 void SerialIoHandlerPosix::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(fd, file().GetPlatformFile());
 
   AttemptRead(false);
 }
 
-void SerialIoHandlerPosix::AttemptRead(bool within_read) {
+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.
-        return;
+        EnsureWatchingReads();
       } else if (errno == ENXIO) {
         RunReadCompleted(within_read, 0, serial::ReceiveError::DEVICE_LOST);
       } else {
         RunReadCompleted(within_read, 0, serial::ReceiveError::SYSTEM_ERROR);
       }
     } else if (bytes_read == 0) {
       RunReadCompleted(within_read, 0, serial::ReceiveError::DEVICE_LOST);
     } else {
       bool break_detected = false;
       bool parity_error_detected = false;
@@ skipping 11 matching lines @@
         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();
   }
+
+  return true;
 }
 
 void SerialIoHandlerPosix::RunReadCompleted(bool within_read,
                                             int bytes_read,
                                             serial::ReceiveError error) {
   if (within_read)
     QueueReadCompleted(bytes_read, error);
   else
     ReadCompleted(bytes_read, error);
 }
@@ skipping 281 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