Revert of Add SkSpecialImage::extractSubset & NewFromPixmap (patchset #5 id:80001 of https://codereview.chromium.org/1787883002/ )

Reason for revert:
Need to wean ImagePixelLocker.h off of SkAutoPixmapStorage :(

Original issue's description:
> Add SkSpecialImage::extractSubset & NewFromPixmap
>
> This is calved off of: https://codereview.chromium.org/1785643003/ (Switch SkBlurImageFilter over to new onFilterImage interface)
>
> GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1787883002
>
> Committed: https://skia.googlesource.com/skia/+/250581493a0859987e482810879e85e5ac2dc002

TBR=bsalomon@google.com,reed@google.com
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review URL: https://codereview.chromium.org/1808833002

19 files changed, 157 insertions, 346 deletions

diff --git a/bench/CoverageBench.cpp b/bench/CoverageBench.cpp
index ebde4208a0..3dee66836f 100644
--- a/bench/CoverageBench.cpp
+++ b/bench/CoverageBench.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "Benchmark.h"
-#include "SkAutoPixmapStorage.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
diff --git a/bench/PDFBench.cpp b/bench/PDFBench.cpp
index ba25e44f37..b7f48daac8 100644
--- a/bench/PDFBench.cpp
+++ b/bench/PDFBench.cpp
@@ -7,7 +7,6 @@
 
 #include "Benchmark.h"
 #include "Resources.h"
-#include "SkAutoPixmapStorage.h"
 #include "SkData.h"
 #include "SkImage.h"
 #include "SkPDFBitmap.h"
diff --git a/gm/image.cpp b/gm/image.cpp
index 4e22dd0ff5..2ddda8f8a4 100644
--- a/gm/image.cpp
+++ b/gm/image.cpp
@@ -7,7 +7,6 @@
 
 #include <functional>
 #include "gm.h"
-#include "SkAutoPixmapStorage.h"
 #include "SkData.h"
 #include "SkCanvas.h"
 #include "SkRandom.h"
diff --git a/gyp/core.gypi b/gyp/core.gypi
index b9ee244a5f..15af4649a1 100644
--- a/gyp/core.gypi
+++ b/gyp/core.gypi
@@ -23,8 +23,6 @@
         '<(skia_src_path)/core/SkAlphaRuns.cpp',
         '<(skia_src_path)/core/SkAntiRun.h',
         '<(skia_src_path)/core/SkAutoKern.h',
-        '<(skia_src_path)/core/SkAutoPixmapStorage.h',
-        '<(skia_src_path)/core/SkAutoPixmapStorage.cpp',
         '<(skia_src_path)/core/SkBBHFactory.cpp',
         '<(skia_src_path)/core/SkBBoxHierarchy.h',
         '<(skia_src_path)/core/SkBigPicture.cpp',
diff --git a/include/core/SkPixmap.h b/include/core/SkPixmap.h
index 3a7abdf134..b43072b957 100644
--- a/include/core/SkPixmap.h
+++ b/include/core/SkPixmap.h
@@ -187,6 +187,71 @@ private:
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 
+class SK_API SkAutoPixmapStorage : public SkPixmap {
+public:
+    SkAutoPixmapStorage();
+    ~SkAutoPixmapStorage();
+
+    /**
+     *  Try to allocate memory for the pixels needed to match the specified Info. On success
+     *  return true and fill out the pixmap to point to that memory. The storage will be freed
+     *  when this object is destroyed, or if another call to tryAlloc() or alloc() is made.
+     *
+     *  On failure, return false and reset() the pixmap to empty.
+     */
+    bool tryAlloc(const SkImageInfo&);
+
+    /**
+     *  Allocate memory for the pixels needed to match the specified Info and fill out the pixmap
+     *  to point to that memory. The storage will be freed when this object is destroyed,
+     *  or if another call to tryAlloc() or alloc() is made.
+     *
+     *  If the memory cannot be allocated, calls sk_throw().
+     */
+    void alloc(const SkImageInfo&);
+
+    /**
+     * Gets the size and optionally the rowBytes that would be allocated by SkAutoPixmapStorage if
+     * alloc/tryAlloc was called.
+     */
+    static size_t AllocSize(const SkImageInfo& info, size_t* rowBytes);
+
+    /**
+     *  Returns an SkData object wrapping the allocated pixels memory, and resets the pixmap.
+     *  If the storage hasn't been allocated, the result is NULL.
+     */
+    const SkData* SK_WARN_UNUSED_RESULT detachPixelsAsData();
+
+    // We wrap these so we can clear our internal storage
+
+    void reset() {
+        this->freeStorage();
+        this->INHERITED::reset();
+    }
+    void reset(const SkImageInfo& info, const void* addr, size_t rb, SkColorTable* ctable = NULL) {
+        this->freeStorage();
+        this->INHERITED::reset(info, addr, rb, ctable);
+    }
+    void reset(const SkImageInfo& info) {
+        this->freeStorage();
+        this->INHERITED::reset(info);
+    }
+    bool SK_WARN_UNUSED_RESULT reset(const SkMask& mask) {
+        this->freeStorage();
+        return this->INHERITED::reset(mask);
+    }
+
+private:
+    void*   fStorage;
+
+    void freeStorage() {
+        sk_free(fStorage);
+        fStorage = nullptr;
+    }
+
+    typedef SkPixmap INHERITED;
+};
+
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 class SK_API SkAutoPixmapUnlock : ::SkNoncopyable {
diff --git a/src/core/SkAutoPixmapStorage.cpp b/src/core/SkAutoPixmapStorage.cpp
deleted file mode 100644
index 3be28a94c4..0000000000
--- a/src/core/SkAutoPixmapStorage.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkAutoPixmapStorage.h"
-#include "SkData.h"
-
-SkAutoPixmapStorage::SkAutoPixmapStorage() : fStorage(nullptr) {}
-
-SkAutoPixmapStorage::~SkAutoPixmapStorage() {
-    this->freeStorage();
-}
-
-size_t SkAutoPixmapStorage::AllocSize(const SkImageInfo& info, size_t* rowBytes) {
-    size_t rb = info.minRowBytes();
-    if (rowBytes) {
-        *rowBytes = rb;
-    }
-    return info.getSafeSize(rb);
-}
-
-bool SkAutoPixmapStorage::tryAlloc(const SkImageInfo& info) {
-    this->freeStorage();
-
-    size_t rb;
-    size_t size = AllocSize(info, &rb);
-    if (0 == size) {
-        return false;
-    }
-    void* pixels = sk_malloc_flags(size, 0);
-    if (nullptr == pixels) {
-        return false;
-    }
-    this->reset(info, pixels, rb);
-    fStorage = pixels;
-    return true;
-}
-
-void SkAutoPixmapStorage::alloc(const SkImageInfo& info) {
-    if (!this->tryAlloc(info)) {
-        sk_throw();
-    }
-}
-
-const SkData* SkAutoPixmapStorage::detachPixelsAsData() {
-    if (!fStorage) {
-        return nullptr;
-    }
-
-    auto data = SkData::MakeFromMalloc(fStorage, this->getSafeSize());
-    fStorage = nullptr;
-    this->INHERITED::reset();
-
-    return data.release();
-}
-
-void SkAutoPixmapStorage::release() {
-    fStorage = nullptr;
-    this->INHERITED::reset();
-}
diff --git a/src/core/SkAutoPixmapStorage.h b/src/core/SkAutoPixmapStorage.h
deleted file mode 100644
index 4379b13d24..0000000000
--- a/src/core/SkAutoPixmapStorage.h
+++ /dev/null
@@ -1,87 +0,0 @@
-
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkAutoPixmapStorage_DEFINED
-#define SkAutoPixmapStorage_DEFINED
-
-#include "SkPixmap.h"
-
-class SK_API SkAutoPixmapStorage : public SkPixmap {
-public:
-    SkAutoPixmapStorage();
-    ~SkAutoPixmapStorage();
-
-    /**
-    *  Try to allocate memory for the pixels needed to match the specified Info. On success
-    *  return true and fill out the pixmap to point to that memory. The storage will be freed
-    *  when this object is destroyed, or if another call to tryAlloc() or alloc() is made.
-    *
-    *  On failure, return false and reset() the pixmap to empty.
-    */
-    bool tryAlloc(const SkImageInfo&);
-
-    /**
-    *  Allocate memory for the pixels needed to match the specified Info and fill out the pixmap
-    *  to point to that memory. The storage will be freed when this object is destroyed,
-    *  or if another call to tryAlloc() or alloc() is made.
-    *
-    *  If the memory cannot be allocated, calls sk_throw().
-    */
-    void alloc(const SkImageInfo&);
-
-    /**
-    * Gets the size and optionally the rowBytes that would be allocated by SkAutoPixmapStorage if
-    * alloc/tryAlloc was called.
-    */
-    static size_t AllocSize(const SkImageInfo& info, size_t* rowBytes);
-
-    /**
-    *  Returns an SkData object wrapping the allocated pixels memory, and resets the pixmap.
-    *  If the storage hasn't been allocated, the result is NULL.
-    */
-    const SkData* SK_WARN_UNUSED_RESULT detachPixelsAsData();
-
-    /**
-    * Whereas 'reset' frees the backing memory and then clears the SkPixmap,
-    * this entry point disowns the backing memory before clearing so the memory
-    * isn't freed. It can be used when the Pixmap has been installed into
-    * an SkBitmap and the SkBitmap should manage the memory's lifetime.
-    */
-    void release();
-
-    // We wrap these so we can clear our internal storage
-
-    void reset() {
-        this->freeStorage();
-        this->INHERITED::reset();
-    }
-    void reset(const SkImageInfo& info, const void* addr, size_t rb, SkColorTable* ctable = NULL) {
-        this->freeStorage();
-        this->INHERITED::reset(info, addr, rb, ctable);
-    }
-    void reset(const SkImageInfo& info) {
-        this->freeStorage();
-        this->INHERITED::reset(info);
-    }
-    bool SK_WARN_UNUSED_RESULT reset(const SkMask& mask) {
-        this->freeStorage();
-        return this->INHERITED::reset(mask);
-    }
-
-private:
-    void*   fStorage;
-
-    void freeStorage() {
-        sk_free(fStorage);
-        fStorage = nullptr;
-    }
-
-    typedef SkPixmap INHERITED;
-};
-
-#endif
diff --git a/src/core/SkPixmap.cpp b/src/core/SkPixmap.cpp
index aa1d213bf6..f7672d082f 100644
--- a/src/core/SkPixmap.cpp
+++ b/src/core/SkPixmap.cpp
@@ -281,3 +281,51 @@ bool SkPixmap::scalePixels(const SkPixmap& dst, SkFilterQuality quality) const {
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
+SkAutoPixmapStorage::SkAutoPixmapStorage() : fStorage(nullptr) {}
+
+SkAutoPixmapStorage::~SkAutoPixmapStorage() {
+    this->freeStorage();
+}
+
+size_t SkAutoPixmapStorage::AllocSize(const SkImageInfo& info, size_t* rowBytes) {
+    size_t rb = info.minRowBytes();
+    if (rowBytes) {
+        *rowBytes = rb;
+    }
+    return info.getSafeSize(rb);
+}
+
+bool SkAutoPixmapStorage::tryAlloc(const SkImageInfo& info) {
+    this->freeStorage();
+
+    size_t rb;
+    size_t size = AllocSize(info, &rb);
+    if (0 == size) {
+        return false;
+    }
+    void* pixels = sk_malloc_flags(size, 0);
+    if (nullptr == pixels) {
+        return false;
+    }
+    this->reset(info, pixels, rb);
+    fStorage = pixels;
+    return true;
+}
+
+void SkAutoPixmapStorage::alloc(const SkImageInfo& info) {
+    if (!this->tryAlloc(info)) {
+        sk_throw();
+    }
+}
+
+const SkData* SkAutoPixmapStorage::detachPixelsAsData() {
+    if (!fStorage) {
+        return nullptr;
+    }
+
+    auto data = SkData::MakeFromMalloc(fStorage, this->getSafeSize());
+    fStorage = nullptr;
+    this->INHERITED::reset();
+
+    return data.release();
+}
diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp
index 5e125f3008..a479c3782f 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -8,7 +8,6 @@
 
 
 #include "SkScalerContext.h"
-#include "SkAutoPixmapStorage.h"
 #include "SkColorPriv.h"
 #include "SkDescriptor.h"
 #include "SkDraw.h"
diff --git a/src/core/SkSpecialImage.cpp b/src/core/SkSpecialImage.cpp
index b17d5d4147..a55fe65029 100644
--- a/src/core/SkSpecialImage.cpp
+++ b/src/core/SkSpecialImage.cpp
@@ -20,7 +20,7 @@ public:
 
     virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) const = 0;
 
-    virtual bool onPeekPixels(SkPixmap*) const { return false; }
+    virtual bool testingOnlyOnPeekPixels(SkPixmap*) const { return false; }
 
     virtual GrTexture* onPeekTexture() const { return nullptr; }
 
@@ -29,9 +29,7 @@ public:
     // Delete this entry point ASAP (see skbug.com/4965)
     virtual bool getBitmapDeprecated(SkBitmap* result) const = 0;
 
-    virtual SkSpecialSurface* onNewSurface(const SkImageInfo& info) const = 0;
-
-    virtual SkSpecialImage* onExtractSubset(const SkIRect& subset) const = 0;
+    virtual SkSpecialSurface* onNewSurface(const SkImageInfo& info) const { return nullptr; }
 
 private:
     typedef SkSpecialImage INHERITED;
@@ -46,8 +44,8 @@ void SkSpecialImage::draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPain
     return as_SIB(this)->onDraw(canvas, x, y, paint);
 }
 
-bool SkSpecialImage::peekPixels(SkPixmap* pixmap) const {
-    return as_SIB(this)->onPeekPixels(pixmap);
+bool SkSpecialImage::testingOnlyPeekPixels(SkPixmap* pixmap) const {
+    return as_SIB(this)->testingOnlyOnPeekPixels(pixmap);
 }
 
 GrTexture* SkSpecialImage::peekTexture() const {
@@ -62,10 +60,6 @@ SkSpecialSurface* SkSpecialImage::newSurface(const SkImageInfo& info) const {
     return as_SIB(this)->onNewSurface(info);
 }
 
-SkSpecialImage* SkSpecialImage::extractSubset(const SkIRect& subset) const {
-    return as_SIB(this)->onExtractSubset(subset);
-}
-
 #if SK_SUPPORT_GPU
 #include "SkGr.h"
 #include "SkGrPixelRef.h"
@@ -91,7 +85,8 @@ bool SkSpecialImage::internal_getBM(SkBitmap* result) {
     return ib->getBitmapDeprecated(result);
 }
 
-SkImageFilter::Proxy* SkSpecialImage::internal_getProxy() const {
+SkImageFilter::Proxy* SkSpecialImage::internal_getProxy() {
+    SkASSERT(fProxy);
     return fProxy;
 }
 
@@ -134,7 +129,7 @@ public:
                               dst, paint, SkCanvas::kStrict_SrcRectConstraint);
     }
 
-    bool onPeekPixels(SkPixmap* pixmap) const override {
+    bool testingOnlyOnPeekPixels(SkPixmap* pixmap) const override {
         return fImage->peekPixels(pixmap);
     }
 
@@ -175,17 +170,6 @@ public:
         return SkSpecialSurface::NewRaster(this->proxy(), info, nullptr);
     }
 
-    SkSpecialImage* onExtractSubset(const SkIRect& subset) const override {
-        SkAutoTUnref<SkImage> subsetImg(fImage->newSubset(subset));
-        if (!subsetImg) {
-            return nullptr;
-        }
-
-        return SkSpecialImage::NewFromImage(this->internal_getProxy(),
-                                            SkIRect::MakeWH(subset.width(), subset.height()),
-                                            subsetImg);
-    }
-
 private:
     SkAutoTUnref<const SkImage> fImage;
 
@@ -230,17 +214,6 @@ public:
         }
     }
 
-    SkSpecialImage_Raster(SkImageFilter::Proxy* proxy,
-                          const SkIRect& subset,
-                          const SkPixmap& pixmap,
-                          void (*releaseProc)(void* addr, void* context),
-                          void* context)
-        : INHERITED(proxy, subset, kNeedNewImageUniqueID_SpecialImage) {
-        fBitmap.installPixels(pixmap.info(), pixmap.writable_addr(),
-                              pixmap.rowBytes(), pixmap.ctable(),
-                              releaseProc, context);
-    }
-
     ~SkSpecialImage_Raster() override { }
 
     bool isOpaque() const override { return fBitmap.isOpaque(); }
@@ -255,13 +228,19 @@ public:
                                dst, paint, SkCanvas::kStrict_SrcRectConstraint);
     }
 
