void setNotificationClient(SkDeferredCanvas::NotificationClient* notificationClient);
SkCanvas* recordingCanvas();
SkCanvas* immediateCanvas() const {return fImmediateCanvas;}
- SkDevice* immediateDevice() const {return fImmediateDevice;}
+ SkDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice();}
SkImage* newImageSnapshot();
bool isFreshFrame();
bool hasPendingCommands();
DeferredPipeController fPipeController;
SkGPipeWriter fPipeWriter;
- SkDevice* fImmediateDevice;
SkCanvas* fImmediateCanvas;
SkCanvas* fRecordingCanvas;
SkSurface* fSurface;
immediateDevice->isOpaque(),
immediateDevice->getDeviceProperties()) {
fSurface = NULL;
- fImmediateDevice = immediateDevice; // ref counted via fImmediateCanvas
- fImmediateCanvas = SkNEW_ARGS(SkCanvas, (fImmediateDevice));
+ fImmediateCanvas = SkNEW_ARGS(SkCanvas, (immediateDevice));
this->init();
}
SkSafeRef(fImmediateCanvas);
fSurface = surface;
SkSafeRef(fSurface);
- fImmediateDevice = fImmediateCanvas->getDevice(); // ref counted via fImmediateCanvas
this->init();
}
void DeferredDevice::beginRecording() {
SkASSERT(NULL == fRecordingCanvas);
fRecordingCanvas = fPipeWriter.startRecording(&fPipeController, 0,
- fImmediateDevice->width(), fImmediateDevice->height());
+ immediateDevice()->width(), immediateDevice()->height());
}
void DeferredDevice::setNotificationClient(
}
uint32_t DeferredDevice::getDeviceCapabilities() {
- return fImmediateDevice->getDeviceCapabilities();
+ return immediateDevice()->getDeviceCapabilities();
}
int DeferredDevice::width() const {
- return fImmediateDevice->width();
+ return immediateDevice()->width();
}
int DeferredDevice::height() const {
- return fImmediateDevice->height();
+ return immediateDevice()->height();
}
SkGpuRenderTarget* DeferredDevice::accessRenderTarget() {
this->flushPendingCommands(kNormal_PlaybackMode);
- return fImmediateDevice->accessRenderTarget();
+ return immediateDevice()->accessRenderTarget();
}
void DeferredDevice::writePixels(const SkBitmap& bitmap,
kPMColorAlias != config8888) {
//Special case config: no deferral
this->flushPendingCommands(kNormal_PlaybackMode);
- fImmediateDevice->writePixels(bitmap, x, y, config8888);
+ immediateDevice()->writePixels(bitmap, x, y, config8888);
return;
}
const SkBitmap& DeferredDevice::onAccessBitmap(SkBitmap*) {
this->flushPendingCommands(kNormal_PlaybackMode);
- return fImmediateDevice->accessBitmap(false);
+ return immediateDevice()->accessBitmap(false);
}
SkDevice* DeferredDevice::onCreateCompatibleDevice(
SkASSERT(usage != kSaveLayer_Usage);
// Create a compatible non-deferred device.
SkAutoTUnref<SkDevice> compatibleDevice
- (fImmediateDevice->createCompatibleDevice(config, width, height,
+ (immediateDevice()->createCompatibleDevice(config, width, height,
isOpaque));
DeferredDevice* device = SkNEW_ARGS(DeferredDevice, (compatibleDevice));
device->setNotificationClient(fNotificationClient);
// write
PixelPtr pixels2 = getSurfacePixelPtr(surface, useGpu);
REPORTER_ASSERT(reporter, pixels1 != pixels2);
- canvas.clear(SK_ColorWHITE);
- canvas.flush();
+ // Verify copy-on write with a draw operation that gets deferred by
+ // the in order draw buffer.
+ SkPaint paint;
+ canvas.drawPaint(paint);
+ SkImage* image4 = canvas.newImageSnapshot(); // implicit flush
+ SkAutoTUnref<SkImage> aur_i4(image4);
+ REPORTER_ASSERT(reporter, image4->uniqueID() != image3->uniqueID());
PixelPtr pixels3 = getSurfacePixelPtr(surface, useGpu);
+ REPORTER_ASSERT(reporter, pixels2 != pixels3);
// Verify that a direct canvas flush with a pending draw does not trigger
// a copy on write when the surface is not sharing its buffer with an
// SkImage.
- canvas.clear(SK_ColorBLACK);
+ canvas.clear(SK_ColorWHITE);
canvas.flush();
PixelPtr pixels4 = getSurfacePixelPtr(surface, useGpu);
- REPORTER_ASSERT(reporter, pixels3 == pixels4);
+ canvas.drawPaint(paint);
+ canvas.flush();
+ PixelPtr pixels5 = getSurfacePixelPtr(surface, useGpu);
+ REPORTER_ASSERT(reporter, pixels4 == pixels5);
}
static void TestDeferredCanvas(skiatest::Reporter* reporter, GrContextFactory* factory) {