unify how canvas checks for null on skia objects (images, blobs, pictures)

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
@@ skipping 23 matching lines @@
 #include "SkTLazy.h"
 #include "SkTraceEvent.h"
 
 #include <new>
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrRenderTarget.h"
 #include "SkGr.h"
 #endif
 

[robertphillips, 2016/01/08 16:44:19]

Aren't our macros usually all caps ?

[reed1, 2016/01/08 17:01:41]

Done.

+#define return_on_null(ptr)     do { if (nullptr == (ptr)) return; } while (0)
+
 /*
  *  Return true if the drawing this rect would hit every pixels in the canvas.
  *
  *  Returns false if
  *  - rect does not contain the canvas' bounds
  *  - paint is not fill
  *  - paint would blur or otherwise change the coverage of the rect
  */
 bool SkCanvas::wouldOverwriteEntireSurface(const SkRect* rect, const SkPaint* paint,
                                            ShaderOverrideOpacity overrideOpacity) const {
@@ skipping 771 matching lines @@
     return rec->fLayer->fDevice;
 }
 
 SkBaseDevice* SkCanvas::getTopDevice(bool updateMatrixClip) const {
     if (updateMatrixClip) {
         const_cast<SkCanvas*>(this)->updateDeviceCMCache();
     }
     return fMCRec->fTopLayer->fDevice;
 }
 
 bool SkCanvas::readPixels(SkBitmap* bitmap, int x, int y) {

[robertphillips, 2016/01/08 16:44:19]

here too ?

     if (kUnknown_SkColorType == bitmap->colorType() || bitmap->getTexture()) {
         return false;
     }
 
     bool weAllocated = false;
     if (nullptr == bitmap->pixelRef()) {
         if (!bitmap->tryAllocPixels()) {
             return false;
         }
         weAllocated = true;
     }
 
     SkAutoPixmapUnlock unlocker;
     if (bitmap->requestLock(&unlocker)) {
         const SkPixmap& pm = unlocker.pixmap();
         if (this->readPixels(pm.info(), pm.writable_addr(), pm.rowBytes(), x, y)) {
             return true;
         }
     }
 
     if (weAllocated) {
         bitmap->setPixelRef(nullptr);
     }
     return false;
 }
 
 bool SkCanvas::readPixels(const SkIRect& srcRect, SkBitmap* bitmap) {

[robertphillips, 2016/01/08 16:44:19]

here ?

     SkIRect r = srcRect;
     const SkISize size = this->getBaseLayerSize();
     if (!r.intersect(0, 0, size.width(), size.height())) {
         bitmap->reset();
         return false;
     }
 
     if (!bitmap->tryAllocN32Pixels(r.width(), r.height())) {
         // bitmap will already be reset.
         return false;
     }
     if (!this->readPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(), r.x(), r.y())) {
         bitmap->reset();
         return false;
     }
     return true;
 }
 
 bool SkCanvas::readPixels(const SkImageInfo& dstInfo, void* dstP, size_t rowBytes, int x, int y) {

[robertphillips, 2016/01/08 16:44:19]

here ?

     SkBaseDevice* device = this->getDevice();
     if (!device) {
         return false;
     }
     const SkISize size = this->getBaseLayerSize();
 
     SkReadPixelsRec rec(dstInfo, dstP, rowBytes, x, y);
     if (!rec.trim(size.width(), size.height())) {
         return false;
     }
@@ skipping 16 matching lines @@
 }
 
 bool SkCanvas::writePixels(const SkImageInfo& origInfo, const void* pixels, size_t rowBytes,
                            int x, int y) {
     switch (origInfo.colorType()) {
         case kUnknown_SkColorType:
         case kIndex_8_SkColorType:
             return false;
         default:
             break;
     }

[robertphillips, 2016/01/08 16:44:19]

here ?

     if (nullptr == pixels || rowBytes < origInfo.minRowBytes()) {
         return false;
     }
 
     const SkISize size = this->getBaseLayerSize();
     SkIRect target = SkIRect::MakeXYWH(x, y, origInfo.width(), origInfo.height());
     if (!target.intersect(0, 0, size.width(), size.height())) {
         return false;
     }
 
@@ skipping 817 matching lines @@
                 SkPath path;
                 element->asPath(&path);
                 rasterclip_path(&tmpClip, this, path, element->getOp(), element->isAA());
                 break;
             }
         }
     }
 }
 #endif
 
 void SkCanvas::replayClips(ClipVisitor* visitor) const {

[robertphillips, 2016/01/08 16:44:19]

here ?

     SkClipStack::B2TIter                iter(*fClipStack);
     const SkClipStack::Element*         element;
 
     while ((element = iter.next()) != nullptr) {
         element->replay(visitor);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 154 matching lines @@
                             const uint16_t indices[], int indexCount, const SkPaint& paint) {
     this->onDrawVertices(vmode, vertexCount, vertices, texs, colors, xmode,
                          indices, indexCount, paint);
 }
 
 void SkCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
     this->onDrawPath(path, paint);
 }
 
 void SkCanvas::drawImage(const SkImage* image, SkScalar x, SkScalar y, const SkPaint* paint) {
+    return_on_null(image);
     this->onDrawImage(image, x, y, paint);
 }
 
 void SkCanvas::drawImageRect(const SkImage* image, const SkRect& src, const SkRect& dst,
                              const SkPaint* paint, SrcRectConstraint constraint) {
+    return_on_null(image);
     if (dst.isEmpty() || src.isEmpty()) {
         return;
     }
     this->onDrawImageRect(image, &src, dst, paint, constraint);
 }
 
 void SkCanvas::drawImageRect(const SkImage* image, const SkIRect& isrc, const SkRect& dst,
                              const SkPaint* paint, SrcRectConstraint constraint) {
+    return_on_null(image);
     this->drawImageRect(image, SkRect::Make(isrc), dst, paint, constraint);
 }
 
 void SkCanvas::drawImageRect(const SkImage* image, const SkRect& dst, const SkPaint* paint,
                              SrcRectConstraint constraint) {
+    return_on_null(image);
     this->drawImageRect(image, SkRect::MakeIWH(image->width(), image->height()), dst, paint,
                         constraint);
 }
 
 void SkCanvas::drawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst,
                              const SkPaint* paint) {
+    return_on_null(image);
     if (dst.isEmpty()) {
         return;
     }
     if (!SkNinePatchIter::Valid(image->width(), image->height(), center)) {
         this->drawImageRect(image, dst, paint);
     }
     this->onDrawImageNine(image, center, dst, paint);
 }
 
 void SkCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar dx, SkScalar dy, const SkPaint* paint) {
@@ skipping 29 matching lines @@
     }
     if (!SkNinePatchIter::Valid(bitmap.width(), bitmap.height(), center)) {
         this->drawBitmapRect(bitmap, dst, paint);
     }
     this->onDrawBitmapNine(bitmap, center, dst, paint);
 }
 
 void SkCanvas::drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
                          const SkColor colors[], int count, SkXfermode::Mode mode,
                          const SkRect* cull, const SkPaint* paint) {
+    return_on_null(atlas);
     if (count <= 0) {
         return;
     }
     SkASSERT(atlas);
     SkASSERT(xform);
     SkASSERT(tex);
     this->onDrawAtlas(atlas, xform, tex, colors, count, mode, cull, paint);
 }
 
 void SkCanvas::legacy_drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