-    bool onPeekPixels(SkPixmap* pixmap) const override {
+    bool testingOnlyOnPeekPixels(SkPixmap* pixmap) const override {
         const SkImageInfo info = fBitmap.info();
         if ((kUnknown_SkColorType == info.colorType()) || !fBitmap.getPixels()) {
             return false;
         }
-
-        return fBitmap.peekPixels(pixmap);
+        const void* pixels = fBitmap.getPixels();
+        if (pixels) {
+            if (pixmap) {
+                pixmap->reset(info, pixels, fBitmap.rowBytes());
+            }
+            return true;
+        }
+        return false;
     }
 
     bool getBitmapDeprecated(SkBitmap* result) const override {
@@ -278,18 +257,6 @@ public:
         return SkSpecialSurface::NewRaster(this->proxy(), info, nullptr);
     }
 
-    SkSpecialImage* onExtractSubset(const SkIRect& subset) const override {
-        SkBitmap subsetBM;
-        
-        if (!fBitmap.extractSubset(&subsetBM, subset)) {
-            return nullptr;
-        }
-
-        return SkSpecialImage::NewFromRaster(this->internal_getProxy(),
-                                             SkIRect::MakeWH(subset.width(), subset.height()),
-                                             subsetBM);
-    }
-
 private:
     SkBitmap fBitmap;
 
@@ -304,15 +271,6 @@ SkSpecialImage* SkSpecialImage::NewFromRaster(SkImageFilter::Proxy* proxy,
     return new SkSpecialImage_Raster(proxy, subset, bm);
 }
 
-SkSpecialImage* SkSpecialImage::NewFromPixmap(SkImageFilter::Proxy* proxy,
-                                              const SkIRect& subset,
-                                              const SkPixmap& src,
-                                              void (*releaseProc)(void* addr, void* context),
-                                              void* context) {
-    return new SkSpecialImage_Raster(proxy, subset, src, releaseProc, context);
-}
-
-
 #if SK_SUPPORT_GPU
 ///////////////////////////////////////////////////////////////////////////////
 #include "GrTexture.h"
@@ -357,10 +315,7 @@ public:
             return false;
         }
 
