PDF: Now threadsafe!

src/pdf/SkPDFDevice.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkPDFDevice_DEFINED
 #define SkPDFDevice_DEFINED
 
 #include "SkDevice.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPicture.h"
 #include "SkRect.h"
 #include "SkRefCnt.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
 #include "SkTemplates.h"
 
 class SkPDFArray;
+class SkPDFCanon;
 class SkPDFDevice;
 class SkPDFDict;
 class SkPDFFont;
 class SkPDFFormXObject;
 class SkPDFGlyphSetMap;
 class SkPDFGraphicState;
 class SkPDFObject;
 class SkPDFResourceDict;
 class SkPDFShader;
 class SkPDFStream;
 class SkRRect;
 template <typename T> class SkTSet;
 
 // Private classes.
 struct ContentEntry;
 struct GraphicStateEntry;
 struct NamedDestination;
 
 /** \class SkPDFDevice
 
     The drawing context for the PDF backend.
 */
 class SkPDFDevice : public SkBaseDevice {
 public:
-    /** Create a PDF drawing context with the given width and height.
-     *  72 points/in means letter paper is 612x792.
-     *  @param pageSize Page size in points.
-     *  @param contentSize The content size of the page in points. This will be
-     *         combined with the initial transform to determine the drawing area
-     *         (as reported by the width and height methods). Anything outside
-     *         of the drawing area will be clipped.
-     *  @param initialTransform The initial transform to apply to the page.
-     *         This may be useful to, for example, move the origin in and
-     *         over a bit to account for a margin, scale the canvas,
-     *         or apply a rotation.  Note1: the SkPDFDevice also applies
-     *         a scale+translate transform to move the origin from the
-     *         bottom left (PDF default) to the top left.  Note2: drawDevice
-     *         (used by layer restore) draws the device after this initial
-     *         transform is applied, so the PDF device does an
-     *         inverse scale+translate to accommodate the one that SkPDFDevice
-     *         always does.
+    /** Create a PDF drawing context.  SkPDFDevice applies a
+     *  scale-and-translate transform to move the origin from the
+     *  bottom left (PDF default) to the top left (Skia default).
+     *  @param pageSize Page size in point units.
+     *         1 point == 127/360 mm == 1/72 inch
+     *  @param rasterDpi the DPI at which features without native PDF
+     *         support will be rasterized (e.g. draw image with
+     *         perspective, draw text with perspective, ...).  A
+     *         larger DPI would create a PDF that reflects the
+     *         original intent with better fidelity, but it can make
+     *         for larger PDF files too, which would use more memory
+     *         while rendering, and it would be slower to be processed
+     *         or sent online or to printer.  A good choice is
+     *         SK_ScalarDefaultRasterDPI(72.0f).
+     *  @param SkPDFCanon.  Should be non-null, and shared by all
+     *         devices in a document.
      */
-    // Deprecated, please use SkDocument::CreatePdf() instead.
-    SK_API SkPDFDevice(const SkISize& pageSize, const SkISize& contentSize,
-                       const SkMatrix& initialTransform);
-    SK_API virtual ~SkPDFDevice();
+    static SkPDFDevice* Create(SkISize pageSize,
+                               SkScalar rasterDpi,
+                               SkPDFCanon* canon) {
+        return SkNEW_ARGS(SkPDFDevice, (pageSize, rasterDpi, canon, true));
+    }
+
+    /** Create a PDF drawing context without fipping the y-axis. */
+    static SkPDFDevice* CreateUnflipped(SkISize pageSize,

[mtklein, 2015/02/19 23:50:38]

This seems like 3 CLs:

1)
The PDF canvas is now just as threadsafe as any other Skia canvas.

DM updated to thread PDF tests.

SkDocument_PDF now owns SkPDFCanon, and pointers to that canon are
passed around to all classes that need access to the canon.

2)
SkPDFDevice now has factory function that matches what cllers need.

3)
SkPDFDeviceFlattener is removed.  There are no clients.

[hal.canary, 2015/02/20 01:22:28]

