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 "bindings/v8/ExceptionMessages.h"
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "core/CSSPropertyNames.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 108 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 1095 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);
+
+    if (context->isClipMode()) {
+        FloatRect specifiedBounds = specifiedPath.boundingRect();
+
+        if (!specifiedBounds.intersects(clipBounds)
+            || !specifiedPath.intersectPath(context->getCurrentClipPath())

[f(malita), 2014/06/17 17:27:26]

I'm not sure getCurrentClipPath() is really needed. How about something like
this:

bool pathIsFullyClipped(SkCanvas* canvas, const SkPath& path)
{
    if (canvas->quickReject(path))
        return true;

    // Only needed if quickReject is too conservative
    canvas->save();
    canvas->clipPath(path);
    bool isClipped = canvas->isClipEmpty();
    canvas->restore();

    return isClipped;
}

[zino, 2014/06/17 23:46:10]

The method sets the intersection path between two path to lvalue(specifiedPath).
(Note: the method doesn't return whether or not to intersect)

As a result, if specifiedPath is not empty (clipPath is not empty),
we should pass it and should save it to HitRegion class.
Also, the path region will be used continuously while hit region exists.

[Rik, 2014/06/17 23:58:58]

Why are you looking at the clipping path? Hit regions are not affected by
clipping.

+            || specifiedPath.isEmpty()) {
+            exceptionState.throwDOMException(NotSupportedError, "The specified path has no pixels.");
+            return;
+        }
+    }
+
+    passOptions.path = specifiedPath;
+    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