mus: Change namespace from mojo to mus.mojom for events.

BUG=548376

Review URL: https://codereview.chromium.org/1424923003

Cr-Commit-Position: refs/heads/master@{#356754}

2 files changed, 107 insertions, 97 deletions

diff --git a/mojo/converters/input_events/input_events_type_converters.cc b/mojo/converters/input_events/input_events_type_converters.cc
index bfd5f4e..4ab9253 100644
--- a/mojo/converters/input_events/input_events_type_converters.cc
+++ b/mojo/converters/input_events/input_events_type_converters.cc
@@ -19,21 +19,21 @@
 namespace mojo {
 namespace {
 
-ui::EventType MojoMouseEventTypeToUIEvent(const EventPtr& event) {
+ui::EventType MojoMouseEventTypeToUIEvent(const mus::mojom::EventPtr& event) {
   DCHECK(event->pointer_data);
-  DCHECK_EQ(POINTER_KIND_MOUSE, event->pointer_data->kind);
+  DCHECK_EQ(mus::mojom::POINTER_KIND_MOUSE, event->pointer_data->kind);
   switch (event->action) {
-    case EVENT_TYPE_POINTER_DOWN:
+    case mus::mojom::EVENT_TYPE_POINTER_DOWN:
       return ui::ET_MOUSE_PRESSED;
 
-    case EVENT_TYPE_POINTER_UP:
+    case mus::mojom::EVENT_TYPE_POINTER_UP:
       return ui::ET_MOUSE_RELEASED;
 
-    case EVENT_TYPE_POINTER_MOVE:
+    case mus::mojom::EVENT_TYPE_POINTER_MOVE:
       DCHECK(event->pointer_data);
-      if (event->flags &
-          (EVENT_FLAGS_LEFT_MOUSE_BUTTON | EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
-           EVENT_FLAGS_RIGHT_MOUSE_BUTTON)) {
+      if (event->flags & (mus::mojom::EVENT_FLAGS_LEFT_MOUSE_BUTTON |
+                          mus::mojom::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
+                          mus::mojom::EVENT_FLAGS_RIGHT_MOUSE_BUTTON)) {
         return ui::ET_MOUSE_DRAGGED;
       }
       return ui::ET_MOUSE_MOVED;
@@ -45,20 +45,20 @@ ui::EventType MojoMouseEventTypeToUIEvent(const EventPtr& event) {
   return ui::ET_MOUSE_RELEASED;
 }
 
-ui::EventType MojoTouchEventTypeToUIEvent(const EventPtr& event) {
+ui::EventType MojoTouchEventTypeToUIEvent(const mus::mojom::EventPtr& event) {
   DCHECK(event->pointer_data);
-  DCHECK_EQ(POINTER_KIND_TOUCH, event->pointer_data->kind);
+  DCHECK_EQ(mus::mojom::POINTER_KIND_TOUCH, event->pointer_data->kind);
   switch (event->action) {
-    case EVENT_TYPE_POINTER_DOWN:
+    case mus::mojom::EVENT_TYPE_POINTER_DOWN:
       return ui::ET_TOUCH_PRESSED;
 
-    case EVENT_TYPE_POINTER_UP:
+    case mus::mojom::EVENT_TYPE_POINTER_UP:
       return ui::ET_TOUCH_RELEASED;
 
-    case EVENT_TYPE_POINTER_MOVE:
+    case mus::mojom::EVENT_TYPE_POINTER_MOVE:
       return ui::ET_TOUCH_MOVED;
 
-    case EVENT_TYPE_POINTER_CANCEL:
+    case mus::mojom::EVENT_TYPE_POINTER_CANCEL:
       return ui::ET_TOUCH_CANCELLED;
 
     default:
@@ -68,13 +68,13 @@ ui::EventType MojoTouchEventTypeToUIEvent(const EventPtr& event) {
   return ui::ET_TOUCH_CANCELLED;
 }
 
-ui::EventType MojoWheelEventTypeToUIEvent(const EventPtr& event) {
+ui::EventType MojoWheelEventTypeToUIEvent(const mus::mojom::EventPtr& event) {
   DCHECK(event->pointer_data && event->pointer_data->wheel_data);
   return ui::ET_MOUSEWHEEL;
 }
 
 void SetPointerDataLocationFromEvent(const ui::LocatedEvent& located_event,
-                                     mojo::LocationData* location_data) {
+                                     mus::mojom::LocationData* location_data) {
   location_data->x = located_event.location_f().x();
   location_data->y = located_event.location_f().y();
   location_data->screen_x = located_event.root_location_f().x();
@@ -83,101 +83,105 @@ void SetPointerDataLocationFromEvent(const ui::LocatedEvent& located_event,
 
 }  // namespace
 
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_NONE) ==
-               static_cast<int32>(ui::EF_NONE),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_NONE) ==
+                   static_cast<int32>(ui::EF_NONE),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_CAPS_LOCK_DOWN) ==
-               static_cast<int32>(ui::EF_CAPS_LOCK_DOWN),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_CAPS_LOCK_DOWN) ==
+                   static_cast<int32>(ui::EF_CAPS_LOCK_DOWN),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_SHIFT_DOWN) ==
-               static_cast<int32>(ui::EF_SHIFT_DOWN),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_SHIFT_DOWN) ==
+                   static_cast<int32>(ui::EF_SHIFT_DOWN),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_CONTROL_DOWN) ==
-               static_cast<int32>(ui::EF_CONTROL_DOWN),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_CONTROL_DOWN) ==
+                   static_cast<int32>(ui::EF_CONTROL_DOWN),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_ALT_DOWN) ==
-               static_cast<int32>(ui::EF_ALT_DOWN),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_ALT_DOWN) ==
+                   static_cast<int32>(ui::EF_ALT_DOWN),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_LEFT_MOUSE_BUTTON) ==
-               static_cast<int32>(ui::EF_LEFT_MOUSE_BUTTON),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_LEFT_MOUSE_BUTTON) ==
+                   static_cast<int32>(ui::EF_LEFT_MOUSE_BUTTON),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_MIDDLE_MOUSE_BUTTON) ==
-               static_cast<int32>(ui::EF_MIDDLE_MOUSE_BUTTON),
+COMPILE_ASSERT(
+    static_cast<int32>(mus::mojom::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON) ==
+        static_cast<int32>(ui::EF_MIDDLE_MOUSE_BUTTON),
+    event_flags_should_match);
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_RIGHT_MOUSE_BUTTON) ==
+                   static_cast<int32>(ui::EF_RIGHT_MOUSE_BUTTON),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_RIGHT_MOUSE_BUTTON) ==
-               static_cast<int32>(ui::EF_RIGHT_MOUSE_BUTTON),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_COMMAND_DOWN) ==
+                   static_cast<int32>(ui::EF_COMMAND_DOWN),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_COMMAND_DOWN) ==
-               static_cast<int32>(ui::EF_COMMAND_DOWN),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_EXTENDED) ==
+                   static_cast<int32>(ui::EF_EXTENDED),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_EXTENDED) ==
-               static_cast<int32>(ui::EF_EXTENDED),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_IS_SYNTHESIZED) ==
+                   static_cast<int32>(ui::EF_IS_SYNTHESIZED),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_IS_SYNTHESIZED) ==
-               static_cast<int32>(ui::EF_IS_SYNTHESIZED),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_ALTGR_DOWN) ==
+                   static_cast<int32>(ui::EF_ALTGR_DOWN),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_ALTGR_DOWN) ==
-               static_cast<int32>(ui::EF_ALTGR_DOWN),
+COMPILE_ASSERT(static_cast<int32>(mus::mojom::EVENT_FLAGS_MOD3_DOWN) ==
+                   static_cast<int32>(ui::EF_MOD3_DOWN),
                event_flags_should_match);
