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

components/mus/ws/event_dispatcher_unittest.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 "components/mus/ws/event_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 186 matching lines @@
       static_cast<ui::MouseEvent*>(dispatched_event.get());
   EXPECT_EQ(gfx::Point(20, 25), dispatched_mouse_event->root_location());
   EXPECT_EQ(gfx::Point(10, 15), dispatched_mouse_event->location());
 }
 
 TEST(EventDispatcherTest, AcceleratorBasic) {
   TestEventDispatcherDelegate event_dispatcher_delegate(nullptr);
   EventDispatcher dispatcher(&event_dispatcher_delegate);
   uint32_t accelerator_1 = 1;
   mojom::EventMatcherPtr matcher = mus::CreateKeyMatcher(
-      mus::mojom::KEYBOARD_CODE_W, mus::mojom::EVENT_FLAGS_CONTROL_DOWN);
+      mus::mojom::KeyboardCode::W, mus::mojom::kEventFlagControlDown);
   EXPECT_TRUE(dispatcher.AddAccelerator(accelerator_1, std::move(matcher)));
 
   uint32_t accelerator_2 = 2;
-  matcher = mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_N,
-                                  mus::mojom::EVENT_FLAGS_NONE);
+  matcher = mus::CreateKeyMatcher(mus::mojom::KeyboardCode::N,
+                                  mus::mojom::kEventFlagNone);
   EXPECT_TRUE(dispatcher.AddAccelerator(accelerator_2, std::move(matcher)));
 
   // Attempting to add a new accelerator with the same id should fail.
-  matcher = mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_T,
-                                  mus::mojom::EVENT_FLAGS_NONE);
+  matcher = mus::CreateKeyMatcher(mus::mojom::KeyboardCode::T,
+                                  mus::mojom::kEventFlagNone);
   EXPECT_FALSE(dispatcher.AddAccelerator(accelerator_2, std::move(matcher)));
 
   // Adding the accelerator with the same id should succeed once the existing
   // accelerator is removed.
   dispatcher.RemoveAccelerator(accelerator_2);
-  matcher = mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_T,
-                                  mus::mojom::EVENT_FLAGS_NONE);
+  matcher = mus::CreateKeyMatcher(mus::mojom::KeyboardCode::T,
+                                  mus::mojom::kEventFlagNone);
   EXPECT_TRUE(dispatcher.AddAccelerator(accelerator_2, std::move(matcher)));
 
   // Attempting to add an accelerator with the same matcher should fail.
   uint32_t accelerator_3 = 3;
-  matcher = mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_T,
-                                  mus::mojom::EVENT_FLAGS_NONE);
+  matcher = mus::CreateKeyMatcher(mus::mojom::KeyboardCode::T,
+                                  mus::mojom::kEventFlagNone);
   EXPECT_FALSE(dispatcher.AddAccelerator(accelerator_3, std::move(matcher)));
 
-  matcher = mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_T,
-                                  mus::mojom::EVENT_FLAGS_CONTROL_DOWN);
+  matcher = mus::CreateKeyMatcher(mus::mojom::KeyboardCode::T,
+                                  mus::mojom::kEventFlagControlDown);
   EXPECT_TRUE(dispatcher.AddAccelerator(accelerator_3, std::move(matcher)));
 }
 
 TEST(EventDispatcherTest, EventMatching) {
   TestServerWindowDelegate window_delegate;
   ServerWindow root(&window_delegate, WindowId(1, 2));
   TestEventDispatcherDelegate event_dispatcher_delegate(&root);
   EventDispatcher dispatcher(&event_dispatcher_delegate);
   dispatcher.set_root(&root);
 
   mojom::EventMatcherPtr matcher = mus::CreateKeyMatcher(
-      mus::mojom::KEYBOARD_CODE_W, mus::mojom::EVENT_FLAGS_CONTROL_DOWN);
+      mus::mojom::KeyboardCode::W, mus::mojom::kEventFlagControlDown);
   uint32_t accelerator_1 = 1;
   dispatcher.AddAccelerator(accelerator_1, std::move(matcher));
 
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   dispatcher.ProcessEvent(mojom::Event::From(key));
   EXPECT_EQ(accelerator_1,
             event_dispatcher_delegate.GetAndClearLastAccelerator());
 
   // EF_NUM_LOCK_ON should be ignored since CreateKeyMatcher defaults to
   // ignoring.
   key = ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_W,
                      ui::EF_CONTROL_DOWN | ui::EF_NUM_LOCK_ON);
   dispatcher.ProcessEvent(mojom::Event::From(key));
   EXPECT_EQ(accelerator_1,
             event_dispatcher_delegate.GetAndClearLastAccelerator());
 
   key = ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_NONE);
   dispatcher.ProcessEvent(mojom::Event::From(key));
   EXPECT_EQ(0u, event_dispatcher_delegate.GetAndClearLastAccelerator());
 
   uint32_t accelerator_2 = 2;
