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

Some mojo enums were previously not proper enums: they were constants
for bitfields. These have been replaced by const int32s in the mojoms:
- mus.mojom.EventFlags
- mus.mojom.MouseEventFlags
- mus.mojom.ResizeBehavior
- mus.mojom.WindowTree.AccessPolicy

Some mojo enum values now conflict with macros (mostly on Windows) and
needed to change:
- mus.mojom.Cursor.NULL became CURSOR_NULL (again)
- mus.mojom.KeyboardCode.DELETE became DELETE_KEY
- mus.mojom.WindowManagerErrorCode.ERROR_ACCESS_DENIED became
  ACCESS_DENIED
- device.usb.TransferDirection.IN became INBOUND
- device.usb.TransferDirection.OUT became OUTBOUND
- device.usb.TransferStatus.ERROR became TRANSFER_ERROR
- device.NFCRecordType.OPAQUE became OPAQUE_RECORD
- media.interfaces.Decryptor.Status.ERROR became DECRYPTION_ERROR
- skia.AlphaType.OPAQUE became ALPHA_TYPE_OPAQUE

Review URL: https://codereview.chromium.org/1527183003

Cr-Commit-Position: refs/heads/master@{#370632}

13 files changed, 173 insertions, 170 deletions

diff --git a/device/devices_app/usb/device_impl.cc b/device/devices_app/usb/device_impl.cc
index bc1cf17..fd2f0ff 100644
--- a/device/devices_app/usb/device_impl.cc
+++ b/device/devices_app/usb/device_impl.cc
@@ -95,7 +95,7 @@ void OnControlTransferInPermissionCheckComplete(
         base::Bind(&OnTransferIn, base::Passed(&callback)));
   } else {
     mojo::Array<uint8_t> data;
-    callback->Run(TRANSFER_STATUS_PERMISSION_DENIED, std::move(data));
+    callback->Run(TransferStatus::PERMISSION_DENIED, std::move(data));
   }
 }
 
@@ -124,7 +124,7 @@ void OnControlTransferOutPermissionCheckComplete(
         params->request, params->value, params->index, buffer, data.size(),
         timeout, base::Bind(&OnTransferOut, base::Passed(&callback)));
   } else {
-    callback->Run(TRANSFER_STATUS_PERMISSION_DENIED);
+    callback->Run(TransferStatus::PERMISSION_DENIED);
   }
 }
 
@@ -189,15 +189,15 @@ void DeviceImpl::HasControlTransferPermission(
   DCHECK(device_handle_);
   const UsbConfigDescriptor* config = device_->GetActiveConfiguration();
 
-  if (recipient == CONTROL_TRANSFER_RECIPIENT_INTERFACE ||
-      recipient == CONTROL_TRANSFER_RECIPIENT_ENDPOINT) {
+  if (recipient == ControlTransferRecipient::INTERFACE ||
+      recipient == ControlTransferRecipient::ENDPOINT) {
     if (!config) {
       callback.Run(false);
       return;
     }
 
     uint8_t interface_number = index & 0xff;
-    if (recipient == CONTROL_TRANSFER_RECIPIENT_ENDPOINT) {
+    if (recipient == ControlTransferRecipient::ENDPOINT) {
       if (!device_handle_->FindInterfaceByEndpoint(index & 0xff,
                                                    &interface_number)) {
         callback.Run(false);
@@ -220,7 +220,7 @@ void DeviceImpl::HasControlTransferPermission(
 void DeviceImpl::OnOpen(const OpenCallback& callback,
                         scoped_refptr<UsbDeviceHandle> handle) {
   device_handle_ = handle;
-  callback.Run(handle ? OPEN_DEVICE_ERROR_OK : OPEN_DEVICE_ERROR_ACCESS_DENIED);
+  callback.Run(handle ? OpenDeviceError::OK : OpenDeviceError::ACCESS_DENIED);
 }
 
 void DeviceImpl::GetDeviceInfo(const GetDeviceInfoCallback& callback) {
@@ -325,7 +325,7 @@ void DeviceImpl::ControlTransferIn(ControlTransferParamsPtr params,
                                    uint32_t timeout,
                                    const ControlTransferInCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR, mojo::Array<uint8_t>());
+    callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>());
     return;
   }
 
@@ -345,7 +345,7 @@ void DeviceImpl::ControlTransferOut(
     uint32_t timeout,
     const ControlTransferOutCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR);
+    callback.Run(TransferStatus::TRANSFER_ERROR);
     return;
   }
 
@@ -364,7 +364,7 @@ void DeviceImpl::GenericTransferIn(uint8_t endpoint_number,
                                    uint32_t timeout,
                                    const GenericTransferInCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR, mojo::Array<uint8_t>());
+    callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>());
     return;
   }
 
@@ -382,7 +382,7 @@ void DeviceImpl::GenericTransferOut(
     uint32_t timeout,
     const GenericTransferOutCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR);
+    callback.Run(TransferStatus::TRANSFER_ERROR);
     return;
   }
 
@@ -403,7 +403,8 @@ void DeviceImpl::IsochronousTransferIn(
     uint32_t timeout,
     const IsochronousTransferInCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR, mojo::Array<mojo::Array<uint8_t>>());
+    callback.Run(TransferStatus::TRANSFER_ERROR,
+                 mojo::Array<mojo::Array<uint8_t>>());
     return;
   }
 
@@ -425,7 +426,7 @@ void DeviceImpl::IsochronousTransferOut(
     uint32_t timeout,
     const IsochronousTransferOutCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR);
+    callback.Run(TransferStatus::TRANSFER_ERROR);
     return;
   }
 
