aura: Remove event-dispatch methods from WindowTreeHostDelegate interface.

ui/aura/remote_root_window_host_win.cc

 // Copyright (c) 2012 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 "ui/aura/remote_root_window_host_win.h"
 
 #include <windows.h>
 
 #include <algorithm>
 
@@ skipping 467 matching lines @@
 }
 
 void RemoteWindowTreeHostWin::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   NOTIMPLEMENTED();
 }
 
 void RemoteWindowTreeHostWin::PrepareForShutdown() {
 }
 
+ui::EventProcessor* RemoteWindowTreeHostWin::GetEventProcessor() {
+  return delegate_->GetEventProcessor();
+}
+
 void RemoteWindowTreeHostWin::CancelComposition() {
   if (!host_)
     return;
   host_->Send(new MetroViewerHostMsg_ImeCancelComposition);
 }
 
 void RemoteWindowTreeHostWin::OnTextInputClientUpdated(
     const std::vector<int32>& input_scopes,
     const std::vector<gfx::Rect>& composition_character_bounds) {
   if (!host_)
@@ skipping 17 matching lines @@
   gfx::Point result( x * scale_factor, y * scale_factor);
   return result;
 }
 
 void RemoteWindowTreeHostWin::OnMouseMoved(int32 x, int32 y, int32 flags) {
   if (ignore_mouse_moves_until_set_cursor_ack_)
     return;
 
   gfx::Point location = PointFromNativeEvent(x, y);
   ui::MouseEvent event(ui::ET_MOUSE_MOVED, location, location, flags, 0);
-  delegate_->OnHostMouseEvent(&event);
+  SendEventToProcessor(&event);
 }
 
 void RemoteWindowTreeHostWin::OnMouseButton(
     const MetroViewerHostMsg_MouseButtonParams& params) {
   gfx::Point location = PointFromNativeEvent(params.x, params.y);
   ui::MouseEvent mouse_event(params.event_type, location, location,
                              static_cast<int>(params.flags),
                              static_cast<int>(params.changed_button));
 
   SetEventFlags(params.flags | key_event_flags());
   if (params.event_type == ui::ET_MOUSEWHEEL) {
     int x_offset = params.is_horizontal_wheel ? params.extra : 0;
     int y_offset = !params.is_horizontal_wheel ? params.extra : 0;
     ui::MouseWheelEvent wheel_event(mouse_event, x_offset, y_offset);
-    delegate_->OnHostMouseEvent(&wheel_event);
+    SendEventToProcessor(&wheel_event);
   } else if (params.event_type == ui::ET_MOUSE_PRESSED) {
     // TODO(shrikant): Ideally modify code in event.cc by adding automatic
     // tracking of double clicks in synthetic MouseEvent constructor code.
     // Non-synthetic MouseEvent constructor code does automatically track
     // this. Need to use some caution while modifying synthetic constructor
     // as many tests and other code paths depend on it and apparently
     // specifically depend on non implicit tracking of previous mouse event.
     if (last_mouse_click_event_ &&
         ui::MouseEvent::IsRepeatedClickEvent(mouse_event,
                                              *last_mouse_click_event_)) {
       mouse_event.SetClickCount(2);
     } else {
       mouse_event.SetClickCount(1);
     }
     last_mouse_click_event_ .reset(new ui::MouseEvent(mouse_event));
-    delegate_->OnHostMouseEvent(&mouse_event);
+    SendEventToProcessor(&mouse_event);
   } else {
-    delegate_->OnHostMouseEvent(&mouse_event);
+    SendEventToProcessor(&mouse_event);
   }
 }
 
 void RemoteWindowTreeHostWin::OnKeyDown(uint32 vkey,
                                         uint32 repeat_count,
                                         uint32 scan_code,
                                         uint32 flags) {
   DispatchKeyboardMessage(ui::ET_KEY_PRESSED, vkey, repeat_count, scan_code,
                           flags, false);
 }
@@ skipping 20 matching lines @@
 
 void RemoteWindowTreeHostWin::OnTouchDown(int32 x,
                                           int32 y,
                                           uint64 timestamp,
                                           uint32 pointer_id) {
   gfx::Point location = PointFromNativeEvent(x, y);
   ui::TouchEvent event(ui::ET_TOUCH_PRESSED,
                        location,
                        pointer_id,
                        base::TimeDelta::FromMicroseconds(timestamp));
-  delegate_->OnHostTouchEvent(&event);
+  SendEventToProcessor(&event);
 }
 
 void RemoteWindowTreeHostWin::OnTouchUp(int32 x,
                                         int32 y,
                                         uint64 timestamp,
                                         uint32 pointer_id) {
   gfx::Point location = PointFromNativeEvent(x, y);
   ui::TouchEvent event(ui::ET_TOUCH_RELEASED,
                        location,
                        pointer_id,
                        base::TimeDelta::FromMicroseconds(timestamp));
-  delegate_->OnHostTouchEvent(&event);
+  SendEventToProcessor(&event);
 }
 
 void RemoteWindowTreeHostWin::OnTouchMoved(int32 x,
                                            int32 y,
                                            uint64 timestamp,
                                            uint32 pointer_id) {
   gfx::Point location = PointFromNativeEvent(x, y);
   ui::TouchEvent event(ui::ET_TOUCH_MOVED,
                        location,
                        pointer_id,
                        base::TimeDelta::FromMicroseconds(timestamp));
-  delegate_->OnHostTouchEvent(&event);
+  SendEventToProcessor(&event);
 }
 
 void RemoteWindowTreeHostWin::OnFileSaveAsDone(bool success,
                                                const base::FilePath& filename,
                                                int filter_index) {
   if (success)
     file_saveas_completion_callback_.Run(filename, filter_index, NULL);
   else
     failure_callback_.Run(NULL);
   file_saveas_completion_callback_.Reset();
@@ skipping 103 matching lines @@
                                                        : keyup_message[index]);
     ::PostThreadMessage(::GetCurrentThreadId(),
                         message,
                         vkey,
                         repeat_count | scan_code >> 15);
   } else {
     ui::KeyEvent event(type,
                        ui::KeyboardCodeForWindowsKeyCode(vkey),
                        flags,
                        is_character);
-    delegate_->OnHostKeyEvent(&event);
+    SendEventToProcessor(&event);
   }
 }
 
 void RemoteWindowTreeHostWin::SetEventFlags(uint32 flags) {
   if (flags == event_flags_)
     return;
   event_flags_ = flags;
   SetVirtualKeyStates(event_flags_);
 }
 
 }  // namespace aura