Implement CRC2D.scrollPathIntoView() on Canvas

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 1b703c02d21e33e3f5823e906fd79d95c83a5fa9..eb9f97969a360791879c2337a310e3d9e05d36ab 100644
--- a/Source/core/html/canvas/CanvasRenderingContext2D.cpp
+++ b/Source/core/html/canvas/CanvasRenderingContext2D.cpp
@@ -1109,6 +1109,40 @@ bool CanvasRenderingContext2D::isPointInStrokeInternal(const Path& path, const f
     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))
@@ -2147,6 +2181,22 @@ void CanvasRenderingContext2D::inflateStrokeRect(FloatRect& rect) const
     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
@@ -2255,15 +2305,9 @@ void CanvasRenderingContext2D::updateFocusRingAccessibility(const Path& path, El
     // 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,