Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(125)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: include/core/SkDevice.h

Issue 22978012: Split SkDevice into SkBaseDevice and SkBitmapDevice (Closed) Base URL: http://skia.googlecode.com/svn/trunk/
Patch Set: Moved code around to make code review easier Created 7 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « include/core/SkCanvas.h ('k') | include/device/xps/SkXPSDevice.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: include/core/SkDevice.h
===================================================================
--- include/core/SkDevice.h (revision 10711)
+++ include/core/SkDevice.h (working copy)
@@ -30,51 +30,15 @@
SK_DECLARE_INST_COUNT(SkDevice)
/**
- * Construct a new device with the specified bitmap as its backend. It is
- * valid for the bitmap to have no pixels associated with it. In that case,
- * any drawing to this device will have no effect.
+ * Construct a new device.
*/
- SkDevice(const SkBitmap& bitmap);
+ SkDevice();
/**
- * Construct a new device with the specified bitmap as its backend. It is
- * valid for the bitmap to have no pixels associated with it. In that case,
- * any drawing to this device will have no effect.
+ * Construct a new device.
*/
- SkDevice(const SkBitmap& bitmap, const SkDeviceProperties& deviceProperties);
+ SkDevice(const SkDeviceProperties& deviceProperties);
- /**
- * Create a new raster device and have the pixels be automatically
- * allocated. The rowBytes of the device will be computed automatically
- * based on the config and the width.
- *
- * @param config The desired config for the pixels. If the request cannot
- * be met, the closest matching support config will be used.
- * @param width width (in pixels) of the device
- * @param height height (in pixels) of the device
- * @param isOpaque Set to true if it is known that all of the pixels will
- * be drawn to opaquely. Used as an accelerator when drawing
- * these pixels to another device.
- */
- SkDevice(SkBitmap::Config config, int width, int height, bool isOpaque = false);
-
- /**
- * Create a new raster device and have the pixels be automatically
- * allocated. The rowBytes of the device will be computed automatically
- * based on the config and the width.
- *
- * @param config The desired config for the pixels. If the request cannot
- * be met, the closest matching support config will be used.
- * @param width width (in pixels) of the device
- * @param height height (in pixels) of the device
- * @param isOpaque Set to true if it is known that all of the pixels will
- * be drawn to opaquely. Used as an accelerator when drawing
- * these pixels to another device.
- * @param deviceProperties Properties which affect compositing.
- */
- SkDevice(SkBitmap::Config config, int width, int height, bool isOpaque,
- const SkDeviceProperties& deviceProperties);
-
virtual ~SkDevice();
/**
@@ -99,14 +63,14 @@
kVector_Capability = 0x2, //!< mask indicating a vector representation
kAll_Capabilities = 0x3
};
- virtual uint32_t getDeviceCapabilities() { return 0; }
+ virtual uint32_t getDeviceCapabilities() = 0;
/** Return the width of the device (in pixels).
*/
- virtual int width() const { return fBitmap.width(); }
+ virtual int width() const = 0;
/** Return the height of the device (in pixels).
*/
- virtual int height() const { return fBitmap.height(); }
+ virtual int height() const = 0;
/** Return the image properties of the device. */
virtual const SkDeviceProperties& getDeviceProperties() const {
@@ -119,16 +83,16 @@
* canvas. The root device will have its top-left at 0,0, but other devices
* such as those associated with saveLayer may have a non-zero origin.
*/
- void getGlobalBounds(SkIRect* bounds) const;
+ virtual void getGlobalBounds(SkIRect* bounds) const = 0;
/** Returns true if the device's bitmap's config treats every pixels as
implicitly opaque.
*/
- bool isOpaque() const { return fBitmap.isOpaque(); }
+ virtual bool isOpaque() const = 0;
/** Return the bitmap config of the device's pixels
*/
- SkBitmap::Config config() const { return fBitmap.getConfig(); }
+ virtual SkBitmap::Config config() const = 0;
reed1 2013/08/15 14:46:29 Can we remove this guy from the base?
robertphillips 2013/08/15 17:34:07 Done.
/** Return the bitmap associated with this device. Call this each time you need
to access the bitmap, as it notifies the subclass to perform any flushing
@@ -154,12 +118,12 @@
* not kARGB_8888_Config then this parameter is ignored.
*/
virtual void writePixels(const SkBitmap& bitmap, int x, int y,
- SkCanvas::Config8888 config8888 = SkCanvas::kNative_Premul_Config8888);
+ SkCanvas::Config8888 config8888 = SkCanvas::kNative_Premul_Config8888) = 0;
/**
* Return the device's associated gpu render target, or NULL.
*/
- virtual GrRenderTarget* accessRenderTarget() { return NULL; }
+ virtual GrRenderTarget* accessRenderTarget() = 0;
/**
@@ -215,7 +179,7 @@
*
* The baseclass SkDevice filters based on its depth and blitters.
*/
- virtual bool filterTextFlags(const SkPaint& paint, TextFlags*);
+ virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) = 0;
/**
*
@@ -234,12 +198,12 @@
* passed in).
*/
virtual void setMatrixClip(const SkMatrix&, const SkRegion&,
- const SkClipStack&);
+ const SkClipStack&) {};
/** Clears the entire device to the specified color (including alpha).
* Ignores the clip.
*/
- virtual void clear(SkColor color);
+ virtual void clear(SkColor color) = 0;
/**
* Deprecated name for clear.
@@ -251,15 +215,15 @@
and are handling any looping from the paint, and any effects from the
DrawFilter.
*/
- virtual void drawPaint(const SkDraw&, const SkPaint& paint);
+ virtual void drawPaint(const SkDraw&, const SkPaint& paint) = 0;
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
- const SkPoint[], const SkPaint& paint);
+ const SkPoint[], const SkPaint& paint) = 0;
virtual void drawRect(const SkDraw&, const SkRect& r,
- const SkPaint& paint);
+ const SkPaint& paint) = 0;
virtual void drawOval(const SkDraw&, const SkRect& oval,
- const SkPaint& paint);
+ const SkPaint& paint) = 0;
virtual void drawRRect(const SkDraw&, const SkRRect& rr,
- const SkPaint& paint);
+ const SkPaint& paint) = 0;
/**
* If pathIsMutable, then the implementation is allowed to cast path to a
@@ -275,11 +239,11 @@
virtual void drawPath(const SkDraw&, const SkPath& path,
const SkPaint& paint,
const SkMatrix* prePathMatrix = NULL,
- bool pathIsMutable = false);
+ bool pathIsMutable = false) = 0;
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
- const SkMatrix& matrix, const SkPaint& paint);
+ const SkMatrix& matrix, const SkPaint& paint) = 0;
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
- int x, int y, const SkPaint& paint);
+ int x, int y, const SkPaint& paint) = 0;
/**
* The default impl. will create a bitmap-shader from the bitmap,
@@ -287,35 +251,35 @@
*/
virtual void drawBitmapRect(const SkDraw&, const SkBitmap&,
const SkRect* srcOrNull, const SkRect& dst,
- const SkPaint& paint);
+ const SkPaint& paint) = 0;
/**
* Does not handle text decoration.
* Decorations (underline and stike-thru) will be handled by SkCanvas.
*/
virtual void drawText(const SkDraw&, const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint& paint);
+ SkScalar x, SkScalar y, const SkPaint& paint) = 0;
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], SkScalar constY,
- int scalarsPerPos, const SkPaint& paint);
+ int scalarsPerPos, const SkPaint& paint) = 0;
virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
const SkPath& path, const SkMatrix* matrix,
- const SkPaint& paint);
+ const SkPaint& paint) = 0;
#ifdef SK_BUILD_FOR_ANDROID
virtual void drawPosTextOnPath(const SkDraw& draw, const void* text, size_t len,
const SkPoint pos[], const SkPaint& paint,
- const SkPath& path, const SkMatrix* matrix);
+ const SkPath& path, const SkMatrix* matrix) = 0;
#endif
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);
+ const SkPaint& paint) = 0;
/** The SkDevice passed will be an SkDevice which was returned by a call to
onCreateCompatibleDevice on this device with kSaveLayer_Usage.
*/
virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
- const SkPaint&);
+ const SkPaint&) = 0;
/**
* On success (returns true), copy the device pixels into the bitmap.
@@ -351,21 +315,11 @@
///////////////////////////////////////////////////////////////////////////
/** Update as needed the pixel value in the bitmap, so that the caller can
- access the pixels directly. Note: only the pixels field should be
- altered. The config/width/height/rowbytes must remain unchanged.
- @param bitmap The device's bitmap
- @return Echo the bitmap parameter, or an alternate (shadow) bitmap
- maintained by the subclass.
+ access the pixels directly.
+ @return The device contents as a bitmap
*/
- virtual const SkBitmap& onAccessBitmap(SkBitmap*);
+ virtual const SkBitmap& onAccessBitmap() = 0;
- SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); }
- // just for subclasses, to assign a custom pixelref
- SkPixelRef* setPixelRef(SkPixelRef* pr, size_t offset) {
- fBitmap.setPixelRef(pr, offset);
- return pr;
- }
-
/**
* Implements readPixels API. The caller will ensure that:
* 1. bitmap has pixel config kARGB_8888_Config.
@@ -375,13 +329,13 @@
*/
virtual bool onReadPixels(const SkBitmap& bitmap,
int x, int y,
- SkCanvas::Config8888 config8888);
+ SkCanvas::Config8888 config8888) = 0;
/** Called when this device is installed into a Canvas. Balanaced by a call
to unlockPixels() when the device is removed from a Canvas.
*/
- virtual void lockPixels();
- virtual void unlockPixels();
+ virtual void lockPixels() = 0;
+ virtual void unlockPixels() = 0;
/**
* Returns true if the device allows processing of this imagefilter. If
@@ -389,7 +343,7 @@
* some subclasses that do not support pixel manipulations after drawing
* has occurred (e.g. printing). The default implementation returns true.
*/
- virtual bool allowImageFilter(SkImageFilter*);
+ virtual bool allowImageFilter(SkImageFilter*) = 0;
/**
* Override and return true for filters that the device can handle
@@ -398,7 +352,7 @@
* Returning false means the SkCanvas will have apply the filter itself,
* and just pass the resulting image to the device.
*/
- virtual bool canHandleImageFilter(SkImageFilter*);
+ virtual bool canHandleImageFilter(SkImageFilter*) = 0;
/**
* Related (but not required) to canHandleImageFilter, this method returns
@@ -408,7 +362,7 @@
* it just returns false and leaves result and offset unchanged.
*/
virtual bool filterImage(SkImageFilter*, const SkBitmap&, const SkMatrix&,
- SkBitmap* result, SkIPoint* offset);
+ SkBitmap* result, SkIPoint* offset) = 0;
// This is equal kBGRA_Premul_Config8888 or kRGBA_Premul_Config8888 if
// either is identical to kNative_Premul_Config8888. Otherwise, -1.
@@ -423,10 +377,11 @@
friend class SkDeviceImageFilterProxy;
friend class SkSurface_Raster;
+
// used to change the backend's pixels (and possibly config/rowbytes)
// but cannot change the width/height, so there should be no change to
// any clip information.
- void replaceBitmapBackendForRasterSurface(const SkBitmap&);
+ virtual void replaceBitmapBackendForRasterSurface(const SkBitmap&) = 0;
// just called by SkCanvas when built as a layer
void setOrigin(int x, int y) { fOrigin.set(x, y); }
@@ -441,13 +396,12 @@
virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
- Usage usage);
+ Usage usage) = 0;
/** Causes any deferred drawing to the device to be completed.
*/
- virtual void flush() {}
+ virtual void flush() = 0;
- SkBitmap fBitmap;
SkIPoint fOrigin;
SkMetaData* fMetaData;
/**
@@ -465,4 +419,284 @@
typedef SkRefCnt INHERITED;
};
+///////////////////////////////////////////////////////////////////////////////
+class SK_API SkRasterDevice : public SkDevice {
+public:
+ SK_DECLARE_INST_COUNT(SkRasterDevice)
+
+ /**
+ * Construct a new device with the specified bitmap as its backend. It is
+ * valid for the bitmap to have no pixels associated with it. In that case,
+ * any drawing to this device will have no effect.
+ */
+ SkRasterDevice(const SkBitmap& bitmap);
+
+ /**
+ * Construct a new device with the specified bitmap as its backend. It is
+ * valid for the bitmap to have no pixels associated with it. In that case,
+ * any drawing to this device will have no effect.
+ */
+ SkRasterDevice(const SkBitmap& bitmap, const SkDeviceProperties& deviceProperties);
+
+ /**
+ * Create a new raster device and have the pixels be automatically
+ * allocated. The rowBytes of the device will be computed automatically
+ * based on the config and the width.
+ *
+ * @param config The desired config for the pixels. If the request cannot
+ * be met, the closest matching support config will be used.
+ * @param width width (in pixels) of the device
+ * @param height height (in pixels) of the device
+ * @param isOpaque Set to true if it is known that all of the pixels will
+ * be drawn to opaquely. Used as an accelerator when drawing
+ * these pixels to another device.
+ */
+ SkRasterDevice(SkBitmap::Config config, int width, int height, bool isOpaque);
+
+ /**
+ * Create a new raster device and have the pixels be automatically
+ * allocated. The rowBytes of the device will be computed automatically
+ * based on the config and the width.
+ *
+ * @param config The desired config for the pixels. If the request cannot
+ * be met, the closest matching support config will be used.
+ * @param width width (in pixels) of the device
+ * @param height height (in pixels) of the device
+ * @param isOpaque Set to true if it is known that all of the pixels will
+ * be drawn to opaquely. Used as an accelerator when drawing
+ * these pixels to another device.
+ * @param deviceProperties Properties which affect compositing.
+ */
+ SkRasterDevice(SkBitmap::Config config, int width, int height, bool isOpaque,
+ const SkDeviceProperties& deviceProperties);
+
+ virtual ~SkRasterDevice();
+
+ virtual uint32_t getDeviceCapabilities() SK_OVERRIDE { return 0; }
+
+ /** Return the width of the device (in pixels).
+ */
+ virtual int width() const SK_OVERRIDE { return fBitmap.width(); }
+ /** Return the height of the device (in pixels).
+ */
+ virtual int height() const SK_OVERRIDE { return fBitmap.height(); }
+
+ /**
+ * Return the bounds of the device in the coordinate space of the root
+ * canvas. The root device will have its top-left at 0,0, but other devices
+ * such as those associated with saveLayer may have a non-zero origin.
+ */
+ virtual void getGlobalBounds(SkIRect* bounds) const SK_OVERRIDE;
+
+ /** Returns true if the device's bitmap's config treats every pixels as
+ implicitly opaque.
+ */
+ virtual bool isOpaque() const SK_OVERRIDE { return fBitmap.isOpaque(); }
+
+ /** Return the bitmap config of the device's pixels
+ */
+ virtual SkBitmap::Config config() const SK_OVERRIDE { return fBitmap.getConfig(); }
+
+ /**
+ * DEPRECATED: This will be made protected once WebKit stops using it.
+ * Instead use Canvas' writePixels method.
+ *
+ * Similar to draw sprite, this method will copy the pixels in bitmap onto
+ * the device, with the top/left corner specified by (x, y). The pixel
+ * values in the device are completely replaced: there is no blending.
+ *
+ * Currently if bitmap is backed by a texture this is a no-op. This may be
+ * relaxed in the future.
+ *
+ * If the bitmap has config kARGB_8888_Config then the config8888 param
+ * will determines how the pixel valuess are intepreted. If the bitmap is
+ * not kARGB_8888_Config then this parameter is ignored.
+ */
+ virtual void writePixels(const SkBitmap& bitmap, int x, int y,
+ SkCanvas::Config8888 config8888) SK_OVERRIDE;
+
+ /**
+ * Return the device's associated gpu render target, or NULL.
+ */
+ virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE { return NULL; }
+
+protected:
+ /**
+ * Device may filter the text flags for drawing text here. If it wants to
+ * make a change to the specified values, it should write them into the
+ * textflags parameter (output) and return true. If the paint is fine as
+ * is, then ignore the textflags parameter and return false.
+ *
+ * The baseclass SkDevice filters based on its depth and blitters.
+ */
+ virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) SK_OVERRIDE;
+
+ /** Clears the entire device to the specified color (including alpha).
+ * Ignores the clip.
+ */
+ virtual void clear(SkColor color) SK_OVERRIDE;
+
+ /** These are called inside the per-device-layer loop for each draw call.
+ When these are called, we have already applied any saveLayer operations,
+ and are handling any looping from the paint, and any effects from the
+ DrawFilter.
+ */
+ virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
+ virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
+ const SkPoint[], const SkPaint& paint) SK_OVERRIDE;
+ virtual void drawRect(const SkDraw&, const SkRect& r,
+ const SkPaint& paint) SK_OVERRIDE;
+ virtual void drawOval(const SkDraw&, const SkRect& oval,
+ const SkPaint& paint) SK_OVERRIDE;
+ virtual void drawRRect(const SkDraw&, const SkRRect& rr,
+ const SkPaint& paint) SK_OVERRIDE;
+
+ /**
+ * If pathIsMutable, then the implementation is allowed to cast path to a
+ * non-const pointer and modify it in place (as an optimization). Canvas
+ * may do this to implement helpers such as drawOval, by placing a temp
+ * path on the stack to hold the representation of the oval.
+ *
+ * If prePathMatrix is not null, it should logically be applied before any
+ * stroking or other effects. If there are no effects on the paint that
+ * affect the geometry/rasterization, then the pre matrix can just be
+ * pre-concated with the current matrix.
+ */
+ virtual void drawPath(const SkDraw&, const SkPath& path,
+ const SkPaint& paint,
+ const SkMatrix* prePathMatrix = NULL,
+ bool pathIsMutable = false) SK_OVERRIDE;
+ virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
+ const SkMatrix& matrix, const SkPaint& paint) SK_OVERRIDE;
+ virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
+ int x, int y, const SkPaint& paint) SK_OVERRIDE;
+
+ /**
+ * The default impl. will create a bitmap-shader from the bitmap,
+ * and call drawRect with it.
+ */
+ virtual void drawBitmapRect(const SkDraw&, const SkBitmap&,
+ const SkRect* srcOrNull, const SkRect& dst,
+ const SkPaint& paint) SK_OVERRIDE;
+
+ /**
+ * Does not handle text decoration.
+ * Decorations (underline and stike-thru) will be handled by SkCanvas.
+ */
+ virtual void drawText(const SkDraw&, const void* text, size_t len,
+ SkScalar x, SkScalar y, const SkPaint& paint) SK_OVERRIDE;
+ virtual void drawPosText(const SkDraw&, const void* text, size_t len,
+ const SkScalar pos[], SkScalar constY,
+ int scalarsPerPos, const SkPaint& paint) SK_OVERRIDE;
+ virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
+ const SkPath& path, const SkMatrix* matrix,
+ const SkPaint& paint) SK_OVERRIDE;
+#ifdef SK_BUILD_FOR_ANDROID
+ virtual void drawPosTextOnPath(const SkDraw& draw, const void* text, size_t len,
+ const SkPoint pos[], const SkPaint& paint,
+ const SkPath& path, const SkMatrix* matrix) SK_OVERRIDE;
#endif
+ 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;
+ /** The SkDevice passed will be an SkDevice which was returned by a call to
+ onCreateCompatibleDevice on this device with kSaveLayer_Usage.
+ */
+ virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
+ const SkPaint&) SK_OVERRIDE;
+
+ ///////////////////////////////////////////////////////////////////////////
+
+ /** Update as needed the pixel value in the bitmap, so that the caller can
+ access the pixels directly. Note: only the pixels field should be
+ altered. The config/width/height/rowbytes must remain unchanged.
+ @return the device contents as a bitmap
+ */
+ virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE;
+
+ SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); }
+ // just for subclasses, to assign a custom pixelref
+ SkPixelRef* setPixelRef(SkPixelRef* pr, size_t offset) {
+ fBitmap.setPixelRef(pr, offset);
+ return pr;
+ }
+
+ /**
+ * Implements readPixels API. The caller will ensure that:
+ * 1. bitmap has pixel config kARGB_8888_Config.
+ * 2. bitmap has pixels.
+ * 3. The rectangle (x, y, x + bitmap->width(), y + bitmap->height()) is
+ * contained in the device bounds.
+ */
+ virtual bool onReadPixels(const SkBitmap& bitmap,
+ int x, int y,
+ SkCanvas::Config8888 config8888) SK_OVERRIDE;
+
+ /** Called when this device is installed into a Canvas. Balanced by a call
+ to unlockPixels() when the device is removed from a Canvas.
+ */
+ virtual void lockPixels() SK_OVERRIDE;
+ virtual void unlockPixels() SK_OVERRIDE;
+
+ /**
+ * Returns true if the device allows processing of this imagefilter. If
+ * false is returned, then the filter is ignored. This may happen for
+ * some subclasses that do not support pixel manipulations after drawing
+ * has occurred (e.g. printing). The default implementation returns true.
+ */
+ virtual bool allowImageFilter(SkImageFilter*) SK_OVERRIDE;
+
+ /**
+ * Override and return true for filters that the device can handle
+ * intrinsically. Doing so means that SkCanvas will pass-through this
+ * filter to drawSprite and drawDevice (and potentially filterImage).
+ * Returning false means the SkCanvas will have apply the filter itself,
+ * and just pass the resulting image to the device.
+ */
+ virtual bool canHandleImageFilter(SkImageFilter*) SK_OVERRIDE;
+
+ /**
+ * Related (but not required) to canHandleImageFilter, this method returns
+ * true if the device could apply the filter to the src bitmap and return
+ * the result (and updates offset as needed).
+ * If the device does not recognize or support this filter,
+ * it just returns false and leaves result and offset unchanged.
+ */
+ virtual bool filterImage(SkImageFilter*, const SkBitmap&, const SkMatrix&,
+ SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
+
+private:
+ friend class SkCanvas;
+ friend struct DeviceCM; //for setMatrixClip
+ friend class SkDraw;
+ friend class SkDrawIter;
+ friend class SkDeviceFilteredPaint;
+ friend class SkDeviceImageFilterProxy;
+
+ friend class SkSurface_Raster;
+
+ // used to change the backend's pixels (and possibly config/rowbytes)
+ // but cannot change the width/height, so there should be no change to
+ // any clip information.
+ virtual void replaceBitmapBackendForRasterSurface(const SkBitmap&) SK_OVERRIDE;
+
+ /**
+ * Subclasses should override this to implement createCompatibleDevice.
+ */
+ virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config,
+ int width, int height,
+ bool isOpaque,
+ Usage usage) SK_OVERRIDE;
+
+ /** Causes any deferred drawing to the device to be completed.
+ */
+ virtual void flush() SK_OVERRIDE {}
+
+ SkBitmap fBitmap;
+
+ typedef SkDevice INHERITED;
+};
+
+#endif
« no previous file with comments | « include/core/SkCanvas.h ('k') | include/device/xps/SkXPSDevice.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698