In SkPDFDocument::emitPDF(), stop pre-calculating file offsets.

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"
@@ skipping 27 matching lines @@
 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");
 }
 
-size_t SkPDFObject::getIndirectOutputSize(SkPDFCatalog* catalog) {
-    return catalog->getObjectNumberSize(this) + strlen(" obj\n") +
-        this->getOutputSize(catalog, false) + strlen("\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) {
@@ skipping 16 matching lines @@
     SkSafeRef(obj);
 }
 
 SkPDFObjRef::~SkPDFObjRef() {}
 
 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) {
     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");
     }
 }
 
-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) {
     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 54 matching lines @@
 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) {
     stream->write(fValue.c_str(), fValue.size());
 }
 
-size_t SkPDFString::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
-    if (indirect)
-        return getIndirectOutputSize(catalog);
-    return fValue.size();
-}
-
 // static
 SkString SkPDFString::FormatString(const char* input, size_t len) {
     return DoFormatString(input, len, false, false);
 }
 
 SkString SkPDFString::FormatString(const uint16_t* input, size_t len,
                                    bool wideChars) {
     return DoFormatString(input, len, true, wideChars);
 }
 
@@ skipping 57 matching lines @@
 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());
 }
 
-size_t SkPDFName::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
-    SkASSERT(!indirect);
-    return fValue.size();
-}
-
 // static
 SkString SkPDFName::FormatName(const SkString& input) {
     SkASSERT(input.size() <= kMaxLen);
     // TODO(vandebo) If more escaping is needed, improve the linear scan.
     static const char escaped[] = "#/%()<>[]{}";
 
     SkString result("/");
     for (size_t i = 0; i < input.size(); i++) {
         if (input[i] & 0x80 || input[i] < '!' || strchr(escaped, input[i])) {
             result.append("#");
@@ skipping 16 matching lines @@
     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("]");
 }
 
-size_t SkPDFArray::getOutputSize(SkPDFCatalog* catalog, bool indirect) {
-    if (indirect) {
-        return getIndirectOutputSize(catalog);
-    }
-
-    size_t result = strlen("[]");
-    if (fValue.count()) {
-        result += fValue.count() - 1;
-    }
-    for (int i = 0; i < fValue.count(); i++) {
-        result += fValue[i]->getOutputSize(catalog, false);
-    }
-    return result;
-}
-
 void SkPDFArray::reserve(int length) {
     SkASSERT(length <= kMaxLen);
     fValue.setReserve(length);
 }
 
 SkPDFObject* SkPDFArray::setAt(int offset, SkPDFObject* value) {
     SkASSERT(offset < fValue.count());
     value->ref();
     fValue[offset]->unref();
     fValue[offset] = value;
@@ skipping 50 matching lines @@
         SkASSERT(fValue[i].key);
         SkASSERT(fValue[i].value);
         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);
-    }
-
-    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.
-    size_t result = strlen("<<>>") + (fValue.count() * 2);
-    for (int i = 0; i < fValue.count(); i++) {
-        SkASSERT(fValue[i].key);
-        SkASSERT(fValue[i].value);
-        result += fValue[i].key->getOutputSize(catalog, false);
-        result += fValue[i].value->getOutputSize(catalog, false);
-    }
-    return result;
-}
-
 SkPDFObject*  SkPDFDict::append(SkPDFName* key, SkPDFObject* value) {
     SkASSERT(key);
     SkASSERT(value);
     SkAutoMutexAcquire lock(fMutex); // If the SkTDArray resizes while
                                      // two threads access array, one
                                      // is left with a bad pointer.
     *(fValue.append()) = Rec(key, value);
     return value;
 }
 
@@ skipping 47 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));
     }
 }