Make drawImage a virtual on SkDevice

src/utils/SkDeferredCanvas.cpp

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDeferredCanvas.h"
 
@@ skipping 17 matching lines @@
 };
 
 enum PlaybackMode {
     kNormal_PlaybackMode,
     kSilent_PlaybackMode,
 };
 
 static bool should_draw_immediately(const SkBitmap* bitmap, const SkPaint* paint,
                                     size_t bitmapSizeThreshold) {
     if (bitmap && ((bitmap->getTexture() && !bitmap->isImmutable()) ||
-        (bitmap->getSize() > bitmapSizeThreshold))) {
+                   (bitmap->getSize() > bitmapSizeThreshold))) {
         return true;
     }
     if (paint) {
+        SkShader* shader = paint->getShader();
+        // Here we detect the case where the shader is an SkBitmapProcShader

[mtklein, 2015/05/05 18:50:01]

Let's pull out a static function for this bit?

[reed1, 2015/05/05 19:45:15]

Done.

+        // with a gpu texture attached.  Checking this without RTTI
+        // requires making the assumption that only gradient shaders
+        // and SkBitmapProcShader implement asABitmap().  The following
+        // code may need to be revised if that assumption is ever broken.
+        if (shader && !shader->asAGradient(NULL)) {
+            SkBitmap bm;
+            if (shader->asABitmap(&bm, NULL, NULL) &&
+                bm.getTexture()) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+static uint64_t image_area(const SkImage* image) {
+    return sk_64_mul(image->width(), image->height());
+}
+
+static bool should_draw_immediately(const SkImage* image, const SkPaint* paint,
+                                    size_t imageSizeThreshold) {
+    if (image && (image_area(image) > imageSizeThreshold)) {
+        return true;
+    }
+    if (paint) {
         SkShader* shader = paint->getShader();
         // Here we detect the case where the shader is an SkBitmapProcShader
         // with a gpu texture attached.  Checking this without RTTI
         // requires making the assumption that only gradient shaders
         // and SkBitmapProcShader implement asABitmap().  The following
         // code may need to be revised if that assumption is ever broken.
         if (shader && !shader->asAGradient(NULL)) {
             SkBitmap bm;
             if (shader->asABitmap(&bm, NULL, NULL) &&
                 bm.getTexture()) {
@@ skipping 143 matching lines @@
     void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
                     const SkMatrix& matrix, const SkPaint& paint) override
         {SkASSERT(0);}
     void drawBitmapRect(const SkDraw&, const SkBitmap&, const SkRect*,
                         const SkRect&, const SkPaint&,
                         SkCanvas::DrawBitmapRectFlags) override
         {SkASSERT(0);}
     void drawSprite(const SkDraw&, const SkBitmap& bitmap,
                     int x, int y, const SkPaint& paint) override
         {SkASSERT(0);}
+    void drawImage(const SkDraw&, const SkImage*, SkScalar, SkScalar, const SkPaint&) override
+        {SkASSERT(0);}
+    void drawImageRect(const SkDraw&, const SkImage*, const SkRect*, const SkRect&,
+                       const SkPaint&) override
+        {SkASSERT(0);}
     void drawText(const SkDraw&, const void* text, size_t len,
                   SkScalar x, SkScalar y, const SkPaint& paint) override
         {SkASSERT(0);}
     void drawPosText(const SkDraw&, const void* text, size_t len,
                      const SkScalar pos[], int scalarsPerPos,
                      const SkPoint& offset, const SkPaint& paint) override
         {SkASSERT(0);}
     void drawTextOnPath(const SkDraw&, const void* text,
                         size_t len, const SkPath& path,
                         const SkMatrix* matrix,
@@ skipping 261 matching lines @@
     this->flushPendingCommands(kNormal_PlaybackMode);
     return fImmediateCanvas->readPixels(info, pixels, rowBytes, x, y);
 }
 
 class AutoImmediateDrawIfNeeded {
 public:
     AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkBitmap* bitmap,
                               const SkPaint* paint) {
         this->init(canvas, bitmap, paint);
     }
+    AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkImage* image,

[mtklein, 2015/05/05 18:50:01]

This seems weirdly asymmetrical.  Let's make init take (canvas, bitmap, image,
paint)?

[reed1, 2015/05/05 19:45:15]

Done.

+                              const SkPaint* paint) {
+        if (canvas.isDeferredDrawing() &&
+            should_draw_immediately(image, paint, canvas.getBitmapSizeThreshold())) {
+            canvas.setDeferredDrawing(false);
+            fCanvas = &canvas;
+        } else {
+            fCanvas = NULL;
+        }
+    }
 
     AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkPaint* paint) {
         this->init(canvas, NULL, paint);
     }
 
     ~AutoImmediateDrawIfNeeded() {
         if (fCanvas) {
             fCanvas->setDeferredDrawing(true);
         }
     }
@@ skipping 333 matching lines @@
         this->isFullFrame(&dst, paint) &&
         isPaintOpaque(paint, &bitmap)) {
         this->getDeferredDevice()->skipPendingCommands();
     }
 
     AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
     this->drawingCanvas()->drawBitmapRectToRect(bitmap, src, dst, paint, flags);
     this->recordedDrawCommand();
 }
 
+
+void SkDeferredCanvas::onDrawImage(const SkImage* image, SkScalar x, SkScalar y,
+                                   const SkPaint* paint) {
+    SkRect bounds = SkRect::MakeXYWH(x, y,
+                                     SkIntToScalar(image->width()), SkIntToScalar(image->height()));
+    if (fDeferredDrawing &&
+        this->isFullFrame(&bounds, paint) &&
+        isPaintOpaque(paint, image)) {
+        this->getDeferredDevice()->skipPendingCommands();
+    }
+    
+    AutoImmediateDrawIfNeeded autoDraw(*this, image, paint);
+    this->drawingCanvas()->drawImage(image, x, y, paint);
+    this->recordedDrawCommand();
+}
+void SkDeferredCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
+                                       const SkPaint* paint) {
+    if (fDeferredDrawing &&
+        this->isFullFrame(&dst, paint) &&
+        isPaintOpaque(paint, image)) {
+        this->getDeferredDevice()->skipPendingCommands();
+    }
+    
+    AutoImmediateDrawIfNeeded autoDraw(*this, image, paint);
+    this->drawingCanvas()->drawImageRect(image, src, dst, paint);
+    this->recordedDrawCommand();
+}
+
 void SkDeferredCanvas::onDrawBitmapNine(const SkBitmap& bitmap,
                                         const SkIRect& center, const SkRect& dst,
                                         const SkPaint* paint) {
     // TODO: reset recording canvas if paint+bitmap is opaque and clip rect
     // covers canvas entirely and dst covers canvas entirely
     AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint);
     this->drawingCanvas()->drawBitmapNine(bitmap, center, dst, paint);
     this->recordedDrawCommand();
 }
 
@@ skipping 79 matching lines @@
 SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) {
     this->drawingCanvas()->setDrawFilter(filter);
     this->INHERITED::setDrawFilter(filter);
     this->recordedDrawCommand();
     return filter;
 }
 
 SkCanvas* SkDeferredCanvas::canvasForDrawIter() {
     return this->drawingCanvas();
 }