Update the SkDocument interface to allow for 1) abort won't emit pdf, 2) close can report success/f…

include/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 "SkBitmapDevice.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 CanvasTestStep;
 class SkPDFArray;
 class SkPDFDevice;
 class SkPDFDict;
 class SkPDFFont;
 class SkPDFFormXObject;
 class SkPDFGlyphSetMap;
 class SkPDFGraphicState;
 class SkPDFObject;
 class SkPDFResourceDict;
 class SkPDFShader;
 class SkPDFStream;
 template <typename T> class SkTSet;
 
+namespace skiatest {
+class Reporter;

[reed1, 2013/10/07 13:24:54]

Why is this declared here?

[edisonn, 2013/10/07 19:29:06]

test code, removed

+}
+
+namespace sk_tools {
+class PdfRenderer;

[reed1, 2013/10/07 13:24:54]

Why is this declared here?

[edisonn, 2013/10/07 19:29:06]

test code, removed

+}
 // Private classes.
 struct ContentEntry;
 struct GraphicStateEntry;
 struct NamedDestination;
 
+typedef bool (*EncodeToDCTStream)(SkWStream* stream, const SkBitmap& bitmap, const SkIRect& rect);

[reed1, 2013/10/07 13:24:54]

Is this different form the EncodeProc type added to SkDocument.h?

[edisonn, 2013/10/07 19:29:06]

Unused, removed

[vandebo (ex-Chrome), 2013/10/07 22:34:10]

remove?

[edisonn, 2013/10/08 17:55:30]

removed

+
 /** \class SkPDFDevice
 
     The drawing context for the PDF backend.
 */
 class SkPDFDevice : public SkBitmapDevice {
 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.
      */
     // TODO(vandebo): The sizes should be SkSize and not SkISize.

[reed1, 2013/10/07 13:24:54]

lets remove the TODO if this is deprecated

[edisonn, 2013/10/07 19:29:06]

Done.

+    // Deprecated, please use SkDocument::CreatePdf() instead.
     SK_API SkPDFDevice(const SkISize& pageSize, const SkISize& contentSize,
                        const SkMatrix& initialTransform);
     SK_API virtual ~SkPDFDevice();
 
     virtual uint32_t getDeviceCapabilities() SK_OVERRIDE;
 
     virtual void clear(SkColor color) SK_OVERRIDE;
 
     /** These are called inside the per-device-layer loop for each draw call.
      When these are called, we have already applied any saveLayer operations,
@@ skipping 113 matching lines @@
         return *(fFontGlyphUsage.get());
     }
 
 protected:
     virtual bool onReadPixels(const SkBitmap& bitmap, int x, int y,
                               SkCanvas::Config8888) SK_OVERRIDE;
 
     virtual bool allowImageFilter(SkImageFilter*) SK_OVERRIDE;
 
 private:
+    SK_API SkPDFDevice(const SkSize& trimBox, const SkRect& mediaBox);
+
     // TODO(vandebo): push most of SkPDFDevice's state into a core object in
     // order to get the right access levels without using friend.
     friend class ScopedContentEntry;
 
     SkISize fPageSize;
     SkISize fContentSize;
     SkMatrix fInitialTransform;
     SkClipStack fExistingClipStack;
     SkRegion fExistingClipRegion;
     SkPDFArray* fAnnotations;
@@ skipping 93 matching lines @@
                                const SkMatrix& matrix, const SkPaint& paint);
     SkPDFDict* createLinkAnnotation(const SkRect& r, const SkMatrix& matrix);
     void handleLinkToURL(SkData* urlData, const SkRect& r,
                          const SkMatrix& matrix);
     void handleLinkToNamedDest(SkData* nameData, const SkRect& r,
                                const SkMatrix& matrix);
     void defineNamedDestination(SkData* nameData, const SkPoint& point,
                                 const SkMatrix& matrix);
 
     typedef SkBitmapDevice INHERITED;
+
+    // TODO(edisonn): Only SkDocument_PDF and SkPDFImageShader should be able to create
+    // an SkPDFDevice
+    friend class SkDocument_PDF;
+    friend class SkPDFImageShader;
+};
+
+class SkPDFDeviceFlattener : public SkPDFDevice {

[reed1, 2013/10/07 13:24:54]

Does this class need to be in this header, or can it be private to the impl?

[edisonn, 2013/10/07 19:29:06]

I could put all this logic inside PDF, but long term, I think PDF and XPS should
inherit the same base class. For now The flattener is based on PDF, but then I
would move the flattener to be inherited by pdf instead, and then maybe add XPS.

In this way I keep most of the logic contained in a single layer.

I would not move this to it's own file, for now.

This class has a private constructor, and only SkDocument::CreatePDF can create
one.

what do you mean by "private to the impl"?

[vandebo (ex-Chrome), 2013/10/07 22:34:10]

Flattener is a very generic name.  Is this meant to be SkPDFDevice with
perspective support?  SkPDFPerspectiveDevice ?

Why do it as a separate device?

[edisonn, 2013/10/08 17:55:30]

This class will flatten other properties unsuported, not only perspective.
The flatten layer should be be separated, so long term XPS and PDF device can
reuse them easily. Probably, long term XPS and PDF should inherit the same
device type. If we mix the flattening code in PDFDevice, then we will end up
with duplicated code in XPS and PDF, and it will be harder to refactor them.

+private:
+    typedef SkPDFDevice INHERITED;
+
+    SK_API SkPDFDeviceFlattener(const SkSize& trimBox, const SkRect& mediaBox);
+
+public:
+    SK_API virtual ~SkPDFDeviceFlattener();
+
+    virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
+    virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode,
+                            size_t count, const SkPoint[],
+                            const SkPaint& paint) SK_OVERRIDE;
+    virtual void drawRect(const SkDraw&, const SkRect& r, const SkPaint& paint);
+    virtual void drawPath(const SkDraw&, const SkPath& origpath,
+                          const SkPaint& paint, const SkMatrix* prePathMatrix,
+                          bool pathIsMutable) SK_OVERRIDE;
+    virtual void drawText(const SkDraw&, const void* text, size_t len,
+                          SkScalar x, SkScalar y, const SkPaint&) SK_OVERRIDE;
+    virtual void drawPosText(const SkDraw&, const void* text, size_t len,
+                             const SkScalar pos[], SkScalar constY,
+                             int scalarsPerPos, const SkPaint&) SK_OVERRIDE;
+    virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
+                                const SkPath& path, const SkMatrix* matrix,
+                                const SkPaint& paint) SK_OVERRIDE;
+    virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode,
+                              int vertexCount, const SkPoint verts[],
+                              const SkPoint texs[], const SkColor colors[],
+                              SkXfermode* xmode, const uint16_t indices[],
+                              int indexCount, const SkPaint& paint) SK_OVERRIDE;
+    virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
+                            const SkPaint&) SK_OVERRIDE;
+private:
+
+    bool mustFlatten(const SkDraw& d) const;
+    bool mustPathText(const SkDraw& d, const SkPaint& paint);
+
+    friend class SkDocument_PDF;
 };
 
 #endif