[SkPDFDevice] Enable pathops-based inverse fills

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 310 matching lines @@
 
     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
 /* 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);
 }
 
+#ifdef SK_PDF_USE_PATHOPS_CLIPPING
 // 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);
@@ skipping 77 matching lines @@
         }
     }
     push();
 
     currentEntry()->fClipStack = clipStack;
     currentEntry()->fClipRegion = clipRegion;
 
     SkMatrix transform;
     transform.setTranslate(translation.fX, translation.fY);
 
-#ifdef SK_PDF_USE_PATHOPS
+#ifdef SK_PDF_USE_PATHOPS_CLIPPING
     SkPath clipPath;
     if (get_clip_stack_path(transform, clipStack, clipRegion, &clipPath)) {
         emit_clip(&clipPath, NULL, fContentStream);
         return;
     }
 #endif
     // 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
@@ skipping 490 matching lines @@
         if (fill) {
             noEffectPaint.setStyle(SkPaint::kFill_Style);
         } else {
             noEffectPaint.setStyle(SkPaint::kStroke_Style);
             noEffectPaint.setStrokeWidth(0);
         }
         drawPath(d, *pathPtr, noEffectPaint, NULL, true);
         return;
     }
 
-#ifdef SK_PDF_USE_PATHOPS
     if (handleInversePath(d, origPath, paint, pathIsMutable, prePathMatrix)) {
         return;
     }
-#endif
 
     if (handleRectAnnotation(pathPtr->getBounds(), matrix, paint)) {
         return;
     }
 
     ScopedContentEntry content(this, d.fClipStack, *d.fClip, matrix, paint);
     if (!content.entry()) {
         return;
     }
     SkPDFUtils::EmitPath(*pathPtr, paint.getStyle(),
@@ skipping 387 matching lines @@
     // initial transform, so just clip to the device size.
     if (fPageSize != fContentSize) {
         SkRect r = SkRect::MakeWH(SkIntToScalar(this->width()),
                                   SkIntToScalar(this->height()));
         emit_clip(NULL, &r, out);
     }
 
     SkPDFDevice::copyContentEntriesToData(fContentEntries.get(), out);
 }
 
-#ifdef SK_PDF_USE_PATHOPS
 /* Draws an inverse filled path by using Path Ops to compute the positive
  * inverse using the current clip as the inverse bounds.
  * Return true if this was an inverse path and was properly handled,
  * otherwise returns false and the normal drawing routine should continue,
  * either as a (incorrect) fallback or because the path was not inverse
  * in the first place.
  */
 bool SkPDFDevice::handleInversePath(const SkDraw& d, const SkPath& origPath,
                                     const SkPaint& paint, bool pathIsMutable,
                                     const SkMatrix* prePathMatrix) {
@@ skipping 45 matching lines @@
     bounds.outset(paint.getStrokeWidth() + SK_Scalar1,
                   paint.getStrokeWidth() + SK_Scalar1);
 
     if (!calculate_inverse_path(bounds, *pathPtr, &modifiedPath)) {
         return false;
     }
 
     drawPath(d, modifiedPath, noInversePaint, prePathMatrix, true);
     return true;
 }
-#endif
 
 bool SkPDFDevice::handleRectAnnotation(const SkRect& r, const SkMatrix& matrix,
                                        const SkPaint& p) {
     SkAnnotation* annotationInfo = p.getAnnotation();
     if (!annotationInfo) {
         return false;
     }
     SkData* urlData = annotationInfo->find(SkAnnotationKeys::URL_Key());
     if (urlData) {
         handleLinkToURL(urlData, r, matrix);
@@ skipping 701 matching lines @@
         return;
     }
     SkAutoTUnref<SkPDFObject> image(SkPDFBitmap::Create(fCanon, subsetBitmap));
     if (!image) {
         return;
     }
 
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(image.get()),
                                 &content.entry()->fContent);
 }