mustash: Use ui::chromeos::EventRewriter in mus

services/ui/ws/platform_display_default.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "services/ui/ws/platform_display_default.h"
 
 #include "base/memory/ptr_util.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "services/ui/display/screen_manager.h"
 #include "services/ui/ws/platform_display_init_params.h"
@@ skipping 149 matching lines @@
 gfx::AcceleratedWidget PlatformDisplayDefault::GetAcceleratedWidget() const {
   return widget_;
 }
 
 void PlatformDisplayDefault::UpdateEventRootLocation(ui::LocatedEvent* event) {
   gfx::Point location = event->location();
   location.Offset(metrics_.bounds.x(), metrics_.bounds.y());
   event->set_root_location(location);
 }
 
+ui::EventProcessor* PlatformDisplayDefault::GetEventProcessor() {
+  return delegate_->GetEventProcessor();
+}
+
 void PlatformDisplayDefault::OnBoundsChanged(const gfx::Rect& new_bounds) {
   // We only care if the window size has changed.
   if (new_bounds.size() == metrics_.pixel_size)
     return;
 
   // TODO(kylechar): Maybe do something here. For CrOS we don't need to support
   // PlatformWindow initiated resizes. For other platforms we need to do
   // something but that isn't fully flushed out.
 }
 
 void PlatformDisplayDefault::OnDamageRect(const gfx::Rect& damaged_region) {
   if (frame_generator_)
     frame_generator_->OnWindowDamaged();
 }
 
 void PlatformDisplayDefault::DispatchEvent(ui::Event* event) {
   if (event->IsLocatedEvent())
     UpdateEventRootLocation(event->AsLocatedEvent());
 
   if (event->IsScrollEvent()) {
     // TODO(moshayedi): crbug.com/602859. Dispatch scroll events as
     // they are once we have proper support for scroll events.
-    delegate_->OnEvent(
-        ui::PointerEvent(ui::MouseWheelEvent(*event->AsScrollEvent())));
+    ui::PointerEvent pointer_event(
+        ui::MouseWheelEvent(*event->AsScrollEvent()));
+    SendEventToProcessor(&pointer_event);
   } else if (event->IsMouseEvent()) {
-    delegate_->OnEvent(ui::PointerEvent(*event->AsMouseEvent()));
+    ui::PointerEvent pointer_event(*event->AsMouseEvent());
+    SendEventToProcessor(&pointer_event);
   } else if (event->IsTouchEvent()) {
-    delegate_->OnEvent(ui::PointerEvent(*event->AsTouchEvent()));
+    ui::PointerEvent pointer_event(*event->AsTouchEvent());
+    SendEventToProcessor(&pointer_event);
   } else {
-    delegate_->OnEvent(*event);
+    SendEventToProcessor(event);
   }
 
 #if defined(USE_X11) || defined(USE_OZONE)
   // We want to emulate the WM_CHAR generation behaviour of Windows.
   //
   // On Linux, we've previously inserted characters by having
   // InputMethodAuraLinux take all key down events and send a character event
   // to the TextInputClient. This causes a mismatch in code that has to be
   // shared between Windows and Linux, including blink code. Now that we're
   // trying to have one way of doing things, we need to standardize on and
   // emulate Windows character events.
   //
   // This is equivalent to what we're doing in the current Linux port, but
   // done once instead of done multiple times in different places.
   if (event->type() == ui::ET_KEY_PRESSED) {
     ui::KeyEvent* key_press_event = event->AsKeyEvent();
     ui::KeyEvent char_event(key_press_event->GetCharacter(),
                             key_press_event->key_code(),
                             key_press_event->flags());
     // We don't check that GetCharacter() is equal because changing a key event
     // with an accelerator to a character event can change the character, for
     // example, from 'M' to '^M'.
     DCHECK_EQ(key_press_event->key_code(), char_event.key_code());
     DCHECK_EQ(key_press_event->flags(), char_event.flags());
-    delegate_->OnEvent(char_event);
+    SendEventToProcessor(&char_event);
   }
 #endif
 }
 
 void PlatformDisplayDefault::OnCloseRequest() {
   display::ScreenManager::GetInstance()->RequestCloseDisplay(GetId());
 }
 
 void PlatformDisplayDefault::OnClosed() {}
 
@@ skipping 23 matching lines @@
 }
 
 void PlatformDisplayDefault::OnActivationChanged(bool active) {}
 
 bool PlatformDisplayDefault::IsInHighContrastMode() {
   return delegate_ ? delegate_->IsInHighContrastMode() : false;
 }
 
 }  // namespace ws
 }  // namespace ui