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

extensions/renderer/api/serial/serial_api_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 171 matching lines @@
 };
 
 class ConfigurePortTestIoHandler : public TestIoHandlerBase {
  public:
   ConfigurePortTestIoHandler() {}
   bool ConfigurePortImpl() override {
     static const device::serial::ConnectionOptions expected_options[] = {
         // Each JavaScript call to chrome.serial.update only modifies a single
         // property of the connection however this function can only check the
         // final value of all options. The modified option is marked with "set".
-        GenerateConnectionOptions(9600,
-                                  device::serial::DATA_BITS_EIGHT,
-                                  device::serial::PARITY_BIT_NO,
-                                  device::serial::STOP_BITS_ONE,
+        GenerateConnectionOptions(9600, device::serial::DataBits::EIGHT,
+                                  device::serial::ParityBit::NO,
+                                  device::serial::StopBits::ONE,
                                   OPTIONAL_VALUE_FALSE),
-        GenerateConnectionOptions(57600,  // set
-                                  device::serial::DATA_BITS_EIGHT,
-                                  device::serial::PARITY_BIT_NO,
-                                  device::serial::STOP_BITS_ONE,
+        GenerateConnectionOptions(
+            57600,  // set
+            device::serial::DataBits::EIGHT, device::serial::ParityBit::NO,
+            device::serial::StopBits::ONE, OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(57600,
+                                  device::serial::DataBits::SEVEN,  // set
+                                  device::serial::ParityBit::NO,
+                                  device::serial::StopBits::ONE,
                                   OPTIONAL_VALUE_FALSE),
         GenerateConnectionOptions(57600,
-                                  device::serial::DATA_BITS_SEVEN,  // set
-                                  device::serial::PARITY_BIT_NO,
-                                  device::serial::STOP_BITS_ONE,
+                                  device::serial::DataBits::EIGHT,  // set
+                                  device::serial::ParityBit::NO,
+                                  device::serial::StopBits::ONE,
                                   OPTIONAL_VALUE_FALSE),
-        GenerateConnectionOptions(57600,
-                                  device::serial::DATA_BITS_EIGHT,  // set
-                                  device::serial::PARITY_BIT_NO,
-                                  device::serial::STOP_BITS_ONE,
+        GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT,
+                                  device::serial::ParityBit::NO,  // set
+                                  device::serial::StopBits::ONE,
                                   OPTIONAL_VALUE_FALSE),
-        GenerateConnectionOptions(57600,
-                                  device::serial::DATA_BITS_EIGHT,
-                                  device::serial::PARITY_BIT_NO,  // set
-                                  device::serial::STOP_BITS_ONE,
+        GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT,
+                                  device::serial::ParityBit::ODD,  // set
+                                  device::serial::StopBits::ONE,
                                   OPTIONAL_VALUE_FALSE),
-        GenerateConnectionOptions(57600,
-                                  device::serial::DATA_BITS_EIGHT,
-                                  device::serial::PARITY_BIT_ODD,  // set
-                                  device::serial::STOP_BITS_ONE,
+        GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT,
+                                  device::serial::ParityBit::EVEN,  // set
+                                  device::serial::StopBits::ONE,
                                   OPTIONAL_VALUE_FALSE),
-        GenerateConnectionOptions(57600,
-                                  device::serial::DATA_BITS_EIGHT,
-                                  device::serial::PARITY_BIT_EVEN,  // set
-                                  device::serial::STOP_BITS_ONE,
+        GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT,
+                                  device::serial::ParityBit::EVEN,
+                                  device::serial::StopBits::ONE,  // set
                                   OPTIONAL_VALUE_FALSE),
-        GenerateConnectionOptions(57600,
-                                  device::serial::DATA_BITS_EIGHT,
-                                  device::serial::PARITY_BIT_EVEN,
-                                  device::serial::STOP_BITS_ONE,  // set
+        GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT,
+                                  device::serial::ParityBit::EVEN,
+                                  device::serial::StopBits::TWO,  // set
                                   OPTIONAL_VALUE_FALSE),
-        GenerateConnectionOptions(57600,
-                                  device::serial::DATA_BITS_EIGHT,
-                                  device::serial::PARITY_BIT_EVEN,
-                                  device::serial::STOP_BITS_TWO,  // set
-                                  OPTIONAL_VALUE_FALSE),
-        GenerateConnectionOptions(57600,
-                                  device::serial::DATA_BITS_EIGHT,
-                                  device::serial::PARITY_BIT_EVEN,
-                                  device::serial::STOP_BITS_TWO,
+        GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT,
+                                  device::serial::ParityBit::EVEN,
+                                  device::serial::StopBits::TWO,
                                   OPTIONAL_VALUE_FALSE),  // set
-        GenerateConnectionOptions(57600,
-                                  device::serial::DATA_BITS_EIGHT,
-                                  device::serial::PARITY_BIT_EVEN,
-                                  device::serial::STOP_BITS_TWO,
+        GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT,
+                                  device::serial::ParityBit::EVEN,
+                                  device::serial::StopBits::TWO,
                                   OPTIONAL_VALUE_TRUE),  // set
     };
 
     if (!TestIoHandlerBase::ConfigurePortImpl()) {
       return false;
     }
 
     if (num_calls() >= arraysize(expected_options)) {
       return false;
     }
@@ skipping 83 matching lines @@
 class FixedDataReceiveTestIoHandler : public TestIoHandlerBase {
  public:
   explicit FixedDataReceiveTestIoHandler(const std::string& data)
       : data_(data) {}
 
   void ReadImpl() override {
     if (pending_read_buffer_len() < data_.size())
       return;
     memcpy(pending_read_buffer(), data_.c_str(), data_.size());
     QueueReadCompleted(static_cast<uint32_t>(data_.size()),
-                       device::serial::RECEIVE_ERROR_NONE);
+                       device::serial::ReceiveError::NONE);
   }
 
  private:
   ~FixedDataReceiveTestIoHandler() override {}
 
   const std::string data_;
 
   DISALLOW_COPY_AND_ASSIGN(FixedDataReceiveTestIoHandler);
 };
 
@@ skipping 11 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ReceiveErrorTestIoHandler);
 };
 
 class SendDataWithErrorIoHandler : public TestIoHandlerBase {
  public:
   SendDataWithErrorIoHandler() : sent_error_(false) {}
   void WriteImpl() override {
     if (sent_error_) {
       WriteCompleted(pending_write_buffer_len(),
-                     device::serial::SEND_ERROR_NONE);
+                     device::serial::SendError::NONE);
       return;
     }
     sent_error_ = true;
     // We expect the JS test code to send a 4 byte buffer.
     ASSERT_LT(2u, pending_write_buffer_len());
-    WriteCompleted(2, device::serial::SEND_ERROR_SYSTEM_ERROR);
+    WriteCompleted(2, device::serial::SendError::SYSTEM_ERROR);
   }
 
  private:
   ~SendDataWithErrorIoHandler() override {}
 
   bool sent_error_;
 
   DISALLOW_COPY_AND_ASSIGN(SendDataWithErrorIoHandler);
 };
 
@@ skipping 175 matching lines @@
   RunTest("serial_unittest.js", "testDisableSendTimeout");
 }
 
 TEST_F(SerialApiTest, PausedReceive) {
   io_handler_ = new FixedDataReceiveTestIoHandler("data");
   RunTest("serial_unittest.js", "testPausedReceive");
 }
 
 TEST_F(SerialApiTest, PausedReceiveError) {
   io_handler_ =
-      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST);
+      new ReceiveErrorTestIoHandler(device::serial::ReceiveError::DEVICE_LOST);
   RunTest("serial_unittest.js", "testPausedReceiveError");
 }
 
 TEST_F(SerialApiTest, ReceiveTimeout) {
   RunTest("serial_unittest.js", "testReceiveTimeout");
 }
 
 TEST_F(SerialApiTest, ReceiveTimeoutAfterSerialization) {
   RunTest("serial_unittest.js", "testReceiveTimeoutAfterSerialization");
 }
 
 TEST_F(SerialApiTest, DisableReceiveTimeout) {
   RunTest("serial_unittest.js", "testDisableReceiveTimeout");
 }
 
 TEST_F(SerialApiTest, ReceiveErrorDisconnected) {
   io_handler_ =
-      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DISCONNECTED);
+      new ReceiveErrorTestIoHandler(device::serial::ReceiveError::DISCONNECTED);
   RunTest("serial_unittest.js", "testReceiveErrorDisconnected");
 }
 
 TEST_F(SerialApiTest, ReceiveErrorDeviceLost) {
   io_handler_ =
-      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST);
+      new ReceiveErrorTestIoHandler(device::serial::ReceiveError::DEVICE_LOST);
   RunTest("serial_unittest.js", "testReceiveErrorDeviceLost");
 }
 
 TEST_F(SerialApiTest, ReceiveErrorBreak) {
   io_handler_ =
-      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_BREAK);
+      new ReceiveErrorTestIoHandler(device::serial::ReceiveError::BREAK);
   RunTest("serial_unittest.js", "testReceiveErrorBreak");
 }
 
 TEST_F(SerialApiTest, ReceiveErrorFrameError) {
   io_handler_ =
-      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_FRAME_ERROR);
+      new ReceiveErrorTestIoHandler(device::serial::ReceiveError::FRAME_ERROR);
   RunTest("serial_unittest.js", "testReceiveErrorFrameError");
 }
 
 TEST_F(SerialApiTest, ReceiveErrorOverrun) {
   io_handler_ =
-      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_OVERRUN);
+      new ReceiveErrorTestIoHandler(device::serial::ReceiveError::OVERRUN);
   RunTest("serial_unittest.js", "testReceiveErrorOverrun");
 }
 
 TEST_F(SerialApiTest, ReceiveErrorBufferOverflow) {
   io_handler_ = new ReceiveErrorTestIoHandler(
-      device::serial::RECEIVE_ERROR_BUFFER_OVERFLOW);
+      device::serial::ReceiveError::BUFFER_OVERFLOW);
   RunTest("serial_unittest.js", "testReceiveErrorBufferOverflow");
 }
 
 TEST_F(SerialApiTest, ReceiveErrorParityError) {
   io_handler_ =
-      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_PARITY_ERROR);
+      new ReceiveErrorTestIoHandler(device::serial::ReceiveError::PARITY_ERROR);
   RunTest("serial_unittest.js", "testReceiveErrorParityError");
 }
 
 TEST_F(SerialApiTest, ReceiveErrorSystemError) {
   io_handler_ =
-      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_SYSTEM_ERROR);
+      new ReceiveErrorTestIoHandler(device::serial::ReceiveError::SYSTEM_ERROR);
   RunTest("serial_unittest.js", "testReceiveErrorSystemError");
 }
 
 TEST_F(SerialApiTest, SendErrorDisconnected) {
   io_handler_ =
-      new SendErrorTestIoHandler(device::serial::SEND_ERROR_DISCONNECTED);
+      new SendErrorTestIoHandler(device::serial::SendError::DISCONNECTED);
   RunTest("serial_unittest.js", "testSendErrorDisconnected");
 }
 
 TEST_F(SerialApiTest, SendErrorSystemError) {
   io_handler_ =
-      new SendErrorTestIoHandler(device::serial::SEND_ERROR_SYSTEM_ERROR);
+      new SendErrorTestIoHandler(device::serial::SendError::SYSTEM_ERROR);
   RunTest("serial_unittest.js", "testSendErrorSystemError");
 }
 
 TEST_F(SerialApiTest, DisconnectUnknownConnectionId) {
   RunTest("serial_unittest.js", "testDisconnectUnknownConnectionId");
 }
 
 TEST_F(SerialApiTest, GetInfoUnknownConnectionId) {
   RunTest("serial_unittest.js", "testGetInfoUnknownConnectionId");
 }
