Add basic PointerEvent support in NewEventHandler

sky/engine/core/frame/NewEventHandler.cpp

Index: sky/engine/core/frame/NewEventHandler.cpp
diff --git a/sky/engine/core/frame/NewEventHandler.cpp b/sky/engine/core/frame/NewEventHandler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8195b85884e90a0ee8185b5bfd1fa3cdd0843b2b
--- /dev/null
+++ b/sky/engine/core/frame/NewEventHandler.cpp
@@ -0,0 +1,151 @@
+// Copyright 2015 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 "sky/engine/config.h"
+#include "sky/engine/core/frame/NewEventHandler.h"
+
+#include "sky/engine/core/dom/Document.h"
+#include "sky/engine/core/dom/NodeRenderingTraversal.h"
+#include "sky/engine/core/dom/TouchList.h"
+#include "sky/engine/core/editing/Editor.h"
+#include "sky/engine/core/editing/FrameSelection.h"
+#include "sky/engine/core/editing/htmlediting.h"
+#include "sky/engine/core/events/PointerEvent.h"
+#include "sky/engine/core/frame/LocalFrame.h"
+#include "sky/engine/core/frame/FrameView.h"
+#include "sky/engine/core/page/EventWithHitTestResults.h"
+#include "sky/engine/core/rendering/RenderObject.h"
+#include "sky/engine/core/rendering/RenderView.h"
+#include "sky/engine/platform/geometry/FloatPoint.h"
+#include "sky/engine/public/platform/WebInputEvent.h"
+
+namespace blink {
+
+static VisiblePosition visiblePositionForHitTestResult(const HitTestResult& hitTestResult)
+{
+    Node* innerNode = hitTestResult.innerNode();
+    VisiblePosition position(innerNode->renderer()->positionForPoint(hitTestResult.localPoint()));
+    if (!position.isNull())
+        return position;
+    return VisiblePosition(firstPositionInOrBeforeNode(innerNode), DOWNSTREAM);
+}
+
+static LayoutPoint positionForEvent(const WebPointerEvent& event)
+{
+    return roundedLayoutPoint(FloatPoint(event.x, event.y));
+}
+
+NewEventHandler::NewEventHandler(LocalFrame* frame)
+    : m_frame(frame)
+{
+}
+
+NewEventHandler::~NewEventHandler()
+{
+}
+
+Node* NewEventHandler::targetForHitTestResult(const HitTestResult& hitTestResult)

[esprehn, 2015/01/20 18:14:33]

This can really be far more specific, we can fix it later though. innerNode() is
either Document, Element or Text. I'm not really sure it can be Document either.

[abarth-chromium, 2015/01/20 18:26:54]

You're saying we can change the return type to ContainerNode?

[esprehn, 2015/01/21 02:47:51]

Yes.

+{
+    Node* node = hitTestResult.innerNode();
+    if (!node)
+        return m_frame->document();
+    if (node->isTextNode())
+        return NodeRenderingTraversal::parent(node);
+    return node;
+}
+
+HitTestResult NewEventHandler::performHitTest(const LayoutPoint& point)
+{
+    HitTestResult result(point);
+    if (!m_frame->contentRenderer() || (m_frame->view() && !m_frame->view()->visibleContentRect().contains(roundedIntPoint(point))))

[esprehn, 2015/01/20 18:14:33]

view() and RenderView (contentRenderer) should live and die together, checking
them separately seems weird.

[abarth-chromium, 2015/01/20 18:26:54]

Ok.  I cargo culted this from the old code.  Will change.

[abarth-chromium, 2015/01/20 21:37:55]

Done.

+        return result;
+    m_frame->contentRenderer()->hitTest(HitTestRequest(HitTestRequest::ReadOnly), result);

[esprehn, 2015/01/20 18:14:33]

Why doesn't hitTest() should do the above contains() check for you, callers
shouldn't need to cull.

[abarth-chromium, 2015/01/20 18:26:54]

It looks like it doesn't do this because it's not always the case that your
children are contained within you.  That's a special case for the RenderView. 
We could move this check inside RenderView if you'd like.

[esprehn, 2015/01/21 02:47:51]

RenderView::hitTest is special, it's not a virtual thing. I'd put it in there.
All callers want this optimization. Actually if you look at hitTestInDocument
you'll see it already has copy pasta of this. :(

[abarth-chromium, 2015/01/21 07:03:26]

Ah!  Will do.

+    return result;
+}
+
+bool NewEventHandler::dispatchPointerEvent(Node* target, const WebPointerEvent& event)
+{
+    RefPtr<PointerEvent> pointerEvent = PointerEvent::create(event);
+    // TODO(abarth): Keep track of how many pointers are targeting the same node
+    // and only mark the first one as primary.
+    pointerEvent->setPrimary(true);
+    return target->dispatchEvent(pointerEvent.release());
+}
+
+bool NewEventHandler::dispatchClickEvent(Node* capturingTarget, const WebPointerEvent& event)
+{
+    ASSERT(event.type == WebInputEvent::PointerUp);
+    HitTestResult hitTestResult = performHitTest(positionForEvent(event));
+    Node* releaseTarget = targetForHitTestResult(hitTestResult);
+    Node* clickTarget = NodeRenderingTraversal::commonAncestor(*releaseTarget, *capturingTarget);
+    if (!clickTarget)
+        return true;
+    // TODO(abarth): Make a proper gesture event that includes information from the event.
+    return clickTarget->dispatchEvent(Event::createCancelableBubble(EventTypeNames::click));
+}
+
+void NewEventHandler::updateSelectionForPointerDown(const HitTestResult& hitTestResult, const WebPointerEvent& event)
+{
+    Node* innerNode = hitTestResult.innerNode();
+    if (!innerNode->renderer())
+        return;
+    if (Position::nodeIsUserSelectNone(innerNode))
+        return;
+    if (!innerNode->dispatchEvent(Event::createCancelableBubble(EventTypeNames::selectstart)))
+        return;
+    VisiblePosition position = visiblePositionForHitTestResult(hitTestResult);
+    m_frame->selection().setNonDirectionalSelectionIfNeeded(VisibleSelection(position), CharacterGranularity);
+}
+
+bool NewEventHandler::handlePointerEvent(const WebPointerEvent& event)
+{
+    if (event.type == WebInputEvent::PointerDown)
+        return handlePointerDownEvent(event);
+    if (event.type == WebInputEvent::PointerUp)
+        return handlePointerUpEvent(event);
+    if (event.type == WebInputEvent::PointerMove)

[esprehn, 2015/01/20 18:14:32]

switch() then the compiler will shout if you miss cases.

[abarth-chromium, 2015/01/20 18:26:54]

Here |type| comes from the base class WebInputEvent and contains all the event
types.  I can change this to a switch, but we'd still have a |default| case to
handle KeyPress and such.

[esprehn, 2015/01/21 02:47:51]

There's no default cases in this function though, you have an ASSERT. So your
switch has an ASSERT_NOT_REACHED() for all the types this function can't handle.

[abarth-chromium, 2015/01/21 07:03:26]

I can do that, but if we don't use |default| the switch will have a couple dozen
entries in order to handle four of them.

+        return handlePointerMoveEvent(event);
+    ASSERT(event.type == WebInputEvent::PointerCancel);
+    return handlePointerCancelEvent(event);
+}
+
+bool NewEventHandler::handlePointerDownEvent(const WebPointerEvent& event)
+{
+    ASSERT(!m_targetForPointer.contains(event.pointer));
+    HitTestResult hitTestResult = performHitTest(positionForEvent(event));
+    RefPtr<Node> target = targetForHitTestResult(hitTestResult);
+    m_targetForPointer.set(event.pointer, target);
+    bool eventSwallowed = !dispatchPointerEvent(target.get(), event);
+    // TODO(abarth): Set the target for the pointer to something determined when
+    // dispatching the event.
+    updateSelectionForPointerDown(hitTestResult, event);
+    return eventSwallowed;
+}
+
+bool NewEventHandler::handlePointerUpEvent(const WebPointerEvent& event)
+{
+    RefPtr<Node> target = m_targetForPointer.take(event.pointer);
+    if (!target)
+        return false;
+    bool eventSwallowed = !dispatchPointerEvent(target.get(), event);
+    // When the user releases the primary pointer, we need to dispatch a tap
+    // event to the common ancestor for where the pointer went down and where
+    // it came up.
+    eventSwallowed |= !dispatchClickEvent(target.get(), event);

[esprehn, 2015/01/20 18:14:33]

I find |= really hard to catch when reading the code. Can we instead do:

if (!dispatchClickEvent(target.get(), event))
  eventSwalloed = true;

Also having the booleans switch like this is super weird. handle*() returns true
if the event was swallowed, but the dispatch*() methods return true if the event
_wasn't_ swallowed? That always made the original EventHandler hard to
understand.

[abarth-chromium, 2015/01/20 18:26:54]

Sure!
Yeah, it's super confusing.  Do you want me to switch that around?  It will take
a while to clean out all the inconsistencies...  Another choice is to wait until
we've switched over to NewEventHandler and then remove all the negations
together.

[esprehn, 2015/01/21 02:47:51]

Follow up cl.

+    return eventSwallowed;
+}
+
+bool NewEventHandler::handlePointerMoveEvent(const WebPointerEvent& event)
+{
+    RefPtr<Node> target = m_targetForPointer.get(event.pointer);
+    return target && dispatchPointerEvent(target.get(), event);
+}
+
+bool NewEventHandler::handlePointerCancelEvent(const WebPointerEvent& event)
+{
+    RefPtr<Node> target = m_targetForPointer.take(event.pointer);
+    return target && dispatchPointerEvent(target.get(), event);
+}
+
+}