Remove internal calls to SkImage::getTexture

src/core/SkSpecialImage.cpp

 /*
  * 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 "SkCanvas.h"
+#include "SkImage_Base.h"
 #include "SkSpecialImage.h"
 #include "SkSpecialSurface.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 class SkSpecialImage_Base : public SkSpecialImage {
 public:
     SkSpecialImage_Base(SkImageFilter::Proxy* proxy, const SkIRect& subset, uint32_t uniqueID)
         : INHERITED(proxy, subset, uniqueID) {
     }
     virtual ~SkSpecialImage_Base() { }
 
     virtual void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) const = 0;
 
     virtual bool onPeekPixels(SkPixmap*) const { return false; }
 
     virtual GrTexture* onPeekTexture() const { return nullptr; }
 
     // Delete this entry point ASAP (see skbug.com/4965)
     virtual bool getBitmap(SkBitmap* result) const = 0;
 
     virtual SkSpecialSurface* onNewSurface(const SkImageInfo& info) const { return nullptr; }
 
 private:
     typedef SkSpecialImage INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
-static inline const SkSpecialImage_Base* as_IB(const SkSpecialImage* image) {
+static inline const SkSpecialImage_Base* as_SIB(const SkSpecialImage* image) {
     return static_cast<const SkSpecialImage_Base*>(image);
 }
 
 void SkSpecialImage::draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const {
-    return as_IB(this)->onDraw(canvas, x, y, paint);
+    return as_SIB(this)->onDraw(canvas, x, y, paint);
 }
 
 bool SkSpecialImage::peekPixels(SkPixmap* pixmap) const {
-    return as_IB(this)->onPeekPixels(pixmap);
+    return as_SIB(this)->onPeekPixels(pixmap);
 }
 
 GrTexture* SkSpecialImage::peekTexture() const {
-    return as_IB(this)->onPeekTexture();
+    return as_SIB(this)->onPeekTexture();
 }
 
 SkSpecialSurface* SkSpecialImage::newSurface(const SkImageInfo& info) const {
-    return as_IB(this)->onNewSurface(info);
+    return as_SIB(this)->onNewSurface(info);
 }
 
 #if SK_SUPPORT_GPU
 #include "SkGr.h"
 #include "SkGrPixelRef.h"
 #endif
 
 SkSpecialImage* SkSpecialImage::internal_fromBM(SkImageFilter::Proxy* proxy,
                                                 const SkBitmap& src) {
     // Need to test offset case! (see skbug.com/4967)
     if (src.getTexture()) {
         return SkSpecialImage::NewFromGpu(proxy,
                                           src.bounds(),
                                           src.getGenerationID(),
                                           src.getTexture());
     }
 
     return SkSpecialImage::NewFromRaster(proxy, src.bounds(), src);
 }
 
 bool SkSpecialImage::internal_getBM(SkBitmap* result) {
-    const SkSpecialImage_Base* ib = as_IB(this);
+    const SkSpecialImage_Base* ib = as_SIB(this);
 
     // TODO: need to test offset case! (see skbug.com/4967)
     return ib->getBitmap(result);
 }
 
 SkImageFilter::Proxy* SkSpecialImage::internal_getProxy() {
     SkASSERT(fProxy);
     return fProxy;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 #include "SkImage.h"
 #if SK_SUPPORT_GPU
 #include "SkGrPriv.h"
 #endif
 
 class SkSpecialImage_Image : public SkSpecialImage_Base {
 public:
     SkSpecialImage_Image(SkImageFilter::Proxy* proxy, const SkIRect& subset, const SkImage* image)
         : INHERITED(proxy, subset, image->uniqueID())
         , fImage(SkRef(image)) {
     }
 
     ~SkSpecialImage_Image() override { }
 
     bool isOpaque() const override { return fImage->isOpaque(); }
 
     size_t getSize() const override {
 #if SK_SUPPORT_GPU
-        if (fImage->getTexture()) {
-            return fImage->getTexture()->gpuMemorySize();
+        if (GrTexture* texture = as_IB(fImage.get())->peekTexture()) {
+            return texture->gpuMemorySize();
         } else
 #endif
         {
             SkImageInfo info;
             size_t rowBytes;
 
             if (fImage->peekPixels(&info, &rowBytes)) {
                 return info.height() * rowBytes;
             }
         }
         return 0;
     }
 
     void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
         SkRect dst = SkRect::MakeXYWH(x, y, this->subset().width(), this->subset().height());
 
         canvas->drawImageRect(fImage, this->subset(),
                               dst, paint, SkCanvas::kStrict_SrcRectConstraint);
     }
 
     bool onPeekPixels(SkPixmap* pixmap) const override {
         return fImage->peekPixels(pixmap);
     }
 
-    GrTexture* onPeekTexture() const override { return fImage->getTexture(); }
+    GrTexture* onPeekTexture() const override { return as_IB(fImage.get())->peekTexture(); }
 
     bool getBitmap(SkBitmap* result) const override {
         return false;
     }
 
     SkSpecialSurface* onNewSurface(const SkImageInfo& info) const override {
 #if SK_SUPPORT_GPU
-        GrTexture* texture = fImage->getTexture();
+        GrTexture* texture = as_IB(fImage.get())->peekTexture();
         if (texture) {
             GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(info);
             desc.fFlags = kRenderTarget_GrSurfaceFlag;
 
             return SkSpecialSurface::NewRenderTarget(this->proxy(), texture->getContext(), desc);
         }
 #endif
         return SkSpecialSurface::NewRaster(this->proxy(), info, nullptr);
     }
 
@@ skipping 161 matching lines @@
 
 SkSpecialImage* SkSpecialImage::NewFromGpu(SkImageFilter::Proxy* proxy,
                                            const SkIRect& subset,
                                            uint32_t uniqueID,
                                            GrTexture* tex,
                                            SkAlphaType at) {
     return nullptr;
 }
 
 #endif