-        const SkImageInfo prInfo = info.makeWH(fTexture->width(), fTexture->height());
-
-        SkAutoTUnref<SkGrPixelRef> pixelRef(new SkGrPixelRef(prInfo, fTexture));
-        result->setPixelRef(pixelRef, this->subset().fLeft, this->subset().fTop);
+        result->setPixelRef(new SkGrPixelRef(info, fTexture))->unref();
         return true;
     }
 
@@ -390,14 +345,6 @@ public:
         return SkSpecialSurface::NewRenderTarget(this->proxy(), fTexture->getContext(), desc);
     }
 
-    SkSpecialImage* onExtractSubset(const SkIRect& subset) const override {
-        return SkSpecialImage::NewFromGpu(this->internal_getProxy(),
-                                          subset,
-                                          this->uniqueID(),
-                                          fTexture, 
-                                          fAlphaType);
-    }
-
 private:
     SkAutoTUnref<GrTexture> fTexture;
     const SkAlphaType       fAlphaType;
diff --git a/src/core/SkSpecialImage.h b/src/core/SkSpecialImage.h
index b1b6a28d6a..e90de097fb 100644
--- a/src/core/SkSpecialImage.h
+++ b/src/core/SkSpecialImage.h
@@ -63,27 +63,16 @@ public:
                                       uint32_t uniqueID,
                                       GrTexture*, 
                                       SkAlphaType at = kPremul_SkAlphaType);
