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