@@ skipping 28 matching lines @@
 TEST_F(SerialApiTest, DISABLED_StashAndRestoreDuringEcho) {
   ASSERT_NO_FATAL_FAILURE(RunTest("serial_unittest.js", "testSendAndStash"));
   scoped_ptr<ModuleSystemTestEnvironment> new_env(CreateEnvironment());
   ApiTestEnvironment new_api_test_env(new_env.get());
   PrepareEnvironment(&new_api_test_env, stash_backend_.get());
   new_api_test_env.RunTest("serial_unittest.js", "testRestoreAndReceive");
 }
 
 TEST_F(SerialApiTest, DISABLED_StashAndRestoreDuringEchoError) {
   io_handler_ =
-      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST);
+      new ReceiveErrorTestIoHandler(device::serial::ReceiveError::DEVICE_LOST);
   ASSERT_NO_FATAL_FAILURE(
       RunTest("serial_unittest.js", "testRestoreAndReceiveErrorSetUp"));
   scoped_ptr<ModuleSystemTestEnvironment> new_env(CreateEnvironment());
   ApiTestEnvironment new_api_test_env(new_env.get());
   PrepareEnvironment(&new_api_test_env, stash_backend_.get());
   new_api_test_env.RunTest("serial_unittest.js", "testRestoreAndReceiveError");
 }
 
 TEST_F(SerialApiTest, StashAndRestoreNoConnections) {
   ASSERT_NO_FATAL_FAILURE(
       RunTest("serial_unittest.js", "testStashNoConnections"));
   io_handler_ = nullptr;
   scoped_ptr<ModuleSystemTestEnvironment> new_env(CreateEnvironment());
   ApiTestEnvironment new_api_test_env(new_env.get());
   PrepareEnvironment(&new_api_test_env, stash_backend_.get());
   new_api_test_env.RunTest("serial_unittest.js", "testRestoreNoConnections");
 }
 
 }  // namespace extensions