SkPDF: Glyph Useage Map improvements

src/pdf/SkPDFDevice.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 "SkPDFDevice.h"
 
 #include "SkAnnotationKeys.h"
@@ skipping 637 matching lines @@
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 SkPDFDevice::SkPDFDevice(SkISize pageSize, SkScalar rasterDpi, SkPDFDocument* doc, bool flip)
     : INHERITED(SkSurfaceProps(0, kUnknown_SkPixelGeometry))
     , fPageSize(pageSize)
     , fContentSize(pageSize)
     , fExistingClipRegion(SkIRect::MakeSize(pageSize))
     , fClipStack(nullptr)
-    , fFontGlyphUsage(new SkPDFGlyphSetMap)
     , fRasterDpi(rasterDpi)
     , fDocument(doc) {
     SkASSERT(pageSize.width() > 0);
     SkASSERT(pageSize.height() > 0);
     fLegacyBitmap.setInfo(
             SkImageInfo::MakeUnknown(pageSize.width(), pageSize.height()));
     if (flip) {
         // Skia generally uses the top left as the origin but PDF
         // natively has the origin at the bottom left. This matrix
         // corrects for that.  But that only needs to be done once, we
         // don't do it when layering.
         fInitialTransform.setTranslate(0, SkIntToScalar(pageSize.fHeight));
         fInitialTransform.preScale(SK_Scalar1, -SK_Scalar1);
     } else {
         fInitialTransform.setIdentity();
     }
 }
 
 SkPDFDevice::~SkPDFDevice() {
-    this->cleanUp(true);
+    this->cleanUp();
 }
 
 void SkPDFDevice::init() {
     fContentEntries.reset();
-    if (fFontGlyphUsage.get() == nullptr) {
-        fFontGlyphUsage.reset(new SkPDFGlyphSetMap);
-    }
 }
 
