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

tools/battor_agent/battor_connection.cc

 // Copyright 2015 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 "tools/battor_agent/battor_connection.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "device/serial/buffer.h"
 #include "device/serial/serial_io_handler.h"
 #include "net/base/io_buffer.h"
 
 using std::vector;
 
 namespace battor {
 
 namespace {
 
 // Serial configuration parameters for the BattOr.
 const uint32_t kBattOrBitrate = 2000000;
 const device::serial::DataBits kBattOrDataBits =
-    device::serial::DATA_BITS_EIGHT;
+    device::serial::DataBits::EIGHT;
 const device::serial::ParityBit kBattOrParityBit =
-    device::serial::PARITY_BIT_NONE;
-const device::serial::StopBits kBattOrStopBit = device::serial::STOP_BITS_ONE;
+    device::serial::ParityBit::NONE;
+const device::serial::StopBits kBattOrStopBit = device::serial::StopBits::ONE;
 const bool kBattOrCtsFlowControl = true;
 const bool kBattOrHasCtsFlowControl = true;
 const uint32_t kMaxMessageSize = 50000;
 
 // MessageHealth describes the possible healthiness states that a partially
 // received message could be in.
 enum class MessageHealth {
   INVALID,
   INCOMPLETE,
   COMPLETE,
@@ skipping 185 matching lines @@
       base::Bind(&BattOrConnection::OnBytesRead, AsWeakPtr());
 
   pending_read_length_ = bytes_to_read;
   io_handler_->Read(make_scoped_ptr(new device::ReceiveBuffer(
       last_read_buffer_, bytes_to_read, on_receive_buffer_filled)));
 }
 
 void BattOrConnection::OnBytesRead(int bytes_read,
                                    device::serial::ReceiveError error) {
   if ((static_cast<size_t>(bytes_read) < pending_read_length_) ||
-      (error != device::serial::RECEIVE_ERROR_NONE)) {
+      (error != device::serial::ReceiveError::NONE)) {
     listener_->OnBytesRead(false, BATTOR_MESSAGE_TYPE_CONTROL, nullptr);
     return;
   }
 
   pending_read_buffer_->insert(pending_read_buffer_->end(),
                                last_read_buffer_->data(),
                                last_read_buffer_->data() + bytes_read);
 
   scoped_ptr<vector<char>> parsed_content(new vector<char>());
   MessageHealth health;
@@ skipping 26 matching lines @@
     // If everything is valid and we didn't see any escape bytes, then we should
     // have the whole message. If we don't, the message was malformed.
     listener_->OnBytesRead(false, BATTOR_MESSAGE_TYPE_CONTROL, nullptr);
 
   // If we've gotten this far, we've received the whole, well-formed message.
   listener_->OnBytesRead(true, type, std::move(parsed_content));
 }
 
 void BattOrConnection::OnBytesSent(int bytes_sent,
                                    device::serial::SendError error) {
-  bool success = (error == device::serial::SEND_ERROR_NONE) &&
+  bool success = (error == device::serial::SendError::NONE) &&
                  (pending_write_length_ == static_cast<size_t>(bytes_sent));
   listener_->OnBytesSent(success);
 }
 
 }  // namespace battor