tree ebe44ab299d34fad010fcbf120e276fdf991fdb9
parent 7391511f7be3049ecc0c164dc07699c91dc9926b
author Chris Dalton <csmartdalton@google.com> 1623268183 -0600
committer Skia Commit-Bot <skia-commit-bot@chromium.org> 1623282989 +0000

Reland "Fix tessellation checks for "usesVaryingCoords""

This is a reland of bd727d0620c4bd85663d6d7c57beb6d40605fb3e

TBR=jvanverth@google.com

Original change's description:
> Fix tessellation checks for "usesVaryingCoords"
>
> We can't use our hardware tessellation back door if any FPs in the
> program have varyings. Before this CL, we were forgetting to check the
> clip FP for strokes, and weren't checking any FPs yet for fills.
>
> Bug: skia:10419
> Change-Id: Ica631ab3cf0407fb359c02c6d53f88f5f301cddc
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/417237
> Reviewed-by: Greg Daniel <egdaniel@google.com>
> Commit-Queue: Chris Dalton <csmartdalton@google.com>

Bug: skia:10419
Change-Id: If8c1e18efc663641b2d565314110f66a6840f8bb
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/417317
Reviewed-by: Chris Dalton <csmartdalton@google.com>
Commit-Queue: Chris Dalton <csmartdalton@google.com>
