Change mojo enums to be scoped enums in the generated C++ bindings.

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 181 matching lines @@
 #elif defined(OS_MACOSX)
     // cfsetispeed and cfsetospeed sometimes work for custom baud rates on OS
     // X but the IOSSIOSPEED ioctl is more reliable but has to be done after
     // the rest of the port parameters are set or else it will be overwritten.
     need_iossiospeed = true;
 #else
     return false;
 #endif
   }
 
-  DCHECK(options().data_bits != serial::DATA_BITS_NONE);
+  DCHECK(options().data_bits != serial::DataBits::NONE);
   config.c_cflag &= ~CSIZE;
   switch (options().data_bits) {
-    case serial::DATA_BITS_SEVEN:
+    case serial::DataBits::SEVEN:
       config.c_cflag |= CS7;
       break;
-    case serial::DATA_BITS_EIGHT:
+    case serial::DataBits::EIGHT:
     default:
       config.c_cflag |= CS8;
       break;
   }
 
-  DCHECK(options().parity_bit != serial::PARITY_BIT_NONE);
+  DCHECK(options().parity_bit != serial::ParityBit::NONE);
   switch (options().parity_bit) {
-    case serial::PARITY_BIT_EVEN:
+    case serial::ParityBit::EVEN:
       config.c_cflag |= PARENB;
       config.c_cflag &= ~PARODD;
       break;
-    case serial::PARITY_BIT_ODD:
+    case serial::ParityBit::ODD:
       config.c_cflag |= (PARODD | PARENB);
       break;
-    case serial::PARITY_BIT_NO:
+    case serial::ParityBit::NO:
     default:
       config.c_cflag &= ~(PARODD | PARENB);
       break;
   }
 
   error_detect_state_ = ErrorDetectState::NO_ERROR;
   num_chars_stashed_ = 0;
 
   if (config.c_cflag & PARENB) {
     config.c_iflag &= ~IGNPAR;
     config.c_iflag |= INPCK;
     parity_check_enabled_ = true;
   } else {
     config.c_iflag |= IGNPAR;
     config.c_iflag &= ~INPCK;
     parity_check_enabled_ = false;
   }
 
-  DCHECK(options().stop_bits != serial::STOP_BITS_NONE);
+  DCHECK(options().stop_bits != serial::StopBits::NONE);
   switch (options().stop_bits) {
-    case serial::STOP_BITS_TWO:
+    case serial::StopBits::TWO:
       config.c_cflag |= CSTOPB;
       break;
-    case serial::STOP_BITS_ONE:
+    case serial::StopBits::ONE:
     default:
       config.c_cflag &= ~CSTOPB;
       break;
   }
 
   DCHECK(options().has_cts_flow_control);
   if (options().cts_flow_control) {
     config.c_cflag |= CRTSCTS;
   } else {
     config.c_cflag &= ~CRTSCTS;
@@ skipping 35 matching lines @@
 void SerialIoHandlerPosix::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(fd, file().GetPlatformFile());
 
   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 == ENXIO) {
-        ReadCompleted(0, serial::RECEIVE_ERROR_DEVICE_LOST);
+        ReadCompleted(0, serial::ReceiveError::DEVICE_LOST);
       } else {
-        ReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
+        ReadCompleted(0, serial::ReceiveError::SYSTEM_ERROR);
       }
     } else if (bytes_read == 0) {
-      ReadCompleted(0, serial::RECEIVE_ERROR_DEVICE_LOST);
+      ReadCompleted(0, serial::ReceiveError::DEVICE_LOST);
     } else {
       bool break_detected = false;
       bool parity_error_detected = false;
       int new_bytes_read =
           CheckReceiveError(pending_read_buffer(), pending_read_buffer_len(),
                             bytes_read, break_detected, parity_error_detected);
 
       if (break_detected) {
-        ReadCompleted(new_bytes_read, serial::RECEIVE_ERROR_BREAK);
+        ReadCompleted(new_bytes_read, serial::ReceiveError::BREAK);
       } else if (parity_error_detected) {
-        ReadCompleted(new_bytes_read, serial::RECEIVE_ERROR_PARITY_ERROR);
+        ReadCompleted(new_bytes_read, serial::ReceiveError::PARITY_ERROR);
       } else {
-        ReadCompleted(new_bytes_read, serial::RECEIVE_ERROR_NONE);
+        ReadCompleted(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();
   }
 }
 
 void SerialIoHandlerPosix::OnFileCanWriteWithoutBlocking(int fd) {
   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::SEND_ERROR_SYSTEM_ERROR);
+      WriteCompleted(0, serial::SendError::SYSTEM_ERROR);
     } else {
-      WriteCompleted(bytes_written, serial::SEND_ERROR_NONE);
+      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();
   }
 }
 
 void SerialIoHandlerPosix::EnsureWatchingReads() {
@@ skipping 102 matching lines @@
     int bitrate = 0;
     if (SpeedConstantToBitrate(ispeed, &bitrate)) {
       info->bitrate = bitrate;
     } else if (ispeed > 0) {
       info->bitrate = static_cast<int>(ispeed);
     }
   }
 #endif
 
   if ((config.c_cflag & CSIZE) == CS7) {
-    info->data_bits = serial::DATA_BITS_SEVEN;
+    info->data_bits = serial::DataBits::SEVEN;
   } else if ((config.c_cflag & CSIZE) == CS8) {
-    info->data_bits = serial::DATA_BITS_EIGHT;
+    info->data_bits = serial::DataBits::EIGHT;
   } else {
-    info->data_bits = serial::DATA_BITS_NONE;
+    info->data_bits = serial::DataBits::NONE;
   }
   if (config.c_cflag & PARENB) {
-    info->parity_bit = (config.c_cflag & PARODD) ? serial::PARITY_BIT_ODD
-                                                 : serial::PARITY_BIT_EVEN;
+    info->parity_bit = (config.c_cflag & PARODD) ? serial::ParityBit::ODD
+                                                 : serial::ParityBit::EVEN;
   } else {
-    info->parity_bit = serial::PARITY_BIT_NO;
+    info->parity_bit = serial::ParityBit::NO;
   }
   info->stop_bits =
-      (config.c_cflag & CSTOPB) ? serial::STOP_BITS_TWO : serial::STOP_BITS_ONE;
+      (config.c_cflag & CSTOPB) ? serial::StopBits::TWO : serial::StopBits::ONE;
   info->cts_flow_control = (config.c_cflag & CRTSCTS) != 0;
   return info;
 }
 
 bool SerialIoHandlerPosix::SetBreak() {
   if (ioctl(file().GetPlatformFile(), TIOCSBRK, 0) != 0) {
     VPLOG(1) << "Failed to set break";
     return false;
   }
 
@@ skipping 122 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