text: 
  /*
   * 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"
  
  #include "SkBitmapDevice.h"
  #include "SkChunkAlloc.h"
  #include "SkColorFilter.h"
  #include "SkDrawFilter.h"
  #include "SkGPipe.h"
  #include "SkPaint.h"
  #include "SkPaintPriv.h"
  #include "SkRRect.h"
  #include "SkShader.h"
  #include "SkSurface.h"
  
  enum {
      // Deferred canvas will auto-flush when recording reaches this limit
      kDefaultMaxRecordingStorageBytes = 64*1024*1024,
      kDeferredCanvasBitmapSizeThreshold = ~0U, // Disables this feature
  
      kNoSaveLayerIndex = -1,
  };
  
  enum PlaybackMode {
      kNormal_PlaybackMode,
      kSilent_PlaybackMode,
  };
  
  static bool should_draw_immediately(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
          // requires making the assumption that only gradient shaders
          // and SkBitmapProcShader implement asABitmap().  The following
          // code may need to be revised if that assumption is ever broken.
          if (shader && !shader->asAGradient(NULL)) {
              SkBitmap bm;
              if (shader->asABitmap(&bm, NULL, NULL) &&
                  bm.getTexture()) {
                  return true;
              }
          }
      }
      return false;
  }
  
  //-----------------------------------------------------------------------------
  // DeferredPipeController
  //-----------------------------------------------------------------------------
  
  class DeferredPipeController : public SkGPipeController {
  public:
      DeferredPipeController();
      void setPlaybackCanvas(SkCanvas*);
      virtual ~DeferredPipeController();
      void* requestBlock(size_t minRequest, size_t* actual) override;
      void notifyWritten(size_t bytes) override;
      void playback(bool silent);
      bool hasPendingCommands() const { return fAllocator.totalUsed() != 0; }
      size_t storageAllocatedForRecording() const { return fAllocator.totalCapacity(); }
  private:
      enum {
          kMinBlockSize = 4096
      };
      struct PipeBlock {
          PipeBlock(void* block, size_t size) { fBlock = block, fSize = size; }
          void* fBlock;
          size_t fSize;
      };
      void* fBlock;
      size_t fBytesWritten;
      SkChunkAlloc fAllocator;
      SkTDArray<PipeBlock> fBlockList;
      SkGPipeReader fReader;
  };
  
  DeferredPipeController::DeferredPipeController() :
      fAllocator(kMinBlockSize) {
      fBlock = NULL;
      fBytesWritten = 0;
  }
  
  DeferredPipeController::~DeferredPipeController() {
      fAllocator.reset();
  }
  
  void DeferredPipeController::setPlaybackCanvas(SkCanvas* canvas) {
      fReader.setCanvas(canvas);
  }
  
  void* DeferredPipeController::requestBlock(size_t minRequest, size_t *actual) {
      if (fBlock) {
          // Save the previous block for later
          PipeBlock previousBloc(fBlock, fBytesWritten);
          fBlockList.push(previousBloc);
      }
      size_t blockSize = SkTMax<size_t>(minRequest, kMinBlockSize);
      fBlock = fAllocator.allocThrow(blockSize);
      fBytesWritten = 0;
      *actual = blockSize;
      return fBlock;
  }
  
  void DeferredPipeController::notifyWritten(size_t bytes) {
      fBytesWritten += bytes;
  }
  
  void DeferredPipeController::playback(bool silent) {
      uint32_t flags = silent ? SkGPipeReader::kSilent_PlaybackFlag : 0;
      for (int currentBlock = 0; currentBlock < fBlockList.count(); currentBlock++ ) {
          fReader.playback(fBlockList[currentBlock].fBlock, fBlockList[currentBlock].fSize,
                           flags);
      }
      fBlockList.reset();
  
      if (fBlock) {
          fReader.playback(fBlock, fBytesWritten, flags);
          fBlock = NULL;
      }
  
      // Release all allocated blocks
      fAllocator.reset();
  }
  
  //-----------------------------------------------------------------------------
  // SkDeferredDevice
  //-----------------------------------------------------------------------------
  class SkDeferredDevice : public SkBaseDevice {
  public:
      explicit SkDeferredDevice(SkSurface* surface);
      ~SkDeferredDevice();
  
      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);
      void flushPendingCommands(PlaybackMode);
      void skipPendingCommands();
      void setMaxRecordingStorage(size_t);
      void recordedDrawCommand();
      void setIsDrawingToLayer(bool value) {fIsDrawingToLayer = value;}
  
      SkImageInfo imageInfo() const override;
  
      GrRenderTarget* accessRenderTarget() override;
  
      SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override;
  
      SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) override;
  
  protected:
      const SkBitmap& onAccessBitmap() override;
      bool onReadPixels(const SkImageInfo&, void*, size_t, int x, int y) override;
      bool onWritePixels(const SkImageInfo&, const void*, size_t, int x, int y) override;
  
      // None of the following drawing methods should ever get called on the
      // deferred device
      void drawPaint(const SkDraw&, const SkPaint& paint) override
          {SkASSERT(0);}
      virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode,
                              size_t count, const SkPoint[],
                              const SkPaint& paint) override
          {SkASSERT(0);}
      virtual void drawRect(const SkDraw&, const SkRect& r,
                              const SkPaint& paint) override
          {SkASSERT(0);}
      void drawOval(const SkDraw&, const SkRect&, const SkPaint&) override
          {SkASSERT(0);}
      virtual void drawRRect(const SkDraw&, const SkRRect& rr,
                             const SkPaint& paint) override
      {SkASSERT(0);}
      virtual void drawPath(const SkDraw&, const SkPath& path,
                              const SkPaint& paint,
                              const SkMatrix* prePathMatrix = NULL,
                              bool pathIsMutable = false) override
          {SkASSERT(0);}
      virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
                              const SkMatrix& matrix, const SkPaint& paint) override
          {SkASSERT(0);}
      virtual void drawBitmapRect(const SkDraw&, const SkBitmap&, const SkRect*,
                                  const SkRect&, const SkPaint&,
                                  SkCanvas::DrawBitmapRectFlags) override
          {SkASSERT(0);}
      virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
                              int x, int y, const SkPaint& paint) override
          {SkASSERT(0);}
      virtual void drawText(const SkDraw&, const void* text, size_t len,
                              SkScalar x, SkScalar y, const SkPaint& paint) override
          {SkASSERT(0);}
      virtual void drawPosText(const SkDraw&, const void* text, size_t len,
                               const SkScalar pos[], int scalarsPerPos,
                               const SkPoint& offset, const SkPaint& paint) override
          {SkASSERT(0);}
      virtual void drawTextOnPath(const SkDraw&, const void* text,
                                  size_t len, const SkPath& path,
                                  const SkMatrix* matrix,
                                  const SkPaint& paint) override
          {SkASSERT(0);}
      virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode,
                                  int vertexCount, const SkPoint verts[],
                                  const SkPoint texs[], const SkColor colors[],
                                  SkXfermode* xmode, const uint16_t indices[],
                                  int indexCount, const SkPaint& paint) override
          {SkASSERT(0);}
      virtual void drawPatch(const SkDraw&, const SkPoint cubics[12], const SkColor colors[4],
                             const SkPoint texCoords[4], SkXfermode* xmode,
                             const SkPaint& paint) override
          {SkASSERT(0);}
      virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
                              const SkPaint&) override
          {SkASSERT(0);}
  
      void lockPixels() override {}
      void unlockPixels() override {}
  
      bool canHandleImageFilter(const SkImageFilter*) override {
          return false;
      }
      virtual bool filterImage(const SkImageFilter*, const SkBitmap&,
                               const SkImageFilter::Context&, SkBitmap*, SkIPoint*) override {
          return false;
      }
  
  private:
      void flush() override;
      void replaceBitmapBackendForRasterSurface(const SkBitmap&) override {}
  
      void beginRecording();
      void init();
      void aboutToDraw();
      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);
      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;
      fIsDrawingToLayer = false;
      fCanDiscardCanvasContents = false;
      fPreviousStorageAllocated = 0;
      fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
      fNotificationClient = NULL;
      this->beginRecording();
  }
  
  SkDeferredDevice::~SkDeferredDevice() {
      this->flushPendingCommands(kSilent_PlaybackMode);
      SkSafeUnref(fImmediateCanvas);
      SkSafeUnref(fSurface);
  }
  
  void SkDeferredDevice::setMaxRecordingStorage(size_t maxStorage) {
      fMaxRecordingStorageBytes = maxStorage;
      this->recordingCanvas(); // Accessing the recording canvas applies the new limit.
  }
  
  void SkDeferredDevice::beginRecording() {
      SkASSERT(NULL == fRecordingCanvas);
      fRecordingCanvas = fPipeWriter.startRecording(&fPipeController, 0,
          immediateDevice()->width(), immediateDevice()->height());
  }
  
  void SkDeferredDevice::setNotificationClient(
      SkDeferredCanvas::NotificationClient* notificationClient) {
      fNotificationClient = notificationClient;
  }
  
  void SkDeferredDevice::skipPendingCommands() {
      if (!fIsDrawingToLayer) {
          fCanDiscardCanvasContents = true;
          if (fPipeController.hasPendingCommands()) {
              fFreshFrame = true;
              flushPendingCommands(kSilent_PlaybackMode);
          }
      }
  }
  
  bool SkDeferredDevice::isFreshFrame() {
      bool ret = fFreshFrame;
      fFreshFrame = false;
      return ret;
  }
  
  bool SkDeferredDevice::hasPendingCommands() {
      return fPipeController.hasPendingCommands();
  }
  
  void SkDeferredDevice::aboutToDraw()
  {
      if (fNotificationClient) {
          fNotificationClient->prepareForDraw();
      }
      if (fCanDiscardCanvasContents) {
          if (fSurface) {
              fSurface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
          }
          fCanDiscardCanvasContents = false;
      }
  }
  
  void SkDeferredDevice::flushPendingCommands(PlaybackMode playbackMode) {
      if (!fPipeController.hasPendingCommands()) {
          return;
      }
      if (playbackMode == kNormal_PlaybackMode) {
          aboutToDraw();
      }
      fPipeWriter.flushRecording(true);
      fPipeController.playback(kSilent_PlaybackMode == playbackMode);
      if (fNotificationClient) {
          if (playbackMode == kSilent_PlaybackMode) {
              fNotificationClient->skippedPendingDrawCommands();
          } else {
              fNotificationClient->flushedDrawCommands();
          }
      }
  
      fPreviousStorageAllocated = storageAllocatedForRecording();
  }
  
  void SkDeferredDevice::flush() {
      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::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
          size_t tryFree = storageAllocated - fMaxRecordingStorageBytes;
          if (this->freeMemoryIfPossible(tryFree) < tryFree) {
              // Flush is necessary to free more space.
              this->flushPendingCommands(kNormal_PlaybackMode);
              // Free as much as possible to avoid oscillating around fMaxRecordingStorageBytes
              // which could cause a high flushing frequency.
              this->freeMemoryIfPossible(~0U);
          }
          storageAllocated = this->storageAllocatedForRecording();
      }
  
      if (fNotificationClient &&
          storageAllocated != fPreviousStorageAllocated) {
          fPreviousStorageAllocated = storageAllocated;
          fNotificationClient->storageAllocatedForRecordingChanged(storageAllocated);
      }
  }
  
  SkCanvas* SkDeferredDevice::recordingCanvas() {
      return fRecordingCanvas;
  }
  
  SkImage* SkDeferredDevice::newImageSnapshot() {
      this->flush();
      return fSurface ? fSurface->newImageSnapshot() : NULL;
  }
  
  SkImageInfo SkDeferredDevice::imageInfo() const {
      return immediateDevice()->imageInfo();
  }
  
  GrRenderTarget* SkDeferredDevice::accessRenderTarget() {
      this->flushPendingCommands(kNormal_PlaybackMode);
      return immediateDevice()->accessRenderTarget();
  }
  
  void SkDeferredDevice::prepareForImmediatePixelWrite() {
      // The purpose of the following code is to make sure commands are flushed, that
      // aboutToDraw() is called and that notifyContentWillChange is called, without
      // calling anything redundantly.
      if (fPipeController.hasPendingCommands()) {
          this->flushPendingCommands(kNormal_PlaybackMode);
      } else {
          bool mustNotifyDirectly = !fCanDiscardCanvasContents;
          this->aboutToDraw();
          if (mustNotifyDirectly) {
              fSurface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
          }
      }
  
      fImmediateCanvas->flush();
  }
  
  bool SkDeferredDevice::onWritePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes,
                                     int x, int y) {
      SkASSERT(x >= 0 && y >= 0);
      SkASSERT(x + info.width() <= width());
      SkASSERT(y + info.height() <= height());
  
      const SkImageInfo deviceInfo = this->imageInfo();
      if (info.width() == deviceInfo.width() && info.height() == deviceInfo.height()) {
          this->skipPendingCommands();
      } else {
          this->flushPendingCommands(kNormal_PlaybackMode);
      }
  
      this->prepareForImmediatePixelWrite();
      return immediateDevice()->onWritePixels(info, pixels, rowBytes, x, y);
  }
  
  const SkBitmap& SkDeferredDevice::onAccessBitmap() {
      this->flushPendingCommands(kNormal_PlaybackMode);
      return immediateDevice()->accessBitmap(false);
  }
  
  SkBaseDevice* SkDeferredDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint* layerPaint) {
      // Create a compatible non-deferred device.
      // We do not create a deferred device because we know the new device
      // will not be used with a deferred canvas (there is no API for that).
      // And connecting a SkDeferredDevice to non-deferred canvas can result
      // in unpredictable behavior.
      return immediateDevice()->onCreateDevice(cinfo, layerPaint);
  }
  
  SkSurface* SkDeferredDevice::newSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
      return this->immediateDevice()->newSurface(info, props);
  }
  
  bool SkDeferredDevice::onReadPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
                                      int x, int y) {
      this->flushPendingCommands(kNormal_PlaybackMode);
      return fImmediateCanvas->readPixels(info, pixels, rowBytes, x, y);
  }
  
  class AutoImmediateDrawIfNeeded {
  public:
      AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkBitmap* bitmap,
                                const SkPaint* paint) {
          this->init(canvas, bitmap, paint);
      }
  
      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) {
          if (canvas.isDeferredDrawing() &&
              should_draw_immediately(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
      fCachedCanvasSize.setEmpty();
      fCachedCanvasSizeDirty = true;
      fSaveLevel = 0;
      fFirstSaveLayerIndex = kNoSaveLayerIndex;
  }
  
  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) {
      fBitmapSizeThreshold = sizeThreshold;
  }
  
  void SkDeferredCanvas::recordedDrawCommand() {
      if (fDeferredDrawing) {
          this->getDeferredDevice()->recordedDrawCommand();
      }
  }
  
  void SkDeferredCanvas::validate() const {
      SkASSERT(this->getDevice());
  }
  
  SkCanvas* SkDeferredCanvas::drawingCanvas() const {
      this->validate();
      return fDeferredDrawing ? this->getDeferredDevice()->recordingCanvas() :
          this->getDeferredDevice()->immediateCanvas();
  }
  
  SkCanvas* SkDeferredCanvas::immediateCanvas() const {
      this->validate();
      return this->getDeferredDevice()->immediateCanvas();
  }
  
  SkDeferredDevice* SkDeferredCanvas::getDeferredDevice() const {
      return static_cast<SkDeferredDevice*>(this->getDevice());
  }
  
  void SkDeferredCanvas::setDeferredDrawing(bool val) {
      this->validate(); // Must set device before calling this method
      if (val != fDeferredDrawing) {
          if (fDeferredDrawing) {
              // Going live.
              this->getDeferredDevice()->flushPendingCommands(kNormal_PlaybackMode);
          }
          fDeferredDrawing = val;
      }
  }
  
  bool SkDeferredCanvas::isDeferredDrawing() const {
      return fDeferredDrawing;
  }
  
  bool SkDeferredCanvas::isFreshFrame() const {
      return this->getDeferredDevice()->isFreshFrame();
  }
  
  SkISize SkDeferredCanvas::getCanvasSize() const {
      if (fCachedCanvasSizeDirty) {
          fCachedCanvasSize = this->getBaseLayerSize();
          fCachedCanvasSizeDirty = false;
      }
      return fCachedCanvasSize;
  }
  
  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);
      fCachedCanvasSizeDirty = 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 {
      SkCanvas* canvas = this->drawingCanvas();
      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();
              if (!(paintStyle == SkPaint::kFill_Style ||
                  paintStyle == SkPaint::kStrokeAndFill_Style)) {
                  return false;
              }
              if (paint->getMaskFilter() || paint->getLooper()
                  || paint->getPathEffect() || paint->getImageFilter()) {
                  return false; // conservative
              }
          }
  
          // The following test holds with AA enabled, and is conservative
          // by a 0.5 pixel margin with AA disabled
          if (transformedRect.fLeft > SkIntToScalar(0) ||
              transformedRect.fTop > SkIntToScalar(0) ||
              transformedRect.fRight < SkIntToScalar(canvasSize.fWidth) ||
              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++;
      if (fFirstSaveLayerIndex == kNoSaveLayerIndex) {
          fFirstSaveLayerIndex = 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(fFirstSaveLayerIndex == kNoSaveLayerIndex || fFirstSaveLayerIndex <= fSaveLevel);
      if (fFirstSaveLayerIndex == fSaveLevel) {
          fFirstSaveLayerIndex = kNoSaveLayerIndex;
          this->getDeferredDevice()->setIsDrawingToLayer(false);
      }
      fSaveLevel--;
      this->drawingCanvas()->restore();
      this->recordedDrawCommand();
      this->INHERITED::willRestore();
  }
  
  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);
  }
  
  void SkDeferredCanvas::onClipRect(const SkRect& rect,
                                    SkRegion::Op op,
                                    ClipEdgeStyle edgeStyle) {
      this->drawingCanvas()->clipRect(rect, op, kSoft_ClipEdgeStyle == edgeStyle);
      this->INHERITED::onClipRect(rect, op, edgeStyle);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onClipRRect(const SkRRect& rrect,
                                     SkRegion::Op op,
                                     ClipEdgeStyle edgeStyle) {
      this->drawingCanvas()->clipRRect(rrect, op, kSoft_ClipEdgeStyle == edgeStyle);
      this->INHERITED::onClipRRect(rrect, op, edgeStyle);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onClipPath(const SkPath& path,
                                    SkRegion::Op op,
                                    ClipEdgeStyle edgeStyle) {
      this->drawingCanvas()->clipPath(path, op, kSoft_ClipEdgeStyle == edgeStyle);
      this->INHERITED::onClipPath(path, op, edgeStyle);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
      this->drawingCanvas()->clipRegion(deviceRgn, op);
      this->INHERITED::onClipRegion(deviceRgn, op);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawPaint(const SkPaint& paint) {
      if (fDeferredDrawing && this->isFullFrame(NULL, &paint) &&
          isPaintOpaque(&paint)) {
          this->getDeferredDevice()->skipPendingCommands();
      }
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawPaint(paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawPoints(PointMode mode, size_t count,
                                      const SkPoint pts[], const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawPoints(mode, count, pts, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawOval(const SkRect& rect, const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawOval(rect, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) {
      if (fDeferredDrawing && this->isFullFrame(&rect, &paint) &&
          isPaintOpaque(&paint)) {
          this->getDeferredDevice()->skipPendingCommands();
      }
  
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawRect(rect, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
      if (rrect.isRect()) {
          this->SkDeferredCanvas::drawRect(rrect.getBounds(), paint);
      } else if (rrect.isOval()) {
          this->SkDeferredCanvas::drawOval(rrect.getBounds(), paint);
      } else {
          AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
          this->drawingCanvas()->drawRRect(rrect, paint);
          this->recordedDrawCommand();
      }
  }
  
  void SkDeferredCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
                                      const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawDRRect(outer, inner, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawPath(path, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawBitmap(const SkBitmap& bitmap, SkScalar left,
                                      SkScalar top, const SkPaint* paint) {
      SkRect bitmapRect = SkRect::MakeXYWH(left, top,
          SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height()));
      if (fDeferredDrawing &&
          this->isFullFrame(&bitmapRect, paint) &&
          isPaintOpaque(paint, &bitmap)) {
          this->getDeferredDevice()->skipPendingCommands();
      }
  
      AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
      this->drawingCanvas()->drawBitmap(bitmap, left, top, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src,
                                          const SkRect& dst,
                                          const SkPaint* paint, DrawBitmapRectFlags flags) {
      if (fDeferredDrawing &&
          this->isFullFrame(&dst, paint) &&
          isPaintOpaque(paint, &bitmap)) {
          this->getDeferredDevice()->skipPendingCommands();
      }
  
      AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
      this->drawingCanvas()->drawBitmapRectToRect(bitmap, src, dst, paint, flags);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawBitmapNine(const SkBitmap& bitmap,
                                          const SkIRect& center, const SkRect& dst,
                                          const SkPaint* paint) {
      // TODO: reset recording canvas if paint+bitmap is opaque and clip rect
      // covers canvas entirely and dst covers canvas entirely
      AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
      this->drawingCanvas()->drawBitmapNine(bitmap, center, dst, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawSprite(const SkBitmap& bitmap, int left, int top,
                                      const SkPaint* paint) {
      SkRect bitmapRect = SkRect::MakeXYWH(
          SkIntToScalar(left),
          SkIntToScalar(top),
          SkIntToScalar(bitmap.width()),
          SkIntToScalar(bitmap.height()));
      if (fDeferredDrawing &&
          this->isFullFrame(&bitmapRect, paint) &&
          isPaintOpaque(paint, &bitmap)) {
          this->getDeferredDevice()->skipPendingCommands();
      }
  
      AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
      this->drawingCanvas()->drawSprite(bitmap, left, top, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                                    const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawText(text, byteLength, x, y, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
                                       const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawPosText(text, byteLength, pos, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
                                        SkScalar constY, const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawPosTextH(text, byteLength, xpos, constY, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                                          const SkMatrix* matrix, const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawTextOnPath(text, byteLength, path, matrix, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                        const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawTextBlob(blob, x, y, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix,
                                       const SkPaint* paint) {
      this->drawingCanvas()->drawPicture(picture, matrix, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
                                        const SkPoint vertices[],
                                        const SkPoint texs[],
                                        const SkColor colors[], SkXfermode* xmode,
                                        const uint16_t indices[], int indexCount,
                                        const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawVertices(vmode, vertexCount, vertices, texs, colors, xmode,
                                          indices, indexCount, paint);
      this->recordedDrawCommand();
  }
  
  void SkDeferredCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
                                     const SkPoint texCoords[4], SkXfermode* xmode,
                                     const SkPaint& paint) {
      AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
      this->drawingCanvas()->drawPatch(cubics, colors, texCoords, xmode, paint);
      this->recordedDrawCommand();
  }
  
  SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) {
      this->drawingCanvas()->setDrawFilter(filter);
      this->INHERITED::setDrawFilter(filter);
      this->recordedDrawCommand();
      return filter;
  }
  
  SkCanvas* SkDeferredCanvas::canvasForDrawIter() {
      return this->drawingCanvas();
  }
  