Optimize CSS box-shadow performance

src/core/SkMaskCache.cpp

Index: src/core/SkMaskCache.cpp
diff --git a/src/core/SkMaskCache.cpp b/src/core/SkMaskCache.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb1288184ff9adfa5a46df45156ee7e0b6d3926e
--- /dev/null
+++ b/src/core/SkMaskCache.cpp
@@ -0,0 +1,150 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkMaskCache.h"
+#include "SkResourceCache.h"
+
+struct MaskValue {
+    SkMask          fMask;
+    SkCachedData*   fData;
+};
+
+struct RRectBlurKey : public SkResourceCache::Key {
+public:
+    RRectBlurKey(SkScalar sigma, const SkRRect& rrect)
+        : fSigma(sigma)
+        , fRRect(rrect) {
+        this->init(sizeof(fSigma) + sizeof(fRRect));
+    }
+
+    SkScalar    fSigma;
+    SkRRect     fRRect;
+};
+
+struct RRectBlurRec : public SkResourceCache::Rec {
+    RRectBlurRec(SkScalar sigma, const SkRRect& rrect, const SkMask& mask, SkCachedData* data)
+        : fKey(sigma, rrect)
+    {
+        fValue.fMask = mask;
+        fValue.fData = data;
+        fValue.fData->attachToCacheAndRef();
+    }
+    ~RRectBlurRec() {
+        fValue.fData->detachFromCacheAndUnref();
+    }
+
+    RRectBlurKey   fKey;
+    MaskValue      fValue;
+
+    virtual const Key& getKey() const SK_OVERRIDE { return fKey; }
+    virtual size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fValue); }
+
+    static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextData) {
+        const RRectBlurRec& rec = static_cast<const RRectBlurRec&>(baseRec);
+        MaskValue* result = (MaskValue*)contextData;
+
+        SkCachedData* tmpData = rec.fValue.fData;
+        tmpData->ref();
+        if (tmpData->data() == NULL) {
+            tmpData->unref();
+            return false;
+        }
+        *result = rec.fValue;
+        return true;
+    }
+};
+
+SkCachedData* SkMaskCache::FindAndRef(SkScalar sigma, const SkRRect& rrect, SkMask* mask) {
+    MaskValue result;
+    RRectBlurKey key(sigma, rrect);
+    if (SkResourceCache::Find(key, RRectBlurRec::Visitor, &result)) {
+        *mask = result.fMask;
+        mask->fImage = (uint8_t*)(result.fData->data());
+
+        if (mask->fImage) {

[reed1, 2014/10/21 21:29:49]

What is this test doing? Have we not already checked this in the Visitor?

+            return result.fData;
+        }
+    }
+    return NULL;
+}
+
+void SkMaskCache::Add(SkScalar sigma, const SkRRect& rrect,
+                      const SkMask& mask, SkCachedData* data) {
+    return SkResourceCache::Add(SkNEW_ARGS(RRectBlurRec, (sigma, rrect, mask, data)));
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+struct RectsBlurKey : public SkResourceCache::Key {
+public:
+    RectsBlurKey(SkScalar sigma, int32_t count, const SkRect rects[])
+        : fSigma(sigma)
+        , fRecCount(count) {
+        for (int i = 0; i < count; i++) {

[reed1, 2014/10/21 21:29:49]

will we crash if count > 2? Should we assert (or check in our caller) that count
is exactly 1 or 2?

+            fRects[i] = rects[i];
+        }
+        this->init(sizeof(fSigma) + sizeof(fRecCount) + sizeof(SkRect) * fRecCount);
+    }
+
+    SkScalar    fSigma;
+    int32_t     fRecCount;
+    SkRect      fRects[2];
+};
+
+struct RectsBlurRec : public SkResourceCache::Rec {
+    RectsBlurRec(SkScalar sigma, unsigned count, const SkRect rects[],
+                 const SkMask& mask, SkCachedData* data)
+        : fKey(sigma, count, rects)
+    {
+        fValue.fMask = mask;
+        fValue.fData = data;
+        fValue.fData->attachToCacheAndRef();
+    }
+    ~RectsBlurRec() {
+        fValue.fData->detachFromCacheAndUnref();
+    }
+
+    RectsBlurKey   fKey;
+    MaskValue      fValue;
+
+    virtual const Key& getKey() const SK_OVERRIDE { return fKey; }
+    virtual size_t bytesUsed() const SK_OVERRIDE { return sizeof(fKey) + sizeof(fValue); }
+
+    static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextData) {
+        const RectsBlurRec& rec = static_cast<const RectsBlurRec&>(baseRec);
+        MaskValue* result = (MaskValue*)contextData;
+
+        SkCachedData* tmpData = rec.fValue.fData;
+        tmpData->ref();
+        if (tmpData->data() == NULL) {
+            tmpData->unref();
+            return false;
+        }
+        *result = rec.fValue;
+        return true;
+    }
+};
+
+SkCachedData* SkMaskCache::FindAndRef(SkScalar sigma, int32_t count,
+                                      const SkRect rects[], SkMask* mask) {
+    MaskValue result;
+    RectsBlurKey key(sigma, count, rects);
+    if (SkResourceCache::Find(key, RectsBlurRec::Visitor, &result)) {
+        *mask = result.fMask;
+        mask->fImage = (uint8_t*)(result.fData->data());
+
+        if (mask->fImage) {

[reed1, 2014/10/21 21:29:49]

ditto about this test?

+            return result.fData;
+        }
+    }
+    return NULL;
+}
+
+void SkMaskCache::Add(SkScalar sigma, int32_t count, const SkRect rects[],
+                      const SkMask& mask, SkCachedData* data) {
+    return SkResourceCache::Add(SkNEW_ARGS(RectsBlurRec, (sigma, count, rects, mask, data)));
+}