Split SkDevice into SkBaseDevice and SkBitmapDevice

src/utils/SkPictureUtils.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 "SkPictureUtils.h"
+#include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkData.h"
-#include "SkDevice.h"
+#include "SkPictureUtils.h"
 #include "SkPixelRef.h"
+#include "SkRRect.h"
 #include "SkShader.h"
-#include "SkRRect.h"
 
 class PixelRefSet {
 public:
     PixelRefSet(SkTDArray<SkPixelRef*>* array) : fArray(array) {}
 
     // This does a linear search on existing pixelrefs, so if this list gets big
     // we should use a more complex sorted/hashy thing.
     //
     void add(SkPixelRef* pr) {
         uint32_t genID = pr->getGenerationID();
@@ skipping 15 matching lines @@
     SkDEBUGFAIL("this method should never be called");
 }
 
 static void nothing_to_do() {}
 
 /**
  *  This device will route all bitmaps (primitives and in shaders) to its PRSet.
  *  It should never actually draw anything, so there need not be any pixels
  *  behind its device-bitmap.
  */
-class GatherPixelRefDevice : public SkDevice {
+class GatherPixelRefDevice : public SkBitmapDevice {
 private:
     PixelRefSet*  fPRSet;
 
     void addBitmap(const SkBitmap& bm) {
         fPRSet->add(bm.pixelRef());
     }
 
     void addBitmapFromPaint(const SkPaint& paint) {
         SkShader* shader = paint.getShader();
         if (shader) {
             SkBitmap bm;
             // Check whether the shader is a gradient in order to short-circuit
             // call to asABitmap to prevent generation of bitmaps from
             // gradient shaders, which implement asABitmap.
             if (SkShader::kNone_GradientType == shader->asAGradient(NULL) &&
                 shader->asABitmap(&bm, NULL, NULL)) {
                 fPRSet->add(bm.pixelRef());
             }
         }
     }
 
 public:
-    GatherPixelRefDevice(const SkBitmap& bm, PixelRefSet* prset) : SkDevice(bm) {
+    GatherPixelRefDevice(const SkBitmap& bm, PixelRefSet* prset) : SkBitmapDevice(bm) {
         fPRSet = prset;
     }
 
     virtual void clear(SkColor color) SK_OVERRIDE {
         nothing_to_do();
     }
     virtual void writePixels(const SkBitmap& bitmap, int x, int y,
                              SkCanvas::Config8888 config8888) SK_OVERRIDE {
         not_supported();
     }
@@ skipping 47 matching lines @@
                                 const SkPaint& paint) SK_OVERRIDE {
         this->addBitmapFromPaint(paint);
     }
     virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
                               const SkPoint verts[], const SkPoint texs[],
                               const SkColor colors[], SkXfermode* xmode,
                               const uint16_t indices[], int indexCount,
                               const SkPaint& paint) SK_OVERRIDE {
         this->addBitmapFromPaint(paint);
     }
-    virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
+    virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
                             const SkPaint&) SK_OVERRIDE {
         nothing_to_do();
     }
 
 protected:
     virtual bool onReadPixels(const SkBitmap& bitmap,
                               int x, int y,
                               SkCanvas::Config8888 config8888) SK_OVERRIDE {
         not_supported();
         return false;
     }
+
+private:
+    typedef SkBitmapDevice INHERITED;
 };
 
 class NoSaveLayerCanvas : public SkCanvas {
 public:
-    NoSaveLayerCanvas(SkDevice* device) : INHERITED(device) {}
+    NoSaveLayerCanvas(SkBaseDevice* device) : INHERITED(device) {}
 
     // turn saveLayer() into save() for speed, should not affect correctness.
     virtual int saveLayer(const SkRect* bounds, const SkPaint* paint,
                           SaveFlags flags) SK_OVERRIDE {
 
         // Like SkPictureRecord, we don't want to create layers, but we do need
         // to respect the save and (possibly) its rect-clip.
 
         int count = this->INHERITED::save(flags);
         if (bounds) {
@@ skipping 48 matching lines @@
     canvas.clipRect(area, SkRegion::kIntersect_Op, false);
     canvas.drawPicture(*pict);
 
     SkData* data = NULL;
     int count = array.count();
     if (count > 0) {
         data = SkData::NewFromMalloc(array.detach(), count * sizeof(SkPixelRef*));
     }
     return data;
 }