-    static SkSpecialImage* NewFromPixmap(SkImageFilter::Proxy*,
-                                         const SkIRect& subset,
-                                         const SkPixmap&,
-                                         void (*releaseProc)(void* addr, void* context),
-                                         void* context);
 
     /**
      *  Create a new surface with a backend that is compatible with this image.
      */
     SkSpecialSurface* newSurface(const SkImageInfo&) const;
 
-    /**
-     * Extract a subset of this special image and return it as a special image.
-     * It may or may not point to the same backing memory.
-     */
-    SkSpecialImage* extractSubset(const SkIRect& subset) const;
-
     // These three internal methods will go away (see skbug.com/4965)
     bool internal_getBM(SkBitmap* result);
     static SkSpecialImage* internal_fromBM(SkImageFilter::Proxy*, const SkBitmap&);
-    SkImageFilter::Proxy* internal_getProxy() const;
+    SkImageFilter::Proxy* internal_getProxy();
 
     // TODO: hide this when GrLayerHoister uses SkSpecialImages more fully (see skbug.com/5063)
     /**
@@ -92,20 +81,6 @@ public:
      */
     GrTexture* peekTexture() const;
 
-    // TODO: hide this whe the imagefilter all have a consistent draw path (see skbug.com/5063)
-    /**
-     *  If the SpecialImage is backed by cpu pixels, return the const address
-     *  of those pixels and, if not null, the ImageInfo, rowBytes, and, if present,
-     *  the color table. The returned address(es) is/are only valid while the image object
-     *  is in scope.
-     *
-     *  The returned ImageInfo represents the backing memory. Use 'subset'
-     *  to get the active portion's dimensions.
-     *
-     *  On failure, return false and ignore the pixmap parameter.
-     */
-    bool peekPixels(SkPixmap*) const;
-
 protected:
     SkSpecialImage(SkImageFilter::Proxy* proxy, const SkIRect& subset, uint32_t uniqueID)
         : fSubset(subset)
