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

device/serial/serial_io_handler_win.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_win.h"
 
 #include <windows.h>
 #include <setupapi.h>
 
 #include "base/bind.h"
@@ skipping 31 matching lines @@
       // If the bitrate doesn't match that of one of the standard
       // index constants, it may be provided as-is to the DCB
       // structure, according to MSDN.
       return bitrate;
   }
 #undef BITRATE_TO_SPEED_CASE
 }
 
 int DataBitsEnumToConstant(serial::DataBits data_bits) {
   switch (data_bits) {
-    case serial::DATA_BITS_SEVEN:
+    case serial::DataBits::SEVEN:
       return 7;
-    case serial::DATA_BITS_EIGHT:
+    case serial::DataBits::EIGHT:
     default:
       return 8;
   }
 }
 
 int ParityBitEnumToConstant(serial::ParityBit parity_bit) {
   switch (parity_bit) {
-    case serial::PARITY_BIT_EVEN:
+    case serial::ParityBit::EVEN:
       return EVENPARITY;
-    case serial::PARITY_BIT_ODD:
+    case serial::ParityBit::ODD:
       return ODDPARITY;
-    case serial::PARITY_BIT_NO:
+    case serial::ParityBit::NO:
     default:
       return NOPARITY;
   }
 }
 
 int StopBitsEnumToConstant(serial::StopBits stop_bits) {
   switch (stop_bits) {
-    case serial::STOP_BITS_TWO:
+    case serial::StopBits::TWO:
       return TWOSTOPBITS;
-    case serial::STOP_BITS_ONE:
+    case serial::StopBits::ONE:
     default:
       return ONESTOPBIT;
   }
 }
 
 int SpeedConstantToBitrate(int speed) {
 #define SPEED_TO_BITRATE_CASE(x) \
   case CBR_##x:                  \
     return x;
   switch (speed) {
@@ skipping 16 matching lines @@
       // it should be an integral baud rate, according to
       // MSDN.
       return speed;
   }
 #undef SPEED_TO_BITRATE_CASE
 }
 
 serial::DataBits DataBitsConstantToEnum(int data_bits) {
   switch (data_bits) {
     case 7:
-      return serial::DATA_BITS_SEVEN;
+      return serial::DataBits::SEVEN;
     case 8:
     default:
-      return serial::DATA_BITS_EIGHT;
+      return serial::DataBits::EIGHT;
   }
 }
 
 serial::ParityBit ParityBitConstantToEnum(int parity_bit) {
   switch (parity_bit) {
     case EVENPARITY:
-      return serial::PARITY_BIT_EVEN;
+      return serial::ParityBit::EVEN;
     case ODDPARITY:
-      return serial::PARITY_BIT_ODD;
+      return serial::ParityBit::ODD;
     case NOPARITY:
     default:
-      return serial::PARITY_BIT_NO;
+      return serial::ParityBit::NO;
   }
 }
 
 serial::StopBits StopBitsConstantToEnum(int stop_bits) {
   switch (stop_bits) {
     case TWOSTOPBITS:
-      return serial::STOP_BITS_TWO;
+      return serial::StopBits::TWO;
     case ONESTOPBIT:
     default:
-      return serial::STOP_BITS_ONE;
+      return serial::StopBits::ONE;
   }
 }
 
 // Searches for the COM port in the device's friendly name, assigns its value to
 // com_port, and returns whether the operation was successful.
 bool GetCOMPort(const std::string friendly_name, std::string* com_port) {
   return RE2::PartialMatch(friendly_name, ".* \\((COM[0-9]+)\\)", com_port);
 }
 
 }  // namespace
@@ skipping 71 matching lines @@
     return;
   }
 
   std::string com_port;
   if (!GetCOMPort(friendly_name, &com_port)) {
     DVPLOG(1) << "Failed to get port name from \"" << friendly_name << "\".";
     return;
   }
 
   if (port() == com_port)
