SkPDF: remove margin foolishness

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 689 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))
     , fLastContentEntry(nullptr)
-    , fLastMarginContentEntry(nullptr)
-    , fDrawingArea(kContent_DrawingArea)
     , 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);
 }
 
 void SkPDFDevice::init() {
     fContentEntries.reset();
     fLastContentEntry = nullptr;
-    fMarginContentEntries.reset();
-    fLastMarginContentEntry = nullptr;
-    fDrawingArea = kContent_DrawingArea;
     if (fFontGlyphUsage.get() == nullptr) {
         fFontGlyphUsage.reset(new SkPDFGlyphSetMap);
     }
 }
 
 void SkPDFDevice::cleanUp(bool clearFontUsage) {
     fGraphicStateResources.unrefAll();
     fXObjectResources.unrefAll();
     fFontResources.unrefAll();
     fShaderResources.unrefAll();
@@ skipping 650 matching lines @@
 void SkPDFDevice::onDetachFromCanvas() {
     INHERITED::onDetachFromCanvas();
 
     fClipStack = nullptr;
 }
 
 sk_sp<SkSurface> SkPDFDevice::makeSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
     return SkSurface::MakeRaster(info, &props);
 }
 
-ContentEntry* SkPDFDevice::getLastContentEntry() {
-    if (fDrawingArea == kContent_DrawingArea) {
-        return fLastContentEntry;
-    } else {
-        return fLastMarginContentEntry;
-    }
-}
-
-SkAutoTDelete<ContentEntry>* SkPDFDevice::getContentEntries() {
-    if (fDrawingArea == kContent_DrawingArea) {
-        return &fContentEntries;
-    } else {
-        return &fMarginContentEntries;
-    }
-}
-
-void SkPDFDevice::setLastContentEntry(ContentEntry* contentEntry) {
-    if (fDrawingArea == kContent_DrawingArea) {
-        fLastContentEntry = contentEntry;
-    } else {
-        fLastMarginContentEntry = contentEntry;
-    }
-}
-
-void SkPDFDevice::setDrawingArea(DrawingArea drawingArea) {
-    // A ScopedContentEntry only exists during the course of a draw call, so
-    // this can't be called while a ScopedContentEntry exists.
-    fDrawingArea = drawingArea;
-}
 
 sk_sp<SkPDFDict> SkPDFDevice::makeResourceDict() const {
     SkTDArray<SkPDFObject*> fonts;
     fonts.setReserve(fFontResources.count());
     for (SkPDFFont* font : fFontResources) {
         fonts.push(font);
     }
     return SkPDFResourceDict::Make(
             &fGraphicStateResources,
             &fShaderResources,
@@ skipping 42 matching lines @@
         entry = entry->fNext.get();
     }
     gsState.drainStack();
 }
 
 void SkPDFDevice::writeContent(SkWStream* out) const {
     if (fInitialTransform.getType() != SkMatrix::kIdentity_Mask) {
         SkPDFUtils::AppendTransform(fInitialTransform, out);
     }
 
-    // TODO(aayushkumar): Apply clip along the margins.  Currently, webkit
-    // colors the contentArea white before it starts drawing into it and
-    // that currently acts as our clip.
-    // Also, think about adding a transform here (or assume that the values
-    // sent across account for that)
-    SkPDFDevice::copyContentEntriesToData(fMarginContentEntries.get(), out);
-
     // If the content area is the entire page, then we don't need to clip
     // the content area (PDF area clips to the page size).  Otherwise,
     // we have to clip to the content area; we've already applied the
     // initial transform, so just clip to the device size.
     if (fPageSize != fContentSize) {
         SkRect r = SkRect::MakeWH(SkIntToScalar(this->width()),
                                   SkIntToScalar(this->height()));
         emit_clip(nullptr, &r, out);
     }
 
@@ skipping 237 matching lines @@
     // Xor, Plus.
 
     // Dst xfer mode doesn't draw source at all.
     if (xfermode == SkXfermode::kDst_Mode) {
         return nullptr;
     }
 
     ContentEntry* entry;
     SkAutoTDelete<ContentEntry> newEntry;
 
-    ContentEntry* lastContentEntry = getLastContentEntry();
-    if (lastContentEntry && lastContentEntry->fContent.getOffset() == 0) {
-        entry = lastContentEntry;
+    if (fLastContentEntry && fLastContentEntry->fContent.getOffset() == 0) {
+        entry = fLastContentEntry;
     } else {
         newEntry.reset(new ContentEntry);
         entry = newEntry.get();
     }
 
     populateGraphicStateEntryFromPaint(matrix, *clipStack, clipRegion, paint,
                                        hasText, &entry->fState);
-    if (lastContentEntry && xfermode != SkXfermode::kDstOver_Mode &&
-            entry->fState.compareInitialState(lastContentEntry->fState)) {
-        return lastContentEntry;
+    if (fLastContentEntry && xfermode != SkXfermode::kDstOver_Mode &&
+            entry->fState.compareInitialState(fLastContentEntry->fState)) {
+        return fLastContentEntry;
     }
 
-    SkAutoTDelete<ContentEntry>* contentEntries = getContentEntries();
-    if (!lastContentEntry) {
-        contentEntries->reset(entry);
-        setLastContentEntry(entry);
+    if (!fLastContentEntry) {
+        fContentEntries.reset(entry);
+        fLastContentEntry = entry;
     } else if (xfermode == SkXfermode::kDstOver_Mode) {
-        entry->fNext.reset(contentEntries->release());
-        contentEntries->reset(entry);
+        entry->fNext.reset(fContentEntries.release());
+        fContentEntries.reset(entry);
     } else {
-        lastContentEntry->fNext.reset(entry);
-        setLastContentEntry(entry);
+        fLastContentEntry->fNext.reset(entry);
+        fLastContentEntry = entry;
     }
     newEntry.release();
     return entry;
 }
 
 void SkPDFDevice::finishContentEntry(SkXfermode::Mode xfermode,
                                      SkPDFFormXObject* dst,
                                      SkPath* shape) {
     if (xfermode != SkXfermode::kClear_Mode       &&
             xfermode != SkXfermode::kSrc_Mode     &&
             xfermode != SkXfermode::kDstOver_Mode &&
             xfermode != SkXfermode::kSrcIn_Mode   &&
             xfermode != SkXfermode::kDstIn_Mode   &&
             xfermode != SkXfermode::kSrcOut_Mode  &&
             xfermode != SkXfermode::kDstOut_Mode  &&
             xfermode != SkXfermode::kSrcATop_Mode &&
             xfermode != SkXfermode::kDstATop_Mode &&
             xfermode != SkXfermode::kModulate_Mode) {
         SkASSERT(!dst);
         return;
     }
     if (xfermode == SkXfermode::kDstOver_Mode) {
         SkASSERT(!dst);
-        ContentEntry* firstContentEntry = getContentEntries()->get();
-        if (firstContentEntry->fContent.getOffset() == 0) {
+        if (fContentEntries->fContent.getOffset() == 0) {
             // For DstOver, an empty content entry was inserted before the rest
             // of the content entries. If nothing was drawn, it needs to be
             // removed.
-            SkAutoTDelete<ContentEntry>* contentEntries = getContentEntries();
-            contentEntries->reset(firstContentEntry->fNext.release());
+            fContentEntries.reset(fContentEntries->fNext.release());
         }
         return;
     }
     if (!dst) {
         SkASSERT(xfermode == SkXfermode::kSrc_Mode ||
                  xfermode == SkXfermode::kSrcOut_Mode);
         return;
     }
 
-    ContentEntry* contentEntries = getContentEntries()->get();
     SkASSERT(dst);
-    SkASSERT(!contentEntries->fNext.get());
+    SkASSERT(!fContentEntries->fNext.get());
     // Changing the current content into a form-xobject will destroy the clip
     // objects which is fine since the xobject will already be clipped. However
     // if source has shape, we need to clip it too, so a copy of the clip is
     // saved.
-    SkClipStack clipStack = contentEntries->fState.fClipStack;
-    SkRegion clipRegion = contentEntries->fState.fClipRegion;
+    SkClipStack clipStack = fContentEntries->fState.fClipStack;
+    SkRegion clipRegion = fContentEntries->fState.fClipRegion;
 
     SkMatrix identity;
     identity.reset();
     SkPaint stockPaint;
 
     sk_sp<SkPDFFormXObject> srcFormXObject;
     if (isContentEmpty()) {
         // If nothing was drawn and there's no shape, then the draw was a
         // no-op, but dst needs to be restored for that to be true.
         // If there is shape, then an empty source with Src, SrcIn, SrcOut,
@@ skipping 94 matching lines @@
                                     SkXfermode::kSrcOver_Mode, false);
             mode = SkXfermode::kMultiply_Mode;
         }
         drawFormXObjectWithMask(addXObjectResource(dst), srcFormXObject.get(),
                                 &fExistingClipStack, fExistingClipRegion, mode,
                                 xfermode == SkXfermode::kDstOut_Mode);
     }
 }
 
 bool SkPDFDevice::isContentEmpty() {
-    ContentEntry* contentEntries = getContentEntries()->get();
-    if (!contentEntries || contentEntries->fContent.getOffset() == 0) {
-        SkASSERT(!contentEntries || !contentEntries->fNext.get());
+    if (!fContentEntries || fContentEntries->fContent.getOffset() == 0) {
+        SkASSERT(!fContentEntries || !fContentEntries->fNext.get());
         return true;
     }
     return false;
 }
 
 void SkPDFDevice::populateGraphicStateEntryFromPaint(
         const SkMatrix& matrix,
         const SkClipStack& clipStack,
         const SkRegion& clipRegion,
         const SkPaint& paint,
@@ skipping 293 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);
 }