@@ -118,6 +93,18 @@ protected:
     friend class TestingSpecialImageAccess;
     friend class TestingSpecialSurfaceAccess;
 
+    /**
+     *  If the SpecialImage is backed by cpu pixels, return the const address
+     *  of those pixels and, if not null, return the ImageInfo and rowBytes.
+     *  The returned address is only valid while the image object is in scope.
+     *
+     *  The returned ImageInfo represents the backing memory. Use 'subset'
+     *  to get the active portion's dimensions.
+     *
+     *  On failure, return false and ignore the pixmap parameter.
+     */
+    bool testingOnlyPeekPixels(SkPixmap*) const;
+
     // This entry point is for testing only. It does a readback from VRAM for
     // GPU-backed special images.
     bool testingOnlyGetROPixels(SkBitmap*) const;
diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h
index fb5d9e86aa..b90205b1a1 100644
--- a/src/gpu/GrSWMaskHelper.h
+++ b/src/gpu/GrSWMaskHelper.h
@@ -8,7 +8,6 @@
 #ifndef GrSWMaskHelper_DEFINED
 #define GrSWMaskHelper_DEFINED
 
-#include "SkAutoPixmapStorage.h"
 #include "GrColor.h"
 #include "GrPipelineBuilder.h"
 #include "SkBitmap.h"
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index 5e687b751a..cde4232d36 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -5,7 +5,6 @@
  * found in the LICENSE file.
  */
 
