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

services/view_manager/gesture_manager.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 "services/view_manager/gesture_manager.h"
 
 #include <algorithm>
 
 #include "mojo/services/input_events/public/interfaces/input_events.mojom.h"
 #include "mojo/services/view_manager/public/cpp/keys.h"
@@ skipping 464 matching lines @@
         gesture_to_choose = gesture;
       }
     }
   }
   if (view)
     gesture_manager_->ChooseGesture(gesture_to_choose, this, view);
 }
 
 bool GestureManager::Pointer::ScheduleDeleteIfNecessary() {
   if (current_event_ &&
-      (current_event_->action == mojo::EVENT_TYPE_POINTER_UP ||
-       current_event_->action == mojo::EVENT_TYPE_POINTER_CANCEL)) {
+      (current_event_->action == mojo::EventType::POINTER_UP ||
+       current_event_->action == mojo::EventType::POINTER_CANCEL)) {
     gesture_manager_->ScheduleDelete(this);
     return true;
   }
   return false;
 }
 
 // ScheduledDeleteProcessor ---------------------------------------------------
 
 class GestureManager::ScheduledDeleteProcessor {
  public:
@@ skipping 43 matching lines @@
 }
 
 bool GestureManager::ProcessEvent(const mojo::Event& event) {
   if (!event.pointer_data)
     return false;
 
   ScheduledDeleteProcessor delete_processor(this);
   const gfx::Point location(static_cast<int>(event.pointer_data->x),
                             static_cast<int>(event.pointer_data->y));
   switch (event.action) {
-    case mojo::EVENT_TYPE_POINTER_DOWN: {
+    case mojo::EventType::POINTER_DOWN: {
       if (GetPointerById(event.pointer_data->pointer_id)) {
         DVLOG(1) << "received more than one down for a pointer without a "
                  << "corresponding up, id=" << event.pointer_data->pointer_id;
         NOTREACHED();
         return true;
       }
 
       const ServerView* deepest = FindDeepestVisibleView(root_view_, location);
       Views targets(GetTouchTargets(deepest));
       if (targets.empty())
         return true;
 
       scoped_ptr<Pointer> pointer(
           new Pointer(this, event.pointer_data->pointer_id, event, targets));
       active_pointers_.push_back(pointer.Pass());
       return true;
     }
 
-    case mojo::EVENT_TYPE_POINTER_CANCEL:
-    case mojo::EVENT_TYPE_POINTER_MOVE:
-    case mojo::EVENT_TYPE_POINTER_UP: {
+    case mojo::EventType::POINTER_CANCEL:
+    case mojo::EventType::POINTER_MOVE:
+    case mojo::EventType::POINTER_UP: {
       Pointer* pointer = GetPointerById(event.pointer_data->pointer_id);
       // We delete a pointer when it has no gestures, so it's possible to get
       // here with no gestures. Additionally there is no need to explicitly
       // delete |pointer| as it'll tell us when it's ready to be deleted.
       if (pointer)
         pointer->ProcessEvent(event);
       return true;
     }
 
     default:
@@ skipping 110 matching lines @@
 void GestureManager::ScheduleDelete(Pointer* pointer) {
   auto iter =
       std::find(active_pointers_.begin(), active_pointers_.end(), pointer);
   if (iter != active_pointers_.end()) {
     active_pointers_.weak_erase(iter);
     pointers_to_delete_.push_back(pointer);
   }
 }
 
 }  // namespace view_manager