Refactoring in SkImage implementations backed by a SkBitmap

src/image/SkImage_Raster.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#include "SkImage_Base.h"
-#include "SkImagePriv.h"
+#include "SkImage_BitmapBase.h"
+
 #include "SkBitmap.h"
-#include "SkCanvas.h"
 #include "SkData.h"
 #include "SkDecodingImageGenerator.h"
-#include "SkMallocPixelRef.h"
+#include "SkImagePriv.h"
 
-class SkImage_Raster : public SkImage_Base {
+class SkImage_Raster : public SkImage_BitmapBase {
 public:
     static bool ValidArgs(const Info& info, size_t rowBytes) {
         const int maxDimension = SK_MaxS32 >> 2;
         const size_t kMaxPixelByteSize = SK_MaxS32;
 
         if (info.width() < 0 || info.height() < 0) {
             return false;
         }
         if (info.width() > maxDimension || info.height() > maxDimension) {
             return false;
@@ skipping 20 matching lines @@
             return false;
         }
         return true;
     }
 
     static SkImage* NewEmpty();
 
     SkImage_Raster(const SkImageInfo&, SkData*, size_t rb);
     virtual ~SkImage_Raster();
 
-    virtual void onDraw(SkCanvas*, SkScalar, SkScalar, const SkPaint*) const SK_OVERRIDE;
-    virtual void onDrawRectToRect(SkCanvas*, const SkRect*, const SkRect&,
-                                  const SkPaint*) const SK_OVERRIDE;
     virtual bool onReadPixels(SkBitmap*, const SkIRect&) const SK_OVERRIDE;
     virtual const void* onPeekPixels(SkImageInfo*, size_t* /*rowBytes*/) const SK_OVERRIDE;
     virtual bool getROPixels(SkBitmap*) const SK_OVERRIDE;
 
     // exposed for SkSurface_Raster via SkNewImageFromPixelRef
     SkImage_Raster(const SkImageInfo&, SkPixelRef*, size_t rowBytes);
 
-    SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); }
-
-    virtual SkShader* onNewShader(SkShader::TileMode,
-                                  SkShader::TileMode,
-                                  const SkMatrix* localMatrix) const SK_OVERRIDE;
-
-    virtual bool isOpaque() const SK_OVERRIDE;
+    SkPixelRef* getPixelRef() const { return this->getBitmap().pixelRef(); }
 
     SkImage_Raster(const SkBitmap& bm)
-        : INHERITED(bm.width(), bm.height())
-        , fBitmap(bm) {}
+        : INHERITED(bm) {}
 
 private:
     SkImage_Raster() : INHERITED(0, 0) {}
 
-    SkBitmap    fBitmap;
+//    SkBitmap    fBitmap;
 
-    typedef SkImage_Base INHERITED;
+    typedef SkImage_BitmapBase INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkImage* SkImage_Raster::NewEmpty() {
     // Returns lazily created singleton
     static SkImage* gEmpty;
     if (NULL == gEmpty) {
         gEmpty = SkNEW(SkImage_Raster);
     }
     gEmpty->ref();
     return gEmpty;
 }
 
 static void release_data(void* addr, void* context) {
     SkData* data = static_cast<SkData*>(context);
     data->unref();
 }
 
 SkImage_Raster::SkImage_Raster(const Info& info, SkData* data, size_t rowBytes)
     : INHERITED(info.width(), info.height())
 {
     data->ref();
     void* addr = const_cast<void*>(data->data());
     SkColorTable* ctable = NULL;
 
-    fBitmap.installPixels(info, addr, rowBytes, ctable, release_data, data);
-    fBitmap.setImmutable();
-    fBitmap.lockPixels();
+    // Safe (in constructor) but ugly, maybe we should add a constructor with the same sig. as
+    // this one in SkImage_BitmapBase ?
+    SkBitmap* bitmap = const_cast<SkBitmap*>(&this->getBitmap());
+    bitmap->installPixels(info, addr, rowBytes, ctable, release_data, data);
+    bitmap->setImmutable();
+    bitmap->lockPixels();
 }
 
 SkImage_Raster::SkImage_Raster(const Info& info, SkPixelRef* pr, size_t rowBytes)
     : INHERITED(info.width(), info.height())
 {
-    fBitmap.setInfo(info, rowBytes);
-    fBitmap.setPixelRef(pr);
-    fBitmap.lockPixels();
+    // Safe (in constructor) but ugly, maybe we should add a constructor with the same sig. as
+    // this one in SkImage_BitmapBase ?
+    SkBitmap* bitmap = const_cast<SkBitmap*>(&this->getBitmap());
+    bitmap->setInfo(info, rowBytes);
+    bitmap->setPixelRef(pr);
+    bitmap->lockPixels();
 }
 
 SkImage_Raster::~SkImage_Raster() {}
 
-SkShader* SkImage_Raster::onNewShader(SkShader::TileMode tileX, SkShader::TileMode tileY,
-                                      const SkMatrix* localMatrix) const {
-    return SkShader::CreateBitmapShader(fBitmap, tileX, tileY, localMatrix);
-}
-
-void SkImage_Raster::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const {
-    canvas->drawBitmap(fBitmap, x, y, paint);
-}
-
-void SkImage_Raster::onDrawRectToRect(SkCanvas* canvas, const SkRect* src, const SkRect& dst,
-                                      const SkPaint* paint) const {
-    canvas->drawBitmapRectToRect(fBitmap, src, dst, paint);
-}
-
 bool SkImage_Raster::onReadPixels(SkBitmap* dst, const SkIRect& subset) const {
     if (dst->pixelRef()) {
         return this->INHERITED::onReadPixels(dst, subset);
     } else {
         SkBitmap src;
-        if (!fBitmap.extractSubset(&src, subset)) {
+        if (!this->getBitmap().extractSubset(&src, subset)) {
             return false;
         }
         return src.copyTo(dst, src.colorType());
     }
 }
 
 const void* SkImage_Raster::onPeekPixels(SkImageInfo* infoPtr, size_t* rowBytesPtr) const {
-    const SkImageInfo info = fBitmap.info();
-    if ((kUnknown_SkColorType == info.colorType()) || !fBitmap.getPixels()) {
+    const SkImageInfo info = this->getBitmap().info();
+    if ((kUnknown_SkColorType == info.colorType()) || !this->getBitmap().getPixels()) {
         return NULL;
     }
     *infoPtr = info;
-    *rowBytesPtr = fBitmap.rowBytes();
-    return fBitmap.getPixels();
+    *rowBytesPtr = this->getBitmap().rowBytes();
+    return this->getBitmap().getPixels();
 }
 
 bool SkImage_Raster::getROPixels(SkBitmap* dst) const {
-    *dst = fBitmap;
+    *dst = this->getBitmap();
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkImage* SkImage::NewRasterCopy(const SkImageInfo& info, const void* pixels, size_t rowBytes) {
     if (!SkImage_Raster::ValidArgs(info, rowBytes)) {
         return NULL;
     }
     if (0 == info.width() && 0 == info.height()) {
@@ skipping 40 matching lines @@
 }
 
 SkImage* SkNewImageFromPixelRef(const SkImageInfo& info, SkPixelRef* pr,
                                 size_t rowBytes) {
     return SkNEW_ARGS(SkImage_Raster, (info, pr, rowBytes));
 }
 
 SkPixelRef* SkBitmapImageGetPixelRef(SkImage* image) {
     return ((SkImage_Raster*)image)->getPixelRef();
 }
-
-bool SkImage_Raster::isOpaque() const {
-    return fBitmap.isOpaque();
-}