tree a2b1752f66095f1caa675648371d78bfbc630439
parent 615b5fd6606a4d2bed2dc13a95ea9f87b497dec4
author Kai Ninomiya <kainino@chromium.org> 1727323950 +0000
committer Dawn LUCI CQ <dawn-scoped@luci-project-accounts.iam.gserviceaccount.com> 1727323950 +0000

Revert "Add a usage parameter to TextureView creation."

This reverts commit 00b941a36b3667490c33f85a66e1217245291f07.

Reason for revert: Breaks existing content; we need to do a staged deprecation. See bug for info.

Original change's description:
> Add a usage parameter to TextureView creation.
>
> This allows views to use a subset of usages from the source texture's
> usages and use formats that may not be compatible with all of the
> source textures usages.
>
> Roll third_party/gpuweb/ 2dc56f297..010f5c9dd (5 commits):
> https://github.com/gpuweb/gpuweb/compare/2dc56f29788a...010f5c9ddfd2
>
> Bug: 363903526
> Change-Id: I4d59907a976063b01a992776a20eeeaf326856ad
> Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/206115
> Commit-Queue: Geoff Lang <geofflang@google.com>
> Reviewed-by: Loko Kung <lokokung@google.com>
> Reviewed-by: Corentin Wallez <cwallez@chromium.org>

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 363903526
Change-Id: I48b04302aa36bf2f58f70c16e17ec02932b94d66
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/208314
Reviewed-by: Loko Kung <lokokung@google.com>
Commit-Queue: Kai Ninomiya <kainino@chromium.org>