-COMPILE_ASSERT(static_cast<int32>(EVENT_FLAGS_MOD3_DOWN) ==
-               static_cast<int32>(ui::EF_MOD3_DOWN),
-               event_flags_should_match);
-
 
 // static
-EventType TypeConverter<EventType, ui::EventType>::Convert(ui::EventType type) {
+mus::mojom::EventType
+TypeConverter<mus::mojom::EventType, ui::EventType>::Convert(
+    ui::EventType type) {
   switch (type) {
     case ui::ET_MOUSE_PRESSED:
     case ui::ET_TOUCH_PRESSED:
-      return EVENT_TYPE_POINTER_DOWN;
+      return mus::mojom::EVENT_TYPE_POINTER_DOWN;
 
     case ui::ET_MOUSE_DRAGGED:
     case ui::ET_MOUSE_MOVED:
     case ui::ET_MOUSE_ENTERED:
     case ui::ET_MOUSE_EXITED:
     case ui::ET_TOUCH_MOVED:
-      return EVENT_TYPE_POINTER_MOVE;
+      return mus::mojom::EVENT_TYPE_POINTER_MOVE;
 
     case ui::ET_MOUSEWHEEL:
-      return EVENT_TYPE_WHEEL;
+      return mus::mojom::EVENT_TYPE_WHEEL;
 
     case ui::ET_MOUSE_RELEASED:
     case ui::ET_TOUCH_RELEASED:
-      return EVENT_TYPE_POINTER_UP;
+      return mus::mojom::EVENT_TYPE_POINTER_UP;
 
     case ui::ET_TOUCH_CANCELLED:
-      return EVENT_TYPE_POINTER_CANCEL;
+      return mus::mojom::EVENT_TYPE_POINTER_CANCEL;
 
     case ui::ET_KEY_PRESSED:
-      return EVENT_TYPE_KEY_PRESSED;
+      return mus::mojom::EVENT_TYPE_KEY_PRESSED;
 
     case ui::ET_KEY_RELEASED:
-      return EVENT_TYPE_KEY_RELEASED;
+      return mus::mojom::EVENT_TYPE_KEY_RELEASED;
 
     default:
       break;
   }
-  return EVENT_TYPE_UNKNOWN;
+  return mus::mojom::EVENT_TYPE_UNKNOWN;
 }
 
-EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
-  const EventType type = ConvertTo<EventType>(input.type());
-  if (type == EVENT_TYPE_UNKNOWN)
+mus::mojom::EventPtr TypeConverter<mus::mojom::EventPtr, ui::Event>::Convert(
+    const ui::Event& input) {
+  const mus::mojom::EventType type =
+      ConvertTo<mus::mojom::EventType>(input.type());
+  if (type == mus::mojom::EVENT_TYPE_UNKNOWN)
     return nullptr;
 
-  EventPtr event = Event::New();
+  mus::mojom::EventPtr event = mus::mojom::Event::New();
   event->action = type;
-  event->flags = EventFlags(input.flags());
+  event->flags = mus::mojom::EventFlags(input.flags());
   event->time_stamp = input.time_stamp().ToInternalValue();
 
   if (input.IsMouseEvent()) {
     const ui::LocatedEvent* located_event =
         static_cast<const ui::LocatedEvent*>(&input);
-    PointerDataPtr pointer_data(PointerData::New());
+    mus::mojom::PointerDataPtr pointer_data(mus::mojom::PointerData::New());
     // TODO(sky): come up with a better way to handle this.
     pointer_data->pointer_id = std::numeric_limits<int32>::max();
-    pointer_data->kind = POINTER_KIND_MOUSE;
-    LocationDataPtr location_data(LocationData::New());
+    pointer_data->kind = mus::mojom::POINTER_KIND_MOUSE;
+    mus::mojom::LocationDataPtr location_data(mus::mojom::LocationData::New());
     SetPointerDataLocationFromEvent(*located_event, location_data.get());
     pointer_data->location = location_data.Pass();
 
@@ -185,11 +189,11 @@ EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
       const ui::MouseWheelEvent* wheel_event =
           static_cast<const ui::MouseWheelEvent*>(&input);
 
-      WheelDataPtr wheel_data(WheelData::New());
+      mus::mojom::WheelDataPtr wheel_data(mus::mojom::WheelData::New());
 
       // TODO(rjkroege): Support page scrolling on windows by directly
       // cracking into a mojo event when the native event is available.
-      wheel_data->mode = WHEEL_MODE_LINE;
+      wheel_data->mode = mus::mojom::WHEEL_MODE_LINE;
       // TODO(rjkroege): Support precise scrolling deltas.
 
       if ((input.flags() & ui::EF_SHIFT_DOWN) != 0 &&
@@ -210,14 +214,14 @@ EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
     const ui::TouchEvent* touch_event =
         static_cast<const ui::TouchEvent*>(&input);
 
-    PointerDataPtr pointer_data(PointerData::New());
+    mus::mojom::PointerDataPtr pointer_data(mus::mojom::PointerData::New());
     pointer_data->pointer_id = touch_event->touch_id();
-    pointer_data->kind = POINTER_KIND_TOUCH;
-    LocationDataPtr location_data(LocationData::New());
+    pointer_data->kind = mus::mojom::POINTER_KIND_TOUCH;
+    mus::mojom::LocationDataPtr location_data(mus::mojom::LocationData::New());
     SetPointerDataLocationFromEvent(*touch_event, location_data.get());
     pointer_data->location = location_data.Pass();
 
-    BrushDataPtr brush_data(BrushData::New());
+    mus::mojom::BrushDataPtr brush_data(mus::mojom::BrushData::New());
 
     // TODO(rjk): this is in the wrong coordinate system
     brush_data->width = touch_event->pointer_details().radius_x();
@@ -234,7 +238,7 @@ EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
     // TODO(rjkroege): Adjust brush data appropriately for Android.
   } else if (input.IsKeyEvent()) {
     const ui::KeyEvent* key_event = static_cast<const ui::KeyEvent*>(&input);
-    KeyDataPtr key_data(KeyData::New());
+    mus::mojom::KeyDataPtr key_data(mus::mojom::KeyData::New());
     key_data->key_code = key_event->GetConflatedWindowsKeyCode();
     key_data->native_key_code =
       ui::KeycodeConverter::DomCodeToNativeKeycode(key_event->code());
@@ -245,12 +249,12 @@ EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
       const MojoExtendedKeyEventData* data =
           static_cast<const MojoExtendedKeyEventData*>(
               key_event->extended_key_event_data());
-      key_data->windows_key_code = static_cast<mojo::KeyboardCode>(
-          data->windows_key_code());
+      key_data->windows_key_code =
+          static_cast<mus::mojom::KeyboardCode>(data->windows_key_code());
       key_data->text = data->text();
       key_data->unmodified_text = data->unmodified_text();
     } else {
-      key_data->windows_key_code = static_cast<mojo::KeyboardCode>(
+      key_data->windows_key_code = static_cast<mus::mojom::KeyboardCode>(
           key_event->GetLocatedWindowsKeyboardCode());
       key_data->text = key_event->GetText();
       key_data->unmodified_text = key_event->GetUnmodifiedText();
@@ -261,14 +265,15 @@ EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
 }
 
 // static
-EventPtr TypeConverter<EventPtr, ui::KeyEvent>::Convert(
+mus::mojom::EventPtr TypeConverter<mus::mojom::EventPtr, ui::KeyEvent>::Convert(
     const ui::KeyEvent& input) {
-  return Event::From(static_cast<const ui::Event&>(input));
+  return mus::mojom::Event::From(static_cast<const ui::Event&>(input));
 }
 
 // static
-scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
-    const EventPtr& input) {
+scoped_ptr<ui::Event>
+TypeConverter<scoped_ptr<ui::Event>, mus::mojom::EventPtr>::Convert(
+    const mus::mojom::EventPtr& input) {
   gfx::PointF location;
   gfx::PointF screen_location;
   if (input->pointer_data && input->pointer_data->location) {
@@ -279,8 +284,8 @@ scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
   }
 
   switch (input->action) {
-    case EVENT_TYPE_KEY_PRESSED:
-    case EVENT_TYPE_KEY_RELEASED: {
+    case mus::mojom::EVENT_TYPE_KEY_PRESSED:
+    case mus::mojom::EVENT_TYPE_KEY_RELEASED: {
       scoped_ptr<ui::KeyEvent> key_event;
       if (input->key_data->is_char) {
         key_event.reset(new ui::KeyEvent(
@@ -290,8 +295,9 @@ scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
             input->flags));
       } else {
         key_event.reset(new ui::KeyEvent(
-            input->action == EVENT_TYPE_KEY_PRESSED ? ui::ET_KEY_PRESSED
-                                                    : ui::ET_KEY_RELEASED,
+            input->action == mus::mojom::EVENT_TYPE_KEY_PRESSED
+                ? ui::ET_KEY_PRESSED
+                : ui::ET_KEY_RELEASED,
 
             static_cast<ui::KeyboardCode>(input->key_data->key_code),
             input->flags));
@@ -303,12 +309,12 @@ scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
               input->key_data->unmodified_text)));
       return key_event.Pass();
     }
-    case EVENT_TYPE_POINTER_DOWN:
-    case EVENT_TYPE_POINTER_UP:
-    case EVENT_TYPE_POINTER_MOVE:
-    case EVENT_TYPE_POINTER_CANCEL: {
+    case mus::mojom::EVENT_TYPE_POINTER_DOWN:
+    case mus::mojom::EVENT_TYPE_POINTER_UP:
+    case mus::mojom::EVENT_TYPE_POINTER_MOVE:
+    case mus::mojom::EVENT_TYPE_POINTER_CANCEL: {
       switch (input->pointer_data->kind) {
-        case POINTER_KIND_MOUSE: {
+        case mus::mojom::POINTER_KIND_MOUSE: {
           // TODO: last flags isn't right. Need to send changed_flags.
           scoped_ptr<ui::MouseEvent> event(new ui::MouseEvent(
               MojoMouseEventTypeToUIEvent(input), location, screen_location,
@@ -316,7 +322,7 @@ scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
               ui::EventFlags(input->flags)));
           return event.Pass();
         } break;
-        case POINTER_KIND_TOUCH: {
+        case mus::mojom::POINTER_KIND_TOUCH: {
           DCHECK(input->pointer_data->brush_data);
           scoped_ptr<ui::TouchEvent> touch_event(new ui::TouchEvent(
               MojoTouchEventTypeToUIEvent(input), location,
@@ -328,12 +334,12 @@ scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
           touch_event->set_root_location(screen_location);
           return touch_event.Pass();
         } break;
-        case POINTER_KIND_PEN:
+        case mus::mojom::POINTER_KIND_PEN:
           NOTIMPLEMENTED();
           break;
       }
     } break;
-    case EVENT_TYPE_WHEEL: {
+    case mus::mojom::EVENT_TYPE_WHEEL: {
       DCHECK(input->pointer_data && input->pointer_data->wheel_data);
       scoped_ptr<ui::MouseEvent> pre_wheel_event(new ui::MouseEvent(
           MojoWheelEventTypeToUIEvent(input), location, screen_location,
diff --git a/mojo/converters/input_events/input_events_type_converters.h b/mojo/converters/input_events/input_events_type_converters.h
index 145de41..5f3223c6 100644
--- a/mojo/converters/input_events/input_events_type_converters.h
+++ b/mojo/converters/input_events/input_events_type_converters.h
@@ -15,28 +15,32 @@ namespace mojo {
 // NOTE: the mojo input events do not necessarily provide a 1-1 mapping with
 // ui::Event types. Be careful in using them!
 template <>
-struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventType, ui::EventType> {
-  static EventType Convert(ui::EventType type);
+struct MOJO_INPUT_EVENTS_EXPORT
+    TypeConverter<mus::mojom::EventType, ui::EventType> {
+  static mus::mojom::EventType Convert(ui::EventType type);
 };
 
 template <>
-struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr, ui::Event> {
-  static EventPtr Convert(const ui::Event& input);
+struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<mus::mojom::EventPtr, ui::Event> {
+  static mus::mojom::EventPtr Convert(const ui::Event& input);
 };
 
 template <>
-struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr, ui::KeyEvent> {
-  static EventPtr Convert(const ui::KeyEvent& input);
+struct MOJO_INPUT_EVENTS_EXPORT
+    TypeConverter<mus::mojom::EventPtr, ui::KeyEvent> {
+  static mus::mojom::EventPtr Convert(const ui::KeyEvent& input);
 };
 
 template <>
-struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<EventPtr, ui::GestureEvent> {
-  static EventPtr Convert(const ui::GestureEvent& input);
+struct MOJO_INPUT_EVENTS_EXPORT
+    TypeConverter<mus::mojom::EventPtr, ui::GestureEvent> {
+  static mus::mojom::EventPtr Convert(const ui::GestureEvent& input);
 };
 
 template <>
-struct MOJO_INPUT_EVENTS_EXPORT TypeConverter<scoped_ptr<ui::Event>, EventPtr> {
-  static scoped_ptr<ui::Event> Convert(const EventPtr& input);
+struct MOJO_INPUT_EVENTS_EXPORT
+    TypeConverter<scoped_ptr<ui::Event>, mus::mojom::EventPtr> {
+  static scoped_ptr<ui::Event> Convert(const mus::mojom::EventPtr& input);
 };
 
 }  // namespace mojo