Make applyCropRect/pad_image convert to the output color space

src/core/SkImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkImageFilter.h"
 
 #include "SkCanvas.h"
@@ skipping 329 matching lines @@
     // grown the bounds beyond the original clip. This can happen for
     // example in tiling, where the clip is much smaller than the filtered
     // primitive. If we didn't do this, we would be processing the filter
     // at the full crop rect size in every tile.
     return dstBounds->intersect(ctx.clipBounds());
 }
 
 // Return a larger (newWidth x newHeight) copy of 'src' with black padding
 // around it.
 static sk_sp<SkSpecialImage> pad_image(SkSpecialImage* src,
+                                       const SkImageFilter::OutputProperties& outProps,
                                        int newWidth, int newHeight, int offX, int offY) {
-    // We explicitly want to operate in the source's color space here
-    SkImageFilter::OutputProperties outProps(src->getColorSpace());
+    // We would like to operate in the source's color space (so that we return an "identical"
+    // image, other than the padding. To achieve that, we'd create new output properties:
+    //
+    // SkImageFilter::OutputProperties outProps(src->getColorSpace());
+    //
+    // That fails in at least two ways. For formats that are texturable but not renderable (like
+    // F16 on some ES implementations), we can't create a surface to do the work. For sRGB, images
+    // may be tagged with an sRGB color space (which leads to an sRGB config in makeSurface). But
+    // the actual config of that sRGB image on a device with no sRGB support is non-sRGB.
+    //
+    // Rather than try to special case these situations, we execute the image padding in the
+    // destination color space. This should not affect the output of the DAG in (almost) any case,
+    // because the result of this call is going to be used as an input, where it would have been
+    // switched to the destination space anyway. The one exception would be a filter that expected
+    // to consume unclamped F16 data, but the padded version of the image is pre-clamped to 8888.
+    // We can revisit this logic if that ever becomes an actual problem.
     sk_sp<SkSpecialSurface> surf(src->makeSurface(outProps, SkISize::Make(newWidth, newHeight)));
     if (!surf) {
         return nullptr;
     }
 
     SkCanvas* canvas = surf->getCanvas();
     SkASSERT(canvas);
 
     canvas->clear(0x0);
 
@@ skipping 11 matching lines @@
 
     SkIRect dstBounds = this->onFilterNodeBounds(srcBounds, ctx.ctm(), kForward_MapDirection);
     fCropRect.applyTo(dstBounds, ctx.ctm(), this->affectsTransparentBlack(), bounds);
     if (!bounds->intersect(ctx.clipBounds())) {
         return nullptr;
     }
 
     if (srcBounds.contains(*bounds)) {
         return sk_sp<SkSpecialImage>(SkRef(src));
     } else {
-        sk_sp<SkSpecialImage> img(pad_image(src,
+        sk_sp<SkSpecialImage> img(pad_image(src, ctx.outputProperties(),
                                             bounds->width(), bounds->height(),
                                             srcOffset->x() - bounds->x(),
                                             srcOffset->y() - bounds->y()));
         *srcOffset = SkIPoint::Make(bounds->x(), bounds->y());
         return img;
     }
 }
 
 SkIRect SkImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
                                       MapDirection direction) const {
@@ skipping 52 matching lines @@
     sk_sp<SkSpecialImage> result(input->filterImage(src, this->mapContext(ctx), offset));
 
     SkASSERT(!result || src->isTextureBacked() == result->isTextureBacked());
 
     return result;
 }
 
 void SkImageFilter::PurgeCache() {
     SkImageFilterCache::Get()->purge();
 }