Implement MouseEvent buttons attribute.

Source/core/page/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 1616 matching lines @@
 
 
 bool EventHandler::dispatchDragEvent(const AtomicString& eventType, Node* dragTarget, const PlatformMouseEvent& event, DataTransfer* dataTransfer)
 {
     FrameView* view = m_frame->view();
 
     // FIXME: We might want to dispatch a dragleave even if the view is gone.
     if (!view)
         return false;
 
+    // FIXME: The drag event have to support for |buttons| attribute because
+    // the event is derived from mouse event. Please see crbug.com/276941.
     RefPtrWillBeRawPtr<MouseEvent> me = MouseEvent::create(eventType,
         true, true, m_frame->document()->domWindow(),
         0, event.globalPosition().x(), event.globalPosition().y(), event.position().x(), event.position().y(),
         event.movementDelta().x(), event.movementDelta().y(),
         event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(),
-        0, nullptr, dataTransfer);
+        0, 0, nullptr, dataTransfer);
 
     dragTarget->dispatchEvent(me.get(), IGNORE_EXCEPTION);
     return me->defaultPrevented();
 }
 
 static bool targetIsFrame(Node* target, LocalFrame*& frame)
 {
     if (!isHTMLFrameElementBase(target))
         return false;
 
@@ skipping 564 matching lines @@
     case PlatformEvent::GesturePinchBegin:
     case PlatformEvent::GesturePinchEnd:
     case PlatformEvent::GesturePinchUpdate:
         return false;
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
 }
 
+static PlatformEvent::Modifiers platformModifiersFrom(unsigned modifierFlags)

[Rick Byers, 2014/11/28 17:36:02]

nit: this function is simple enough you should just write the cast inline rather
than use a helper function.

[zino, 2014/12/03 15:47:15]

Done.

+{
+    return static_cast<PlatformEvent::Modifiers>(modifierFlags);
+}
+
+static unsigned modifierFlagsFrom(const PlatformGestureEvent& event)

[Rick Byers, 2014/11/28 17:36:02]

Isn't this function pretty much equivalent to just 'return event.modifiers()'? 
You should just be able to copy the modifiers directly without needing this
function at all, right?  I'm not sure why the original code was doing this -
maybe just old...

[zino, 2014/12/03 15:47:15]

Yep.. you're right :)
Thanks.

Done.

