Remove SkCanvas::isDrawingToLayer

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 136 matching lines @@
     SkImage* newImageSnapshot();
     void setSurface(SkSurface* surface);
     bool isFreshFrame();
     bool hasPendingCommands();
     size_t storageAllocatedForRecording() const;
     size_t freeMemoryIfPossible(size_t bytesToFree);
     void flushPendingCommands(PlaybackMode);
     void skipPendingCommands();
     void setMaxRecordingStorage(size_t);
     void recordedDrawCommand();
+    void setIsDrawingToLayer(bool value) {fIsDrawingToLayer = value;}
 
     virtual SkImageInfo imageInfo() const SK_OVERRIDE;
 
     virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE;
 
     virtual SkBaseDevice* onCreateCompatibleDevice(const CreateInfo&) SK_OVERRIDE;
 
     virtual SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE;
 
 protected:
@@ skipping 82 matching lines @@
     void prepareForImmediatePixelWrite();
 
     DeferredPipeController fPipeController;
     SkGPipeWriter  fPipeWriter;
     SkCanvas* fImmediateCanvas;
     SkCanvas* fRecordingCanvas;
     SkSurface* fSurface;
     SkDeferredCanvas::NotificationClient* fNotificationClient;
     bool fFreshFrame;
     bool fCanDiscardCanvasContents;
+    bool fIsDrawingToLayer;
     size_t fMaxRecordingStorageBytes;
     size_t fPreviousStorageAllocated;
 };
 
 SkDeferredDevice::SkDeferredDevice(SkSurface* surface) {
     fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
     fNotificationClient = NULL;
     fImmediateCanvas = NULL;
     fSurface = NULL;
     this->setSurface(surface);
@@ skipping 32 matching lines @@
     fRecordingCanvas = fPipeWriter.startRecording(&fPipeController, 0,
         immediateDevice()->width(), immediateDevice()->height());
 }
 
 void SkDeferredDevice::setNotificationClient(
     SkDeferredCanvas::NotificationClient* notificationClient) {
     fNotificationClient = notificationClient;
 }
 
 void SkDeferredDevice::skipPendingCommands() {
-    if (!fRecordingCanvas->isDrawingToLayer()) {
+    if (!fIsDrawingToLayer) {
         fCanDiscardCanvasContents = true;
         if (fPipeController.hasPendingCommands()) {
             fFreshFrame = true;
             flushPendingCommands(kSilent_PlaybackMode);
         }
     }
 }
 
 bool SkDeferredDevice::isFreshFrame() {
     bool ret = fFreshFrame;
@@ skipping 193 matching lines @@
 
 SkDeferredCanvas::SkDeferredCanvas(SkDeferredDevice* device) : SkCanvas (device) {
     this->init();
 }
 
 void SkDeferredCanvas::init() {
     fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold;
     fDeferredDrawing = true; // On by default
     fCachedCanvasSize.setEmpty();
     fCachedCanvasSizeDirty = true;
+    fSaveLevel = 0;
 }
 
 void SkDeferredCanvas::setMaxRecordingStorage(size_t maxStorage) {
     this->validate();
     this->getDeferredDevice()->setMaxRecordingStorage(maxStorage);
 }
 
 size_t SkDeferredCanvas::storageAllocatedForRecording() const {
     return this->getDeferredDevice()->storageAllocatedForRecording();
 }
@@ skipping 131 matching lines @@
             transformedRect.fBottom < SkIntToScalar(canvasSize.fHeight)) {
             return false;
         }
     }
 
     return this->getClipStack()->quickContains(SkRect::MakeXYWH(0, 0,
         SkIntToScalar(canvasSize.fWidth), SkIntToScalar(canvasSize.fHeight)));
 }
 
 void SkDeferredCanvas::willSave() {
+    fSaveLevel++;
     this->drawingCanvas()->save();
     this->recordedDrawCommand();
     this->INHERITED::willSave();
 }
 
 SkCanvas::SaveLayerStrategy SkDeferredCanvas::willSaveLayer(const SkRect* bounds,
                                                             const SkPaint* paint, SaveFlags flags) {
+    fSaveLevel++;
+    fSaveLayerStack.push(fSaveLevel);
+    this->getDeferredDevice()->setIsDrawingToLayer(true);
     this->drawingCanvas()->saveLayer(bounds, paint, flags);
     this->recordedDrawCommand();
     this->INHERITED::willSaveLayer(bounds, paint, flags);
     // No need for a full layer.
     return kNoLayer_SaveLayerStrategy;
 }
 
 void SkDeferredCanvas::willRestore() {
+    SkASSERT(fSaveLayerStack.isEmpty() || fSaveLayerStack.top() <= fSaveLevel);
+    if (!fSaveLayerStack.isEmpty() && fSaveLayerStack.top() == fSaveLevel) {
+        fSaveLayerStack.pop();
+        if (fSaveLayerStack.isEmpty())
+        {
+            this->getDeferredDevice()->setIsDrawingToLayer(false);
+        }
+    }
     this->drawingCanvas()->restore();
     this->recordedDrawCommand();
     this->INHERITED::willRestore();
 }
 
-bool SkDeferredCanvas::isDrawingToLayer() const {
-    return this->drawingCanvas()->isDrawingToLayer();
-}
-
 void SkDeferredCanvas::didConcat(const SkMatrix& matrix) {
     this->drawingCanvas()->concat(matrix);
     this->recordedDrawCommand();
     this->INHERITED::didConcat(matrix);
 }
 
 void SkDeferredCanvas::didSetMatrix(const SkMatrix& matrix) {
     this->drawingCanvas()->setMatrix(matrix);
     this->recordedDrawCommand();
     this->INHERITED::didSetMatrix(matrix);
@@ skipping 211 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();
 }