stop calling SkCanvas::getDevice

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 11 matching lines @@
 enum {
     // Deferred canvas will auto-flush when recording reaches this limit
     kDefaultMaxRecordingStorageBytes = 64*1024*1024,
     kDeferredCanvasBitmapSizeThreshold = ~0U, // Disables this feature
 };
 
 enum PlaybackMode {
     kNormal_PlaybackMode,
     kSilent_PlaybackMode,
 };
 

[robertphillips, 2014/06/30 13:36:20]

should_draw_immediately ?

[reed1, 2014/06/30 14:33:12]

Done.

 static bool shouldDrawImmediately(const SkBitmap* bitmap, const SkPaint* paint,
                            size_t bitmapSizeThreshold) {
     if (bitmap && ((bitmap->getTexture() && !bitmap->isImmutable()) ||
         (bitmap->getSize() > bitmapSizeThreshold))) {
         return true;
     }
     if (paint) {
         SkShader* shader = paint->getShader();
         // Here we detect the case where the shader is an SkBitmapProcShader
         // with a gpu texture attached.  Checking this without RTTI
@@ skipping 100 matching lines @@
     void setNotificationClient(SkDeferredCanvas::NotificationClient* notificationClient);
     SkCanvas* recordingCanvas();
     SkCanvas* immediateCanvas() const {return fImmediateCanvas;}
     SkBaseDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice();}
     SkImage* newImageSnapshot();
     void setSurface(SkSurface* surface);
     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);
     void recordedDrawCommand();
 
     virtual SkImageInfo imageInfo() const SK_OVERRIDE;
 
     virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE;
 
     virtual SkBaseDevice* onCreateDevice(const SkImageInfo&, Usage) SK_OVERRIDE;
@@ skipping 91 matching lines @@
     DeferredPipeController fPipeController;
     SkGPipeWriter  fPipeWriter;
     SkCanvas* fImmediateCanvas;
     SkCanvas* fRecordingCanvas;
     SkSurface* fSurface;
     SkDeferredCanvas::NotificationClient* fNotificationClient;
     bool fFreshFrame;
     bool fCanDiscardCanvasContents;
     size_t fMaxRecordingStorageBytes;
     size_t fPreviousStorageAllocated;
-    size_t fBitmapSizeThreshold;
 };
 
 SkDeferredDevice::SkDeferredDevice(SkSurface* surface) {
     fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
     fNotificationClient = NULL;
     fImmediateCanvas = NULL;
     fSurface = NULL;
     this->setSurface(surface);
     this->init();
 }
 
 void SkDeferredDevice::setSurface(SkSurface* surface) {
     SkRefCnt_SafeAssign(fImmediateCanvas, surface->getCanvas());
     SkRefCnt_SafeAssign(fSurface, surface);
     fPipeController.setPlaybackCanvas(fImmediateCanvas);
 }
 
 void SkDeferredDevice::init() {
     fRecordingCanvas = NULL;
     fFreshFrame = true;
     fCanDiscardCanvasContents = false;
     fPreviousStorageAllocated = 0;
-    fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold;
     fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
     fNotificationClient = NULL;
     this->beginRecording();
 }
 
 SkDeferredDevice::~SkDeferredDevice() {
     this->flushPendingCommands(kSilent_PlaybackMode);
     SkSafeUnref(fImmediateCanvas);
     SkSafeUnref(fSurface);
 }
@@ skipping 71 matching lines @@
     this->flushPendingCommands(kNormal_PlaybackMode);
     fImmediateCanvas->flush();
 }
 
 size_t SkDeferredDevice::freeMemoryIfPossible(size_t bytesToFree) {
     size_t val = fPipeWriter.freeMemoryIfPossible(bytesToFree);
     fPreviousStorageAllocated = storageAllocatedForRecording();
     return val;
 }
 
-size_t SkDeferredDevice::getBitmapSizeThreshold() const {
-    return fBitmapSizeThreshold;
-}
-
-void SkDeferredDevice::setBitmapSizeThreshold(size_t sizeThreshold) {
-    fBitmapSizeThreshold = sizeThreshold;
-}
-
 size_t SkDeferredDevice::storageAllocatedForRecording() const {
     return (fPipeController.storageAllocatedForRecording()
             + fPipeWriter.storageAllocatedForRecording());
 }
 
 void SkDeferredDevice::recordedDrawCommand() {
     size_t storageAllocated = this->storageAllocatedForRecording();
 
     if (storageAllocated > fMaxRecordingStorageBytes) {
         // First, attempt to reduce cache without flushing
@@ skipping 103 matching lines @@
     AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkPaint* paint) {
         this->init(canvas, NULL, paint);
     }
 
     ~AutoImmediateDrawIfNeeded() {
         if (fCanvas) {
             fCanvas->setDeferredDrawing(true);
         }
     }
 private:
-    void init(SkDeferredCanvas& canvas, const SkBitmap* bitmap, const SkPaint* paint)
-    {
-        SkDeferredDevice* device = static_cast<SkDeferredDevice*>(canvas.getDevice());
-        if (canvas.isDeferredDrawing() && (NULL != device) &&
-            shouldDrawImmediately(bitmap, paint, device->getBitmapSizeThreshold())) {
+    void init(SkDeferredCanvas& canvas, const SkBitmap* bitmap, const SkPaint* paint) {
+        if (canvas.isDeferredDrawing() &&
+            shouldDrawImmediately(bitmap, paint, canvas.getBitmapSizeThreshold())) {
             canvas.setDeferredDrawing(false);
             fCanvas = &canvas;
         } else {
             fCanvas = NULL;
         }
     }
 
     SkDeferredCanvas* fCanvas;
 };
 
 SkDeferredCanvas* SkDeferredCanvas::Create(SkSurface* surface) {
     SkAutoTUnref<SkDeferredDevice> deferredDevice(SkNEW_ARGS(SkDeferredDevice, (surface)));
     return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice));
 }
 
 SkDeferredCanvas::SkDeferredCanvas(SkDeferredDevice* device) : SkCanvas (device) {
     this->init();
 }
 
 void SkDeferredCanvas::init() {
+    fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold;
     fDeferredDrawing = true; // On by default
 }
 
 void SkDeferredCanvas::setMaxRecordingStorage(size_t maxStorage) {
     this->validate();
     this->getDeferredDevice()->setMaxRecordingStorage(maxStorage);
 }
 
 size_t SkDeferredCanvas::storageAllocatedForRecording() const {
     return this->getDeferredDevice()->storageAllocatedForRecording();
 }
 
 size_t SkDeferredCanvas::freeMemoryIfPossible(size_t bytesToFree) {
     return this->getDeferredDevice()->freeMemoryIfPossible(bytesToFree);
 }
 
 void SkDeferredCanvas::setBitmapSizeThreshold(size_t sizeThreshold) {
-    SkDeferredDevice* deferredDevice = this->getDeferredDevice();
-    SkASSERT(deferredDevice);
-    deferredDevice->setBitmapSizeThreshold(sizeThreshold);
+    fBitmapSizeThreshold = sizeThreshold;
 }
 
 void SkDeferredCanvas::recordedDrawCommand() {
     if (fDeferredDrawing) {
         this->getDeferredDevice()->recordedDrawCommand();
     }
 }
 
 void SkDeferredCanvas::validate() const {
     SkASSERT(this->getDevice());
@@ skipping 365 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();
 }