Use Path Ops to generate PDF clips

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 255 matching lines @@
     fStackDepth++;
     fEntries[fStackDepth] = fEntries[fStackDepth - 1];
 }
 
 void GraphicStackState::pop() {
     SkASSERT(fStackDepth > 0);
     fContentStream->writeText("Q\n");
     fStackDepth--;
 }
 
+#ifndef SK_PDF_USE_PATHOPS
 // This function initializes iter to be an iterator on the "stack" argument
 // and then skips over the leading entries as specified in prefix.  It requires
 // and asserts that "prefix" will be a prefix to "stack."
 static void skip_clip_stack_prefix(const SkClipStack& prefix,
                                    const SkClipStack& stack,
                                    SkClipStack::Iter* iter) {
     SkClipStack::B2TIter prefixIter(prefix);
     iter->reset(stack, SkClipStack::Iter::kBottom_IterStart);
 
     const SkClipStack::Element* prefixEntry;
@@ skipping 11 matching lines @@
             SkASSERT(iterEntry->getType() == prefixEntry->getType());
             // back up the iterator by one
             iter->prev();
             prefixEntry = prefixIter.next();
             break;
         }
     }
 
     SkASSERT(prefixEntry == NULL);
 }
+#endif
 
 static void emit_clip(SkPath* clipPath, SkRect* clipRect,
                       SkWStream* contentStream) {
     SkASSERT(clipPath || clipRect);
 
     SkPath::FillType clipFill;
     if (clipPath) {
         SkPDFUtils::EmitPath(*clipPath, SkPaint::kFill_Style, contentStream);
         clipFill = clipPath->getFillType();
     } else {
         SkPDFUtils::AppendRectangle(*clipRect, contentStream);
         clipFill = SkPath::kWinding_FillType;
     }
 
     NOT_IMPLEMENTED(clipFill == SkPath::kInverseEvenOdd_FillType, false);
     NOT_IMPLEMENTED(clipFill == SkPath::kInverseWinding_FillType, false);
     if (clipFill == SkPath::kEvenOdd_FillType) {
         contentStream->writeText("W* n\n");
     } else {
         contentStream->writeText("W n\n");
     }
 }
 
