Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(22)

Side by Side Diff: src/utils/SkDeferredCanvas.cpp

Issue 355193006: stop calling SkCanvas::getDevice (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Created 6 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 1
2 /* 2 /*
3 * Copyright 2013 Google Inc. 3 * Copyright 2013 Google Inc.
4 * 4 *
5 * Use of this source code is governed by a BSD-style license that can be 5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file. 6 * found in the LICENSE file.
7 */ 7 */
8 8
9 #include "SkDeferredCanvas.h" 9 #include "SkDeferredCanvas.h"
10 10
(...skipping 11 matching lines...) Expand all
22 enum { 22 enum {
23 // Deferred canvas will auto-flush when recording reaches this limit 23 // Deferred canvas will auto-flush when recording reaches this limit
24 kDefaultMaxRecordingStorageBytes = 64*1024*1024, 24 kDefaultMaxRecordingStorageBytes = 64*1024*1024,
25 kDeferredCanvasBitmapSizeThreshold = ~0U, // Disables this feature 25 kDeferredCanvasBitmapSizeThreshold = ~0U, // Disables this feature
26 }; 26 };
27 27
28 enum PlaybackMode { 28 enum PlaybackMode {
29 kNormal_PlaybackMode, 29 kNormal_PlaybackMode,
30 kSilent_PlaybackMode, 30 kSilent_PlaybackMode,
31 }; 31 };
32 32
robertphillips 2014/06/30 13:36:20 should_draw_immediately ?
reed1 2014/06/30 14:33:12 Done.
33 static bool shouldDrawImmediately(const SkBitmap* bitmap, const SkPaint* paint, 33 static bool shouldDrawImmediately(const SkBitmap* bitmap, const SkPaint* paint,
34 size_t bitmapSizeThreshold) { 34 size_t bitmapSizeThreshold) {
35 if (bitmap && ((bitmap->getTexture() && !bitmap->isImmutable()) || 35 if (bitmap && ((bitmap->getTexture() && !bitmap->isImmutable()) ||
36 (bitmap->getSize() > bitmapSizeThreshold))) { 36 (bitmap->getSize() > bitmapSizeThreshold))) {
37 return true; 37 return true;
38 } 38 }
39 if (paint) { 39 if (paint) {
40 SkShader* shader = paint->getShader(); 40 SkShader* shader = paint->getShader();
41 // Here we detect the case where the shader is an SkBitmapProcShader 41 // Here we detect the case where the shader is an SkBitmapProcShader
42 // with a gpu texture attached. Checking this without RTTI 42 // with a gpu texture attached. Checking this without RTTI
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after
143 void setNotificationClient(SkDeferredCanvas::NotificationClient* notificatio nClient); 143 void setNotificationClient(SkDeferredCanvas::NotificationClient* notificatio nClient);
144 SkCanvas* recordingCanvas(); 144 SkCanvas* recordingCanvas();
145 SkCanvas* immediateCanvas() const {return fImmediateCanvas;} 145 SkCanvas* immediateCanvas() const {return fImmediateCanvas;}
146 SkBaseDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice ();} 146 SkBaseDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice ();}
147 SkImage* newImageSnapshot(); 147 SkImage* newImageSnapshot();
148 void setSurface(SkSurface* surface); 148 void setSurface(SkSurface* surface);
149 bool isFreshFrame(); 149 bool isFreshFrame();
150 bool hasPendingCommands(); 150 bool hasPendingCommands();
151 size_t storageAllocatedForRecording() const; 151 size_t storageAllocatedForRecording() const;
152 size_t freeMemoryIfPossible(size_t bytesToFree); 152 size_t freeMemoryIfPossible(size_t bytesToFree);
153 size_t getBitmapSizeThreshold() const;
154 void setBitmapSizeThreshold(size_t sizeThreshold);
155 void flushPendingCommands(PlaybackMode); 153 void flushPendingCommands(PlaybackMode);
156 void skipPendingCommands(); 154 void skipPendingCommands();
157 void setMaxRecordingStorage(size_t); 155 void setMaxRecordingStorage(size_t);
158 void recordedDrawCommand(); 156 void recordedDrawCommand();
159 157
160 virtual SkImageInfo imageInfo() const SK_OVERRIDE; 158 virtual SkImageInfo imageInfo() const SK_OVERRIDE;
161 159
162 virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE; 160 virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE;
163 161
164 virtual SkBaseDevice* onCreateDevice(const SkImageInfo&, Usage) SK_OVERRIDE; 162 virtual SkBaseDevice* onCreateDevice(const SkImageInfo&, Usage) SK_OVERRIDE;
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after
256 DeferredPipeController fPipeController; 254 DeferredPipeController fPipeController;
257 SkGPipeWriter fPipeWriter; 255 SkGPipeWriter fPipeWriter;
258 SkCanvas* fImmediateCanvas; 256 SkCanvas* fImmediateCanvas;
259 SkCanvas* fRecordingCanvas; 257 SkCanvas* fRecordingCanvas;
260 SkSurface* fSurface; 258 SkSurface* fSurface;
261 SkDeferredCanvas::NotificationClient* fNotificationClient; 259 SkDeferredCanvas::NotificationClient* fNotificationClient;
262 bool fFreshFrame; 260 bool fFreshFrame;
263 bool fCanDiscardCanvasContents; 261 bool fCanDiscardCanvasContents;
264 size_t fMaxRecordingStorageBytes; 262 size_t fMaxRecordingStorageBytes;
265 size_t fPreviousStorageAllocated; 263 size_t fPreviousStorageAllocated;
266 size_t fBitmapSizeThreshold;
267 }; 264 };
268 265
269 SkDeferredDevice::SkDeferredDevice(SkSurface* surface) { 266 SkDeferredDevice::SkDeferredDevice(SkSurface* surface) {
270 fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes; 267 fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
271 fNotificationClient = NULL; 268 fNotificationClient = NULL;
272 fImmediateCanvas = NULL; 269 fImmediateCanvas = NULL;
273 fSurface = NULL; 270 fSurface = NULL;
274 this->setSurface(surface); 271 this->setSurface(surface);
275 this->init(); 272 this->init();
276 } 273 }
277 274
278 void SkDeferredDevice::setSurface(SkSurface* surface) { 275 void SkDeferredDevice::setSurface(SkSurface* surface) {
279 SkRefCnt_SafeAssign(fImmediateCanvas, surface->getCanvas()); 276 SkRefCnt_SafeAssign(fImmediateCanvas, surface->getCanvas());
280 SkRefCnt_SafeAssign(fSurface, surface); 277 SkRefCnt_SafeAssign(fSurface, surface);
281 fPipeController.setPlaybackCanvas(fImmediateCanvas); 278 fPipeController.setPlaybackCanvas(fImmediateCanvas);
282 } 279 }
283 280
284 void SkDeferredDevice::init() { 281 void SkDeferredDevice::init() {
285 fRecordingCanvas = NULL; 282 fRecordingCanvas = NULL;
286 fFreshFrame = true; 283 fFreshFrame = true;
287 fCanDiscardCanvasContents = false; 284 fCanDiscardCanvasContents = false;
288 fPreviousStorageAllocated = 0; 285 fPreviousStorageAllocated = 0;
289 fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold;
290 fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes; 286 fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
291 fNotificationClient = NULL; 287 fNotificationClient = NULL;
292 this->beginRecording(); 288 this->beginRecording();
293 } 289 }
294 290
295 SkDeferredDevice::~SkDeferredDevice() { 291 SkDeferredDevice::~SkDeferredDevice() {
296 this->flushPendingCommands(kSilent_PlaybackMode); 292 this->flushPendingCommands(kSilent_PlaybackMode);
297 SkSafeUnref(fImmediateCanvas); 293 SkSafeUnref(fImmediateCanvas);
298 SkSafeUnref(fSurface); 294 SkSafeUnref(fSurface);
299 } 295 }
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after
371 this->flushPendingCommands(kNormal_PlaybackMode); 367 this->flushPendingCommands(kNormal_PlaybackMode);
372 fImmediateCanvas->flush(); 368 fImmediateCanvas->flush();
373 } 369 }
374 370
375 size_t SkDeferredDevice::freeMemoryIfPossible(size_t bytesToFree) { 371 size_t SkDeferredDevice::freeMemoryIfPossible(size_t bytesToFree) {
376 size_t val = fPipeWriter.freeMemoryIfPossible(bytesToFree); 372 size_t val = fPipeWriter.freeMemoryIfPossible(bytesToFree);
377 fPreviousStorageAllocated = storageAllocatedForRecording(); 373 fPreviousStorageAllocated = storageAllocatedForRecording();
378 return val; 374 return val;
379 } 375 }
380 376
381 size_t SkDeferredDevice::getBitmapSizeThreshold() const {
382 return fBitmapSizeThreshold;
383 }
384
385 void SkDeferredDevice::setBitmapSizeThreshold(size_t sizeThreshold) {
386 fBitmapSizeThreshold = sizeThreshold;
387 }
388
389 size_t SkDeferredDevice::storageAllocatedForRecording() const { 377 size_t SkDeferredDevice::storageAllocatedForRecording() const {
390 return (fPipeController.storageAllocatedForRecording() 378 return (fPipeController.storageAllocatedForRecording()
391 + fPipeWriter.storageAllocatedForRecording()); 379 + fPipeWriter.storageAllocatedForRecording());
392 } 380 }
393 381
394 void SkDeferredDevice::recordedDrawCommand() { 382 void SkDeferredDevice::recordedDrawCommand() {
395 size_t storageAllocated = this->storageAllocatedForRecording(); 383 size_t storageAllocated = this->storageAllocatedForRecording();
396 384
397 if (storageAllocated > fMaxRecordingStorageBytes) { 385 if (storageAllocated > fMaxRecordingStorageBytes) {
398 // First, attempt to reduce cache without flushing 386 // First, attempt to reduce cache without flushing
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after
502 AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkPaint* paint) { 490 AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkPaint* paint) {
503 this->init(canvas, NULL, paint); 491 this->init(canvas, NULL, paint);
504 } 492 }
505 493
506 ~AutoImmediateDrawIfNeeded() { 494 ~AutoImmediateDrawIfNeeded() {
507 if (fCanvas) { 495 if (fCanvas) {
508 fCanvas->setDeferredDrawing(true); 496 fCanvas->setDeferredDrawing(true);
509 } 497 }
510 } 498 }
511 private: 499 private:
512 void init(SkDeferredCanvas& canvas, const SkBitmap* bitmap, const SkPaint* p aint) 500 void init(SkDeferredCanvas& canvas, const SkBitmap* bitmap, const SkPaint* p aint) {
513 { 501 if (canvas.isDeferredDrawing() &&
514 SkDeferredDevice* device = static_cast<SkDeferredDevice*>(canvas.getDevi ce()); 502 shouldDrawImmediately(bitmap, paint, canvas.getBitmapSizeThreshold() )) {
515 if (canvas.isDeferredDrawing() && (NULL != device) &&
516 shouldDrawImmediately(bitmap, paint, device->getBitmapSizeThreshold( ))) {
517 canvas.setDeferredDrawing(false); 503 canvas.setDeferredDrawing(false);
518 fCanvas = &canvas; 504 fCanvas = &canvas;
519 } else { 505 } else {
520 fCanvas = NULL; 506 fCanvas = NULL;
521 } 507 }
522 } 508 }
523 509
524 SkDeferredCanvas* fCanvas; 510 SkDeferredCanvas* fCanvas;
525 }; 511 };
526 512
527 SkDeferredCanvas* SkDeferredCanvas::Create(SkSurface* surface) { 513 SkDeferredCanvas* SkDeferredCanvas::Create(SkSurface* surface) {
528 SkAutoTUnref<SkDeferredDevice> deferredDevice(SkNEW_ARGS(SkDeferredDevice, ( surface))); 514 SkAutoTUnref<SkDeferredDevice> deferredDevice(SkNEW_ARGS(SkDeferredDevice, ( surface)));
529 return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice)); 515 return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice));
530 } 516 }
531 517
532 SkDeferredCanvas::SkDeferredCanvas(SkDeferredDevice* device) : SkCanvas (device) { 518 SkDeferredCanvas::SkDeferredCanvas(SkDeferredDevice* device) : SkCanvas (device) {
533 this->init(); 519 this->init();
534 } 520 }
535 521
536 void SkDeferredCanvas::init() { 522 void SkDeferredCanvas::init() {
523 fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold;
537 fDeferredDrawing = true; // On by default 524 fDeferredDrawing = true; // On by default
538 } 525 }
539 526
540 void SkDeferredCanvas::setMaxRecordingStorage(size_t maxStorage) { 527 void SkDeferredCanvas::setMaxRecordingStorage(size_t maxStorage) {
541 this->validate(); 528 this->validate();
542 this->getDeferredDevice()->setMaxRecordingStorage(maxStorage); 529 this->getDeferredDevice()->setMaxRecordingStorage(maxStorage);
543 } 530 }
544 531
545 size_t SkDeferredCanvas::storageAllocatedForRecording() const { 532 size_t SkDeferredCanvas::storageAllocatedForRecording() const {
546 return this->getDeferredDevice()->storageAllocatedForRecording(); 533 return this->getDeferredDevice()->storageAllocatedForRecording();
547 } 534 }
548 535
549 size_t SkDeferredCanvas::freeMemoryIfPossible(size_t bytesToFree) { 536 size_t SkDeferredCanvas::freeMemoryIfPossible(size_t bytesToFree) {
550 return this->getDeferredDevice()->freeMemoryIfPossible(bytesToFree); 537 return this->getDeferredDevice()->freeMemoryIfPossible(bytesToFree);
551 } 538 }
552 539
553 void SkDeferredCanvas::setBitmapSizeThreshold(size_t sizeThreshold) { 540 void SkDeferredCanvas::setBitmapSizeThreshold(size_t sizeThreshold) {
554 SkDeferredDevice* deferredDevice = this->getDeferredDevice(); 541 fBitmapSizeThreshold = sizeThreshold;
555 SkASSERT(deferredDevice);
556 deferredDevice->setBitmapSizeThreshold(sizeThreshold);
557 } 542 }
558 543
559 void SkDeferredCanvas::recordedDrawCommand() { 544 void SkDeferredCanvas::recordedDrawCommand() {
560 if (fDeferredDrawing) { 545 if (fDeferredDrawing) {
561 this->getDeferredDevice()->recordedDrawCommand(); 546 this->getDeferredDevice()->recordedDrawCommand();
562 } 547 }
563 } 548 }
564 549
565 void SkDeferredCanvas::validate() const { 550 void SkDeferredCanvas::validate() const {
566 SkASSERT(this->getDevice()); 551 SkASSERT(this->getDevice());
(...skipping 365 matching lines...) Expand 10 before | Expand all | Expand 10 after
932 SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) { 917 SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) {
933 this->drawingCanvas()->setDrawFilter(filter); 918 this->drawingCanvas()->setDrawFilter(filter);
934 this->INHERITED::setDrawFilter(filter); 919 this->INHERITED::setDrawFilter(filter);
935 this->recordedDrawCommand(); 920 this->recordedDrawCommand();
936 return filter; 921 return filter;
937 } 922 }
938 923
939 SkCanvas* SkDeferredCanvas::canvasForDrawIter() { 924 SkCanvas* SkDeferredCanvas::canvasForDrawIter() {
940 return this->drawingCanvas(); 925 return this->drawingCanvas();
941 } 926 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698