Implement CRC2D.scrollPathIntoView() on Canvas

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 1091 matching lines @@
 
     StrokeData strokeData;
     strokeData.setThickness(lineWidth());
     strokeData.setLineCap(getLineCap());
     strokeData.setLineJoin(getLineJoin());
     strokeData.setMiterLimit(miterLimit());
     strokeData.setLineDash(getLineDash(), lineDashOffset());
     return path.strokeContains(transformedPoint, strokeData);
 }
 
+void CanvasRenderingContext2D::scrollPathIntoView()
+{
+    scrollPathIntoViewInternal(m_path);

[Rik, 2014/03/20 16:22:19]

Does this take the current CTM into account?
I believe m_path is in user coordinate space.

+}
+
+void CanvasRenderingContext2D::scrollPathIntoView(Path2D* path2d, ExceptionState& exceptionState)
+{
+    if (!path2d) {
+        exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "Path2D"));
+        return;
+    }
+
+    scrollPathIntoViewInternal(path2d->path());
+}
+
+void CanvasRenderingContext2D::scrollPathIntoViewInternal(const Path& path)
+{
+    if (!state().m_invertibleCTM || !canvas() || path.isEmpty())

[Rik, 2014/03/20 16:22:19]

scrollPathIntoView() should take ctm into account.
According to the spec, scrollPathIntoView(Path path) should not. (This feels
like a spec bug)

Even though you check, it does look like you're using the CTM.

[Justin Novosad, 2014/03/20 20:03:12]

I agree, all the other methods on CanvasRenderingContext2D that take a path
object use the CTM. ctx.fill(myPath) followed by ctx.scrollPathIntoView(myPath)
should line-up.

Also, no need to check !canvas(). CRC2D holds a counted reference on the canvas
element that it was created from, so the canvas will always continue to exist as
long as the CRC2D is alive, even if the canvas element was removed from the
document and the JS heap.

+        return;
+
+    canvas()->document().updateLayoutIgnorePendingStylesheets();
+
+    LayoutRect pathRect;
+    absoluteBoundingPathRect(path, pathRect);
+
+    if (canvas()->renderer()) {
+        canvas()->renderer()->scrollRectToVisible(
+            pathRect, ScrollAlignment::alignCenterAlways, ScrollAlignment::alignTopAlways);
+    }
+
+    // TODO: should implement "inform the user" that the caret and/or
+    // selection the specified rectangle of the canvas.
+}
+
 void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height)
 {
     if (!validateRectForCanvas(x, y, width, height))
         return;
     GraphicsContext* context = drawingContext();
     if (!context)
         return;
     if (!state().m_invertibleCTM)
         return;
     FloatRect rect(x, y, width, height);
@@ skipping 1018 matching lines @@
     static const float root2 = sqrtf(2);
     float delta = state().m_lineWidth / 2;
     if (state().m_lineJoin == MiterJoin)
         delta *= state().m_miterLimit;
     else if (state().m_lineCap == SquareCap)
         delta *= root2;
 
     rect.inflate(delta);
 }
 
+void CanvasRenderingContext2D::absoluteBoundingPathRect(const Path& path, LayoutRect& rect) const
+{
+    // Get the bounding rect and apply transformations.
+    FloatRect bounds = path.boundingRect();
+    AffineTransform ctm = state().m_transform;
+    FloatRect transformedBounds = ctm.mapRect(bounds);
+    rect = LayoutRect(transformedBounds);

[Justin Novosad, 2014/03/20 20:03:12]

This works if the transform has only translation and scale.  If there is
rotation, you need to transform the path first and then take the bounds of the
transformed path, which is not equivalent in that case.

+
+    // Offset by the canvas rect (We should take border and padding into account).
+    IntRect canvasRect = canvas()->renderer()->absoluteBoundingBoxRect();
+    RenderBoxModelObject* rbmo = canvas()->renderBoxModelObject();
+    canvasRect.move(rbmo->borderLeft() + rbmo->paddingLeft(),
+        rbmo->borderTop() + rbmo->paddingTop());
+    rect.moveBy(canvasRect.location());
+}
+
 const Font& CanvasRenderingContext2D::accessFont()
 {
     // This needs style to be up to date, but can't assert so because drawTextInternal
     // can invalidate style before this is called (e.g. drawingContext invalidates style).
     if (!state().m_realizedFont)
         setFont(state().m_unparsedFont);
     return state().m_font;
 }
 
 int CanvasRenderingContext2D::getFontBaseline(const FontMetrics& fontMetrics) const
@@ skipping 88 matching lines @@
 {
     if (!canvas()->renderer())
         return;
 
     // If accessibility is already enabled in this frame, associate this path's
     // bounding box with the accessible object. Do this even if the element
     // isn't focused because assistive technology might try to explore the object's
     // location before it gets focus.
     if (AXObjectCache* axObjectCache = element->document().existingAXObjectCache()) {
         if (AXObject* obj = axObjectCache->getOrCreate(element)) {
-            // Get the bounding rect and apply transformations.
-            FloatRect bounds = m_path.boundingRect();
-            AffineTransform ctm = state().m_transform;
-            FloatRect transformedBounds = ctm.mapRect(bounds);
-            LayoutRect elementRect = LayoutRect(transformedBounds);
-
-            // Offset by the canvas rect and set the bounds of the accessible element.
-            IntRect canvasRect = canvas()->renderer()->absoluteBoundingBoxRect();
-            elementRect.moveBy(canvasRect.location());
+            // set the bounds of the accessible element.
+            LayoutRect elementRect;
+            absoluteBoundingPathRect(path, elementRect);
             obj->setElementRect(elementRect);
 
             // Set the bounds of any ancestor accessible elements, up to the canvas element,
             // otherwise this element will appear to not be within its parent element.
             obj = obj->parentObject();
             while (obj && obj->node() != canvas()) {
                 obj->setElementRect(elementRect);
                 obj = obj->parentObject();
             }
         }
@@ skipping 20 matching lines @@
     const int focusRingWidth = 5;
     const int focusRingOutline = 0;
     c->drawFocusRing(path, focusRingWidth, focusRingOutline, focusRingColor);
 
     c->restore();
 
     didDraw(dirtyRect);
 }
 
 } // namespace WebCore