Change function signature of SkPDFObject::emitObject.

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);
-    return realObject->emitObject(stream, catalog, indirect);
+    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) {}
@@ skipping 34 matching lines @@
         }
     }
 }
 
 SkPDFObjRef::SkPDFObjRef(SkPDFObject* obj) : fObj(obj) {
     SkSafeRef(obj);
 }
 
 SkPDFObjRef::~SkPDFObjRef() {}
 
-void SkPDFObjRef::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
-                             bool indirect) {
-    SkASSERT(!indirect);
+void SkPDFObjRef::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     catalog->emitObjectNumber(stream, fObj.get());
     stream->writeText(" R");
 }
 
 size_t SkPDFObjRef::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
     SkASSERT(!indirect);
     return catalog->getObjectNumberSize(fObj.get()) + strlen(" R");
 }
 
 SkPDFInt::SkPDFInt(int32_t value) : fValue(value) {}
 SkPDFInt::~SkPDFInt() {}
 
-void SkPDFInt::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
-                          bool indirect) {
-    if (indirect) {
-        return emitIndirectObject(stream, catalog);
-    }
+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,
-                          bool indirect) {
-    SkASSERT(!indirect);
+void SkPDFBool::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     if (fValue) {
         stream->writeText("true");
     } else {
         stream->writeText("false");
     }
 }
 
 size_t SkPDFBool::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
     SkASSERT(!indirect);
     if (fValue) {
         return strlen("true");
     }
     return strlen("false");
 }
 
 SkPDFScalar::SkPDFScalar(SkScalar value) : fValue(value) {}
 SkPDFScalar::~SkPDFScalar() {}
 
-void SkPDFScalar::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
-                             bool indirect) {
-    if (indirect) {
-        return emitIndirectObject(stream, catalog);
-    }
-
+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
     // +/- 1/65,536 (though integers can range from 2^31 - 1 to -2^31).
     // When using floats that are outside the whole value range, we can use
     // integers instead.
 
@@ skipping 46 matching lines @@
 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)) {
 }
 
 SkPDFString::~SkPDFString() {}
 
-void SkPDFString::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
-                             bool indirect) {
-    if (indirect)
-        return emitIndirectObject(stream, catalog);
+void SkPDFString::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     stream->write(fValue.c_str(), fValue.size());
 }
 
 size_t SkPDFString::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
     if (indirect)
         return getIndirectOutputSize(catalog);
     return fValue.size();
 }
 
 // static
@@ skipping 62 matching lines @@
 }
 
 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,
-                           bool indirect) {
-    SkASSERT(!indirect);
+void SkPDFName::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     stream->write(fValue.c_str(), fValue.size());
 }
 
 size_t SkPDFName::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
     SkASSERT(!indirect);
     return fValue.size();
 }
 
 // static
 SkString SkPDFName::FormatName(const SkString& input) {
@@ skipping 13 matching lines @@
     }
 
     return result;
 }
 
 SkPDFArray::SkPDFArray() {}
 SkPDFArray::~SkPDFArray() {
     fValue.unrefAll();
 }
 
-void SkPDFArray::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
-                            bool indirect) {
-    if (indirect) {
-        return emitIndirectObject(stream, catalog);
-    }
-
+void SkPDFArray::emitObject(SkWStream* stream, SkPDFCatalog* catalog) {
     stream->writeText("[");
     for (int i = 0; i < fValue.count(); i++) {
         fValue[i]->emit(stream, catalog, false);
         if (i + 1 < fValue.count()) {
             stream->writeText(" ");
         }
     }
     stream->writeText("]");
 }
 
@@ skipping 58 matching lines @@
 SkPDFDict::~SkPDFDict() {
     clear();
 }
 
 int SkPDFDict::size() const {
     SkAutoMutexAcquire lock(fMutex);
     return fValue.count();
 }
 
 
-void SkPDFDict::emitObject(SkWStream* stream, SkPDFCatalog* catalog,
-                           bool indirect) {
-    if (indirect) {
-        return emitIndirectObject(stream, catalog);
-    }
-
+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, false);
+        fValue[i].key->emitObject(stream, catalog);
         stream->writeText(" ");
         fValue[i].value->emit(stream, catalog, false);
         stream->writeText("\n");
     }
     stream->writeText(">>");
 }
 
 size_t SkPDFDict::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
     if (indirect) {
         return getIndirectOutputSize(catalog);
@@ skipping 73 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));
     }
 }