Implement basic parts of hit regions on canvas2d.

Source/core/html/canvas/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 19 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/html/canvas/CanvasRenderingContext2D.h"
 
 #include "CSSPropertyNames.h"
 #include "bindings/v8/ExceptionMessages.h"
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/ExceptionStatePlaceholder.h"
-#include "core/accessibility/AXObjectCache.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/parser/BisonCSSParser.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/fetch/ImageResource.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLMediaElement.h"
@@ skipping 110 matching lines @@
             m_isContextLost = false;
         }
     }
 }
 
 void CanvasRenderingContext2D::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_stateStack);
     visitor->trace(m_fetchedFonts);
+    visitor->trace(m_hitRegionManager);
 #endif
     CanvasRenderingContext::trace(visitor);
 }
 
 void CanvasRenderingContext2D::dispatchContextLostEvent(Timer<CanvasRenderingContext2D>*)
 {
     if (contextLostRestoredEventsEnabled()) {
         RefPtrWillBeRawPtr<Event> event = Event::createCancelable(EventTypeNames::contextlost);
         canvas()->dispatchEvent(event);
         if (event->defaultPrevented()) {
@@ skipping 1056 matching lines @@
         context->setAlphaAsFloat(1);
     }
     if (state().m_globalComposite != CompositeSourceOver) {
         if (!saved) {
             context->save();
             saved = true;
         }
         context->setCompositeOperation(CompositeSourceOver);
     }
     context->clearRect(rect);
+    if (m_hitRegionManager)
+        m_hitRegionManager->removeHitRegionsInRect(rect, state().m_transform);
     if (saved)
         context->restore();
 
     validateStateStack();
     didDraw(dirtyRect);
 }
 
 void CanvasRenderingContext2D::fillRect(float x, float y, float width, float height)
 {
     if (!validateRectForCanvas(x, y, width, height))
@@ skipping 1092 matching lines @@
     c->save();
     c->setAlphaAsFloat(1.0);
     c->clearShadow();
     c->setCompositeOperation(CompositeSourceOver, blink::WebBlendModeNormal);
     c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
     c->restore();
     validateStateStack();
     didDraw(dirtyRect);
 }
 
+void CanvasRenderingContext2D::addHitRegion(ExceptionState& exceptionState)
+{
+    addHitRegion(Dictionary(), exceptionState);
+}
+
+void CanvasRenderingContext2D::addHitRegion(const Dictionary& options, ExceptionState& exceptionState)
+{
+    HitRegionOptions passOptions;
+
+    options.getWithUndefinedOrNullCheck("id", passOptions.id);
+    options.getWithUndefinedOrNullCheck("control", passOptions.control);
+    if (passOptions.id.isEmpty() && !passOptions.control) {
+        exceptionState.throwDOMException(NotSupportedError, "Both id and control are null.");
+        return;
+    }
+
+    FloatRect clipBounds;
+    GraphicsContext* context = drawingContext();
+
+    if (m_path.isEmpty() || !context || !state().m_invertibleCTM
+        || !context->getTransformedClipBounds(&clipBounds)) {
+        exceptionState.throwDOMException(NotSupportedError, "The specified path has no pixels.");
+        return;
+    }
+
+    Path specifiedPath(m_path);
+    specifiedPath.transform(state().m_transform);
+    specifiedPath.intersectPath(context->getCurrentClipPath());

[fs, 2014/06/10 11:45:15]

The path could be "degenerate" after this operation, so I think that the
bounding-box of the path needs to checked at this step.

[zino, 2014/06/10 15:40:25]

Done.

+
+    passOptions.path = specifiedPath;
+
+    if (passOptions.path.isEmpty())
+        exceptionState.throwDOMException(NotSupportedError, "The specified path has no pixels.");
+    else
+        addHitRegionInternal(passOptions, exceptionState);
+}
+
+void CanvasRenderingContext2D::addHitRegionInternal(const HitRegionOptions& options, ExceptionState& exceptionState)
+{
+    if (!m_hitRegionManager)
+        m_hitRegionManager = HitRegionManager::create();
+
+    // Remove previous region (with id or control)
+    m_hitRegionManager->removeHitRegionById(options.id);
+    m_hitRegionManager->removeHitRegionByControl(options.control.get());
+
+    RefPtrWillBeRawPtr<HitRegion> hitRegion = HitRegion::create(options);
+    hitRegion->updateAccessibility(canvas());
+    m_hitRegionManager->addHitRegion(hitRegion.release());
+}
+
+void CanvasRenderingContext2D::removeHitRegion(const String& id)
+{
+    if (m_hitRegionManager)
+        m_hitRegionManager->removeHitRegionById(id);
+}
+
+void CanvasRenderingContext2D::clearHitRegions()
+{
+    if (m_hitRegionManager)
+        m_hitRegionManager->removeAllHitRegions();
+}
+
+HitRegion* CanvasRenderingContext2D::hitRegionAtPoint(const LayoutPoint& point)
+{
+    if (m_hitRegionManager)
+        return m_hitRegionManager->getHitRegionAtPoint(point);
+
+    return 0;
+}
+
+unsigned CanvasRenderingContext2D::hitRegionsCount() const
+{
+    if (m_hitRegionManager)
+        return m_hitRegionManager->getHitRegionsCount();
+
+    return 0;
+}
+
 } // namespace WebCore