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}

41 files changed, 369 insertions, 342 deletions

diff --git a/components/html_viewer/blink_input_events_type_converters.cc b/components/html_viewer/blink_input_events_type_converters.cc
index e81b44a..5b36a77 100644
--- a/components/html_viewer/blink_input_events_type_converters.cc
+++ b/components/html_viewer/blink_input_events_type_converters.cc
@@ -13,53 +13,56 @@
 namespace mojo {
 namespace {
 
-double EventTimeToWebEventTime(const EventPtr& event) {
+double EventTimeToWebEventTime(const mus::mojom::EventPtr& event) {
   return base::TimeDelta::FromInternalValue(event->time_stamp).InSecondsF();
 }
 
 int EventFlagsToWebEventModifiers(int flags) {
   int modifiers = 0;
 
-  if (flags & mojo::EVENT_FLAGS_SHIFT_DOWN)
+  if (flags & mus::mojom::EVENT_FLAGS_SHIFT_DOWN)
     modifiers |= blink::WebInputEvent::ShiftKey;
-  if (flags & mojo::EVENT_FLAGS_CONTROL_DOWN)
+  if (flags & mus::mojom::EVENT_FLAGS_CONTROL_DOWN)
     modifiers |= blink::WebInputEvent::ControlKey;
-  if (flags & mojo::EVENT_FLAGS_ALT_DOWN)
+  if (flags & mus::mojom::EVENT_FLAGS_ALT_DOWN)
     modifiers |= blink::WebInputEvent::AltKey;
   // TODO(beng): MetaKey/META_MASK
-  if (flags & mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON)
+  if (flags & mus::mojom::EVENT_FLAGS_LEFT_MOUSE_BUTTON)
     modifiers |= blink::WebInputEvent::LeftButtonDown;
-  if (flags & mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON)
+  if (flags & mus::mojom::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON)
     modifiers |= blink::WebInputEvent::MiddleButtonDown;
-  if (flags & mojo::EVENT_FLAGS_RIGHT_MOUSE_BUTTON)
+  if (flags & mus::mojom::EVENT_FLAGS_RIGHT_MOUSE_BUTTON)
     modifiers |= blink::WebInputEvent::RightButtonDown;
-  if (flags & mojo::EVENT_FLAGS_CAPS_LOCK_DOWN)
+  if (flags & mus::mojom::EVENT_FLAGS_CAPS_LOCK_DOWN)
     modifiers |= blink::WebInputEvent::CapsLockOn;
   return modifiers;
 }
 
 int EventFlagsToWebInputEventModifiers(int flags) {
-  return
-      (flags & mojo::EVENT_FLAGS_SHIFT_DOWN ?
-       blink::WebInputEvent::ShiftKey : 0) |
-      (flags & mojo::EVENT_FLAGS_CONTROL_DOWN ?
-       blink::WebInputEvent::ControlKey : 0) |
-      (flags & mojo::EVENT_FLAGS_CAPS_LOCK_DOWN ?
-       blink::WebInputEvent::CapsLockOn : 0) |
-      (flags & mojo::EVENT_FLAGS_ALT_DOWN ?
-       blink::WebInputEvent::AltKey : 0);
+  return (flags & mus::mojom::EVENT_FLAGS_SHIFT_DOWN
+              ? blink::WebInputEvent::ShiftKey
+              : 0) |
+         (flags & mus::mojom::EVENT_FLAGS_CONTROL_DOWN
+              ? blink::WebInputEvent::ControlKey
+              : 0) |
+         (flags & mus::mojom::EVENT_FLAGS_CAPS_LOCK_DOWN
+              ? blink::WebInputEvent::CapsLockOn
+              : 0) |
+         (flags & mus::mojom::EVENT_FLAGS_ALT_DOWN
+              ? blink::WebInputEvent::AltKey
+              : 0);
 }
 
 int GetClickCount(int flags) {
-  if (flags & mojo::MOUSE_EVENT_FLAGS_IS_TRIPLE_CLICK)
+  if (flags & mus::mojom::MOUSE_EVENT_FLAGS_IS_TRIPLE_CLICK)
     return 3;
-  else if (flags & mojo::MOUSE_EVENT_FLAGS_IS_DOUBLE_CLICK)
+  else if (flags & mus::mojom::MOUSE_EVENT_FLAGS_IS_DOUBLE_CLICK)
     return 2;
 
   return 1;
 }
 
-void SetWebMouseEventLocation(const mojo::LocationData& location_data,
+void SetWebMouseEventLocation(const mus::mojom::LocationData& location_data,
                               blink::WebMouseEvent* web_event) {
   web_event->x = static_cast<int>(location_data.x);
   web_event->y = static_cast<int>(location_data.y);
@@ -67,7 +70,8 @@ void SetWebMouseEventLocation(const mojo::LocationData& location_data,
   web_event->globalY = static_cast<int>(location_data.screen_y);
 }
 
-scoped_ptr<blink::WebInputEvent> BuildWebMouseEventFrom(const EventPtr& event) {
+scoped_ptr<blink::WebInputEvent> BuildWebMouseEventFrom(
+    const mus::mojom::EventPtr& event) {
   scoped_ptr<blink::WebMouseEvent> web_event(new blink::WebMouseEvent);
 
   if (event->pointer_data && event->pointer_data->location)
@@ -77,21 +81,21 @@ scoped_ptr<blink::WebInputEvent> BuildWebMouseEventFrom(const EventPtr& event) {
   web_event->timeStampSeconds = EventTimeToWebEventTime(event);
 
   web_event->button = blink::WebMouseEvent::ButtonNone;
-  if (event->flags & mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON)
+  if (event->flags & mus::mojom::EVENT_FLAGS_LEFT_MOUSE_BUTTON)
     web_event->button = blink::WebMouseEvent::ButtonLeft;
-  if (event->flags & mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON)
+  if (event->flags & mus::mojom::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON)
     web_event->button = blink::WebMouseEvent::ButtonMiddle;
-  if (event->flags & mojo::EVENT_FLAGS_RIGHT_MOUSE_BUTTON)
+  if (event->flags & mus::mojom::EVENT_FLAGS_RIGHT_MOUSE_BUTTON)
     web_event->button = blink::WebMouseEvent::ButtonRight;
 
   switch (event->action) {
-    case mojo::EVENT_TYPE_POINTER_DOWN:
+    case mus::mojom::EVENT_TYPE_POINTER_DOWN:
       web_event->type = blink::WebInputEvent::MouseDown;
       break;
-    case mojo::EVENT_TYPE_POINTER_UP:
+    case mus::mojom::EVENT_TYPE_POINTER_UP:
       web_event->type = blink::WebInputEvent::MouseUp;
       break;
-    case mojo::EVENT_TYPE_POINTER_MOVE:
+    case mus::mojom::EVENT_TYPE_POINTER_MOVE:
       web_event->type = blink::WebInputEvent::MouseMove;
       break;
     default:
@@ -105,18 +109,18 @@ scoped_ptr<blink::WebInputEvent> BuildWebMouseEventFrom(const EventPtr& event) {
 }
 
 scoped_ptr<blink::WebInputEvent> BuildWebKeyboardEvent(
-    const EventPtr& event) {
+    const mus::mojom::EventPtr& event) {
   scoped_ptr<blink::WebKeyboardEvent> web_event(new blink::WebKeyboardEvent);
 
   web_event->modifiers = EventFlagsToWebInputEventModifiers(event->flags);
   web_event->timeStampSeconds = EventTimeToWebEventTime(event);
 
   switch (event->action) {
-    case EVENT_TYPE_KEY_PRESSED:
+    case mus::mojom::EVENT_TYPE_KEY_PRESSED:
       web_event->type = event->key_data->is_char ? blink::WebInputEvent::Char :
           blink::WebInputEvent::RawKeyDown;
       break;
-    case EVENT_TYPE_KEY_RELEASED:
+    case mus::mojom::EVENT_TYPE_KEY_RELEASED:
       web_event->type = blink::WebInputEvent::KeyUp;
       break;
     default:
@@ -136,9 +140,9 @@ scoped_ptr<blink::WebInputEvent> BuildWebKeyboardEvent(
 }
 
 scoped_ptr<blink::WebInputEvent> BuildWebMouseWheelEventFrom(
-    const EventPtr& event) {
+    const mus::mojom::EventPtr& event) {
   DCHECK(event->pointer_data && event->pointer_data->wheel_data);
-  const mojo::WheelData& wheel_data = *event->pointer_data->wheel_data;
+  const mus::mojom::WheelData& wheel_data = *event->pointer_data->wheel_data;
   scoped_ptr<blink::WebMouseWheelEvent> web_event(
       new blink::WebMouseWheelEvent);
   web_event->type = blink::WebInputEvent::MouseWheel;
@@ -161,22 +165,22 @@ scoped_ptr<blink::WebInputEvent> BuildWebMouseWheelEventFrom(
   // wheel events so the other modes are not yet tested. Verify that
   // the implementation is correct.
   switch (wheel_data.mode) {
-    case mojo::WHEEL_MODE_PIXEL:
+    case mus::mojom::WHEEL_MODE_PIXEL:
       web_event->hasPreciseScrollingDeltas = true;
       web_event->scrollByPage = false;
       web_event->canScroll = true;
       break;
-    case mojo::WHEEL_MODE_LINE:
+    case mus::mojom::WHEEL_MODE_LINE:
       web_event->hasPreciseScrollingDeltas = false;
       web_event->scrollByPage = false;
       web_event->canScroll = true;
       break;
-    case mojo::WHEEL_MODE_PAGE:
+    case mus::mojom::WHEEL_MODE_PAGE:
       web_event->hasPreciseScrollingDeltas = false;
       web_event->scrollByPage = true;
       web_event->canScroll = true;
       break;
-    case mojo::WHEEL_MODE_SCALING:
+    case mus::mojom::WHEEL_MODE_SCALING:
       web_event->hasPreciseScrollingDeltas = false;
       web_event->scrollByPage = false;
       web_event->canScroll = false;
@@ -190,23 +194,23 @@ scoped_ptr<blink::WebInputEvent> BuildWebMouseWheelEventFrom(
 
 // static
 scoped_ptr<blink::WebInputEvent>
-TypeConverter<scoped_ptr<blink::WebInputEvent>, EventPtr>::Convert(
-    const EventPtr& event) {
+TypeConverter<scoped_ptr<blink::WebInputEvent>, mus::mojom::EventPtr>::Convert(
+    const mus::mojom::EventPtr& event) {
   switch (event->action) {
-    case mojo::EVENT_TYPE_POINTER_DOWN:
-    case mojo::EVENT_TYPE_POINTER_UP:
-    case mojo::EVENT_TYPE_POINTER_CANCEL:
-    case mojo::EVENT_TYPE_POINTER_MOVE:
+    case mus::mojom::EVENT_TYPE_POINTER_DOWN:
+    case mus::mojom::EVENT_TYPE_POINTER_UP:
+    case mus::mojom::EVENT_TYPE_POINTER_CANCEL:
+    case mus::mojom::EVENT_TYPE_POINTER_MOVE:
       if (event->pointer_data &&
-          event->pointer_data->kind == mojo::POINTER_KIND_MOUSE) {
+          event->pointer_data->kind == mus::mojom::POINTER_KIND_MOUSE) {
         return BuildWebMouseEventFrom(event);
     }
-    case mojo::EVENT_TYPE_WHEEL:
+    case mus::mojom::EVENT_TYPE_WHEEL:
       return BuildWebMouseWheelEventFrom(event);
-    case mojo::EVENT_TYPE_KEY_PRESSED:
-    case mojo::EVENT_TYPE_KEY_RELEASED:
+    case mus::mojom::EVENT_TYPE_KEY_PRESSED:
+    case mus::mojom::EVENT_TYPE_KEY_RELEASED:
       return BuildWebKeyboardEvent(event);
-    case mojo::EVENT_TYPE_UNKNOWN:
+    case mus::mojom::EVENT_TYPE_UNKNOWN:
       return nullptr;
   }
   return nullptr;
diff --git a/components/html_viewer/blink_input_events_type_converters.h b/components/html_viewer/blink_input_events_type_converters.h
index 77834b7..9461bdc 100644
--- a/components/html_viewer/blink_input_events_type_converters.h
+++ b/components/html_viewer/blink_input_events_type_converters.h
@@ -15,8 +15,9 @@ class WebInputEvent;
 namespace mojo {
 
 template <>
-struct TypeConverter<scoped_ptr<blink::WebInputEvent>, EventPtr> {
-  static scoped_ptr<blink::WebInputEvent> Convert(const EventPtr& input);
+struct TypeConverter<scoped_ptr<blink::WebInputEvent>, mus::mojom::EventPtr> {
+  static scoped_ptr<blink::WebInputEvent> Convert(
+      const mus::mojom::EventPtr& input);
 };
 
 }  // namespace mojo
diff --git a/components/html_viewer/html_frame.cc b/components/html_viewer/html_frame.cc
index e25b95b..dea99e9 100644
--- a/components/html_viewer/html_frame.cc
+++ b/components/html_viewer/html_frame.cc
@@ -758,7 +758,7 @@ void HTMLFrame::OnWindowDestroyed(mus::Window* window) {
 }
 
 void HTMLFrame::OnWindowInputEvent(mus::Window* window,
-                                   const mojo::EventPtr& event) {
+                                   const mus::mojom::EventPtr& event) {
   if (event->pointer_data && event->pointer_data->location) {
     // Blink expects coordintes to be in DIPs.
     event->pointer_data->location->x /= global_state()->device_pixel_ratio();
@@ -774,12 +774,13 @@ void HTMLFrame::OnWindowInputEvent(mus::Window* window,
   if (!touch_handler_ && web_widget)
     touch_handler_.reset(new TouchHandler(web_widget));
 
-  if (touch_handler_ && (event->action == mojo::EVENT_TYPE_POINTER_DOWN ||
-                         event->action == mojo::EVENT_TYPE_POINTER_UP ||
-                         event->action == mojo::EVENT_TYPE_POINTER_CANCEL ||
-                         event->action == mojo::EVENT_TYPE_POINTER_MOVE) &&
+  if (touch_handler_ &&
+      (event->action == mus::mojom::EVENT_TYPE_POINTER_DOWN ||
+       event->action == mus::mojom::EVENT_TYPE_POINTER_UP ||
+       event->action == mus::mojom::EVENT_TYPE_POINTER_CANCEL ||
+       event->action == mus::mojom::EVENT_TYPE_POINTER_MOVE) &&
       event->pointer_data &&
-      event->pointer_data->kind == mojo::POINTER_KIND_TOUCH) {
+      event->pointer_data->kind == mus::mojom::POINTER_KIND_TOUCH) {
     touch_handler_->OnTouchEvent(*event);
     return;
   }
diff --git a/components/html_viewer/html_frame.h b/components/html_viewer/html_frame.h
index 2bcbe38..8ab2431 100644
--- a/components/html_viewer/html_frame.h
+++ b/components/html_viewer/html_frame.h
@@ -270,7 +270,7 @@ class HTMLFrame : public blink::WebFrameClient,
                              const gfx::Rect& new_bounds) override;
   void OnWindowDestroyed(mus::Window* window) override;
   void OnWindowInputEvent(mus::Window* window,
-                          const mojo::EventPtr& event) override;
+                          const mus::mojom::EventPtr& event) override;
   void OnWindowFocusChanged(mus::Window* gained_focus,
                             mus::Window* lost_focus) override;
 
diff --git a/components/html_viewer/input_events_unittest.cc b/components/html_viewer/input_events_unittest.cc
index d593ebe..66ffe26 100644
--- a/components/html_viewer/input_events_unittest.cc
+++ b/components/html_viewer/input_events_unittest.cc
@@ -24,10 +24,10 @@ TEST(InputEventLibTest, MouseEventConversion) {
       new ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(1, 2),
                          gfx::Point(3, 4), EventTimeForNow(), 0, 0));
 
-  mojo::EventPtr mojo_event(Event::From(*mouseev));
+  mus::mojom::EventPtr mojo_event(mus::mojom::Event::From(*mouseev));
 
-  EXPECT_EQ(EVENT_TYPE_POINTER_DOWN, mojo_event->action);
-  EXPECT_EQ(POINTER_KIND_MOUSE, mojo_event->pointer_data->kind);
+  EXPECT_EQ(mus::mojom::EVENT_TYPE_POINTER_DOWN, mojo_event->action);
+  EXPECT_EQ(mus::mojom::POINTER_KIND_MOUSE, mojo_event->pointer_data->kind);
 
   scoped_ptr<blink::WebInputEvent> webevent =
       mojo_event.To<scoped_ptr<blink::WebInputEvent>>();
@@ -50,9 +50,9 @@ TEST(InputEventLibTest, MouseWheelEventConversionNonPrecise) {
                     -2.0 * ui::MouseWheelEvent::kWheelDelta),
       gfx::PointF(1.0, 2.0), gfx::PointF(3.0, 4.0), EventTimeForNow(), 0, 0));
 
-  mojo::EventPtr mojo_event(mojo::Event::From(*original_wheel));
+  mus::mojom::EventPtr mojo_event(mus::mojom::Event::From(*original_wheel));
 
-  EXPECT_EQ(EVENT_TYPE_WHEEL, mojo_event->action);
+  EXPECT_EQ(mus::mojom::EVENT_TYPE_WHEEL, mojo_event->action);
 
   // Exercise the blink converter.
   scoped_ptr<blink::WebInputEvent> webevent =
@@ -80,7 +80,8 @@ TEST(InputEventLibTest, MouseWheelEventConversionNonPrecise) {
   EXPECT_TRUE(web_wheel->canScroll);
 
   // Exercise the round-trip converter.
-  mojo::EventPtr mojo_other_event(mojo::Event::From(*original_wheel));
+  mus::mojom::EventPtr mojo_other_event(
+      mus::mojom::Event::From(*original_wheel));
   scoped_ptr<ui::Event> new_event =
       mojo_other_event.To<scoped_ptr<ui::Event>>();
   EXPECT_EQ(ui::ET_MOUSEWHEEL, new_event->type());
diff --git a/components/html_viewer/touch_handler.cc b/components/html_viewer/touch_handler.cc
index 553fd74..e99cec8 100644
--- a/components/html_viewer/touch_handler.cc
+++ b/components/html_viewer/touch_handler.cc
@@ -17,7 +17,7 @@ namespace {
 
 // TODO(rjkroege): Gesture recognition currently happens in the html_viewer.
 // In phase2, it will be relocated to MUS. Update this code at that time.
-void SetPropertiesFromEvent(const mojo::Event& event,
+void SetPropertiesFromEvent(const mus::mojom::Event& event,
                             ui::PointerProperties* properties) {
   if (event.pointer_data) {
     properties->id = event.pointer_data->pointer_id;
@@ -30,8 +30,8 @@ void SetPropertiesFromEvent(const mojo::Event& event,
   }
 
   if (event.pointer_data && event.pointer_data->brush_data &&
-      (event.pointer_data->kind == mojo::POINTER_KIND_TOUCH ||
-       event.pointer_data->kind == mojo::POINTER_KIND_PEN)) {
+      (event.pointer_data->kind == mus::mojom::POINTER_KIND_TOUCH ||
+       event.pointer_data->kind == mus::mojom::POINTER_KIND_PEN)) {
     properties->pressure = event.pointer_data->brush_data->pressure;
 
     // TODO(rjkroege): vary orientation for width, height.
@@ -39,9 +39,9 @@ void SetPropertiesFromEvent(const mojo::Event& event,
                                       event.pointer_data->brush_data->height,
                                       0.0);
   } else {
-    if (event.flags & mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON ||
-        event.flags & mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON ||
-        event.flags & mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON) {
+    if (event.flags & mus::mojom::EVENT_FLAGS_LEFT_MOUSE_BUTTON ||
+        event.flags & mus::mojom::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON ||
+        event.flags & mus::mojom::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON) {
       properties->pressure = 0.5;
     } else {
       properties->pressure = 0.0;
@@ -62,7 +62,7 @@ TouchHandler::TouchHandler(blink::WebWidget* web_widget)
 TouchHandler::~TouchHandler() {
 }
 
-void TouchHandler::OnTouchEvent(const mojo::Event& event) {
+void TouchHandler::OnTouchEvent(const mus::mojom::Event& event) {
   if (!UpdateMotionEvent(event))
     return;
 
@@ -85,7 +85,7 @@ void TouchHandler::OnGestureEvent(const ui::GestureEventData& gesture) {
   web_widget_->handleInputEvent(web_gesture);
 }
 
-bool TouchHandler::UpdateMotionEvent(const mojo::Event& event) {
+bool TouchHandler::UpdateMotionEvent(const mus::mojom::Event& event) {
   ui::PointerProperties properties;
   SetPropertiesFromEvent(event, &properties);
 
@@ -97,7 +97,7 @@ bool TouchHandler::UpdateMotionEvent(const mojo::Event& event) {
   }
 
   switch (event.action) {
-    case mojo::EVENT_TYPE_POINTER_DOWN:
+    case mus::mojom::EVENT_TYPE_POINTER_DOWN:
       if (!current_motion_event_.get()) {
         current_motion_event_.reset(new ui::MotionEventGeneric(
             ui::MotionEvent::ACTION_DOWN, timestamp, properties));
@@ -115,7 +115,7 @@ bool TouchHandler::UpdateMotionEvent(const mojo::Event& event) {
       }
       return true;
 
-    case mojo::EVENT_TYPE_POINTER_UP: {
+    case mus::mojom::EVENT_TYPE_POINTER_UP: {
       if (!current_motion_event_.get()) {
         DVLOG(1) << "pointer up with no event, id=" << properties.id;
         return false;
@@ -135,7 +135,7 @@ bool TouchHandler::UpdateMotionEvent(const mojo::Event& event) {
       return true;
     }
 
-    case mojo::EVENT_TYPE_POINTER_MOVE: {
+    case mus::mojom::EVENT_TYPE_POINTER_MOVE: {
       if (!current_motion_event_.get()) {
         DVLOG(1) << "pointer move with no event, id=" << properties.id;
         return false;
@@ -152,7 +152,7 @@ bool TouchHandler::UpdateMotionEvent(const mojo::Event& event) {
       return true;
     }
 
-    case mojo::EVENT_TYPE_POINTER_CANCEL: {
+    case mus::mojom::EVENT_TYPE_POINTER_CANCEL: {
       if (!current_motion_event_.get()) {
         DVLOG(1) << "canel with no event, id=" << properties.id;
         return false;
@@ -187,9 +187,9 @@ void TouchHandler::SendMotionEventToGestureProvider() {
                                     web_widget_->handleInputEvent(web_event));
 }
 
-void TouchHandler::PostProcessMotionEvent(const mojo::Event& event) {
+void TouchHandler::PostProcessMotionEvent(const mus::mojom::Event& event) {
   switch (event.action) {
-    case mojo::EVENT_TYPE_POINTER_UP: {
+    case mus::mojom::EVENT_TYPE_POINTER_UP: {
       if (event.pointer_data) {
         const int index = current_motion_event_->FindPointerIndexOfId(
             event.pointer_data->pointer_id);
@@ -200,7 +200,7 @@ void TouchHandler::PostProcessMotionEvent(const mojo::Event& event) {
       break;
     }
 
-    case mojo::EVENT_TYPE_POINTER_CANCEL:
+    case mus::mojom::EVENT_TYPE_POINTER_CANCEL:
       current_motion_event_.reset();
       break;
 
diff --git a/components/html_viewer/touch_handler.h b/components/html_viewer/touch_handler.h
index 4c5972b..3f18dfe 100644
--- a/components/html_viewer/touch_handler.h
+++ b/components/html_viewer/touch_handler.h
@@ -6,16 +6,13 @@
 #define COMPONENTS_HTML_VIEWER_TOUCH_HANDLER_H_
 
 #include "base/basictypes.h"
+#include "components/mus/public/interfaces/input_events.mojom.h"
 #include "ui/events/gesture_detection/filtered_gesture_provider.h"
 
 namespace blink {
 class WebWidget;
 }
 
-namespace mojo {
-class Event;
-}
-
 namespace ui {
 class MotionEventGeneric;
 }
@@ -23,28 +20,29 @@ class MotionEventGeneric;
 namespace html_viewer {
 
 // TouchHandler is responsible for converting touch events into gesture events.
-// It does this by converting mojo::Events into a MotionEventGeneric and using
+// It does this by converting mus::mojom::Events into a MotionEventGeneric and
+// using
 // FilteredGestureProvider.
 class TouchHandler : public ui::GestureProviderClient {
  public:
   explicit TouchHandler(blink::WebWidget* web_widget);
   ~TouchHandler() override;
 
-  void OnTouchEvent(const mojo::Event& event);
+  void OnTouchEvent(const mus::mojom::Event& event);
 
   // ui::GestureProviderClient implementation.
   void OnGestureEvent(const ui::GestureEventData& gesture) override;
 
  private:
   // Updates |current_motion_event_| from |event|. Returns true on success.
-  bool UpdateMotionEvent(const mojo::Event& event);
+  bool UpdateMotionEvent(const mus::mojom::Event& event);
 
   // Sends |current_motion_event_| to the GestureProvider and WebView.
   void SendMotionEventToGestureProvider();
 
   // Does post processing after sending |current_motion_event_| to the
   // GestureProvider.
-  void PostProcessMotionEvent(const mojo::Event& event);
+  void PostProcessMotionEvent(const mus::mojom::Event& event);
 
   blink::WebWidget* web_widget_;
 
diff --git a/components/mus/example/wm/move_loop.cc b/components/mus/example/wm/move_loop.cc
index efdf242..227b786 100644
--- a/components/mus/example/wm/move_loop.cc
+++ b/components/mus/example/wm/move_loop.cc
@@ -12,22 +12,22 @@
 
 namespace {
 
-gfx::Point EventLocationToPoint(const mojo::Event& event) {
+gfx::Point EventLocationToPoint(const mus::mojom::Event& event) {
   return gfx::ToFlooredPoint(gfx::PointF(event.pointer_data->location->x,
                                          event.pointer_data->location->y));
 }
 
-gfx::Point EventScreenLocationToPoint(const mojo::Event& event) {
+gfx::Point EventScreenLocationToPoint(const mus::mojom::Event& event) {
   return gfx::ToFlooredPoint(
       gfx::PointF(event.pointer_data->location->screen_x,
                   event.pointer_data->location->screen_y));
 }
 
-mojo::EventFlags MouseOnlyEventFlags(mojo::EventFlags flags) {
-  return static_cast<mojo::EventFlags>(flags &
-                                       (mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON |
-                                        mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
-                                        mojo::EVENT_FLAGS_RIGHT_MOUSE_BUTTON));
+mus::mojom::EventFlags MouseOnlyEventFlags(mus::mojom::EventFlags flags) {
+  return static_cast<mus::mojom::EventFlags>(
+      flags & (mus::mojom::EVENT_FLAGS_LEFT_MOUSE_BUTTON |
+               mus::mojom::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
+               mus::mojom::EVENT_FLAGS_RIGHT_MOUSE_BUTTON));
 }
 
 }  // namespace
@@ -39,8 +39,8 @@ MoveLoop::~MoveLoop() {
 
 // static
 scoped_ptr<MoveLoop> MoveLoop::Create(mus::Window* target,
-                                      const mojo::Event& event) {
-  DCHECK_EQ(event.action, mojo::EVENT_TYPE_POINTER_DOWN);
+                                      const mus::mojom::Event& event) {
+  DCHECK_EQ(event.action, mus::mojom::EVENT_TYPE_POINTER_DOWN);
   const gfx::Point location(EventLocationToPoint(event));
   if (!gfx::Rect(target->bounds().size()).Contains(location) ||
       target->client_area().Contains(location)) {
@@ -48,17 +48,18 @@ scoped_ptr<MoveLoop> MoveLoop::Create(mus::Window* target,
   }
 
   // Start a move on left mouse, or any other type of pointer.
-  if (event.pointer_data->kind == mojo::POINTER_KIND_MOUSE &&
-      MouseOnlyEventFlags(event.flags) != mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON) {
+  if (event.pointer_data->kind == mus::mojom::POINTER_KIND_MOUSE &&
+      MouseOnlyEventFlags(event.flags) !=
+          mus::mojom::EVENT_FLAGS_LEFT_MOUSE_BUTTON) {
     return nullptr;
   }
 
   return make_scoped_ptr(new MoveLoop(target, event));
 }
 
-MoveLoop::MoveResult MoveLoop::Move(const mojo::Event& event) {
+MoveLoop::MoveResult MoveLoop::Move(const mus::mojom::Event& event) {
   switch (event.action) {
-    case mojo::EVENT_TYPE_POINTER_CANCEL:
+    case mus::mojom::EVENT_TYPE_POINTER_CANCEL:
       if (event.pointer_data->pointer_id == pointer_id_) {
         if (target_)
           Revert();
@@ -66,12 +67,12 @@ MoveLoop::MoveResult MoveLoop::Move(const mojo::Event& event) {
       }
       return MoveResult::CONTINUE;
 
-    case mojo::EVENT_TYPE_POINTER_MOVE:
+    case mus::mojom::EVENT_TYPE_POINTER_MOVE:
       if (target_ && event.pointer_data->pointer_id == pointer_id_)
         MoveImpl(event);
       return MoveResult::CONTINUE;
 
-    case mojo::EVENT_TYPE_POINTER_UP:
+    case mus::mojom::EVENT_TYPE_POINTER_UP:
       if (event.pointer_data->pointer_id == pointer_id_) {
         // TODO(sky): need to support changed_flags.
         if (target_)
@@ -87,7 +88,7 @@ MoveLoop::MoveResult MoveLoop::Move(const mojo::Event& event) {
   return MoveResult::CONTINUE;
 }
 
-MoveLoop::MoveLoop(mus::Window* target, const mojo::Event& event)
+MoveLoop::MoveLoop(mus::Window* target, const mus::mojom::Event& event)
     : target_(target),
       pointer_id_(event.pointer_data->pointer_id),
       initial_event_screen_location_(EventScreenLocationToPoint(event)),
@@ -96,7 +97,7 @@ MoveLoop::MoveLoop(mus::Window* target, const mojo::Event& event)
   target->AddObserver(this);
 }
 
-void MoveLoop::MoveImpl(const mojo::Event& event) {
+void MoveLoop::MoveImpl(const mus::mojom::Event& event) {
   const gfx::Vector2d delta =
       EventScreenLocationToPoint(event) - initial_event_screen_location_;
   const gfx::Rect new_bounds(initial_window_bounds_.origin() + delta,
diff --git a/components/mus/example/wm/move_loop.h b/components/mus/example/wm/move_loop.h
index 9eeec18..07aabc6 100644
--- a/components/mus/example/wm/move_loop.h
+++ b/components/mus/example/wm/move_loop.h
@@ -29,16 +29,16 @@ class MoveLoop : public mus::WindowObserver {
   // and returns a new MoveLoop. All events should be funneled to the MoveLoop
   // until done (Move()).
   static scoped_ptr<MoveLoop> Create(mus::Window* target,
-                                     const mojo::Event& event);
+                                     const mus::mojom::Event& event);
 
   // Processes an event for a move/resize loop.
-  MoveResult Move(const mojo::Event& event);
+  MoveResult Move(const mus::mojom::Event& event);
 
  private:
-  MoveLoop(mus::Window* target, const mojo::Event& event);
+  MoveLoop(mus::Window* target, const mus::mojom::Event& event);
 
   // Does the actual move/resize.
-  void MoveImpl(const mojo::Event& event);
+  void MoveImpl(const mus::mojom::Event& event);
 
   // Cancels the loop. This sets |target_| to null and removes the observer.
   // After this the MoveLoop is still ongoing and won't stop until the
diff --git a/components/mus/example/wm/window_manager_impl.cc b/components/mus/example/wm/window_manager_impl.cc
index 7807624..0ee918a 100644
--- a/components/mus/example/wm/window_manager_impl.cc
+++ b/components/mus/example/wm/window_manager_impl.cc
@@ -18,11 +18,11 @@
 
 namespace {
 
-bool IsPointerEvent(const mojo::Event& event) {
-  return event.action == mojo::EVENT_TYPE_POINTER_CANCEL ||
-         event.action == mojo::EVENT_TYPE_POINTER_DOWN ||
-         event.action == mojo::EVENT_TYPE_POINTER_MOVE ||
-         event.action == mojo::EVENT_TYPE_POINTER_UP;
+bool IsPointerEvent(const mus::mojom::Event& event) {
+  return event.action == mus::mojom::EVENT_TYPE_POINTER_CANCEL ||
+         event.action == mus::mojom::EVENT_TYPE_POINTER_DOWN ||
+         event.action == mus::mojom::EVENT_TYPE_POINTER_MOVE ||
+         event.action == mus::mojom::EVENT_TYPE_POINTER_UP;
 }
 
 }  // namespace
@@ -125,13 +125,13 @@ void WindowManagerImpl::OnWindowDestroyed(mus::Window* window) {
 }
 
 void WindowManagerImpl::OnWindowInputEvent(mus::Window* window,
-                                           const mojo::EventPtr& event) {
+                                           const mus::mojom::EventPtr& event) {
   if (move_loop_ && IsPointerEvent(*event)) {
     if (move_loop_->Move(*event) == MoveLoop::DONE)
       move_loop_.reset();
     return;
   }
-  if (!move_loop_ && event->action == mojo::EVENT_TYPE_POINTER_DOWN)
+  if (!move_loop_ && event->action == mus::mojom::EVENT_TYPE_POINTER_DOWN)
     move_loop_ = MoveLoop::Create(window, *event);
 }
 
diff --git a/components/mus/example/wm/window_manager_impl.h b/components/mus/example/wm/window_manager_impl.h
index c813539..5551a47 100644
--- a/components/mus/example/wm/window_manager_impl.h
+++ b/components/mus/example/wm/window_manager_impl.h
@@ -44,7 +44,7 @@ class WindowManagerImpl : public mus::mojom::WindowManager,
   // mus::WindowObserver:
   void OnWindowDestroyed(mus::Window* window) override;
   void OnWindowInputEvent(mus::Window* window,
-                          const mojo::EventPtr& event) override;
+                          const mus::mojom::EventPtr& event) override;
 
   mus::Window* GetContainerForChild(mus::Window* child);
 
diff --git a/components/mus/public/cpp/event_matcher.h b/components/mus/public/cpp/event_matcher.h
index 6f7c441..d25dc38 100644
--- a/components/mus/public/cpp/event_matcher.h
+++ b/components/mus/public/cpp/event_matcher.h
@@ -11,8 +11,8 @@
 
 namespace mus {
 
-mojo::EventMatcherPtr CreateKeyMatcher(mojo::KeyboardCode code,
-                                       mojo::EventFlags flags);
+mojom::EventMatcherPtr CreateKeyMatcher(mojom::KeyboardCode code,
+                                        mojom::EventFlags flags);
 
 }  // namespace mus
 
diff --git a/components/mus/public/cpp/lib/event_matcher.cc b/components/mus/public/cpp/lib/event_matcher.cc
index af4d8a8..702ad53 100644
--- a/components/mus/public/cpp/lib/event_matcher.cc
+++ b/components/mus/public/cpp/lib/event_matcher.cc
@@ -6,14 +6,14 @@
 
 namespace mus {
 
-mojo::EventMatcherPtr CreateKeyMatcher(mojo::KeyboardCode code,
-                                       mojo::EventFlags flags) {
-  mojo::EventMatcherPtr matcher(mojo::EventMatcher::New());
-  matcher->type_matcher = mojo::EventTypeMatcher::New();
-  matcher->flags_matcher = mojo::EventFlagsMatcher::New();
-  matcher->key_matcher = mojo::KeyEventMatcher::New();
+mojom::EventMatcherPtr CreateKeyMatcher(mojom::KeyboardCode code,
+                                        mojom::EventFlags flags) {
+  mojom::EventMatcherPtr matcher(mojom::EventMatcher::New());
+  matcher->type_matcher = mojom::EventTypeMatcher::New();
+  matcher->flags_matcher = mojom::EventFlagsMatcher::New();
+  matcher->key_matcher = mojom::KeyEventMatcher::New();
 
-  matcher->type_matcher->type = mojo::EVENT_TYPE_KEY_PRESSED;
+  matcher->type_matcher->type = mus::mojom::EVENT_TYPE_KEY_PRESSED;
   matcher->flags_matcher->flags = flags;
   matcher->key_matcher->keyboard_code = code;
   return matcher.Pass();
diff --git a/components/mus/public/cpp/lib/window_tree_client_impl.cc b/components/mus/public/cpp/lib/window_tree_client_impl.cc
index da23fca..9922a73 100644
--- a/components/mus/public/cpp/lib/window_tree_client_impl.cc
+++ b/components/mus/public/cpp/lib/window_tree_client_impl.cc
@@ -455,7 +455,7 @@ void WindowTreeClientImpl::OnWindowSharedPropertyChanged(
 
 void WindowTreeClientImpl::OnWindowInputEvent(
     Id window_id,
-    mojo::EventPtr event,
+    mojom::EventPtr event,
     const mojo::Callback<void()>& ack_callback) {
   Window* window = GetWindowById(window_id);
   if (window) {
diff --git a/components/mus/public/cpp/lib/window_tree_client_impl.h b/components/mus/public/cpp/lib/window_tree_client_impl.h
index 80475db..634047f 100644
--- a/components/mus/public/cpp/lib/window_tree_client_impl.h
+++ b/components/mus/public/cpp/lib/window_tree_client_impl.h
@@ -138,7 +138,7 @@ class WindowTreeClientImpl : public WindowTreeConnection,
                                      const mojo::String& name,
                                      mojo::Array<uint8_t> new_data) override;
   void OnWindowInputEvent(Id window_id,
-                          mojo::EventPtr event,
+                          mojom::EventPtr event,
                           const mojo::Callback<void()>& callback) override;
   void OnWindowFocused(Id focused_window_id) override;
 
diff --git a/components/mus/public/cpp/window_observer.h b/components/mus/public/cpp/window_observer.h
index ed5c2bf..91fd666 100644
--- a/components/mus/public/cpp/window_observer.h
+++ b/components/mus/public/cpp/window_observer.h
@@ -64,8 +64,8 @@ class WindowObserver {
 
   virtual void OnWindowFocusChanged(Window* gained_focus, Window* lost_focus) {}
 
-  virtual void OnWindowInputEvent(Window* window, const mojo::EventPtr& event) {
-  }
+  virtual void OnWindowInputEvent(Window* window,
+                                  const mojom::EventPtr& event) {}
 
   virtual void OnWindowVisibilityChanging(Window* window) {}
   virtual void OnWindowVisibilityChanged(Window* window) {}
diff --git a/components/mus/public/interfaces/input_event_constants.mojom b/components/mus/public/interfaces/input_event_constants.mojom
index 9b22e98..587a17d 100644
--- a/components/mus/public/interfaces/input_event_constants.mojom
+++ b/components/mus/public/interfaces/input_event_constants.mojom
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-module mojo;
+module mus.mojom;
 
 enum EventType {
   UNKNOWN,
diff --git a/components/mus/public/interfaces/input_event_matcher.mojom b/components/mus/public/interfaces/input_event_matcher.mojom
index 5e5c212..89c75c4 100644
--- a/components/mus/public/interfaces/input_event_matcher.mojom
+++ b/components/mus/public/interfaces/input_event_matcher.mojom
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-module mojo;
+module mus.mojom;
 
 import "components/mus/public/interfaces/input_event_constants.mojom";
 import "components/mus/public/interfaces/input_key_codes.mojom";
@@ -17,7 +17,7 @@ struct PointerKindMatcher {
 };
 
 struct PointerLocationMatcher {
-  RectF region;
+  mojo.RectF region;
 };
 
 struct EventTypeMatcher {
diff --git a/components/mus/public/interfaces/input_events.mojom b/components/mus/public/interfaces/input_events.mojom
index 2ca3f6c..3647b66 100644
--- a/components/mus/public/interfaces/input_events.mojom
+++ b/components/mus/public/interfaces/input_events.mojom
@@ -2,11 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-module mojo;
+module mus.mojom;
 
 import "components/mus/public/interfaces/input_event_constants.mojom";
 import "components/mus/public/interfaces/input_key_codes.mojom";
-import "ui/mojo/geometry/geometry.mojom";
 
 struct KeyData {
   // The chromium event key code; these values are from the ui/ KeyCode enum,
diff --git a/components/mus/public/interfaces/input_key_codes.mojom b/components/mus/public/interfaces/input_key_codes.mojom
index 695f5bd..ba3497f 100644
--- a/components/mus/public/interfaces/input_key_codes.mojom
+++ b/components/mus/public/interfaces/input_key_codes.mojom
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-module mojo;
+module mus.mojom;
 
 // Cross platform keyboard codes.
 //
diff --git a/components/mus/public/interfaces/window_tree.mojom b/components/mus/public/interfaces/window_tree.mojom
index 69033fb..485eb49 100644
--- a/components/mus/public/interfaces/window_tree.mojom
+++ b/components/mus/public/interfaces/window_tree.mojom
@@ -265,7 +265,7 @@ interface WindowTreeClient {
                                 array<uint8>? new_data);
 
   // Invoked when an event is targeted at the specified window.
-  OnWindowInputEvent(uint32 window, mojo.Event event) => ();
+  OnWindowInputEvent(uint32 window, Event event) => ();
 
   OnWindowFocused(uint32 focused_window_id);
 };
diff --git a/components/mus/public/interfaces/window_tree_host.mojom b/components/mus/public/interfaces/window_tree_host.mojom
index 1ade81c..74109de 100644
--- a/components/mus/public/interfaces/window_tree_host.mojom
+++ b/components/mus/public/interfaces/window_tree_host.mojom
@@ -25,13 +25,13 @@ interface WindowTreeHost {
   // WindowTreeHostClient receives the event via OnAccelerator() rather than the
   // target window. The id is defined by the client and can be used to more
   // easily identify the accelerator's action.
-  AddAccelerator(uint32 id, mojo.EventMatcher matcher);
+  AddAccelerator(uint32 id, EventMatcher matcher);
   RemoveAccelerator(uint32 id);
 };
 
 interface WindowTreeHostClient {
   // An accelerator registered via AddAccelerator() has been triggered.
-  OnAccelerator(uint32 id, mojo.Event event);
+  OnAccelerator(uint32 id, Event event);
 };
 
 interface WindowTreeHostFactory {
diff --git a/components/mus/ws/display_manager.cc b/components/mus/ws/display_manager.cc
index f740e01..25d390d 100644
--- a/components/mus/ws/display_manager.cc
+++ b/components/mus/ws/display_manager.cc
@@ -280,7 +280,7 @@ void DefaultDisplayManager::OnDamageRect(const gfx::Rect& damaged_region) {
 }
 
 void DefaultDisplayManager::DispatchEvent(ui::Event* event) {
-  mojo::EventPtr mojo_event(mojo::Event::From(*event));
+  mojom::EventPtr mojo_event(mojom::Event::From(*event));
   delegate_->OnEvent(mojo_event.Pass());
 
   switch (event->type()) {
@@ -323,7 +323,7 @@ void DefaultDisplayManager::DispatchEvent(ui::Event* event) {
             key_press_event->GetLocatedWindowsKeyboardCode(),
             key_press_event->GetText(), key_press_event->GetUnmodifiedText())));
 
-    delegate_->OnEvent(mojo::Event::From(char_event));
+    delegate_->OnEvent(mojom::Event::From(char_event));
   }
 #endif
 }
diff --git a/components/mus/ws/display_manager_delegate.h b/components/mus/ws/display_manager_delegate.h
index 19bf01b..00fab3e 100644
--- a/components/mus/ws/display_manager_delegate.h
+++ b/components/mus/ws/display_manager_delegate.h
@@ -30,7 +30,7 @@ class DisplayManagerDelegate {
   virtual void OnDisplayClosed() = 0;
 
   // Called when an event arrives.
-  virtual void OnEvent(mojo::EventPtr event) = 0;
+  virtual void OnEvent(mojom::EventPtr event) = 0;
 
   // Signals that the metrics of this display's viewport has changed.
   virtual void OnViewportMetricsChanged(
diff --git a/components/mus/ws/event_dispatcher.cc b/components/mus/ws/event_dispatcher.cc
index c1f775f..e0f8605 100644
--- a/components/mus/ws/event_dispatcher.cc
+++ b/components/mus/ws/event_dispatcher.cc
@@ -21,19 +21,19 @@ namespace ws {
 namespace {
 
 bool IsMouseEventFlag(int32_t event_flags) {
-  return !!(event_flags & (mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON |
-                           mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
-                           mojo::EVENT_FLAGS_RIGHT_MOUSE_BUTTON));
+  return !!(event_flags & (mojom::EVENT_FLAGS_LEFT_MOUSE_BUTTON |
+                           mojom::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
+                           mojom::EVENT_FLAGS_RIGHT_MOUSE_BUTTON));
 }
 
-bool IsOnlyOneMouseButtonDown(mojo::EventFlags flags) {
+bool IsOnlyOneMouseButtonDown(mojom::EventFlags flags) {
   const uint32_t mouse_only_flags =
-      flags & (mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON |
-               mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
-               mojo::EVENT_FLAGS_RIGHT_MOUSE_BUTTON);
-  return mouse_only_flags == mojo::EVENT_FLAGS_LEFT_MOUSE_BUTTON ||
-         mouse_only_flags == mojo::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON ||
-         mouse_only_flags == mojo::EVENT_FLAGS_RIGHT_MOUSE_BUTTON;
+      flags & (mojom::EVENT_FLAGS_LEFT_MOUSE_BUTTON |
+               mojom::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
+               mojom::EVENT_FLAGS_RIGHT_MOUSE_BUTTON);
+  return mouse_only_flags == mojom::EVENT_FLAGS_LEFT_MOUSE_BUTTON ||
+         mouse_only_flags == mojom::EVENT_FLAGS_MIDDLE_MOUSE_BUTTON ||
+         mouse_only_flags == mojom::EVENT_FLAGS_RIGHT_MOUSE_BUTTON;
 }
 
 bool IsLocationInNonclientArea(const ServerWindow* target,
@@ -42,7 +42,7 @@ bool IsLocationInNonclientArea(const ServerWindow* target,
          !target->client_area().Contains(location);
 }
 
-gfx::Point EventLocationToPoint(const mojo::Event& event) {
+gfx::Point EventLocationToPoint(const mojom::Event& event) {
   return gfx::ToFlooredPoint(gfx::PointF(event.pointer_data->location->x,
                                          event.pointer_data->location->y));
 }
@@ -51,12 +51,12 @@ gfx::Point EventLocationToPoint(const mojo::Event& event) {
 
 class EventMatcher {
  public:
-  explicit EventMatcher(const mojo::EventMatcher& matcher)
+  explicit EventMatcher(const mojom::EventMatcher& matcher)
       : fields_to_match_(NONE),
-        event_type_(mojo::EVENT_TYPE_UNKNOWN),
-        event_flags_(mojo::EVENT_FLAGS_NONE),
-        keyboard_code_(mojo::KEYBOARD_CODE_UNKNOWN),
-        pointer_kind_(mojo::POINTER_KIND_MOUSE) {
+        event_type_(mojom::EVENT_TYPE_UNKNOWN),
+        event_flags_(mojom::EVENT_FLAGS_NONE),
+        keyboard_code_(mojom::KEYBOARD_CODE_UNKNOWN),
+        pointer_kind_(mojom::POINTER_KIND_MOUSE) {
     if (matcher.type_matcher) {
       fields_to_match_ |= TYPE;
       event_type_ = matcher.type_matcher->type;
@@ -82,7 +82,7 @@ class EventMatcher {
 
   ~EventMatcher() {}
 
-  bool MatchesEvent(const mojo::Event& event) const {
+  bool MatchesEvent(const mojom::Event& event) const {
     if ((fields_to_match_ & TYPE) && event.action != event_type_)
       return false;
     if ((fields_to_match_ & FLAGS) && event.flags != event_flags_)
@@ -131,10 +131,10 @@ class EventMatcher {
   };
 
   uint32_t fields_to_match_;
-  mojo::EventType event_type_;
-  mojo::EventFlags event_flags_;
-  mojo::KeyboardCode keyboard_code_;
-  mojo::PointerKind pointer_kind_;
+  mojom::EventType event_type_;
+  mojom::EventFlags event_flags_;
+  mojom::KeyboardCode keyboard_code_;
+  mojom::PointerKind pointer_kind_;
   gfx::RectF pointer_region_;
 };
 
@@ -149,7 +149,7 @@ EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
 EventDispatcher::~EventDispatcher() {}
 
 void EventDispatcher::AddAccelerator(uint32_t id,
-                                     mojo::EventMatcherPtr event_matcher) {
+                                     mojom::EventMatcherPtr event_matcher) {
   EventMatcher matcher(*event_matcher);
 #if !defined(NDEBUG)
   for (const auto& pair : accelerators_) {
@@ -166,11 +166,11 @@ void EventDispatcher::RemoveAccelerator(uint32_t id) {
   accelerators_.erase(it);
 }
 
-void EventDispatcher::OnEvent(mojo::EventPtr event) {
+void EventDispatcher::OnEvent(mojom::EventPtr event) {
   if (!root_)
     return;
 
-  if (event->action == mojo::EVENT_TYPE_KEY_PRESSED &&
+  if (event->action == mojom::EVENT_TYPE_KEY_PRESSED &&
       !event->key_data->is_char) {
     uint32_t accelerator = 0u;
     if (FindAccelerator(*event, &accelerator)) {
@@ -184,7 +184,7 @@ void EventDispatcher::OnEvent(mojo::EventPtr event) {
 
   if (IsMouseEventFlag(event->flags)) {
     if (!capture_window_ && target &&
-        (event->action == mojo::EVENT_TYPE_POINTER_DOWN)) {
+        (event->action == mojom::EVENT_TYPE_POINTER_DOWN)) {
       // TODO(sky): |capture_window_| needs to be reset when window removed
       // from hierarchy.
       capture_window_ = target;
@@ -192,7 +192,7 @@ void EventDispatcher::OnEvent(mojo::EventPtr event) {
       capture_in_nonclient_area_ =
           IsLocationInNonclientArea(target, EventLocationToPoint(*event));
       in_nonclient_area = capture_in_nonclient_area_;
-    } else if (event->action == mojo::EVENT_TYPE_POINTER_UP &&
+    } else if (event->action == mojom::EVENT_TYPE_POINTER_UP &&
                IsOnlyOneMouseButtonDown(event->flags)) {
       capture_window_ = nullptr;
     }
@@ -200,7 +200,7 @@ void EventDispatcher::OnEvent(mojo::EventPtr event) {
   }
 
   if (target) {
-    if (event->action == mojo::EVENT_TYPE_POINTER_DOWN)
+    if (event->action == mojom::EVENT_TYPE_POINTER_DOWN)
       delegate_->SetFocusedWindowFromEventDispatcher(target);
 
     delegate_->DispatchInputEventToWindow(target, in_nonclient_area,
@@ -208,7 +208,7 @@ void EventDispatcher::OnEvent(mojo::EventPtr event) {
   }
 }
 
-bool EventDispatcher::FindAccelerator(const mojo::Event& event,
+bool EventDispatcher::FindAccelerator(const mojom::Event& event,
                                       uint32_t* accelerator_id) {
   DCHECK(event.key_data);
   for (const auto& pair : accelerators_) {
@@ -220,14 +220,14 @@ bool EventDispatcher::FindAccelerator(const mojo::Event& event,
   return false;
 }
 
-ServerWindow* EventDispatcher::FindEventTarget(mojo::Event* event) {
+ServerWindow* EventDispatcher::FindEventTarget(mojom::Event* event) {
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher();
   if (event->key_data)
     return focused_window;
 
   DCHECK(event->pointer_data) << "Unknown event type: " << event->action;
-  mojo::LocationData* event_location = event->pointer_data->location.get();
+  mojom::LocationData* event_location = event->pointer_data->location.get();
   DCHECK(event_location);
   gfx::Point location(static_cast<int>(event_location->x),
                       static_cast<int>(event_location->y));
diff --git a/components/mus/ws/event_dispatcher.h b/components/mus/ws/event_dispatcher.h
index 078488c..0e89233 100644
--- a/components/mus/ws/event_dispatcher.h
+++ b/components/mus/ws/event_dispatcher.h
@@ -32,22 +32,22 @@ class EventDispatcher {
 
   void set_surface_id(cc::SurfaceId surface_id) { surface_id_ = surface_id; }
 
-  void AddAccelerator(uint32_t id, mojo::EventMatcherPtr event_matcher);
+  void AddAccelerator(uint32_t id, mojom::EventMatcherPtr event_matcher);
   void RemoveAccelerator(uint32_t id);
 
-  void OnEvent(mojo::EventPtr event);
+  void OnEvent(mojom::EventPtr event);
 
  private:
   // Looks to see if there is an accelerator bound to the specified code/flags.
   // If there is one, sets |accelerator_id| to the id of the accelerator invoked
   // and returns true. If there is none, returns false so normal key event
   // processing can continue.
-  bool FindAccelerator(const mojo::Event& event, uint32_t* accelerator_id);
+  bool FindAccelerator(const mojom::Event& event, uint32_t* accelerator_id);
 
   // Returns the ServerWindow that should receive |event|. If |event| is a
   // pointer-type event, then this function also updates the event location to
   // make sure it is in the returned target's coordinate space.
-  ServerWindow* FindEventTarget(mojo::Event* event);
+  ServerWindow* FindEventTarget(mojom::Event* event);
 
   EventDispatcherDelegate* delegate_;
   ServerWindow* root_;
diff --git a/components/mus/ws/event_dispatcher_delegate.h b/components/mus/ws/event_dispatcher_delegate.h
index a82c2c9..cfd55ff 100644
--- a/components/mus/ws/event_dispatcher_delegate.h
+++ b/components/mus/ws/event_dispatcher_delegate.h
@@ -15,7 +15,7 @@ class ServerWindow;
 // Used by EventDispatcher for mocking in tests.
 class EventDispatcherDelegate {
  public:
-  virtual void OnAccelerator(uint32_t accelerator, mojo::EventPtr event) = 0;
+  virtual void OnAccelerator(uint32_t accelerator, mojom::EventPtr event) = 0;
 
   virtual void SetFocusedWindowFromEventDispatcher(ServerWindow* window) = 0;
   virtual ServerWindow* GetFocusedWindowForEventDispatcher() = 0;
@@ -23,7 +23,7 @@ class EventDispatcherDelegate {
   // |in_nonclient_area| is true if the event occurred in the non-client area.
   virtual void DispatchInputEventToWindow(ServerWindow* target,
                                           bool in_nonclient_area,
-                                          mojo::EventPtr event) = 0;
+                                          mojom::EventPtr event) = 0;
 
  protected:
   virtual ~EventDispatcherDelegate() {}
diff --git a/components/mus/ws/event_dispatcher_unittest.cc b/components/mus/ws/event_dispatcher_unittest.cc
index 91ce4b3..0cdcfed 100644
--- a/components/mus/ws/event_dispatcher_unittest.cc
+++ b/components/mus/ws/event_dispatcher_unittest.cc
@@ -26,7 +26,7 @@ class TestEventDispatcherDelegate : public EventDispatcherDelegate {
         last_in_nonclient_area_(false) {}
   ~TestEventDispatcherDelegate() override {}
 
-  mojo::EventPtr GetAndClearLastDispatchedEvent() {
+  mojom::EventPtr GetAndClearLastDispatchedEvent() {
     return last_dispatched_event_.Pass();
   }
 
@@ -46,7 +46,7 @@ class TestEventDispatcherDelegate : public EventDispatcherDelegate {
 
  private:
   // EventDispatcherDelegate:
-  void OnAccelerator(uint32_t accelerator, mojo::EventPtr event) override {
+  void OnAccelerator(uint32_t accelerator, mojom::EventPtr event) override {
     EXPECT_EQ(0u, last_accelerator_);
     last_accelerator_ = accelerator;
   }
@@ -58,7 +58,7 @@ class TestEventDispatcherDelegate : public EventDispatcherDelegate {
   }
   void DispatchInputEventToWindow(ServerWindow* target,
                                   bool in_nonclient_area,
-                                  mojo::EventPtr event) override {
+                                  mojom::EventPtr event) override {
     last_target_ = target;
     last_dispatched_event_ = event.Pass();
     last_in_nonclient_area_ = in_nonclient_area;
@@ -67,7 +67,7 @@ class TestEventDispatcherDelegate : public EventDispatcherDelegate {
   ServerWindow* root_;
   ServerWindow* focused_window_;
   ServerWindow* last_target_;
-  mojo::EventPtr last_dispatched_event_;
+  mojom::EventPtr last_dispatched_event_;
   uint32_t last_accelerator_;
   bool last_in_nonclient_area_;
 
@@ -88,12 +88,12 @@ void RunMouseEventTests(EventDispatcher* dispatcher,
   for (size_t i = 0; i < test_count; ++i) {
     const MouseEventTest& test = tests[i];
     dispatcher->OnEvent(
-        mojo::Event::From(static_cast<const ui::Event&>(test.input_event)));
+        mojom::Event::From(static_cast<const ui::Event&>(test.input_event)));
 
     ASSERT_EQ(test.expected_target_window, dispatcher_delegate->last_target())
         << "Test " << i << " failed.";
 
-    mojo::EventPtr dispatched_event_mojo =
+    mojom::EventPtr dispatched_event_mojo =
         dispatcher_delegate->GetAndClearLastDispatchedEvent();
     ASSERT_TRUE(dispatched_event_mojo.get()) << "Test " << i << " failed.";
     scoped_ptr<ui::Event> dispatched_event(
@@ -136,11 +136,11 @@ TEST(EventDispatcherTest, OnEvent) {
       ui::ET_MOUSE_PRESSED, gfx::PointF(20.f, 25.f), gfx::PointF(20.f, 25.f),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   dispatcher.OnEvent(
-      mojo::Event::From(static_cast<const ui::Event&>(ui_event)));
+      mojom::Event::From(static_cast<const ui::Event&>(ui_event)));
 
   ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
 
-  mojo::EventPtr dispatched_event_mojo =
+  mojom::EventPtr dispatched_event_mojo =
       event_dispatcher_delegate.GetAndClearLastDispatchedEvent();
   ASSERT_TRUE(dispatched_event_mojo.get());
   scoped_ptr<ui::Event> dispatched_event(
@@ -160,31 +160,30 @@ TEST(EventDispatcherTest, EventMatching) {
   EventDispatcher dispatcher(&event_dispatcher_delegate);
   dispatcher.set_root(&root);
 
-  mojo::EventMatcherPtr matcher =
-      mus::CreateKeyMatcher(mojo::KEYBOARD_CODE_W,
-                            mojo::EVENT_FLAGS_CONTROL_DOWN);
+  mojom::EventMatcherPtr matcher = mus::CreateKeyMatcher(
+      mus::mojom::KEYBOARD_CODE_W, mus::mojom::EVENT_FLAGS_CONTROL_DOWN);
   uint32_t accelerator_1 = 1;
   dispatcher.AddAccelerator(accelerator_1, matcher.Pass());
 
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
-  dispatcher.OnEvent(mojo::Event::From(key));
+  dispatcher.OnEvent(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.OnEvent(mojo::Event::From(key));
+  dispatcher.OnEvent(mojom::Event::From(key));
   EXPECT_EQ(0u, event_dispatcher_delegate.GetAndClearLastAccelerator());
 
   uint32_t accelerator_2 = 2;
-  matcher = mus::CreateKeyMatcher(mojo::KEYBOARD_CODE_W,
-                                  mojo::EVENT_FLAGS_NONE);
+  matcher = mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_W,
+                                  mus::mojom::EVENT_FLAGS_NONE);
   dispatcher.AddAccelerator(accelerator_2, matcher.Pass());
-  dispatcher.OnEvent(mojo::Event::From(key));
+  dispatcher.OnEvent(mojom::Event::From(key));
   EXPECT_EQ(accelerator_2,
             event_dispatcher_delegate.GetAndClearLastAccelerator());
 
   dispatcher.RemoveAccelerator(accelerator_2);
-  dispatcher.OnEvent(mojo::Event::From(key));
+  dispatcher.OnEvent(mojom::Event::From(key));
   EXPECT_EQ(0u, event_dispatcher_delegate.GetAndClearLastAccelerator());
 }
 
@@ -304,7 +303,7 @@ TEST(EventDispatcherTest, ClientAreaGoesToOwner) {
       ui::ET_MOUSE_PRESSED, gfx::PointF(12.f, 12.f), gfx::PointF(12.f, 12.f),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   dispatcher.OnEvent(
-      mojo::Event::From(static_cast<const ui::Event&>(press_event)));
+      mojom::Event::From(static_cast<const ui::Event&>(press_event)));
 
   // Events should target child and be in the non-client area.
   ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
@@ -315,7 +314,7 @@ TEST(EventDispatcherTest, ClientAreaGoesToOwner) {
                                   gfx::PointF(17.f, 18.f), base::TimeDelta(),
                                   ui::EF_LEFT_MOUSE_BUTTON, 0);
   dispatcher.OnEvent(
-      mojo::Event::From(static_cast<const ui::Event&>(move_event)));
+      mojom::Event::From(static_cast<const ui::Event&>(move_event)));
 
   // Still same target.
   ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
@@ -326,7 +325,7 @@ TEST(EventDispatcherTest, ClientAreaGoesToOwner) {
       ui::ET_MOUSE_RELEASED, gfx::PointF(17.f, 18.f), gfx::PointF(17.f, 18.f),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   dispatcher.OnEvent(
-      mojo::Event::From(static_cast<const ui::Event&>(release_event)));
+      mojom::Event::From(static_cast<const ui::Event&>(release_event)));
 
   // The event should not have been dispatched to the delegate.
   ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
@@ -337,7 +336,7 @@ TEST(EventDispatcherTest, ClientAreaGoesToOwner) {
       ui::ET_MOUSE_PRESSED, gfx::PointF(21.f, 22.f), gfx::PointF(21.f, 22.f),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   dispatcher.OnEvent(
-      mojo::Event::From(static_cast<const ui::Event&>(press_event2)));
+      mojom::Event::From(static_cast<const ui::Event&>(press_event2)));
   ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
   EXPECT_FALSE(event_dispatcher_delegate.GetAndClearLastInNonclientArea());
 }
diff --git a/components/mus/ws/test_change_tracker.cc b/components/mus/ws/test_change_tracker.cc
index c48f9cc..ac673ec 100644
--- a/components/mus/ws/test_change_tracker.cc
+++ b/components/mus/ws/test_change_tracker.cc
@@ -268,7 +268,8 @@ void TestChangeTracker::OnWindowDrawnStateChanged(Id window_id, bool drawn) {
   AddChange(change);
 }
 
-void TestChangeTracker::OnWindowInputEvent(Id window_id, mojo::EventPtr event) {
+void TestChangeTracker::OnWindowInputEvent(Id window_id,
+                                           mojom::EventPtr event) {
   Change change;
   change.type = CHANGE_TYPE_INPUT_EVENT;
   change.window_id = window_id;
diff --git a/components/mus/ws/test_change_tracker.h b/components/mus/ws/test_change_tracker.h
index 776247a..5946a18 100644
--- a/components/mus/ws/test_change_tracker.h
+++ b/components/mus/ws/test_change_tracker.h
@@ -137,7 +137,7 @@ class TestChangeTracker {
   void OnWindowDeleted(Id window_id);
   void OnWindowVisibilityChanged(Id window_id, bool visible);
   void OnWindowDrawnStateChanged(Id window_id, bool drawn);
-  void OnWindowInputEvent(Id window_id, mojo::EventPtr event);
+  void OnWindowInputEvent(Id window_id, mojom::EventPtr event);
   void OnWindowSharedPropertyChanged(Id window_id,
                                      mojo::String name,
                                      mojo::Array<uint8_t> data);
diff --git a/components/mus/ws/window_tree_apptest.cc b/components/mus/ws/window_tree_apptest.cc
index 6e00cd6..4686293 100644
--- a/components/mus/ws/window_tree_apptest.cc
+++ b/components/mus/ws/window_tree_apptest.cc
@@ -18,12 +18,12 @@ using mojo::ApplicationConnection;
 using mojo::ApplicationDelegate;
 using mojo::Array;
 using mojo::Callback;
-using mojo::EventPtr;
 using mojo::InterfaceRequest;
 using mojo::RectPtr;
 using mojo::String;
 using mus::mojom::ERROR_CODE_NONE;
 using mus::mojom::ErrorCode;
+using mus::mojom::EventPtr;
 using mus::mojom::ViewportMetricsPtr;
 using mus::mojom::WindowDataPtr;
 using mus::mojom::WindowTree;
diff --git a/components/mus/ws/window_tree_host_impl.cc b/components/mus/ws/window_tree_host_impl.cc
index 7487c0ec..eee39c7 100644
--- a/components/mus/ws/window_tree_host_impl.cc
+++ b/components/mus/ws/window_tree_host_impl.cc
@@ -111,7 +111,7 @@ void WindowTreeHostImpl::SetTitle(const mojo::String& title) {
 }
 
 void WindowTreeHostImpl::AddAccelerator(uint32_t id,
-                                        mojo::EventMatcherPtr event_matcher) {
+                                        mojom::EventMatcherPtr event_matcher) {
   event_dispatcher_.AddAccelerator(id, event_matcher.Pass());
 }
 
@@ -132,7 +132,7 @@ ServerWindow* WindowTreeHostImpl::GetRootWindow() {
   return root_.get();
 }
 
-void WindowTreeHostImpl::OnEvent(mojo::EventPtr event) {
+void WindowTreeHostImpl::OnEvent(mojom::EventPtr event) {
   event_dispatcher_.OnEvent(event.Pass());
 }
 
@@ -225,7 +225,7 @@ void WindowTreeHostImpl::OnFocusChanged(ServerWindow* old_focused_window,
 }
 
 void WindowTreeHostImpl::OnAccelerator(uint32_t accelerator_id,
-                                       mojo::EventPtr event) {
+                                       mojom::EventPtr event) {
   client()->OnAccelerator(accelerator_id, event.Pass());
 }
 
@@ -240,7 +240,7 @@ ServerWindow* WindowTreeHostImpl::GetFocusedWindowForEventDispatcher() {
 
 void WindowTreeHostImpl::DispatchInputEventToWindow(ServerWindow* target,
                                                     bool in_nonclient_area,
-                                                    mojo::EventPtr event) {
+                                                    mojom::EventPtr event) {
   // If the event is in the non-client area the event goes to the owner of
   // the window. Otherwise if the window is an embed root, forward to the
   // embedded window.
diff --git a/components/mus/ws/window_tree_host_impl.h b/components/mus/ws/window_tree_host_impl.h
index 73bf36d..f41f476c 100644
--- a/components/mus/ws/window_tree_host_impl.h
+++ b/components/mus/ws/window_tree_host_impl.h
@@ -85,7 +85,7 @@ class WindowTreeHostImpl : public DisplayManagerDelegate,
   void SetSize(mojo::SizePtr size) override;
   void SetTitle(const mojo::String& title) override;
   void AddAccelerator(uint32_t id,
-                      mojo::EventMatcherPtr event_matcher) override;
+                      mojom::EventMatcherPtr event_matcher) override;
   void RemoveAccelerator(uint32_t id) override;
 
  private:
@@ -93,7 +93,7 @@ class WindowTreeHostImpl : public DisplayManagerDelegate,
 
   // DisplayManagerDelegate:
   ServerWindow* GetRootWindow() override;
-  void OnEvent(mojo::EventPtr event) override;
+  void OnEvent(mojom::EventPtr event) override;
   void OnDisplayClosed() override;
   void OnViewportMetricsChanged(
       const mojom::ViewportMetrics& old_metrics,
@@ -105,12 +105,12 @@ class WindowTreeHostImpl : public DisplayManagerDelegate,
                       ServerWindow* new_focused_window) override;
 
   // EventDispatcherDelegate:
-  void OnAccelerator(uint32_t accelerator_id, mojo::EventPtr event) override;
+  void OnAccelerator(uint32_t accelerator_id, mojom::EventPtr event) override;
   void SetFocusedWindowFromEventDispatcher(ServerWindow* window) override;
   ServerWindow* GetFocusedWindowForEventDispatcher() override;
   void DispatchInputEventToWindow(ServerWindow* target,
                                   bool in_nonclient_area,
-                                  mojo::EventPtr event) override;
+                                  mojom::EventPtr event) override;
 
   WindowTreeHostDelegate* delegate_;
   ConnectionManager* const connection_manager_;
diff --git a/components/mus/ws/window_tree_unittest.cc b/components/mus/ws/window_tree_unittest.cc
index b9c2b1e..b35f146 100644
--- a/components/mus/ws/window_tree_unittest.cc
+++ b/components/mus/ws/window_tree_unittest.cc
@@ -30,6 +30,10 @@ using mojo::Array;
 using mojo::InterfaceRequest;
 using mojo::String;
 using mus::mojom::ERROR_CODE_NONE;
+using mus::mojom::Event;
+using mus::mojom::EventPtr;
+using mus::mojom::LocationData;
+using mus::mojom::PointerData;
 using mus::mojom::WindowDataPtr;
 
 namespace mus {
@@ -108,7 +112,7 @@ class TestWindowTreeClient : public mus::mojom::WindowTreeClient {
     tracker_.OnWindowSharedPropertyChanged(window, name, new_data.Pass());
   }
   void OnWindowInputEvent(uint32_t window,
-                          mojo::EventPtr event,
+                          EventPtr event,
                           const mojo::Callback<void()>& callback) override {
     tracker_.OnWindowInputEvent(window, event.Pass());
   }
@@ -248,23 +252,23 @@ class TestDisplayManagerFactory : public DisplayManagerFactory {
   DISALLOW_COPY_AND_ASSIGN(TestDisplayManagerFactory);
 };
 
-mojo::EventPtr CreatePointerDownEvent(int x, int y) {
-  mojo::EventPtr event(mojo::Event::New());
-  event->action = mojo::EVENT_TYPE_POINTER_DOWN;
-  event->pointer_data = mojo::PointerData::New();
+EventPtr CreatePointerDownEvent(int x, int y) {
+  EventPtr event(Event::New());
+  event->action = mus::mojom::EVENT_TYPE_POINTER_DOWN;
+  event->pointer_data = PointerData::New();
   event->pointer_data->pointer_id = 1u;
-  event->pointer_data->location = mojo::LocationData::New();
+  event->pointer_data->location = LocationData::New();
   event->pointer_data->location->x = x;
   event->pointer_data->location->y = y;
   return event.Pass();
 }
 
-mojo::EventPtr CreatePointerUpEvent(int x, int y) {
-  mojo::EventPtr event(mojo::Event::New());
-  event->action = mojo::EVENT_TYPE_POINTER_UP;
-  event->pointer_data = mojo::PointerData::New();
+EventPtr CreatePointerUpEvent(int x, int y) {
+  EventPtr event(Event::New());
+  event->action = mus::mojom::EVENT_TYPE_POINTER_UP;
+  event->pointer_data = PointerData::New();
   event->pointer_data->pointer_id = 1u;
-  event->pointer_data->location = mojo::LocationData::New();
+  event->pointer_data->location = LocationData::New();
   event->pointer_data->location->x = x;
   event->pointer_data->location->y = y;
   return event.Pass();
diff --git a/components/pdf_viewer/pdf_viewer.cc b/components/pdf_viewer/pdf_viewer.cc
index 18e6cc8..9da7989 100644
--- a/components/pdf_viewer/pdf_viewer.cc
+++ b/components/pdf_viewer/pdf_viewer.cc
@@ -398,16 +398,17 @@ class PDFView : public mus::WindowTreeDelegate,
   }
 
   void OnWindowInputEvent(mus::Window* view,
-                          const mojo::EventPtr& event) override {
-    if (event->key_data && (event->action != mojo::EVENT_TYPE_KEY_PRESSED ||
-                            event->key_data->is_char)) {
+                          const mus::mojom::EventPtr& event) override {
+    if (event->key_data &&
+        (event->action != mus::mojom::EVENT_TYPE_KEY_PRESSED ||
+         event->key_data->is_char)) {
       return;
     }
 
     // TODO(rjkroege): Make panning and scrolling more performant and
     // responsive to gesture events.
     if ((event->key_data &&
-         event->key_data->windows_key_code == mojo::KEYBOARD_CODE_DOWN) ||
+         event->key_data->windows_key_code == mus::mojom::KEYBOARD_CODE_DOWN) ||
         (event->pointer_data && event->pointer_data->wheel_data &&
          event->pointer_data->wheel_data->delta_y < 0)) {
       if (current_page_ < (page_count_ - 1)) {
@@ -415,7 +416,8 @@ class PDFView : public mus::WindowTreeDelegate,
         DrawBitmap();
       }
     } else if ((event->key_data &&
-                event->key_data->windows_key_code == mojo::KEYBOARD_CODE_UP) ||
+                event->key_data->windows_key_code ==
+                    mus::mojom::KEYBOARD_CODE_UP) ||
                (event->pointer_data && event->pointer_data->wheel_data &&
                 event->pointer_data->wheel_data->delta_y > 0)) {
       if (current_page_ > 0) {
diff --git a/mandoline/ui/desktop_ui/browser_window.cc b/mandoline/ui/desktop_ui/browser_window.cc
index a6db187..d30e99b 100644
--- a/mandoline/ui/desktop_ui/browser_window.cc
+++ b/mandoline/ui/desktop_ui/browser_window.cc
@@ -183,24 +183,30 @@ void BrowserWindow::OnEmbed(mus::Window* root) {
 
   web_view_.Init(app_, content_);
 
-  host_->AddAccelerator(static_cast<uint32_t>(BrowserCommand::CLOSE),
-                        mus::CreateKeyMatcher(mojo::KEYBOARD_CODE_W,
-                                              mojo::EVENT_FLAGS_CONTROL_DOWN));
-  host_->AddAccelerator(static_cast<uint32_t>(BrowserCommand::FOCUS_OMNIBOX),
-                        mus::CreateKeyMatcher(mojo::KEYBOARD_CODE_L,
-                                              mojo::EVENT_FLAGS_CONTROL_DOWN));
-  host_->AddAccelerator(static_cast<uint32_t>(BrowserCommand::NEW_WINDOW),
-                        mus::CreateKeyMatcher(mojo::KEYBOARD_CODE_N,
-                                              mojo::EVENT_FLAGS_CONTROL_DOWN));
-  host_->AddAccelerator(static_cast<uint32_t>(BrowserCommand::SHOW_FIND),
-                        mus::CreateKeyMatcher(mojo::KEYBOARD_CODE_F,
-                                              mojo::EVENT_FLAGS_CONTROL_DOWN));
-  host_->AddAccelerator(static_cast<uint32_t>(BrowserCommand::GO_BACK),
-                        mus::CreateKeyMatcher(mojo::KEYBOARD_CODE_LEFT,
-                                              mojo::EVENT_FLAGS_ALT_DOWN));
-  host_->AddAccelerator(static_cast<uint32_t>(BrowserCommand::GO_FORWARD),
-                        mus::CreateKeyMatcher(mojo::KEYBOARD_CODE_RIGHT,
-                                              mojo::EVENT_FLAGS_ALT_DOWN));
+  host_->AddAccelerator(
+      static_cast<uint32_t>(BrowserCommand::CLOSE),
+      mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_W,
+                            mus::mojom::EVENT_FLAGS_CONTROL_DOWN));
+  host_->AddAccelerator(
+      static_cast<uint32_t>(BrowserCommand::FOCUS_OMNIBOX),
+      mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_L,
+                            mus::mojom::EVENT_FLAGS_CONTROL_DOWN));
+  host_->AddAccelerator(
+      static_cast<uint32_t>(BrowserCommand::NEW_WINDOW),
+      mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_N,
+                            mus::mojom::EVENT_FLAGS_CONTROL_DOWN));
+  host_->AddAccelerator(
+      static_cast<uint32_t>(BrowserCommand::SHOW_FIND),
+      mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_F,
+                            mus::mojom::EVENT_FLAGS_CONTROL_DOWN));
+  host_->AddAccelerator(
+      static_cast<uint32_t>(BrowserCommand::GO_BACK),
+      mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_LEFT,
+                            mus::mojom::EVENT_FLAGS_ALT_DOWN));
+  host_->AddAccelerator(
+      static_cast<uint32_t>(BrowserCommand::GO_FORWARD),
+      mus::CreateKeyMatcher(mus::mojom::KEYBOARD_CODE_RIGHT,
+                            mus::mojom::EVENT_FLAGS_ALT_DOWN));
   // Now that we're ready, load the default url.
   LoadURL(default_url_);
 
@@ -232,7 +238,7 @@ void BrowserWindow::OnConnectionLost(mus::WindowTreeConnection* connection) {
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserWindow, mus::ViewTreeHostClient implementation:
 
-void BrowserWindow::OnAccelerator(uint32_t id, mojo::EventPtr event) {
+void BrowserWindow::OnAccelerator(uint32_t id, mus::mojom::EventPtr event) {
   switch (static_cast<BrowserCommand>(id)) {
     case BrowserCommand::CLOSE:
       Close();
diff --git a/mandoline/ui/desktop_ui/browser_window.h b/mandoline/ui/desktop_ui/browser_window.h
index c3606fe..1f60ccd 100644
--- a/mandoline/ui/desktop_ui/browser_window.h
+++ b/mandoline/ui/desktop_ui/browser_window.h
@@ -61,7 +61,7 @@ class BrowserWindow : public mus::WindowTreeDelegate,
   void OnConnectionLost(mus::WindowTreeConnection* connection) override;
 
   // Overridden from WindowTreeHostClient:
-  void OnAccelerator(uint32_t id, mojo::EventPtr event) override;
+  void OnAccelerator(uint32_t id, mus::mojom::EventPtr event) override;
 
   // Overridden from web_view::mojom::WebViewClient:
   void TopLevelNavigateRequest(mojo::URLRequestPtr request) override;
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
diff --git a/ui/views/mus/window_tree_host_mus.cc b/ui/views/mus/window_tree_host_mus.cc
index 884274a..9ad0bdd 100644
--- a/ui/views/mus/window_tree_host_mus.cc
+++ b/ui/views/mus/window_tree_host_mus.cc
@@ -135,7 +135,7 @@ void WindowTreeHostMojo::OnWindowFocusChanged(mus::Window* gained_focus,
 }
 
 void WindowTreeHostMojo::OnWindowInputEvent(mus::Window* view,
-                                            const mojo::EventPtr& event) {
+                                            const mus::mojom::EventPtr& event) {
   scoped_ptr<ui::Event> ui_event(event.To<scoped_ptr<ui::Event>>());
   if (!ui_event)
     return;
diff --git a/ui/views/mus/window_tree_host_mus.h b/ui/views/mus/window_tree_host_mus.h
index 246ddb7..ca1b4ca 100644
--- a/ui/views/mus/window_tree_host_mus.h
+++ b/ui/views/mus/window_tree_host_mus.h
@@ -64,7 +64,7 @@ class WindowTreeHostMojo : public aura::WindowTreeHost,
   void OnWindowFocusChanged(mus::Window* gained_focus,
                             mus::Window* lost_focus) override;
   void OnWindowInputEvent(mus::Window* view,
-                          const mojo::EventPtr& event) override;
+                          const mus::mojom::EventPtr& event) override;
   void OnWindowSharedPropertyChanged(
       mus::Window* window,
       const std::string& name,