Add SkMaskCache

src/core/SkMaskCache.cpp

+/*
+ * 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"
+
+#define CHECK_LOCAL(localCache, localName, globalName, ...) \
+    ((localCache) ? localCache->localName(__VA_ARGS__) : SkResourceCache::globalName(__VA_ARGS__))
+
+struct MaskValue {
+    SkMask          fMask;
+    SkCachedData*   fData;
+};
+
+struct RRectBlurKey : public SkResourceCache::Key {
+public:
+    RRectBlurKey(SkScalar sigma, const SkRRect& rrect, SkBlurStyle style, SkBlurQuality quality)
+        : fSigma(sigma)
+        , fRRect(rrect)
+        , fStyle(style)
+        , fQuality(quality) {
+        this->init(sizeof(fSigma) + sizeof(fRRect) + sizeof(fStyle) + sizeof(fQuality));
+    }
+
+    SkScalar      fSigma;
+    SkRRect       fRRect;

[reed1, 2014/10/22 16:05:27]

SkRRect has as its last field an enum "Type". This may introduce uninitialized
bytes at the end, so this may make SkRRect a risk as a key.

I think either we need to either
1. change SkRRect to not have this problem
2. store some "flattened" version of SkRRect

adding Robert to the review for his opinion.

[robertphillips, 2014/10/22 16:52:25]

I think we should "fix" SkRRect.
Additionally, some static asserts regarding the packed nature of the data and
its overall size (i.e., a multiple of 4) would be nice.

[qiankun, 2014/10/22 17:19:54]

What about only use rect and radii of SkRRect?

+    SkBlurStyle   fStyle;

[reed1, 2014/10/22 16:05:26]

Since ResourceKey is going to hash through the entire key as an array of int32s,
we have to be sure that our "this" is a multiple of 4 with no uninitialized
padding.

I think to be totally safe, we need to always store types of explicitly known
sizes. SkBlurStyle and SkBlurQuality are enums, so perhaps those should be
stored as explicit int32_t.

[qiankun, 2014/10/22 17:19:54]

Done.

+    SkBlurQuality fQuality;
+};
+
+struct RRectBlurRec : public SkResourceCache::Rec {
+    RRectBlurRec(RRectBlurKey key, const SkMask& mask, SkCachedData* data)
+        : fKey(key)
+    {
+        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(*this) + fValue.fData->size(); }
+
+    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 (NULL == tmpData->data()) {
+            tmpData->unref();
+            return false;
+        }
+        *result = rec.fValue;
+        return true;
+    }
+};
+
+SkCachedData* SkMaskCache::FindAndRef(SkScalar sigma, const SkRRect& rrect, SkBlurStyle style,
+                                      SkBlurQuality quality, SkMask* mask,
+                                      SkResourceCache* localCache) {
+    MaskValue result;
+    RRectBlurKey key(sigma, rrect, style, quality);
+    if (!CHECK_LOCAL(localCache, find, Find, key, RRectBlurRec::Visitor, &result)) {
+        return NULL;
+    }
+
+    *mask = result.fMask;
+    mask->fImage = (uint8_t*)(result.fData->data());
+    return result.fData;
+}
+
+void SkMaskCache::Add(SkScalar sigma, const SkRRect& rrect, SkBlurStyle style,
+                      SkBlurQuality quality, const SkMask& mask, SkCachedData* data,
+                      SkResourceCache* localCache) {
+    RRectBlurKey key(sigma, rrect, style, quality);
+    return CHECK_LOCAL(localCache, add, Add, SkNEW_ARGS(RRectBlurRec, (key, mask, data)));
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+struct RectsBlurKey : public SkResourceCache::Key {
+public:
+    RectsBlurKey(SkScalar sigma, int count, const SkRect rects[], SkBlurStyle style)
+        : fSigma(sigma)
+        , fRecCount(count)
+        , fStyle(style){
+        SkASSERT(1 == count || 2 == count);
+        fRects[0] = SkRect::MakeEmpty();
+        fRects[1] = SkRect::MakeEmpty();
+        for (int i = 0; i < count; i++) {
+            fRects[i] = rects[i];
+        }
+        this->init(sizeof(fSigma) + sizeof(fRecCount) + sizeof(fRects) + sizeof(fStyle));
+    }
+
+    SkScalar    fSigma;
+    int         fRecCount;
+    SkRect      fRects[2];
+    SkBlurStyle fStyle;
+};
+
+struct RectsBlurRec : public SkResourceCache::Rec {
+    RectsBlurRec(RectsBlurKey key, const SkMask& mask, SkCachedData* data)
+        : fKey(key)
+    {
+        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(*this) + fValue.fData->size(); }
+
+    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 (NULL == tmpData->data()) {
+            tmpData->unref();
+            return false;
+        }
+        *result = rec.fValue;
+        return true;
+    }
+};
+
+SkCachedData* SkMaskCache::FindAndRef(SkScalar sigma, const SkRect rects[], int count,
+                                      SkBlurStyle style, SkMask* mask,
+                                      SkResourceCache* localCache) {
+    MaskValue result;
+    RectsBlurKey key(sigma, count, rects, style);
+    if (!CHECK_LOCAL(localCache, find, Find, key, RectsBlurRec::Visitor, &result)) {
+        return NULL;
+    }
+
+    *mask = result.fMask;
+    mask->fImage = (uint8_t*)(result.fData->data());
+    return result.fData;
+}
+
+void SkMaskCache::Add(SkScalar sigma, const SkRect rects[], int count, SkBlurStyle style,
+                      const SkMask& mask, SkCachedData* data,
+                      SkResourceCache* localCache) {
+    RectsBlurKey key(sigma, count, rects, style);
+    return CHECK_LOCAL(localCache, add, Add, SkNEW_ARGS(RectsBlurRec, (key, mask, data)));
+}