Simplify SkLayerDrawLooper

src/effects/SkLayerDrawLooper.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkCanvas.h"
 #include "SkColor.h"
+#include "SkPaint.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkLayerDrawLooper.h"
 #include "SkString.h"
 #include "SkStringUtils.h"
 #include "SkUnPreMultiply.h"
 
 SkLayerDrawLooper::LayerInfo::LayerInfo() {
     fPaintBits = 0;                     // ignore our paint fields
     fColorMode = SkXfermode::kDst_Mode; // ignore our color
     fOffset.set(0, 0);
     fPostTranslate = false;
 }
 
-SkLayerDrawLooper::SkLayerDrawLooper()
-        : fRecs(nullptr),
-          fCount(0) {
-}
+SkLayerDrawLooper::SkLayerDrawLooper() : fRecs() {}
 
-SkLayerDrawLooper::~SkLayerDrawLooper() {
-    Rec* rec = fRecs;
-    while (rec) {
-        Rec* next = rec->fNext;
-        delete rec;
-        rec = next;
-    }
-}
+SkLayerDrawLooper::~SkLayerDrawLooper() {}
+
+struct SkLayerDrawLooper::Rec {
+    explicit Rec(const LayerInfo& info) : fPaint(), fInfo(info) {}
+
+    SkPaint fPaint;
+    LayerInfo fInfo;
+};
 
 SkLayerDrawLooper::Context* SkLayerDrawLooper::createContext(SkCanvas* canvas, void* storage) const {
     canvas->save();
     return new (storage) LayerDrawLooperContext(this);
 }
 
 static SkColor xferColor(SkColor src, SkColor dst, SkXfermode::Mode mode) {
     switch (mode) {
         case SkXfermode::kSrc_Mode:
             return src;
@@ skipping 74 matching lines @@
 }
 
 // Should we add this to canvas?
 static void postTranslate(SkCanvas* canvas, SkScalar dx, SkScalar dy) {
     SkMatrix m = canvas->getTotalMatrix();
     m.postTranslate(dx, dy);
     canvas->setMatrix(m);
 }
 
 SkLayerDrawLooper::LayerDrawLooperContext::LayerDrawLooperContext(
-        const SkLayerDrawLooper* looper) : fCurrRec(looper->fRecs) {}
+        const SkLayerDrawLooper* looper)
+    : fCurr(looper->fRecs.begin()), fEnd(looper->fRecs.end()) {}
 
 bool SkLayerDrawLooper::LayerDrawLooperContext::next(SkCanvas* canvas,
                                                      SkPaint* paint) {
     canvas->restore();
-    if (nullptr == fCurrRec) {
+    if (fEnd == fCurr) {
         return false;
     }
 
-    ApplyInfo(paint, fCurrRec->fPaint, fCurrRec->fInfo);
+    const Rec& rec = *fCurr++;
+    ApplyInfo(paint, rec.fPaint, rec.fInfo);
 
     canvas->save();
-    if (fCurrRec->fInfo.fPostTranslate) {
-        postTranslate(canvas, fCurrRec->fInfo.fOffset.fX,
-                      fCurrRec->fInfo.fOffset.fY);
+    if (rec.fInfo.fPostTranslate) {
+        postTranslate(canvas, rec.fInfo.fOffset.fX,
+                      rec.fInfo.fOffset.fY);
     } else {
-        canvas->translate(fCurrRec->fInfo.fOffset.fX,
-                          fCurrRec->fInfo.fOffset.fY);
+        canvas->translate(rec.fInfo.fOffset.fX,
+                          rec.fInfo.fOffset.fY);
     }
-    fCurrRec = fCurrRec->fNext;
 
     return true;
 }
 
 bool SkLayerDrawLooper::asABlurShadow(BlurShadowRec* bsRec) const {
-    if (fCount != 2) {
+    if (fRecs.size() != 2) {
         return false;
     }
-    const Rec* rec = fRecs;
+    const Rec* rec = &fRecs[0];
 
     // bottom layer needs to be just blur(maskfilter)
     if ((rec->fInfo.fPaintBits & ~kMaskFilter_Bit)) {
         return false;
     }
     if (SkXfermode::kSrc_Mode != rec->fInfo.fColorMode) {
         return false;
     }
     const SkMaskFilter* mf = rec->fPaint.getMaskFilter();
     if (nullptr == mf) {
         return false;
     }
     SkMaskFilter::BlurRec maskBlur;
     if (!mf->asABlur(&maskBlur)) {
         return false;
     }
 
-    rec = rec->fNext;
+    rec = &fRecs[1];
     // top layer needs to be "plain"
     if (rec->fInfo.fPaintBits) {
         return false;
     }
     if (SkXfermode::kDst_Mode != rec->fInfo.fColorMode) {
         return false;
     }
     if (!rec->fInfo.fOffset.equals(0, 0)) {
         return false;
     }
 
     if (bsRec) {
         bsRec->fSigma = maskBlur.fSigma;
-        bsRec->fOffset = fRecs->fInfo.fOffset;
-        bsRec->fColor = fRecs->fPaint.getColor();
+        bsRec->fOffset = fRecs[0].fInfo.fOffset;
+        bsRec->fColor = fRecs[0].fPaint.getColor();
         bsRec->fStyle = maskBlur.fStyle;
         bsRec->fQuality = maskBlur.fQuality;
     }
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkLayerDrawLooper::flatten(SkWriteBuffer& buffer) const {
-    buffer.writeInt(fCount);
+    buffer.writeInt(fRecs.size());
 
-    Rec* rec = fRecs;
-    for (int i = 0; i < fCount; i++) {
+    for (const Rec& rec : fRecs) {
         // Legacy "flagsmask" field -- now ignored, remove when we bump version
         buffer.writeInt(0);
 
-        buffer.writeInt(rec->fInfo.fPaintBits);
-        buffer.writeInt(rec->fInfo.fColorMode);
-        buffer.writePoint(rec->fInfo.fOffset);
-        buffer.writeBool(rec->fInfo.fPostTranslate);
-        buffer.writePaint(rec->fPaint);
-        rec = rec->fNext;
+        buffer.writeInt(rec.fInfo.fPaintBits);
+        buffer.writeInt(rec.fInfo.fColorMode);
+        buffer.writePoint(rec.fInfo.fOffset);
+        buffer.writeBool(rec.fInfo.fPostTranslate);
+        buffer.writePaint(rec.fPaint);
     }
 }
 
 SkFlattenable* SkLayerDrawLooper::CreateProc(SkReadBuffer& buffer) {
     int count = buffer.readInt();
 
     Builder builder;
+    builder.reserve(count);
     for (int i = 0; i < count; i++) {
         LayerInfo info;
         // Legacy "flagsmask" field -- now ignored, remove when we bump version
         (void)buffer.readInt();
 
         info.fPaintBits = buffer.readInt();
         info.fColorMode = (SkXfermode::Mode)buffer.readInt();
         buffer.readPoint(&info.fOffset);
         info.fPostTranslate = buffer.readBool();
         buffer.readPaint(builder.addLayerOnTop(info));
     }
     return builder.detachLooper();
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkLayerDrawLooper::toString(SkString* str) const {
-    str->appendf("SkLayerDrawLooper (%d): ", fCount);
+    str->appendf("SkLayerDrawLooper (%zu): ", fRecs.size());
 
-    Rec* rec = fRecs;
-    for (int i = 0; i < fCount; i++) {
-        str->appendf("%d: paintBits: (", i);
-        if (0 == rec->fInfo.fPaintBits) {
+    for (size_t i = 0; i < fRecs.size(); i++) {
+        const Rec& rec = fRecs[i];
+        str->appendf("%zu: paintBits: (", i);
+        if (0 == rec.fInfo.fPaintBits) {
             str->append("None");
-        } else if (kEntirePaint_Bits == rec->fInfo.fPaintBits) {
+        } else if (kEntirePaint_Bits == rec.fInfo.fPaintBits) {
             str->append("EntirePaint");
         } else {
             bool needSeparator = false;
-            SkAddFlagToString(str, SkToBool(kStyle_Bit & rec->fInfo.fPaintBits), "Style",
+            SkAddFlagToString(str, SkToBool(kStyle_Bit & rec.fInfo.fPaintBits), "Style",
                               &needSeparator);
-            SkAddFlagToString(str, SkToBool(kTextSkewX_Bit & rec->fInfo.fPaintBits), "TextSkewX",
+            SkAddFlagToString(str, SkToBool(kTextSkewX_Bit & rec.fInfo.fPaintBits), "TextSkewX",
                               &needSeparator);
-            SkAddFlagToString(str, SkToBool(kPathEffect_Bit & rec->fInfo.fPaintBits), "PathEffect",
+            SkAddFlagToString(str, SkToBool(kPathEffect_Bit & rec.fInfo.fPaintBits), "PathEffect",
                               &needSeparator);
-            SkAddFlagToString(str, SkToBool(kMaskFilter_Bit & rec->fInfo.fPaintBits), "MaskFilter",
+            SkAddFlagToString(str, SkToBool(kMaskFilter_Bit & rec.fInfo.fPaintBits), "MaskFilter",
                               &needSeparator);
-            SkAddFlagToString(str, SkToBool(kShader_Bit & rec->fInfo.fPaintBits), "Shader",
+            SkAddFlagToString(str, SkToBool(kShader_Bit & rec.fInfo.fPaintBits), "Shader",
                               &needSeparator);
-            SkAddFlagToString(str, SkToBool(kColorFilter_Bit & rec->fInfo.fPaintBits), "ColorFilter",
+            SkAddFlagToString(str, SkToBool(kColorFilter_Bit & rec.fInfo.fPaintBits), "ColorFilter",
                               &needSeparator);
-            SkAddFlagToString(str, SkToBool(kXfermode_Bit & rec->fInfo.fPaintBits), "Xfermode",
+            SkAddFlagToString(str, SkToBool(kXfermode_Bit & rec.fInfo.fPaintBits), "Xfermode",
                               &needSeparator);
         }
         str->append(") ");
 
         static const char* gModeStrings[SkXfermode::kLastMode+1] = {
             "kClear", "kSrc", "kDst", "kSrcOver", "kDstOver", "kSrcIn", "kDstIn",
             "kSrcOut", "kDstOut", "kSrcATop", "kDstATop", "kXor", "kPlus",
             "kMultiply", "kScreen", "kOverlay", "kDarken", "kLighten", "kColorDodge",
             "kColorBurn", "kHardLight", "kSoftLight", "kDifference", "kExclusion"
         };
 
-        str->appendf("mode: %s ", gModeStrings[rec->fInfo.fColorMode]);
+        str->appendf("mode: %s ", gModeStrings[rec.fInfo.fColorMode]);
 
         str->append("offset: (");
-        str->appendScalar(rec->fInfo.fOffset.fX);
+        str->appendScalar(rec.fInfo.fOffset.fX);
         str->append(", ");
-        str->appendScalar(rec->fInfo.fOffset.fY);
+        str->appendScalar(rec.fInfo.fOffset.fY);
         str->append(") ");
 
         str->append("postTranslate: ");
-        if (rec->fInfo.fPostTranslate) {
+        if (rec.fInfo.fPostTranslate) {
             str->append("true ");
         } else {
             str->append("false ");
         }
 
-        rec->fPaint.toString(str);
-        rec = rec->fNext;
+        rec.fPaint.toString(str);
     }
 }
 #endif
 
 SkLayerDrawLooper::Builder::Builder()
-        : fRecs(nullptr),
-          fTopRec(nullptr),
-          fCount(0) {
-}
+    : fRecs() {}
 
-SkLayerDrawLooper::Builder::~Builder() {
-    Rec* rec = fRecs;
-    while (rec) {
-        Rec* next = rec->fNext;
-        delete rec;
-        rec = next;
-    }
-}
+SkLayerDrawLooper::Builder::~Builder() {}
 
-SkPaint* SkLayerDrawLooper::Builder::addLayer(const LayerInfo& info) {
-    fCount += 1;
-
-    Rec* rec = new Rec;
-    rec->fNext = fRecs;
-    rec->fInfo = info;
-    fRecs = rec;
-    if (nullptr == fTopRec) {
-        fTopRec = rec;
-    }
-
-    return &rec->fPaint;
-}
-
-void SkLayerDrawLooper::Builder::addLayer(SkScalar dx, SkScalar dy) {
-    LayerInfo info;
-
-    info.fOffset.set(dx, dy);
-    (void)this->addLayer(info);
+void SkLayerDrawLooper::Builder::reserve(size_t n) {
+    fRecs.reserve(n);
 }
 
 SkPaint* SkLayerDrawLooper::Builder::addLayerOnTop(const LayerInfo& info) {
-    fCount += 1;
+    fRecs.push_back(Rec(info));
+    return &fRecs.back().fPaint;
+}
 
-    Rec* rec = new Rec;
-    rec->fNext = nullptr;
-    rec->fInfo = info;
-    if (nullptr == fRecs) {
-        fRecs = rec;
-    } else {
-        SkASSERT(fTopRec);
-        fTopRec->fNext = rec;
-    }
-    fTopRec = rec;
-
-    return &rec->fPaint;
+void SkLayerDrawLooper::Builder::addLayerOnTop(SkScalar dx, SkScalar dy) {
+    LayerInfo info;
+    info.fOffset.set(dx, dy);
+    this->addLayerOnTop(info);
 }
 
 SkLayerDrawLooper* SkLayerDrawLooper::Builder::detachLooper() {
     SkLayerDrawLooper* looper = new SkLayerDrawLooper;
-    looper->fCount = fCount;
-    looper->fRecs = fRecs;
-
-    fCount = 0;
-    fRecs = nullptr;
-    fTopRec = nullptr;
-
+    fRecs.swap(looper->fRecs);
     return looper;
 }