+{
+    unsigned modifierFlags = 0;
+
+    if (event.altKey())
+        modifierFlags |= PlatformEvent::AltKey;
+    if (event.ctrlKey())
+        modifierFlags |= PlatformEvent::CtrlKey;
+    if (event.metaKey())
+        modifierFlags |= PlatformEvent::MetaKey;
+    if (event.shiftKey())
+        modifierFlags |= PlatformEvent::ShiftKey;
+
+    return modifierFlags;
+}
+
 bool EventHandler::handleGestureTap(const GestureEventWithHitTestResults& targetedEvent)
 {
     RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
     HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
 
     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 
-    unsigned modifierFlags = 0;
-    if (gestureEvent.altKey())
-        modifierFlags |= PlatformEvent::AltKey;
-    if (gestureEvent.ctrlKey())
-        modifierFlags |= PlatformEvent::CtrlKey;
-    if (gestureEvent.metaKey())
-        modifierFlags |= PlatformEvent::MetaKey;
-    if (gestureEvent.shiftKey())
-        modifierFlags |= PlatformEvent::ShiftKey;
-    PlatformEvent::Modifiers modifiers = static_cast<PlatformEvent::Modifiers>(modifierFlags);
+    unsigned modifierFlags = modifierFlagsFrom(gestureEvent);
 
     HitTestResult currentHitTest = targetedEvent.hitTestResult();
 
     // We use the adjusted position so the application isn't surprised to see a event with
     // co-ordinates outside the target's bounds.
     IntPoint adjustedPoint = m_frame->view()->windowToContents(gestureEvent.position());
 
     PlatformMouseEvent fakeMouseMove(gestureEvent.position(), gestureEvent.globalPosition(),
         NoButton, PlatformEvent::MouseMoved, /* clickCount */ 0,
-        modifiers, PlatformMouseEvent::FromTouch, gestureEvent.timestamp());
+        platformModifiersFrom(modifierFlags),
+        PlatformMouseEvent::FromTouch, gestureEvent.timestamp());
     dispatchMouseEvent(EventTypeNames::mousemove, currentHitTest.innerNode(), 0, fakeMouseMove, true);
 
     // Do a new hit-test in case the mousemove event changed the DOM.
     // Note that if the original hit test wasn't over an element (eg. was over a scrollbar) we
     // don't want to re-hit-test because it may be in the wrong frame (and there's no way the page
     // could have seen the event anyway).
     // FIXME: Use a hit-test cache to avoid unnecessary hit tests. http://crbug.com/398920
     if (currentHitTest.innerNode())
         currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, hitType);
     m_clickNode = currentHitTest.innerNode();
     if (m_clickNode && m_clickNode->isTextNode())
         m_clickNode = NodeRenderingTraversal::parent(*m_clickNode);
 
     PlatformMouseEvent fakeMouseDown(gestureEvent.position(), gestureEvent.globalPosition(),
         LeftButton, PlatformEvent::MousePressed, gestureEvent.tapCount(),
-        modifiers, PlatformMouseEvent::FromTouch,  gestureEvent.timestamp());
+        platformModifiersFrom(modifierFlags | PlatformEvent::LeftButtonDown),
+        PlatformMouseEvent::FromTouch,  gestureEvent.timestamp());
     bool swallowMouseDownEvent = !dispatchMouseEvent(EventTypeNames::mousedown, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseDown, true);
     if (!swallowMouseDownEvent)
         swallowMouseDownEvent = handleMouseFocus(MouseEventWithHitTestResults(fakeMouseDown, currentHitTest));
     if (!swallowMouseDownEvent) {
         swallowMouseDownEvent = handleMousePressEvent(MouseEventWithHitTestResults(fakeMouseDown, currentHitTest));
         // m_selectionInitiationState is initialized after dispatching mousedown event.
         m_selectionInitiationState = HaveNotStartedSelection;
     }
 
     // FIXME: Use a hit-test cache to avoid unnecessary hit tests. http://crbug.com/398920
     if (currentHitTest.innerNode())
         currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, hitType);
     PlatformMouseEvent fakeMouseUp(gestureEvent.position(), gestureEvent.globalPosition(),
         LeftButton, PlatformEvent::MouseReleased, gestureEvent.tapCount(),
-        modifiers, PlatformMouseEvent::FromTouch,  gestureEvent.timestamp());
+        platformModifiersFrom(modifierFlags),
+        PlatformMouseEvent::FromTouch,  gestureEvent.timestamp());
     bool swallowMouseUpEvent = !dispatchMouseEvent(EventTypeNames::mouseup, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseUp, false);
 
     bool swallowClickEvent = false;
     if (m_clickNode) {
         if (currentHitTest.innerNode()) {
             // Updates distribution because a mouseup (or mousedown) event listener can make the
             // tree dirty at dispatchMouseEvent() invocation above.
             // Unless distribution is updated, commonAncestor would hit ASSERT.
             // Both m_clickNode and currentHitTest.innerNode()) don't need to be updated
             // because commonAncestor() will exit early if their documents are different.
             m_clickNode->document().updateDistributionForNodeIfNeeded(m_clickNode.get());
             Node* clickTargetNode = currentHitTest.innerNode()->commonAncestor(*m_clickNode, parentForClickEvent);
             swallowClickEvent = !dispatchMouseEvent(EventTypeNames::click, clickTargetNode, gestureEvent.tapCount(), fakeMouseUp, true);
         }
         m_clickNode = nullptr;
     }
 
     if (!swallowMouseUpEvent)
         swallowMouseUpEvent = handleMouseReleaseEvent(MouseEventWithHitTestResults(fakeMouseUp, currentHitTest));
 
     return swallowMouseDownEvent | swallowMouseUpEvent | swallowClickEvent;
 }
 
 bool EventHandler::handleGestureLongPress(const GestureEventWithHitTestResults& targetedEvent)
 {
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
     IntPoint adjustedPoint = gestureEvent.position();
 
+    unsigned modifierFlags = modifierFlagsFrom(gestureEvent);
+
     // FIXME: Ideally we should try to remove the extra mouse-specific hit-tests here (re-using the
     // supplied HitTestResult), but that will require some overhaul of the touch drag-and-drop code
     // and LongPress is such a special scenario that it's unlikely to matter much in practice.
 
     m_longTapShouldInvokeContextMenu = false;
     if (m_frame->settings() && m_frame->settings()->touchDragDropEnabled() && m_frame->view()) {
         PlatformMouseEvent mouseDownEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MousePressed, 1,
-            gestureEvent.shiftKey(), gestureEvent.ctrlKey(), gestureEvent.altKey(), gestureEvent.metaKey(), PlatformMouseEvent::FromTouch, WTF::currentTime());
+            platformModifiersFrom(modifierFlags | PlatformEvent::LeftButtonDown),
+            PlatformMouseEvent::FromTouch, WTF::currentTime());
         m_mouseDown = mouseDownEvent;
 
         PlatformMouseEvent mouseDragEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MouseMoved, 1,
