Convert SerialIoHandler to use Mojo types.

chrome/browser/extensions/api/serial/serial_io_handler_win.cc

 // Copyright 2013 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 <windows.h>
 
 #include "chrome/browser/extensions/api/serial/serial_io_handler_win.h"
 
 namespace extensions {
 
@@ skipping 20 matching lines @@
     BITRATE_TO_SPEED_CASE(256000);
     default:
       // 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(api::serial::DataBits data_bits) {
+int DataBitsEnumToConstant(device::DataBits data_bits) {
   switch (data_bits) {
-    case api::serial::DATA_BITS_SEVEN:
+    case device::DATA_BITS_SEVEN:
       return 7;
-    case api::serial::DATA_BITS_EIGHT:
+    case device::DATA_BITS_EIGHT:
     default:
       return 8;
   }
 }
 
-int ParityBitEnumToConstant(api::serial::ParityBit parity_bit) {
+int ParityBitEnumToConstant(device::ParityBit parity_bit) {
   switch (parity_bit) {
-    case api::serial::PARITY_BIT_EVEN:
+    case device::PARITY_BIT_EVEN:
       return EVENPARITY;
-    case api::serial::PARITY_BIT_ODD:
+    case device::PARITY_BIT_ODD:
       return SPACEPARITY;
-    case api::serial::PARITY_BIT_NO:
+    case device::PARITY_BIT_NO:
     default:
       return NOPARITY;
   }
 }
 
-int StopBitsEnumToConstant(api::serial::StopBits stop_bits) {
+int StopBitsEnumToConstant(device::StopBits stop_bits) {
   switch (stop_bits) {
-    case api::serial::STOP_BITS_TWO:
+    case device::STOP_BITS_TWO:
       return TWOSTOPBITS;
-    case api::serial::STOP_BITS_ONE:
+    case device::STOP_BITS_ONE:
     default:
       return ONESTOPBIT;
   }
 }
 
 int SpeedConstantToBitrate(int speed) {
 #define SPEED_TO_BITRATE_CASE(x) \
   case CBR_##x:                  \
     return x;
   switch (speed) {
@@ skipping 13 matching lines @@
     SPEED_TO_BITRATE_CASE(256000);
     default:
       // If it's not one of the standard index constants,
       // it should be an integral baud rate, according to
       // MSDN.
       return speed;
   }
 #undef SPEED_TO_BITRATE_CASE
 }
 
-api::serial::DataBits DataBitsConstantToEnum(int data_bits) {
+device::DataBits DataBitsConstantToEnum(int data_bits) {
   switch (data_bits) {
     case 7:
-      return api::serial::DATA_BITS_SEVEN;
+      return device::DATA_BITS_SEVEN;
     case 8:
     default:
-      return api::serial::DATA_BITS_EIGHT;
+      return device::DATA_BITS_EIGHT;
   }
 }
 
-api::serial::ParityBit ParityBitConstantToEnum(int parity_bit) {
+device::ParityBit ParityBitConstantToEnum(int parity_bit) {
   switch (parity_bit) {
     case EVENPARITY:
-      return api::serial::PARITY_BIT_EVEN;
+      return device::PARITY_BIT_EVEN;
     case ODDPARITY:
-      return api::serial::PARITY_BIT_ODD;
+      return device::PARITY_BIT_ODD;
     case NOPARITY:
     default:
-      return api::serial::PARITY_BIT_NO;
+      return device::PARITY_BIT_NO;
   }
 }
 
-api::serial::StopBits StopBitsConstantToEnum(int stop_bits) {
+device::StopBits StopBitsConstantToEnum(int stop_bits) {
   switch (stop_bits) {
     case TWOSTOPBITS:
-      return api::serial::STOP_BITS_TWO;
+      return device::STOP_BITS_TWO;
     case ONESTOPBIT:
     default:
-      return api::serial::STOP_BITS_ONE;
+      return device::STOP_BITS_ONE;
   }
 }
 
 }  // namespace
 
 // static
 scoped_refptr<SerialIoHandler> SerialIoHandler::Create() {
   return new SerialIoHandlerWin();
 }
 
@@ skipping 48 matching lines @@
 
 void SerialIoHandlerWin::ReadImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(pending_read_buffer());
   DCHECK(file().IsValid());
 
   DWORD errors;
   COMSTAT status;
   if (!ClearCommError(file().GetPlatformFile(), &errors, &status) ||
       errors != 0) {
-    QueueReadCompleted(0, api::serial::RECEIVE_ERROR_SYSTEM_ERROR);
+    QueueReadCompleted(0, device::RECEIVE_ERROR_SYSTEM_ERROR);
     return;
   }
 
   SetCommMask(file().GetPlatformFile(), EV_RXCHAR);
 
   event_mask_ = 0;
   BOOL ok = ::WaitCommEvent(
       file().GetPlatformFile(), &event_mask_, &comm_context_->overlapped);
   if (!ok && GetLastError() != ERROR_IO_PENDING) {
-    QueueReadCompleted(0, api::serial::RECEIVE_ERROR_SYSTEM_ERROR);
+    QueueReadCompleted(0, device::RECEIVE_ERROR_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()->data(),
                         pending_write_buffer_len(),
                         NULL,
                         &write_context_->overlapped);
   if (!ok && GetLastError() != ERROR_IO_PENDING) {
-    QueueWriteCompleted(0, api::serial::SEND_ERROR_SYSTEM_ERROR);
+    QueueWriteCompleted(0, device::SEND_ERROR_SYSTEM_ERROR);
   }
 }
 
 void SerialIoHandlerWin::CancelReadImpl() {
   DCHECK(CalledOnValidThread());
   DCHECK(file().IsValid());
   ::CancelIo(file().GetPlatformFile());
 }
 
 void SerialIoHandlerWin::CancelWriteImpl() {
@@ skipping 12 matching lines @@
 
 void SerialIoHandlerWin::OnIOCompleted(
     base::MessageLoopForIO::IOContext* context,
     DWORD bytes_transferred,
     DWORD error) {
   DCHECK(CalledOnValidThread());
   if (context == comm_context_) {
     if (read_canceled()) {
       ReadCompleted(bytes_transferred, read_cancel_reason());
     } else if (error != ERROR_SUCCESS && error != ERROR_OPERATION_ABORTED) {
-      ReadCompleted(0, api::serial::RECEIVE_ERROR_SYSTEM_ERROR);
+      ReadCompleted(0, device::RECEIVE_ERROR_SYSTEM_ERROR);
     } else if (pending_read_buffer()) {
       BOOL ok = ::ReadFile(file().GetPlatformFile(),
                            pending_read_buffer()->data(),
                            pending_read_buffer_len(),
                            NULL,
                            &read_context_->overlapped);
       if (!ok && GetLastError() != ERROR_IO_PENDING) {
-        ReadCompleted(0, api::serial::RECEIVE_ERROR_SYSTEM_ERROR);
+        ReadCompleted(0, device::RECEIVE_ERROR_SYSTEM_ERROR);
       }
     }
   } else if (context == read_context_) {
     if (read_canceled()) {
       ReadCompleted(bytes_transferred, read_cancel_reason());
     } else if (error != ERROR_SUCCESS && error != ERROR_OPERATION_ABORTED) {
-      ReadCompleted(0, api::serial::RECEIVE_ERROR_SYSTEM_ERROR);
+      ReadCompleted(0, device::RECEIVE_ERROR_SYSTEM_ERROR);
     } else {
-      ReadCompleted(
-          bytes_transferred,
-          error == ERROR_SUCCESS ? api::serial::RECEIVE_ERROR_NONE
-                                 : api::serial::RECEIVE_ERROR_SYSTEM_ERROR);
+      ReadCompleted(bytes_transferred,
+                    error == ERROR_SUCCESS
+                        ? device::RECEIVE_ERROR_NONE
+                        : device::RECEIVE_ERROR_SYSTEM_ERROR);
     }
   } else if (context == write_context_) {
     DCHECK(pending_write_buffer());
     if (write_canceled()) {
       WriteCompleted(0, write_cancel_reason());
     } else if (error != ERROR_SUCCESS && error != ERROR_OPERATION_ABORTED) {
-      WriteCompleted(0, api::serial::SEND_ERROR_SYSTEM_ERROR);
+      WriteCompleted(0, device::SEND_ERROR_SYSTEM_ERROR);
     } else {
-      WriteCompleted(
-          bytes_transferred,
-          error == ERROR_SUCCESS ? api::serial::SEND_ERROR_NONE
-                                 : api::serial::SEND_ERROR_SYSTEM_ERROR);
+      WriteCompleted(bytes_transferred,
+                     error == ERROR_SUCCESS ? device::SEND_ERROR_NONE
+                                            : device::SEND_ERROR_SYSTEM_ERROR);
     }
   } else {
       NOTREACHED() << "Invalid IOContext";
   }
 }
 
 bool SerialIoHandlerWin::ConfigurePort(
-    const api::serial::ConnectionOptions& options) {
+    const device::ConnectionOptions& options) {
   DCB config = {0};
   config.DCBlength = sizeof(config);
   if (!GetCommState(file().GetPlatformFile(), &config)) {
     return false;
   }
-  if (options.bitrate.get())
-    config.BaudRate = BitrateToSpeedConstant(*options.bitrate);
-  if (options.data_bits != api::serial::DATA_BITS_NONE)
+  if (options.bitrate)
+    config.BaudRate = BitrateToSpeedConstant(options.bitrate);
+  if (options.data_bits != device::DATA_BITS_NONE)
     config.ByteSize = DataBitsEnumToConstant(options.data_bits);
-  if (options.parity_bit != api::serial::PARITY_BIT_NONE)
+  if (options.parity_bit != device::PARITY_BIT_NONE)
     config.Parity = ParityBitEnumToConstant(options.parity_bit);
-  if (options.stop_bits != api::serial::STOP_BITS_NONE)
+  if (options.stop_bits != device::STOP_BITS_NONE)
     config.StopBits = StopBitsEnumToConstant(options.stop_bits);
-  if (options.cts_flow_control.get()) {
-    if (*options.cts_flow_control) {
+  if (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;
     }
   }
   return SetCommState(file().GetPlatformFile(), &config) != 0;
 }
 
 bool SerialIoHandlerWin::Flush() const {
   return PurgeComm(file().GetPlatformFile(), PURGE_RXCLEAR | PURGE_TXCLEAR) !=
          0;
 }
 
-bool SerialIoHandlerWin::GetControlSignals(
-    api::serial::DeviceControlSignals* signals) const {
+device::DeviceControlSignalsPtr SerialIoHandlerWin::GetControlSignals() const {
   DWORD status;
   if (!GetCommModemStatus(file().GetPlatformFile(), &status)) {
-    return false;
+    return device::DeviceControlSignalsPtr();
   }
+
+  device::DeviceControlSignalsPtr signals(device::DeviceControlSignals::New());
   signals->dcd = (status & MS_RLSD_ON) != 0;
   signals->cts = (status & MS_CTS_ON) != 0;
   signals->dsr = (status & MS_DSR_ON) != 0;
   signals->ri = (status & MS_RING_ON) != 0;
-  return true;
+  return signals.Pass();
 }
 
 bool SerialIoHandlerWin::SetControlSignals(
-    const api::serial::HostControlSignals& signals) {
-  if (signals.dtr.get()) {
+    const device::HostControlSignals& signals) {
+  if (signals.has_dtr) {
     if (!EscapeCommFunction(file().GetPlatformFile(),
-                            *signals.dtr ? SETDTR : CLRDTR)) {
+                            signals.dtr ? SETDTR : CLRDTR)) {
       return false;
     }
   }
-  if (signals.rts.get()) {
+  if (signals.has_rts) {
     if (!EscapeCommFunction(file().GetPlatformFile(),
-                            *signals.rts ? SETRTS : CLRRTS)) {
+                            signals.rts ? SETRTS : CLRRTS)) {
       return false;
     }
   }
   return true;
 }
 
-bool SerialIoHandlerWin::GetPortInfo(api::serial::ConnectionInfo* info) const {
+device::ConnectionInfoPtr SerialIoHandlerWin::GetPortInfo() const {
   DCB config = {0};
   config.DCBlength = sizeof(config);
   if (!GetCommState(file().GetPlatformFile(), &config)) {
-    return false;
+    return device::ConnectionInfoPtr();
   }
-  info->bitrate.reset(new int(SpeedConstantToBitrate(config.BaudRate)));
+  device::ConnectionInfoPtr info(device::ConnectionInfo::New());
+  info->bitrate = SpeedConstantToBitrate(config.BaudRate);
   info->data_bits = DataBitsConstantToEnum(config.ByteSize);
   info->parity_bit = ParityBitConstantToEnum(config.Parity);
   info->stop_bits = StopBitsConstantToEnum(config.StopBits);
-  info->cts_flow_control.reset(new bool(config.fOutxCtsFlow != 0));
-  return true;
+  info->cts_flow_control = config.fOutxCtsFlow != 0;
+  return info.Pass();
 }
 
 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 extensions