Implement basic parts of hit regions on canvas2d.

Source/core/html/canvas/CanvasRenderingContext2D.cpp

Index: Source/core/html/canvas/CanvasRenderingContext2D.cpp
diff --git a/Source/core/html/canvas/CanvasRenderingContext2D.cpp b/Source/core/html/canvas/CanvasRenderingContext2D.cpp
index ccca4ddd03fc0da373af9092d78ca687cfec0e49..683a2e3a2f22b5a0cd0ed359faa514506a798227 100644
--- a/Source/core/html/canvas/CanvasRenderingContext2D.cpp
+++ b/Source/core/html/canvas/CanvasRenderingContext2D.cpp
@@ -37,7 +37,6 @@
 #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"
@@ -166,6 +165,7 @@ void CanvasRenderingContext2D::trace(Visitor* visitor)
 #if ENABLE(OILPAN)
     visitor->trace(m_stateStack);
     visitor->trace(m_fetchedFonts);
+    visitor->trace(m_hitRegionManager);
 #endif
     CanvasRenderingContext::trace(visitor);
 }
@@ -1242,6 +1242,8 @@ void CanvasRenderingContext2D::clearRect(float x, float y, float width, float he
         context->setCompositeOperation(CompositeSourceOver);
     }
     context->clearRect(rect);
+    if (m_hitRegionManager)
+        m_hitRegionManager->removeHitRegionsInRect(rect, state().m_transform);
     if (saved)
         context->restore();
 
@@ -2357,4 +2359,89 @@ void CanvasRenderingContext2D::drawFocusRing(const Path& path)
     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