WIP: <canvas> hit regions

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 34 matching lines @@
 #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"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/html/TextMetrics.h"
 #include "core/html/canvas/CanvasGradient.h"
+#include "core/html/canvas/CanvasHitRegion.h"
 #include "core/html/canvas/CanvasPattern.h"
 #include "core/html/canvas/CanvasStyle.h"
 #include "core/html/canvas/Path2D.h"
 #include "core/rendering/RenderImage.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderTheme.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/graphics/DrawLooperBuilder.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
@@ skipping 14 matching lines @@
 static const double TryRestoreContextInterval = 0.5;
 static const unsigned MaxTryRestoreContextAttempts = 4;
 
 static bool contextLostRestoredEventsEnabled()
 {
     return RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
 }
 
 CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement* canvas, const Canvas2DContextAttributes* attrs, bool usesCSSCompatibilityParseMode)
     : CanvasRenderingContext(canvas)
+    , m_hitRegionManager(CanvasHitRegionManager::create())
     , m_usesCSSCompatibilityParseMode(usesCSSCompatibilityParseMode)
     , m_hasAlpha(!attrs || attrs->alpha())
     , m_isContextLost(false)
     , m_contextRestorable(true)
     , m_storageMode(!attrs ? PersistentStorage : attrs->parsedStorage())
     , m_tryRestoreContextAttemptCount(0)
     , m_dispatchContextLostEventTimer(this, &CanvasRenderingContext2D::dispatchContextLostEvent)
     , m_dispatchContextRestoredEventTimer(this, &CanvasRenderingContext2D::dispatchContextRestoredEvent)
     , m_tryRestoreContextEventTimer(this, &CanvasRenderingContext2D::tryRestoreContextEvent)
 {
@@ skipping 60 matching lines @@
             reset();
             m_isContextLost = false;
         }
     }
 }
 
 void CanvasRenderingContext2D::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_stateStack);
+    visitor->trace(m_hitRegionManager);
     visitor->trace(m_fetchedFonts);
 #endif
     CanvasRenderingContext::trace(visitor);
 }
 
 void CanvasRenderingContext2D::dispatchContextLostEvent(Timer<CanvasRenderingContext2D>*)
 {
     if (contextLostRestoredEventsEnabled()) {
         RefPtrWillBeRawPtr<Event> event = Event::createCancelable(EventTypeNames::contextlost);
         canvas()->dispatchEvent(event);
@@ skipping 44 matching lines @@
         canvas()->dispatchEvent(event);
     }
 }
 
 void CanvasRenderingContext2D::reset()
 {
     unwindStateStack();
     m_stateStack.resize(1);
     m_stateStack.first() = adoptPtrWillBeNoop(new State());
     m_path.clear();
+    m_hitRegionManager->clear();
 }
 
 // Important: Several of these properties are also stored in GraphicsContext's
 // StrokeData. The default values that StrokeData uses may not the same values
 // that the canvas 2d spec specifies. Make sure to sync the initial state of the
 // GraphicsContext in HTMLCanvasElement::createImageBuffer()!
 CanvasRenderingContext2D::State::State()
     : m_unrealizedSaveCount(0)
     , m_strokeStyle(CanvasStyle::createFromRGBA(Color::black))
     , m_fillStyle(CanvasStyle::createFromRGBA(Color::black))
@@ skipping 966 matching lines @@
     if (!context)
         return;
     if (!state().m_invertibleCTM)
         return;
     FloatRect rect(x, y, width, height);
 
     FloatRect dirtyRect;
     if (!computeDirtyRect(rect, &dirtyRect))
         return;
 
+    m_hitRegionManager->removeEnclosed(rect, state().m_transform);
+
     bool saved = false;
     if (shouldDrawShadows()) {
         context->save();
         saved = true;
         context->clearShadow();
     }
     if (state().m_globalAlpha != 1) {
         if (!saved) {
             context->save();
             saved = true;
@@ skipping 1030 matching lines @@
         c->setImageInterpolationQuality(enabled ? CanvasDefaultInterpolationQuality : InterpolationNone);
 }
 
 PassRefPtr<Canvas2DContextAttributes> CanvasRenderingContext2D::getContextAttributes() const
 {
     RefPtr<Canvas2DContextAttributes> attributes = Canvas2DContextAttributes::create();
     attributes->setAlpha(m_hasAlpha);
     return attributes.release();
 }
 
+void CanvasRenderingContext2D::addHitRegion(ExceptionState& exceptionState)
+{
+    DecodedHitRegionOptions decodedOptions;
+    decodedOptions.resolvePath(m_path, state().m_transform);
+    // parentId / id will be null here, so no need to resolve them.
+
+    addHitRegionInternal(decodedOptions, exceptionState);
+}
+
+void CanvasRenderingContext2D::addHitRegion(const Dictionary& options, ExceptionState& exceptionState)
+{
+    DecodedHitRegionOptions decodedOptions(options);
+    decodedOptions.resolvePath(m_path, state().m_transform);
+    decodedOptions.resolveIds(m_hitRegionManager.get());
+
+    addHitRegionInternal(decodedOptions, exceptionState);
+}
+
+void CanvasRenderingContext2D::removeHitRegion(const String& id)
+{
+    if (CanvasHitRegion* hitRegion = m_hitRegionManager->getHitRegionById(id))
+        m_hitRegionManager->remove(hitRegion);
+}
+
+CanvasHitRegion* CanvasRenderingContext2D::hitRegionAtPoint(const LayoutPoint& point)
+{
+    return m_hitRegionManager->getHitRegionAtPoint(point);
+}
+
+void CanvasRenderingContext2D::addHitRegionInternal(const DecodedHitRegionOptions& options, ExceptionState& exceptionState)
+{
+    if (!options.validate(exceptionState))
+        return;
+
+    RefPtrWillBeRawPtr<CanvasHitRegion> hitRegion = CanvasHitRegion::create(options);
+    m_hitRegionManager->remove(options.previousHitRegion.get());
+    m_hitRegionManager->add(hitRegion.release());
+}
+
 void CanvasRenderingContext2D::drawFocusIfNeeded(Element* element)
 {
     drawFocusIfNeededInternal(m_path, element);
 }
 
 void CanvasRenderingContext2D::drawFocusIfNeeded(Path2D* path2d, Element* element)
 {
     drawFocusIfNeededInternal(path2d->path(), element);
 }
 
@@ skipping 91 matching lines @@
     c->setAlphaAsFloat(1.0);
     c->clearShadow();
     c->setCompositeOperation(CompositeSourceOver, blink::WebBlendModeNormal);
     c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
     c->restore();
 
     didDraw(dirtyRect);
 }
 
 } // namespace WebCore