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/display_client_compositor_frame_sink.h"
@@ skipping 34 matching lines @@
   // Don't notify the delegate from the destructor.
   delegate_ = nullptr;
 
   frame_generator_.reset();
   // Destroy the PlatformWindow early on as it may call us back during
   // destruction and we want to be in a known state. But destroy the surface
   // first because it can still be using the platform window.
   platform_window_.reset();
 }
 
+EventSink* PlatformDisplayDefault::GetEventSink() {
+  return delegate_->GetEventSink();
+}
+
 void PlatformDisplayDefault::Init(PlatformDisplayDelegate* delegate) {
   delegate_ = delegate;
 
   const gfx::Rect& bounds = metrics_.bounds_in_pixels;
   DCHECK(!bounds.size().IsEmpty());
 
 #if defined(OS_WIN)
   platform_window_ = base::MakeUnique<ui::WinWindow>(this, bounds);
 #elif defined(USE_X11) && !defined(OS_CHROMEOS)
   platform_window_ = base::MakeUnique<ui::X11Window>(this, bounds);
@@ skipping 83 matching lines @@
 
 void PlatformDisplayDefault::UpdateEventRootLocation(ui::LocatedEvent* event) {
   // TODO(riajiang): This is broken for HDPI because it mixes PPs and DIPs. See
   // http://crbug.com/701036 for details.
   const display::Display& display = delegate_->GetDisplay();
   gfx::Point location = event->location();
   location.Offset(display.bounds().x(), display.bounds().y());
   event->set_root_location(location);
 }
 
+void PlatformDisplayDefault::DispatchEventToDelegate(const ui::Event& event) {
+  SendEventToSink(const_cast<ui::Event*>(&event));

[sky, 2017/03/20 15:42:12]

Don't cast away the const here. Instead make this take a ui::Event* event.

[Peng, 2017/03/20 17:24:14]

Done.

+}
+
 void PlatformDisplayDefault::OnBoundsChanged(const gfx::Rect& new_bounds) {
   // We only care if the window size has changed.
   if (new_bounds.size() == metrics_.bounds_in_pixels.size())
     return;
 
   // TODO(tonikitoo): Handle the bounds changing in external window mode. The
   // window should be resized by the WS and it shouldn't involve ScreenManager.
 }
 
 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(
+    DispatchEventToDelegate(
         ui::PointerEvent(ui::MouseWheelEvent(*event->AsScrollEvent())));
   } else if (event->IsMouseEvent()) {
-    delegate_->OnEvent(ui::PointerEvent(*event->AsMouseEvent()));
+    DispatchEventToDelegate(ui::PointerEvent(*event->AsMouseEvent()));
   } else if (event->IsTouchEvent()) {
-    delegate_->OnEvent(ui::PointerEvent(*event->AsTouchEvent()));
+    DispatchEventToDelegate(ui::PointerEvent(*event->AsTouchEvent()));
   } else {
-    delegate_->OnEvent(*event);
+    DispatchEventToDelegate(*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);
+    DispatchEventToDelegate(char_event);
   }
 #endif
 }
 
 void PlatformDisplayDefault::OnCloseRequest() {
   // TODO(tonikitoo): Handle a close request in external window mode. The window
   // should be closed by the WS and it shouldn't involve ScreenManager.
   const int64_t display_id = delegate_->GetDisplay().id();
   display::ScreenManager::GetInstance()->RequestCloseDisplay(display_id);
 }
@@ skipping 44 matching lines @@
 }
 
 void PlatformDisplayDefault::OnActivationChanged(bool active) {}
 
 bool PlatformDisplayDefault::IsInHighContrastMode() {
   return delegate_ ? delegate_->IsInHighContrastMode() : false;
 }
 
 }  // namespace ws
 }  // namespace ui