For c++, Generate enum classes instead of enum from mojom.

apps/moterm/moterm_driver.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 "apps/moterm/moterm_driver.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 129 matching lines @@
       // In canonical mode, each read only gets a single line.
       if (icanon_ && data[i] == kNL) {
         data_size = i + 1;
         data.resize(data_size);
         break;
       }
     }
     send_data_queue_.erase(send_data_queue_.begin(),
                            send_data_queue_.begin() + data_size);
 
-    pending_read.callback.Run(mojo::files::ERROR_OK, data.Pass());
+    pending_read.callback.Run(mojo::files::Error::OK, data.Pass());
   }
 }
 
 void MotermDriver::FlushInputLine() {
   for (size_t i = 0; i < input_line_queue_.size(); i++)
     send_data_queue_.push_back(input_line_queue_[i]);
   input_line_queue_.clear();
   CompletePendingReads();
 }
 
@@ skipping 15 matching lines @@
   // TODO(vtl): It seems extremely unlikely that we'd overlow a |uint32_t| here
   // (but it's theoretically possible). But perhaps we should handle it more
   // gracefully if it ever comes up.
   CHECK_LE(translated_bytes.size(), std::numeric_limits<uint32_t>::max());
   client_->OnDataReceived(translated_bytes.data(),
                           static_cast<uint32_t>(translated_bytes.size()));
 }
 
 void MotermDriver::Close(const CloseCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED);
+    callback.Run(mojo::files::Error::CLOSED);
     return;
   }
 
   // TODO(vtl): Call pending read callbacks?
 
   is_closed_ = true;
-  callback.Run(mojo::files::ERROR_OK);
+  callback.Run(mojo::files::Error::OK);
 
   client_->OnClosed();
 }
 
 void MotermDriver::Read(uint32_t num_bytes_to_read,
                         int64_t offset,
                         mojo::files::Whence whence,
                         const ReadCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED, mojo::Array<uint8_t>());
+    callback.Run(mojo::files::Error::CLOSED, mojo::Array<uint8_t>());
     return;
   }
 
-  if (offset != 0 || whence != mojo::files::WHENCE_FROM_CURRENT) {
+  if (offset != 0 || whence != mojo::files::Whence::FROM_CURRENT) {
     // TODO(vtl): Is this the "right" behavior?
-    callback.Run(mojo::files::ERROR_INVALID_ARGUMENT, mojo::Array<uint8_t>());
+    callback.Run(mojo::files::Error::INVALID_ARGUMENT, mojo::Array<uint8_t>());
     return;
   }
 
   if (!num_bytes_to_read) {
-    callback.Run(mojo::files::ERROR_OK, mojo::Array<uint8_t>());
+    callback.Run(mojo::files::Error::OK, mojo::Array<uint8_t>());
     return;
   }
 
   pending_read_queue_.push_back(PendingRead(num_bytes_to_read, callback));
   CompletePendingReads();
 }
 
 void MotermDriver::Write(mojo::Array<uint8_t> bytes_to_write,
                          int64_t offset,
                          mojo::files::Whence whence,
                          const WriteCallback& callback) {
   DCHECK(!bytes_to_write.is_null());
 
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED, 0);
+    callback.Run(mojo::files::Error::CLOSED, 0);
     return;
   }
 
-  if (offset != 0 || whence != mojo::files::WHENCE_FROM_CURRENT) {
+  if (offset != 0 || whence != mojo::files::Whence::FROM_CURRENT) {
     // TODO(vtl): Is this the "right" behavior?
-    callback.Run(mojo::files::ERROR_INVALID_ARGUMENT, 0);
+    callback.Run(mojo::files::Error::INVALID_ARGUMENT, 0);
     return;
   }
 
   if (!bytes_to_write.size()) {
-    callback.Run(mojo::files::ERROR_OK, 0);
+    callback.Run(mojo::files::Error::OK, 0);
     return;
   }
 
   HandleOutput(&bytes_to_write.front(), bytes_to_write.size());
 
   // TODO(vtl): Is this OK if the client detached (and we're destroyed?).
-  callback.Run(mojo::files::ERROR_OK,
+  callback.Run(mojo::files::Error::OK,
                static_cast<uint32_t>(bytes_to_write.size()));
 }
 
 void MotermDriver::ReadToStream(mojo::ScopedDataPipeProducerHandle source,
                                 int64_t offset,
                                 mojo::files::Whence whence,
                                 int64_t num_bytes_to_read,
                                 const ReadToStreamCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED);
+    callback.Run(mojo::files::Error::CLOSED);
     return;
   }
 
   // TODO(vtl)
   NOTIMPLEMENTED();
