Revert of Port uses of SkLazyPtr to SkOncePtr.

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 "SkOncePtr.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 99 matching lines @@
         // since the emitObject() interface is non-const.  But We
         // promise that there is no way to mutate this object from
         // here on out.
         return SkRef(const_cast<SkPDFGraphicState*>(canonGS));
     }
     SkPDFGraphicState* pdfGraphicState = new SkPDFGraphicState(paint);
     canon->addGraphicState(pdfGraphicState);
     return pdfGraphicState;
 }
 
-static SkPDFObject* create_invert_function() {
+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)));
 
     SkPDFStream* invertFunction = new SkPDFStream(psInvertStream.get());
     invertFunction->insertInt("FunctionType", 4);
     invertFunction->insertObject("Domain", SkRef(domainAndRange.get()));
     invertFunction->insertObject("Range", domainAndRange.detach());
     return invertFunction;
 }
 
-SK_DECLARE_STATIC_ONCE_PTR(SkPDFObject, invertFunction);
+template <typename T> void unref(T* ptr) { ptr->unref(); }
+}  // namespace
+
+SK_DECLARE_STATIC_LAZY_PTR(SkPDFObject,
+                           invertFunction,
+                           create_invert_function,
+                           unref<SkPDFObject>);
 
 // static
 SkPDFDict* 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.
     SkAutoTUnref<SkPDFDict> sMaskDict(new SkPDFDict("Mask"));
     if (sMaskMode == kAlpha_SMaskMode) {
         sMaskDict->insertName("S", "Alpha");
     } else if (sMaskMode == kLuminosity_SMaskMode) {
         sMaskDict->insertName("S", "Luminosity");
     }
     sMaskDict->insertObjRef("G", SkRef(sMask));
     if (invert) {
-        sMaskDict->insertObjRef("TR", SkRef(invertFunction.get(create_invert_function)));
+        sMaskDict->insertObjRef("TR", SkRef(invertFunction.get()));
     }
 
     SkPDFDict* result = new SkPDFDict("ExtGState");
     result->insertObject("SMask", sMaskDict.detach());
     return result;
 }
 
-static SkPDFDict* create_no_smask_graphic_state() {
+namespace {
+SkPDFDict* create_no_smask_graphic_state() {
     SkPDFDict* noSMaskGS = new SkPDFDict("ExtGState");
     noSMaskGS->insertName("SMask", "None");
     return noSMaskGS;
 }
-SK_DECLARE_STATIC_ONCE_PTR(SkPDFDict, noSMaskGraphicState);
+} // namespace
+SK_DECLARE_STATIC_LAZY_PTR(SkPDFDict,
+                           noSMaskGraphicState,
+                           create_no_smask_graphic_state,
+                           unref<SkPDFDict>);
 
 // static
 SkPDFDict* SkPDFGraphicState::GetNoSMaskGraphicState() {
-    return SkRef(noSMaskGraphicState.get(create_no_smask_graphic_state));
+    return SkRef(noSMaskGraphicState.get());
 }
 
 void SkPDFGraphicState::emitObject(
         SkWStream* stream,
         const SkPDFObjNumMap& objNumMap,
         const SkPDFSubstituteMap& substitutes) const {
     SkAutoTUnref<SkPDFDict> dict(new SkPDFDict("ExtGState"));
     dict->insertName("Type", "ExtGState");
 
     SkScalar alpha = SkIntToScalar(fAlpha) / 0xFF;
@@ skipping 17 matching lines @@
     static_assert(SkPaint::kJoinCount == 3, "paint_join_mismatch");
     SkASSERT(strokeJoin >= 0 && strokeJoin <= 2);
     dict->insertInt("LJ", strokeJoin);
 
     dict->insertScalar("LW", fStrokeWidth);
     dict->insertScalar("ML", fStrokeMiter);
     dict->insertBool("SA", true);  // SA = Auto stroke adjustment.
     dict->insertName("BM", as_blend_mode(xferMode));
     dict->emitObject(stream, objNumMap, substitutes);
 }