SkPDF: add drop() virtual to release resources early.

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"
@@ skipping 245 matching lines @@
     fValue.emitObject(stream, objNumMap, substitutes);
 }
 void SkPDFAtom::addResources(SkPDFObjNumMap* map,
                              const SkPDFSubstituteMap& substitutes) const {
     fValue.addResources(map, substitutes);
 }
 #endif  // 0
 
 ////////////////////////////////////////////////////////////////////////////////
 
-SkPDFArray::SkPDFArray() {}
-SkPDFArray::~SkPDFArray() {
-    for (SkPDFUnion& value : fValues) {
-        value.~SkPDFUnion();
-    }
+SkPDFArray::SkPDFArray() { SkDEBUGCODE(fDumped = false;) }
+
+SkPDFArray::~SkPDFArray() { this->dump(); }
+
+void SkPDFArray::dump() {
     fValues.reset();
+    SkDEBUGCODE(fDumped = true;)
 }
 
 int SkPDFArray::size() const { return fValues.count(); }
 
-void SkPDFArray::reserve(int length) { fValues.setReserve(length); }
+void SkPDFArray::reserve(int length) {
+    // TODO: implement SkTArray<T>::reserve()

[tomhudson, 2016/03/18 13:59:38]

TODO! If you intend to leave undone, is there anything somebody else needs to
know to do this themselves, or a bug to refer to?

[hal.canary, 2016/03/18 21:18:07]

I put more info in the TODO.  I haven't had time to explore this yet.

+}
 
 void SkPDFArray::emitObject(SkWStream* stream,
                             const SkPDFObjNumMap& objNumMap,
                             const SkPDFSubstituteMap& substitutes) const {
+    SkASSERT(!fDumped);
     stream->writeText("[");
     for (int i = 0; i < fValues.count(); i++) {
         fValues[i].emitObject(stream, objNumMap, substitutes);
         if (i + 1 < fValues.count()) {
             stream->writeText(" ");
         }
     }
     stream->writeText("]");
 }
 
 void SkPDFArray::addResources(SkPDFObjNumMap* catalog,
                               const SkPDFSubstituteMap& substitutes) const {
+    SkASSERT(!fDumped);
     for (const SkPDFUnion& value : fValues) {
         value.addResources(catalog, substitutes);
     }
 }
 
 void SkPDFArray::append(SkPDFUnion&& value) {
-    new (fValues.append()) SkPDFUnion(std::move(value));
+    fValues.emplace_back(std::move(value));
 }
 
 void SkPDFArray::appendInt(int32_t value) {
     this->append(SkPDFUnion::Int(value));
 }
 
 void SkPDFArray::appendBool(bool value) {
     this->append(SkPDFUnion::Bool(value));
 }
 
@@ skipping 20 matching lines @@
 void SkPDFArray::appendObject(sk_sp<SkPDFObject> objSp) {
     this->append(SkPDFUnion::Object(std::move(objSp)));
 }
 
 void SkPDFArray::appendObjRef(sk_sp<SkPDFObject> objSp) {
     this->append(SkPDFUnion::ObjRef(std::move(objSp)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkPDFDict::SkPDFDict() {}
+SkPDFDict::~SkPDFDict() { this->dump(); }
 
-SkPDFDict::~SkPDFDict() { this->clear(); }
+void SkPDFDict::dump() {
+    fRecords.reset();
+    SkDEBUGCODE(fDumped = true;)
+}
 
-SkPDFDict::SkPDFDict(const char type[]) { this->insertName("Type", type); }
+SkPDFDict::SkPDFDict(const char type[]) {
+    SkDEBUGCODE(fDumped = false;)
+    if (type) {
+        this->insertName("Type", type);
+    }
+}
 
 void SkPDFDict::emitObject(SkWStream* stream,
                            const SkPDFObjNumMap& objNumMap,
                            const SkPDFSubstituteMap& substitutes) const {
     stream->writeText("<<");
     this->emitAll(stream, objNumMap, substitutes);
     stream->writeText(">>");
 }
 
 void SkPDFDict::emitAll(SkWStream* stream,
                         const SkPDFObjNumMap& objNumMap,
                         const SkPDFSubstituteMap& substitutes) const {
+    SkASSERT(!fDumped);
     for (int i = 0; i < fRecords.count(); i++) {
         fRecords[i].fKey.emitObject(stream, objNumMap, substitutes);
         stream->writeText(" ");
         fRecords[i].fValue.emitObject(stream, objNumMap, substitutes);
         if (i + 1 < fRecords.count()) {
             stream->writeText("\n");
         }
     }
 }
 
 void SkPDFDict::addResources(SkPDFObjNumMap* catalog,
                              const SkPDFSubstituteMap& substitutes) const {
+    SkASSERT(!fDumped);
     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));
+SkPDFDict::Record::Record(SkPDFUnion&& k, SkPDFUnion&& v)
+    : fKey(std::move(k)), fValue(std::move(v)) {}
+
+SkPDFDict::Record::Record(SkPDFDict::Record&& o)
+    : fKey(std::move(o.fKey)), fValue(std::move(o.fValue)) {}
+
+SkPDFDict::Record& SkPDFDict::Record::operator=(SkPDFDict::Record&& o) {

[tomhudson, 2016/03/18 13:59:38]

You want move assignment but no non-destructive non-moving assignment?

[hal.canary, 2016/03/18 21:18:07]

Yep.  I have not needed those yet, so I don't define them. 

[tomhudson, 2016/03/21 13:54:30]

Acknowledged.

+    fKey = std::move(o.fKey);
+    fValue = std::move(o.fValue);
+    return *this;
 }
 
 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)));
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(std::move(objSp)));
 }
