support direct writing to top layer, and hide getTopLayer()
this should remove many of the chrome callers that today call
accessBitmap on the toplayer, so they can read/write those pixels.
The ultimate fix will be to support custom allocation of raster layers
(via GDI/cairo/mac) so we can remove PlatformDevice subclassing in
skia/ext
BUG=skia:
R=bsalomon@google.com, scroggo@google.com
Review URL: https://codereview.chromium.org/197433002
git-svn-id: http://skia.googlecode.com/svn/trunk@13774 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp
index aebf6fb..e80853c 100644
--- a/gm/beziereffects.cpp
+++ b/gm/beziereffects.cpp
@@ -60,8 +60,7 @@
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- SkBaseDevice* device = canvas->getTopDevice();
- GrRenderTarget* rt = device->accessRenderTarget();
+ GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
if (NULL == rt) {
return;
}
@@ -219,8 +218,7 @@
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- SkBaseDevice* device = canvas->getTopDevice();
- GrRenderTarget* rt = device->accessRenderTarget();
+ GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
if (NULL == rt) {
return;
}
@@ -411,8 +409,7 @@
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- SkBaseDevice* device = canvas->getTopDevice();
- GrRenderTarget* rt = device->accessRenderTarget();
+ GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
if (NULL == rt) {
return;
}
diff --git a/gm/convexpolyeffect.cpp b/gm/convexpolyeffect.cpp
index ac8ec72..4e79500 100644
--- a/gm/convexpolyeffect.cpp
+++ b/gm/convexpolyeffect.cpp
@@ -103,8 +103,7 @@
}
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
- SkBaseDevice* device = canvas->getTopDevice();
- GrRenderTarget* rt = device->accessRenderTarget();
+ GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
if (NULL == rt) {
return;
}
diff --git a/gm/rrects.cpp b/gm/rrects.cpp
index a79ff54..6c63af9 100644
--- a/gm/rrects.cpp
+++ b/gm/rrects.cpp
@@ -66,12 +66,8 @@
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
#if SK_SUPPORT_GPU
- SkBaseDevice* device = canvas->getTopDevice();
- GrContext* context = NULL;
- GrRenderTarget* rt = device->accessRenderTarget();
- if (NULL != rt) {
- context = rt->getContext();
- }
+ GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
+ GrContext* context = rt ? rt->getContext() : NULL;
if (kEffect_Type == fType && NULL == context) {
return;
}
diff --git a/gm/texdata.cpp b/gm/texdata.cpp
index a87684e..72735a1 100644
--- a/gm/texdata.cpp
+++ b/gm/texdata.cpp
@@ -14,7 +14,6 @@
#include "GrContext.h"
#include "effects/GrSimpleTextureEffect.h"
#include "SkColorPriv.h"
-#include "SkDevice.h"
namespace skiagm {
@@ -38,8 +37,7 @@
virtual uint32_t onGetFlags() const SK_OVERRIDE { return kGPUOnly_Flag; }
virtual void onDraw(SkCanvas* canvas) {
- SkBaseDevice* device = canvas->getTopDevice();
- GrRenderTarget* target = device->accessRenderTarget();
+ GrRenderTarget* target = canvas->internal_private_accessTopLayerRenderTarget();
GrContext* ctx = canvas->getGrContext();
if (ctx && target) {
SkAutoTArray<SkPMColor> gTextureData((2 * S) * (2 * S));
diff --git a/gyp/skia_for_chromium_defines.gypi b/gyp/skia_for_chromium_defines.gypi
index d5a4b12..c85d706 100644
--- a/gyp/skia_for_chromium_defines.gypi
+++ b/gyp/skia_for_chromium_defines.gypi
@@ -18,6 +18,7 @@
'SK_SUPPORT_LEGACY_WRITEPIXELSCONFIG',
'SK_SUPPORT_LEGACY_GETCLIPTYPE',
'SK_SUPPORT_LEGACY_GETTOTALCLIP',
+ 'SK_SUPPORT_LEGACY_GETTOPDEVICE',
],
},
}
diff --git a/include/core/SkBitmapDevice.h b/include/core/SkBitmapDevice.h
index a345071..5505042 100644
--- a/include/core/SkBitmapDevice.h
+++ b/include/core/SkBitmapDevice.h
@@ -218,6 +218,7 @@
*/
virtual bool onReadPixels(const SkBitmap&, int x, int y, SkCanvas::Config8888) SK_OVERRIDE;
virtual bool onWritePixels(const SkImageInfo&, const void*, size_t, int, int) SK_OVERRIDE;
+ virtual void* onAccessPixels(SkImageInfo* info, size_t* rowBytes) 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.
diff --git a/include/core/SkCanvas.h b/include/core/SkCanvas.h
index 773df89..5ac137d 100644
--- a/include/core/SkCanvas.h
+++ b/include/core/SkCanvas.h
@@ -25,6 +25,7 @@
//#define SK_SUPPORT_LEGACY_WRITEPIXELSCONFIG
//#define SK_SUPPORT_LEGACY_GETCLIPTYPE
//#define SK_SUPPORT_LEGACY_GETTOTALCLIP
+//#define SK_SUPPORT_LEGACY_GETTOPDEVICE
class SkBounder;
class SkBaseDevice;
@@ -36,6 +37,7 @@
class SkSurface;
class SkSurface_Base;
class GrContext;
+class GrRenderTarget;
/** \class SkCanvas
@@ -159,7 +161,11 @@
* is drawn to, but is optional here, as there is a small perf hit
* sometimes.
*/
+#ifndef SK_SUPPORT_LEGACY_GETTOPDEVICE
+private:
+#endif
SkBaseDevice* getTopDevice(bool updateMatrixClip = false) const;
+public:
/**
* Create a new surface matching the specified info, one that attempts to
@@ -176,8 +182,22 @@
///////////////////////////////////////////////////////////////////////////
/**
- * If the canvas has pixels (and is not recording to a picture or other
- * non-raster target) and has direct access to its pixels (i.e. they are in
+ * If the canvas has writable pixels in its top layer (and is not recording to a picture
+ * or other non-raster target) and has direct access to its pixels (i.e. they are in
+ * local RAM) return the address of those pixels, and if not null,
+ * return the ImageInfo and rowBytes. The returned address is only valid
+ * while the canvas object is in scope and unchanged. Any API calls made on
+ * canvas (or its parent surface if any) will invalidate the
+ * returned address (and associated information).
+ *
+ * On failure, returns NULL and the info and rowBytes parameters are
+ * ignored.
+ */
+ void* accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes);
+
+ /**
+ * If the canvas has readable pixels in its base layer (and is not recording to a picture
+ * or other non-raster target) and has direct access to its pixels (i.e. they are in
* local RAM) return the const-address of those pixels, and if not null,
* return the ImageInfo and rowBytes. The returned address is only valid
* while the canvas object is in scope and unchanged. Any API calls made on
@@ -1170,6 +1190,8 @@
const SkRegion& internal_private_getTotalClip() const;
// don't call
void internal_private_getTotalClipAsPath(SkPath*) const;
+ // don't call
+ GrRenderTarget* internal_private_accessTopLayerRenderTarget();
protected:
// default impl defers to getDevice()->newSurface(info)
@@ -1177,6 +1199,7 @@
// default impl defers to its device
virtual const void* onPeekPixels(SkImageInfo*, size_t* rowBytes);
+ virtual void* onAccessTopLayerPixels(SkImageInfo*, size_t* rowBytes);
virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&);
@@ -1243,9 +1266,10 @@
bool fDeviceCMDirty; // cleared by updateDeviceCMCache()
void updateDeviceCMCache();
- friend class SkDrawIter; // needs setupDrawForLayerDevice()
+ friend class SkDrawIter; // needs setupDrawForLayerDevice()
friend class AutoDrawLooper;
- friend class SkLua; // needs top layer size and offset
+ friend class SkLua; // needs top layer size and offset
+ friend class SkDeferredDevice; // needs getTopDevice()
SkBaseDevice* createLayerDevice(const SkImageInfo&);
diff --git a/include/core/SkDevice.h b/include/core/SkDevice.h
index 90bdfa3..b3be780 100644
--- a/include/core/SkDevice.h
+++ b/include/core/SkDevice.h
@@ -138,6 +138,8 @@
bool writePixelsDirect(const SkImageInfo&, const void*, size_t rowBytes, int x, int y);
+ void* accessPixels(SkImageInfo* info, size_t* rowBytes);
+
/**
* Return the device's associated gpu render target, or NULL.
*/
@@ -400,6 +402,11 @@
virtual bool onWritePixels(const SkImageInfo&, const void*, size_t, int x, int y);
/**
+ * Default impl returns NULL.
+ */
+ virtual void* onAccessPixels(SkImageInfo* info, size_t* rowBytes);
+
+ /**
* Leaky properties are those which the device should be applying but it isn't.
* These properties will be applied by the draw, when and as it can.
* If the device does handle a property, that property should be set to the identity value
@@ -414,7 +421,7 @@
friend class SkDrawIter;
friend class SkDeviceFilteredPaint;
friend class SkDeviceImageFilterProxy;
- friend class DeferredDevice; // for newSurface
+ friend class SkDeferredDevice; // for newSurface
friend class SkSurface_Raster;
diff --git a/include/utils/SkDeferredCanvas.h b/include/utils/SkDeferredCanvas.h
index b26ddbc..e82cad3 100644
--- a/include/utils/SkDeferredCanvas.h
+++ b/include/utils/SkDeferredCanvas.h
@@ -11,7 +11,7 @@
#include "SkCanvas.h"
#include "SkPixelRef.h"
-class DeferredDevice;
+class SkDeferredDevice;
class SkImage;
class SkSurface;
@@ -236,10 +236,10 @@
protected:
virtual SkCanvas* canvasForDrawIter();
- DeferredDevice* getDeferredDevice() const;
+ SkDeferredDevice* getDeferredDevice() const;
private:
- SkDeferredCanvas(DeferredDevice*);
+ SkDeferredCanvas(SkDeferredDevice*);
void recordedDrawCommand();
SkCanvas* drawingCanvas() const;
diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp
index 098f0fc..8524f0b 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -268,6 +268,15 @@
}
#endif
+void* SkBitmapDevice::onAccessPixels(SkImageInfo* info, size_t* rowBytes) {
+ if (fBitmap.getPixels()) {
+ *info = fBitmap.info();
+ *rowBytes = fBitmap.rowBytes();
+ return fBitmap.getPixels();
+ }
+ return NULL;
+}
+
static void rect_memcpy(void* dst, size_t dstRB, const void* src, size_t srcRB, size_t bytesPerRow,
int rowCount) {
SkASSERT(bytesPerRow <= srcRB);
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 9fbb37b..4086291 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -1040,6 +1040,15 @@
return dev ? dev->peekPixels(info, rowBytes) : NULL;
}
+void* SkCanvas::accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes) {
+ return this->onAccessTopLayerPixels(info, rowBytes);
+}
+
+void* SkCanvas::onAccessTopLayerPixels(SkImageInfo* info, size_t* rowBytes) {
+ SkBaseDevice* dev = this->getTopDevice();
+ return dev ? dev->accessPixels(info, rowBytes) : NULL;
+}
+
SkAutoROCanvasPixels::SkAutoROCanvasPixels(SkCanvas* canvas) {
fAddr = canvas->peekPixels(&fInfo, &fRowBytes);
if (NULL == fAddr) {
@@ -1713,6 +1722,11 @@
(void)rgn.getBoundaryPath(path);
}
+GrRenderTarget* SkCanvas::internal_private_accessTopLayerRenderTarget() {
+ SkBaseDevice* dev = this->getTopDevice();
+ return dev ? dev->accessRenderTarget() : NULL;
+}
+
SkBaseDevice* SkCanvas::createLayerDevice(const SkImageInfo& info) {
SkBaseDevice* device = this->getTopDevice();
return device ? device->createCompatibleDeviceForSaveLayer(info) : NULL;
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index 666e456..5871813 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -194,6 +194,22 @@
return false;
}
+void* SkBaseDevice::accessPixels(SkImageInfo* info, size_t* rowBytes) {
+ SkImageInfo tmpInfo;
+ size_t tmpRowBytes;
+ if (NULL == info) {
+ info = &tmpInfo;
+ }
+ if (NULL == rowBytes) {
+ rowBytes = &tmpRowBytes;
+ }
+ return this->onAccessPixels(info, rowBytes);
+}
+
+void* SkBaseDevice::onAccessPixels(SkImageInfo* info, size_t* rowBytes) {
+ return NULL;
+}
+
#ifdef SK_SUPPORT_LEGACY_WRITEPIXELSCONFIG
void SkBaseDevice::writePixels(const SkBitmap&, int x, int y, SkCanvas::Config8888) {}
#endif
diff --git a/src/utils/SkDeferredCanvas.cpp b/src/utils/SkDeferredCanvas.cpp
index efe7501..31d62bb 100644
--- a/src/utils/SkDeferredCanvas.cpp
+++ b/src/utils/SkDeferredCanvas.cpp
@@ -133,12 +133,12 @@
}
//-----------------------------------------------------------------------------
-// DeferredDevice
+// SkDeferredDevice
//-----------------------------------------------------------------------------
-class DeferredDevice : public SkBaseDevice {
+class SkDeferredDevice : public SkBaseDevice {
public:
- explicit DeferredDevice(SkSurface* surface);
- ~DeferredDevice();
+ explicit SkDeferredDevice(SkSurface* surface);
+ ~SkDeferredDevice();
void setNotificationClient(SkDeferredCanvas::NotificationClient* notificationClient);
SkCanvas* recordingCanvas();
@@ -277,7 +277,7 @@
size_t fBitmapSizeThreshold;
};
-DeferredDevice::DeferredDevice(SkSurface* surface) {
+SkDeferredDevice::SkDeferredDevice(SkSurface* surface) {
fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
fNotificationClient = NULL;
fImmediateCanvas = NULL;
@@ -286,13 +286,13 @@
this->init();
}
-void DeferredDevice::setSurface(SkSurface* surface) {
+void SkDeferredDevice::setSurface(SkSurface* surface) {
SkRefCnt_SafeAssign(fImmediateCanvas, surface->getCanvas());
SkRefCnt_SafeAssign(fSurface, surface);
fPipeController.setPlaybackCanvas(fImmediateCanvas);
}
-void DeferredDevice::init() {
+void SkDeferredDevice::init() {
fRecordingCanvas = NULL;
fFreshFrame = true;
fCanDiscardCanvasContents = false;
@@ -303,29 +303,29 @@
this->beginRecording();
}
-DeferredDevice::~DeferredDevice() {
+SkDeferredDevice::~SkDeferredDevice() {
this->flushPendingCommands(kSilent_PlaybackMode);
SkSafeUnref(fImmediateCanvas);
SkSafeUnref(fSurface);
}
-void DeferredDevice::setMaxRecordingStorage(size_t maxStorage) {
+void SkDeferredDevice::setMaxRecordingStorage(size_t maxStorage) {
fMaxRecordingStorageBytes = maxStorage;
this->recordingCanvas(); // Accessing the recording canvas applies the new limit.
}
-void DeferredDevice::beginRecording() {
+void SkDeferredDevice::beginRecording() {
SkASSERT(NULL == fRecordingCanvas);
fRecordingCanvas = fPipeWriter.startRecording(&fPipeController, 0,
immediateDevice()->width(), immediateDevice()->height());
}
-void DeferredDevice::setNotificationClient(
+void SkDeferredDevice::setNotificationClient(
SkDeferredCanvas::NotificationClient* notificationClient) {
fNotificationClient = notificationClient;
}
-void DeferredDevice::skipPendingCommands() {
+void SkDeferredDevice::skipPendingCommands() {
if (!fRecordingCanvas->isDrawingToLayer()) {
fCanDiscardCanvasContents = true;
if (fPipeController.hasPendingCommands()) {
@@ -338,17 +338,17 @@
}
}
-bool DeferredDevice::isFreshFrame() {
+bool SkDeferredDevice::isFreshFrame() {
bool ret = fFreshFrame;
fFreshFrame = false;
return ret;
}
-bool DeferredDevice::hasPendingCommands() {
+bool SkDeferredDevice::hasPendingCommands() {
return fPipeController.hasPendingCommands();
}
-void DeferredDevice::aboutToDraw()
+void SkDeferredDevice::aboutToDraw()
{
if (NULL != fNotificationClient) {
fNotificationClient->prepareForDraw();
@@ -361,7 +361,7 @@
}
}
-void DeferredDevice::flushPendingCommands(PlaybackMode playbackMode) {
+void SkDeferredDevice::flushPendingCommands(PlaybackMode playbackMode) {
if (!fPipeController.hasPendingCommands()) {
return;
}
@@ -376,31 +376,31 @@
fPreviousStorageAllocated = storageAllocatedForRecording();
}
-void DeferredDevice::flush() {
+void SkDeferredDevice::flush() {
this->flushPendingCommands(kNormal_PlaybackMode);
fImmediateCanvas->flush();
}
-size_t DeferredDevice::freeMemoryIfPossible(size_t bytesToFree) {
+size_t SkDeferredDevice::freeMemoryIfPossible(size_t bytesToFree) {
size_t val = fPipeWriter.freeMemoryIfPossible(bytesToFree);
fPreviousStorageAllocated = storageAllocatedForRecording();
return val;
}
-size_t DeferredDevice::getBitmapSizeThreshold() const {
+size_t SkDeferredDevice::getBitmapSizeThreshold() const {
return fBitmapSizeThreshold;
}
-void DeferredDevice::setBitmapSizeThreshold(size_t sizeThreshold) {
+void SkDeferredDevice::setBitmapSizeThreshold(size_t sizeThreshold) {
fBitmapSizeThreshold = sizeThreshold;
}
-size_t DeferredDevice::storageAllocatedForRecording() const {
+size_t SkDeferredDevice::storageAllocatedForRecording() const {
return (fPipeController.storageAllocatedForRecording()
+ fPipeWriter.storageAllocatedForRecording());
}
-void DeferredDevice::recordedDrawCommand() {
+void SkDeferredDevice::recordedDrawCommand() {
size_t storageAllocated = this->storageAllocatedForRecording();
if (storageAllocated > fMaxRecordingStorageBytes) {
@@ -423,45 +423,45 @@
}
}
-SkCanvas* DeferredDevice::recordingCanvas() {
+SkCanvas* SkDeferredDevice::recordingCanvas() {
return fRecordingCanvas;
}
-SkImage* DeferredDevice::newImageSnapshot() {
+SkImage* SkDeferredDevice::newImageSnapshot() {
this->flush();
return fSurface ? fSurface->newImageSnapshot() : NULL;
}
-uint32_t DeferredDevice::getDeviceCapabilities() {
+uint32_t SkDeferredDevice::getDeviceCapabilities() {
return immediateDevice()->getDeviceCapabilities();
}
-int DeferredDevice::width() const {
+int SkDeferredDevice::width() const {
return immediateDevice()->width();
}
-int DeferredDevice::height() const {
+int SkDeferredDevice::height() const {
return immediateDevice()->height();
}
-SkBitmap::Config DeferredDevice::config() const {
+SkBitmap::Config SkDeferredDevice::config() const {
return immediateDevice()->config();
}
-bool DeferredDevice::isOpaque() const {
+bool SkDeferredDevice::isOpaque() const {
return immediateDevice()->isOpaque();
}
-SkImageInfo DeferredDevice::imageInfo() const {
+SkImageInfo SkDeferredDevice::imageInfo() const {
return immediateDevice()->imageInfo();
}
-GrRenderTarget* DeferredDevice::accessRenderTarget() {
+GrRenderTarget* SkDeferredDevice::accessRenderTarget() {
this->flushPendingCommands(kNormal_PlaybackMode);
return immediateDevice()->accessRenderTarget();
}
-void DeferredDevice::prepareForImmediatePixelWrite() {
+void SkDeferredDevice::prepareForImmediatePixelWrite() {
// The purpose of the following code is to make sure commands are flushed, that
// aboutToDraw() is called and that notifyContentWillChange is called, without
// calling anything redundantly.
@@ -479,7 +479,7 @@
}
#ifdef SK_SUPPORT_LEGACY_WRITEPIXELSCONFIG
-void DeferredDevice::writePixels(const SkBitmap& bitmap, int x, int y,
+void SkDeferredDevice::writePixels(const SkBitmap& bitmap, int x, int y,
SkCanvas::Config8888 config8888) {
if (x <= 0 && y <= 0 && (x + bitmap.width()) >= width() &&
@@ -509,7 +509,7 @@
}
#endif
-bool DeferredDevice::onWritePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes,
+bool SkDeferredDevice::onWritePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes,
int x, int y) {
SkASSERT(x >= 0 && y >= 0);
SkASSERT(x + info.width() <= width());
@@ -526,27 +526,27 @@
return immediateDevice()->onWritePixels(info, pixels, rowBytes, x, y);
}
-const SkBitmap& DeferredDevice::onAccessBitmap() {
+const SkBitmap& SkDeferredDevice::onAccessBitmap() {
this->flushPendingCommands(kNormal_PlaybackMode);
return immediateDevice()->accessBitmap(false);
}
-SkBaseDevice* DeferredDevice::onCreateDevice(const SkImageInfo& info, Usage usage) {
+SkBaseDevice* SkDeferredDevice::onCreateDevice(const SkImageInfo& info, Usage usage) {
// Save layer usage not supported, and not required by SkDeferredCanvas.
SkASSERT(usage != kSaveLayer_Usage);
// Create a compatible non-deferred device.
// We do not create a deferred device because we know the new device
// will not be used with a deferred canvas (there is no API for that).
- // And connecting a DeferredDevice to non-deferred canvas can result
+ // And connecting a SkDeferredDevice to non-deferred canvas can result
// in unpredictable behavior.
return immediateDevice()->createCompatibleDevice(info);
}
-SkSurface* DeferredDevice::newSurface(const SkImageInfo& info) {
+SkSurface* SkDeferredDevice::newSurface(const SkImageInfo& info) {
return this->immediateDevice()->newSurface(info);
}
-bool DeferredDevice::onReadPixels(
+bool SkDeferredDevice::onReadPixels(
const SkBitmap& bitmap, int x, int y, SkCanvas::Config8888 config8888) {
this->flushPendingCommands(kNormal_PlaybackMode);
return fImmediateCanvas->readPixels(const_cast<SkBitmap*>(&bitmap),
@@ -572,7 +572,7 @@
private:
void init(SkDeferredCanvas& canvas, const SkBitmap* bitmap, const SkPaint* paint)
{
- DeferredDevice* device = static_cast<DeferredDevice*>(canvas.getDevice());
+ SkDeferredDevice* device = static_cast<SkDeferredDevice*>(canvas.getDevice());
if (canvas.isDeferredDrawing() && (NULL != device) &&
shouldDrawImmediately(bitmap, paint, device->getBitmapSizeThreshold())) {
canvas.setDeferredDrawing(false);
@@ -586,11 +586,11 @@
};
SkDeferredCanvas* SkDeferredCanvas::Create(SkSurface* surface) {
- SkAutoTUnref<DeferredDevice> deferredDevice(SkNEW_ARGS(DeferredDevice, (surface)));
+ SkAutoTUnref<SkDeferredDevice> deferredDevice(SkNEW_ARGS(SkDeferredDevice, (surface)));
return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice));
}
-SkDeferredCanvas::SkDeferredCanvas(DeferredDevice* device) : SkCanvas (device) {
+SkDeferredCanvas::SkDeferredCanvas(SkDeferredDevice* device) : SkCanvas (device) {
this->init();
}
@@ -612,7 +612,7 @@
}
void SkDeferredCanvas::setBitmapSizeThreshold(size_t sizeThreshold) {
- DeferredDevice* deferredDevice = this->getDeferredDevice();
+ SkDeferredDevice* deferredDevice = this->getDeferredDevice();
SkASSERT(deferredDevice);
deferredDevice->setBitmapSizeThreshold(sizeThreshold);
}
@@ -638,8 +638,8 @@
return this->getDeferredDevice()->immediateCanvas();
}
-DeferredDevice* SkDeferredCanvas::getDeferredDevice() const {
- return static_cast<DeferredDevice*>(this->getDevice());
+SkDeferredDevice* SkDeferredCanvas::getDeferredDevice() const {
+ return static_cast<SkDeferredDevice*>(this->getDevice());
}
void SkDeferredCanvas::setDeferredDrawing(bool val) {
@@ -675,7 +675,7 @@
}
SkSurface* SkDeferredCanvas::setSurface(SkSurface* surface) {
- DeferredDevice* deferredDevice = this->getDeferredDevice();
+ SkDeferredDevice* deferredDevice = this->getDeferredDevice();
SkASSERT(NULL != deferredDevice);
// By swapping the surface into the existing device, we preserve
// all pending commands, which can help to seamlessly recover from
@@ -687,7 +687,7 @@
SkDeferredCanvas::NotificationClient* SkDeferredCanvas::setNotificationClient(
NotificationClient* notificationClient) {
- DeferredDevice* deferredDevice = this->getDeferredDevice();
+ SkDeferredDevice* deferredDevice = this->getDeferredDevice();
SkASSERT(deferredDevice);
if (deferredDevice) {
deferredDevice->setNotificationClient(notificationClient);
@@ -696,7 +696,7 @@
}
SkImage* SkDeferredCanvas::newImageSnapshot() {
- DeferredDevice* deferredDevice = this->getDeferredDevice();
+ SkDeferredDevice* deferredDevice = this->getDeferredDevice();
SkASSERT(deferredDevice);
return deferredDevice ? deferredDevice->newImageSnapshot() : NULL;
}