-#include "SkAutoPixmapStorage.h"
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrDrawContext.h"
diff --git a/tests/DeviceLooperTest.cpp b/tests/DeviceLooperTest.cpp
index c8eb3c7b75..1a51b58980 100644
--- a/tests/DeviceLooperTest.cpp
+++ b/tests/DeviceLooperTest.cpp
@@ -5,7 +5,6 @@
  * found in the LICENSE file.
  */
 
-#include "SkAutoPixmapStorage.h"
 #include "SkDeviceLooper.h"
 #include "SkRasterClip.h"
 #include "Test.h"
diff --git a/tests/Float16Test.cpp b/tests/Float16Test.cpp
index 6a7f9842f4..ef349c6cb6 100644
--- a/tests/Float16Test.cpp
+++ b/tests/Float16Test.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "Test.h"
-#include "SkAutoPixmapStorage.h"
 #include "SkColor.h"
 #include "SkHalf.h"
 #include "SkOpts.h"
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index da9268dded..3c2c31cca9 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -9,7 +9,6 @@
 #include <initializer_list>
 #include "DMGpuSupport.h"
 
-#include "SkAutoPixmapStorage.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkData.h"
diff --git a/tests/SpecialImageTest.cpp b/tests/SpecialImageTest.cpp
index 7511e62971..9bde7eec33 100644
--- a/tests/SpecialImageTest.cpp
+++ b/tests/SpecialImageTest.cpp
@@ -5,11 +5,9 @@
  * found in the LICENSE file
  */
 