+#ifdef SK_PDF_USE_PATHOPS
+// Sanity check the numerical values of the SkRegion ops and PathOps ops
+// enums so region_op_to_pathops_op can do a straight passthrough cast.
+// If these are failing, it may be necessary to make region_op_to_pathops_op
+// do more.
+SK_COMPILE_ASSERT(SkRegion::kDifference_Op == (int)kDifference_PathOp,
+                  region_pathop_mismatch);
+SK_COMPILE_ASSERT(SkRegion::kIntersect_Op == (int)kIntersect_PathOp,
+                  region_pathop_mismatch);
+SK_COMPILE_ASSERT(SkRegion::kUnion_Op == (int)kUnion_PathOp,
+                  region_pathop_mismatch);
+SK_COMPILE_ASSERT(SkRegion::kXOR_Op == (int)kXOR_PathOp,
+                  region_pathop_mismatch);
+SK_COMPILE_ASSERT(SkRegion::kReverseDifference_Op ==
+                  (int)kReverseDifference_PathOp,
+                  region_pathop_mismatch);
+
+static SkPathOp region_op_to_pathops_op(SkRegion::Op op) {
+    SkASSERT(op >= 0);
+    SkASSERT(op <= SkRegion::kReverseDifference_Op);
+    return (SkPathOp)op;
+}
+
+static SkPath get_clip_stack_path(const SkMatrix& transform,
+                                  const SkClipStack& clipStack,
+                                  const SkRegion& clipRegion) {
+    SkPath clipPath;
+    clipPath.setFillType(SkPath::kInverseWinding_FillType);
+
+    const SkClipStack::Element* clipEntry;
+    SkClipStack::Iter iter;
+    iter.reset(clipStack, SkClipStack::Iter::kBottom_IterStart);
+    for (clipEntry = iter.next(); clipEntry; clipEntry = iter.next()) {
+        SkPath entryPath;
+        if (SkClipStack::Element::kEmpty_Type == clipEntry->getType()) {
+            clipPath.reset();
+            clipPath.setFillType(SkPath::kInverseWinding_FillType);
+            continue;
+        } else if (SkClipStack::Element::kRect_Type == clipEntry->getType()) {
+            entryPath.addRect(clipEntry->getRect());
+        } else if (SkClipStack::Element::kPath_Type == clipEntry->getType()) {
+            entryPath = clipEntry->getPath();
+        }
+        entryPath.transform(transform);
+
+        if (SkRegion::kReplace_Op == clipEntry->getOp()) {
+            clipPath = entryPath;
+        } else {
+            SkPathOp op = region_op_to_pathops_op(clipEntry->getOp());
+            if (!Op(clipPath, entryPath, op, &clipPath)) {
+                SkAssertResult(clipRegion.getBoundaryPath(&clipPath));

[vandebo (ex-Chrome), 2013/08/02 15:58:09]

Here we could fall back to the old code.

[ducky, 2013/08/02 19:03:33]

Done.

+                return clipPath;
+            }
+        }
+    }
+
+    // Intersect the results with the clip bounds from the region to handle

[vandebo (ex-Chrome), 2013/08/02 15:58:09]

Don't we only need to do this chunk of code if clipPath.isInverseFillType() ? 
And if it is, should we call calculate_inverse_path ?

[ducky, 2013/08/02 19:03:33]

Good point.

+    // an inverse fill. The bounds are slightly outset to ensure this is
+    // correct in the face of floating-point accuracy and possible
+    // SkRegion bitmap approximations.
+    SkRect clipBounds = SkRect::Make(clipRegion.getBounds());
+    clipBounds.outset(SK_Scalar1, SK_Scalar1);
+    SkPath boundsPath;
+    boundsPath.addRect(clipBounds);
+
+    if (!Op(clipPath, boundsPath, kIntersect_PathOp, &clipPath)) {
+        SkAssertResult(clipRegion.getBoundaryPath(&clipPath));
+        return clipPath;
+    }
+
+    return clipPath;
+}
+#endif
+
 // TODO(vandebo): Take advantage of SkClipStack::getSaveCount(), the PDF
 // graphic state stack, and the fact that we can know all the clips used
 // on the page to optimize this.
 void GraphicStackState::updateClip(const SkClipStack& clipStack,
                                    const SkRegion& clipRegion,
                                    const SkPoint& translation) {
     if (clipStack == currentEntry()->fClipStack) {
         return;
     }
 
     while (fStackDepth > 0) {
         pop();
         if (clipStack == currentEntry()->fClipStack) {
             return;
         }
     }
     push();
 
+    SkMatrix transform;
+    transform.setTranslate(translation.fX, translation.fY);
+
+#ifdef SK_PDF_USE_PATHOPS
+    SkPath clipPath = get_clip_stack_path(transform, clipStack, clipRegion);
+    emit_clip(&clipPath, NULL, fContentStream);
+#else
     // gsState->initialEntry()->fClipStack/Region specifies the clip that has
     // already been applied.  (If this is a top level device, then it specifies
     // a clip to the content area.  If this is a layer, then it specifies
     // the clip in effect when the layer was created.)  There's no need to
     // reapply that clip; SKCanvas's SkDrawIter will draw anything outside the
     // initial clip on the parent layer.  (This means there's a bug if the user
     // expands the clip and then uses any xfer mode that uses dst:
     // http://code.google.com/p/skia/issues/detail?id=228 )
     SkClipStack::Iter iter;
     skip_clip_stack_prefix(fEntries[0].fClipStack, clipStack, &iter);
 
     // If the clip stack does anything other than intersect or if it uses
     // an inverse fill type, we have to fall back to the clip region.
     bool needRegion = false;
     const SkClipStack::Element* clipEntry;
     for (clipEntry = iter.next(); clipEntry; clipEntry = iter.next()) {
         if (clipEntry->getOp() != SkRegion::kIntersect_Op || clipEntry->isInverseFilled()) {
             needRegion = true;
             break;
         }
     }
 
     if (needRegion) {
         SkPath clipPath;
         SkAssertResult(clipRegion.getBoundaryPath(&clipPath));
         emit_clip(&clipPath, NULL, fContentStream);
     } else {
         skip_clip_stack_prefix(fEntries[0].fClipStack, clipStack, &iter);
-        SkMatrix transform;
-        transform.setTranslate(translation.fX, translation.fY);
         const SkClipStack::Element* clipEntry;
         for (clipEntry = iter.next(); clipEntry; clipEntry = iter.next()) {
             SkASSERT(clipEntry->getOp() == SkRegion::kIntersect_Op);
             switch (clipEntry->getType()) {
                 case SkClipStack::Element::kRect_Type: {
                     SkRect translatedClip;
                     transform.mapRect(&translatedClip, clipEntry->getRect());
                     emit_clip(NULL, &translatedClip, fContentStream);
                     break;
                 }
                 case SkClipStack::Element::kPath_Type: {
                     SkPath translatedPath;
                     clipEntry->getPath().transform(transform, &translatedPath);
                     emit_clip(&translatedPath, NULL, fContentStream);
                     break;
                 }
                 default:
                     SkASSERT(false);
             }
         }
     }
+#endif
     currentEntry()->fClipStack = clipStack;
     currentEntry()->fClipRegion = clipRegion;
 }
 
 void GraphicStackState::updateMatrix(const SkMatrix& matrix) {
     if (matrix == currentEntry()->fMatrix) {
         return;
     }
 
     if (currentEntry()->fMatrix.getType() != SkMatrix::kIdentity_Mask) {
@@ skipping 825 matching lines @@
 
     SkPDFDevice::copyContentEntriesToData(fContentEntries.get(), &data);
 
     // potentially we could cache this SkData, and only rebuild it if we
     // see that our state has changed.
     return data.copyToData();
 }
 
 /* Calculate an inverted path's equivalent non-inverted path, given the
  * canvas bounds.
+ * outPath may alias with invPath (since this is supported by PathOps).
  */
 static bool calculate_inverse_path(const SkRect& bounds, const SkPath& invPath,
                                    SkPath* outPath) {
     SkASSERT(invPath.isInverseFillType());
 
     SkPath clipPath;
     clipPath.addRect(bounds);
 
     return Op(clipPath, invPath, kIntersect_PathOp, outPath);
 }
@@ skipping 578 matching lines @@
 }
 
 bool SkPDFDevice::onReadPixels(const SkBitmap& bitmap, int x, int y,
                                SkCanvas::Config8888) {
     return false;
 }
 
 bool SkPDFDevice::allowImageFilter(SkImageFilter*) {
     return false;
 }