-  matcher = mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_W,
-                                  mus::mojom::EVENT_FLAGS_NONE);
+  matcher = mus::CreateKeyMatcher(mus::mojom::KeyboardCode::W,
+                                  mus::mojom::kEventFlagNone);
   dispatcher.AddAccelerator(accelerator_2, std::move(matcher));
   dispatcher.ProcessEvent(mojom::Event::From(key));
   EXPECT_EQ(accelerator_2,
             event_dispatcher_delegate.GetAndClearLastAccelerator());
 
   dispatcher.RemoveAccelerator(accelerator_2);
   dispatcher.ProcessEvent(mojom::Event::From(key));
   EXPECT_EQ(0u, event_dispatcher_delegate.GetAndClearLastAccelerator());
 }
 
@@ skipping 171 matching lines @@
   // should get an exit first.
   const ui::MouseEvent press_event2(
       ui::ET_MOUSE_PRESSED, gfx::Point(21, 22), gfx::Point(21, 22),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   dispatcher.ProcessEvent(
       mojom::Event::From(static_cast<const ui::Event&>(press_event2)));
   details = event_dispatcher_delegate.GetAndAdvanceDispatchedEventDetails();
   EXPECT_TRUE(event_dispatcher_delegate.has_queued_events());
   ASSERT_EQ(&child, details->window);
   EXPECT_TRUE(details->in_nonclient_area);
-  EXPECT_EQ(mojom::EVENT_TYPE_MOUSE_EXIT, details->event->action);
+  EXPECT_EQ(mojom::EventType::MOUSE_EXIT, details->event->action);
 
   details = event_dispatcher_delegate.GetAndAdvanceDispatchedEventDetails();
   EXPECT_FALSE(event_dispatcher_delegate.has_queued_events());
   ASSERT_EQ(&child, details->window);
   EXPECT_FALSE(details->in_nonclient_area);
-  EXPECT_EQ(mojom::EVENT_TYPE_POINTER_DOWN, details->event->action);
+  EXPECT_EQ(mojom::EventType::POINTER_DOWN, details->event->action);
 }
 
 TEST(EventDispatcherTest, AdditionalClientArea) {
   TestServerWindowDelegate window_delegate;
   ServerWindow root(&window_delegate, WindowId(1, 2));
   window_delegate.set_root_window(&root);
   root.SetVisible(true);
 
   ServerWindow child(&window_delegate, WindowId(1, 3));
   root.Add(&child);
@@ skipping 231 matching lines @@
   ASSERT_EQ(&root, details->window);
   EXPECT_FALSE(details->in_nonclient_area);
 
   // Change the extended hit test region and send event in extended hit test
   // region. Should result in exit for root, followed by press for child.
   child.set_extended_hit_test_region(gfx::Insets(5, 5, 5, 5));
   dispatcher.ProcessEvent(
       mojom::Event::From(static_cast<const ui::Event&>(ui_event)));
   details = event_dispatcher_delegate.GetAndAdvanceDispatchedEventDetails();
   EXPECT_EQ(&root, details->window);
-  EXPECT_EQ(mojom::EVENT_TYPE_MOUSE_EXIT, details->event->action);
+  EXPECT_EQ(mojom::EventType::MOUSE_EXIT, details->event->action);
   details = event_dispatcher_delegate.GetAndAdvanceDispatchedEventDetails();
   ASSERT_TRUE(details);
 
   EXPECT_FALSE(event_dispatcher_delegate.has_queued_events());
   EXPECT_TRUE(details->in_nonclient_area);
   ASSERT_EQ(&child, details->window);
-  EXPECT_EQ(mojom::EVENT_TYPE_POINTER_DOWN, details->event->action);
+  EXPECT_EQ(mojom::EventType::POINTER_DOWN, details->event->action);
   scoped_ptr<ui::Event> dispatched_event(
       details->event.To<scoped_ptr<ui::Event>>());
   ASSERT_TRUE(dispatched_event.get());
   ASSERT_TRUE(dispatched_event->IsMouseEvent());
   ui::MouseEvent* dispatched_mouse_event =
       static_cast<ui::MouseEvent*>(dispatched_event.get());
   EXPECT_EQ(gfx::Point(-2, -1), dispatched_mouse_event->location());
 }
 
 TEST(EventDispatcherTest, WheelWhileDown) {
@@ skipping 33 matching lines @@
                            ui::EF_NONE),
        &child1, gfx::Point(53, 54), gfx::Point(43, 44), nullptr, gfx::Point(),
        gfx::Point()},
   };
   RunMouseEventTests(&dispatcher, &event_dispatcher_delegate, tests,
                      arraysize(tests));
 }
 
 }  // namespace ws
 }  // namespace mus