Upgrade SkSpecialImage to have getTextureRef & getROPixels entry points

src/effects/SkMorphologyImageFilter.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 "SkMorphologyImageFilter.h"
 
 #include "SkBitmap.h"
@@ skipping 25 matching lines @@
     , fRadius(SkISize::Make(radiusX, radiusY)) {
 }
 
 void SkMorphologyImageFilter::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeInt(fRadius.fWidth);
     buffer.writeInt(fRadius.fHeight);
 }
 
 static void call_proc_X(SkMorphologyImageFilter::Proc procX,
-                        const SkPixmap& src, SkBitmap* dst,
+                        const SkBitmap& src, SkBitmap* dst,
                         int radiusX, const SkIRect& bounds) {
-    procX(src.addr32(bounds.left(), bounds.top()), dst->getAddr32(0, 0),
+    procX(src.getAddr32(bounds.left(), bounds.top()), dst->getAddr32(0, 0),
           radiusX, bounds.width(), bounds.height(),
           src.rowBytesAsPixels(), dst->rowBytesAsPixels());
 }
 
 static void call_proc_Y(SkMorphologyImageFilter::Proc procY,
                         const SkPMColor* src, int srcRowBytesAsPixels, SkBitmap* dst,
                         int radiusY, const SkIRect& bounds) {
     procY(src, dst->getAddr32(0, 0),
           radiusY, bounds.height(), bounds.width(),
           srcRowBytesAsPixels, dst->rowBytesAsPixels());
@@ skipping 484 matching lines @@
     SkIRect srcBounds = bounds;
     srcBounds.offset(-inputOffset);
 
     if (0 == width && 0 == height) {
         offset->fX = bounds.left();
         offset->fY = bounds.top();
         return input->makeSubset(srcBounds);
     }
 
 #if SK_SUPPORT_GPU
-    if (input->peekTexture() && input->peekTexture()->getContext()) {
+    if (source->peekTexture() && source->peekTexture()->getContext()) {
+        GrTexture* inputTexture = input->asTextureRef(source->peekTexture()->getContext());
+        if (!inputTexture) {

[Stephen White, 2016/04/06 16:21:23]

I find this API somewhat error-prone, in that it's not clear when you have to
call peekTexture() and when you call asTextureRef() (and the fact that you don't
use the result of the latter call). Could we bake this call into filterInput()
or (better) filterImage(), so the onus is not on each filter to do it?

[robertphillips, 2016/04/06 17:19:53]

I have updated the SkSpecialImage API to cleave more closely to SkImage (i.e.,
peekTexture has been replaced with isTextureBacked).

Wrt baking this into filterInput or filterImage, the image filters that have a
GPU-specific special case are going to have to burrow into the SkSpecialImage no
matter what. So we'll need something here. I agree that we should always force
all images in the ImageFilter cache to be GrTexture-backed when targeting an
SkGpuDevice but I think that would be a separate CL.

+            return nullptr;
+        }
+
         auto type = (kDilate_Op == this->op()) ? GrMorphologyEffect::kDilate_MorphologyType
                                                : GrMorphologyEffect::kErode_MorphologyType;
         sk_sp<SkSpecialImage> result(apply_morphology(input.get(), srcBounds, type,
                                                       SkISize::Make(width, height)));
         if (result) {
             offset->fX = bounds.left();
             offset->fY = bounds.top();
         }
         return result;
     }
 #endif
 
-    SkPixmap inputPixmap;
+    SkBitmap inputBM;
 
-    if (!input->peekPixels(&inputPixmap)) {
+    if (!input->getROPixels(&inputBM)) {
         return nullptr;
     }
 
-    if (inputPixmap.colorType() != kN32_SkColorType) {
+    if (inputBM.colorType() != kN32_SkColorType) {
         return nullptr;
     }
 
     SkImageInfo info = SkImageInfo::Make(bounds.width(), bounds.height(),
-                                         inputPixmap.colorType(), inputPixmap.alphaType());
+                                         inputBM.colorType(), inputBM.alphaType());
 
     SkBitmap dst;
     if (!dst.tryAllocPixels(info)) {
         return nullptr;
     }
 
-    SkAutoLockPixels dstLock(dst);
+    SkAutoLockPixels inputLock(inputBM), dstLock(dst);
 
     SkMorphologyImageFilter::Proc procX, procY;
 
     if (kDilate_Op == this->op()) {
         procX = SkOpts::dilate_x;
         procY = SkOpts::dilate_y;
     } else {
         procX = SkOpts::erode_x;
         procY = SkOpts::erode_y;
     }
 
     if (width > 0 && height > 0) {
         SkBitmap tmp;
         if (!tmp.tryAllocPixels(info)) {
             return nullptr;
         }
 
         SkAutoLockPixels tmpLock(tmp);
 
-        call_proc_X(procX, inputPixmap, &tmp, width, srcBounds);
+        call_proc_X(procX, inputBM, &tmp, width, srcBounds);
         SkIRect tmpBounds = SkIRect::MakeWH(srcBounds.width(), srcBounds.height());
         call_proc_Y(procY,
                     tmp.getAddr32(tmpBounds.left(), tmpBounds.top()), tmp.rowBytesAsPixels(),
                     &dst, height, tmpBounds);
     } else if (width > 0) {
-        call_proc_X(procX, inputPixmap, &dst, width, srcBounds);
+        call_proc_X(procX, inputBM, &dst, width, srcBounds);
     } else if (height > 0) {
         call_proc_Y(procY,
-                    inputPixmap.addr32(srcBounds.left(), srcBounds.top()),
-                    inputPixmap.rowBytesAsPixels(),
+                    inputBM.getAddr32(srcBounds.left(), srcBounds.top()),
+                    inputBM.rowBytesAsPixels(),
                     &dst, height, srcBounds);
     }
     offset->fX = bounds.left();
     offset->fY = bounds.top();
 
     return SkSpecialImage::MakeFromRaster(source->internal_getProxy(),
                                           SkIRect::MakeWH(bounds.width(), bounds.height()),
                                           dst);
 }