pdfviewer: track what objects have been used during rendering. It will be the base of reporting unu…

experimental/PdfViewer/pdfparser/native/SkPdfNativeObject.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPdfNativeObject_DEFINED
 #define SkPdfNativeObject_DEFINED
 
@@ skipping 85 matching lines @@
         SkTDArray<SkPdfNativeObject*>* fArray;
         Reference fRef;
     };
     SkTDict<SkPdfNativeObject*>* fMap;
 
     // TODO(edisonn): rename data with cache
     void* fData;
     DataType fDataType;
 
 
+    // Keep this the last entrys
+#ifdef PDF_TRACK_OBJECT_USAGE
+    mutable bool fUsed;
+#endif   // PDF_TRACK_OBJECT_USAGE
+
 public:
 
-    SkPdfNativeObject() : fInRendering(0), fObjectType(kInvalid_PdfObjectType), fMap(NULL), fData(NULL), fDataType(kEmpty_Data) {}
+    SkPdfNativeObject() : fInRendering(0)
+                        , fObjectType(kInvalid_PdfObjectType)
+                        , fMap(NULL)
+                        , fData(NULL)
+                        , fDataType(kEmpty_Data)
+#ifdef PDF_TRACK_OBJECT_USAGE
+                        , fUsed(false)
+#endif   // PDF_TRACK_OBJECT_USAGE
+    {}
 
     bool inRendering() const { return fInRendering != 0; }
     void startRendering() {fInRendering = 1;}
     void doneRendering() {fInRendering = 0;}
 
     inline bool hasData(DataType type) {
         return type == fDataType;
     }
 
     inline void* data(DataType type) {
         return type == fDataType ? fData : NULL;
     }
 
     inline void setData(void* data, DataType type) {
         releaseData();
         fDataType = type;
         fData = data;
     }
 
     void releaseData();
 
 //    ~SkPdfNativeObject() {
 //        //reset();  must be called manually!
 //    }
 
     void reset() {
+        SkPdfMarkObjectUnused();
+
         switch (fObjectType) {
             case kArray_PdfObjectType:
                 delete fArray;
                 break;
 
             case kDictionary_PdfObjectType:
                 delete fMap;
                 if (isStreamOwned()) {
                     delete[] fStr.fBuffer;
                     fStr.fBuffer = NULL;
                     fStr.fBytes = 0;
                 }
                 break;
 
             default:
                 break;
         }
         fObjectType = kInvalid_PdfObjectType;
         releaseData();
     }
 
