Unwind PDFObject destructor calls into heap instead of stack. Notice: the order of the destructors …

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
@@ skipping 11 matching lines @@
 /** \class SkPDFObject
 
     A PDF Object is the base class for primitive elements in a PDF file.  A
     common subtype is used to ease the use of indirect object references,
     which are common in the PDF format.
 */
 class SkPDFObject : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(SkPDFObject)
 
+    virtual ~SkPDFObject() { };
+
     /** Return the size (number of bytes) of this object in the final output
      *  file. Compound objects or objects that are computationally intensive
      *  to output should override this method.
      *  @param catalog  The object catalog to use.
      *  @param indirect If true, output an object identifier with the object.
      */
     virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
 
     /** For non-primitive objects (i.e. objects defined outside this file),
      *  this method will add to resourceList any objects that this method
@@ skipping 30 matching lines @@
                                   SkTDArray<SkPDFObject*>* list);
 
     /** Static helper function to copy and reference the resources (and all
      *   their subresources) into a new list.
      * @param resources The resource list.
      * @param result    The list to add to.
      */
     static void GetResourcesHelper(SkTDArray<SkPDFObject*>* resources,
                                    SkTDArray<SkPDFObject*>* result);
 
+    /** Destroys safely an array of SkPDFObject's.

[Tom Hudson, 2013/03/07 13:54:37]

nit: no apostrophe

[edisonn, 2013/03/07 16:51:30]

Done.

+     *  The stack won't be used much, and stack overflow will be avoided.
+     *  @param list: The list of objects to be destroyed.

[Tom Hudson, 2013/03/07 13:54:37]

nit: redundant @param

[edisonn, 2013/03/07 16:51:30]

removed

+     */
+    static void safeUnref(SkTDArray<SkPDFObject*>* list) {
+        while (list->count() > 0) {
+            SkPDFObject* obj = NULL;
+            list->pop(&obj);
+            if (obj) {
+                // Releases all refs to be owned by list, unref will call destructor!
+                if (obj->fRefCnt == 1) {
+                    obj->trasferPDFObjecsOwnership(list);
+                }
+                // If unref calls destructor, it won't call recursively
+                // other ~SkPDFObjects().
+                obj->unref();
+            }
+        }
+    }
+
 protected:
     /** Subclasses must implement this method to print the object to the
      *  PDF file.
      *  @param catalog  The object catalog to use.
      *  @param indirect If true, output an object identifier with the object.
      *  @param stream   The writable output stream to send the output to.
      */
     virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
                             bool indirect) = 0;
 
+    /** Dumps all the SkPDFObject members in the list. When the destructor is
+     *  called, the stack won't be used much.
+     *  This method will destroy the state of the object. Should be called only
+     *  during destructor calls.
+     *  @param list: The list that will own the SkPDFObject members.

[Tom Hudson, 2013/03/07 13:54:37]

This @param declaration doesn't actually explain what's going on (perhaps
because of verb tense?), but we don't normally require @param for everything,
and it is adequately covered by the function comment.

[edisonn, 2013/03/07 16:51:30]

Done.

+     */
+    virtual void trasferPDFObjecsOwnership(SkTDArray<SkPDFObject*>* list) {}
+
         typedef SkRefCnt INHERITED;
 };
 
 /** \class SkPDFObjRef
 
     An indirect reference to a PDF object.
 */
 class SkPDFObjRef : public SkPDFObject {
 public:
     SK_DECLARE_INST_COUNT(SkPDFObjRef)
 
     /** Create a reference to an existing SkPDFObject.
      *  @param obj The object to reference.
      */
     explicit SkPDFObjRef(SkPDFObject* obj);
     virtual ~SkPDFObjRef();
 
     // The SkPDFObject interface.
     virtual void emitObject(SkWStream* stream, SkPDFCatalog* catalog,
                             bool indirect);
     virtual size_t getOutputSize(SkPDFCatalog* catalog, bool indirect);
 
+protected:
+    virtual void trasferPDFObjecsOwnership(SkTDArray<SkPDFObject*>* list) {
+        list->push(fObj.detach());
+
+        INHERITED::trasferPDFObjecsOwnership(list);
+    }
+
 private:
     SkAutoTUnref<SkPDFObject> fObj;
 
     typedef SkPDFObject INHERITED;
 };
 
 /** \class SkPDFInt
 
     An integer object in a PDF.
 */
@@ skipping 275 matching lines @@
      *  @param name  The name for this dictionary entry.
      */
     void insertName(const char key[], const SkString& name) {
         this->insertName(key, name.c_str());
     }
 
     /** Remove all entries from the dictionary.
      */
     void clear();
 
+    virtual void trasferPDFObjecsOwnership(SkTDArray<SkPDFObject*>* list) {
+        for (int i = 0; i < fValue.count(); i++) {
+            list->push(fValue[i].key);
+            fValue[i].key = NULL;
+            list->push(fValue[i].value);
+            fValue[i].value = NULL;
+        }
+        fValue.reset();
+
+        INHERITED::trasferPDFObjecsOwnership(list);
+    }
+
 private:
     struct Rec {
       SkPDFName* key;
       SkPDFObject* value;
     };
 
 public:
     class Iter {
     public:
         explicit Iter(const SkPDFDict& dict);
         SkPDFName* next(SkPDFObject** value);
 
     private:
         const Rec* fIter;
         const Rec* fStop;
     };
 
 private:
     static const int kMaxLen = 4095;
 
     SkTDArray<struct Rec> fValue;
 
     typedef SkPDFObject INHERITED;
 };
 
 #endif