Cleanup SkPDFObject::emit*

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 "SkPDFCatalog.h"
 #include "SkPDFTypes.h"
 #include "SkStream.h"
 
 #ifdef SK_BUILD_FOR_WIN
     #define SNPRINTF    _snprintf
 #else
     #define SNPRINTF    snprintf
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkPDFObject::emit(SkWStream* stream, SkPDFCatalog* catalog,
-                       bool indirect) {
-    SkPDFObject* realObject = catalog->getSubstituteObject(this);
-    if (indirect) {
-        realObject->emitIndirectObject(stream, catalog);
-    } else {
-        realObject->emitObject(stream, catalog);
-    }
-}
-
-size_t SkPDFObject::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
-    SkDynamicMemoryWStream buffer;
-    emit(&buffer, catalog, indirect);
-    return buffer.getOffset();
-}
-
 void SkPDFObject::getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
                                SkTSet<SkPDFObject*>* newResourceObjects) {}
 
-void SkPDFObject::emitIndirectObject(SkWStream* stream, SkPDFCatalog* catalog) {
-    catalog->emitObjectNumber(stream, this);
-    stream->writeText(" obj\n");
-    emit(stream, catalog, false);
-    stream->writeText("\nendobj\n");
-}
-
 void SkPDFObject::AddResourceHelper(SkPDFObject* resource,
                                     SkTDArray<SkPDFObject*>* list) {
     list->push(resource);
     resource->ref();
 }
 
 void SkPDFObject::GetResourcesHelper(
         const SkTDArray<SkPDFObject*>* resources,
         const SkTSet<SkPDFObject*>& knownResourceObjects,
         SkTSet<SkPDFObject*>* newResourceObjects) {
     if (resources->count()) {
         newResourceObjects->setReserve(
             newResourceObjects->count() + resources->count());
         for (int i = 0; i < resources->count(); i++) {
             if (!knownResourceObjects.contains((*resources)[i]) &&
                     !newResourceObjects->contains((*resources)[i])) {
                 newResourceObjects->add((*resources)[i]);
                 (*resources)[i]->ref();
                 (*resources)[i]->getResources(knownResourceObjects,
                                               newResourceObjects);
             }
         }
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 SkPDFObjRef::SkPDFObjRef(SkPDFObject* obj) : fObj(obj) {
     SkSafeRef(obj);
 }
 
 SkPDFObjRef::~SkPDFObjRef() {}
 
 void SkPDFObjRef::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     catalog->emitObjectNumber(stream, fObj.get());
     stream->writeText(" R");
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 SkPDFInt::SkPDFInt(int32_t value) : fValue(value) {}
 SkPDFInt::~SkPDFInt() {}
 
 void SkPDFInt::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     stream->writeDecAsText(fValue);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 SkPDFBool::SkPDFBool(bool value) : fValue(value) {}
 SkPDFBool::~SkPDFBool() {}
 
 void SkPDFBool::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     if (fValue) {
         stream->writeText("true");
     } else {
         stream->writeText("false");
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 SkPDFScalar::SkPDFScalar(SkScalar value) : fValue(value) {}
 SkPDFScalar::~SkPDFScalar() {}
 
 void SkPDFScalar::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     Append(fValue, stream);
 }
 
 // static
 void SkPDFScalar::Append(SkScalar value, SkWStream* stream) {
     // The range of reals in PDF/A is the same as SkFixed: +/- 32,767 and
@@ skipping 36 matching lines @@
         buffer[len - 1] = '\0';
     }
     if (buffer[len - 1] == '.') {
         buffer[len - 1] = '\0';
     }
     stream->writeText(buffer);
     return;
 #endif  // SK_ALLOW_LARGE_PDF_SCALARS
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 SkPDFString::SkPDFString(const char value[])
     : fValue(FormatString(value, strlen(value))) {
 }
 
 SkPDFString::SkPDFString(const SkString& value)
     : fValue(FormatString(value.c_str(), value.size())) {
 }
 
 SkPDFString::SkPDFString(const uint16_t* value, size_t len, bool wideChars)
     : fValue(FormatString(value, len, wideChars)) {
@@ skipping 63 matching lines @@
             SkASSERT(!wideInput || !(win[i] & ~0xFF));
             unsigned char val = wideInput ? win[i] : cin[i];
             result.appendHex(val, 2);
         }
         result.append(">");
     }
 
     return result;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 SkPDFName::SkPDFName(const char name[]) : fValue(FormatName(SkString(name))) {}
 SkPDFName::SkPDFName(const SkString& name) : fValue(FormatName(name)) {}
 SkPDFName::~SkPDFName() {}
 
 bool SkPDFName::operator==(const SkPDFName& b) const {
     return fValue == b.fValue;
 }
 
 void SkPDFName::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     stream->write(fValue.c_str(), fValue.size());
@@ skipping 12 matching lines @@
             // Mask with 0xFF to avoid sign extension. i.e. #FFFFFF81
             result.appendHex(input[i] & 0xFF, 2);
         } else {
             result.append(input.c_str() + i, 1);
         }
     }
 
     return result;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 SkPDFArray::SkPDFArray() {}
 SkPDFArray::~SkPDFArray() {
     fValue.unrefAll();
 }
 
 void SkPDFArray::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     stream->writeText("[");
     for (int i = 0; i < fValue.count(); i++) {
-        fValue[i]->emit(stream, catalog, false);
+        catalog->getSubstituteObject(fValue[i])->emitObject(stream, catalog);
         if (i + 1 < fValue.count()) {
             stream->writeText(" ");
         }
     }
     stream->writeText("]");
 }
 
 void SkPDFArray::reserve(int length) {
     SkASSERT(length <= kMaxLen);
     fValue.setReserve(length);
@@ skipping 39 matching lines @@
 
 SkPDFDict::~SkPDFDict() {
     clear();
 }
 
 int SkPDFDict::size() const {
     SkAutoMutexAcquire lock(fMutex);
     return fValue.count();
 }
 
-
 void SkPDFDict::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     SkAutoMutexAcquire lock(fMutex); // If another thread triggers a
                                      // resize while this thread is in
                                      // the for-loop, we can be left
                                      // with a bad fValue[i] reference.
     stream->writeText("<<");
     for (int i = 0; i < fValue.count(); i++) {
         SkASSERT(fValue[i].key);
         SkASSERT(fValue[i].value);
         fValue[i].key->emitObject(stream, catalog);
         stream->writeText(" ");
-        fValue[i].value->emit(stream, catalog, false);
+        catalog->getSubstituteObject(fValue[i].value)
+                ->emitObject(stream, catalog);
         stream->writeText("\n");
     }
     stream->writeText(">>");
 }
 
 SkPDFObject*  SkPDFDict::append(SkPDFName* key, SkPDFObject* value) {
     SkASSERT(key);
     SkASSERT(value);
     SkAutoMutexAcquire lock(fMutex); // If the SkTDArray resizes while
                                      // two threads access array, one
@@ skipping 52 matching lines @@
 void SkPDFDict::mergeFrom(const SkPDFDict& other) {
     SkAutoMutexAcquire lockOther(other.fMutex);
     SkTDArray<Rec> copy(other.fValue);
     lockOther.release();  // Do not hold both mutexes at once.
 
     SkAutoMutexAcquire lock(fMutex);
     for (int i = 0; i < copy.count(); i++) {
         *(fValue.append()) = Rec(SkRef(copy[i].key), SkRef(copy[i].value));
     }
 }