-  callback.Run(mojo::files::ERROR_UNIMPLEMENTED);
+  callback.Run(mojo::files::Error::UNIMPLEMENTED);
 }
 
 void MotermDriver::WriteFromStream(mojo::ScopedDataPipeConsumerHandle sink,
                                    int64_t offset,
                                    mojo::files::Whence whence,
                                    const WriteFromStreamCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED);
+    callback.Run(mojo::files::Error::CLOSED);
     return;
   }
 
   // TODO(vtl)
   NOTIMPLEMENTED();
-  callback.Run(mojo::files::ERROR_UNIMPLEMENTED);
+  callback.Run(mojo::files::Error::UNIMPLEMENTED);
 }
 
 void MotermDriver::Tell(const TellCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED, 0);
+    callback.Run(mojo::files::Error::CLOSED, 0);
     return;
   }
 
   // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
   // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::ERROR_UNAVAILABLE, 0);
+  callback.Run(mojo::files::Error::UNAVAILABLE, 0);
 }
 
 void MotermDriver::Seek(int64_t offset,
                         mojo::files::Whence whence,
                         const SeekCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED, 0);
+    callback.Run(mojo::files::Error::CLOSED, 0);
     return;
   }
 
   // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
   // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::ERROR_UNAVAILABLE, 0);
+  callback.Run(mojo::files::Error::UNAVAILABLE, 0);
 }
 
 void MotermDriver::Stat(const StatCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED, nullptr);
+    callback.Run(mojo::files::Error::CLOSED, nullptr);
     return;
   }
 
   // TODO(vtl)
   NOTIMPLEMENTED();
-  callback.Run(mojo::files::ERROR_UNIMPLEMENTED, nullptr);
+  callback.Run(mojo::files::Error::UNIMPLEMENTED, nullptr);
 }
 
 void MotermDriver::Truncate(int64_t size, const TruncateCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED);
+    callback.Run(mojo::files::Error::CLOSED);
     return;
   }
 
   // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
   // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::ERROR_UNAVAILABLE);
+  callback.Run(mojo::files::Error::UNAVAILABLE);
 }
 
 void MotermDriver::Touch(mojo::files::TimespecOrNowPtr atime,
                          mojo::files::TimespecOrNowPtr mtime,
                          const TouchCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED);
+    callback.Run(mojo::files::Error::CLOSED);
     return;
   }
 
   // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
   // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::ERROR_UNAVAILABLE);
+  callback.Run(mojo::files::Error::UNAVAILABLE);
 }
 
 void MotermDriver::Dup(mojo::InterfaceRequest<mojo::files::File> file,
                        const DupCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED);
+    callback.Run(mojo::files::Error::CLOSED);
     return;
   }
 
   // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
   // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::ERROR_UNAVAILABLE);
+  callback.Run(mojo::files::Error::UNAVAILABLE);
 }
 
 void MotermDriver::Reopen(mojo::InterfaceRequest<mojo::files::File> file,
                           uint32_t open_flags,
                           const ReopenCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED);
+    callback.Run(mojo::files::Error::CLOSED);
     return;
   }
 
   // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
   // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::ERROR_UNAVAILABLE);
+  callback.Run(mojo::files::Error::UNAVAILABLE);
 }
 
 void MotermDriver::AsBuffer(const AsBufferCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED, mojo::ScopedSharedBufferHandle());
+    callback.Run(mojo::files::Error::CLOSED, mojo::ScopedSharedBufferHandle());
     return;
   }
 
   // TODO(vtl): Is this what we want? (Also is "unavailable" right? Maybe
   // unsupported/EINVAL is better.)
