Fix crash with SkDeferredCanvas+SkSurface integration with in order draw buffer.

src/utils/SkDeferredCanvas.cpp

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDeferredCanvas.h"
 
@@ skipping 128 matching lines @@
 //-----------------------------------------------------------------------------
 class DeferredDevice : public SkDevice {
 public:
     explicit DeferredDevice(SkDevice* immediateDevice);
     explicit DeferredDevice(SkSurface* surface);
     ~DeferredDevice();
 
     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();
     size_t storageAllocatedForRecording() const;
     size_t freeMemoryIfPossible(size_t bytesToFree);
     size_t getBitmapSizeThreshold() const;
     void setBitmapSizeThreshold(size_t sizeThreshold);
     void flushPendingCommands(PlaybackMode);
     void skipPendingCommands();
     void setMaxRecordingStorage(size_t);
@@ skipping 76 matching lines @@
                             const SkPaint&)
         {SkASSERT(0);}
 private:
     virtual void flush();
 
     void beginRecording();
     void init();
 
     DeferredPipeController fPipeController;
     SkGPipeWriter  fPipeWriter;
-    SkDevice* fImmediateDevice;
     SkCanvas* fImmediateCanvas;
     SkCanvas* fRecordingCanvas;
     SkSurface* fSurface;
     SkDeferredCanvas::NotificationClient* fNotificationClient;
     bool fFreshFrame;
     size_t fMaxRecordingStorageBytes;
     size_t fPreviousStorageAllocated;
     size_t fBitmapSizeThreshold;
 };
 
 DeferredDevice::DeferredDevice(SkDevice* immediateDevice)
     : SkDevice(SkBitmap::kNo_Config,
                immediateDevice->width(), immediateDevice->height(),
                immediateDevice->isOpaque(),
                immediateDevice->getDeviceProperties()) {
     fSurface = NULL;
-    fImmediateDevice = immediateDevice;  // ref counted via fImmediateCanvas
-    fImmediateCanvas = SkNEW_ARGS(SkCanvas, (fImmediateDevice));
+    fImmediateCanvas = SkNEW_ARGS(SkCanvas, (immediateDevice));
     this->init();
 }
 
 DeferredDevice::DeferredDevice(SkSurface* surface)
     : SkDevice(SkBitmap::kNo_Config,
                surface->getCanvas()->getDevice()->width(),
                surface->getCanvas()->getDevice()->height(),
                surface->getCanvas()->getDevice()->isOpaque(),
                surface->getCanvas()->getDevice()->getDeviceProperties()) {
     fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
     fNotificationClient = NULL;
     fImmediateCanvas = surface->getCanvas();
     SkSafeRef(fImmediateCanvas);
     fSurface = surface;
     SkSafeRef(fSurface);
-    fImmediateDevice = fImmediateCanvas->getDevice();  // ref counted via fImmediateCanvas
     this->init();
 }
 
 void DeferredDevice::init() {
     fRecordingCanvas = NULL;
     fFreshFrame = true;
     fPreviousStorageAllocated = 0;
     fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold;
     fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
     fNotificationClient = NULL;
     fPipeController.setPlaybackCanvas(fImmediateCanvas);
     this->beginRecording();
 }
 
 DeferredDevice::~DeferredDevice() {
     this->flushPendingCommands(kSilent_PlaybackMode);
     SkSafeUnref(fImmediateCanvas);
     SkSafeUnref(fSurface);
 }
 
 void DeferredDevice::setMaxRecordingStorage(size_t maxStorage) {
     fMaxRecordingStorageBytes = maxStorage;
     this->recordingCanvas(); // Accessing the recording canvas applies the new limit.
 }
 
 void DeferredDevice::beginRecording() {
     SkASSERT(NULL == fRecordingCanvas);
     fRecordingCanvas = fPipeWriter.startRecording(&fPipeController, 0,
-        fImmediateDevice->width(), fImmediateDevice->height());
+        immediateDevice()->width(), immediateDevice()->height());
 }
 
 void DeferredDevice::setNotificationClient(
     SkDeferredCanvas::NotificationClient* notificationClient) {
     fNotificationClient = notificationClient;
 }
 
 void DeferredDevice::skipPendingCommands() {
     if (!fRecordingCanvas->isDrawingToLayer() && fPipeController.hasPendingCommands()) {
         fFreshFrame = true;
@@ skipping 79 matching lines @@
 SkCanvas* DeferredDevice::recordingCanvas() {
     return fRecordingCanvas;
 }
 
 SkImage* DeferredDevice::newImageSnapshot() {
     this->flush();
     return fSurface ? fSurface->newImageSnapshot() : NULL;
 }
 
 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,
     int x, int y, SkCanvas::Config8888 config8888) {
 
     if (x <= 0 && y <= 0 && (x + bitmap.width()) >= width() &&
         (y + bitmap.height()) >= height()) {
         this->skipPendingCommands();
     }
 
     if (SkBitmap::kARGB_8888_Config == bitmap.config() &&
         SkCanvas::kNative_Premul_Config8888 != config8888 &&
         kPMColorAlias != config8888) {
         //Special case config: no deferral
         this->flushPendingCommands(kNormal_PlaybackMode);
-        fImmediateDevice->writePixels(bitmap, x, y, config8888);
+        immediateDevice()->writePixels(bitmap, x, y, config8888);
         return;
     }
 
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     if (shouldDrawImmediately(&bitmap, NULL, getBitmapSizeThreshold())) {
         this->flushPendingCommands(kNormal_PlaybackMode);
         fImmediateCanvas->drawSprite(bitmap, x, y, &paint);
     } else {
         this->recordingCanvas()->drawSprite(bitmap, x, y, &paint);
         this->recordedDrawCommand();
 
     }
 }
 
 const SkBitmap& DeferredDevice::onAccessBitmap(SkBitmap*) {
     this->flushPendingCommands(kNormal_PlaybackMode);
-    return fImmediateDevice->accessBitmap(false);
+    return immediateDevice()->accessBitmap(false);
 }
 
 SkDevice* DeferredDevice::onCreateCompatibleDevice(
     SkBitmap::Config config, int width, int height, bool isOpaque,
     Usage usage) {
 
     // Save layer usage not supported, and not required by SkDeferredCanvas.
     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);
     return device;
 }
 
 bool DeferredDevice::onReadPixels(
     const SkBitmap& bitmap, int x, int y, SkCanvas::Config8888 config8888) {
     this->flushPendingCommands(kNormal_PlaybackMode);
     return fImmediateCanvas->readPixels(const_cast<SkBitmap*>(&bitmap),
@@ skipping 479 matching lines @@
 SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) {
     this->drawingCanvas()->setDrawFilter(filter);
     this->INHERITED::setDrawFilter(filter);
     this->recordedDrawCommand();
     return filter;
 }
 
 SkCanvas* SkDeferredCanvas::canvasForDrawIter() {
     return this->drawingCanvas();
 }