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

apps/moterm/moterm_view.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_view.h"
 
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES
 #endif
 
@@ skipping 100 matching lines @@
                                      const mojo::Rect& old_bounds,
                                      const mojo::Rect& new_bounds) {
   DCHECK_EQ(view, view_);
   gl_helper_.SetSurfaceSize(RectToSize(view_->bounds()));
   bitmap_device_.clear();
   Draw(true);
 }
 
 void MotermView::OnViewInputEvent(mojo::View* view,
                                   const mojo::EventPtr& event) {
-  if (event->action == mojo::EVENT_TYPE_KEY_PRESSED)
+  if (event->action == mojo::EventType::KEY_PRESSED)
     OnKeyPressed(event);
 }
 
 void MotermView::OnSurfaceIdChanged(mojo::SurfaceIdPtr surface_id) {
   view_->SetSurfaceId(surface_id.Pass());
 }
 
 void MotermView::OnContextLost() {
   // TODO(vtl): We'll need to force a draw when we regain a context.
 }
@@ skipping 44 matching lines @@
 void MotermView::Connect(
     mojo::InterfaceRequest<mojo::files::File> terminal_file,
     bool force,
     const ConnectCallback& callback) {
   if (driver_) {
     // We already have a connection.
     if (force) {
       OnClosed();
     } else {
       // TODO(vtl): Is this error code right?
-      callback.Run(mojo::files::ERROR_UNAVAILABLE);
+      callback.Run(mojo::files::Error::UNAVAILABLE);
       return;
     }
   }
 
   driver_ = MotermDriver::Create(this, terminal_file.Pass());
   DCHECK(on_closed_callback_.is_null());
-  on_closed_callback_ = [callback] { callback.Run(mojo::files::ERROR_OK); };
+  on_closed_callback_ = [callback] { callback.Run(mojo::files::Error::OK); };
 }
 
 void MotermView::ConnectToClient(
     mojo::terminal::TerminalClientPtr terminal_client,
     bool force,
     const ConnectToClientCallback& callback) {
   if (driver_) {
     // We already have a connection.
     if (force) {
       OnClosed();
     } else {
       // TODO(vtl): Is this error code right?
-      callback.Run(mojo::files::ERROR_UNAVAILABLE);
+      callback.Run(mojo::files::Error::UNAVAILABLE);
       return;
     }
   }
 
   mojo::files::FilePtr file;
   driver_ = MotermDriver::Create(this, GetProxy(&file));
   terminal_client->ConnectToTerminal(file.Pass());
   DCHECK(on_closed_callback_.is_null());
-  on_closed_callback_ = [callback] { callback.Run(mojo::files::ERROR_OK); };
+  on_closed_callback_ = [callback] { callback.Run(mojo::files::Error::OK); };
 }
 
 void MotermView::GetSize(const GetSizeCallback& callback) {
   MotermModel::Size size = model_.GetSize();
-  callback.Run(mojo::files::ERROR_OK, size.rows, size.columns);
+  callback.Run(mojo::files::Error::OK, size.rows, size.columns);
 }
 
 void MotermView::SetSize(uint32_t rows,
                          uint32_t columns,
                          bool reset,
                          const SetSizeCallback& callback) {
   if (!rows) {
     rows = std::max(1u, std::min(MotermModel::kMaxRows,
                                  static_cast<uint32_t>(view_->bounds().height) /
                                      line_height_));
   }
   if (!columns) {
     columns =
         std::max(1u, std::min(MotermModel::kMaxColumns,
                               static_cast<uint32_t>(view_->bounds().width) /
                                   advance_width_));
   }
 
   model_.SetSize(MotermModel::Size(rows, columns), reset);
-  callback.Run(mojo::files::ERROR_OK, rows, columns);
+  callback.Run(mojo::files::Error::OK, rows, columns);
 
   Draw(false);
 }
 
 void MotermView::Draw(bool force) {
   // TODO(vtl): See TODO above |frame_pending_| in the class declaration.
   if (frame_pending_) {
     force_next_draw_ |= force;
     return;
   }
@@ skipping 95 matching lines @@
 
 void MotermView::OnKeyPressed(const mojo::EventPtr& key_event) {
   std::string input_sequence =
       GetInputSequenceForKeyPressedEvent(*key_event, keypad_application_mode_);
   if (input_sequence.empty())
     return;
 
   if (driver_)
     driver_->SendData(input_sequence.data(), input_sequence.size());
 }