SkPDF: SkPDFDevice has ptr to SkPDFDocument

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"
 #include "SkColor.h"
 #include "SkColorFilter.h"
 #include "SkClipStack.h"
 #include "SkDraw.h"
 #include "SkGlyphCache.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPathEffect.h"
 #include "SkPathOps.h"
 #include "SkPDFBitmap.h"
 #include "SkPDFCanon.h"
+#include "SkPDFDocument.h"
 #include "SkPDFFont.h"
 #include "SkPDFFormXObject.h"
 #include "SkPDFGraphicState.h"
 #include "SkPDFResourceDict.h"
 #include "SkPDFShader.h"
 #include "SkPDFStream.h"
 #include "SkPDFTypes.h"
 #include "SkPDFUtils.h"
 #include "SkRasterClip.h"
 #include "SkRect.h"
@@ skipping 545 matching lines @@
     // TODO: should we return true if there is a colorfilter?
     return layerPaint.getImageFilter() != nullptr;
 }
 
 SkBaseDevice* SkPDFDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint* layerPaint) {
     if (cinfo.fForImageFilter ||
         (layerPaint && not_supported_for_layers(*layerPaint))) {
         return nullptr;
     }
     SkISize size = SkISize::Make(cinfo.fInfo.width(), cinfo.fInfo.height());
-    return SkPDFDevice::Create(size, fRasterDpi, fCanon);
+    return SkPDFDevice::Create(size, fRasterDpi, fDocument);
 }
 
+SkPDFCanon* SkPDFDevice::getCanon() const { return fDocument->canon(); }
+
 
 struct ContentEntry {
     GraphicStateEntry fState;
     SkDynamicMemoryWStream fContent;
     SkAutoTDelete<ContentEntry> fNext;
 
     // If the stack is too deep we could get Stack Overflow.
     // So we manually destruct the object.
     ~ContentEntry() {
         ContentEntry* val = fNext.release();
@@ skipping 93 matching lines @@
             paint.getXfermode()->asMode(&fXfermode);
         }
         fContentEntry = fDevice->setUpContentEntry(clipStack, clipRegion,
                                                    matrix, paint, hasText,
                                                    &fDstFormXObject);
     }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
-SkPDFDevice::SkPDFDevice(SkISize pageSize, SkScalar rasterDpi, SkPDFCanon* canon, bool flip)
+SkPDFDevice::SkPDFDevice(SkISize pageSize, SkScalar rasterDpi, SkPDFDocument* doc, bool flip)
     : INHERITED(SkSurfaceProps(0, kUnknown_SkPixelGeometry))
     , fPageSize(pageSize)
     , fContentSize(pageSize)
     , fExistingClipRegion(SkIRect::MakeSize(pageSize))
     , fLastContentEntry(nullptr)
     , fLastMarginContentEntry(nullptr)
     , fDrawingArea(kContent_DrawingArea)
     , fClipStack(nullptr)
     , fFontGlyphUsage(new SkPDFGlyphSetMap)
     , fRasterDpi(rasterDpi)
-    , fCanon(canon) {
+    , 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));
@@ skipping 325 matching lines @@
     if (bitmap.isOpaque()) {
         replace_srcmode_on_opaque_paint(&paint);
     }
 
     if (d.fClip->isEmpty()) {
         return;
     }
 
     SkMatrix transform = matrix;
     transform.postConcat(*d.fMatrix);
