Picture Recording: fix the performance bottleneck in SkDeferredCanvas::isFullFrame

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 508 matching lines @@
     return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice));
 }
 
 SkDeferredCanvas::SkDeferredCanvas(SkDeferredDevice* device) : SkCanvas (device) {
     this->init();
 }
 
 void SkDeferredCanvas::init() {
     fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold;
     fDeferredDrawing = true; // On by default
+    fCanvasSizeChanged = true;

[reed1, 2014/09/11 15:38:13]

nit: often in skia we name this sort of boolean "Dirty" -- meaning the cache
value field it refers to is dirty and needs to be recomputed.

[yunchao, 2014/09/12 10:13:28]

Done.

+    fCanvasSize.setEmpty();

[reed1, 2014/09/11 15:38:13]

nit: may be clear to name this fCachedCanvasSize, so we don't ever think it
could be different from the computed size.

[yunchao, 2014/09/12 10:13:28]

Done.

 }
 
 void SkDeferredCanvas::setMaxRecordingStorage(size_t maxStorage) {
     this->validate();
     this->getDeferredDevice()->setMaxRecordingStorage(maxStorage);
 }
 
 size_t SkDeferredCanvas::storageAllocatedForRecording() const {
     return this->getDeferredDevice()->storageAllocatedForRecording();
 }
@@ skipping 43 matching lines @@
 }
 
 bool SkDeferredCanvas::isDeferredDrawing() const {
     return fDeferredDrawing;
 }
 
 bool SkDeferredCanvas::isFreshFrame() const {
     return this->getDeferredDevice()->isFreshFrame();
 }
 
+SkISize SkDeferredCanvas::getCanvasSize() {
+    if (fCanvasSizeChanged) {
+        fCanvasSize = this->getBaseLayerSize();
+        fCanvasSizeChanged = false;
+    }
+    return fCanvasSize;
+}
+
 bool SkDeferredCanvas::hasPendingCommands() const {
     return this->getDeferredDevice()->hasPendingCommands();
 }
 
 void SkDeferredCanvas::silentFlush() {
     if (fDeferredDrawing) {
         this->getDeferredDevice()->flushPendingCommands(kSilent_PlaybackMode);
     }
 }
 
 SkDeferredCanvas::~SkDeferredCanvas() {
 }
 
 SkSurface* SkDeferredCanvas::setSurface(SkSurface* surface) {
     SkDeferredDevice* deferredDevice = this->getDeferredDevice();
     SkASSERT(deferredDevice);
     // By swapping the surface into the existing device, we preserve
     // all pending commands, which can help to seamlessly recover from
     // a lost accelerated graphics context.
     deferredDevice->setSurface(surface);
+    fCanvasSizeChanged = true;
     return surface;
 }
 
 SkDeferredCanvas::NotificationClient* SkDeferredCanvas::setNotificationClient(
     NotificationClient* notificationClient) {
 
     SkDeferredDevice* deferredDevice = this->getDeferredDevice();
     SkASSERT(deferredDevice);
     if (deferredDevice) {
         deferredDevice->setNotificationClient(notificationClient);
     }
     return notificationClient;
 }
 
 SkImage* SkDeferredCanvas::newImageSnapshot() {
     SkDeferredDevice* deferredDevice = this->getDeferredDevice();
     SkASSERT(deferredDevice);
     return deferredDevice ? deferredDevice->newImageSnapshot() : NULL;
 }
 
 bool SkDeferredCanvas::isFullFrame(const SkRect* rect,
-                                   const SkPaint* paint) const {
+                                   const SkPaint* paint) {
     SkCanvas* canvas = this->drawingCanvas();
-    SkISize canvasSize = this->getDeviceSize();
+    SkISize canvasSize = this->getCanvasSize();
     if (rect) {
         if (!canvas->getTotalMatrix().rectStaysRect()) {
             return false; // conservative
         }
 
         SkRect transformedRect;
         canvas->getTotalMatrix().mapRect(&transformedRect, *rect);
 
         if (paint) {
             SkPaint::Style paintStyle = paint->getStyle();
@@ skipping 291 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();
 }