src/third_party/skia/src/utils/SkDeferredCanvas.cpp

   1
   2 /*
   3  * Copyright 2013 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9 #include "SkDeferredCanvas.h"
  10
  11 #include "SkBitmapDevice.h"
  12 #include "SkChunkAlloc.h"
  13 #include "SkColorFilter.h"
  14 #include "SkDrawFilter.h"
  15 #include "SkGPipe.h"
  16 #include "SkPaint.h"
  17 #include "SkPaintPriv.h"
  18 #include "SkRRect.h"
  19 #include "SkShader.h"
  20 #include "SkSurface.h"
  21
  22 enum {
  23     // Deferred canvas will auto-flush when recording reaches this limit
  24     kDefaultMaxRecordingStorageBytes = 64*1024*1024,
  25     kDeferredCanvasBitmapSizeThreshold = ~0U, // Disables this feature
  26 };
  27
  28 enum PlaybackMode {
  29     kNormal_PlaybackMode,
  30     kSilent_PlaybackMode,
  31 };
  32
  33 namespace {
  34 bool shouldDrawImmediately(const SkBitmap* bitmap, const SkPaint* paint,
  35                            size_t bitmapSizeThreshold) {
  36     if (bitmap && ((bitmap->getTexture() && !bitmap->isImmutable()) ||
  37         (bitmap->getSize() > bitmapSizeThreshold))) {
  38         return true;
  39     }
  40     if (paint) {
  41         SkShader* shader = paint->getShader();
  42         // Here we detect the case where the shader is an SkBitmapProcShader
  43         // with a gpu texture attached.  Checking this without RTTI
  44         // requires making the assumption that only gradient shaders
  45         // and SkBitmapProcShader implement asABitmap().  The following
  46         // code may need to be revised if that assumption is ever broken.
  47         if (shader && !shader->asAGradient(NULL)) {
  48             SkBitmap bm;
  49             if (shader->asABitmap(&bm, NULL, NULL) &&
  50                 NULL != bm.getTexture()) {
  51                 return true;
  52             }
  53         }
  54     }
  55     return false;
  56 }
  57 }
  58
  59 //-----------------------------------------------------------------------------
  60 // DeferredPipeController
  61 //-----------------------------------------------------------------------------
  62
  63 class DeferredPipeController : public SkGPipeController {
  64 public:
  65     DeferredPipeController();
  66     void setPlaybackCanvas(SkCanvas*);
  67     virtual ~DeferredPipeController();
  68     virtual void* requestBlock(size_t minRequest, size_t* actual) SK_OVERRIDE;
  69     virtual void notifyWritten(size_t bytes) SK_OVERRIDE;
  70     void playback(bool silent);
  71     bool hasPendingCommands() const { return fAllocator.blockCount() != 0; }
  72     size_t storageAllocatedForRecording() const { return fAllocator.totalCapacity(); }
  73 private:
  74     enum {
  75         kMinBlockSize = 4096
  76     };
  77     struct PipeBlock {
  78         PipeBlock(void* block, size_t size) { fBlock = block, fSize = size; }
  79         void* fBlock;
  80         size_t fSize;
  81     };
  82     void* fBlock;
  83     size_t fBytesWritten;
  84     SkChunkAlloc fAllocator;
  85     SkTDArray<PipeBlock> fBlockList;
  86     SkGPipeReader fReader;
  87 };
  88
  89 DeferredPipeController::DeferredPipeController() :
  90     fAllocator(kMinBlockSize) {
  91     fBlock = NULL;
  92     fBytesWritten = 0;
  93 }
  94
  95 DeferredPipeController::~DeferredPipeController() {
  96     fAllocator.reset();
  97 }
  98
  99 void DeferredPipeController::setPlaybackCanvas(SkCanvas* canvas) {
 100     fReader.setCanvas(canvas);
 101 }
 102
 103 void* DeferredPipeController::requestBlock(size_t minRequest, size_t *actual) {
 104     if (fBlock) {
 105         // Save the previous block for later
 106         PipeBlock previousBloc(fBlock, fBytesWritten);
 107         fBlockList.push(previousBloc);
 108     }
 109     size_t blockSize = SkTMax<size_t>(minRequest, kMinBlockSize);
 110     fBlock = fAllocator.allocThrow(blockSize);
 111     fBytesWritten = 0;
 112     *actual = blockSize;
 113     return fBlock;
 114 }
 115
 116 void DeferredPipeController::notifyWritten(size_t bytes) {
 117     fBytesWritten += bytes;
 118 }
 119
 120 void DeferredPipeController::playback(bool silent) {
 121     uint32_t flags = silent ? SkGPipeReader::kSilent_PlaybackFlag : 0;
 122     for (int currentBlock = 0; currentBlock < fBlockList.count(); currentBlock++ ) {
 123         fReader.playback(fBlockList[currentBlock].fBlock, fBlockList[currentBlock].fSize,
 124                          flags);
 125     }
 126     fBlockList.reset();
 127
 128     if (fBlock) {
 129         fReader.playback(fBlock, fBytesWritten, flags);
 130         fBlock = NULL;
 131     }
 132
 133     // Release all allocated blocks
 134     fAllocator.reset();
 135 }
 136
 137 //-----------------------------------------------------------------------------
 138 // DeferredDevice
 139 //-----------------------------------------------------------------------------
 140 // FIXME: Derive from SkBaseDevice.
 141 class DeferredDevice : public SkBitmapDevice {
 142 public:
 143     explicit DeferredDevice(SkSurface* surface);
 144     ~DeferredDevice();
 145
 146     void setNotificationClient(SkDeferredCanvas::NotificationClient* notificationClient);
 147     SkCanvas* recordingCanvas();
 148     SkCanvas* immediateCanvas() const {return fImmediateCanvas;}
 149     SkBaseDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice();}
 150     SkImage* newImageSnapshot();
 151     void setSurface(SkSurface* surface);
 152     bool isFreshFrame();
 153     bool hasPendingCommands();
 154     size_t storageAllocatedForRecording() const;
 155     size_t freeMemoryIfPossible(size_t bytesToFree);
 156     size_t getBitmapSizeThreshold() const;
 157     void setBitmapSizeThreshold(size_t sizeThreshold);
 158     void flushPendingCommands(PlaybackMode);
 159     void skipPendingCommands();
 160     void setMaxRecordingStorage(size_t);
 161     void recordedDrawCommand();
 162
 163     virtual uint32_t getDeviceCapabilities() SK_OVERRIDE;
 164     virtual int width() const SK_OVERRIDE;
 165     virtual int height() const SK_OVERRIDE;
 166     virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE;
 167
 168     virtual SkBaseDevice* onCreateCompatibleDevice(SkBitmap::Config config,
 169                                                    int width, int height,
 170                                                    bool isOpaque,
 171                                                    Usage usage) SK_OVERRIDE;
 172
 173     virtual void writePixels(const SkBitmap& bitmap, int x, int y,
 174                                 SkCanvas::Config8888 config8888) SK_OVERRIDE;
 175
 176     virtual SkSurface* newSurface(const SkImageInfo&) SK_OVERRIDE;
 177
 178 protected:
 179     virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE;
 180     virtual bool onReadPixels(const SkBitmap& bitmap,
 181                                 int x, int y,
 182                                 SkCanvas::Config8888 config8888) SK_OVERRIDE;
 183
 184     // The following methods are no-ops on a deferred device
 185     virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) SK_OVERRIDE {
 186         return false;
 187     }
 188
 189     // None of the following drawing methods should ever get called on the
 190     // deferred device
 191     virtual void clear(SkColor color) SK_OVERRIDE
 192         {SkASSERT(0);}
 193     virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE
 194         {SkASSERT(0);}
 195     virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode,
 196                             size_t count, const SkPoint[],
 197                             const SkPaint& paint) SK_OVERRIDE
 198         {SkASSERT(0);}
 199     virtual void drawRect(const SkDraw&, const SkRect& r,
 200                             const SkPaint& paint) SK_OVERRIDE
 201         {SkASSERT(0);}
 202     virtual void drawRRect(const SkDraw&, const SkRRect& rr,
 203                            const SkPaint& paint) SK_OVERRIDE
 204         {SkASSERT(0);}
 205     virtual void drawPath(const SkDraw&, const SkPath& path,
 206                             const SkPaint& paint,
 207                             const SkMatrix* prePathMatrix = NULL,
 208                             bool pathIsMutable = false) SK_OVERRIDE
 209         {SkASSERT(0);}
 210     virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
 211                             const SkMatrix& matrix, const SkPaint& paint) SK_OVERRIDE
 212         {SkASSERT(0);}
 213     virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
 214                             int x, int y, const SkPaint& paint) SK_OVERRIDE
 215         {SkASSERT(0);}
 216     virtual void drawText(const SkDraw&, const void* text, size_t len,
 217                             SkScalar x, SkScalar y, const SkPaint& paint) SK_OVERRIDE
 218         {SkASSERT(0);}
 219     virtual void drawPosText(const SkDraw&, const void* text, size_t len,
 220                                 const SkScalar pos[], SkScalar constY,
 221                                 int scalarsPerPos, const SkPaint& paint) SK_OVERRIDE
 222         {SkASSERT(0);}
 223     virtual void drawTextOnPath(const SkDraw&, const void* text,
 224                                 size_t len, const SkPath& path,
 225                                 const SkMatrix* matrix,
 226                                 const SkPaint& paint) SK_OVERRIDE
 227         {SkASSERT(0);}
 228     virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode,
 229                                 int vertexCount, const SkPoint verts[],
 230                                 const SkPoint texs[], const SkColor colors[],
 231                                 SkXfermode* xmode, const uint16_t indices[],
 232                                 int indexCount, const SkPaint& paint) SK_OVERRIDE
 233         {SkASSERT(0);}
 234     virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
 235                             const SkPaint&) SK_OVERRIDE
 236         {SkASSERT(0);}
 237 private:
 238     virtual void flush() SK_OVERRIDE;
 239
 240     void beginRecording();
 241     void init();
 242     void aboutToDraw();
 243     void prepareForImmediatePixelWrite();
 244
 245     DeferredPipeController fPipeController;
 246     SkGPipeWriter  fPipeWriter;
 247     SkCanvas* fImmediateCanvas;
 248     SkCanvas* fRecordingCanvas;
 249     SkSurface* fSurface;
 250     SkDeferredCanvas::NotificationClient* fNotificationClient;
 251     bool fFreshFrame;
 252     bool fCanDiscardCanvasContents;
 253     size_t fMaxRecordingStorageBytes;
 254     size_t fPreviousStorageAllocated;
 255     size_t fBitmapSizeThreshold;
 256 };
 257
 258 DeferredDevice::DeferredDevice(SkSurface* surface)
 259     : SkBitmapDevice(SkBitmap::kNo_Config,
 260                      surface->getCanvas()->getDevice()->width(),
 261                      surface->getCanvas()->getDevice()->height(),
 262                      surface->getCanvas()->getDevice()->isOpaque(),
 263                      surface->getCanvas()->getDevice()->getDeviceProperties()) {
 264     fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
 265     fNotificationClient = NULL;
 266     fImmediateCanvas = NULL;
 267     fSurface = NULL;
 268     this->setSurface(surface);
 269     this->init();
 270 }
 271
 272 void DeferredDevice::setSurface(SkSurface* surface) {
 273     SkRefCnt_SafeAssign(fImmediateCanvas, surface->getCanvas());
 274     SkRefCnt_SafeAssign(fSurface, surface);
 275     fPipeController.setPlaybackCanvas(fImmediateCanvas);
 276 }
 277
 278 void DeferredDevice::init() {
 279     fRecordingCanvas = NULL;
 280     fFreshFrame = true;
 281     fCanDiscardCanvasContents = false;
 282     fPreviousStorageAllocated = 0;
 283     fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold;
 284     fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
 285     fNotificationClient = NULL;
 286     this->beginRecording();
 287 }
 288
 289 DeferredDevice::~DeferredDevice() {
 290     this->flushPendingCommands(kSilent_PlaybackMode);
 291     SkSafeUnref(fImmediateCanvas);
 292     SkSafeUnref(fSurface);
 293 }
 294
 295 void DeferredDevice::setMaxRecordingStorage(size_t maxStorage) {
 296     fMaxRecordingStorageBytes = maxStorage;
 297     this->recordingCanvas(); // Accessing the recording canvas applies the new limit.
 298 }
 299
 300 void DeferredDevice::beginRecording() {
 301     SkASSERT(NULL == fRecordingCanvas);
 302     fRecordingCanvas = fPipeWriter.startRecording(&fPipeController, 0,
 303         immediateDevice()->width(), immediateDevice()->height());
 304 }
 305
 306 void DeferredDevice::setNotificationClient(
 307     SkDeferredCanvas::NotificationClient* notificationClient) {
 308     fNotificationClient = notificationClient;
 309 }
 310
 311 void DeferredDevice::skipPendingCommands() {
 312     if (!fRecordingCanvas->isDrawingToLayer()) {
 313         fCanDiscardCanvasContents = true;
 314         if (fPipeController.hasPendingCommands()) {
 315             fFreshFrame = true;
 316             flushPendingCommands(kSilent_PlaybackMode);
 317             if (fNotificationClient) {
 318                 fNotificationClient->skippedPendingDrawCommands();
 319             }
 320         }
 321     }
 322 }
 323
 324 bool DeferredDevice::isFreshFrame() {
 325     bool ret = fFreshFrame;
 326     fFreshFrame = false;
 327     return ret;
 328 }
 329
 330 bool DeferredDevice::hasPendingCommands() {
 331     return fPipeController.hasPendingCommands();
 332 }
 333
 334 void DeferredDevice::aboutToDraw()
 335 {
 336     if (NULL != fNotificationClient) {
 337         fNotificationClient->prepareForDraw();
 338     }
 339     if (fCanDiscardCanvasContents) {
 340         if (NULL != fSurface) {
 341             fSurface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
 342         }
 343         fCanDiscardCanvasContents = false;
 344     }
 345 }
 346
 347 void DeferredDevice::flushPendingCommands(PlaybackMode playbackMode) {
 348     if (!fPipeController.hasPendingCommands()) {
 349         return;
 350     }
 351     if (playbackMode == kNormal_PlaybackMode) {
 352         aboutToDraw();
 353     }
 354     fPipeWriter.flushRecording(true);
 355     fPipeController.playback(kSilent_PlaybackMode == playbackMode);
 356     if (playbackMode == kNormal_PlaybackMode && fNotificationClient) {
 357         fNotificationClient->flushedDrawCommands();
 358     }
 359     fPreviousStorageAllocated = storageAllocatedForRecording();
 360 }
 361
 362 void DeferredDevice::flush() {
 363     this->flushPendingCommands(kNormal_PlaybackMode);
 364     fImmediateCanvas->flush();
 365 }
 366
 367 size_t DeferredDevice::freeMemoryIfPossible(size_t bytesToFree) {
 368     size_t val = fPipeWriter.freeMemoryIfPossible(bytesToFree);
 369     fPreviousStorageAllocated = storageAllocatedForRecording();
 370     return val;
 371 }
 372
 373 size_t DeferredDevice::getBitmapSizeThreshold() const {
 374     return fBitmapSizeThreshold;
 375 }
 376
 377 void DeferredDevice::setBitmapSizeThreshold(size_t sizeThreshold) {
 378     fBitmapSizeThreshold = sizeThreshold;
 379 }
 380
 381 size_t DeferredDevice::storageAllocatedForRecording() const {
 382     return (fPipeController.storageAllocatedForRecording()
 383             + fPipeWriter.storageAllocatedForRecording());
 384 }
 385
 386 void DeferredDevice::recordedDrawCommand() {
 387     size_t storageAllocated = this->storageAllocatedForRecording();
 388
 389     if (storageAllocated > fMaxRecordingStorageBytes) {
 390         // First, attempt to reduce cache without flushing
 391         size_t tryFree = storageAllocated - fMaxRecordingStorageBytes;
 392         if (this->freeMemoryIfPossible(tryFree) < tryFree) {
 393             // Flush is necessary to free more space.
 394             this->flushPendingCommands(kNormal_PlaybackMode);
 395             // Free as much as possible to avoid oscillating around fMaxRecordingStorageBytes
 396             // which could cause a high flushing frequency.
 397             this->freeMemoryIfPossible(~0U);
 398         }
 399         storageAllocated = this->storageAllocatedForRecording();
 400     }
 401
 402     if (fNotificationClient &&
 403         storageAllocated != fPreviousStorageAllocated) {
 404         fPreviousStorageAllocated = storageAllocated;
 405         fNotificationClient->storageAllocatedForRecordingChanged(storageAllocated);
 406     }
 407 }
 408
 409 SkCanvas* DeferredDevice::recordingCanvas() {
 410     return fRecordingCanvas;
 411 }
 412
 413 SkImage* DeferredDevice::newImageSnapshot() {
 414     this->flush();
 415     return fSurface ? fSurface->newImageSnapshot() : NULL;
 416 }
 417
 418 uint32_t DeferredDevice::getDeviceCapabilities() {
 419     return immediateDevice()->getDeviceCapabilities();
 420 }
 421
 422 int DeferredDevice::width() const {
 423     return immediateDevice()->width();
 424 }
 425
 426 int DeferredDevice::height() const {
 427     return immediateDevice()->height();
 428 }
 429
 430 GrRenderTarget* DeferredDevice::accessRenderTarget() {
 431     this->flushPendingCommands(kNormal_PlaybackMode);
 432     return immediateDevice()->accessRenderTarget();
 433 }
 434
 435 void DeferredDevice::prepareForImmediatePixelWrite() {
 436     // The purpose of the following code is to make sure commands are flushed, that
 437     // aboutToDraw() is called and that notifyContentWillChange is called, without
 438     // calling anything redundantly.
 439     if (fPipeController.hasPendingCommands()) {
 440         this->flushPendingCommands(kNormal_PlaybackMode);
 441     } else {
 442         bool mustNotifyDirectly = !fCanDiscardCanvasContents;
 443         this->aboutToDraw();
 444         if (mustNotifyDirectly) {
 445             fSurface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
 446         }
 447     }
 448
 449     fImmediateCanvas->flush();
 450 }
 451
 452 void DeferredDevice::writePixels(const SkBitmap& bitmap,
 453     int x, int y, SkCanvas::Config8888 config8888) {
 454
 455     if (x <= 0 && y <= 0 && (x + bitmap.width()) >= width() &&
 456         (y + bitmap.height()) >= height()) {
 457         this->skipPendingCommands();
 458     }
 459
 460     if (SkBitmap::kARGB_8888_Config == bitmap.config() &&
 461         SkCanvas::kNative_Premul_Config8888 != config8888 &&
 462         kPMColorAlias != config8888) {
 463         //Special case config: no deferral
 464         prepareForImmediatePixelWrite();
 465         immediateDevice()->writePixels(bitmap, x, y, config8888);
 466         return;
 467     }
 468
 469     SkPaint paint;
 470     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
 471     if (shouldDrawImmediately(&bitmap, NULL, getBitmapSizeThreshold())) {
 472         prepareForImmediatePixelWrite();
 473         fImmediateCanvas->drawSprite(bitmap, x, y, &paint);
 474     } else {
 475         this->recordingCanvas()->drawSprite(bitmap, x, y, &paint);
 476         this->recordedDrawCommand();
 477
 478     }
 479 }
 480
 481 const SkBitmap& DeferredDevice::onAccessBitmap() {
 482     this->flushPendingCommands(kNormal_PlaybackMode);
 483     return immediateDevice()->accessBitmap(false);
 484 }
 485
 486 SkBaseDevice* DeferredDevice::onCreateCompatibleDevice(
 487     SkBitmap::Config config, int width, int height, bool isOpaque,
 488     Usage usage) {
 489
 490     // Save layer usage not supported, and not required by SkDeferredCanvas.
 491     SkASSERT(usage != kSaveLayer_Usage);
 492     // Create a compatible non-deferred device.
 493     // We do not create a deferred device because we know the new device
 494     // will not be used with a deferred canvas (there is no API for that).
 495     // And connecting a DeferredDevice to non-deferred canvas can result
 496     // in unpredictable behavior.
 497     return immediateDevice()->createCompatibleDevice(config, width, height, isOpaque);
 498 }
 499
 500 SkSurface* DeferredDevice::newSurface(const SkImageInfo& info) {
 501     return this->immediateDevice()->newSurface(info);
 502 }
 503
 504 bool DeferredDevice::onReadPixels(
 505     const SkBitmap& bitmap, int x, int y, SkCanvas::Config8888 config8888) {
 506     this->flushPendingCommands(kNormal_PlaybackMode);
 507     return fImmediateCanvas->readPixels(const_cast<SkBitmap*>(&bitmap),
 508                                                    x, y, config8888);
 509 }
 510
 511 class AutoImmediateDrawIfNeeded {
 512 public:
 513     AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkBitmap* bitmap,
 514                               const SkPaint* paint) {
 515         this->init(canvas, bitmap, paint);
 516     }
 517
 518     AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkPaint* paint) {
 519         this->init(canvas, NULL, paint);
 520     }
 521
 522     ~AutoImmediateDrawIfNeeded() {
 523         if (fCanvas) {
 524             fCanvas->setDeferredDrawing(true);
 525         }
 526     }
 527 private:
 528     void init(SkDeferredCanvas& canvas, const SkBitmap* bitmap, const SkPaint* paint)
 529     {
 530         DeferredDevice* device = static_cast<DeferredDevice*>(canvas.getDevice());
 531         if (canvas.isDeferredDrawing() && (NULL != device) &&
 532             shouldDrawImmediately(bitmap, paint, device->getBitmapSizeThreshold())) {
 533             canvas.setDeferredDrawing(false);
 534             fCanvas = &canvas;
 535         } else {
 536             fCanvas = NULL;
 537         }
 538     }
 539
 540     SkDeferredCanvas* fCanvas;
 541 };
 542
 543 SkDeferredCanvas* SkDeferredCanvas::Create(SkSurface* surface) {
 544     SkAutoTUnref<DeferredDevice> deferredDevice(SkNEW_ARGS(DeferredDevice, (surface)));
 545     return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice));
 546 }
 547
 548 SkDeferredCanvas::SkDeferredCanvas(DeferredDevice* device) : SkCanvas (device) {
 549     this->init();
 550 }
 551
 552 void SkDeferredCanvas::init() {
 553     fDeferredDrawing = true; // On by default
 554 }
 555
 556 void SkDeferredCanvas::setMaxRecordingStorage(size_t maxStorage) {
 557     this->validate();
 558     this->getDeferredDevice()->setMaxRecordingStorage(maxStorage);
 559 }
 560
 561 size_t SkDeferredCanvas::storageAllocatedForRecording() const {
 562     return this->getDeferredDevice()->storageAllocatedForRecording();
 563 }
 564
 565 size_t SkDeferredCanvas::freeMemoryIfPossible(size_t bytesToFree) {
 566     return this->getDeferredDevice()->freeMemoryIfPossible(bytesToFree);
 567 }
 568
 569 void SkDeferredCanvas::setBitmapSizeThreshold(size_t sizeThreshold) {
 570     DeferredDevice* deferredDevice = this->getDeferredDevice();
 571     SkASSERT(deferredDevice);
 572     deferredDevice->setBitmapSizeThreshold(sizeThreshold);
 573 }
 574
 575 void SkDeferredCanvas::recordedDrawCommand() {
 576     if (fDeferredDrawing) {
 577         this->getDeferredDevice()->recordedDrawCommand();
 578     }
 579 }
 580
 581 void SkDeferredCanvas::validate() const {
 582     SkASSERT(this->getDevice());
 583 }
 584
 585 SkCanvas* SkDeferredCanvas::drawingCanvas() const {
 586     this->validate();
 587     return fDeferredDrawing ? this->getDeferredDevice()->recordingCanvas() :
 588         this->getDeferredDevice()->immediateCanvas();
 589 }
 590
 591 SkCanvas* SkDeferredCanvas::immediateCanvas() const {
 592     this->validate();
 593     return this->getDeferredDevice()->immediateCanvas();
 594 }
 595
 596 DeferredDevice* SkDeferredCanvas::getDeferredDevice() const {
 597     return static_cast<DeferredDevice*>(this->getDevice());
 598 }
 599
 600 void SkDeferredCanvas::setDeferredDrawing(bool val) {
 601     this->validate(); // Must set device before calling this method
 602     if (val != fDeferredDrawing) {
 603         if (fDeferredDrawing) {
 604             // Going live.
 605             this->getDeferredDevice()->flushPendingCommands(kNormal_PlaybackMode);
 606         }
 607         fDeferredDrawing = val;
 608     }
 609 }
 610
 611 bool SkDeferredCanvas::isDeferredDrawing() const {
 612     return fDeferredDrawing;
 613 }
 614
 615 bool SkDeferredCanvas::isFreshFrame() const {
 616     return this->getDeferredDevice()->isFreshFrame();
 617 }
 618
 619 bool SkDeferredCanvas::hasPendingCommands() const {
 620     return this->getDeferredDevice()->hasPendingCommands();
 621 }
 622
 623 void SkDeferredCanvas::silentFlush() {
 624     if (fDeferredDrawing) {
 625         this->getDeferredDevice()->flushPendingCommands(kSilent_PlaybackMode);
 626     }
 627 }
 628
 629 SkDeferredCanvas::~SkDeferredCanvas() {
 630 }
 631
 632 SkSurface* SkDeferredCanvas::setSurface(SkSurface* surface) {
 633     DeferredDevice* deferredDevice = this->getDeferredDevice();
 634     SkASSERT(NULL != deferredDevice);
 635     // By swapping the surface into the existing device, we preserve
 636     // all pending commands, which can help to seamlessly recover from
 637     // a lost accelerated graphics context.
 638     deferredDevice->setSurface(surface);
 639     return surface;
 640 }
 641
 642 SkDeferredCanvas::NotificationClient* SkDeferredCanvas::setNotificationClient(
 643     NotificationClient* notificationClient) {
 644
 645     DeferredDevice* deferredDevice = this->getDeferredDevice();
 646     SkASSERT(deferredDevice);
 647     if (deferredDevice) {
 648         deferredDevice->setNotificationClient(notificationClient);
 649     }
 650     return notificationClient;
 651 }
 652
 653 SkImage* SkDeferredCanvas::newImageSnapshot() {
 654     DeferredDevice* deferredDevice = this->getDeferredDevice();
 655     SkASSERT(deferredDevice);
 656     return deferredDevice ? deferredDevice->newImageSnapshot() : NULL;
 657 }
 658
 659 bool SkDeferredCanvas::isFullFrame(const SkRect* rect,
 660                                    const SkPaint* paint) const {
 661     SkCanvas* canvas = this->drawingCanvas();
 662     SkISize canvasSize = this->getDeviceSize();
 663     if (rect) {
 664         if (!canvas->getTotalMatrix().rectStaysRect()) {
 665             return false; // conservative
 666         }
 667
 668         SkRect transformedRect;
 669         canvas->getTotalMatrix().mapRect(&transformedRect, *rect);
 670
 671         if (paint) {
 672             SkPaint::Style paintStyle = paint->getStyle();
 673             if (!(paintStyle == SkPaint::kFill_Style ||
 674                 paintStyle == SkPaint::kStrokeAndFill_Style)) {
 675                 return false;
 676             }
 677             if (paint->getMaskFilter() || paint->getLooper()
 678                 || paint->getPathEffect() || paint->getImageFilter()) {
 679                 return false; // conservative
 680             }
 681         }
 682
 683         // The following test holds with AA enabled, and is conservative
 684         // by a 0.5 pixel margin with AA disabled
 685         if (transformedRect.fLeft > SkIntToScalar(0) ||
 686             transformedRect.fTop > SkIntToScalar(0) ||
 687             transformedRect.fRight < SkIntToScalar(canvasSize.fWidth) ||
 688             transformedRect.fBottom < SkIntToScalar(canvasSize.fHeight)) {
 689             return false;
 690         }
 691     }
 692
 693     return this->getClipStack()->quickContains(SkRect::MakeXYWH(0, 0,
 694         SkIntToScalar(canvasSize.fWidth), SkIntToScalar(canvasSize.fHeight)));
 695 }
 696
 697 int SkDeferredCanvas::save(SaveFlags flags) {
 698     this->drawingCanvas()->save(flags);
 699     int val = this->INHERITED::save(flags);
 700     this->recordedDrawCommand();
 701
 702     return val;
 703 }
 704
 705 int SkDeferredCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
 706                                 SaveFlags flags) {
 707     this->drawingCanvas()->saveLayer(bounds, paint, flags);
 708     int count = this->INHERITED::save(flags);
 709     this->clipRectBounds(bounds, flags, NULL);
 710     this->recordedDrawCommand();
 711
 712     return count;
 713 }
 714
 715 void SkDeferredCanvas::restore() {
 716     this->drawingCanvas()->restore();
 717     this->INHERITED::restore();
 718     this->recordedDrawCommand();
 719 }
 720
 721 bool SkDeferredCanvas::isDrawingToLayer() const {
 722     return this->drawingCanvas()->isDrawingToLayer();
 723 }
 724
 725 bool SkDeferredCanvas::translate(SkScalar dx, SkScalar dy) {
 726     this->drawingCanvas()->translate(dx, dy);
 727     bool val = this->INHERITED::translate(dx, dy);
 728     this->recordedDrawCommand();
 729     return val;
 730 }
 731
 732 bool SkDeferredCanvas::scale(SkScalar sx, SkScalar sy) {
 733     this->drawingCanvas()->scale(sx, sy);
 734     bool val = this->INHERITED::scale(sx, sy);
 735     this->recordedDrawCommand();
 736     return val;
 737 }
 738
 739 bool SkDeferredCanvas::rotate(SkScalar degrees) {
 740     this->drawingCanvas()->rotate(degrees);
 741     bool val = this->INHERITED::rotate(degrees);
 742     this->recordedDrawCommand();
 743     return val;
 744 }
 745
 746 bool SkDeferredCanvas::skew(SkScalar sx, SkScalar sy) {
 747     this->drawingCanvas()->skew(sx, sy);
 748     bool val = this->INHERITED::skew(sx, sy);
 749     this->recordedDrawCommand();
 750     return val;
 751 }
 752
 753 bool SkDeferredCanvas::concat(const SkMatrix& matrix) {
 754     this->drawingCanvas()->concat(matrix);
 755     bool val = this->INHERITED::concat(matrix);
 756     this->recordedDrawCommand();
 757     return val;
 758 }
 759
 760 void SkDeferredCanvas::setMatrix(const SkMatrix& matrix) {
 761     this->drawingCanvas()->setMatrix(matrix);
 762     this->INHERITED::setMatrix(matrix);
 763     this->recordedDrawCommand();
 764 }
 765
 766 bool SkDeferredCanvas::clipRect(const SkRect& rect,
 767                                 SkRegion::Op op,
 768                                 bool doAntiAlias) {
 769     this->drawingCanvas()->clipRect(rect, op, doAntiAlias);
 770     bool val = this->INHERITED::clipRect(rect, op, doAntiAlias);
 771     this->recordedDrawCommand();
 772     return val;
 773 }
 774
 775 bool SkDeferredCanvas::clipRRect(const SkRRect& rrect,
 776                                  SkRegion::Op op,
 777                                  bool doAntiAlias) {
 778     this->drawingCanvas()->clipRRect(rrect, op, doAntiAlias);
 779     bool val = this->INHERITED::clipRRect(rrect, op, doAntiAlias);
 780     this->recordedDrawCommand();
 781     return val;
 782 }
 783
 784 bool SkDeferredCanvas::clipPath(const SkPath& path,
 785                                 SkRegion::Op op,
 786                                 bool doAntiAlias) {
 787     this->drawingCanvas()->clipPath(path, op, doAntiAlias);
 788     bool val = this->INHERITED::clipPath(path, op, doAntiAlias);
 789     this->recordedDrawCommand();
 790     return val;
 791 }
 792
 793 bool SkDeferredCanvas::clipRegion(const SkRegion& deviceRgn,
 794                                   SkRegion::Op op) {
 795     this->drawingCanvas()->clipRegion(deviceRgn, op);
 796     bool val = this->INHERITED::clipRegion(deviceRgn, op);
 797     this->recordedDrawCommand();
 798     return val;
 799 }
 800
 801 void SkDeferredCanvas::clear(SkColor color) {
 802     // purge pending commands
 803     if (fDeferredDrawing) {
 804         this->getDeferredDevice()->skipPendingCommands();
 805     }
 806
 807     this->drawingCanvas()->clear(color);
 808     this->recordedDrawCommand();
 809 }
 810
 811 void SkDeferredCanvas::drawPaint(const SkPaint& paint) {
 812     if (fDeferredDrawing && this->isFullFrame(NULL, &paint) &&
 813         isPaintOpaque(&paint)) {
 814         this->getDeferredDevice()->skipPendingCommands();
 815     }
 816     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 817     this->drawingCanvas()->drawPaint(paint);
 818     this->recordedDrawCommand();
 819 }
 820
 821 void SkDeferredCanvas::drawPoints(PointMode mode, size_t count,
 822                                   const SkPoint pts[], const SkPaint& paint) {
 823     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 824     this->drawingCanvas()->drawPoints(mode, count, pts, paint);
 825     this->recordedDrawCommand();
 826 }
 827
 828 void SkDeferredCanvas::drawOval(const SkRect& rect, const SkPaint& paint) {
 829     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 830     this->drawingCanvas()->drawOval(rect, paint);
 831     this->recordedDrawCommand();
 832 }
 833
 834 void SkDeferredCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
 835     if (fDeferredDrawing && this->isFullFrame(&rect, &paint) &&
 836         isPaintOpaque(&paint)) {
 837         this->getDeferredDevice()->skipPendingCommands();
 838     }
 839
 840     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 841     this->drawingCanvas()->drawRect(rect, paint);
 842     this->recordedDrawCommand();
 843 }
 844
 845 void SkDeferredCanvas::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
 846     if (rrect.isRect()) {
 847         this->SkDeferredCanvas::drawRect(rrect.getBounds(), paint);
 848     } else if (rrect.isOval()) {
 849         this->SkDeferredCanvas::drawOval(rrect.getBounds(), paint);
 850     } else {
 851         AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 852         this->drawingCanvas()->drawRRect(rrect, paint);
 853         this->recordedDrawCommand();
 854     }
 855 }
 856
 857 void SkDeferredCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
 858     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 859     this->drawingCanvas()->drawPath(path, paint);
 860     this->recordedDrawCommand();
 861 }
 862
 863 void SkDeferredCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar left,
 864                                   SkScalar top, const SkPaint* paint) {
 865     SkRect bitmapRect = SkRect::MakeXYWH(left, top,
 866         SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height()));
 867     if (fDeferredDrawing &&
 868         this->isFullFrame(&bitmapRect, paint) &&
 869         isPaintOpaque(paint, &bitmap)) {
 870         this->getDeferredDevice()->skipPendingCommands();
 871     }
 872
 873     AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
 874     this->drawingCanvas()->drawBitmap(bitmap, left, top, paint);
 875     this->recordedDrawCommand();
 876 }
 877
 878 void SkDeferredCanvas::drawBitmapRectToRect(const SkBitmap& bitmap,
 879                                             const SkRect* src,
 880                                             const SkRect& dst,
 881                                             const SkPaint* paint,
 882                                             DrawBitmapRectFlags flags) {
 883     if (fDeferredDrawing &&
 884         this->isFullFrame(&dst, paint) &&
 885         isPaintOpaque(paint, &bitmap)) {
 886         this->getDeferredDevice()->skipPendingCommands();
 887     }
 888
 889     AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
 890     this->drawingCanvas()->drawBitmapRectToRect(bitmap, src, dst, paint, flags);
 891     this->recordedDrawCommand();
 892 }
 893
 894
 895 void SkDeferredCanvas::drawBitmapMatrix(const SkBitmap& bitmap,
 896                                         const SkMatrix& m,
 897                                         const SkPaint* paint) {
 898     // TODO: reset recording canvas if paint+bitmap is opaque and clip rect
 899     // covers canvas entirely and transformed bitmap covers canvas entirely
 900     AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
 901     this->drawingCanvas()->drawBitmapMatrix(bitmap, m, paint);
 902     this->recordedDrawCommand();
 903 }
 904
 905 void SkDeferredCanvas::drawBitmapNine(const SkBitmap& bitmap,
 906                                       const SkIRect& center, const SkRect& dst,
 907                                       const SkPaint* paint) {
 908     // TODO: reset recording canvas if paint+bitmap is opaque and clip rect
 909     // covers canvas entirely and dst covers canvas entirely
 910     AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
 911     this->drawingCanvas()->drawBitmapNine(bitmap, center, dst, paint);
 912     this->recordedDrawCommand();
 913 }
 914
 915 void SkDeferredCanvas::drawSprite(const SkBitmap& bitmap, int left, int top,
 916                                   const SkPaint* paint) {
 917     SkRect bitmapRect = SkRect::MakeXYWH(
 918         SkIntToScalar(left),
 919         SkIntToScalar(top),
 920         SkIntToScalar(bitmap.width()),
 921         SkIntToScalar(bitmap.height()));
 922     if (fDeferredDrawing &&
 923         this->isFullFrame(&bitmapRect, paint) &&
 924         isPaintOpaque(paint, &bitmap)) {
 925         this->getDeferredDevice()->skipPendingCommands();
 926     }
 927
 928     AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
 929     this->drawingCanvas()->drawSprite(bitmap, left, top, paint);
 930     this->recordedDrawCommand();
 931 }
 932
 933 void SkDeferredCanvas::drawText(const void* text, size_t byteLength,
 934                                 SkScalar x, SkScalar y, const SkPaint& paint) {
 935     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 936     this->drawingCanvas()->drawText(text, byteLength, x, y, paint);
 937     this->recordedDrawCommand();
 938 }
 939
 940 void SkDeferredCanvas::drawPosText(const void* text, size_t byteLength,
 941                                    const SkPoint pos[], const SkPaint& paint) {
 942     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 943     this->drawingCanvas()->drawPosText(text, byteLength, pos, paint);
 944     this->recordedDrawCommand();
 945 }
 946
 947 void SkDeferredCanvas::drawPosTextH(const void* text, size_t byteLength,
 948                                     const SkScalar xpos[], SkScalar constY,
 949                                     const SkPaint& paint) {
 950     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 951     this->drawingCanvas()->drawPosTextH(text, byteLength, xpos, constY, paint);
 952     this->recordedDrawCommand();
 953 }
 954
 955 void SkDeferredCanvas::drawTextOnPath(const void* text, size_t byteLength,
 956                                       const SkPath& path,
 957                                       const SkMatrix* matrix,
 958                                       const SkPaint& paint) {
 959     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 960     this->drawingCanvas()->drawTextOnPath(text, byteLength, path, matrix, paint);
 961     this->recordedDrawCommand();
 962 }
 963
 964 void SkDeferredCanvas::drawPicture(SkPicture& picture) {
 965     this->drawingCanvas()->drawPicture(picture);
 966     this->recordedDrawCommand();
 967 }
 968
 969 void SkDeferredCanvas::drawVertices(VertexMode vmode, int vertexCount,
 970                                     const SkPoint vertices[],
 971                                     const SkPoint texs[],
 972                                     const SkColor colors[], SkXfermode* xmode,
 973                                     const uint16_t indices[], int indexCount,
 974                                     const SkPaint& paint) {
 975     AutoImmediateDrawIfNeeded autoDraw(*this, &paint);
 976     this->drawingCanvas()->drawVertices(vmode, vertexCount, vertices, texs, colors, xmode,
 977                                         indices, indexCount, paint);
 978     this->recordedDrawCommand();
 979 }
 980
 981 SkBounder* SkDeferredCanvas::setBounder(SkBounder* bounder) {
 982     this->drawingCanvas()->setBounder(bounder);
 983     this->INHERITED::setBounder(bounder);
 984     this->recordedDrawCommand();
 985     return bounder;
 986 }
 987
 988 SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) {
 989     this->drawingCanvas()->setDrawFilter(filter);
 990     this->INHERITED::setDrawFilter(filter);
 991     this->recordedDrawCommand();
 992     return filter;
 993 }
 994
 995 SkCanvas* SkDeferredCanvas::canvasForDrawIter() {
 996     return this->drawingCanvas();
 997 }