-    const SkImage* image = fCanon->bitmapToImage(bitmap);
+    const SkImage* image = fDocument->canon()->bitmapToImage(bitmap);
     if (!image) {
         return;
     }
     this->internalDrawImage(transform, d.fClipStack, *d.fClip, image, nullptr,
                             paint);
 }
 
 void SkPDFDevice::drawSprite(const SkDraw& d,
                              const SkBitmap& bitmap,
                              int x,
                              int y,
                              const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     if (bitmap.isOpaque()) {
         replace_srcmode_on_opaque_paint(&paint);
     }
 
     if (d.fClip->isEmpty()) {
         return;
     }
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
-    const SkImage* image = fCanon->bitmapToImage(bitmap);
+    const SkImage* image = fDocument->canon()->bitmapToImage(bitmap);
     if (!image) {
         return;
     }
     this->internalDrawImage(matrix, d.fClipStack, *d.fClip, image, nullptr,
                             paint);
 }
 
 void SkPDFDevice::drawImage(const SkDraw& draw,
                             const SkImage* image,
                             SkScalar x,
@@ skipping 94 matching lines @@
             device->drawText(d, text, len, x, y, transparent);
             break;
         default:
             SkFAIL("unknown text encoding");
     }
 }
 
 
 void SkPDFDevice::drawText(const SkDraw& d, const void* text, size_t len,
                            SkScalar x, SkScalar y, const SkPaint& srcPaint) {
-    if (!SkPDFFont::CanEmbedTypeface(srcPaint.getTypeface(), fCanon)) {
+    if (!SkPDFFont::CanEmbedTypeface(srcPaint.getTypeface(), fDocument->canon())) {
         // https://bug.skia.org/3866
         SkPath path;
         srcPaint.getTextPath(text, len, x, y, &path);
         this->drawPath(d, path, srcPaint, &SkMatrix::I(), true);
         // Draw text transparently to make it copyable/searchable/accessable.
         draw_transparent_text(this, d, text, len, x, y, srcPaint);
         return;
     }
     SkPaint paint = srcPaint;
     replace_srcmode_on_opaque_paint(&paint);
@@ skipping 40 matching lines @@
         content.entry()->fContent.writeText(encodedString.c_str());
         consumedGlyphCount += availableGlyphs;
         content.entry()->fContent.writeText(" Tj\n");
     }
     content.entry()->fContent.writeText("ET\n");
 }
 
 void SkPDFDevice::drawPosText(const SkDraw& d, const void* text, size_t len,
                               const SkScalar pos[], int scalarsPerPos,
                               const SkPoint& offset, const SkPaint& srcPaint) {
-    if (!SkPDFFont::CanEmbedTypeface(srcPaint.getTypeface(), fCanon)) {
+    if (!SkPDFFont::CanEmbedTypeface(srcPaint.getTypeface(), fDocument->canon())) {
         const SkPoint* positions = reinterpret_cast<const SkPoint*>(pos);
         SkAutoTMalloc<SkPoint> positionsBuffer;
         if (2 != scalarsPerPos) {
             int glyphCount = srcPaint.textToGlyphs(text, len, NULL);
             positionsBuffer.reset(glyphCount);
             for (int  i = 0; i < glyphCount; ++i) {
                 positionsBuffer[i].set(pos[i], 0.0f);
             }
             positions = &positionsBuffer[0];
         }
@@ skipping 402 matching lines @@
                                           SkPDFFormXObject* mask,
                                           const SkClipStack* clipStack,
                                           const SkRegion& clipRegion,
                                           SkXfermode::Mode mode,
                                           bool invertClip) {
     if (clipRegion.isEmpty() && !invertClip) {
         return;
     }
 
     auto sMaskGS = SkPDFGraphicState::GetSMaskGraphicState(
-            mask, invertClip, SkPDFGraphicState::kAlpha_SMaskMode, fCanon);
+            mask, invertClip, SkPDFGraphicState::kAlpha_SMaskMode, fDocument->canon());
 
     SkMatrix identity;
     identity.reset();
     SkPaint paint;
     paint.setXfermodeMode(mode);
     ScopedContentEntry content(this, clipStack, clipRegion, identity, paint);
     if (!content.entry()) {
         return;
     }
     SkPDFUtils::ApplyGraphicState(addGraphicStateResource(sMaskGS.get()),
                                   &content.entry()->fContent);
     SkPDFUtils::DrawFormXObject(xObjectIndex, &content.entry()->fContent);
 
     // Call makeNoSmaskGraphicState() instead of
     // SkPDFGraphicState::MakeNoSmaskGraphicState so that the canon
     // can deduplicate.
-    sMaskGS = fCanon->makeNoSmaskGraphicState();
+    sMaskGS = fDocument->canon()->makeNoSmaskGraphicState();
     SkPDFUtils::ApplyGraphicState(addGraphicStateResource(sMaskGS.get()),
                                   &content.entry()->fContent);
 }
 
 ContentEntry* SkPDFDevice::setUpContentEntry(const SkClipStack* clipStack,
                                              const SkRegion& clipRegion,
                                              const SkMatrix& matrix,
                                              const SkPaint& paint,
                                              bool hasText,
                                              SkPDFFormXObject** dst) {
@@ skipping 286 matching lines @@
         // We need to apply the initial transform to bounds in order to get
         // bounds in a consistent coordinate system.
         SkRect boundsTemp;
         boundsTemp.set(bounds);
         fInitialTransform.mapRect(&boundsTemp);
         boundsTemp.roundOut(&bounds);
 
         SkScalar rasterScale =
                 SkIntToScalar(fRasterDpi) / DPI_FOR_RASTER_SCALE_ONE;
         pdfShader.reset(SkPDFShader::GetPDFShader(
-                fCanon, fRasterDpi, *shader, transform, bounds, rasterScale));
+                fDocument, fRasterDpi, *shader, transform, bounds, rasterScale));
 
         if (pdfShader.get()) {
             // pdfShader has been canonicalized so we can directly compare
             // pointers.
             int resourceIndex = fShaderResources.find(pdfShader.get());
             if (resourceIndex < 0) {
                 resourceIndex = fShaderResources.count();
                 fShaderResources.push(pdfShader.get());
                 pdfShader.get()->ref();
             }
@@ skipping 10 matching lines @@
                     SkShader::kColor_GradientType) {
                 entry->fColor = SkColorSetA(gradientColor, 0xFF);
                 color = gradientColor;
             }
         }
     }
 
     sk_sp<SkPDFGraphicState> newGraphicState;
     if (color == paint.getColor()) {
         newGraphicState.reset(
-                SkPDFGraphicState::GetGraphicStateForPaint(fCanon, paint));
+                SkPDFGraphicState::GetGraphicStateForPaint(fDocument->canon(), paint));
     } else {
         SkPaint newPaint = paint;
         newPaint.setColor(color);
         newGraphicState.reset(
-                SkPDFGraphicState::GetGraphicStateForPaint(fCanon, newPaint));
+                SkPDFGraphicState::GetGraphicStateForPaint(fDocument->canon(), newPaint));
     }
     int resourceIndex = addGraphicStateResource(newGraphicState.get());
     entry->fGraphicStateIndex = resourceIndex;
 
     if (hasText) {
         entry->fTextScaleX = paint.getTextScaleX();
         entry->fTextFill = paint.getStyle();
     } else {
         entry->fTextScaleX = 0;
     }
