pdf: report NYI features, and fail gracefully when something is not supported in pdf.

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 661 matching lines @@
 // TODO(vandebo) change pageSize to SkSize.
 SkPDFDevice::SkPDFDevice(const SkISize& pageSize, const SkISize& contentSize,
                          const SkMatrix& initialTransform)
     : SkBitmapDevice(makeContentBitmap(contentSize, &initialTransform)),
       fPageSize(pageSize),
       fContentSize(contentSize),
       fLastContentEntry(NULL),
       fLastMarginContentEntry(NULL),
       fClipStack(NULL),
       fEncoder(NULL) {
+    SkASSERT(!initialTransform.hasPerspective());

[vandebo (ex-Chrome), 2013/09/12 21:37:05]

If you want to assert, just pass true for the second arg to NOT_IMPLEMENTED...

[edisonn, 2013/09/17 15:14:23]

Done.

     // 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);
     fInitialTransform.preConcat(initialTransform);
 
     SkIRect existingClip = SkIRect::MakeWH(this->width(), this->height());
     fExistingClipRegion.setRect(existingClip);
 
     this->init();
+    if (initialTransform.hasPerspective()) {
+        NOT_IMPLEMENTED(true, false);  // just report that PDF does not supports perspective
+                                       // TODO(edisonn): update the shape when possible
+                                       // or dump in an image otherwise
+    }
 }
 
 // TODO(vandebo) change layerSize to SkSize.
 SkPDFDevice::SkPDFDevice(const SkISize& layerSize,
                          const SkClipStack& existingClipStack,
                          const SkRegion& existingClipRegion)
     : SkBitmapDevice(makeContentBitmap(layerSize, NULL)),
       fPageSize(layerSize),
       fContentSize(layerSize),
       fExistingClipStack(existingClipStack),
@@ skipping 67 matching lines @@
         return;
     }
     SkRect bbox = SkRect::MakeWH(SkIntToScalar(this->width()),
                                  SkIntToScalar(this->height()));
     SkMatrix totalTransform = fInitialTransform;
     totalTransform.preConcat(contentEntry->fState.fMatrix);
     SkMatrix inverse;
     if (!totalTransform.invert(&inverse)) {
         return;
     }
+
+    if (totalTransform.hasPerspective()) {
+        NOT_IMPLEMENTED(true, false);  // just report that PDF does not supports perspective
+                                       // TODO(edisonn): update the shape when possible
+                                       // or dump in an image otherwise
+        return;
+    }
+
     inverse.mapRect(&bbox);
 
     SkPDFUtils::AppendRectangle(bbox, &contentEntry->fContent);
     SkPDFUtils::PaintPath(paint.getStyle(), SkPath::kWinding_FillType,
                           &contentEntry->fContent);
 }
 
 void SkPDFDevice::drawPoints(const SkDraw& d, SkCanvas::PointMode mode,
                              size_t count, const SkPoint* points,
                              const SkPaint& passedPaint) {
@@ skipping 93 matching lines @@
         SkPath path;
         path.addRect(r);
         drawPath(d, path, paint, NULL, true);
         return;
     }
 
     if (handleRectAnnotation(r, *d.fMatrix, paint)) {
         return;
     }
 
+    if (d.fMatrix->hasPerspective()) {

[vandebo (ex-Chrome), 2013/09/12 21:37:05]

If you put this in ScopedContentEntry, you'll cover most of the cases with a
single test.

[edisonn, 2013/09/17 15:14:23]

Done.

+        NOT_IMPLEMENTED(true, false);  // just report that PDF does not supports perspective
+                                       // TODO(edisonn): update the shape when possible
+                                       // or dump in an image otherwise
+        return;
+    }
+
     ScopedContentEntry content(this, d, paint);
     if (!content.entry()) {
         return;
     }
     SkPDFUtils::AppendRectangle(r, &content.entry()->fContent);
     SkPDFUtils::PaintPath(paint.getStyle(), SkPath::kWinding_FillType,
                           &content.entry()->fContent);
 }
 
 void SkPDFDevice::drawPath(const SkDraw& d, const SkPath& origPath,
                            const SkPaint& paint, const SkMatrix* prePathMatrix,
                            bool pathIsMutable) {
     SkPath modifiedPath;
     SkPath* pathPtr = const_cast<SkPath*>(&origPath);
 
     SkMatrix matrix = *d.fMatrix;
     if (prePathMatrix) {
         if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
             if (!pathIsMutable) {
                 pathPtr = &modifiedPath;
                 pathIsMutable = true;
             }
             origPath.transform(*prePathMatrix, pathPtr);
         } else {
             if (!matrix.preConcat(*prePathMatrix)) {
+                // TODO(edisonn): report somewhow why we failed?
                 return;
             }
         }
     }
 
+    if (matrix.hasPerspective()) {
+        NOT_IMPLEMENTED(true, false);  // just report that PDF does not supports perspective
+                                       // TODO(edisonn): update the shape when possible
+                                       // or dump in an image otherwise
+        return;
+    }
+
     if (paint.getPathEffect()) {
         if (d.fClip->isEmpty()) {
             return;
         }
         if (!pathIsMutable) {
             pathPtr = &modifiedPath;
             pathIsMutable = true;
         }
         bool fill = paint.getFillPath(origPath, pathPtr);
 
@@ skipping 962 matching lines @@
                                      const SkPaint& paint) {
     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);
+
+    if (scaled.hasPerspective()) {
+        NOT_IMPLEMENTED(true, false);  // just report that PDF does not supports perspective
+                                       // TODO(edisonn): update the shape when possible
+                                       // or dump in an image otherwise
+        return;
+    }
+
     ScopedContentEntry content(this, clipStack, clipRegion, scaled, paint);
     if (!content.entry()) {
         return;
     }
 
     if (srcRect && !subset.intersect(*srcRect)) {
         return;
     }
 
     SkPDFImage* image = SkPDFImage::CreateImage(bitmap, subset, fEncoder);
     if (!image) {
         return;
     }
 
     fXObjectResources.push(image);  // Transfer reference.
     SkPDFUtils::DrawFormXObject(fXObjectResources.count() - 1,
                                 &content.entry()->fContent);
 }
 
 bool SkPDFDevice::onReadPixels(const SkBitmap& bitmap, int x, int y,
                                SkCanvas::Config8888) {
     return false;
 }
 
 bool SkPDFDevice::allowImageFilter(SkImageFilter*) {
     return false;
 }