-void SkPDFDevice::cleanUp(bool clearFontUsage) {
+void SkPDFDevice::cleanUp() {
     fGraphicStateResources.unrefAll();
     fXObjectResources.unrefAll();
     fFontResources.unrefAll();
     fShaderResources.unrefAll();
-
-    if (clearFontUsage) {
-        fFontGlyphUsage->reset();
-    }
 }
 
 void SkPDFDevice::drawAnnotation(const SkDraw& d, const SkRect& rect, const char key[],
                                  SkData* value) {
     if (0 == rect.width() && 0 == rect.height()) {
         handlePointAnnotation({ rect.x(), rect.y() }, *d.fMatrix, key, value);
     } else {
         SkPath path;
         path.addRect(rect);
         handlePathAnnotation(path, d, key, value);
@@ skipping 460 matching lines @@
 
     SkPaint::GlyphCacheProc glyphCacheProc = textPaint.getGlyphCacheProc(true);
     align_text(glyphCacheProc, textPaint, glyphIDs, numGlyphs, &x, &y);
     content.entry()->fContent.writeText("BT\n");
     set_text_transform(x, y, textPaint.getTextSkewX(),
                        &content.entry()->fContent);
     int consumedGlyphCount = 0;
 
     SkTDArray<uint16_t> glyphIDsCopy(glyphIDs, numGlyphs);
 
+    SkPDFGlyphSetMap* fontGlyphUsage = fDocument->getGlyphUsage();
+
     while (numGlyphs > consumedGlyphCount) {
         this->updateFont(textPaint, glyphIDs[consumedGlyphCount], content.entry());
         SkPDFFont* font = content.entry()->fState.fFont;
 
         int availableGlyphs = font->glyphsToPDFFontEncoding(
                 glyphIDsCopy.begin() + consumedGlyphCount,
                 numGlyphs - consumedGlyphCount);
-        fFontGlyphUsage->noteGlyphUsage(
+        fontGlyphUsage->noteGlyphUsage(
                 font,  glyphIDsCopy.begin() + consumedGlyphCount,
                 availableGlyphs);
         write_wide_string(&content.entry()->fContent,
                           glyphIDsCopy.begin() + consumedGlyphCount,
                           availableGlyphs, font->multiByteGlyphs());
         consumedGlyphCount += availableGlyphs;
         content.entry()->fContent.writeText(" Tj\n");
     }
     content.entry()->fContent.writeText("ET\n");
 }
@@ skipping 41 matching lines @@
     }
 
     SkGlyphStorage storage(0);
     const uint16_t* glyphIDs = nullptr;
     size_t numGlyphs = force_glyph_encoding(paint, text, len, &storage, &glyphIDs);
     textPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
 
     SkPaint::GlyphCacheProc glyphCacheProc = textPaint.getGlyphCacheProc(true);
     content.entry()->fContent.writeText("BT\n");
     this->updateFont(textPaint, glyphIDs[0], content.entry());
+    SkPDFGlyphSetMap* fontGlyphUsage = fDocument->getGlyphUsage();
     for (size_t i = 0; i < numGlyphs; i++) {
         SkPDFFont* font = content.entry()->fState.fFont;
         uint16_t encodedValue = glyphIDs[i];
         if (font->glyphsToPDFFontEncoding(&encodedValue, 1) != 1) {
             // The current pdf font cannot encode the current glyph.
             // Try to get a pdf font which can encode the current glyph.
             this->updateFont(textPaint, glyphIDs[i], content.entry());
             font = content.entry()->fState.fFont;
             if (font->glyphsToPDFFontEncoding(&encodedValue, 1) != 1) {
                 SkDEBUGFAIL("PDF could not encode glyph.");
                 continue;
             }
         }
 
-        fFontGlyphUsage->noteGlyphUsage(font, &encodedValue, 1);
+        fontGlyphUsage->noteGlyphUsage(font, &encodedValue, 1);
         SkScalar x = offset.x() + pos[i * scalarsPerPos];
         SkScalar y = offset.y() + (2 == scalarsPerPos ? pos[i * scalarsPerPos + 1] : 0);
 
         align_text(glyphCacheProc, textPaint, glyphIDs + i, 1, &x, &y);
         set_text_transform(x, y, textPaint.getTextSkewX(), &content.entry()->fContent);
         write_wide_string(&content.entry()->fContent, &encodedValue, 1,
                           font->multiByteGlyphs());
         content.entry()->fContent.writeText(" Tj\n");
     }
     content.entry()->fContent.writeText("ET\n");
@@ skipping 47 matching lines @@
                                        SkIntToScalar(device->height())));
         content.setShape(shape);
     }
     if (!content.needSource()) {
         return;
     }
 
     auto xObject = sk_make_sp<SkPDFFormXObject>(pdfDevice);
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(xObject.get()),
                                 &content.entry()->fContent);
-
-    // Merge glyph sets from the drawn device.
-    fFontGlyphUsage->merge(pdfDevice->getFontGlyphUsage());
 }
 
 SkImageInfo SkPDFDevice::imageInfo() const {
     return fLegacyBitmap.info();
 }
 
 void SkPDFDevice::onAttachToCanvas(SkCanvas* canvas) {
     INHERITED::onAttachToCanvas(canvas);
 
     // Canvas promises that this ptr is valid until onDetachFromCanvas is called
@@ skipping 210 matching lines @@
         SkString name(static_cast<const char*>(dest.nameData->data()));
         dict->insertObject(name, std::move(pdfDest));
     }
 }
 
 SkPDFFormXObject* SkPDFDevice::createFormXObjectFromDevice() {
     SkPDFFormXObject* xobject = new SkPDFFormXObject(this);
     // We always draw the form xobjects that we create back into the device, so
     // we simply preserve the font usage instead of pulling it out and merging
     // it back in later.
-    cleanUp(false);  // Reset this device to have no content.
+    cleanUp();  // Reset this device to have no content.
     init();
     return xobject;
 }
 
 void SkPDFDevice::drawFormXObjectWithMask(int xObjectIndex,
                                           SkPDFFormXObject* mask,
                                           const SkClipStack* clipStack,
                                           const SkRegion& clipRegion,
                                           SkXfermode::Mode mode,
                                           bool invertClip) {
@@ skipping 564 matching lines @@
         if (!pdfimage) {
             return;
         }
         fDocument->serialize(pdfimage);  // serialize images early.
         fDocument->canon()->addPDFBitmap(key, pdfimage);
     }
     // TODO(halcanary): addXObjectResource() should take a sk_sp<SkPDFObject>
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(pdfimage.get()),
                                 &content.entry()->fContent);
 }