SkOncePtr -> SkOnce

src/core/SkMiniRecorder.cpp

 /*
  * Copyright 2015 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 "SkTLazy.h"
 #include "SkMiniRecorder.h"
-#include "SkOncePtr.h"
+#include "SkOnce.h"
 #include "SkPicture.h"
 #include "SkPictureCommon.h"
 #include "SkRecordDraw.h"
 #include "SkTextBlob.h"
 
 using namespace SkRecords;
 
 class SkEmptyPicture final : public SkPicture {
 public:
     void playback(SkCanvas*, AbortCallback*) const override { }
 
     size_t approximateBytesUsed() const override { return sizeof(*this); }
     int    approximateOpCount()   const override { return 0; }
     SkRect cullRect()             const override { return SkRect::MakeEmpty(); }
     bool   hasText()              const override { return false; }
     int    numSlowPaths()         const override { return 0; }
     bool   willPlayBackBitmaps()  const override { return false; }
 };
-SK_DECLARE_STATIC_ONCE_PTR(SkEmptyPicture, gEmptyPicture);
 
 template <typename T>
 class SkMiniPicture final : public SkPicture {
 public:
     SkMiniPicture(SkRect cull, T* op) : fCull(cull) {
         memcpy(&fOp, op, sizeof(fOp));  // We take ownership of op's guts.
     }
 
     void playback(SkCanvas* c, AbortCallback*) const override {
         SkRecords::Draw(c, nullptr, nullptr, 0, nullptr)(fOp);
@@ skipping 59 matching lines @@
 }
 #undef TRY_TO_STORE
 
 
 sk_sp<SkPicture> SkMiniRecorder::detachAsPicture(const SkRect& cull) {
 #define CASE(Type)              \
     case State::k##Type:        \
         fState = State::kEmpty; \
         return sk_make_sp<SkMiniPicture<Type>>(cull, reinterpret_cast<Type*>(fBuffer.get()))
 
+    static SkOnce once;
+    static SkPicture* empty;
+
     switch (fState) {
-        case State::kEmpty: return sk_ref_sp(gEmptyPicture.get([]{ return new SkEmptyPicture; }));
+        case State::kEmpty:
+            once([]{ empty = new SkEmptyPicture; });
+            return sk_ref_sp(empty);
         CASE(DrawBitmapRectFixedSize);
         CASE(DrawPath);
         CASE(DrawRect);
         CASE(DrawTextBlob);
     }
     SkASSERT(false);
     return nullptr;
 #undef CASE
 }
 
 void SkMiniRecorder::flushAndReset(SkCanvas* canvas) {
 #define CASE(Type)                                                  \
     case State::k##Type: {                                          \
         fState = State::kEmpty;                                     \
         Type* op = reinterpret_cast<Type*>(fBuffer.get());          \
         SkRecords::Draw(canvas, nullptr, nullptr, 0, nullptr)(*op); \
         op->~Type();                                                \
     } return
 
     switch (fState) {
         case State::kEmpty: return;
         CASE(DrawBitmapRectFixedSize);
         CASE(DrawPath);
         CASE(DrawRect);
         CASE(DrawTextBlob);
     }
     SkASSERT(false);
 #undef CASE
 }