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

src/pdf/SkPDFTypes.h

 /*
  * Copyright 2010 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkPDFTypes_DEFINED
 #define SkPDFTypes_DEFINED
@@ skipping 21 matching lines @@
     which are common in the PDF format.
 
 */
 class SkPDFObject : public SkRefCnt {
 public:
     /** Subclasses must implement this method to print the object to the
      *  PDF file.
      *  @param catalog  The object catalog to use.
      *  @param stream   The writable output stream to send the output to.
      */
+    // TODO(halcanary): make this method const
     virtual void emitObject(SkWStream* stream,
                             const SkPDFObjNumMap& objNumMap,
                             const SkPDFSubstituteMap& substitutes) const = 0;
 
     /**
      *  Adds all transitive dependencies of this object to the
      *  catalog.  Implementations should respect the catalog's object
      *  substitution map.
      */
     virtual void addResources(SkPDFObjNumMap* catalog,
                               const SkPDFSubstituteMap& substitutes) const {}
 
 private:
     typedef SkRefCnt INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
    A SkPDFUnion is a non-virtualized implementation of the
    non-compound, non-specialized PDF Object types: Name, String,
    Number, Boolean.
  */
 class SkPDFUnion {
 public:
+    // u.move() is analogous to std::move(u). It returns an rvalue.
+    SkPDFUnion move() { return static_cast<SkPDFUnion&&>(*this); }
     // Move contstructor and assignemnt operator destroy the argument
     // and steal their references (if needed).
     SkPDFUnion(SkPDFUnion&& other);
     SkPDFUnion& operator=(SkPDFUnion&& other);
 
     ~SkPDFUnion();
 
     /** The following nine functions are the standard way of creating
         SkPDFUnion objects. */
 
     static SkPDFUnion Int(int32_t);
 
     static SkPDFUnion Int(size_t v) { return SkPDFUnion::Int(SkToS32(v)); }
 
     static SkPDFUnion Bool(bool);
 
     static SkPDFUnion Scalar(SkScalar);
 
-    /** These two functions do NOT take ownership of char*, and do NOT
+    /** These two functions do NOT take ownership of ptr, and do NOT
         copy the string.  Suitable for passing in static const
         strings. For example:
           SkPDFUnion n = SkPDFUnion::Name("Length");
           SkPDFUnion u = SkPDFUnion::String("Identity"); */
 
     /** SkPDFUnion::Name(const char*) assumes that the passed string
         is already a valid name (that is: it has no control or
         whitespace characters).  This will not copy the name. */
     static SkPDFUnion Name(const char*);
 
     /** SkPDFUnion::String will encode the passed string.  This will
         not copy the name. */
     static SkPDFUnion String(const char*);
 
     /** SkPDFUnion::Name(const SkString&) does not assume that the
         passed string is already a valid name and it will escape the
         string. */
     static SkPDFUnion Name(const SkString&);
 
     /** SkPDFUnion::String will encode the passed string. */
     static SkPDFUnion String(const SkString&);
 
-    static SkPDFUnion Object(sk_sp<SkPDFObject>);
-    static SkPDFUnion ObjRef(sk_sp<SkPDFObject>);
+    /** This function DOES take ownership of the object. E.g.
+          auto dict = sk_make_sp<SkPDFDict>();
+          dict->insert(.....);
+          SkPDFUnion u = SkPDFUnion::Object(dict.detach()) */
+    static SkPDFUnion Object(SkPDFObject*);
+
+    /** This function DOES take ownership of the object. E.g.
+          sk_sp<SkPDFBitmap> image(
+                 SkPDFBitmap::Create(fCanon, bitmap));
+          SkPDFUnion u = SkPDFUnion::ObjRef(image.detach()) */
+    static SkPDFUnion ObjRef(SkPDFObject*);
 
     /** These two non-virtual methods mirror SkPDFObject's
         corresponding virtuals. */
     void emitObject(SkWStream*,
                     const SkPDFObjNumMap&,
                     const SkPDFSubstituteMap&) const;
     void addResources(SkPDFObjNumMap*, const SkPDFSubstituteMap&) const;
 
     bool isName() const;
 
@@ skipping 35 matching lines @@
 #if 0  // Enable if needed.
 /** This class is a SkPDFUnion with SkPDFObject virtuals attached.
     The only use case of this is when a non-compound PDF object is
     referenced indirectly. */
 class SkPDFAtom final : public SkPDFObject {
 public:
     void emitObject(SkWStream* stream,
                     const SkPDFObjNumMap& objNumMap,
                     const SkPDFSubstituteMap& substitutes) final;
     void addResources(SkPDFObjNumMap*, const SkPDFSubstituteMap&) const final;
-    SkPDFAtom(SkPDFUnion&& v) : fValue(std::move(v) {}
+    SkPDFAtom(SkPDFUnion&& v) : fValue(v.move()) {}
 
 private:
     const SkPDFUnion fValue;
     typedef SkPDFObject INHERITED;
 };
 #endif  // 0
 
 ////////////////////////////////////////////////////////////////////////////////
 
 /** \class SkPDFArray
@@ skipping 28 matching lines @@
     /** Appends a value to the end of the array.
      *  @param value The value to add to the array.
      */
     void appendInt(int32_t);
     void appendBool(bool);
     void appendScalar(SkScalar);
     void appendName(const char[]);
     void appendName(const SkString&);
     void appendString(const char[]);
     void appendString(const SkString&);
-    void appendObject(sk_sp<SkPDFObject>);
-    void appendObjRef(sk_sp<SkPDFObject>);
+    /** appendObject and appendObjRef take ownership of the passed object */
+    void appendObject(SkPDFObject*);
+    void appendObjRef(SkPDFObject*);
 
 private:
     SkTDArray<SkPDFUnion> fValues;
     void append(SkPDFUnion&& value);
     typedef SkPDFObject INHERITED;
 };
 
 /** \class SkPDFDict
 
     A dictionary object in a PDF.
@@ skipping 15 matching lines @@
     void emitObject(SkWStream* stream,
                     const SkPDFObjNumMap& objNumMap,
                     const SkPDFSubstituteMap& substitutes) const override;
     void addResources(SkPDFObjNumMap*,
                       const SkPDFSubstituteMap&) const override;
 
     /** The size of the dictionary.
      */
     int size() const;
 
-    /** Add the value to the dictionary with the given key.
+    /** Add the value to the dictionary with the given key.  Takes
+     *  ownership of the object.
      *  @param key   The text of the key for this dictionary entry.
      *  @param value The value for this dictionary entry.
      */
-    void insertObject(const char key[], sk_sp<SkPDFObject>);
-    void insertObject(const SkString& key, sk_sp<SkPDFObject>);
-    void insertObjRef(const char key[], sk_sp<SkPDFObject>);
-    void insertObjRef(const SkString& key, sk_sp<SkPDFObject>);
+    void insertObject(const char key[], SkPDFObject* value);
+    void insertObject(const SkString& key, SkPDFObject* value);
+    void insertObjRef(const char key[], SkPDFObject* value);
+    void insertObjRef(const SkString& key, SkPDFObject* value);
 
     /** Add the value to the dictionary with the given key.
      *  @param key   The text of the key for this dictionary entry.
      *  @param value The value for this dictionary entry.
      */
     void insertBool(const char key[], bool value);
     void insertInt(const char key[], int32_t value);
     void insertInt(const char key[], size_t value);
     void insertScalar(const char key[], SkScalar value);
     void insertName(const char key[], const char nameValue[]);
@@ skipping 27 matching lines @@
 /** \class SkPDFSharedStream
 
     This class takes an asset and assumes that it is backed by
     long-lived shared data (for example, an open file
     descriptor). That is: no memory savings can be made by holding on
     to a compressed version instead.
  */
 class SkPDFSharedStream final : public SkPDFObject {
 public:
     // Takes ownership of asset.
-    SkPDFSharedStream(SkStreamAsset* data)
-        : fAsset(data), fDict(new SkPDFDict) { SkASSERT(data); }
+    SkPDFSharedStream(SkStreamAsset* data) : fAsset(data), fDict(new SkPDFDict) { SkASSERT(data); }
     SkPDFDict* dict() { return fDict.get(); }
     void emitObject(SkWStream*,
                     const SkPDFObjNumMap&,
                     const SkPDFSubstituteMap&) const override;
     void addResources(SkPDFObjNumMap*,
                       const SkPDFSubstituteMap&) const override;
 
 private:
     SkAutoTDelete<SkStreamAsset> fAsset;
     sk_sp<SkPDFDict> fDict;
@@ skipping 62 matching lines @@
 };
 
 #ifdef SK_PDF_IMAGE_STATS
 extern SkAtomic<int> gDrawImageCalls;
 extern SkAtomic<int> gJpegImageObjects;
 extern SkAtomic<int> gRegularImageObjects;
 extern void SkPDFImageDumpStats();
 #endif // SK_PDF_IMAGE_STATS
 
 #endif