Use SkLazyPtr in SkPDFGraphicState.cpp

src/pdf/SkPDFGraphicState.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 "SkData.h"
+#include "SkLazyPtr.h"
 #include "SkPDFCanon.h"
 #include "SkPDFFormXObject.h"
 #include "SkPDFGraphicState.h"
 #include "SkPDFUtils.h"
 #include "SkTypes.h"
 
 static const char* as_blend_mode(SkXfermode::Mode mode) {
     switch (mode) {
         case SkXfermode::kSrcOver_Mode:
             return "Normal";
@@ skipping 118 matching lines @@
     SkPDFGraphicState* pdfGraphicState =
             SkPDFCanon::GetCanon().findGraphicState(paint);
     if (pdfGraphicState) {
         return SkRef(pdfGraphicState);
     }
     pdfGraphicState = new SkPDFGraphicState(paint);
     SkPDFCanon::GetCanon().addGraphicState(pdfGraphicState);
     return pdfGraphicState;
 }
 
-// static
-SkPDFObject* SkPDFGraphicState::GetInvertFunction() {
-    // This assumes that canonicalPaintsMutex is held.
-    SkPDFCanon::GetPaintMutex().assertHeld();
-    static SkPDFStream* invertFunction = NULL;
-    if (!invertFunction) {
-        // Acrobat crashes if we use a type 0 function, kpdf crashes if we use
-        // a type 2 function, so we use a type 4 function.
-        SkAutoTUnref<SkPDFArray> domainAndRange(new SkPDFArray);
-        domainAndRange->reserve(2);
-        domainAndRange->appendInt(0);
-        domainAndRange->appendInt(1);
+namespace {
+SkPDFObject* create_invert_function() {
+    // Acrobat crashes if we use a type 0 function, kpdf crashes if we use
+    // a type 2 function, so we use a type 4 function.
+    SkAutoTUnref<SkPDFArray> domainAndRange(new SkPDFArray);
+    domainAndRange->reserve(2);
+    domainAndRange->appendInt(0);
+    domainAndRange->appendInt(1);
 
-        static const char psInvert[] = "{1 exch sub}";
-        // Do not copy the trailing '\0' into the SkData.
-        SkAutoTUnref<SkData> psInvertStream(
-                SkData::NewWithoutCopy(psInvert, strlen(psInvert)));
+    static const char psInvert[] = "{1 exch sub}";
+    // Do not copy the trailing '\0' into the SkData.
+    SkAutoTUnref<SkData> psInvertStream(
+            SkData::NewWithoutCopy(psInvert, strlen(psInvert)));
 
-        invertFunction = new SkPDFStream(psInvertStream.get());
-        invertFunction->insertInt("FunctionType", 4);
-        invertFunction->insert("Domain", domainAndRange.get());
-        invertFunction->insert("Range", domainAndRange.get());
-    }
+    SkPDFStream* invertFunction = SkNEW_ARGS(
+            SkPDFStream, (psInvertStream.get()));
+    invertFunction->insertInt("FunctionType", 4);
+    invertFunction->insert("Domain", domainAndRange.get());
+    invertFunction->insert("Range", domainAndRange.get());
     return invertFunction;
 }
 
+template <typename T> void unref(T* ptr) { ptr->unref(); }
+}  // namespace
+
+SK_DECLARE_STATIC_LAZY_PTR(SkPDFObject, invertFunction,
+                           create_invert_function, unref<SkPDFObject>);
+
 // static
+SkPDFObject* SkPDFGraphicState::GetInvertFunction() {
+    return invertFunction.get();
+}
+
+// static
 SkPDFGraphicState* SkPDFGraphicState::GetSMaskGraphicState(
         SkPDFFormXObject* sMask, bool invert, SkPDFSMaskMode sMaskMode) {
     // The practical chances of using the same mask more than once are unlikely
     // enough that it's not worth canonicalizing.
-    SkAutoMutexAcquire lock(SkPDFCanon::GetPaintMutex());
     SkAutoTUnref<SkPDFDict> sMaskDict(new SkPDFDict("Mask"));
     if (sMaskMode == kAlpha_SMaskMode) {
         sMaskDict->insertName("S", "Alpha");
     } else if (sMaskMode == kLuminosity_SMaskMode) {
         sMaskDict->insertName("S", "Luminosity");
     }
     sMaskDict->insert("G", new SkPDFObjRef(sMask))->unref();
 
     SkPDFGraphicState* result = new SkPDFGraphicState;
     result->fPopulated = true;
     result->fSMask = true;
     result->insertName("Type", "ExtGState");
     result->insert("SMask", sMaskDict.get());
     result->fResources.push(sMask);
     sMask->ref();
 
     if (invert) {
         SkPDFObject* invertFunction = GetInvertFunction();
         result->fResources.push(invertFunction);
         invertFunction->ref();
         sMaskDict->insert("TR", new SkPDFObjRef(invertFunction))->unref();
     }
 
     return result;
 }
 
-// static
-SkPDFGraphicState* SkPDFGraphicState::GetNoSMaskGraphicState() {
-    SkAutoMutexAcquire lock(SkPDFCanon::GetPaintMutex());
-    static SkPDFGraphicState* noSMaskGS = NULL;
-    if (!noSMaskGS) {
-        noSMaskGS = new SkPDFGraphicState;
-        noSMaskGS->fPopulated = true;
-        noSMaskGS->fSMask = true;
-        noSMaskGS->insertName("Type", "ExtGState");
-        noSMaskGS->insertName("SMask", "None");
-    }
-    noSMaskGS->ref();
+SkPDFGraphicState* SkPDFGraphicState::CreateNoSMaskGraphicState() {
+    SkPDFGraphicState* noSMaskGS = SkNEW(SkPDFGraphicState);
+    noSMaskGS->fPopulated = true;
+    noSMaskGS->fSMask = true;
+    noSMaskGS->insertName("Type", "ExtGState");
+    noSMaskGS->insertName("SMask", "None");
     return noSMaskGS;
 }
 
+SK_DECLARE_STATIC_LAZY_PTR(
+        SkPDFGraphicState, noSMaskGraphicState,
+        SkPDFGraphicState::CreateNoSMaskGraphicState, unref<SkPDFGraphicState>);
+
+// static
+SkPDFGraphicState* SkPDFGraphicState::GetNoSMaskGraphicState() {
+    return SkRef(noSMaskGraphicState.get());
+}
+
 SkPDFGraphicState::SkPDFGraphicState()
     : fPopulated(false),
       fSMask(false) {
 }
 
 SkPDFGraphicState::SkPDFGraphicState(const SkPaint& paint)
     : fPaint(paint),
       fPopulated(false),
       fSMask(false) {
 }
@@ skipping 33 matching lines @@
             fPaint.getXfermode()->asMode(&xfermode);
         // If we don't support the mode, just use kSrcOver_Mode.
         if (xfermode < 0 || xfermode > SkXfermode::kLastMode ||
             as_blend_mode(xfermode) == NULL) {
             xfermode = SkXfermode::kSrcOver_Mode;
             NOT_IMPLEMENTED("unsupported xfermode", false);
         }
         insertName("BM", as_blend_mode(xfermode));
     }
 }
-