+
 void SkPDFDict::insertObjRef(const SkString& key, sk_sp<SkPDFObject> objSp) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(std::move(objSp)));
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::ObjRef(std::move(objSp)));
 }
 
 void SkPDFDict::insertObject(const char key[], sk_sp<SkPDFObject> objSp) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::Object(std::move(objSp)));
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::Object(std::move(objSp)));
 }
 void SkPDFDict::insertObject(const SkString& key, sk_sp<SkPDFObject> objSp) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::Object(std::move(objSp)));
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::Object(std::move(objSp)));
 }
 
 void SkPDFDict::insertBool(const char key[], bool value) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::Bool(value));
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::Bool(value));
 }
 
 void SkPDFDict::insertInt(const char key[], int32_t value) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::Int(value));
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::Int(value));
 }
 
 void SkPDFDict::insertInt(const char key[], size_t value) {
     this->insertInt(key, SkToS32(value));
 }
 
 void SkPDFDict::insertScalar(const char key[], SkScalar value) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::Scalar(value));
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::Scalar(value));
 }
 
 void SkPDFDict::insertName(const char key[], const char name[]) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::Name(name));
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::Name(name));
 }
 
 void SkPDFDict::insertName(const char key[], const SkString& name) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::Name(name));
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::Name(name));
 }
 
 void SkPDFDict::insertString(const char key[], const char value[]) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::String(value));
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::String(value));
 }
 
 void SkPDFDict::insertString(const char key[], const SkString& value) {
-    this->set(SkPDFUnion::Name(key), SkPDFUnion::String(value));
-}
-
-void SkPDFDict::clear() {

[tomhudson, 2016/03/18 13:59:38]

What happened to clear()? Do we just not need to call the union destructor any
more?

[hal.canary, 2016/03/18 21:18:07]

clear() is superceded by drop(), which has the same functionality, but is also
virtual.

[tomhudson, 2016/03/21 13:54:30]

Acknowledged.

-    for (Record& rec : fRecords) {
-        rec.fKey.~SkPDFUnion();
-        rec.fValue.~SkPDFUnion();
-    }
-    fRecords.reset();
+    fRecords.emplace_back(SkPDFUnion::Name(key), SkPDFUnion::String(value));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
+SkPDFSharedStream::SkPDFSharedStream(SkStreamAsset* data)
+    : fAsset(data), fDict(new SkPDFDict) {
+    SkDEBUGCODE(fDumped = false;)
+    SkASSERT(data);
+}
+
+SkPDFSharedStream::~SkPDFSharedStream() { this->dump(); }
+
+void SkPDFSharedStream::dump() {
+    fAsset.free();
+    fDict.reset(nullptr);
+    SkDEBUGCODE(fDumped = true;)
+}
+
 void SkPDFSharedStream::emitObject(
         SkWStream* stream,
         const SkPDFObjNumMap& objNumMap,
         const SkPDFSubstituteMap& substitutes) const {
+    SkASSERT(!fDumped);
     SkDynamicMemoryWStream buffer;
     SkDeflateWStream deflateWStream(&buffer);
     // Since emitObject is const, this function doesn't change the dictionary.
     SkAutoTDelete<SkStreamAsset> dup(fAsset->duplicate());  // Cheap copy
     SkASSERT(dup);
     SkStreamCopy(&deflateWStream, dup.get());
     deflateWStream.finalize();
     size_t length = buffer.bytesWritten();
     stream->writeText("<<");
     fDict->emitAll(stream, objNumMap, substitutes);
     stream->writeText("\n");
     SkPDFUnion::Name("Length").emitObject(stream, objNumMap, substitutes);
     stream->writeText(" ");
     SkPDFUnion::Int(length).emitObject(stream, objNumMap, substitutes);
     stream->writeText("\n");
     SkPDFUnion::Name("Filter").emitObject(stream, objNumMap, substitutes);
     stream->writeText(" ");
     SkPDFUnion::Name("FlateDecode").emitObject(stream, objNumMap, substitutes);
     stream->writeText(">>");
     stream->writeText(" stream\n");
     buffer.writeToStream(stream);
     stream->writeText("\nendstream");
 }
 
 void SkPDFSharedStream::addResources(
         SkPDFObjNumMap* catalog, const SkPDFSubstituteMap& substitutes) const {
+    SkASSERT(!fDumped);
     fDict->addResources(catalog, substitutes);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFSubstituteMap::~SkPDFSubstituteMap() {
     fSubstituteMap.foreach(
             [](SkPDFObject*, SkPDFObject** v) { (*v)->unref(); });
 }
 
 void SkPDFSubstituteMap::setSubstitute(SkPDFObject* original,
                                        SkPDFObject* substitute) {
     SkASSERT(original != substitute);
     SkASSERT(!fSubstituteMap.find(original));
     fSubstituteMap.set(original, SkRef(substitute));
 }
 
 SkPDFObject* SkPDFSubstituteMap::getSubstitute(SkPDFObject* object) const {
     SkPDFObject** found = fSubstituteMap.find(object);
     return found ? *found : object;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool SkPDFObjNumMap::addObject(SkPDFObject* obj) {
     if (fObjectNumbers.find(obj)) {
         return false;
     }
     fObjectNumbers.set(obj, fObjectNumbers.count() + 1);
-    fObjects.push(obj);
+    fObjects.emplace_back(sk_ref_sp(obj));

[tomhudson, 2016/03/18 13:59:38]

You're ref'ing an sp, but input is a raw pointer?

[hal.canary, 2016/03/18 21:18:07]

yes.  this is awkward now and I will fix it later.  I need to start holding a
ref so that objects don't get unrefed out of existance when I call drop()
uptree.

[tomhudson, 2016/03/21 13:54:30]

Plz to file bug or TODO about laters.

     return true;
 }
 
 void SkPDFObjNumMap::addObjectRecursively(SkPDFObject* obj,
                                           const SkPDFSubstituteMap& subs) {
     if (obj && this->addObject(obj)) {
         obj->addResources(this, subs);
     }
 }
 
@@ skipping 10 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