Implement canvas focus ring methods.

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 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 16 matching lines @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * 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 "core/accessibility/AXObjectCache.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/CSSParser.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExceptionCodePlaceholder.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/Canvas2DContextAttributes.h"
 #include "core/html/canvas/CanvasGradient.h"
 #include "core/html/canvas/CanvasPattern.h"
 #include "core/html/canvas/CanvasStyle.h"
 #include "core/html/canvas/DOMPath.h"
 #include "core/loader/cache/CachedImage.h"
 #include "core/page/ImageBitmap.h"
 #include "core/platform/graphics/DrawLooper.h"
 #include "core/platform/graphics/FloatQuad.h"
 #include "core/platform/graphics/FontCache.h"
 #include "core/platform/graphics/GraphicsContextStateSaver.h"
 #include "core/platform/graphics/TextRun.h"
 #include "core/platform/graphics/transforms/AffineTransform.h"
 #include "core/rendering/RenderLayer.h"
+#include "core/rendering/RenderTheme.h"
 #include "weborigin/SecurityOrigin.h"
 
 #include "wtf/CheckedArithmetic.h"
 #include "wtf/MathExtras.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/Uint8ClampedArray.h"
 #include "wtf/text/StringBuilder.h"
 
 using namespace std;
 
@@ skipping 2257 matching lines @@
         c->setImageInterpolationQuality(enabled ? DefaultInterpolationQuality : InterpolationNone);
 }
 
 PassRefPtr<Canvas2DContextAttributes> CanvasRenderingContext2D::getContextAttributes() const
 {
     RefPtr<Canvas2DContextAttributes> attributes = Canvas2DContextAttributes::create();
     attributes->setAlpha(m_hasAlpha);
     return attributes.release();
 }
 
+void CanvasRenderingContext2D::drawSystemFocusRing(Element* element)
+{
+    drawFocusRing(m_path, element, false);
+}
+
+bool CanvasRenderingContext2D::drawCustomFocusRing(Element* element)
+{
+    drawFocusRing(m_path, element, true);
+    // Blink doesn't draw a custom focus ring; we always return false to inform the web app it should draw it.
+    return false;
+}
+
+void CanvasRenderingContext2D::drawFocusRing(const Path& path, Element* element, bool custom)
+{
+    GraphicsContext* c = drawingContext();
+    if (!c)
+        return;
+    if (!state().m_invertibleCTM)
+        return;
+    if (path.isEmpty())
+        return;
+    FloatRect boundingRect = path.boundingRect();
+
+    // If accessibility is enabled, associate this bounding box with the element.
+    if (AXObjectCache* axObjectCache = element->document()->existingAXObjectCache()) {
+        if (AccessibilityObject* obj = axObjectCache->getOrCreate(element)) {
+            IntRect canvasRect = canvas()->renderer()->absoluteBoundingBoxRect();
+            LayoutRect rect = LayoutRect(boundingRect);
+            rect.moveBy(canvasRect.location());
+            obj->setElementRect(rect);
+        }
+    }
+
+    // Only draw if the element is focused and if the function called wasn't drawCustomFocusRing.
+    if (custom || !element->focused())
+        return;
+
+    c->save();
+    c->setAlpha(1.0);
+    c->clearShadow();
+    c->setCompositeOperation(CompositeSourceOver, BlendModeNormal);
+
+    RefPtr<RenderStyle> style(RenderStyle::createDefaultStyle());
+    Color focusRingColor = RenderTheme::focusRingColor();
+    Vector<IntRect> rects;
+    rects.append(pixelSnappedIntRect(LayoutRect(boundingRect)));
+    c->drawFocusRing(rects, style->outlineWidth(), style->outlineOffset(), focusRingColor);

[jbroman, 2013/07/29 17:25:08]

Why not draw the path itself? GraphicsContext::drawFocusRing can take a path,
and the spec seems to suggest that is the correct behaviour.

If you'd like to close the path, there's Path::closeSubpath which should do the
trick (though it may make sense to leave that up to the content author). That's
how paths are closed in CanvasPathMethods::closePath, for instance.

[Rik, 2013/07/29 20:10:00]

I'm unsure this is true. The spec is confusing here by mentioning "around the
path" and "along the path"

[dmazzoni, 2013/07/29 21:44:21]

It's unclear to me too.

Since this is behind a flag, I don't really care too much, I
just want to throw it in front of a few web developers and see
if they find it confusing or not.

I currently changed it to just draw the path without closing it.
Let's see how that goes.

+
+    c->restore();
+    didDraw(boundingRect);
+}
+
 } // namespace WebCore