@@ skipping 36 matching lines @@
                 fontIndex).c_str());
         contentEntry->fContent.writeText(" ");
         SkPDFUtils::AppendScalar(paint.getTextSize(), &contentEntry->fContent);
         contentEntry->fContent.writeText(" Tf\n");
         contentEntry->fState.fFont = fFontResources[fontIndex];
     }
 }
 
 int SkPDFDevice::getFontResourceIndex(SkTypeface* typeface, uint16_t glyphID) {
     sk_sp<SkPDFFont> newFont(
-            SkPDFFont::GetFontResource(fCanon, typeface, glyphID));
+            SkPDFFont::GetFontResource(fDocument->canon(), typeface, glyphID));
     int resourceIndex = fFontResources.find(newFont.get());
     if (resourceIndex < 0) {
         resourceIndex = fFontResources.count();
         fFontResources.push(newFont.get());
         newFont.get()->ref();
     }
     return resourceIndex;
 }
 
 static SkSize rect_to_size(const SkRect& r) {
@@ skipping 143 matching lines @@
         // TODO(https://bug.skia.org/4378): implement colorfilter on other
         // draw calls.  This code here works for all
         // drawBitmap*()/drawImage*() calls amd ImageFilters (which
         // rasterize a layer on this backend).  Fortuanely, this seems
         // to be how Chromium impements most color-filters.
         autoImageUnref.reset(color_filter(image, colorFilter));
         image = autoImageUnref.get();
         // TODO(halcanary): de-dupe this by caching filtered images.
         // (maybe in the resource cache?)
     }
-    sk_sp<SkPDFObject> pdfimage(SkSafeRef(fCanon->findPDFBitmap(image)));
+    sk_sp<SkPDFObject> pdfimage(SkSafeRef(fDocument->canon()->findPDFBitmap(image)));
     if (!pdfimage) {
         pdfimage.reset(SkPDFCreateBitmapObject(
-                               image, fCanon->getPixelSerializer()));
+                               image, fDocument->canon()->getPixelSerializer()));
         if (!pdfimage) {
             return;
         }
-        fCanon->addPDFBitmap(image->uniqueID(), pdfimage.get());
+        #if SK_PDF_SERIALIZE_IMAGES_EARLY // TODO(halcanary): enable.
+        sk_sp<SkData> encodedImage(image->refEncodedData());
+        if (!encodedImage) {
+            fDocument->serialize(pdfimage);
+        }
+        #endif
+        fDocument->canon()->addPDFBitmap(image->uniqueID(), pdfimage.get());
     }
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(pdfimage.get()),
                                 &content.entry()->fContent);
 }