aura: Remove event-dispatch methods from WindowTreeHostDelegate interface.

ui/views/widget/desktop_aura/desktop_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/views/widget/desktop_aura/desktop_root_window_host_win.h"
 
 #include "base/win/metro.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 559 matching lines @@
     const base::NativeEvent& native_event) {
 }
 
 void DesktopWindowTreeHostWin::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
 }
 
 void DesktopWindowTreeHostWin::PrepareForShutdown() {
 }
 
+
+////////////////////////////////////////////////////////////////////////////////
+// DesktopWindowTreeHostWin, ui::EventSource implementation:
+
+ui::EventProcessor* DesktopWindowTreeHostWin::GetEventProcessor() {
+  return delegate_->GetEventProcessor();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostWin, aura::AnimationHost implementation:
 
 void DesktopWindowTreeHostWin::SetHostTransitionOffsets(
     const gfx::Vector2d& top_left_delta,
     const gfx::Vector2d& bottom_right_delta) {
   gfx::Rect bounds_without_expansion = GetBounds();
   window_expansion_top_left_delta_ = top_left_delta;
   window_expansion_bottom_right_delta_ = bottom_right_delta;
   SetBounds(bounds_without_expansion);
@@ skipping 249 matching lines @@
 }
 
 void DesktopWindowTreeHostWin::HandleNativeBlur(HWND focused_window) {
   // TODO(beng): inform the native_widget_delegate_.
   InputMethod* input_method = GetInputMethod();
   if (input_method)
     input_method->OnBlur();
 }
 
 bool DesktopWindowTreeHostWin::HandleMouseEvent(const ui::MouseEvent& event) {
-  return delegate_->OnHostMouseEvent(const_cast<ui::MouseEvent*>(&event));
+  SendEventToProcessor(const_cast<ui::MouseEvent*>(&event));
+  return event.handled();
 }
 
 bool DesktopWindowTreeHostWin::HandleKeyEvent(const ui::KeyEvent& event) {
   return false;
 }
 
 bool DesktopWindowTreeHostWin::HandleUntranslatedKeyEvent(
     const ui::KeyEvent& event) {
   ui::KeyEvent duplicate_event(event);
-  return delegate_->OnHostKeyEvent(&duplicate_event);
+  SendEventToProcessor(&duplicate_event);
+  return duplicate_event.handled();
 }
 
 void DesktopWindowTreeHostWin::HandleTouchEvent(
     const ui::TouchEvent& event) {
   // HWNDMessageHandler asynchronously processes touch events. Because of this
   // it's possible for the aura::RootWindow to have been destroyed by the time
   // we attempt to process them.
   if (!GetWidget()->GetNativeView())
     return;
 
   // Currently we assume the window that has capture gets touch events too.
   aura::RootWindow* root =
       aura::RootWindow::GetForAcceleratedWidget(GetCapture());
   if (root) {
     DesktopWindowTreeHostWin* target =
         root->window()->GetProperty(kDesktopWindowTreeHostKey);
     if (target && target->HasCapture() && target != this) {
       POINT target_location(event.location().ToPOINT());
       ClientToScreen(GetHWND(), &target_location);
       ScreenToClient(target->GetHWND(), &target_location);
       ui::TouchEvent target_event(event, static_cast<View*>(NULL),
                                   static_cast<View*>(NULL));
       target_event.set_location(gfx::Point(target_location));
       target_event.set_root_location(target_event.location());
-      target->delegate_->OnHostTouchEvent(&target_event);
+      target->SendEventToProcessor(&target_event);
       return;
     }
   }
-  delegate_->OnHostTouchEvent(
-      const_cast<ui::TouchEvent*>(&event));
+  SendEventToProcessor(const_cast<ui::TouchEvent*>(&event));
 }
 
 bool DesktopWindowTreeHostWin::HandleIMEMessage(UINT message,
                                                 WPARAM w_param,
                                                 LPARAM l_param,
                                                 LRESULT* result) {
   MSG msg = {};
   msg.hwnd = GetHWND();
   msg.message = message;
   msg.wParam = w_param;
@@ skipping 47 matching lines @@
   return false;
 }
 
 void DesktopWindowTreeHostWin::PostHandleMSG(UINT message,
                                              WPARAM w_param,
                                              LPARAM l_param) {
 }
 
 bool DesktopWindowTreeHostWin::HandleScrollEvent(
     const ui::ScrollEvent& event) {
-  return delegate_->OnHostScrollEvent(const_cast<ui::ScrollEvent*>(&event));
+  SendEventToProcessor(const_cast<ui::ScrollEvent*>(&event));
+  return event.handled();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostWin, private:
 
 Widget* DesktopWindowTreeHostWin::GetWidget() {
   return native_widget_delegate_->AsWidget();
 }
 
 const Widget* DesktopWindowTreeHostWin::GetWidget() const {
@@ skipping 34 matching lines @@
 
 // static
 DesktopWindowTreeHost* DesktopWindowTreeHost::Create(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura) {
   return new DesktopWindowTreeHostWin(native_widget_delegate,
                                       desktop_native_widget_aura);
 }
 
 }  // namespace views