@@ skipping 622 matching lines @@
     TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawPosTextH()");
     this->onDrawPosTextH(text, byteLength, xpos, constY, paint);
 }
 void SkCanvas::drawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                               const SkMatrix* matrix, const SkPaint& paint) {
     TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawTextOnPath()");
     this->onDrawTextOnPath(text, byteLength, path, matrix, paint);
 }
 void SkCanvas::drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                             const SkPaint& paint) {
+    return_on_null(blob);
     TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawTextBlob()");
-    if (blob) {
-        this->onDrawTextBlob(blob, x, y, paint);
-    }
+    this->onDrawTextBlob(blob, x, y, paint);
 }
 
 void SkCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
                               const SkPoint verts[], const SkPoint texs[],
                               const SkColor colors[], SkXfermode* xmode,
                               const uint16_t indices[], int indexCount,
                               const SkPaint& paint) {
     TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawVertices()");
     LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type, nullptr)
 
@@ skipping 30 matching lines @@
     LOOPER_BEGIN(paint, SkDrawFilter::kPath_Type, nullptr)
 
     while (iter.next()) {
         iter.fDevice->drawPatch(iter, cubics, colors, texCoords, xmode, paint);
     }
 
     LOOPER_END
 }
 
 void SkCanvas::drawDrawable(SkDrawable* dr, SkScalar x, SkScalar y) {
-    if (dr) {
-        if (x || y) {
-            SkMatrix matrix = SkMatrix::MakeTrans(x, y);
-            this->onDrawDrawable(dr, &matrix);
-        } else {
-            this->onDrawDrawable(dr, nullptr);
-        }
+    return_on_null(dr);
+    if (x || y) {
+        SkMatrix matrix = SkMatrix::MakeTrans(x, y);
+        this->onDrawDrawable(dr, &matrix);
+    } else {
+        this->onDrawDrawable(dr, nullptr);
     }
 }
 
 void SkCanvas::drawDrawable(SkDrawable* dr, const SkMatrix* matrix) {
-    if (dr) {
-        if (matrix && matrix->isIdentity()) {
-            matrix = nullptr;
-        }
-        this->onDrawDrawable(dr, matrix);
+    return_on_null(dr);
+    if (matrix && matrix->isIdentity()) {
+        matrix = nullptr;
     }
+    this->onDrawDrawable(dr, matrix);
 }
 
 void SkCanvas::onDrawDrawable(SkDrawable* dr, const SkMatrix* matrix) {
     SkRect bounds = dr->getBounds();
     if (matrix) {
         matrix->mapRect(&bounds);
     }
     if (this->quickReject(bounds)) {
         return;
     }
@@ skipping 149 matching lines @@
 /**
  *  This constant is trying to balance the speed of ref'ing a subpicture into a parent picture,
  *  against the playback cost of recursing into the subpicture to get at its actual ops.
  *
  *  For now we pick a conservatively small value, though measurement (and other heuristics like
  *  the type of ops contained) may justify changing this value.
  */
 #define kMaxPictureOpsToUnrollInsteadOfRef  1
 
 void SkCanvas::drawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint) {
+    return_on_null(picture);
+
     TRACE_EVENT0("disabled-by-default-skia", "SkCanvas::drawPicture()");
-    if (picture) {
-        if (matrix && matrix->isIdentity()) {
-            matrix = nullptr;
-        }
-        if (picture->approximateOpCount() <= kMaxPictureOpsToUnrollInsteadOfRef) {
-            SkAutoCanvasMatrixPaint acmp(this, matrix, paint, picture->cullRect());
-            picture->playback(this);
-        } else {
-            this->onDrawPicture(picture, matrix, paint);
-        }
+    if (matrix && matrix->isIdentity()) {
+        matrix = nullptr;
+    }
+    if (picture->approximateOpCount() <= kMaxPictureOpsToUnrollInsteadOfRef) {
+        SkAutoCanvasMatrixPaint acmp(this, matrix, paint, picture->cullRect());
+        picture->playback(this);
+    } else {
+        this->onDrawPicture(picture, matrix, paint);
     }
 }
 
 void SkCanvas::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix,
                              const SkPaint* paint) {
     if (!paint || paint->canComputeFastBounds()) {
         SkRect bounds = picture->cullRect();
         if (paint) {
             paint->computeFastBounds(bounds, &bounds);
         }
@@ skipping 115 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }