tree 0249f6b8005e3c47a67ed485fdcb62ddbce015dd
parent 39c6266b531e523cdfb83f8b5e81f3e3d9140978
author Mike Klein <mtklein@google.com> 1593784901 +0000
committer Mike Klein <mtklein@google.com> 1593787313 +0000

Revert "Use Wuffs v0.3 by default, not v0.2"

This reverts commit 7a3ea55259873508171a0e488930d383530d5d41.

Reason for revert: linker failures rolling to Flutter, e.g

[5594/5828] LINK ./flow_unittests
FAILED: flow_unittests exe.unstripped/flow_unittests 
/b/s/w/ir/cache/goma/client/gomacc ../../buildtools/linux-x64/clang/bin/clang++ -Wl,--fatal-warnings -m64 -fPIC -Wl,-z,noexecstack -Wl,-z,now -Wl,-z,relro -Wl,-z,defs -pthread --sysroot=/b/s/w/ir/cache/builder/src/build/linux/debian_sid_amd64-sysroot -L/b/s/w/ir/cache/builder/src/build/linux/debian_sid_amd64-sysroot/usr/local/lib/x86_64-linux-gnu\ -Wl,-rpath-link=/b/s/w/ir/cache/builder/src/build/linux/debian_sid_amd64-sysroot/usr/local/lib/x86_64-linux-gnu\ -L/b/s/w/ir/cache/builder/src/build/linux/debian_sid_amd64-sysroot/lib/x86_64-linux-gnu\ -Wl,-rpath-link=/b/s/w/ir/cache/builder/src/build/linux/debian_sid_amd64-sysroot/lib/x86_64-linux-gnu\ -L/b/s/w/ir/cache/builder/src/build/linux/debian_sid_amd64-sysroot/usr/lib/x86_64-linux-gnu\ -Wl,-rpath-link=/b/s/w/ir/cache/builder/src/build/linux/debian_sid_amd64-sysroot/usr/lib/x86_64-linux-gnu -Wl,-rpath=\$ORIGIN/ -Wl,-rpath-link= -Wl,--disable-new-dtags  -o ./exe.unstripped/flow_unittests -Wl,--build-id=sha1 -Wl,--start-group @./flow_unittests.rsp  -Wl,--end-group  -ldl -lpthread  && strip --strip-unneeded -o ./flow_unittests ./exe.unstripped/flow_unittests
ld.lld: error: undefined symbol: wuffs_base__note__end_of_data
>>> referenced by SkWuffsCodec.cpp:0 (../../third_party/skia/src/codec/SkWuffsCodec.cpp:0)
>>>               obj/third_party/skia/src/codec/wuffs.SkWuffsCodec.o:(SkWuffsCodec::onGetFrameCountInternal())
clang-11: error: linker command failed with exit code 1 (use -v to see invocation)

https://github.com/flutter/engine/pull/19466
https://ci.chromium.org/p/flutter/builders/try/Linux%20Host%20Engine/9900? (among several)

Original change's description:
> Use Wuffs v0.3 by default, not v0.2
> 
> Change-Id: Ie57fea197778f4b17ca08d2e3022b77f783de927
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/298616
> Reviewed-by: Leon Scroggins <scroggo@google.com>
> Commit-Queue: Mike Klein <mtklein@google.com>

TBR=mtklein@google.com,scroggo@google.com,nigeltao@google.com

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

Change-Id: Ie21293deade92e064099ebd5d41de69dbf8b2545
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/300413
Reviewed-by: Mike Klein <mtklein@google.com>
Commit-Queue: Mike Klein <mtklein@google.com>
