Split SkDevice into SkBaseDevice and SkBitmapDevice

src/core/SkCanvas.cpp

 
 /*
  * Copyright 2008 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 "SkCanvas.h"
+#include "SkBitmapDevice.h"
 #include "SkBounder.h"
-#include "SkDevice.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDraw.h"
 #include "SkDrawFilter.h"
 #include "SkDrawLooper.h"
 #include "SkMetaData.h"
 #include "SkPathOps.h"
 #include "SkPicture.h"
 #include "SkRasterClip.h"
 #include "SkRRect.h"
 #include "SkScalarCompare.h"
@@ skipping 99 matching lines @@
 typedef SkTLazy<SkPaint> SkLazyPaint;
 
 void SkCanvas::predrawNotify() {
     if (fSurfaceBase) {
         fSurfaceBase->aboutToDraw(SkSurface::kRetain_ContentChangeMode);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-/*  This is the record we keep for each SkDevice that the user installs.
+/*  This is the record we keep for each SkBaseDevice that the user installs.
     The clip/matrix/proc are fields that reflect the top of the save/restore
     stack. Whenever the canvas changes, it marks a dirty flag, and then before
     these are used (assuming we're not on a layer) we rebuild these cache
     values: they reflect the top of the save stack, but translated and clipped
     by the device's XY offset and bitmap-bounds.
 */
 struct DeviceCM {
     DeviceCM*           fNext;
-    SkDevice*           fDevice;
+    SkBaseDevice*       fDevice;
     SkRasterClip        fClip;
     const SkMatrix*     fMatrix;
     SkPaint*            fPaint; // may be null (in the future)
 
-    DeviceCM(SkDevice* device, int x, int y, const SkPaint* paint, SkCanvas* canvas)
+    DeviceCM(SkBaseDevice* device, int x, int y, const SkPaint* paint, SkCanvas* canvas)
             : fNext(NULL) {
         if (NULL != device) {
             device->ref();
             device->onAttachToCanvas(canvas);
         }
         fDevice = device;
         fPaint = paint ? SkNEW_ARGS(SkPaint, (*paint)) : NULL;
     }
 
     ~DeviceCM() {
@@ skipping 151 matching lines @@
             if (fBounder) {
                 fBounder->setClip(fClip);
             }
             // fCurrLayer may be NULL now
 
             return true;
         }
         return false;
     }
 
-    SkDevice* getDevice() const { return fDevice; }
+    SkBaseDevice* getDevice() const { return fDevice; }
     int getX() const { return fDevice->getOrigin().x(); }
     int getY() const { return fDevice->getOrigin().y(); }
     const SkMatrix& getMatrix() const { return *fMatrix; }
     const SkRegion& getClip() const { return *fClip; }
     const SkPaint* getPaint() const { return fPaint; }
 
 private:
     SkCanvas*       fCanvas;
     const DeviceCM* fCurrLayer;
     const SkPaint*  fPaint;     // May be null.
@@ skipping 146 matching lines @@
     this->predrawNotify();                                          \
     AutoDrawLooper  looper(this, paint);                            \
     while (looper.next(type)) {                                     \
         SkAutoBounderCommit ac(fBounder);                           \
         SkDrawIter          iter(this);
 
 #define LOOPER_END    }
 
 ////////////////////////////////////////////////////////////////////////////
 
-SkDevice* SkCanvas::init(SkDevice* device) {
+SkBaseDevice* SkCanvas::init(SkBaseDevice* device) {
     fBounder = NULL;
     fLocalBoundsCompareType.setEmpty();
     fLocalBoundsCompareTypeDirty = true;
     fAllowSoftClip = true;
     fAllowSimplifyClip = false;
     fDeviceCMDirty = false;
     fSaveLayerCount = 0;
     fMetaData = NULL;
 
     fMCRec = (MCRec*)fMCStack.push_back();
     new (fMCRec) MCRec(NULL, 0);
 
     fMCRec->fLayer = SkNEW_ARGS(DeviceCM, (NULL, 0, 0, NULL, NULL));
     fMCRec->fTopLayer = fMCRec->fLayer;
     fMCRec->fNext = NULL;
 
     fSurfaceBase = NULL;
 
     return this->setDevice(device);
 }
 
 SkCanvas::SkCanvas()
 : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage)) {
     inc_canvas();
 
     this->init(NULL);
 }
 
