Canvas2d: Implement rerouting event by hit region's control.

third_party/WebKit/Source/modules/canvas2d/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 24 matching lines @@
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/CSSPropertyNames.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/parser/CSSParser.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/StyleEngine.h"
 #include "core/events/Event.h"
+#include "core/events/MouseEvent.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/html/TextMetrics.h"
 #include "core/html/canvas/CanvasFontCache.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutTheme.h"
 #include "modules/canvas2d/CanvasGradient.h"
 #include "modules/canvas2d/CanvasPattern.h"
@@ skipping 1734 matching lines @@
     }
 }
 
 void CanvasRenderingContext2D::styleDidChange(const ComputedStyle* oldStyle, const ComputedStyle& newStyle)
 {
     if (oldStyle && oldStyle->font() == newStyle.font())
         return;
     pruneLocalFontCache(0);
 }
 
+std::pair<Element*, String> CanvasRenderingContext2D::getControlAndIDIfHitRegionExists(const LayoutPoint& location)
+{
+    Document& document = canvas()->document();
+    document.updateLayoutTreeForNodeIfNeeded(canvas());

[Justin Novosad, 2016/02/05 15:22:53]

Updating layout... Is this the right thing to do?  My concerns are that the
updated layout is less likely to represent the layout that was presented on
screen when mouse or touch event was registered.  I am also concerned about how
this might affect performance because it may trigger multiple layout passes per
animation frame. On the other hand, I think updating the layout maybe the
desired behavior when dealing with synthetic events. For example if a we have
some JS code that makes DOM or style changes before dispatching a synthetic
mouse event, one would probably expect the event to take the DOM changes into
account.

@philipj, rbyers: What do you think?

[Rick Byers, 2016/02/05 16:01:20]

I agree we absolutely don't want to force any extra layouts - that could be
disasterous for performance.  We're working to try to align input with the
document lifecycle to make input-event-induced layouts more predictable (ideally
unnecessary) also.

I haven't looked over the entire CL in detail yet, but I _think_ this code
should only need to be called when creating a real mouse or touch event, just
after that does a hit test (which also requires layout to be up-to-date).

We could try to assert that layout isn't dirty, but I think a better approach is
to update the signature to make it clear we're not really going to re-do any
sort of hit-test here.  In particular, instead of taking a LayoutPoint, we could
take a HitTestResult (and then use it's m_localPoint for getting the region).

Doing that would require a bit more plumbing, but it looks easy in the
TouchEvent case.  The MouseEvent case looks pretty hacky right now (plugging
into event dispatch), which would make taking a HitTestResult harder.  Ideally
that should be reworked to be similar to the TouchEvent case.  That is, hooked
in at the point of event generation in EventHandler, not trying to modify the
event at dispatch time.  If we can do that, then again taking a HitTestResult
should be easy.

Then the case for JS dispatching a synthetic result is very analogous.  Either
the JS code already has some context from which to get the 'target', 'region'
etc. for the event constructor, or it does it's own hit-test
(document.elementFromPoint) and computes all the event constructor arguments
based on that.

[zino, 2016/02/12 15:26:19]

Probably done.

[Justin Novosad, 2016/02/12 15:41:59]

I think this is correct (layout "IfNeeded"). But I would like to hear from other
reviewers before committing.

+
+    LayoutBox* box = canvas()->layoutBox();
+    FloatPoint localPos = box->absoluteToLocal(FloatPoint(location), UseTransforms);
+    if (box->hasBorderOrPadding())
+        localPos.move(-box->contentBoxOffset());
+    localPos.scale(canvas()->width() / box->contentWidth(), canvas()->height() / box->contentHeight());
+
+    HitRegion* hitRegion = hitRegionAtPoint(localPos);
+    if (hitRegion)
+        return std::make_pair(hitRegion->control(), hitRegion->id());
+    return std::make_pair(nullptr, String());
+}
+
 String CanvasRenderingContext2D::textAlign() const
 {
     return textAlignName(state().textAlign());
 }
 
 void CanvasRenderingContext2D::setTextAlign(const String& s)
 {
     TextAlign align;
     if (!parseTextAlign(s, align))
         return;
@@ skipping 517 matching lines @@
         if (imageType == CanvasRenderingContext2DState::NonOpaqueImage)
             return;
         if (alpha < 0xFF)
             return;
     }
 
     canvas()->buffer()->willOverwriteCanvas();
 }
 
 } // namespace blink