Revert of SkPDF: Add sk_sp setters; .release() becomes std::move()

src/pdf/SkPDFTypes.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 "SkDeflate.h"
 #include "SkPDFTypes.h"
 #include "SkPDFUtils.h"
 #include "SkStreamPriv.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkString* pun(char* x) { return reinterpret_cast<SkString*>(x); }
 const SkString* pun(const char* x) {
     return reinterpret_cast<const SkString*>(x);
 }
 
 SkPDFUnion::SkPDFUnion(Type t) : fType(t) {}
 
 SkPDFUnion::~SkPDFUnion() {
     switch (fType) {
         case Type::kNameSkS:
         case Type::kStringSkS:
             pun(fSkString)->~SkString();
             return;
         case Type::kObjRef:
         case Type::kObject:
-            SkASSERT(fObject);
-            fObject->unref();
+            SkSafeUnref(fObject);
             return;
         default:
             return;
     }
 }
 
 SkPDFUnion& SkPDFUnion::operator=(SkPDFUnion&& other) {
     if (this != &other) {
         this->~SkPDFUnion();
-        new (this) SkPDFUnion(std::move(other));
+        new (this) SkPDFUnion(other.move());
     }
     return *this;
 }
 
 SkPDFUnion::SkPDFUnion(SkPDFUnion&& other) {
     SkASSERT(this != &other);
     memcpy(this, &other, sizeof(*this));
     other.fType = Type::kDestroyed;
 }
 
 #if 0
 SkPDFUnion SkPDFUnion::copy() const {
     SkPDFUnion u(fType);
     memcpy(&u, this, sizeof(u));
     switch (fType) {
         case Type::kNameSkS:
         case Type::kStringSkS:
-            new (pun(u.fSkString)) SkString(*pun(fSkString));
-            return std::move(u);
+            new (pun(u.fSkString))  SkString                                   (*pun(fSkString));
+            return u.move();
         case Type::kObjRef:
         case Type::kObject:
             SkRef(u.fObject);
-            return std::move(u);
+            return u.move();
         default:
-            return std::move(u);
+            return u.move();
     }
 }
 SkPDFUnion& SkPDFUnion::operator=(const SkPDFUnion& other) {
     return *this = other.copy();
 }
 SkPDFUnion::SkPDFUnion(const SkPDFUnion& other) {
     *this = other.copy();
 }
 #endif
 
@@ skipping 107 matching lines @@
             fObject->addResources(objNumMap, substituteMap);
             return;
         default:
             SkDEBUGFAIL("SkPDFUnion::addResources with bad type");
     }
 }
 
 SkPDFUnion SkPDFUnion::Int(int32_t value) {
     SkPDFUnion u(Type::kInt);
     u.fIntValue = value;
-    return std::move(u);
+    return u.move();
 }
 
 SkPDFUnion SkPDFUnion::Bool(bool value) {
     SkPDFUnion u(Type::kBool);
     u.fBoolValue = value;
-    return std::move(u);
+    return u.move();
 }
 
 SkPDFUnion SkPDFUnion::Scalar(SkScalar value) {
     SkPDFUnion u(Type::kScalar);
     u.fScalarValue = value;
-    return std::move(u);
+    return u.move();
 }
 
 SkPDFUnion SkPDFUnion::Name(const char* value) {
     SkPDFUnion u(Type::kName);
     SkASSERT(value);
     SkASSERT(is_valid_name(value));
     u.fStaticString = value;
-    return std::move(u);
+    return u.move();
 }
 
 SkPDFUnion SkPDFUnion::String(const char* value) {
     SkPDFUnion u(Type::kString);
     SkASSERT(value);
     u.fStaticString = value;
-    return std::move(u);
+    return u.move();
 }
 
 SkPDFUnion SkPDFUnion::Name(const SkString& s) {
     SkPDFUnion u(Type::kNameSkS);
     new (pun(u.fSkString)) SkString(s);
-    return std::move(u);
+    return u.move();
 }
 
 SkPDFUnion SkPDFUnion::String(const SkString& s) {
     SkPDFUnion u(Type::kStringSkS);
     new (pun(u.fSkString)) SkString(s);
-    return std::move(u);
+    return u.move();
 }
 