-SkCanvas::SkCanvas(SkDevice* device)
+SkCanvas::SkCanvas(SkBaseDevice* device)
         : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage)) {
     inc_canvas();
 
     this->init(device);
 }
 
 SkCanvas::SkCanvas(const SkBitmap& bitmap)
         : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage)) {
     inc_canvas();
 
-    this->init(SkNEW_ARGS(SkDevice, (bitmap)))->unref();
+    this->init(SkNEW_ARGS(SkBitmapDevice, (bitmap)))->unref();
 }
 
 SkCanvas::~SkCanvas() {
     // free up the contents of our deque
     this->restoreToCount(1);    // restore everything but the last
     SkASSERT(0 == fSaveLayerCount);
 
     this->internalRestore();    // restore the last, since we're going away
 
     SkSafeUnref(fBounder);
@@ skipping 21 matching lines @@
     // can decide to just make it a field in the device (rather than a ptr)
     if (NULL == fMetaData) {
         fMetaData = new SkMetaData;
     }
     return *fMetaData;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkCanvas::flush() {
-    SkDevice* device = this->getDevice();
+    SkBaseDevice* device = this->getDevice();
     if (device) {
         device->flush();
     }
 }
 
 SkISize SkCanvas::getDeviceSize() const {
-    SkDevice* d = this->getDevice();
+    SkBaseDevice* d = this->getDevice();
     return d ? SkISize::Make(d->width(), d->height()) : SkISize::Make(0, 0);
 }
 
-SkDevice* SkCanvas::getDevice() const {
+SkBaseDevice* SkCanvas::getDevice() const {
     // return root device
     MCRec* rec = (MCRec*) fMCStack.front();
     SkASSERT(rec && rec->fLayer);
     return rec->fLayer->fDevice;
 }
 
-SkDevice* SkCanvas::getTopDevice(bool updateMatrixClip) const {
+SkBaseDevice* SkCanvas::getTopDevice(bool updateMatrixClip) const {
     if (updateMatrixClip) {
         const_cast<SkCanvas*>(this)->updateDeviceCMCache();
     }
     return fMCRec->fTopLayer->fDevice;
 }
 
-SkDevice* SkCanvas::setDevice(SkDevice* device) {
+SkBaseDevice* SkCanvas::setDevice(SkBaseDevice* device) {
     // return root device
     SkDeque::F2BIter iter(fMCStack);
     MCRec*           rec = (MCRec*)iter.next();
     SkASSERT(rec && rec->fLayer);
-    SkDevice*       rootDevice = rec->fLayer->fDevice;
+    SkBaseDevice*    rootDevice = rec->fLayer->fDevice;
 
     if (rootDevice == device) {
         return device;
     }
 
     if (device) {
         device->onAttachToCanvas(this);
     }
     if (rootDevice) {
         rootDevice->onDetachFromCanvas();
@@ skipping 29 matching lines @@
     while ((rec = (MCRec*)iter.next()) != NULL) {
         (void)rec->fRasterClip->op(bounds, SkRegion::kIntersect_Op);
     }
 
     return device;
 }
 
 bool SkCanvas::readPixels(SkBitmap* bitmap,
                           int x, int y,
                           Config8888 config8888) {
-    SkDevice* device = this->getDevice();
+    SkBaseDevice* device = this->getDevice();
     if (!device) {
         return false;
     }
     return device->readPixels(bitmap, x, y, config8888);
 }
 
 bool SkCanvas::readPixels(const SkIRect& srcRect, SkBitmap* bitmap) {
-    SkDevice* device = this->getDevice();
+    SkBaseDevice* device = this->getDevice();
     if (!device) {
         return false;
     }
 
     SkIRect bounds;
     bounds.set(0, 0, device->width(), device->height());
     if (!bounds.intersect(srcRect)) {
         return false;
     }
 
     SkBitmap tmp;
     tmp.setConfig(SkBitmap::kARGB_8888_Config, bounds.width(),
                                                bounds.height());
     if (this->readPixels(&tmp, bounds.fLeft, bounds.fTop)) {
         bitmap->swap(tmp);
         return true;
     } else {
         return false;
     }
 }
 
 void SkCanvas::writePixels(const SkBitmap& bitmap, int x, int y,
                            Config8888 config8888) {
-    SkDevice* device = this->getDevice();
+    SkBaseDevice* device = this->getDevice();
     if (device) {
         if (SkIRect::Intersects(SkIRect::MakeSize(this->getDeviceSize()),
                                 SkIRect::MakeXYWH(x, y, bitmap.width(), bitmap.height()))) {
             device->accessBitmap(true);
             device->writePixels(bitmap, x, y, config8888);
         }
     }
 }
 
 SkCanvas* SkCanvas::canvasForDrawIter() {
@@ skipping 51 matching lines @@
                                        const SkIRect& bounds,
                                        SkCanvas::SaveFlags flags,
                                        bool* isOpaque) {
     *isOpaque = (flags & SkCanvas::kHasAlphaLayer_SaveFlag) == 0;
 
 #if 0
     // loop through and union all the configs we may draw into
     uint32_t configMask = 0;
     for (int i = canvas->countLayerDevices() - 1; i >= 0; --i)
     {
-        SkDevice* device = canvas->getLayerDevice(i);
+        SkBaseDevice* device = canvas->getLayerDevice(i);
         if (device->intersects(bounds))
             configMask |= 1 << device->config();
     }
 
     // if the caller wants alpha or fullcolor, we can't return 565
     if (flags & (SkCanvas::kFullColorLayer_SaveFlag |
                  SkCanvas::kHasAlphaLayer_SaveFlag))
         configMask &= ~C16MASK;
 
     switch (configMask) {
@@ skipping 80 matching lines @@
             }
             SkPaint* p = lazyP.set(*paint);
             p->setImageFilter(NULL);
             paint = p;
         }
     }
 
     bool isOpaque;
     SkBitmap::Config config = resolve_config(this, ir, flags, &isOpaque);
 
-    SkDevice* device;
+    SkBaseDevice* device;
     if (paint && paint->getImageFilter()) {
         device = this->createCompatibleDevice(config, ir.width(), ir.height(),
                                               isOpaque);
     } else {
         device = this->createLayerDevice(config, ir.width(), ir.height(),
                                          isOpaque);
     }
     if (NULL == device) {
         SkDebugf("Unable to create device for layer.");
         return count;
@@ skipping 111 matching lines @@
 
     LOOPER_BEGIN(*paint, SkDrawFilter::kBitmap_Type)
 
     while (iter.next()) {
         iter.fDevice->drawBitmap(iter, bitmap, matrix, looper.paint());
     }
 
     LOOPER_END
 }
 
-void SkCanvas::internalDrawDevice(SkDevice* srcDev, int x, int y,
+void SkCanvas::internalDrawDevice(SkBaseDevice* srcDev, int x, int y,
                                   const SkPaint* paint) {
     SkPaint tmp;
     if (NULL == paint) {
         tmp.setDither(true);
         paint = &tmp;
     }
 
     LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kBitmap_Type)
     while (iter.next()) {
-        SkDevice* dstDev = iter.fDevice;
+        SkBaseDevice* dstDev = iter.fDevice;
         paint = &looper.paint();
         SkImageFilter* filter = paint->getImageFilter();
         SkIPoint pos = { x - iter.getX(), y - iter.getY() };
         if (filter && !dstDev->canHandleImageFilter(filter)) {
             SkDeviceImageFilterProxy proxy(dstDev);
             SkBitmap dst;
             const SkBitmap& src = srcDev->accessBitmap(false);
             SkMatrix matrix = *iter.fMatrix;
             matrix.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y));
             if (filter->filterImage(&proxy, src, matrix, &dst, &pos)) {
@@ skipping 155 matching lines @@
             // but relaxing the test above triggers GM asserts in
             // SkRgnBuilder::blitH(). We need to investigate what's going on.
             return currClip->setPath(devPath, currClip->bwRgn(), doAA);
         } else {
             base.setRect(currClip->getBounds());
             SkRasterClip clip;
             clip.setPath(devPath, base, doAA);
             return currClip->op(clip, op);
         }
     } else {
-        const SkDevice* device = canvas->getDevice();
+        const SkBaseDevice* device = canvas->getDevice();
         if (!device) {
             return currClip->setEmpty();
         }
 
         base.setRect(0, 0, device->width(), device->height());
 
         if (SkRegion::kReplace_Op == op) {
             return currClip->setPath(devPath, base, doAA);
         } else {
             SkRasterClip clip;
@@ skipping 173 matching lines @@
     // todo: signal fClipStack that we have a region, and therefore (I guess)
     // we have to ignore it, and use the region directly?
     fClipStack.clipDevRect(rgn.getBounds(), op);
 
     return fMCRec->fRasterClip->op(rgn, op);
 }
 
 #ifdef SK_DEBUG
 void SkCanvas::validateClip() const {
     // construct clipRgn from the clipstack
-    const SkDevice* device = this->getDevice();
+    const SkBaseDevice* device = this->getDevice();
     if (!device) {
         SkASSERT(this->getTotalClip().isEmpty());
         return;
     }
 
     SkIRect ir;
     ir.set(0, 0, device->width(), device->height());
     SkRasterClip tmpClip(ir);
 
     SkClipStack::B2TIter                iter(fClipStack);
@@ skipping 164 matching lines @@
 SkCanvas::ClipType SkCanvas::getClipType() const {
     if (fMCRec->fRasterClip->isEmpty()) return kEmpty_ClipType;
     if (fMCRec->fRasterClip->isRect()) return kRect_ClipType;
     return kComplex_ClipType;
 }
 
 const SkRegion& SkCanvas::getTotalClip() const {
     return fMCRec->fRasterClip->forceGetBW();
 }
 
-SkDevice* SkCanvas::createLayerDevice(SkBitmap::Config config,
+SkBaseDevice* SkCanvas::createLayerDevice(SkBitmap::Config config,
                                       int width, int height,
                                       bool isOpaque) {
-    SkDevice* device = this->getTopDevice();
+    SkBaseDevice* device = this->getTopDevice();
     if (device) {
         return device->createCompatibleDeviceForSaveLayer(config, width, height,
                                                           isOpaque);
     } else {
         return NULL;
     }
 }
 
-SkDevice* SkCanvas::createCompatibleDevice(SkBitmap::Config config,
+SkBaseDevice* SkCanvas::createCompatibleDevice(SkBitmap::Config config,
                                            int width, int height,
                                            bool isOpaque) {
-    SkDevice* device = this->getDevice();
+    SkBaseDevice* device = this->getDevice();
     if (device) {
         return device->createCompatibleDevice(config, width, height, isOpaque);
     } else {
         return NULL;
     }
 }
 
 
 //////////////////////////////////////////////////////////////////////////////
 //  These are the virtual drawing methods
@@ skipping 295 matching lines @@
 void SkCanvas::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
                               const SkRect& dst, const SkPaint* paint) {
     SkDEBUGCODE(bitmap.validate();)
 
     // Need a device entry-point, so gpu can use a mesh
     this->internalDrawBitmapNine(bitmap, center, dst, paint);
 }
 
 class SkDeviceFilteredPaint {
 public:
-    SkDeviceFilteredPaint(SkDevice* device, const SkPaint& paint) {
-        SkDevice::TextFlags flags;
+    SkDeviceFilteredPaint(SkBaseDevice* device, const SkPaint& paint) {
+        SkBaseDevice::TextFlags flags;
         if (device->filterTextFlags(paint, &flags)) {
             SkPaint* newPaint = fLazy.set(paint);
             newPaint->setFlags(flags.fFlags);
             newPaint->setHinting(flags.fHinting);
             fPaint = newPaint;
         } else {
             fPaint = &paint;
         }
     }
 
@@ skipping 307 matching lines @@
 }
 
 SkCanvas::LayerIter::~LayerIter() {
     fImpl->~SkDrawIter();
 }
 
 void SkCanvas::LayerIter::next() {
     fDone = !fImpl->next();
 }
 
-SkDevice* SkCanvas::LayerIter::device() const {
+SkBaseDevice* SkCanvas::LayerIter::device() const {
     return fImpl->getDevice();
 }
 
 const SkMatrix& SkCanvas::LayerIter::matrix() const {
     return fImpl->getMatrix();
 }
 
 const SkPaint& SkCanvas::LayerIter::paint() const {
     const SkPaint* paint = fImpl->getPaint();
     if (NULL == paint) {
         paint = &fDefaultPaint;
     }
     return *paint;
 }
 
 const SkRegion& SkCanvas::LayerIter::clip() const { return fImpl->getClip(); }
 int SkCanvas::LayerIter::x() const { return fImpl->getX(); }
 int SkCanvas::LayerIter::y() const { return fImpl->getY(); }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkCanvas::ClipVisitor::~ClipVisitor() { }