-  callback.Run(mojo::files::ERROR_UNAVAILABLE,
+  callback.Run(mojo::files::Error::UNAVAILABLE,
                mojo::ScopedSharedBufferHandle());
 }
 
 void MotermDriver::Ioctl(uint32_t request,
                          mojo::Array<uint32_t> in_values,
                          const IoctlCallback& callback) {
   if (is_closed_) {
-    callback.Run(mojo::files::ERROR_CLOSED, mojo::Array<uint32_t>());
+    callback.Run(mojo::files::Error::CLOSED, mojo::Array<uint32_t>());
     return;
   }
 
   if (request != mojo::files::kIoctlTerminal) {
-    callback.Run(mojo::files::ERROR_UNIMPLEMENTED, mojo::Array<uint32_t>());
+    callback.Run(mojo::files::Error::UNIMPLEMENTED, mojo::Array<uint32_t>());
     return;
   }
 
   // "Is TTY?" Yes.
   if (!in_values || !in_values.size()) {
-    callback.Run(mojo::files::ERROR_OK, mojo::Array<uint32_t>());
+    callback.Run(mojo::files::Error::OK, mojo::Array<uint32_t>());
     return;
   }
 
   switch (in_values[0]) {
     case mojo::files::kIoctlTerminalGetSettings:
       IoctlGetSettings(in_values.Pass(), callback);
       return;
     case mojo::files::kIoctlTerminalSetSettings:
       IoctlSetSettings(in_values.Pass(), callback);
       return;
     case mojo::files::kIoctlTerminalGetWindowSize:
     case mojo::files::kIoctlTerminalSetWindowSize:
       NOTIMPLEMENTED();
-      callback.Run(mojo::files::ERROR_UNIMPLEMENTED, mojo::Array<uint32_t>());
+      callback.Run(mojo::files::Error::UNIMPLEMENTED, mojo::Array<uint32_t>());
       return;
     default:
-      callback.Run(mojo::files::ERROR_UNIMPLEMENTED, mojo::Array<uint32_t>());
+      callback.Run(mojo::files::Error::UNIMPLEMENTED, mojo::Array<uint32_t>());
       return;
   }
 }
 
 void MotermDriver::IoctlGetSettings(mojo::Array<uint32_t> in_values,
                                     const IoctlCallback& callback) {
   if (in_values.size() != 1u) {
-    callback.Run(mojo::files::ERROR_INVALID_ARGUMENT, mojo::Array<uint32_t>());
+    callback.Run(mojo::files::Error::INVALID_ARGUMENT, mojo::Array<uint32_t>());
     return;
   }
 
   auto out_values = mojo::Array<uint32_t>::New(kTotalFieldCount);
 
   // TODO(vtl): Add support for various things. Also, some values should be
   // hard-coded.
 
   // iflag:
   if (icrnl_)
     out_values[kIFlagIdx] |= mojo::files::kIoctlTerminalTermiosIFlagICRNL;
 
   // oflag:
   if (onlcr_)
     out_values[kOFlagIdx] |= mojo::files::kIoctlTerminalTermiosOFlagONLCR;
 
   // lflag:
   if (icanon_)
     out_values[kLFlagIdx] |= mojo::files::kIoctlTerminalTermiosLFlagICANON;
 
   // cc:
   out_values[kVEraseIdx] = verase_;
   out_values[kVEOFIdx] = veof_;
 
-  callback.Run(mojo::files::ERROR_OK, out_values.Pass());
+  callback.Run(mojo::files::Error::OK, out_values.Pass());
 }
 
 void MotermDriver::IoctlSetSettings(mojo::Array<uint32_t> in_values,
                                     const IoctlCallback& callback) {
   callback.Run(IoctlSetSettingsHelper(in_values.Pass()),
                mojo::Array<uint32_t>());
 }
 
 mojo::files::Error MotermDriver::IoctlSetSettingsHelper(
     mojo::Array<uint32_t> in_values) {
   // Note: "termios" offsets (and sizes) are increased by 1, to accomodate the
   // subrequest at index 0.
 
   // The "cc" values are optional.
   if (in_values.size() < 1 + kBaseFieldCount)
-    return mojo::files::ERROR_INVALID_ARGUMENT;
+    return mojo::files::Error::INVALID_ARGUMENT;
 
   // TODO(vtl): Add support for various things. Also, some values can't be
   // changed.
 
   // iflag:
   icrnl_ = !!(in_values[1 + kIFlagIdx] &
               mojo::files::kIoctlTerminalTermiosIFlagICRNL);
 
   // oflag:
   onlcr_ = !!(in_values[1 + kOFlagIdx] &
               mojo::files::kIoctlTerminalTermiosOFlagONLCR);
 
   // lflag:
   icanon_ = !!(in_values[1 + kLFlagIdx] &
                mojo::files::kIoctlTerminalTermiosLFlagICANON);
 
   // TODO(vtl): Check that ispeed and ospeed are not set?
 
   // cc:
   if (1 + kVEraseIdx < in_values.size()) {
     uint32_t value = in_values[1 + kVEraseIdx];
     if (value > std::numeric_limits<uint8_t>::max())
-      return mojo::files::ERROR_INVALID_ARGUMENT;
+      return mojo::files::Error::INVALID_ARGUMENT;
     verase_ = static_cast<uint8_t>(value);
   }
   if (1 + kVEOFIdx < in_values.size()) {
     uint32_t value = in_values[1 + kVEOFIdx];
     if (value > std::numeric_limits<uint8_t>::max())
-      return mojo::files::ERROR_INVALID_ARGUMENT;
+      return mojo::files::Error::INVALID_ARGUMENT;
     veof_ = static_cast<uint8_t>(value);
   }
 
-  return mojo::files::ERROR_OK;
+  return mojo::files::Error::OK;
 }