-SkPDFUnion SkPDFUnion::ObjRef(sk_sp<SkPDFObject> objSp) {
+SkPDFUnion SkPDFUnion::ObjRef(SkPDFObject* ptr) {
     SkPDFUnion u(Type::kObjRef);
-    SkASSERT(objSp.get());
-    u.fObject = objSp.release();  // take ownership into union{}
-    return std::move(u);
+    SkASSERT(ptr);
+    u.fObject = ptr;
+    return u.move();
 }
 
-SkPDFUnion SkPDFUnion::Object(sk_sp<SkPDFObject> objSp) {
+SkPDFUnion SkPDFUnion::Object(SkPDFObject* ptr) {
     SkPDFUnion u(Type::kObject);
-    SkASSERT(objSp.get());
-    u.fObject = objSp.release();  // take ownership into union{}
-    return std::move(u);
+    SkASSERT(ptr);
+    u.fObject = ptr;
+    return u.move();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #if 0  // Enable if needed.
 void SkPDFAtom::emitObject(SkWStream* stream,
                            const SkPDFObjNumMap& objNumMap,
                            const SkPDFSubstituteMap& substitutes) const {
     fValue.emitObject(stream, objNumMap, substitutes);
 }
@@ skipping 30 matching lines @@
     stream->writeText("]");
 }
 
 void SkPDFArray::addResources(SkPDFObjNumMap* catalog,
                               const SkPDFSubstituteMap& substitutes) const {
     for (const SkPDFUnion& value : fValues) {
         value.addResources(catalog, substitutes);
     }
 }
 
-void SkPDFArray::append(SkPDFUnion&& value) {
-    new (fValues.append()) SkPDFUnion(std::move(value));
-}
+void SkPDFArray::append(SkPDFUnion&& value) { new (fValues.append()) SkPDFUnion(value.move()); }
 
 void SkPDFArray::appendInt(int32_t value) {
     this->append(SkPDFUnion::Int(value));
 }
 
 void SkPDFArray::appendBool(bool value) {
     this->append(SkPDFUnion::Bool(value));
 }
 
 void SkPDFArray::appendScalar(SkScalar value) {
     this->append(SkPDFUnion::Scalar(value));
 }
 
 void SkPDFArray::appendName(const char name[]) {
     this->append(SkPDFUnion::Name(SkString(name)));
 }
 
 void SkPDFArray::appendName(const SkString& name) {
     this->append(SkPDFUnion::Name(name));
 }
 
 void SkPDFArray::appendString(const SkString& value) {
     this->append(SkPDFUnion::String(value));
 }
 
 void SkPDFArray::appendString(const char value[]) {
     this->append(SkPDFUnion::String(value));
 }
 
-void SkPDFArray::appendObject(sk_sp<SkPDFObject> objSp) {
-    this->append(SkPDFUnion::Object(std::move(objSp)));
+void SkPDFArray::appendObject(SkPDFObject* value) {
+    this->append(SkPDFUnion::Object(value));
 }
 
-void SkPDFArray::appendObjRef(sk_sp<SkPDFObject> objSp) {
-    this->append(SkPDFUnion::ObjRef(std::move(objSp)));
+void SkPDFArray::appendObjRef(SkPDFObject* value) {
+    this->append(SkPDFUnion::ObjRef(value));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPDFDict::SkPDFDict() {}
 
 SkPDFDict::~SkPDFDict() { this->clear(); }
 
 SkPDFDict::SkPDFDict(const char type[]) { this->insertName("Type", type); }
 
@@ skipping 22 matching lines @@
                              const SkPDFSubstituteMap& substitutes) const {
     for (int i = 0; i < fRecords.count(); i++) {
         fRecords[i].fKey.addResources(catalog, substitutes);
         fRecords[i].fValue.addResources(catalog, substitutes);
     }
 }
 
 void SkPDFDict::set(SkPDFUnion&& name, SkPDFUnion&& value) {
     Record* rec = fRecords.append();
     SkASSERT(name.isName());
-    new (&rec->fKey) SkPDFUnion(std::move(name));
-    new (&rec->fValue) SkPDFUnion(std::move(value));
+    new (&rec->fKey) SkPDFUnion(name.move());
+    new (&rec->fValue) SkPDFUnion(value.move());
 }
 
 int SkPDFDict::size() const { return fRecords.count(); }
 
-void SkPDFDict::insertObjRef(const char key[], sk_sp<SkPDFObject> objSp) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(std::move(objSp)));
+void SkPDFDict::insertObjRef(const char key[], SkPDFObject* value) {
+    this->set(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(value));
 }
-void SkPDFDict::insertObjRef(const SkString& key, sk_sp<SkPDFObject> objSp) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(std::move(objSp)));
+void SkPDFDict::insertObjRef(const SkString& key, SkPDFObject* value) {
+    this->set(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(value));
 }
 
-void SkPDFDict::insertObject(const char key[], sk_sp<SkPDFObject> objSp) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::Object(std::move(objSp)));
+void SkPDFDict::insertObject(const char key[], SkPDFObject* value) {
+    this->set(SkPDFUnion::Name(key), SkPDFUnion::Object(value));
 }
-void SkPDFDict::insertObject(const SkString& key, sk_sp<SkPDFObject> objSp) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::Object(std::move(objSp)));
+void SkPDFDict::insertObject(const SkString& key, SkPDFObject* value) {
+    this->set(SkPDFUnion::Name(key), SkPDFUnion::Object(value));
 }
 
 void SkPDFDict::insertBool(const char key[], bool value) {
     this->set(SkPDFUnion::Name(key), SkPDFUnion::Bool(value));
 }
 
 void SkPDFDict::insertInt(const char key[], int32_t value) {
     this->set(SkPDFUnion::Name(key), SkPDFUnion::Int(value));
 }
 
@@ skipping 114 matching lines @@
 
 void SkPDFImageDumpStats() {
     SkDebugf("\ntotal PDF drawImage/drawBitmap calls: %d\n"
              "total PDF jpeg images: %d\n"
              "total PDF regular images: %d\n",
              gDrawImageCalls.load(),
              gJpegImageObjects.load(),
              gRegularImageObjects.load());
 }
 #endif // SK_PDF_IMAGE_STATS