tree df4ce9fc58a8189b382dcc13e469bfd081425c01
parent f61ec43f84dd73508a566c36ef085156b40285f0
author John Stiles <johnstiles@google.com> 1629292907 +0000
committer SkCQ <skcq-be@skia-corp.google.com.iam.gserviceaccount.com> 1629292917 +0000

Revert "Use generation() to detect ES3 support."

This reverts commit fdde20d3ec773fcf347086201406a5b8cb7271b8.

Reason for revert: generation() can promise things that it can't deliver

Original change's description:
> Use generation() to detect ES3 support.
>
> Desktop GLSL 1.30 supports the things we currently consider as "ES3
> only"--nonsquare matrices, derivatives, and unsigned integers.
>
> Change-Id: I4b5a844cf3aabee6b6d2c562e78859a29efc36fc
> Bug: skia:12347
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/439937
> Commit-Queue: John Stiles <johnstiles@google.com>
> Auto-Submit: John Stiles <johnstiles@google.com>
> Reviewed-by: Brian Osman <brianosman@google.com>

TBR=brianosman@google.com,johnstiles@google.com,skcq-be@skia-corp.google.com.iam.gserviceaccount.com

Change-Id: I118e08da078090f404a4fdf33c3a16a48c702753
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:12347
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/440457
Reviewed-by: John Stiles <johnstiles@google.com>
Commit-Queue: John Stiles <johnstiles@google.com>
