tree aef5f6f60ce7d6ad9a87a75abf087f77bd1285a8
parent d282df432c9fd8ce1f8d94efd44c541129283701
author Mike Reed <reed@google.com> 1581516462 +0000
committer Skia Commit-Bot <skia-commit-bot@chromium.org> 1581516483 +0000

Revert "Ensure arcTo (SVG) ends at the targeted point"

This reverts commit 31143100ee2a5e95a552b3d9ed559b068c8df76b.

Reason for revert: need to guard this, to stage changes to test images

Original change's description:
> Ensure arcTo (SVG) ends at the targeted point
> 
> Floating-point errors in the calculations in arcTo can cause the final
> point to differ significantly enough from the supplied target point that
> a subsequent 'close' operation inserts a lineTo to close the curve. This
> can result in bad miters on curves with thick outlines.
> 
> The fix is to ensure that the final point used is *exactly* the point
> that was supplied.
> 
> Bug: chromium:1001768
> Change-Id: I75c740ab25fb05153bc852a204be957977674cd2
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/270000
> Reviewed-by: Mike Reed <reed@google.com>
> Commit-Queue: Mike Reed <reed@google.com>

TBR=reed@google.com,iapres@microsoft.com

Change-Id: If331924a4db83294769b28501bba875238a521bd
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: chromium:1001768
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/270356
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>
