make LayerIter private, and remove skipClip option

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 300 matching lines @@
         SkASSERT(fDeferredSaveCount == 0);
 
         fMatrix.reset();
         fRasterClip.setRect(bounds);
         fLayer->reset(bounds);
     }
 };
 
 class SkDrawIter : public SkDraw {
 public:
-    SkDrawIter(SkCanvas* canvas, bool skipEmptyClips = true) {
+    SkDrawIter(SkCanvas* canvas) {
         canvas = canvas->canvasForDrawIter();
         fCanvas = canvas;
         canvas->updateDeviceCMCache();
 
         fClipStack = canvas->fClipStack;
         fCurrLayer = canvas->fMCRec->fTopLayer;
-        fSkipEmptyClips = skipEmptyClips;
     }
 
     bool next() {
         // skip over recs with empty clips
-        if (fSkipEmptyClips) {
-            while (fCurrLayer && fCurrLayer->fClip.isEmpty()) {
-                fCurrLayer = fCurrLayer->fNext;
-            }
+        while (fCurrLayer && fCurrLayer->fClip.isEmpty()) {
+            fCurrLayer = fCurrLayer->fNext;
         }
 
         const DeviceCM* rec = fCurrLayer;
         if (rec && rec->fDevice) {
 
             fMatrix = rec->fMatrix;
             fRC     = &rec->fClip;
             fDevice = rec->fDevice;
             if (!fDevice->accessPixels(&fDst)) {
                 fDst.reset(fDevice->imageInfo(), nullptr, 0);
@@ skipping 13 matching lines @@
     const SkRasterClip& getClip() const { return *fRC; }
     int getX() const { return fDevice->getOrigin().x(); }
     int getY() const { return fDevice->getOrigin().y(); }
     const SkMatrix& getMatrix() const { return *fMatrix; }
     const SkPaint* getPaint() const { return fPaint; }
 
 private:
     SkCanvas*       fCanvas;
     const DeviceCM* fCurrLayer;
     const SkPaint*  fPaint;     // May be null.
-    SkBool8         fSkipEmptyClips;
 
     typedef SkDraw INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////////////
 
 static SkPaint* set_if_needed(SkLazyPaint* lazy, const SkPaint& orig) {
     return lazy->isValid() ? lazy->get() : lazy->set(orig);
 }
 
@@ skipping 44 matching lines @@
     } else {
         return rawBounds;
     }
 }
 
 class AutoDrawLooper {
 public:
     // "rawBounds" is the original bounds of the primitive about to be drawn, unmodified by the
     // paint. It's used to determine the size of the offscreen layer for filters.
     // If null, the clip will be used instead.
-    AutoDrawLooper(SkCanvas* canvas, const SkSurfaceProps& props, const SkPaint& paint,
-                   bool skipLayerForImageFilter = false,
+    AutoDrawLooper(SkCanvas* canvas, const SkPaint& paint, bool skipLayerForImageFilter = false,
                    const SkRect* rawBounds = nullptr) : fOrigPaint(paint) {
         fCanvas = canvas;
 #ifdef SK_SUPPORT_LEGACY_DRAWFILTER
         fFilter = canvas->getDrawFilter();
 #else
         fFilter = nullptr;
 #endif
         fPaint = &fOrigPaint;
         fSaveCount = canvas->getSaveCount();
         fTempLayerForImageFilter = false;
@@ skipping 126 matching lines @@
     // call this after any possible paint modifiers
     if (fPaint->nothingToDraw()) {
         fPaint = nullptr;
         return false;
     }
     return true;
 }
 
 ////////// macros to place around the internal draw calls //////////////////
 
-#define LOOPER_BEGIN_DRAWBITMAP(paint, skipLayerForFilter, bounds)          \
-    this->predrawNotify();                                                  \
-    AutoDrawLooper looper(this, fProps, paint, skipLayerForFilter, bounds); \
-    while (looper.next(SkDrawFilter::kBitmap_Type)) {                       \
+#define LOOPER_BEGIN_DRAWBITMAP(paint, skipLayerForFilter, bounds)  \
+    this->predrawNotify();                                          \
+    AutoDrawLooper looper(this, paint, skipLayerForFilter, bounds); \
+    while (looper.next(SkDrawFilter::kBitmap_Type)) {               \
         SkDrawIter iter(this);
 
 
 #define LOOPER_BEGIN_DRAWDEVICE(paint, type)                        \
     this->predrawNotify();                                          \
-    AutoDrawLooper  looper(this, fProps, paint, true);              \
+    AutoDrawLooper  looper(this, paint, true);                      \
     while (looper.next(type)) {                                     \
         SkDrawIter          iter(this);
 
 #define LOOPER_BEGIN(paint, type, bounds)                           \
     this->predrawNotify();                                          \
-    AutoDrawLooper  looper(this, fProps, paint, false, bounds);     \
+    AutoDrawLooper  looper(this, paint, false, bounds);             \
     while (looper.next(type)) {                                     \
         SkDrawIter          iter(this);
 
 #define LOOPER_BEGIN_CHECK_COMPLETE_OVERWRITE(paint, type, bounds, auxOpaque)  \
     this->predrawNotify(bounds, &paint, auxOpaque);                 \
-    AutoDrawLooper  looper(this, fProps, paint, false, bounds);     \
+    AutoDrawLooper  looper(this, paint, false, bounds);             \
     while (looper.next(type)) {                                     \
         SkDrawIter          iter(this);
 
 #define LOOPER_END    }
 
 ////////////////////////////////////////////////////////////////////////////
 
 static inline SkRect qr_clip_bounds(const SkIRect& bounds) {
     if (bounds.isEmpty()) {
         return SkRect::MakeEmpty();
@@ skipping 2641 matching lines @@
 
     shadowPaint.setShader(shadowShader);
 
     this->drawRect(SkRect::MakeIWH(diffuseMap->width(), diffuseMap->height()), shadowPaint);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-SkCanvas::LayerIter::LayerIter(SkCanvas* canvas, bool skipEmptyClips) {
+SkCanvas::LayerIter::LayerIter(SkCanvas* canvas) {
     static_assert(sizeof(fStorage) >= sizeof(SkDrawIter), "fStorage_too_small");
 
     SkASSERT(canvas);
 
-    fImpl = new (fStorage) SkDrawIter(canvas, skipEmptyClips);
+    fImpl = new (fStorage) SkDrawIter(canvas);
     fDone = !fImpl->next();
 }
 
 SkCanvas::LayerIter::~LayerIter() {
     fImpl->~SkDrawIter();
 }
 
 void SkCanvas::LayerIter::next() {
     fDone = !fImpl->next();
 }
@@ skipping 81 matching lines @@
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }
 
 #ifdef SK_SUPPORT_LEGACY_NEW_SURFACE_API
 SkSurface* SkCanvas::newSurface(const SkImageInfo& info, const SkSurfaceProps* props) {
     return this->makeSurface(info, props).release();
 }
 #endif