Return a enumeration of the state of handling of InputEvents.

third_party/WebKit/Source/web/PageWidgetDelegate.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 96 matching lines @@
 {
     paintInternal(page, canvas, rect, root, GlobalPaintNormalPhase);
 }
 
 void PageWidgetDelegate::paintIgnoringCompositing(Page& page, WebCanvas* canvas,
     const WebRect& rect, LocalFrame& root)
 {
     paintInternal(page, canvas, rect, root, GlobalPaintFlattenCompositingLayers);
 }
 
-bool PageWidgetDelegate::handleInputEvent(PageWidgetEventHandler& handler, const WebInputEvent& event, LocalFrame* root)
+WebInputEventResult PageWidgetDelegate::handleInputEvent(PageWidgetEventHandler& handler, const WebInputEvent& event, LocalFrame* root)
 {
     switch (event.type) {
 
     // FIXME: WebKit seems to always return false on mouse events processing
     // methods. For now we'll assume it has processed them (as we are only
     // interested in whether keyboard events are processed).
-    // FIXME: Why do we return true when there is no root or the root is
-    // detached?
+    // FIXME: Why do we return HandleSuppressed when there is no root or
+    // the root is detached?
     case WebInputEvent::MouseMove:
         if (!root || !root->view())
-            return true;
+            return WebInputEventResult::HandledSuppressed;
         handler.handleMouseMove(*root, static_cast<const WebMouseEvent&>(event));
-        return true;
+        return WebInputEventResult::HandledSystem;
     case WebInputEvent::MouseLeave:
         if (!root || !root->view())
-            return true;
+            return WebInputEventResult::HandledSuppressed;
         handler.handleMouseLeave(*root, static_cast<const WebMouseEvent&>(event));
-        return true;
+        return WebInputEventResult::HandledSystem;
     case WebInputEvent::MouseDown:
         if (!root || !root->view())
-            return true;
+            return WebInputEventResult::HandledSuppressed;
         handler.handleMouseDown(*root, static_cast<const WebMouseEvent&>(event));
-        return true;
+        return WebInputEventResult::HandledSystem;
     case WebInputEvent::MouseUp:
         if (!root || !root->view())
-            return true;
+            return WebInputEventResult::HandledSuppressed;
         handler.handleMouseUp(*root, static_cast<const WebMouseEvent&>(event));
-        return true;
-
+        return WebInputEventResult::HandledSystem;

[kotenkov, 2016/01/12 20:55:00]

It seems to me that there are a lot of changes in EventHandler.cpp, that are
simply not used. The call above will lead to
|EventHanlder::handleMouseRelease()| that may return any of the elements of the
enum. But we ignore that value and always return
WebInputEventResult::HandledSystem. The same is true for
WebInputEvent::MouseMove and some others. It seems to me that there is an error
here: either we should pay attention to values returned from EventHandler
functions, or we shouldn't have changed anything there.

[dtapuska, 2016/01/12 21:06:48]

I agree the return values should be used. I wasn't trying to clean up all the
cruft; and that change was larger than I wanted to make this change. Feel free
to go ahead and fix it if you like.

     case WebInputEvent::MouseWheel:
         if (!root || !root->view())
-            return false;
+            return WebInputEventResult::NotHandled;
         return handler.handleMouseWheel(*root, static_cast<const WebMouseWheelEvent&>(event));
 
     case WebInputEvent::RawKeyDown:
     case WebInputEvent::KeyDown:
     case WebInputEvent::KeyUp:
         return handler.handleKeyEvent(static_cast<const WebKeyboardEvent&>(event));
 
     case WebInputEvent::Char:
         return handler.handleCharEvent(static_cast<const WebKeyboardEvent&>(event));
     case WebInputEvent::GestureScrollBegin:
@@ skipping 10 matching lines @@
     case WebInputEvent::GestureTwoFingerTap:
     case WebInputEvent::GestureLongPress:
     case WebInputEvent::GestureLongTap:
         return handler.handleGestureEvent(static_cast<const WebGestureEvent&>(event));
 
     case WebInputEvent::TouchStart:
     case WebInputEvent::TouchMove:
     case WebInputEvent::TouchEnd:
     case WebInputEvent::TouchCancel:
         if (!root || !root->view())
-            return false;
+            return WebInputEventResult::NotHandled;
         return handler.handleTouchEvent(*root, static_cast<const WebTouchEvent&>(event));
     case WebInputEvent::GesturePinchBegin:
     case WebInputEvent::GesturePinchEnd:
     case WebInputEvent::GesturePinchUpdate:
         // Touchscreen pinch events are currently not handled in main thread. Once they are,
         // these should be passed to |handleGestureEvent| similar to gesture scroll events.
-        return false;
+        return WebInputEventResult::NotHandled;
     default:
-        return false;
+        return WebInputEventResult::NotHandled;
     }
 }
 
 // ----------------------------------------------------------------
 // Default handlers for PageWidgetEventHandler
 
 void PageWidgetEventHandler::handleMouseMove(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     mainFrame.eventHandler().handleMouseMoveEvent(PlatformMouseEventBuilder(mainFrame.view(), event));
 }
 
 void PageWidgetEventHandler::handleMouseLeave(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     mainFrame.eventHandler().handleMouseLeaveEvent(PlatformMouseEventBuilder(mainFrame.view(), event));
 }
 
 void PageWidgetEventHandler::handleMouseDown(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     mainFrame.eventHandler().handleMousePressEvent(PlatformMouseEventBuilder(mainFrame.view(), event));
 }
 
 void PageWidgetEventHandler::handleMouseUp(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     mainFrame.eventHandler().handleMouseReleaseEvent(PlatformMouseEventBuilder(mainFrame.view(), event));
 }
 
-bool PageWidgetEventHandler::handleMouseWheel(LocalFrame& mainFrame, const WebMouseWheelEvent& event)
+WebInputEventResult PageWidgetEventHandler::handleMouseWheel(LocalFrame& mainFrame, const WebMouseWheelEvent& event)
 {
     return mainFrame.eventHandler().handleWheelEvent(PlatformWheelEventBuilder(mainFrame.view(), event));
 }
 
-bool PageWidgetEventHandler::handleTouchEvent(LocalFrame& mainFrame, const WebTouchEvent& event)
+WebInputEventResult PageWidgetEventHandler::handleTouchEvent(LocalFrame& mainFrame, const WebTouchEvent& event)
 {
     return mainFrame.eventHandler().handleTouchEvent(PlatformTouchEventBuilder(mainFrame.view(), event));
 }
 
 #define WEBINPUT_EVENT_CASE(type) case WebInputEvent::type: return #type;
 
 const char* PageWidgetEventHandler::inputTypeToName(WebInputEvent::Type type)
 {
     switch (type) {
         WEBINPUT_EVENT_CASE(MouseDown)
@@ skipping 28 matching lines @@
         WEBINPUT_EVENT_CASE(TouchMove)
         WEBINPUT_EVENT_CASE(TouchEnd)
         WEBINPUT_EVENT_CASE(TouchCancel)
     default:
         ASSERT_NOT_REACHED();
         return "";
     }
 }
 
 } // namespace blink