-    ObjectType type() { return fObjectType; }
+    ObjectType type() {
+        SkPdfMarkObjectUsed();
+
+        return fObjectType;
+    }
 
     const char* c_str() const {
+        SkPdfMarkObjectUsed();
+
         switch (fObjectType) {
             case kString_PdfObjectType:
             case kHexString_PdfObjectType:
             case kKeyword_PdfObjectType:
             case kName_PdfObjectType:
                 return (const char*)fStr.fBuffer;
 
             default:
                 // TODO(edisonn): report/warning
                 return NULL;
         }
     }
 
     size_t lenstr() const {
+        SkPdfMarkObjectUsed();
+
         switch (fObjectType) {
             case kString_PdfObjectType:
             case kHexString_PdfObjectType:
             case kKeyword_PdfObjectType:
             case kName_PdfObjectType:
                 return fStr.fBytes;
 
             default:
                 // TODO(edisonn): report/warning
                 return 0;
@@ skipping 163 matching lines @@
         if (fObjectType != kArray_PdfObjectType) {
             // TODO(edisonn): report err
             return false;
         }
 
         fArray->push(obj);
         return true;
     }
 
     size_t size() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kArray_PdfObjectType);
 
         return fArray->count();
     }
 
     SkPdfNativeObject* objAtAIndex(int i) {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kArray_PdfObjectType);
 
         return (*fArray)[i];
     }
 
     SkPdfNativeObject* removeLastInArray() {
+        // SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kArray_PdfObjectType);
 
         SkPdfNativeObject* ret = NULL;
         fArray->pop(&ret);
 
         return ret;
     }
 
 
     const SkPdfNativeObject* objAtAIndex(int i) const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kArray_PdfObjectType);
 
         return (*fArray)[i];
     }
 
     SkPdfNativeObject* operator[](int i) {
         SkASSERT(fObjectType == kArray_PdfObjectType);
 
         return (*fArray)[i];
     }
 
     const SkPdfNativeObject* operator[](int i) const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kArray_PdfObjectType);
 
         return (*fArray)[i];
     }
 
 
     // TODO(edisonn): make the functions to return SkPdfDictionary, move these functions in SkPdfDictionary
     static void makeEmptyDictionary(SkPdfNativeObject* obj) {
         SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
 
         obj->fObjectType = kDictionary_PdfObjectType;
         obj->fMap = new SkTDict<SkPdfNativeObject*>(1);
         obj->fStr.fBuffer = NULL;
         obj->fStr.fBytes = 0;
     }
 
     // TODO(edisonn): get all the possible names from spec, and compute a hash function
     // that would create no overlaps in the same dictionary
     // or build a tree of chars that when followed goes to a unique id/index/hash
     // TODO(edisonn): generate constants like kDictFoo, kNameDict_name
     // which will be used in code
     // add function SkPdfFastNameKey key(const char* key);
     // TODO(edisonn): setting the same key twike, will make the value undefined!
     bool set(const SkPdfNativeObject* key, SkPdfNativeObject* value) {
+        //SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key->fObjectType == kName_PdfObjectType);
 
         if (key->fObjectType != kName_PdfObjectType || fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return false;
         }
 
         //// we rewrite all delimiters and white spaces with '\0', so we expect the end of name to be '\0'
         //SkASSERT(key->fStr.fBuffer[key->fStr.fBytes] == '\0');
 
         return set(key->fStr.fBuffer, key->fStr.fBytes, value);
     }
 
     bool set(const char* key, SkPdfNativeObject* value) {
+        //SkPdfMarkObjectUsed();
+
         return set((const unsigned char*)key, strlen(key), value);
     }
 
     bool set(const unsigned char* key, size_t len, SkPdfNativeObject* value) {
+        //SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
 
         if (fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return false;
         }
 
         return fMap->set((const char*)key, len, value);
     }
 
     SkPdfNativeObject* get(const SkPdfNativeObject* key) {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key->fObjectType == kName_PdfObjectType);
 
         if (key->fObjectType != kName_PdfObjectType || fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return NULL;
         }
 
         //SkASSERT(key->fStr.fBuffer[key->fStr.fBytes] == '\0');
 
         return get(key->fStr.fBuffer, key->fStr.fBytes);
     }
 
     SkPdfNativeObject* get(const char* key) {
+        SkPdfMarkObjectUsed();
+
         return get((const unsigned char*)key, strlen(key));
     }
 
     SkPdfNativeObject* get(const unsigned char* key, size_t len) {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key);
         if (fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return NULL;
         }
         SkPdfNativeObject* ret = NULL;
         fMap->find((const char*)key, len, &ret);
 
 #ifdef PDF_TRACE
         SkString _key;
         _key.append((const char*)key, len);
         printf("\nget(/%s) = %s\n", _key.c_str(), ret ? ret->toString(0, len + 9).c_str() : "_NOT_FOUND");
 #endif
 
         return ret;
     }
 
     const SkPdfNativeObject* get(const SkPdfNativeObject* key) const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key->fObjectType == kName_PdfObjectType);
 
         if (key->fObjectType != kName_PdfObjectType || fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return NULL;
         }
 
         //SkASSERT(key->fStr.fBuffer[key->fStr.fBytes] == '\0');
 
         return get(key->fStr.fBuffer, key->fStr.fBytes);
     }
 
     const SkPdfNativeObject* get(const char* key) const {
+        SkPdfMarkObjectUsed();
+
         return get((const unsigned char*)key, strlen(key));
     }
 
     const SkPdfNativeObject* get(const unsigned char* key, size_t len) const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key);
         if (fObjectType != kDictionary_PdfObjectType) {
             // TODO(edisonn): report err
             return NULL;
         }
         SkPdfNativeObject* ret = NULL;
         fMap->find((const char*)key, len, &ret);
 
 #ifdef PDF_TRACE
         SkString _key;
         _key.append((const char*)key, len);
         printf("\nget(/%s) = %s\n", _key.c_str(), ret ? ret->toString(0, len + 9).c_str() : "_NOT_FOUND");
 #endif
 
         return ret;
     }
 
     const SkPdfNativeObject* get(const char* key, const char* abr) const {
+        SkPdfMarkObjectUsed();
+
         const SkPdfNativeObject* ret = get(key);
         // TODO(edisonn): / is a valid name, and it might be an abreviation, so "" should not be like NULL
         // make this distiontion in generator, and remove "" from condition
         if (ret != NULL || abr == NULL || *abr == '\0') {
             return ret;
         }
         return get(abr);
     }
 
     SkPdfNativeObject* get(const char* key, const char* abr) {
+        SkPdfMarkObjectUsed();
+
         SkPdfNativeObject* ret = get(key);
         // TODO(edisonn): / is a valid name, and it might be an abreviation, so "" should not be like NULL
         // make this distiontion in generator, and remove "" from condition
         if (ret != NULL || abr == NULL || *abr == '\0') {
             return ret;
         }
         return get(abr);
     }
 
     SkPdfDictionary* asDictionary() {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(isDictionary());
         if (!isDictionary()) {
             return NULL;
         }
         return (SkPdfDictionary*) this;
     }
 
     const SkPdfDictionary* asDictionary() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(isDictionary());
         if (!isDictionary()) {
             return NULL;
         }
         return (SkPdfDictionary*) this;
     }
 
 
     bool isReference() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kReference_PdfObjectType;
     }
 
     bool isBoolean() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kBoolean_PdfObjectType;
     }
 
     bool isInteger() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kInteger_PdfObjectType;
     }
 private:
     bool isReal() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kReal_PdfObjectType;
     }
 public:
     bool isNumber() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kInteger_PdfObjectType || fObjectType == kReal_PdfObjectType;
     }
 
     bool isKeywordReference() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kKeyword_PdfObjectType && fStr.fBytes == 1 && fStr.fBuffer[0] == 'R';
     }
 
     bool isKeyword() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kKeyword_PdfObjectType;
     }
 
     bool isKeyword(const char* keyword) const {
+        SkPdfMarkObjectUsed();
+
         if (!isKeyword()) {
             return false;
         }
 
         if (strlen(keyword) != fStr.fBytes) {
             return false;
         }
 
         if (strncmp(keyword, (const char*)fStr.fBuffer, fStr.fBytes) != 0) {
             return false;
         }
 
         return true;
     }
 
     bool isName() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kName_PdfObjectType;
     }
 
     bool isName(const char* name) const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kName_PdfObjectType && fStr.fBytes == strlen(name) && strncmp((const char*)fStr.fBuffer, name, fStr.fBytes) == 0;
     }
 
     bool isArray() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kArray_PdfObjectType;
     }
 
     bool isDate() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kString_PdfObjectType || fObjectType == kHexString_PdfObjectType;
     }
 
     bool isDictionary() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kDictionary_PdfObjectType;
     }
 
     bool isFunction() const {
+        SkPdfMarkObjectUsed();
+
         return false;  // NYI
     }
 
     bool isRectangle() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kArray_PdfObjectType && fArray->count() == 4; // NYI + and elems are numbers
     }
 
     // TODO(edisonn): has stream .. or is stream ... TBD
     bool hasStream() const {
+        SkPdfMarkObjectUsed();
+
         return isDictionary() && fStr.fBuffer != NULL;
     }
 
     // TODO(edisonn): has stream .. or is stream ... TBD
     const SkPdfStream* getStream() const {
+        SkPdfMarkObjectUsed();
+
         return hasStream() ? (const SkPdfStream*)this : NULL;
     }
 
     SkPdfStream* getStream() {
+        SkPdfMarkObjectUsed();
+
         return hasStream() ? (SkPdfStream*)this : NULL;
     }
 
     bool isAnyString() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kString_PdfObjectType || fObjectType == kHexString_PdfObjectType;
     }
 
     bool isHexString() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kHexString_PdfObjectType;
     }
 
     bool isMatrix() const {
+        SkPdfMarkObjectUsed();
+
         return fObjectType == kArray_PdfObjectType && fArray->count() == 6; // NYI + and elems are numbers
     }
 
     inline int64_t intValue() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kInteger_PdfObjectType);
 
         if (fObjectType != kInteger_PdfObjectType) {
             // TODO(edisonn): log err
             return 0;
         }
         return fIntegerValue;
     }
 private:
     inline double realValue() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kReal_PdfObjectType);
 
         if (fObjectType != kReal_PdfObjectType) {
             // TODO(edisonn): log err
             return 0;
         }
         return fRealValue;
     }
 public:
     inline double numberValue() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(isNumber());
 
         if (!isNumber()) {
             // TODO(edisonn): log err
             return 0;
         }
         return fObjectType == kReal_PdfObjectType ? fRealValue : fIntegerValue;
     }
 
     inline SkScalar scalarValue() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(isNumber());
 
         if (!isNumber()) {
             // TODO(edisonn): log err
             return SkIntToScalar(0);
         }
         return fObjectType == kReal_PdfObjectType ? SkDoubleToScalar(fRealValue) :
                                                     SkIntToScalar(fIntegerValue);
     }
 
     int referenceId() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kReference_PdfObjectType);
         return fRef.fId;
     }
 
     int referenceGeneration() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kReference_PdfObjectType);
         return fRef.fGen;
     }
 
     inline const char* nameValue() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kName_PdfObjectType);
 
         if (fObjectType != kName_PdfObjectType) {
             // TODO(edisonn): log err
             return "";
         }
         return (const char*)fStr.fBuffer;
     }
 
     inline const char* stringValue() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kString_PdfObjectType || fObjectType == kHexString_PdfObjectType);
 
         if (fObjectType != kString_PdfObjectType && fObjectType != kHexString_PdfObjectType) {
             // TODO(edisonn): log err
             return "";
         }
         return (const char*)fStr.fBuffer;
     }
 
     inline NotOwnedString strRef() {
+        SkPdfMarkObjectUsed();
+
         switch (fObjectType) {
             case kString_PdfObjectType:
             case kHexString_PdfObjectType:
             case kKeyword_PdfObjectType:
             case kName_PdfObjectType:
                 return fStr;
 
             default:
                 // TODO(edisonn): report/warning
                 return NotOwnedString();
         }
     }
 
     // TODO(edisonn): nameValue2 and stringValue2 are used to make code generation easy,
     // but it is not a performat way to do it, since it will create an extra copy
     // remove these functions and make code generated faster
     inline SkString nameValue2() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kName_PdfObjectType);
 
         if (fObjectType != kName_PdfObjectType) {
             // TODO(edisonn): log err
             return SkString();
         }
         return SkString((const char*)fStr.fBuffer, fStr.fBytes);
     }
 
     inline SkString stringValue2() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kString_PdfObjectType || fObjectType == kHexString_PdfObjectType);
 
         if (fObjectType != kString_PdfObjectType && fObjectType != kHexString_PdfObjectType) {
             // TODO(edisonn): log err
             return SkString();
         }
         return SkString((const char*)fStr.fBuffer, fStr.fBytes);
     }
 
     inline bool boolValue() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(fObjectType == kBoolean_PdfObjectType);
 
         if (fObjectType != kBoolean_PdfObjectType) {
             // TODO(edisonn): log err
             return false;
         }
         return fBooleanValue;
     }
 
     SkRect rectangleValue() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(isRectangle());
         if (!isRectangle()) {
             return SkRect::MakeEmpty();
         }
 
         double array[4];
         for (int i = 0; i < 4; i++) {
             // TODO(edisonn): version where we could resolve references?
             const SkPdfNativeObject* elem = objAtAIndex(i);
             if (elem == NULL || !elem->isNumber()) {
                 // TODO(edisonn): report error
                 return SkRect::MakeEmpty();
             }
             array[i] = elem->numberValue();
         }
 
         return SkRect::MakeLTRB(SkDoubleToScalar(array[0]),
                                 SkDoubleToScalar(array[1]),
                                 SkDoubleToScalar(array[2]),
                                 SkDoubleToScalar(array[3]));
     }
 
     SkMatrix matrixValue() const {
+        SkPdfMarkObjectUsed();
+
         SkASSERT(isMatrix());
         if (!isMatrix()) {
             return SkMatrix::I();
         }
 
         double array[6];
         for (int i = 0; i < 6; i++) {
             // TODO(edisonn): version where we could resolve references?
             const SkPdfNativeObject* elem = objAtAIndex(i);
             if (elem == NULL || !elem->isNumber()) {
                 // TODO(edisonn): report error
                 return SkMatrix::I();
             }
             array[i] = elem->numberValue();
         }
 
         return SkMatrixFromPdfMatrix(array);
     }
 
     bool filterStream();
 
 
     bool GetFilteredStreamRef(unsigned char const** buffer, size_t* len) {
+        SkPdfMarkObjectUsed();
+
         // TODO(edisonn): add params that couls let the last filter in place if it is jpeg or png to fast load images
         if (!hasStream()) {
             return false;
         }
 
         filterStream();
 
         if (buffer) {
             *buffer = fStr.fBuffer;
         }
 
         if (len) {
             *len = fStr.fBytes >> 2;  // last 2 bits
         }
 
         return true;
     }
 
     bool isStreamFiltered() const {
+        SkPdfMarkObjectUsed();
+
         return hasStream() && ((fStr.fBytes & 1) == kFilteredStreamBit);
     }
 
     bool isStreamOwned() const {
+        SkPdfMarkObjectUsed();
+
         return hasStream() && ((fStr.fBytes & 2) == kOwnedStreamBit);
     }
 
     bool GetUnfilteredStreamRef(unsigned char const** buffer, size_t* len) const {
+        SkPdfMarkObjectUsed();
+
         if (isStreamFiltered()) {
             return false;
         }
 
         if (!hasStream()) {
             return false;
         }
 
         if (buffer) {
             *buffer = fStr.fBuffer;
         }
 
         if (len) {
             *len = fStr.fBytes >> 2;  // remove last 2 bits
         }
 
         return true;
     }
 
     bool addStream(const unsigned char* buffer, size_t len) {
+        //SkPdfMarkObjectUsed();
+
         SkASSERT(!hasStream());
         SkASSERT(isDictionary());
 
         if (!isDictionary() || hasStream()) {
             return false;
         }
 
         fStr.fBuffer = buffer;
         fStr.fBytes = (len << 2) + kUnfilteredStreamBit;
 
@@ skipping 164 matching lines @@
     SkPdfName() : SkPdfNativeObject() {
         SkPdfNativeObject::makeName((const unsigned char*)"", this);
     }
 public:
     SkPdfName(char* name) : SkPdfNativeObject() {
         this->makeName((const unsigned char*)name, this);
     }
 };
 
 #endif  // SkPdfNativeObject