-    CancelRead(serial::RECEIVE_ERROR_DEVICE_LOST);
+    CancelRead(serial::ReceiveError::DEVICE_LOST);
 }
 
 bool SerialIoHandlerWin::PostOpen() {
   DCHECK(!comm_context_);
   DCHECK(!read_context_);
   DCHECK(!write_context_);
 
   base::MessageLoopForIO::current()->RegisterIOHandler(file().GetPlatformFile(),
                                                        this);
 
@@ skipping 37 matching lines @@
 
   if (!SetCommMask(file().GetPlatformFile(), EV_RXCHAR)) {
     VPLOG(1) << "Failed to set serial event flags";
   }
 
   event_mask_ = 0;
   BOOL ok = ::WaitCommEvent(
       file().GetPlatformFile(), &event_mask_, &comm_context_->overlapped);
   if (!ok && GetLastError() != ERROR_IO_PENDING) {
     VPLOG(1) << "Failed to receive serial event";
-    QueueReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
+    QueueReadCompleted(0, serial::ReceiveError::SYSTEM_ERROR);
   }
   is_comm_pending_ = true;
 }
 
 void SerialIoHandlerWin::WriteImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(pending_write_buffer());
   DCHECK(file().IsValid());
 
   BOOL ok = ::WriteFile(file().GetPlatformFile(),
                         pending_write_buffer(),
                         pending_write_buffer_len(),
                         NULL,
                         &write_context_->overlapped);
   if (!ok && GetLastError() != ERROR_IO_PENDING) {
     VPLOG(1) << "Write failed";
-    QueueWriteCompleted(0, serial::SEND_ERROR_SYSTEM_ERROR);
+    QueueWriteCompleted(0, serial::SendError::SYSTEM_ERROR);
   }
 }
 
 void SerialIoHandlerWin::CancelReadImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(file().IsValid());
   ::CancelIo(file().GetPlatformFile());
 }
 
 void SerialIoHandlerWin::CancelWriteImpl() {
@@ skipping 16 matching lines @@
   config.fAbortOnError = TRUE;
   config.fOutxDsrFlow = FALSE;
   config.fDtrControl = DTR_CONTROL_ENABLE;
   config.fDsrSensitivity = FALSE;
   config.fOutX = FALSE;
   config.fInX = FALSE;
 
   DCHECK(options().bitrate);
   config.BaudRate = BitrateToSpeedConstant(options().bitrate);
 
-  DCHECK(options().data_bits != serial::DATA_BITS_NONE);
+  DCHECK(options().data_bits != serial::DataBits::NONE);
   config.ByteSize = DataBitsEnumToConstant(options().data_bits);
 
-  DCHECK(options().parity_bit != serial::PARITY_BIT_NONE);
+  DCHECK(options().parity_bit != serial::ParityBit::NONE);
   config.Parity = ParityBitEnumToConstant(options().parity_bit);
 
-  DCHECK(options().stop_bits != serial::STOP_BITS_NONE);
+  DCHECK(options().stop_bits != serial::StopBits::NONE);
   config.StopBits = StopBitsEnumToConstant(options().stop_bits);
 
   DCHECK(options().has_cts_flow_control);
   if (options().cts_flow_control) {
     config.fOutxCtsFlow = TRUE;
     config.fRtsControl = RTS_CONTROL_HANDSHAKE;
   } else {
     config.fOutxCtsFlow = FALSE;
     config.fRtsControl = RTS_CONTROL_ENABLE;
   }
@@ skipping 22 matching lines @@
     base::MessageLoopForIO::IOContext* context,
     DWORD bytes_transferred,
     DWORD error) {
   DCHECK(CalledOnValidThread());
   if (context == comm_context_.get()) {
     DWORD errors;
     COMSTAT status;
     if (!ClearCommError(file().GetPlatformFile(), &errors, &status) ||
         errors != 0) {
       if (errors & CE_BREAK) {
-        ReadCompleted(0, serial::RECEIVE_ERROR_BREAK);
+        ReadCompleted(0, serial::ReceiveError::BREAK);
       } else if (errors & CE_FRAME) {
-        ReadCompleted(0, serial::RECEIVE_ERROR_FRAME_ERROR);
+        ReadCompleted(0, serial::ReceiveError::FRAME_ERROR);
       } else if (errors & CE_OVERRUN) {
-        ReadCompleted(0, serial::RECEIVE_ERROR_OVERRUN);
+        ReadCompleted(0, serial::ReceiveError::OVERRUN);
       } else if (errors & CE_RXOVER) {
-        ReadCompleted(0, serial::RECEIVE_ERROR_BUFFER_OVERFLOW);
+        ReadCompleted(0, serial::ReceiveError::BUFFER_OVERFLOW);
       } else if (errors & CE_RXPARITY) {
-        ReadCompleted(0, serial::RECEIVE_ERROR_PARITY_ERROR);
+        ReadCompleted(0, serial::ReceiveError::PARITY_ERROR);
       } else {
-        ReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
+        ReadCompleted(0, serial::ReceiveError::SYSTEM_ERROR);
       }
       return;
     }
 
     if (read_canceled()) {
       ReadCompleted(bytes_transferred, read_cancel_reason());
     } else if (error != ERROR_SUCCESS && error != ERROR_OPERATION_ABORTED) {
-      ReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
+      ReadCompleted(0, serial::ReceiveError::SYSTEM_ERROR);
     } else if (pending_read_buffer()) {
       BOOL ok = ::ReadFile(file().GetPlatformFile(),
                            pending_read_buffer(),
                            pending_read_buffer_len(),
                            NULL,
                            &read_context_->overlapped);
       if (!ok && GetLastError() != ERROR_IO_PENDING) {
         VPLOG(1) << "Read failed";
-        ReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
+        ReadCompleted(0, serial::ReceiveError::SYSTEM_ERROR);
       }
     }
   } else if (context == read_context_.get()) {
     if (read_canceled()) {
       ReadCompleted(bytes_transferred, read_cancel_reason());
     } else if (error != ERROR_SUCCESS && error != ERROR_OPERATION_ABORTED) {
-      ReadCompleted(0, serial::RECEIVE_ERROR_SYSTEM_ERROR);
+      ReadCompleted(0, serial::ReceiveError::SYSTEM_ERROR);
     } else {
       ReadCompleted(bytes_transferred,
                     error == ERROR_SUCCESS
-                        ? serial::RECEIVE_ERROR_NONE
-                        : serial::RECEIVE_ERROR_SYSTEM_ERROR);
+                        ? serial::ReceiveError::NONE
+                        : serial::ReceiveError::SYSTEM_ERROR);
     }
   } else if (context == write_context_.get()) {
     DCHECK(pending_write_buffer());
     if (write_canceled()) {
       WriteCompleted(0, write_cancel_reason());
     } else if (error != ERROR_SUCCESS && error != ERROR_OPERATION_ABORTED) {
-      WriteCompleted(0, serial::SEND_ERROR_SYSTEM_ERROR);
+      WriteCompleted(0, serial::SendError::SYSTEM_ERROR);
       if (error == ERROR_GEN_FAILURE && IsReadPending()) {
         // For devices using drivers such as FTDI, CP2xxx, when device is
         // disconnected, the context is comm_context_ and the error is
         // ERROR_OPERATION_ABORTED.
         // However, for devices using CDC-ACM driver, when device is
         // disconnected, the context is write_context_ and the error is
         // ERROR_GEN_FAILURE. In this situation, in addition to a write error
         // signal, also need to generate a read error signal
         // serial::OnReceiveError which will notify the app about the
         // disconnection.
-        CancelRead(serial::RECEIVE_ERROR_SYSTEM_ERROR);
+        CancelRead(serial::ReceiveError::SYSTEM_ERROR);
       }
     } else {
-      WriteCompleted(bytes_transferred,
-                     error == ERROR_SUCCESS ? serial::SEND_ERROR_NONE
-                                            : serial::SEND_ERROR_SYSTEM_ERROR);
+      WriteCompleted(bytes_transferred, error == ERROR_SUCCESS
+                                            ? serial::SendError::NONE
+                                            : serial::SendError::SYSTEM_ERROR);
     }
   } else {
     NOTREACHED() << "Invalid IOContext";
   }
 }
 
 bool SerialIoHandlerWin::Flush() const {
   if (!PurgeComm(file().GetPlatformFile(), PURGE_RXCLEAR | PURGE_TXCLEAR)) {
     VPLOG(1) << "Failed to flush serial port";
     return false;
@@ skipping 70 matching lines @@
 std::string SerialIoHandler::MaybeFixUpPortName(const std::string& port_name) {
   // For COM numbers less than 9, CreateFile is called with a string such as
   // "COM1". For numbers greater than 9, a prefix of "\\\\.\\" must be added.
   if (port_name.length() > std::string("COM9").length())
     return std::string("\\\\.\\").append(port_name);
 
   return port_name;
 }
 
 }  // namespace device