-#include "SkAutoPixmapStorage.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkImage.h"
-#include "SkPixmap.h"
 #include "SkSpecialImage.h"
 #include "SkSpecialSurface.h"
 #include "Test.h"
@@ -50,11 +48,10 @@ static SkBitmap create_bm() {
 
 // Basic test of the SkSpecialImage public API (e.g., peekTexture, peekPixels & draw)
 static void test_image(SkSpecialImage* img, skiatest::Reporter* reporter,
-                       bool peekPixelsSucceeds, bool peekTextureSucceeds,
-                       int offset, int size) {
+                       bool peekPixelsSucceeds, bool peekTextureSucceeds) {
     const SkIRect subset = TestingSpecialImageAccess::Subset(img);
-    REPORTER_ASSERT(reporter, offset == subset.left());
-    REPORTER_ASSERT(reporter, offset == subset.top());
+    REPORTER_ASSERT(reporter, kPad == subset.left());
+    REPORTER_ASSERT(reporter, kPad == subset.top());
     REPORTER_ASSERT(reporter, kSmallerSize == subset.width());
     REPORTER_ASSERT(reporter, kSmallerSize == subset.height());
 
@@ -66,8 +63,8 @@ static void test_image(SkSpecialImage* img, skiatest::Reporter* reporter,
     REPORTER_ASSERT(reporter, peekPixelsSucceeds ==
                               !!TestingSpecialImageAccess::PeekPixels(img, &pixmap));
     if (peekPixelsSucceeds) {
-        REPORTER_ASSERT(reporter, size == pixmap.width());
-        REPORTER_ASSERT(reporter, size == pixmap.height());
+        REPORTER_ASSERT(reporter, kFullSize == pixmap.width());
+        REPORTER_ASSERT(reporter, kFullSize == pixmap.height());
     }
 
     //--------------
@@ -98,22 +95,10 @@ static void test_image(SkSpecialImage* img, skiatest::Reporter* reporter,
 DEF_TEST(SpecialImage_Raster, reporter) {
     SkBitmap bm = create_bm();
 
-    SkAutoTUnref<SkSpecialImage> fullSImage(SkSpecialImage::NewFromRaster(
-                                                            nullptr,
-                                                            SkIRect::MakeWH(kFullSize, kFullSize),
-                                                            bm));
-
     const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
 
-    {
-        SkAutoTUnref<SkSpecialImage> subSImg1(SkSpecialImage::NewFromRaster(nullptr, subset, bm));
-        test_image(subSImg1, reporter, true, false, kPad, kFullSize);
-    }
-
-    {
-        SkAutoTUnref<SkSpecialImage> subSImg2(fullSImage->extractSubset(subset));
-        test_image(subSImg2, reporter, true, false, 0, kSmallerSize);
-    }
+    SkAutoTUnref<SkSpecialImage> img(SkSpecialImage::NewFromRaster(nullptr, subset, bm));
+    test_image(img, reporter, true, false);
 }
 
 DEF_TEST(SpecialImage_Image, reporter) {
@@ -121,56 +106,12 @@ DEF_TEST(SpecialImage_Image, reporter) {
 
     SkAutoTUnref<SkImage> fullImage(SkImage::NewFromBitmap(bm));
 
-    SkAutoTUnref<SkSpecialImage> fullSImage(SkSpecialImage::NewFromImage(
-                                                            nullptr,
-                                                            SkIRect::MakeWH(kFullSize, kFullSize),
-                                                            fullImage));
-
     const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
 
-    {
-        SkAutoTUnref<SkSpecialImage> subSImg1(SkSpecialImage::NewFromImage(nullptr,
-                                                                           subset,
-                                                                           fullImage));
-        test_image(subSImg1, reporter, true, false, kPad, kFullSize);
-    }
-
-    {
-        SkAutoTUnref<SkSpecialImage> subSImg2(fullSImage->extractSubset(subset));
-        test_image(subSImg2, reporter, true, false, 0, kSmallerSize);
-    }
+    SkAutoTUnref<SkSpecialImage> img(SkSpecialImage::NewFromImage(nullptr, subset, fullImage));
+    test_image(img, reporter, true, false);
 }
 
-DEF_TEST(SpecialImage_Pixmap, reporter) {
-    SkAutoPixmapStorage pixmap;
-
-    const SkImageInfo info = SkImageInfo::MakeN32(kFullSize, kFullSize, kOpaque_SkAlphaType);
-    pixmap.alloc(info);
-    pixmap.erase(SK_ColorGREEN);
-
-    const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
-
-    pixmap.erase(SK_ColorRED, subset);
-
-    {
-        // The SkAutoPixmapStorage keeps hold of the memory
-        SkAutoTUnref<SkSpecialImage> img(SkSpecialImage::NewFromPixmap(nullptr, subset, pixmap,
-                                                                       nullptr, nullptr));
-        test_image(img, reporter, true, false, kPad, kFullSize);
-    }
-
-    {
-        // The image takes ownership of the memory
-        SkAutoTUnref<SkSpecialImage> img(SkSpecialImage::NewFromPixmap(
-                                               nullptr, subset, pixmap,
-                                               [] (void* addr, void*) -> void { sk_free(addr); },
-                                               nullptr));
-        pixmap.release();
-        test_image(img, reporter, true, false, kPad, kFullSize);
-    }
-}
-
-
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_Gpu, reporter, context) {
     SkBitmap bm = create_bm();
@@ -187,26 +128,12 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_Gpu, reporter, context) {
         return;
     }
 
-    SkAutoTUnref<SkSpecialImage> fullSImg(SkSpecialImage::NewFromGpu(
-                                                            nullptr,
-                                                            SkIRect::MakeWH(kFullSize, kFullSize),
-                                                            kNeedNewImageUniqueID_SpecialImage,
-                                                            texture));
-
     const SkIRect& subset = SkIRect::MakeXYWH(kPad, kPad, kSmallerSize, kSmallerSize);
 
-    {
-        SkAutoTUnref<SkSpecialImage> subSImg1(SkSpecialImage::NewFromGpu(
-                                                               nullptr, subset, 
-                                                               kNeedNewImageUniqueID_SpecialImage,
-                                                               texture));
-        test_image(subSImg1, reporter, false, true, kPad, kFullSize);
-    }
-
-    {
-        SkAutoTUnref<SkSpecialImage> subSImg2(fullSImg->extractSubset(subset));
-        test_image(subSImg2, reporter, false, true, kPad, kFullSize);
-    }
+    SkAutoTUnref<SkSpecialImage> img(SkSpecialImage::NewFromGpu(nullptr, subset, 
+                                                                kNeedNewImageUniqueID_SpecialImage,
+                                                                texture));
+    test_image(img, reporter, false, true);
 }
 
 #endif
diff --git a/tests/TestingSpecialImageAccess.h b/tests/TestingSpecialImageAccess.h
index 8dd4e9bb50..cd9d77c7ff 100644
--- a/tests/TestingSpecialImageAccess.h
+++ b/tests/TestingSpecialImageAccess.h
@@ -15,7 +15,7 @@ public:
     }
 
     static bool PeekPixels(const SkSpecialImage* img, SkPixmap* pixmap) {
-        return img->peekPixels(pixmap);
+        return img->testingOnlyPeekPixels(pixmap);
     }
 
     static GrTexture* PeekTexture(const SkSpecialImage* img) {
diff --git a/tests/TextureCompressionTest.cpp b/tests/TextureCompressionTest.cpp
index 09086605a5..18afebeff2 100644
--- a/tests/TextureCompressionTest.cpp
+++ b/tests/TextureCompressionTest.cpp
@@ -5,7 +5,6 @@
  * found in the LICENSE file.
  */
 
-#include "SkAutoPixmapStorage.h"
 #include "SkBitmap.h"
 #include "SkData.h"
 #include "SkEndian.h"