events: Dispatch all events through EventHandler::OnEvent from the dispatcher.

The EventDispatcher dispatches all events to EventHandler::OnEvent. The default
implementation routes various events to more appropriate handlers (e.g. OnKeyEvent
for KeyEvent etc.)

BUG=163606

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=170641

Review URL: https://codereview.chromium.org/11299285

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@170656 0039d316-1c4b-4281-b951-d872f2087c98

ui/base/events/event.h

@@ -97,7 +97,8 @@ class UI_EXPORT Event {
            type_ == ET_MOUSE_MOVED ||
            type_ == ET_MOUSE_ENTERED ||
            type_ == ET_MOUSE_EXITED ||
-           type_ == ET_MOUSEWHEEL;
+           type_ == ET_MOUSEWHEEL ||
+           type_ == ET_MOUSE_CAPTURE_CHANGED;
   }
 
   bool IsTouchEvent() const {
@@ -114,6 +115,7 @@ class UI_EXPORT Event {
       case ET_GESTURE_SCROLL_END:
       case ET_GESTURE_SCROLL_UPDATE:
       case ET_GESTURE_TAP:
+      case ET_GESTURE_TAP_CANCEL:
       case ET_GESTURE_TAP_DOWN:
       case ET_GESTURE_BEGIN:
       case ET_GESTURE_END:

ui/base/events/event_dispatcher.cc

@@ -24,31 +24,6 @@ EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
   return handler->OnEvent(event);
 }
 
-EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
-                                                          KeyEvent* event) {
-  return handler->OnKeyEvent(event);
-}
-
-EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
-                                                          MouseEvent* event) {
-  return handler->OnMouseEvent(event);
-}
-
-EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
-                                                          ScrollEvent* event) {
-  return handler->OnScrollEvent(event);
-}
-
-EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
-                                                          TouchEvent* event) {
-  return handler->OnTouchEvent(event);
-}
-
-EventResult EventDispatcher::DispatchEventToSingleHandler(EventHandler* handler,
-                                                          GestureEvent* event) {
-  return handler->OnGestureEvent(event);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // EventDispatcher::ScopedDispatchHelper
 

ui/base/events/event_dispatcher.h

@@ -115,16 +115,6 @@ class UI_EXPORT EventDispatcher {
   }
 
   EventResult DispatchEventToSingleHandler(EventHandler* handler, Event* event);
-  EventResult DispatchEventToSingleHandler(EventHandler* handler,
-                                           KeyEvent* event);
-  EventResult DispatchEventToSingleHandler(EventHandler* handler,
-                                           MouseEvent* event);
-  EventResult DispatchEventToSingleHandler(EventHandler* handler,
-                                           ScrollEvent* event);
-  EventResult DispatchEventToSingleHandler(EventHandler* handler,
-                                           TouchEvent* event);
-  EventResult DispatchEventToSingleHandler(EventHandler* handler,
-                                           GestureEvent* event);
 
   // This is used to track whether the dispatcher has been destroyed in the
   // middle of dispatching an event.

ui/base/events/event_handler.cc

@@ -4,6 +4,8 @@
 
 #include "ui/base/events/event_handler.h"
 
+#include "ui/base/events/event.h"
+
 namespace ui {
 
 EventHandler::EventHandler() {
@@ -13,6 +15,16 @@ EventHandler::~EventHandler() {
 }
 
 EventResult EventHandler::OnEvent(Event* event) {
+  if (event->IsKeyEvent())
+    return OnKeyEvent(static_cast<KeyEvent*>(event));
+  if (event->IsMouseEvent())
+    return OnMouseEvent(static_cast<MouseEvent*>(event));
+  if (event->IsScrollEvent())
+    return OnScrollEvent(static_cast<ScrollEvent*>(event));
+  if (event->IsTouchEvent())
+    return OnTouchEvent(static_cast<TouchEvent*>(event));
+  if (event->IsGestureEvent())
+    return OnGestureEvent(static_cast<GestureEvent*>(event));
   return ui::ER_UNHANDLED;
 }
 

ui/base/events/event_handler.h

@@ -28,6 +28,10 @@ class UI_EXPORT EventHandler {
   EventHandler();
   virtual ~EventHandler();
 
+  // This is called for all events. The default implementation routes the event
+  // to one of the event-specific callbacks (OnKeyEvent, OnMouseEvent etc.). If
+  // this is overridden, then normally, the override should chain into the
+  // default implementation for un-handled events.
   virtual EventResult OnEvent(Event* event);
 
   virtual EventResult OnKeyEvent(KeyEvent* event);

ui/ui.gyp

@@ -801,6 +801,12 @@
           'sources!': [
             'base/events/event.cc',
             'base/events/event.h',
+            'base/events/event_dispatcher.cc',
+            'base/events/event_dispatcher.h',
+            'base/events/event_handler.cc',
+            'base/events/event_handler.h',
+            'base/events/event_target.cc',
+            'base/events/event_target.h',
             'base/x/events_x.cc',
           ],
         }],