Will do.

+                                        SkScalar rasterDpi,
+                                        SkPDFCanon* canon) {
+        return SkNEW_ARGS(SkPDFDevice, (pageSize, rasterDpi, canon, false));
+    }
+
+    virtual ~SkPDFDevice();
 
     /** These are called inside the per-device-layer loop for each draw call.
      When these are called, we have already applied any saveLayer operations,
      and are handling any looping from the paint, and any effects from the
      DrawFilter.
      */
     void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
     void drawPoints(const SkDraw&, SkCanvas::PointMode mode,
                     size_t count, const SkPoint[],
                     const SkPaint& paint) SK_OVERRIDE;
@@ skipping 99 matching lines @@
         return fInitialTransform;
     }
 
     /** Returns a SkPDFGlyphSetMap which represents glyph usage of every font
      *  that shows on this device.
      */
     const SkPDFGlyphSetMap& getFontGlyphUsage() const {
         return *(fFontGlyphUsage.get());
     }
 
-
-    /**
-     *  rasterDpi - the DPI at which features without native PDF support
-     *              will be rasterized (e.g. draw image with perspective,
-     *              draw text with perspective, ...)
-     *              A larger DPI would create a PDF that reflects the original
-     *              intent with better fidelity, but it can make for larger
-     *              PDF files too, which would use more memory while rendering,
-     *              and it would be slower to be processed or sent online or
-     *              to printer.
-     */
-    void setRasterDpi(SkScalar rasterDpi) {
-        fRasterDpi = rasterDpi;
-    }
-
 protected:
     const SkBitmap& onAccessBitmap() SK_OVERRIDE {
         return fLegacyBitmap;
     }
 
     SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) SK_OVERRIDE;
 
 private:
     // TODO(vandebo): push most of SkPDFDevice's state into a core object in
     // order to get the right access levels without using friend.
@@ skipping 16 matching lines @@
     SkAutoTDelete<ContentEntry> fContentEntries;
     ContentEntry* fLastContentEntry;
     SkAutoTDelete<ContentEntry> fMarginContentEntries;
     ContentEntry* fLastMarginContentEntry;
     DrawingArea fDrawingArea;
 
     const SkClipStack* fClipStack;
 
     // Accessor and setter functions based on the current DrawingArea.
     SkAutoTDelete<ContentEntry>* getContentEntries();
-    ContentEntry* getLastContentEntry();
-    void setLastContentEntry(ContentEntry* contentEntry);
 
     // Glyph ids used for each font on this device.
     SkAutoTDelete<SkPDFGlyphSetMap> fFontGlyphUsage;
 
     SkPicture::EncodeBitmap fEncoder;
     SkScalar fRasterDpi;
 
     SkBitmap fLegacyBitmap;
 
-    SkPDFDevice(const SkISize& layerSize, const SkClipStack& existingClipStack,
-                const SkRegion& existingClipRegion);
+    SkPDFCanon* fCanon;  // Owned by SkDocument_PDF
+    ////////////////////////////////////////////////////////////////////////////
+
+    SkPDFDevice(SkISize pageSize,
+                SkScalar rasterDpi,
+                SkPDFCanon* canon,
+                bool flip);
+
+    ContentEntry* getLastContentEntry();
+    void setLastContentEntry(ContentEntry* contentEntry);
 
     // override from SkBaseDevice
     SkBaseDevice* onCreateCompatibleDevice(const CreateInfo&) SK_OVERRIDE;
 
     void init();
     void cleanUp(bool clearFontUsage);
     SkPDFFormXObject* createFormXObjectFromDevice();
 
     void drawFormXObjectWithMask(int xObjectIndex,
                                  SkPDFFormXObject* mask,
@@ skipping 62 matching lines @@
 
     typedef SkBaseDevice INHERITED;
 
     // TODO(edisonn): Only SkDocument_PDF and SkPDFImageShader should be able to create
     // an SkPDFDevice
     //friend class SkDocument_PDF;
     //friend class SkPDFImageShader;
 };
 
 #endif