tree 27cbabe180fc0741d20501c1e8e43e788700bca2
parent 57b9d4071ba5ba03c9991fb351e6f66fbf75d268
author Mike Klein <mtklein@google.com> 1538493059 -0400
committer Skia Commit-Bot <skia-commit-bot@chromium.org> 1538506225 +0000

Reland "clamp gamut if needed in SkConvertPixels"

This is a reland of b8fef7c9869816c93a9e4fe9547d8ce4b82f2166

readpixels is now disabled on serialize-8888.
The image encoding means it doesn't quite round trip,
though the image looks fine to the eye.

Original change's description:
> clamp gamut if needed in SkConvertPixels
>
> We need to clamp here for all the same reasons we need to clamp when
> blitting.  I've centralized the clamp's implementation to help that.
>
> I've allowed any --config to run this GM.  --config 565 was actually
> pointing out this problem by asserting, and now looks fine.
>
> Change-Id: Icc066792fc53747b161302d200abdd8dc4669f7f
> Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel
> Reviewed-on: https://skia-review.googlesource.com/158721
> Reviewed-by: Brian Osman <brianosman@google.com>
> Commit-Queue: Mike Klein <mtklein@google.com>

Change-Id: I07601149e1d1e070bf96361f5303569b6a7b4e2a
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel
Reviewed-on: https://skia-review.googlesource.com/c/159001
Reviewed-by: Mike Klein <mtklein@google.com>
Commit-Queue: Mike Klein <mtklein@google.com>
