code cleanup

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
 
 #include <stdint.h>
 #include <string.h>
+
+#include "SkMatrix.h"
+#include "SkPdfConfig.h"
+#include "SkPdfNativeTokenizer.h"
+#include "SkPdfNYI.h"
+#include "SkPdfUtils.h"
+#include "SkRect.h"
 #include "SkString.h"
 #include "SkTDArray.h"
 #include "SkTDict.h"
-#include "SkRect.h"
-#include "SkMatrix.h"
-#include "SkString.h"
-
-#include "SkPdfNYI.h"
-#include "SkPdfConfig.h"
-#include "SkPdfUtils.h"
-
-#include "SkPdfNativeTokenizer.h"
 
 class SkPdfDictionary;
 class SkPdfStream;
 class SkPdfAllocator;
 
-// TODO(edisonn): macro it and move it to utils
-SkMatrix SkMatrixFromPdfMatrix(double array[6]);
-
-
+// TODO(edisonn): remove these constants and clean up the code.
 #define kFilteredStreamBit 0
 #define kUnfilteredStreamBit 1
 #define kOwnedStreamBit 2
 
 class SkPdfNativeObject {
  public:
      enum ObjectType {
          // The type will have only one of these values, but for error reporting, we make it an enum
          // so it can easily report that something was expected to be one of a few types
          kInvalid_PdfObjectType = 1 << 1,
 
          kBoolean_PdfObjectType = 1 << 2,
          kInteger_PdfObjectType = 1 << 3,
          kReal_PdfObjectType = 1 << 4,
          _kNumber_PdfObjectType = kInteger_PdfObjectType | kReal_PdfObjectType,
          kString_PdfObjectType = 1 << 5,
          kHexString_PdfObjectType = 1 << 6,
          _kAnyString_PdfObjectType = kString_PdfObjectType | kHexString_PdfObjectType,
          kName_PdfObjectType = 1 << 7,
          kKeyword_PdfObjectType = 1 << 8,
          _kStream_PdfObjectType = 1 << 9,  //  attached to a Dictionary, do not use
          kArray_PdfObjectType = 1 << 10,
          kDictionary_PdfObjectType = 1 << 11,
          kNull_PdfObjectType = 1 << 12,
 
-         // TODO(edisonn): after the pdf has been loaded completely, resolve all references
-         // try the same thing with delayed loaded ...
          kReference_PdfObjectType = 1 << 13,
 
-         kUndefined_PdfObjectType = 1 << 14,  // per 1.4 spec, if the same key appear twice in the dictionary, the value is undefined
+         kUndefined_PdfObjectType = 1 << 14,  // per 1.4 spec, if the same key appear twice in the
+                                              // dictionary, the value is undefined.
 
          _kObject_PdfObjectType = -1,
      };
 
      enum DataType {
          kEmpty_Data,
          kFont_Data,
          kBitmap_Data,
      };
 
 private:
-    // TODO(edisonn): assert reset operations while in rendering!
+    // TODO(edisonn): assert reset operations while in rendering! The objects should be reset
+    // only when rendering is completed.
     uint32_t fInRendering : 1;
     uint32_t fUnused : 31;
 
-
     struct Reference {
         unsigned int fId;
         unsigned int fGen;
     };
 
-    // TODO(edisonn): add stream start, stream end, where stream is weither the file
-    // or decoded/filtered pdf stream
-
-    // TODO(edisonn): add warning/report per object
-    // TODO(edisonn): add flag fUsed, to be used once the parsing is complete,
-    // so we could show what parts have been proccessed, ignored, or generated errors
-
     ObjectType fObjectType;
 
     union {
         bool fBooleanValue;
         int64_t fIntegerValue;
-        // TODO(edisonn): double, float? typedefed
+        // TODO(edisonn): double, float, SkScalar?
         double fRealValue;
         NotOwnedString fStr;
 
-        // TODO(edisonn): make sure the foorprint of fArray and fMap is small, otherwise, use pointers, or classes with up to 8 bytes in footprint
         SkTDArray<SkPdfNativeObject*>* fArray;
         Reference fRef;
     };
     SkTDict<SkPdfNativeObject*>* fMap;
 
     // TODO(edisonn): rename data with cache
     void* fData;
     DataType fDataType;
 
-
     // Keep this the last entries
 #ifdef PDF_TRACK_OBJECT_USAGE
     mutable bool fUsed;
 #endif   // PDF_TRACK_OBJECT_USAGE
 
 #ifdef PDF_TRACK_STREAM_OFFSETS
 public:
     int fStreamId;
     int fOffsetStart;
     int fOffsetEnd;
@@ skipping 38 matching lines @@
 
     inline void setData(void* data, DataType type) {
         releaseData();
         fDataType = type;
         fData = data;
     }
 
     void releaseData();
 
 //    ~SkPdfNativeObject() {
-//        //reset();  must be called manually!
+//        //reset();  must be called manually! Normally, will be called by allocator destructor.
 //    }
 
     void reset() {
         SkPdfMarkObjectUnused();
 
         switch (fObjectType) {
             case kArray_PdfObjectType:
                 delete fArray;
                 break;
 
@@ skipping 23 matching lines @@
         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
+                // TODO(edisonn): report/warning/assert?
                 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
+                // TODO(edisonn): report/warning/assert?
                 return 0;
         }
     }
 
 
     // TODO(edisonn): NYI
     SkPdfDate& dateValue() const {
         static SkPdfDate nyi;
         return nyi;
     }
 
     // TODO(edisonn): NYI
     SkPdfFunction& functionValue() const {
         static SkPdfFunction nyi;
         return nyi;
     }
 
     // TODO(edisonn): NYI
     SkPdfFileSpec& fileSpecValue() const {
         static SkPdfFileSpec nyi;
         return nyi;
     }
 
     // TODO(edisonn): NYI
     SkPdfTree& treeValue() const {
         static SkPdfTree nyi;
         return nyi;
     }
 
-    // TODO(edisonn) impl store
-    //STORE_TRACK_PARAMETERS(obj);
-
     static void makeBoolean(bool value, SkPdfNativeObject* obj) {
 
         SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
 
         obj->fObjectType = kBoolean_PdfObjectType;
         obj->fBooleanValue = value;
     }
 
     static SkPdfNativeObject makeBoolean(bool value) {
         SkPdfNativeObject obj;
@@ skipping 25 matching lines @@
 
     static SkPdfNativeObject makeNull() {
         SkPdfNativeObject obj;
 
         obj.fObjectType = kNull_PdfObjectType;
         return obj;
     }
 
     static SkPdfNativeObject kNull;
 
-    static void makeNumeric(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj) {
+    static void makeNumeric(const unsigned char* start, const unsigned char* end,
+                            SkPdfNativeObject* obj) {
         SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
 
         // TODO(edisonn): NYI properly
         // if has dot (impl), or exceeds max int, is real, otherwise is int
         bool isInt = true;
         for (const unsigned char* current = start; current < end; current++) {
             if (*current == '.') {
                 isInt = false;
                 break;
             }
@@ skipping 17 matching lines @@
     static void resetAndMakeReference(unsigned int id, unsigned int gen, SkPdfNativeObject* obj) {
         obj->reset();
         makeReference(id, gen, obj);
     }
 
 
     static void makeString(const unsigned char* start, SkPdfNativeObject* obj) {
         makeStringCore(start, strlen((const char*)start), obj, kString_PdfObjectType);
     }
 
-    static void makeString(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj) {
+    static void makeString(const unsigned char* start, const unsigned char* end,
+                           SkPdfNativeObject* obj) {
         makeStringCore(start, end - start, obj, kString_PdfObjectType);
     }
 
     static void makeString(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
         makeStringCore(start, bytes, obj, kString_PdfObjectType);
     }
 
 
     static void makeHexString(const unsigned char* start, SkPdfNativeObject* obj) {
         makeStringCore(start, strlen((const char*)start), obj, kHexString_PdfObjectType);
     }
 
-    static void makeHexString(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj) {
+    static void makeHexString(const unsigned char* start, const unsigned char* end,
+                              SkPdfNativeObject* obj) {
         makeStringCore(start, end - start, obj, kHexString_PdfObjectType);
     }
 
     static void makeHexString(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
         makeStringCore(start, bytes, obj, kHexString_PdfObjectType);
     }
 
 
     static void makeName(const unsigned char* start, SkPdfNativeObject* obj) {
         makeStringCore(start, strlen((const char*)start), obj, kName_PdfObjectType);
     }
 
-    static void makeName(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj) {
+    static void makeName(const unsigned char* start, const unsigned char* end,
+                         SkPdfNativeObject* obj) {
         makeStringCore(start, end - start, obj, kName_PdfObjectType);
     }
 
     static void makeName(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
         makeStringCore(start, bytes, obj, kName_PdfObjectType);
     }
 
 
     static void makeKeyword(const unsigned char* start, SkPdfNativeObject* obj) {
         makeStringCore(start, strlen((const char*)start), obj, kKeyword_PdfObjectType);
     }
 
-    static void makeKeyword(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj) {
+    static void makeKeyword(const unsigned char* start, const unsigned char* end,
+                            SkPdfNativeObject* obj) {
         makeStringCore(start, end - start, obj, kKeyword_PdfObjectType);
     }
 
     static void makeKeyword(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj) {
         makeStringCore(start, bytes, obj, kKeyword_PdfObjectType);
     }
 
-
-
-    // TODO(edisonn): make the functions to return SkPdfArray, move these functions in SkPdfArray
     static void makeEmptyArray(SkPdfNativeObject* obj) {
         SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
 
         obj->fObjectType = kArray_PdfObjectType;
         obj->fArray = new SkTDArray<SkPdfNativeObject*>();
-        // return (SkPdfArray*)obj;
     }
 
     bool appendInArray(SkPdfNativeObject* obj) {
         SkASSERT(fObjectType == kArray_PdfObjectType);
         if (fObjectType != kArray_PdfObjectType) {
-            // TODO(edisonn): report err
+            // TODO(edisonn): report/warning/assert?
             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();
+        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) {
+        SkPdfMarkObjectUsed();
+
         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
+    // TODO(edisonn): perf: 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!
+    // TODO(edisonn): setting the same key twice, will make the value undefined!
     bool set(const SkPdfNativeObject* key, SkPdfNativeObject* value) {
-        //SkPdfMarkObjectUsed();
+        SkPdfMarkObjectUsed();
 
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
         SkASSERT(key->fObjectType == kName_PdfObjectType);
 
         if (key->fObjectType != kName_PdfObjectType || fObjectType != kDictionary_PdfObjectType) {
-            // TODO(edisonn): report err
+            // TODO(edisonn): report/warn/assert?
             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();
+        SkPdfMarkObjectUsed();
 
         return set((const unsigned char*)key, strlen(key), value);
     }
 
     bool set(const unsigned char* key, size_t len, SkPdfNativeObject* value) {
-        //SkPdfMarkObjectUsed();
+        SkPdfMarkObjectUsed();
 
         SkASSERT(fObjectType == kDictionary_PdfObjectType);
 
         if (fObjectType != kDictionary_PdfObjectType) {
-            // TODO(edisonn): report err
+            // TODO(edisonn): report/warn/assert.
             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
+            // TODO(edisonn): report/warn/assert.
             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
+            // TODO(edisonn): report/warn/assert.
             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");
+        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
+            // TODO(edisonn): report/warn/assert.
             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
+            // TODO(edisonn): report/warn/assert.
             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");
+        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
+        // TODO(edisonn): remove  || *abr == '\0' and pass NULL in the _autogen files instead.
         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
+        // TODO(edisonn): remove  || *abr == '\0' and pass NULL in the _autogen files instead.
         if (ret != NULL || abr == NULL || *abr == '\0') {
             return ret;
         }
         return get(abr);
     }
 
     SkPdfDictionary* asDictionary() {
         SkPdfMarkObjectUsed();
 
         SkASSERT(isDictionary());
@@ skipping 76 matching lines @@
 
     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;
+        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): add also that each of these 4 objects are numbers.
+        return fObjectType == kArray_PdfObjectType && fArray->count() == 4;
     }
 
     // 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
@@ skipping 17 matching lines @@
 
     bool isHexString() const {
         SkPdfMarkObjectUsed();
 
         return fObjectType == kHexString_PdfObjectType;
     }
 
     bool isMatrix() const {
         SkPdfMarkObjectUsed();
 
-        return fObjectType == kArray_PdfObjectType && fArray->count() == 6; // NYI + and elems are numbers
+        // TODO(edisonn): add also that each of these 6 objects are numbers.
+        return fObjectType == kArray_PdfObjectType && fArray->count() == 6;
     }
 
     inline int64_t intValue() const {
         SkPdfMarkObjectUsed();
 
         SkASSERT(fObjectType == kInteger_PdfObjectType);
 
         if (fObjectType != kInteger_PdfObjectType) {
-            // TODO(edisonn): log err
+            // TODO(edisonn): report/warn/assert.
             return 0;
         }
         return fIntegerValue;
     }
 private:
     inline double realValue() const {
         SkPdfMarkObjectUsed();
 
         SkASSERT(fObjectType == kReal_PdfObjectType);
 
         if (fObjectType != kReal_PdfObjectType) {
-            // TODO(edisonn): log err
+            // TODO(edisonn): report/warn/assert.
             return 0;
         }
         return fRealValue;
     }
 public:
     inline double numberValue() const {
         SkPdfMarkObjectUsed();
 
         SkASSERT(isNumber());
 
         if (!isNumber()) {
-            // TODO(edisonn): log err
+            // TODO(edisonn): report/warn/assert.
             return 0;
         }
         return fObjectType == kReal_PdfObjectType ? fRealValue : fIntegerValue;
     }
 
     inline SkScalar scalarValue() const {
         SkPdfMarkObjectUsed();
 
         SkASSERT(isNumber());
 
         if (!isNumber()) {
-            // TODO(edisonn): log err
+            // TODO(edisonn): report/warn/assert.
             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
+            // TODO(edisonn): report/warn/assert.
             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
+            // TODO(edisonn): report/warn/assert.
             return "";
         }
         return (const char*)fStr.fBuffer;
     }
 
     inline NotOwnedString strRef() {
         SkPdfMarkObjectUsed();
 
         switch (fObjectType) {
             case kString_PdfObjectType:
@@ skipping 22 matching lines @@
         }
         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
+            // TODO(edisonn): report/warn/assert.
             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
+            // TODO(edisonn): report/warn/assert.
             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
+                // TODO(edisonn): report/warn/assert.
                 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
+                // TODO(edisonn): report/warn/assert.
                 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
+        // TODO(edisonn): add params that could 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
+            *len = fStr.fBytes >> 2;  // last 2 bits - TODO(edisonn): clean up.
         }
 
         return true;
     }
 
     bool isStreamFiltered() const {
         SkPdfMarkObjectUsed();
 
         return hasStream() && ((fStr.fBytes & 1) == kFilteredStreamBit);
     }
@@ skipping 13 matching lines @@
 
         if (!hasStream()) {
             return false;
         }
 
         if (buffer) {
             *buffer = fStr.fBuffer;
         }
 
         if (len) {
-            *len = fStr.fBytes >> 2;  // remove last 2 bits
+            *len = fStr.fBytes >> 2;  // remove last 2 bits - TODO(edisonn): clean up.
         }
 
         return true;
     }
 
     bool addStream(const unsigned char* buffer, size_t len) {
-        //SkPdfMarkObjectUsed();
+        SkPdfMarkObjectUsed();
 
         SkASSERT(!hasStream());
         SkASSERT(isDictionary());
 
         if (!isDictionary() || hasStream()) {
             return false;
         }
 
         fStr.fBuffer = buffer;
         fStr.fBytes = (len << 2) + kUnfilteredStreamBit;
@@ skipping 86 matching lines @@
                 str.append("]");
                 break;
 
             case kDictionary_PdfObjectType: {
                     SkTDict<SkPdfNativeObject*>::Iter iter(*fMap);
                     SkPdfNativeObject* obj = NULL;
                     const char* key = NULL;
                     str.append("<<\n");
                     while ((key = iter.next(&obj)) != NULL) {
                         appendSpaces(&str, level + 2);
-                        str.appendf("/%s %s\n", key, obj->toString(0, level + strlen(key) + 4).c_str());
+                        str.appendf("/%s %s\n", key,
+                                    obj->toString(0, level + strlen(key) + 4).c_str());
                     }
                     appendSpaces(&str, level);
                     str.append(">>");
                     if (hasStream()) {
                         const unsigned char* stream = NULL;
                         size_t length = 0;
                         if (GetFilteredStreamRef(&stream, &length)) {
                             str.append("stream\n");
                             append(&str, (const char*)stream, length > 256 ? 256 : length);
                             str.append("\nendstream");
@@ skipping 18 matching lines @@
 
             default:
                 str = "Error";
                 break;
         }
 
         return str;
     }
 
 private:
-    static void makeStringCore(const unsigned char* start, SkPdfNativeObject* obj, ObjectType type) {
+    static void makeStringCore(const unsigned char* start, SkPdfNativeObject* obj,
+                               ObjectType type) {
         makeStringCore(start, strlen((const char*)start), obj, type);
     }
 
-    static void makeStringCore(const unsigned char* start, const unsigned char* end, SkPdfNativeObject* obj, ObjectType type) {
+    static void makeStringCore(const unsigned char* start, const unsigned char* end,
+                               SkPdfNativeObject* obj, ObjectType type) {
         makeStringCore(start, end - start, obj, type);
     }
 
-    static void makeStringCore(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj, ObjectType type) {
-
+    static void makeStringCore(const unsigned char* start, size_t bytes, SkPdfNativeObject* obj,
+                               ObjectType type) {
         SkASSERT(obj->fObjectType == kInvalid_PdfObjectType);
 
         obj->fObjectType = type;
         obj->fStr.fBuffer = start;
         obj->fStr.fBytes = bytes;
     }
 
     bool applyFilter(const char* name);
     bool applyFlateDecodeFilter();
     bool applyDCTDecodeFilter();
@@ skipping 11 matching lines @@
     SkPdfName() : SkPdfNativeObject() {
         SkPdfNativeObject::makeName((const unsigned char*)"", this);
     }
 public:
     SkPdfName(char* name) : SkPdfNativeObject() {
         this->makeName((const unsigned char*)name, this);
     }
 };
 
 #endif  // SkPdfNativeObject