Reorganize event mojom files.

components/mus/ws/event_dispatcher.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/mus/ws/event_dispatcher.h"
 
 #include <algorithm>
 
 #include "base/time/time.h"
 #include "components/mus/ws/accelerator.h"
@@ skipping 236 matching lines @@
 }
 
 void EventDispatcher::ProcessEvent(const ui::Event& event) {
   if (!root_)  // Tests may not have a root window.
     return;
 
   if (event.IsKeyEvent()) {
     const ui::KeyEvent* key_event = event.AsKeyEvent();
     if (event.type() == ui::ET_KEY_PRESSED && !key_event->is_char()) {
       Accelerator* pre_target =
-          FindAccelerator(*key_event, mojom::AcceleratorPhase::PRE_TARGET);
+          FindAccelerator(*key_event, ui::mojom::AcceleratorPhase::PRE_TARGET);
       if (pre_target) {
         delegate_->OnAccelerator(pre_target->id(), event);
         return;
       }
     }
     ProcessKeyEvent(*key_event);
     return;
   }
 
   if (event.IsPointerEvent() || event.IsMouseWheelEvent()) {
     ProcessLocatedEvent(*event.AsLocatedEvent());
     return;
   }
 
   NOTREACHED();
 }
 
 void EventDispatcher::ProcessKeyEvent(const ui::KeyEvent& event) {
   Accelerator* post_target =
-      FindAccelerator(event, mojom::AcceleratorPhase::POST_TARGET);
+      FindAccelerator(event, ui::mojom::AcceleratorPhase::POST_TARGET);
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher();
   if (focused_window) {
     delegate_->DispatchInputEventToWindow(focused_window, false, event,
                                           post_target);
     return;
   }
   delegate_->OnEventTargetNotFound(event);
   if (post_target)
     delegate_->OnAccelerator(post_target->id(), event);
@@ skipping 202 matching lines @@
   DCHECK_LT(0u, it->second);
   it->second--;
   if (!it->second) {
     window->RemoveObserver(this);
     observed_windows_.erase(it);
   }
 }
 
 Accelerator* EventDispatcher::FindAccelerator(
     const ui::KeyEvent& event,
-    const mojom::AcceleratorPhase phase) {
+    const ui::mojom::AcceleratorPhase phase) {
   for (const auto& pair : accelerators_) {
     if (pair.second->MatchesEvent(event, phase)) {
       return pair.second.get();
     }
   }
   return nullptr;
 }
 
 void EventDispatcher::OnWillChangeWindowHierarchy(ServerWindow* window,
                                                   ServerWindow* new_parent,
@@ skipping 18 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus