Upgrade SkSpecialImage to have getTextureRef & getROPixels entry points

src/effects/SkBlurImageFilter.cpp

 /*
  * Copyright 2011 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 "SkBlurImageFilter.h"
 
 #include "SkAutoPixmapStorage.h"
@@ skipping 77 matching lines @@
     if (!this->applyCropRect(this->mapContext(ctx), inputBounds, &dstBounds)) {
         return nullptr;
     }
     if (!inputBounds.intersect(dstBounds)) {
         return nullptr;
     }
 
     const SkVector sigma = map_sigma(fSigma, ctx.ctm());
 
 #if SK_SUPPORT_GPU
-    if (input->peekTexture() && input->peekTexture()->getContext()) {
+    if (source->isTextureBacked()) {
+        GrContext* context = source->getContext();
+        GrTexture* inputTexture = input->asTextureRef(context);
+        SkASSERT(inputTexture);
+
         if (0 == sigma.x() && 0 == sigma.y()) {
             offset->fX = inputBounds.x();
             offset->fY = inputBounds.y();
             return input->makeSubset(inputBounds.makeOffset(-inputOffset.x(),
                                                             -inputOffset.y()));
         }
 
-        GrTexture* inputTexture = input->peekTexture();
-
         offset->fX = dstBounds.fLeft;
         offset->fY = dstBounds.fTop;
         inputBounds.offset(-inputOffset);
         dstBounds.offset(-inputOffset);
         SkRect inputBoundsF(SkRect::Make(inputBounds));
-        SkAutoTUnref<GrTexture> tex(SkGpuBlurUtils::GaussianBlur(inputTexture->getContext(),
+        SkAutoTUnref<GrTexture> tex(SkGpuBlurUtils::GaussianBlur(context,
                                                                  inputTexture,
                                                                  false,
                                                                  source->props().allowSRGBInputs(),
                                                                  SkRect::Make(dstBounds),
                                                                  &inputBoundsF,
                                                                  sigma.x(),
                                                                  sigma.y()));
         if (!tex) {
             return nullptr;
         }
@@ skipping 14 matching lines @@
         return nullptr;
     }
 
     if (kernelSizeX == 0 && kernelSizeY == 0) {
         offset->fX = inputBounds.x();
         offset->fY = inputBounds.y();
         return input->makeSubset(inputBounds.makeOffset(-inputOffset.x(),
                                                         -inputOffset.y()));
     }
 
-    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(dstBounds.width(), dstBounds.height(),
-                                         inputPixmap.colorType(), inputPixmap.alphaType());
+                                         inputBM.colorType(), inputBM.alphaType());
 
     SkBitmap tmp, dst;
     if (!tmp.tryAllocPixels(info) || !dst.tryAllocPixels(info)) {
         return nullptr;
     }
 
-    SkAutoLockPixels tmpLock(tmp), dstLock(dst);
+    SkAutoLockPixels inputLock(inputBM), tmpLock(tmp), dstLock(dst);
 
     offset->fX = dstBounds.fLeft;
     offset->fY = dstBounds.fTop;
     SkPMColor* t = tmp.getAddr32(0, 0);
     SkPMColor* d = dst.getAddr32(0, 0);
     int w = dstBounds.width(), h = dstBounds.height();
-    const SkPMColor* s = inputPixmap.addr32(inputBounds.x() - inputOffset.x(),
-                                            inputBounds.y() - inputOffset.y());
+    const SkPMColor* s = inputBM.getAddr32(inputBounds.x() - inputOffset.x(),
+                                           inputBounds.y() - inputOffset.y());
     inputBounds.offset(-dstBounds.x(), -dstBounds.y());
     dstBounds.offset(-dstBounds.x(), -dstBounds.y());
     SkIRect inputBoundsT = SkIRect::MakeLTRB(inputBounds.top(), inputBounds.left(),
                                              inputBounds.bottom(), inputBounds.right());
     SkIRect dstBoundsT = SkIRect::MakeWH(dstBounds.height(), dstBounds.width());
-    int sw = int(inputPixmap.rowBytes() >> 2);
+    int sw = int(inputBM.rowBytes() >> 2);
 
     /**
      *
      * In order to make memory accesses cache-friendly, we reorder the passes to
      * use contiguous memory reads wherever possible.
      *
      * For example, the 6 passes of the X-and-Y blur case are rewritten as
      * follows. Instead of 3 passes in X and 3 passes in Y, we perform
      * 2 passes in X, 1 pass in X transposed to Y on write, 2 passes in X,
      * then 1 pass in X transposed to Y on write.
@@ skipping 49 matching lines @@
     str->appendf("SkBlurImageFilter: (");
     str->appendf("sigma: (%f, %f) input (", fSigma.fWidth, fSigma.fHeight);
 
     if (this->getInput(0)) {
         this->getInput(0)->toString(str);
     }
 
     str->append("))");
 }
 #endif