-            gestureEvent.shiftKey(), gestureEvent.ctrlKey(), gestureEvent.altKey(), gestureEvent.metaKey(), PlatformMouseEvent::FromTouch, WTF::currentTime());
+            platformModifiersFrom(modifierFlags | PlatformEvent::LeftButtonDown),
+            PlatformMouseEvent::FromTouch, WTF::currentTime());
         HitTestRequest request(HitTestRequest::ReadOnly);
         MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseDragEvent);
         m_mouseDownMayStartDrag = true;
         dragState().m_dragSrc = nullptr;
         m_mouseDownPos = m_frame->view()->windowToContents(mouseDragEvent.position());
         RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
         if (handleDrag(mev, DragInitiator::Touch)) {
             m_longTapShouldInvokeContextMenu = true;
             return true;
         }
@@ skipping 488 matching lines @@
 
     handleMousePressEvent(mouseEvent);
     return sendContextMenuEvent(mouseEvent);
 }
 
 bool EventHandler::sendContextMenuEventForGesture(const GestureEventWithHitTestResults& targetedEvent)
 {
 #if OS(WIN)
     PlatformEvent::Type eventType = PlatformEvent::MouseReleased;
 #else
     PlatformEvent::Type eventType = PlatformEvent::MousePressed;

[Rick Byers, 2014/11/28 17:36:02]

Looks like I was wrong and this OS behavior difference will effect your CL for
the gesture long tap case only.  You need to add RightButtonDown to the
modifiers for the MousePressed (non-windows) case.

Sadly I guess this means you'll need a platform-specific expectations file for
windows (and need to detect windows from your layout test to change your
expected button for this case).  Really the right fix here is to add a
WebPreference for 'show contextmenu on mouseup' which chrome sets to true only
on Windows (then we could test both in the same layout tests on all platforms). 
This might be a nice follow-up CL if you're interested.  If you want to do this,
then feel free to disable the test on Windows for now against that bug (or
better - just land an expectation that has a FAIL in it), rather than trying to
detect Windows and making it pass cleanly...

[zino, 2014/12/03 15:47:15]

Thank you for your guide.
As you know, these works are in review.

 #endif
 
-    PlatformMouseEvent mouseEvent(targetedEvent.event().position(), targetedEvent.event().globalPosition(), RightButton, eventType, 1, false, false, false, false, PlatformMouseEvent::FromTouch, WTF::currentTime());
+    PlatformMouseEvent mouseEvent(targetedEvent.event().position(), targetedEvent.event().globalPosition(), RightButton, eventType, 1,
+        platformModifiersFrom(modifierFlagsFrom(targetedEvent.event())),
+        PlatformMouseEvent::FromTouch, WTF::currentTime());
     // To simulate right-click behavior, we send a right mouse down and then
     // context menu event.
     // FIXME: Send HitTestResults to avoid redundant hit tests.
     handleMousePressEvent(mouseEvent);
     return sendContextMenuEvent(mouseEvent);
     // We do not need to send a corresponding mouse release because in case of
     // right-click, the context menu takes capture and consumes all events.
 }
 
 void EventHandler::scheduleHoverStateUpdate()
@@ skipping 1015 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink