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

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 "SkAnnotation.h"
@@ skipping 2016 matching lines @@
     }
     return resourceIndex;
 }
 
 void SkPDFDevice::internalDrawBitmap(const SkMatrix& matrix,
                                      const SkClipStack* clipStack,
                                      const SkRegion& clipRegion,
                                      const SkBitmap& bitmap,
                                      const SkIRect* srcRect,
                                      const SkPaint& paint) {
+    // TODO(edisonn): Perspective matrix support implemented here
     SkMatrix scaled;
     // Adjust for origin flip.
     scaled.setScale(SK_Scalar1, -SK_Scalar1);
     scaled.postTranslate(0, SK_Scalar1);
     // Scale the image up from 1x1 to WxH.
     SkIRect subset = SkIRect::MakeWH(bitmap.width(), bitmap.height());
     scaled.postScale(SkIntToScalar(subset.width()),
                      SkIntToScalar(subset.height()));
     scaled.postConcat(matrix);
     ScopedContentEntry content(this, clipStack, clipRegion, scaled, paint);
@@ skipping 16 matching lines @@
 }
 
 bool SkPDFDevice::onReadPixels(const SkBitmap& bitmap, int x, int y,
                                SkCanvas::Config8888) {
     return false;
 }
 
 bool SkPDFDevice::allowImageFilter(SkImageFilter*) {
     return false;
 }
+
+static SkISize SkSizeToISize(const SkSize& size) {
+    return SkISize::Make(SkScalarRoundToInt(size.width()), SkScalarRoundToInt(size.height()));
+}
+
+static SkMatrix buildMatrixToMapTrimBox00(const SkRect& content) {
+    SkMatrix matrix;
+    matrix.setTranslate(-content.left(), -content.top());
+    return matrix;
+}
+
+SkPDFDeviceFlattener::SkPDFDeviceFlattener(const SkSize& trimBox, const SkRect& content)
+            : SkPDFDevice(SkSizeToISize(trimBox),
+                          SkSizeToISize(SkSize::Make(content.width(), content.height())),
+                          buildMatrixToMapTrimBox00(content)) {
+}
+
+SkPDFDeviceFlattener::~SkPDFDeviceFlattener() {
+}
+
+void SkPDFDeviceFlattener::drawPaint(const SkDraw& d, const SkPaint& paint) {
+    INHERITED::drawPaint(d, paint);
+}
+
+void SkPDFDeviceFlattener::drawPoints(const SkDraw& d, SkCanvas::PointMode mode,
+                                      size_t count, const SkPoint points[],
+                                      const SkPaint& paint) {
+    if (mustFlatten(d)) {
+        SkPoint* flattenedPoints = SkNEW_ARRAY(SkPoint, count);
+        d.fMatrix->mapPoints(flattenedPoints, points, count);
+        SkDraw draw(d);
+        SkMatrix identity = SkMatrix::I();
+        draw.fMatrix = &identity;
+        INHERITED::drawPoints(draw, mode, count, flattenedPoints, paint);
+        SkDELETE_ARRAY(flattenedPoints);
+        return;
+    }
+
+    INHERITED::drawPoints(d, mode, count, points, paint);
+}
+
+void SkPDFDeviceFlattener::drawRect(const SkDraw& d, const SkRect& r, const SkPaint& paint) {
+    if (mustFlatten(d)) {
+        SkPath path;
+        path.addRect(r);
+        path.transform(*d.fMatrix);
+        SkDraw draw(d);
+        SkMatrix matrix = SkMatrix::I();
+        draw.fMatrix = &matrix;
+
+        SkPaint paintFlatten = paint;
+        if (paintFlatten.getShader()) {
+            SkMatrix local = paintFlatten.getShader()->getLocalMatrix();
+            local.preConcat(*d.fMatrix);
+            paintFlatten.getShader()->setLocalMatrix(local);
+        }
+
+        INHERITED::drawPath(draw, path, paintFlatten, NULL, true);
+        return;
+    }
+
+    INHERITED::drawRect(d, r, paint);
+}
+
+void SkPDFDeviceFlattener::drawPath(const SkDraw& d, const SkPath& origpath,
+                                    const SkPaint& paint, const SkMatrix* prePathMatrix,
+                                    bool pathIsMutable) {
+    if (mustFlatten(d) || (prePathMatrix && prePathMatrix->hasPerspective())) {
+        SkPath path;
+        path.addPath(origpath);
+        if (prePathMatrix) {
+            path.transform(*prePathMatrix);
+        }
+        path.transform(*d.fMatrix);
+        SkDraw draw(d);
+        SkMatrix matrix = SkMatrix::I();
+        draw.fMatrix = &matrix;
+
+        SkPaint paintFlatten = paint;
+        if (paintFlatten.getShader()) {
+            SkMatrix local = *d.fMatrix;
+            local.preConcat(paintFlatten.getShader()->getLocalMatrix());
+
+            paintFlatten.getShader()->setLocalMatrix(local);
+        }
+
+        INHERITED::drawPath(draw, path, paintFlatten, NULL, true);
+        return;
+    }
+
+    INHERITED::drawPath(d, origpath, paint, prePathMatrix, pathIsMutable);
+}
+
+void SkPDFDeviceFlattener::drawText(const SkDraw& d, const void* text, size_t len,
+                                    SkScalar x, SkScalar y, const SkPaint& paint) {
+    if (mustPathText(d, paint)) {
+        d.drawText_asPaths((const char*)text, len, x, y, paint);
+        return;
+    }
+
+    INHERITED::drawText(d, text, len, x, y, paint);
+}
+
+void SkPDFDeviceFlattener::drawPosText(const SkDraw& d, const void* text, size_t len,
+                                       const SkScalar pos[], SkScalar constY,
+                                       int scalarsPerPos, const SkPaint& paint) {
+    if (mustPathText(d, paint)) {
+        d.drawPosText_asPaths((const char*)text, len, pos, constY, scalarsPerPos, paint);
+        return;
+    }
+    INHERITED::drawPosText(d, text, len,pos, constY,scalarsPerPos, paint);
+}
+
+void SkPDFDeviceFlattener::drawTextOnPath(const SkDraw& d, const void* text, size_t len,
+                                          const SkPath& path, const SkMatrix* matrix,
+                                          const SkPaint& paint) {
+    if (mustPathText(d, paint) || (matrix && matrix->hasPerspective())) {
+        d.drawTextOnPath((const char*)text, len, path, matrix, paint);
+        return;
+    }
+    INHERITED::drawTextOnPath(d, text, len, path, matrix, paint);
+}
+
+void SkPDFDeviceFlattener::drawVertices(const SkDraw& d, SkCanvas::VertexMode mode,
+                                        int vertexCount, const SkPoint verts[],
+                                        const SkPoint texs[], const SkColor colors[],
+                                        SkXfermode* xmode, const uint16_t indices[],
+                                        int indexCount, const SkPaint& paint) {
+    INHERITED::drawVertices(d, mode, vertexCount, verts, texs, colors, xmode, indices, indexCount,
+                            paint);
+}
+
+void SkPDFDeviceFlattener::drawDevice(const SkDraw& d, SkBaseDevice* dev, int x, int y,
+                                      const SkPaint& paint) {
+    INHERITED::drawDevice(d, dev, x, y, paint);
+}
+
+bool SkPDFDeviceFlattener::mustFlatten(const SkDraw& d) const {
+    // TODO(edisonn): testability, add flag to force return true.
+    return d.fMatrix->hasPerspective();
+}
+
+bool SkPDFDeviceFlattener::mustPathText(const SkDraw& d, const SkPaint&) {
+    // TODO(edisonn): testability, add flag to force return true.
+    // TODO(edisonn): TBD: How to flatten MaskFilter.
+    return d.fMatrix->hasPerspective();
+}