diff --git a/device/devices_app/usb/device_impl_unittest.cc b/device/devices_app/usb/device_impl_unittest.cc
index 3fbc702..f6ad171 100644
--- a/device/devices_app/usb/device_impl_unittest.cc
+++ b/device/devices_app/usb/device_impl_unittest.cc
@@ -379,7 +379,7 @@ TEST_F(USBDeviceImplTest, Open) {
 
   base::RunLoop loop;
   device->Open(
-      base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK, loop.QuitClosure()));
+      base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK, loop.QuitClosure()));
   loop.Run();
 
   EXPECT_CALL(mock_handle(), Close());
@@ -394,7 +394,7 @@ TEST_F(USBDeviceImplTest, Close) {
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
@@ -430,7 +430,7 @@ TEST_F(USBDeviceImplTest, SetInvalidConfiguration) {
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
@@ -456,7 +456,7 @@ TEST_F(USBDeviceImplTest, SetValidConfiguration) {
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
@@ -485,7 +485,7 @@ TEST_F(USBDeviceImplTest, Reset) {
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
@@ -520,7 +520,7 @@ TEST_F(USBDeviceImplTest, ClaimAndReleaseInterface) {
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
@@ -588,7 +588,7 @@ TEST_F(USBDeviceImplTest, SetInterfaceAlternateSetting) {
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
@@ -626,7 +626,7 @@ TEST_F(USBDeviceImplTest, ControlTransfer) {
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
@@ -656,15 +656,15 @@ TEST_F(USBDeviceImplTest, ControlTransfer) {
 
   {
     auto params = ControlTransferParams::New();
-    params->type = CONTROL_TRANSFER_TYPE_STANDARD;
-    params->recipient = CONTROL_TRANSFER_RECIPIENT_DEVICE;
+    params->type = ControlTransferType::STANDARD;
+    params->recipient = ControlTransferRecipient::DEVICE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferIn(
         std::move(params), static_cast<uint32_t>(fake_data.size()), 0,
-        base::Bind(&ExpectTransferInAndThen, TRANSFER_STATUS_COMPLETED,
+        base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED,
                    fake_data, loop.QuitClosure()));
     loop.Run();
   }
@@ -678,15 +678,15 @@ TEST_F(USBDeviceImplTest, ControlTransfer) {
 
   {
     auto params = ControlTransferParams::New();
-    params->type = CONTROL_TRANSFER_TYPE_STANDARD;
-    params->recipient = CONTROL_TRANSFER_RECIPIENT_INTERFACE;
+    params->type = ControlTransferType::STANDARD;
+    params->recipient = ControlTransferRecipient::INTERFACE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferOut(
         std::move(params), mojo::Array<uint8_t>::From(fake_data), 0,
-        base::Bind(&ExpectTransferStatusAndThen, TRANSFER_STATUS_COMPLETED,
+        base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
                    loop.QuitClosure()));
     loop.Run();
   }
@@ -701,7 +701,7 @@ TEST_F(USBDeviceImplTest, GenericTransfer) {
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
@@ -725,7 +725,7 @@ TEST_F(USBDeviceImplTest, GenericTransfer) {
     base::RunLoop loop;
     device->GenericTransferOut(
         1, mojo::Array<uint8_t>::From(fake_outbound_data), 0,
-        base::Bind(&ExpectTransferStatusAndThen, TRANSFER_STATUS_COMPLETED,
+        base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
                    loop.QuitClosure()));
     loop.Run();
   }
@@ -737,7 +737,7 @@ TEST_F(USBDeviceImplTest, GenericTransfer) {
     base::RunLoop loop;
     device->GenericTransferIn(
         1, static_cast<uint32_t>(fake_inbound_data.size()), 0,
-        base::Bind(&ExpectTransferInAndThen, TRANSFER_STATUS_COMPLETED,
+        base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED,
                    fake_inbound_data, loop.QuitClosure()));
     loop.Run();
   }
@@ -752,7 +752,7 @@ TEST_F(USBDeviceImplTest, IsochronousTransfer) {
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
@@ -787,7 +787,7 @@ TEST_F(USBDeviceImplTest, IsochronousTransfer) {
     }
     device->IsochronousTransferOut(
         1, std::move(packets), 0,
-        base::Bind(&ExpectTransferStatusAndThen, TRANSFER_STATUS_COMPLETED,
+        base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
                    loop.QuitClosure()));
     loop.Run();
   }
@@ -805,7 +805,7 @@ TEST_F(USBDeviceImplTest, IsochronousTransfer) {
                 inbound_packet_data.begin() + i * 8 + 8, packets[i].begin());
     }
     device->IsochronousTransferIn(
-        1, 4, 8, 0, base::Bind(&ExpectPacketsAndThen, TRANSFER_STATUS_COMPLETED,
+        1, 4, 8, 0, base::Bind(&ExpectPacketsAndThen, TransferStatus::COMPLETED,
                                packets, loop.QuitClosure()));
     loop.Run();
   }
diff --git a/device/devices_app/usb/public/interfaces/device.mojom b/device/devices_app/usb/public/interfaces/device.mojom
index 5382ce3..438aed1 100644
--- a/device/devices_app/usb/public/interfaces/device.mojom
+++ b/device/devices_app/usb/public/interfaces/device.mojom
@@ -13,8 +13,8 @@ enum OpenDeviceError {
 };
 
 enum TransferDirection {
-  IN,
-  OUT,
+  INBOUND,
+  OUTBOUND,
 };
 
 enum ControlTransferType {
@@ -113,7 +113,7 @@ enum TransferStatus {
   COMPLETED,
 
   // The transfer failed due to a non-specific error.
-  ERROR,
+  TRANSFER_ERROR,
 
   // The transfer was not allowed.
   PERMISSION_DENIED,
diff --git a/device/devices_app/usb/type_converters.cc b/device/devices_app/usb/type_converters.cc
index 7152d45..cadf9cf 100644
--- a/device/devices_app/usb/type_converters.cc
+++ b/device/devices_app/usb/type_converters.cc
@@ -41,9 +41,9 @@ device::usb::TransferDirection
 TypeConverter<device::usb::TransferDirection, device::UsbEndpointDirection>::
     Convert(const device::UsbEndpointDirection& direction) {
   if (direction == device::USB_DIRECTION_INBOUND)
-    return device::usb::TRANSFER_DIRECTION_IN;
+    return device::usb::TransferDirection::INBOUND;
   DCHECK(direction == device::USB_DIRECTION_OUTBOUND);
-  return device::usb::TRANSFER_DIRECTION_OUT;
+  return device::usb::TransferDirection::OUTBOUND;
 }
 
 // static
@@ -52,24 +52,24 @@ TypeConverter<device::usb::TransferStatus, device::UsbTransferStatus>::Convert(
     const device::UsbTransferStatus& status) {
   switch (status) {
     case device::USB_TRANSFER_COMPLETED:
-      return device::usb::TRANSFER_STATUS_COMPLETED;
+      return device::usb::TransferStatus::COMPLETED;
     case device::USB_TRANSFER_ERROR:
-      return device::usb::TRANSFER_STATUS_ERROR;
+      return device::usb::TransferStatus::TRANSFER_ERROR;
     case device::USB_TRANSFER_TIMEOUT:
-      return device::usb::TRANSFER_STATUS_TIMEOUT;
+      return device::usb::TransferStatus::TIMEOUT;
     case device::USB_TRANSFER_CANCELLED:
-      return device::usb::TRANSFER_STATUS_CANCELLED;
+      return device::usb::TransferStatus::CANCELLED;
     case device::USB_TRANSFER_STALLED:
-      return device::usb::TRANSFER_STATUS_STALLED;
+      return device::usb::TransferStatus::STALLED;
     case device::USB_TRANSFER_DISCONNECT:
-      return device::usb::TRANSFER_STATUS_DISCONNECT;
+      return device::usb::TransferStatus::DISCONNECT;
     case device::USB_TRANSFER_OVERFLOW:
-      return device::usb::TRANSFER_STATUS_BABBLE;
+      return device::usb::TransferStatus::BABBLE;
     case device::USB_TRANSFER_LENGTH_SHORT:
-      return device::usb::TRANSFER_STATUS_SHORT_PACKET;
+      return device::usb::TransferStatus::SHORT_PACKET;
     default:
       NOTREACHED();
-      return device::usb::TRANSFER_STATUS_ERROR;
+      return device::usb::TransferStatus::TRANSFER_ERROR;
   }
 }
 
@@ -79,13 +79,13 @@ TypeConverter<device::UsbDeviceHandle::TransferRequestType,
               device::usb::ControlTransferType>::
     Convert(const device::usb::ControlTransferType& type) {
   switch (type) {
-    case device::usb::CONTROL_TRANSFER_TYPE_STANDARD:
+    case device::usb::ControlTransferType::STANDARD:
       return device::UsbDeviceHandle::STANDARD;
-    case device::usb::CONTROL_TRANSFER_TYPE_CLASS:
+    case device::usb::ControlTransferType::CLASS:
       return device::UsbDeviceHandle::CLASS;
-    case device::usb::CONTROL_TRANSFER_TYPE_VENDOR:
+    case device::usb::ControlTransferType::VENDOR:
       return device::UsbDeviceHandle::VENDOR;
-    case device::usb::CONTROL_TRANSFER_TYPE_RESERVED:
+    case device::usb::ControlTransferType::RESERVED:
       return device::UsbDeviceHandle::RESERVED;
     default:
       NOTREACHED();
@@ -99,13 +99,13 @@ TypeConverter<device::UsbDeviceHandle::TransferRecipient,
               device::usb::ControlTransferRecipient>::
     Convert(const device::usb::ControlTransferRecipient& recipient) {
   switch (recipient) {
-    case device::usb::CONTROL_TRANSFER_RECIPIENT_DEVICE:
+    case device::usb::ControlTransferRecipient::DEVICE:
       return device::UsbDeviceHandle::DEVICE;
-    case device::usb::CONTROL_TRANSFER_RECIPIENT_INTERFACE:
+    case device::usb::ControlTransferRecipient::INTERFACE:
       return device::UsbDeviceHandle::INTERFACE;
-    case device::usb::CONTROL_TRANSFER_RECIPIENT_ENDPOINT:
+    case device::usb::ControlTransferRecipient::ENDPOINT:
       return device::UsbDeviceHandle::ENDPOINT;
-    case device::usb::CONTROL_TRANSFER_RECIPIENT_OTHER:
+    case device::usb::ControlTransferRecipient::OTHER:
       return device::UsbDeviceHandle::OTHER;
     default:
       NOTREACHED();
@@ -119,17 +119,17 @@ TypeConverter<device::usb::EndpointType, device::UsbTransferType>::Convert(
     const device::UsbTransferType& type) {
   switch (type) {
     case device::USB_TRANSFER_ISOCHRONOUS:
-      return device::usb::ENDPOINT_TYPE_ISOCHRONOUS;
+      return device::usb::EndpointType::ISOCHRONOUS;
     case device::USB_TRANSFER_BULK:
-      return device::usb::ENDPOINT_TYPE_BULK;
+      return device::usb::EndpointType::BULK;
     case device::USB_TRANSFER_INTERRUPT:
-      return device::usb::ENDPOINT_TYPE_INTERRUPT;
+      return device::usb::EndpointType::INTERRUPT;
     // Note that we do not expose control transfer in the public interface
     // because control endpoints are implied rather than explicitly enumerated
     // there.
     default:
       NOTREACHED();
-      return device::usb::ENDPOINT_TYPE_BULK;
+      return device::usb::EndpointType::BULK;
   }
 }
 
diff --git a/device/nfc/nfc.mojom b/device/nfc/nfc.mojom
index 72b3e9e..6ba8b7a 100644
--- a/device/nfc/nfc.mojom
+++ b/device/nfc/nfc.mojom
@@ -21,7 +21,7 @@ enum NFCRecordType {
   TEXT,
   URL,
   JSON,
-  OPAQUE
+  OPAQUE_RECORD
 };
 
 enum NFCPushTarget {
diff --git a/device/serial/buffer.cc b/device/serial/buffer.cc
index 2475e01..c6eeea2 100644
--- a/device/serial/buffer.cc
+++ b/device/serial/buffer.cc
@@ -30,7 +30,7 @@ uint32_t SendBuffer::GetSize() {
 }
 
 void SendBuffer::Done(uint32_t bytes_read) {
-  callback_.Run(bytes_read, device::serial::SEND_ERROR_NONE);
+  callback_.Run(bytes_read, device::serial::SendError::NONE);
 }
 
 void SendBuffer::DoneWithError(uint32_t bytes_read, int32_t error) {
@@ -54,7 +54,7 @@ uint32_t ReceiveBuffer::GetSize() {
 }
 
 void ReceiveBuffer::Done(uint32_t bytes_written) {
-  callback_.Run(bytes_written, device::serial::RECEIVE_ERROR_NONE);
+  callback_.Run(bytes_written, device::serial::ReceiveError::NONE);
 }
 
 void ReceiveBuffer::DoneWithError(uint32_t bytes_written, int32_t error) {
diff --git a/device/serial/serial_connection.cc b/device/serial/serial_connection.cc
index 249b892..9b88c9d 100644
--- a/device/serial/serial_connection.cc
+++ b/device/serial/serial_connection.cc
@@ -35,8 +35,8 @@ SerialConnection::SerialConnection(
 SerialConnection::~SerialConnection() {
   receiver_->ShutDown();
   sender_->ShutDown();
-  io_handler_->CancelRead(serial::RECEIVE_ERROR_DISCONNECTED);
-  io_handler_->CancelWrite(serial::SEND_ERROR_DISCONNECTED);
+  io_handler_->CancelRead(serial::ReceiveError::DISCONNECTED);
+  io_handler_->CancelWrite(serial::SendError::DISCONNECTED);
 }
 
 void SerialConnection::GetInfo(
@@ -47,7 +47,7 @@ void SerialConnection::GetInfo(
 void SerialConnection::SetOptions(serial::ConnectionOptionsPtr options,
                                   const mojo::Callback<void(bool)>& callback) {
   callback.Run(io_handler_->ConfigurePort(*options));
-  io_handler_->CancelRead(device::serial::RECEIVE_ERROR_NONE);
+  io_handler_->CancelRead(device::serial::ReceiveError::NONE);
 }
 
 void SerialConnection::SetControlSignals(
diff --git a/device/serial/serial_connection_factory.cc b/device/serial/serial_connection_factory.cc
index d167a78..8088a7e 100644
--- a/device/serial/serial_connection_factory.cc
+++ b/device/serial/serial_connection_factory.cc
@@ -18,12 +18,12 @@ namespace {
 void FillDefaultConnectionOptions(serial::ConnectionOptions* options) {
   if (!options->bitrate)
     options->bitrate = 9600;
-  if (options->data_bits == serial::DATA_BITS_NONE)
-    options->data_bits = serial::DATA_BITS_EIGHT;
-  if (options->stop_bits == serial::STOP_BITS_NONE)
-    options->stop_bits = serial::STOP_BITS_ONE;
-  if (options->parity_bit == serial::PARITY_BIT_NONE)
-    options->parity_bit = serial::PARITY_BIT_NO;
+  if (options->data_bits == serial::DataBits::NONE)
+    options->data_bits = serial::DataBits::EIGHT;
+  if (options->stop_bits == serial::StopBits::NONE)
+    options->stop_bits = serial::StopBits::ONE;
+  if (options->parity_bit == serial::ParityBit::NONE)
+    options->parity_bit = serial::ParityBit::NO;
   if (!options->has_cts_flow_control) {
     options->has_cts_flow_control = true;
     options->cts_flow_control = false;
diff --git a/device/serial/serial_connection_unittest.cc b/device/serial/serial_connection_unittest.cc
index c310755..3d5f51e 100644
--- a/device/serial/serial_connection_unittest.cc
+++ b/device/serial/serial_connection_unittest.cc
@@ -61,8 +61,8 @@ class SerialConnectionTest : public testing::Test {
       : connected_(false),
         success_(false),
         bytes_sent_(0),
-        send_error_(serial::SEND_ERROR_NONE),
-        receive_error_(serial::RECEIVE_ERROR_NONE),
+        send_error_(serial::SendError::NONE),
+        receive_error_(serial::ReceiveError::NONE),
         expected_event_(EVENT_NONE) {}
 
   void SetUp() override {
@@ -85,11 +85,12 @@ class SerialConnectionTest : public testing::Test {
     service->Connect("device", serial::ConnectionOptions::New(),
                      mojo::GetProxy(&connection_), mojo::GetProxy(&sink),
                      mojo::GetProxy(&source), std::move(source_client));
-    sender_.reset(new DataSender(std::move(sink), kBufferSize,
-                                 serial::SEND_ERROR_DISCONNECTED));
-    receiver_ =
-        new DataReceiver(std::move(source), std::move(source_client_request),
-                         kBufferSize, serial::RECEIVE_ERROR_DISCONNECTED);
+    sender_.reset(
+        new DataSender(std::move(sink), kBufferSize,
+                       static_cast<int32_t>(serial::SendError::DISCONNECTED)));
+    receiver_ = new DataReceiver(
+        std::move(source), std::move(source_client_request), kBufferSize,
+        static_cast<int32_t>(serial::ReceiveError::DISCONNECTED));
     connection_.set_connection_error_handler(base::Bind(
         &SerialConnectionTest::OnConnectionError, base::Unretained(this)));
     connection_->GetInfo(
@@ -152,7 +153,7 @@ class SerialConnectionTest : public testing::Test {
 
   void OnDataSent(uint32_t bytes_sent) {
     bytes_sent_ += bytes_sent;
-    send_error_ = serial::SEND_ERROR_NONE;
+    send_error_ = serial::SendError::NONE;
     EventReceived(EVENT_DATA_SENT);
   }
 
@@ -165,7 +166,7 @@ class SerialConnectionTest : public testing::Test {
   void OnDataReceived(scoped_ptr<ReadOnlyBuffer> buffer) {
     data_received_ += std::string(buffer->GetData(), buffer->GetSize());
     buffer->Done(buffer->GetSize());
-    receive_error_ = serial::RECEIVE_ERROR_NONE;
+    receive_error_ = serial::ReceiveError::NONE;
     EventReceived(EVENT_DATA_RECEIVED);
   }
 
@@ -207,16 +208,16 @@ TEST_F(SerialConnectionTest, GetInfo) {
   // |info_| is filled in during SetUp().
   ASSERT_TRUE(info_);
   EXPECT_EQ(9600u, info_->bitrate);
-  EXPECT_EQ(serial::DATA_BITS_EIGHT, info_->data_bits);
-  EXPECT_EQ(serial::PARITY_BIT_NO, info_->parity_bit);
-  EXPECT_EQ(serial::STOP_BITS_ONE, info_->stop_bits);
+  EXPECT_EQ(serial::DataBits::EIGHT, info_->data_bits);
+  EXPECT_EQ(serial::ParityBit::NO, info_->parity_bit);
+  EXPECT_EQ(serial::StopBits::ONE, info_->stop_bits);
   EXPECT_FALSE(info_->cts_flow_control);
 }
 
 TEST_F(SerialConnectionTest, SetOptions) {
   serial::ConnectionOptionsPtr options(serial::ConnectionOptions::New());
   options->bitrate = 12345;
-  options->data_bits = serial::DATA_BITS_SEVEN;
+  options->data_bits = serial::DataBits::SEVEN;
   options->has_cts_flow_control = true;
   options->cts_flow_control = true;
   connection_->SetOptions(
@@ -227,9 +228,9 @@ TEST_F(SerialConnectionTest, SetOptions) {
   ASSERT_TRUE(success_);
   serial::ConnectionInfo* info = io_handler_->connection_info();
   EXPECT_EQ(12345u, info->bitrate);
-  EXPECT_EQ(serial::DATA_BITS_SEVEN, info->data_bits);
-  EXPECT_EQ(serial::PARITY_BIT_NO, info->parity_bit);
-  EXPECT_EQ(serial::STOP_BITS_ONE, info->stop_bits);
+  EXPECT_EQ(serial::DataBits::SEVEN, info->data_bits);
+  EXPECT_EQ(serial::ParityBit::NO, info->parity_bit);
+  EXPECT_EQ(serial::StopBits::ONE, info->stop_bits);
   EXPECT_TRUE(info->cts_flow_control);
 }
 
@@ -280,7 +281,7 @@ TEST_F(SerialConnectionTest, DisconnectWithSend) {
   io_handler_->set_send_callback(base::Bind(base::DoNothing));
   ASSERT_NO_FATAL_FAILURE(Send("data"));
   WaitForEvent(EVENT_SEND_ERROR);
-  EXPECT_EQ(serial::SEND_ERROR_DISCONNECTED, send_error_);
+  EXPECT_EQ(serial::SendError::DISCONNECTED, send_error_);
   EXPECT_EQ(0, bytes_sent_);
   EXPECT_TRUE(io_handler_->HasOneRef());
 }
@@ -289,7 +290,7 @@ TEST_F(SerialConnectionTest, DisconnectWithReceive) {
   connection_.reset();
   ASSERT_NO_FATAL_FAILURE(Receive());
   WaitForEvent(EVENT_RECEIVE_ERROR);
-  EXPECT_EQ(serial::RECEIVE_ERROR_DISCONNECTED, receive_error_);
+  EXPECT_EQ(serial::ReceiveError::DISCONNECTED, receive_error_);
   EXPECT_EQ("", data_received_);
   EXPECT_TRUE(io_handler_->HasOneRef());
 }
@@ -297,12 +298,12 @@ TEST_F(SerialConnectionTest, DisconnectWithReceive) {
 TEST_F(SerialConnectionTest, Echo) {
   ASSERT_NO_FATAL_FAILURE(Send("data"));
   WaitForEvent(EVENT_DATA_SENT);
-  EXPECT_EQ(serial::SEND_ERROR_NONE, send_error_);
+  EXPECT_EQ(serial::SendError::NONE, send_error_);
   EXPECT_EQ(4, bytes_sent_);
   ASSERT_NO_FATAL_FAILURE(Receive());
   WaitForEvent(EVENT_DATA_RECEIVED);
   EXPECT_EQ("data", data_received_);
-  EXPECT_EQ(serial::RECEIVE_ERROR_NONE, receive_error_);
+  EXPECT_EQ(serial::ReceiveError::NONE, receive_error_);
 }
 
 TEST_F(SerialConnectionTest, Cancel) {
@@ -317,22 +318,22 @@ TEST_F(SerialConnectionTest, Cancel) {
   WaitForEvent(EVENT_DATA_AT_IO_HANDLER);
   EXPECT_EQ(0, bytes_sent_);
 
-  ASSERT_TRUE(sender_->Cancel(serial::SEND_ERROR_TIMEOUT,
-                              base::Bind(&SerialConnectionTest::EventReceived,
-                                         base::Unretained(this),
-                                         EVENT_CANCEL_COMPLETE)));
+  ASSERT_TRUE(sender_->Cancel(
+      static_cast<int32_t>(serial::SendError::TIMEOUT),
+      base::Bind(&SerialConnectionTest::EventReceived, base::Unretained(this),
+                 EVENT_CANCEL_COMPLETE)));
 
   WaitForEvent(EVENT_CANCEL_COMPLETE);
-  EXPECT_EQ(serial::SEND_ERROR_TIMEOUT, send_error_);
+  EXPECT_EQ(serial::SendError::TIMEOUT, send_error_);
 
   ASSERT_NO_FATAL_FAILURE(Send("data"));
   WaitForEvent(EVENT_DATA_SENT);
-  EXPECT_EQ(serial::SEND_ERROR_NONE, send_error_);
+  EXPECT_EQ(serial::SendError::NONE, send_error_);
   EXPECT_EQ(4, bytes_sent_);
   ASSERT_NO_FATAL_FAILURE(Receive());
   WaitForEvent(EVENT_DATA_RECEIVED);
   EXPECT_EQ("data", data_received_);
-  EXPECT_EQ(serial::RECEIVE_ERROR_NONE, receive_error_);
+  EXPECT_EQ(serial::ReceiveError::NONE, receive_error_);
 }
 
 }  // namespace device
diff --git a/device/serial/serial_io_handler.cc b/device/serial/serial_io_handler.cc
index ae63dab..35b41f7 100644
--- a/device/serial/serial_io_handler.cc
+++ b/device/serial/serial_io_handler.cc
@@ -26,9 +26,9 @@ SerialIoHandler::SerialIoHandler(
     : file_thread_task_runner_(file_thread_task_runner),
       ui_thread_task_runner_(ui_thread_task_runner) {
   options_.bitrate = 9600;
-  options_.data_bits = serial::DATA_BITS_EIGHT;
-  options_.parity_bit = serial::PARITY_BIT_NO;
-  options_.stop_bits = serial::STOP_BITS_ONE;
+  options_.data_bits = serial::DataBits::EIGHT;
+  options_.parity_bit = serial::ParityBit::NO;
+  options_.stop_bits = serial::StopBits::ONE;
   options_.cts_flow_control = false;
   options_.has_cts_flow_control = true;
 }
@@ -100,13 +100,13 @@ void SerialIoHandler::MergeConnectionOptions(
   if (options.bitrate) {
     options_.bitrate = options.bitrate;
   }
-  if (options.data_bits != serial::DATA_BITS_NONE) {
+  if (options.data_bits != serial::DataBits::NONE) {
     options_.data_bits = options.data_bits;
   }
-  if (options.parity_bit != serial::PARITY_BIT_NONE) {
+  if (options.parity_bit != serial::ParityBit::NONE) {
     options_.parity_bit = options.parity_bit;
   }
-  if (options.stop_bits != serial::STOP_BITS_NONE) {
+  if (options.stop_bits != serial::StopBits::NONE) {
     options_.stop_bits = options.stop_bits;
   }
   if (options.has_cts_flow_control) {
@@ -200,10 +200,10 @@ void SerialIoHandler::ReadCompleted(int bytes_read,
   DCHECK(IsReadPending());
   scoped_ptr<WritableBuffer> pending_read_buffer =
       std::move(pending_read_buffer_);
-  if (error == serial::RECEIVE_ERROR_NONE) {
+  if (error == serial::ReceiveError::NONE) {
     pending_read_buffer->Done(bytes_read);
   } else {
-    pending_read_buffer->DoneWithError(bytes_read, error);
+    pending_read_buffer->DoneWithError(bytes_read, static_cast<int32_t>(error));
   }
   Release();
 }
@@ -214,10 +214,11 @@ void SerialIoHandler::WriteCompleted(int bytes_written,
   DCHECK(IsWritePending());
   scoped_ptr<ReadOnlyBuffer> pending_write_buffer =
       std::move(pending_write_buffer_);
-  if (error == serial::SEND_ERROR_NONE) {
+  if (error == serial::SendError::NONE) {
     pending_write_buffer->Done(bytes_written);
   } else {
-    pending_write_buffer->DoneWithError(bytes_written, error);
+    pending_write_buffer->DoneWithError(bytes_written,
+                                        static_cast<int32_t>(error));
   }
   Release();
 }
diff --git a/device/serial/serial_io_handler_posix.cc b/device/serial/serial_io_handler_posix.cc
index 45385e9..158c374 100644
--- a/device/serial/serial_io_handler_posix.cc
+++ b/device/serial/serial_io_handler_posix.cc
@@ -199,28 +199,28 @@ bool SerialIoHandlerPosix::ConfigurePortImpl() {
 #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;
@@ -239,12 +239,12 @@ bool SerialIoHandlerPosix::ConfigurePortImpl() {
     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;
@@ -300,12 +300,12 @@ void SerialIoHandlerPosix::OnFileCanReadWithoutBlocking(int fd) {
                                        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;
@@ -314,11 +314,11 @@ void SerialIoHandlerPosix::OnFileCanReadWithoutBlocking(int fd) {
                             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 {
@@ -338,9 +338,9 @@ void SerialIoHandlerPosix::OnFileCanWriteWithoutBlocking(int fd) {
                                            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
@@ -463,20 +463,20 @@ serial::ConnectionInfoPtr SerialIoHandlerPosix::GetPortInfo() const {
 #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;
 }
diff --git a/device/serial/serial_io_handler_win.cc b/device/serial/serial_io_handler_win.cc
index dec9450..4c1010f 100644
--- a/device/serial/serial_io_handler_win.cc
+++ b/device/serial/serial_io_handler_win.cc
@@ -49,9 +49,9 @@ int BitrateToSpeedConstant(int bitrate) {
 
 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;
   }
@@ -59,11 +59,11 @@ int DataBitsEnumToConstant(serial::DataBits data_bits) {
 
 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;
   }
@@ -71,9 +71,9 @@ int ParityBitEnumToConstant(serial::ParityBit parity_bit) {
 
 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;
   }
@@ -110,32 +110,32 @@ int SpeedConstantToBitrate(int speed) {
 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;
   }
 }
 
@@ -227,7 +227,7 @@ void SerialIoHandlerWin::OnDeviceRemoved(const std::string& device_path) {
   }
 
   if (port() == com_port)
-    CancelRead(serial::RECEIVE_ERROR_DEVICE_LOST);
+    CancelRead(serial::ReceiveError::DEVICE_LOST);
 }
 
 bool SerialIoHandlerWin::PostOpen() {
@@ -285,7 +285,7 @@ void SerialIoHandlerWin::ReadImpl() {
       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;
 }
@@ -302,7 +302,7 @@ void SerialIoHandlerWin::WriteImpl() {
                         &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);
   }
 }
 
@@ -339,13 +339,13 @@ bool SerialIoHandlerWin::ConfigurePortImpl() {
   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);
@@ -388,17 +388,17 @@ void SerialIoHandlerWin::OnIOCompleted(
     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;
     }
@@ -406,7 +406,7 @@ void SerialIoHandlerWin::OnIOCompleted(
     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(),
@@ -415,26 +415,26 @@ void SerialIoHandlerWin::OnIOCompleted(
                            &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
@@ -445,12 +445,12 @@ void SerialIoHandlerWin::OnIOCompleted(
         // 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";
diff --git a/device/serial/test_serial_io_handler.cc b/device/serial/test_serial_io_handler.cc
index b112462..d0b4ee6 100644
--- a/device/serial/test_serial_io_handler.cc
+++ b/device/serial/test_serial_io_handler.cc
@@ -45,7 +45,7 @@ void TestSerialIoHandler::ReadImpl() {
       std::min(buffer_.size(), static_cast<size_t>(pending_read_buffer_len()));
   memcpy(pending_read_buffer(), buffer_.c_str(), num_bytes);
   buffer_ = buffer_.substr(num_bytes);
-  ReadCompleted(static_cast<uint32_t>(num_bytes), serial::RECEIVE_ERROR_NONE);
+  ReadCompleted(static_cast<uint32_t>(num_bytes), serial::ReceiveError::NONE);
 }
 
 void TestSerialIoHandler::CancelReadImpl() {
@@ -60,7 +60,7 @@ void TestSerialIoHandler::WriteImpl() {
     return;
   }
   buffer_ += std::string(pending_write_buffer(), pending_write_buffer_len());
-  WriteCompleted(pending_write_buffer_len(), serial::SEND_ERROR_NONE);
+  WriteCompleted(pending_write_buffer_len(), serial::SendError::NONE);
   if (pending_read_buffer())
     ReadImpl();
 }