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

examples/native_run_app/native_run_app.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.
 
 // This is a terminal client (i.e., a "raw" |mojo.terminal.Terminal| -- e.g.,
 // moterm -- can be asked to talk to this) that prompts the user for a native
 // (Linux) binary to run and then does so (via mojo:native_support).
 //
 // E.g., first run mojo:moterm_example_app (embedded by a window manager). Then,
 // at the prompt, enter "mojo:native_run_app". At the next prompt, enter "bash"
@@ skipping 36 matching lines @@
     terminal_.set_connection_error_handler([this]() { delete this; });
     Start();
   }
   ~TerminalConnection() {}
 
  private:
   void Write(const char* s, mojo::files::File::WriteCallback callback) {
     size_t length = strlen(s);
     mojo::Array<uint8_t> a(length);
     memcpy(&a[0], s, length);
-    terminal_->Write(a.Pass(), 0, mojo::files::WHENCE_FROM_CURRENT, callback);
+    terminal_->Write(a.Pass(), 0, mojo::files::Whence::FROM_CURRENT, callback);
   }
 
   void Start() {
     // TODO(vtl): Check canonical mode (via ioctl) first (or before |Read()|).
 
     const char kPrompt[] = "\x1b[0mNative program to run?\n>>> ";
     Write(kPrompt, [this](mojo::files::Error error, uint32_t) {
       this->DidWritePrompt(error);
     });
   }
   void DidWritePrompt(mojo::files::Error error) {
-    if (error != mojo::files::ERROR_OK) {
+    if (error != mojo::files::Error::OK) {
       LOG(ERROR) << "Write() error: " << error;
       delete this;
       return;
     }
 
     terminal_->Read(
-        1000, 0, mojo::files::WHENCE_FROM_CURRENT,
+        1000, 0, mojo::files::Whence::FROM_CURRENT,
         [this](mojo::files::Error error, mojo::Array<uint8_t> bytes_read) {
           this->DidReadFromPrompt(error, bytes_read.Pass());
         });
   }
   void DidReadFromPrompt(mojo::files::Error error,
                          mojo::Array<uint8_t> bytes_read) {
-    if (error != mojo::files::ERROR_OK || !bytes_read.size()) {
+    if (error != mojo::files::Error::OK || !bytes_read.size()) {
       LOG(ERROR) << "Read() error: " << error;
       delete this;
       return;
     }
 
     std::string input(reinterpret_cast<const char*>(&bytes_read[0]),
                       bytes_read.size());
     command_line_.clear();
     base::SplitStringAlongWhitespace(input, &command_line_);
 
@@ skipping 10 matching lines @@
     mojo::Array<uint32_t> in_values = mojo::Array<uint32_t>::New(1);
     in_values[0] = mojo::files::kIoctlTerminalGetSettings;
     terminal_->Ioctl(
         mojo::files::kIoctlTerminal, in_values.Pass(),
         [this](mojo::files::Error error, mojo::Array<uint32_t> out_values) {
           this->DidGetTerminalSettings(error, out_values.Pass());
         });
   }
   void DidGetTerminalSettings(mojo::files::Error error,
                               mojo::Array<uint32_t> out_values) {
-    if (error != mojo::files::ERROR_OK || out_values.size() < 6) {
+    if (error != mojo::files::Error::OK || out_values.size() < 6) {
       LOG(ERROR) << "Ioctl() (terminal get settings) error: " << error;
       delete this;
       return;
     }
 
     const size_t kBaseFieldCount =
         mojo::files::kIoctlTerminalTermiosBaseFieldCount;
     const uint32_t kLFlagIdx = mojo::files::kIoctlTerminalTermiosLFlagIndex;
     const uint32_t kLFlagICANON = mojo::files::kIoctlTerminalTermiosLFlagICANON;
 
     auto in_values = mojo::Array<uint32_t>::New(1 + kBaseFieldCount);
     in_values[0] = mojo::files::kIoctlTerminalSetSettings;
     for (size_t i = 0; i < kBaseFieldCount; i++)
       in_values[1 + i] = out_values[i];
     // Just turn off ICANON, which is in "lflag".
     in_values[1 + kLFlagIdx] &= ~kLFlagICANON;
     terminal_->Ioctl(
         mojo::files::kIoctlTerminal, in_values.Pass(),
         [this](mojo::files::Error error, mojo::Array<uint32_t> out_values) {
           this->DidSetTerminalSettings(error, out_values.Pass());
         });
   }
   void DidSetTerminalSettings(mojo::files::Error error,
                               mojo::Array<uint32_t> out_values) {
-    if (error != mojo::files::ERROR_OK) {
+    if (error != mojo::files::Error::OK) {
       LOG(ERROR) << "Ioctl() (terminal set settings) error: " << error;
       delete this;
       return;
     }
 
     // Now, we can spawn.
     mojo::String path(command_line_[0]);
     mojo::Array<mojo::String> argv;
     for (const auto& arg : command_line_)
       argv.push_back(arg);
 
     // TODO(vtl): If the |InterfacePtr| underlying |native_support_process_|
     // encounters an error, then we're sort of dead in the water.
     native_support_process_->SpawnWithTerminal(
         path, argv.Pass(), mojo::Array<mojo::String>(), terminal_.Pass(),
         GetProxy(&process_controller_), [this](mojo::files::Error error) {
           this->DidSpawnWithTerminal(error);
         });
     process_controller_.set_connection_error_handler([this]() { delete this; });
   }
   void DidSpawnWithTerminal(mojo::files::Error error) {
-    if (error != mojo::files::ERROR_OK) {
+    if (error != mojo::files::Error::OK) {
       LOG(ERROR) << "SpawnWithTerminal() error: " << error;
       delete this;
       return;
     }
     process_controller_->Wait(
         [this](mojo::files::Error error, int32_t exit_status) {
           this->DidWait(error, exit_status);
         });
   }
   void DidWait(mojo::files::Error error, int32_t exit_status) {
-    if (error != mojo::files::ERROR_OK)
+    if (error != mojo::files::Error::OK)
       LOG(ERROR) << "Wait() error: " << error;
     else if (exit_status != 0)  // |exit_status| only valid if OK.
       LOG(ERROR) << "Process exit status: " << exit_status;
 
     // We're done, regardless.
     delete this;
   }
 
   mojo::files::FilePtr terminal_;
   native_support::Process* native_support_process_;
@@ skipping 59 matching lines @@
   mojo::ApplicationImpl* application_impl_;
   native_support::ProcessPtr native_support_process_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeRunApp);
 };
 
 MojoResult MojoMain(MojoHandle application_request) {
   mojo::ApplicationRunnerChromium runner(new NativeRunApp());
   return runner.Run(application_request);
 }