remove 'deprecated' region from SkDraw

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 "SkAnnotationKeys.h"
@@ skipping 549 matching lines @@
 // A helper class to automatically finish a ContentEntry at the end of a
 // drawing method and maintain the state needed between set up and finish.
 class ScopedContentEntry {
 public:
     ScopedContentEntry(SkPDFDevice* device, const SkDraw& draw,
                        const SkPaint& paint, bool hasText = false)
         : fDevice(device),
           fContentEntry(nullptr),
           fXfermode(SkXfermode::kSrcOver_Mode),
           fDstFormXObject(nullptr) {
-        init(draw.fClipStack, *draw.fClip, *draw.fMatrix, paint, hasText);
+        init(draw.fClipStack, draw.fRC->bwRgn(), *draw.fMatrix, paint, hasText);
     }
     ScopedContentEntry(SkPDFDevice* device, const SkClipStack* clipStack,
                        const SkRegion& clipRegion, const SkMatrix& matrix,
                        const SkPaint& paint, bool hasText = false)
         : fDevice(device),
           fContentEntry(nullptr),
           fXfermode(SkXfermode::kSrcOver_Mode),
           fDstFormXObject(nullptr) {
         init(clipStack, clipRegion, matrix, paint, hasText);
     }
@@ skipping 164 matching lines @@
     replace_srcmode_on_opaque_paint(&passedPaint);
 
     if (count == 0) {
         return;
     }
 
     // SkDraw::drawPoints converts to multiple calls to fDevice->drawPath.
     // We only use this when there's a path effect because of the overhead
     // of multiple calls to setUpContentEntry it causes.
     if (passedPaint.getPathEffect()) {
-        if (d.fClip->isEmpty()) {
+        if (d.fRC->isEmpty()) {
             return;
         }
         SkDraw pointDraw(d);
         pointDraw.fDevice = this;
         pointDraw.drawPoints(mode, count, points, passedPaint, true);
         return;
     }
 
     const SkPaint* paint = &passedPaint;
     SkPaint modifiedPaint;
@@ skipping 103 matching lines @@
 
 void SkPDFDevice::drawRect(const SkDraw& d,
                            const SkRect& rect,
                            const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     replace_srcmode_on_opaque_paint(&paint);
     SkRect r = rect;
     r.sort();
 
     if (paint.getPathEffect()) {
-        if (d.fClip->isEmpty()) {
+        if (d.fRC->isEmpty()) {
             return;
         }
         SkPath path;
         path.addRect(r);
         drawPath(d, path, paint, nullptr, true);
         return;
     }
 
     ScopedContentEntry content(this, d, paint);
     if (!content.entry()) {
@@ skipping 41 matching lines @@
                 pathPtr = &modifiedPath;
                 pathIsMutable = true;
             }
             origPath.transform(*prePathMatrix, pathPtr);
         } else {
             matrix.preConcat(*prePathMatrix);
         }
     }
 
     if (paint.getPathEffect()) {
-        if (d.fClip->isEmpty()) {
+        if (d.fRC->isEmpty()) {
             return;
         }
         if (!pathIsMutable) {
             pathPtr = &modifiedPath;
             pathIsMutable = true;
         }
         bool fill = paint.getFillPath(origPath, pathPtr);
 
         SkPaint noEffectPaint(paint);
         noEffectPaint.setPathEffect(nullptr);
         if (fill) {
             noEffectPaint.setStyle(SkPaint::kFill_Style);
         } else {
             noEffectPaint.setStyle(SkPaint::kStroke_Style);
             noEffectPaint.setStrokeWidth(0);
         }
         drawPath(d, *pathPtr, noEffectPaint, nullptr, true);
         return;
     }
 
     if (handleInversePath(d, origPath, paint, pathIsMutable, prePathMatrix)) {
         return;
     }
 
-    ScopedContentEntry content(this, d.fClipStack, *d.fClip, matrix, paint);
+    ScopedContentEntry content(this, d.fClipStack, d.fRC->bwRgn(), matrix, paint);
     if (!content.entry()) {
         return;
     }
     bool consumeDegeratePathSegments =
            paint.getStyle() == SkPaint::kFill_Style ||
            (paint.getStrokeCap() != SkPaint::kRound_Cap &&
             paint.getStrokeCap() != SkPaint::kSquare_Cap);
     SkPDFUtils::EmitPath(*pathPtr, paint.getStyle(),
                          consumeDegeratePathSegments,
                          &content.entry()->fContent);
@@ skipping 12 matching lines @@
 
 void SkPDFDevice::drawBitmap(const SkDraw& d,
                              const SkBitmap& bitmap,
                              const SkMatrix& matrix,
                              const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     if (bitmap.isOpaque()) {
         replace_srcmode_on_opaque_paint(&paint);
     }
 
-    if (d.fClip->isEmpty()) {
+    if (d.fRC->isEmpty()) {
         return;
     }
 
     SkMatrix transform = matrix;
     transform.postConcat(*d.fMatrix);
     SkImageBitmap imageBitmap(bitmap);
     this->internalDrawImage(
-            transform, d.fClipStack, *d.fClip, imageBitmap, paint);
+            transform, d.fClipStack, d.fRC->bwRgn(), imageBitmap, paint);
 }
 
 void SkPDFDevice::drawSprite(const SkDraw& d,
                              const SkBitmap& bitmap,
                              int x,
                              int y,
                              const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     if (bitmap.isOpaque()) {
         replace_srcmode_on_opaque_paint(&paint);
     }
 
-    if (d.fClip->isEmpty()) {
+    if (d.fRC->isEmpty()) {
         return;
     }
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
     SkImageBitmap imageBitmap(bitmap);
     this->internalDrawImage(
-            matrix, d.fClipStack, *d.fClip, imageBitmap, paint);
+            matrix, d.fClipStack, d.fRC->bwRgn(), imageBitmap, paint);
 }
 
 void SkPDFDevice::drawImage(const SkDraw& draw,
                             const SkImage* image,
                             SkScalar x,
                             SkScalar y,
                             const SkPaint& srcPaint) {
     SkPaint paint = srcPaint;
     if (!image) {
         return;
     }
     if (image->isOpaque()) {
         replace_srcmode_on_opaque_paint(&paint);
     }
-    if (draw.fClip->isEmpty()) {
+    if (draw.fRC->isEmpty()) {
         return;
     }
     SkMatrix transform = SkMatrix::MakeTrans(x, y);
     transform.postConcat(*draw.fMatrix);
     SkImageBitmap imageBitmap(const_cast<SkImage*>(image));
     this->internalDrawImage(
-            transform, draw.fClipStack, *draw.fClip, imageBitmap, paint);
+            transform, draw.fClipStack, draw.fRC->bwRgn(), imageBitmap, paint);
 }
 
 void SkPDFDevice::drawImageRect(const SkDraw& draw,
                                 const SkImage* image,
                                 const SkRect* src,
                                 const SkRect& dst,
                                 const SkPaint& srcPaint,
                                 SkCanvas::SrcRectConstraint constraint) {
     SkASSERT(false);
 }
@@ skipping 209 matching lines @@
         content.entry()->fContent.writeText(" Tj\n");
     }
     content.entry()->fContent.writeText("ET\n");
 }
 
 void SkPDFDevice::drawVertices(const SkDraw& d, SkCanvas::VertexMode,
                                int vertexCount, const SkPoint verts[],
                                const SkPoint texs[], const SkColor colors[],
                                SkXfermode* xmode, const uint16_t indices[],
                                int indexCount, const SkPaint& paint) {
-    if (d.fClip->isEmpty()) {
+    if (d.fRC->isEmpty()) {
         return;
     }
     // TODO: implement drawVertices
 }
 
 void SkPDFDevice::drawDevice(const SkDraw& d, SkBaseDevice* device,
                              int x, int y, const SkPaint& paint) {
     // our onCreateCompatibleDevice() always creates SkPDFDevice subclasses.
     SkPDFDevice* pdfDevice = static_cast<SkPDFDevice*>(device);
 
@@ skipping 11 matching lines @@
         SkPoint p = d.point + SkPoint::Make(scalarX, scalarY);
         fNamedDestinations.emplace_back(d.nameData.get(), p);
     }
 
     if (pdfDevice->isContentEmpty()) {
         return;
     }
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
-    ScopedContentEntry content(this, d.fClipStack, *d.fClip, matrix, paint);
+    ScopedContentEntry content(this, d.fClipStack, d.fRC->bwRgn(), matrix, paint);
     if (!content.entry()) {
         return;
     }
     if (content.needShape()) {
         SkPath shape;
         shape.addRect(SkRect::MakeXYWH(SkIntToScalar(x), SkIntToScalar(y),
                                        SkIntToScalar(device->width()),
                                        SkIntToScalar(device->height())));
         content.setShape(shape);
     }
@@ skipping 104 matching lines @@
  * 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) {
     if (!origPath.isInverseFillType()) {
         return false;
     }
 
-    if (d.fClip->isEmpty()) {
+    if (d.fRC->isEmpty()) {
         return false;
     }
 
     SkPath modifiedPath;
     SkPath* pathPtr = const_cast<SkPath*>(&origPath);
     SkPaint noInversePaint(paint);
 
     // Merge stroking operations into final path.
     if (SkPaint::kStroke_Style == paint.getStyle() ||
         SkPaint::kStrokeAndFill_Style == paint.getStyle()) {
@@ skipping 15 matching lines @@
     // (clip bounds are given in device space).
     SkRect bounds;
     SkMatrix transformInverse;
     SkMatrix totalMatrix = *d.fMatrix;
     if (prePathMatrix) {
         totalMatrix.preConcat(*prePathMatrix);
     }
     if (!totalMatrix.invert(&transformInverse)) {
         return false;
     }
-    bounds.set(d.fClip->getBounds());
+    bounds.set(d.fRC->getBounds());
     transformInverse.mapRect(&bounds);
 
     // Extend the bounds by the line width (plus some padding)
     // so the edge doesn't cause a visible stroke.
     bounds.outset(paint.getStrokeWidth() + SK_Scalar1,
                   paint.getStrokeWidth() + SK_Scalar1);
 
     if (!calculate_inverse_path(bounds, *pathPtr, &modifiedPath)) {
         return false;
     }
@@ skipping 267 matching lines @@
         // the non-transparent parts of the device and the outlines (shape) of
         // all images and devices drawn.
         drawFormXObjectWithMask(addXObjectResource(srcFormXObject.get()), dst,
                                 &fExistingClipStack, fExistingClipRegion,
                                 SkXfermode::kSrcOver_Mode, true);
     } else {
         sk_sp<SkPDFFormXObject> dstMaskStorage;
         SkPDFFormXObject* dstMask = srcFormXObject.get();
         if (shape != nullptr) {
             // Draw shape into a form-xobject.
+            SkRasterClip rc(clipRegion);
             SkDraw d;
             d.fMatrix = &identity;
-            d.fClip = &clipRegion;
+            d.fRC = &rc;
             d.fClipStack = &clipStack;
             SkPaint filledPaint;
             filledPaint.setColor(SK_ColorBLACK);
             filledPaint.setStyle(SkPaint::kFill_Style);
             this->drawPath(d, *shape, filledPaint, nullptr, true);
 
             dstMaskStorage.reset(createFormXObjectFromDevice());
             dstMask = dstMaskStorage.get();
         }
         drawFormXObjectWithMask(addXObjectResource(dst), dstMask,
@@ skipping 363 matching lines @@
         if (!pdfimage) {
             return;
         }
         fDocument->serialize(pdfimage);  // serialize images early.
         fDocument->canon()->addPDFBitmap(key, pdfimage);
     }
     // TODO(halcanary): addXObjectResource() should take a sk_sp<SkPDFObject>
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(pdfimage.get()),
                                 &content.entry()->fContent);
 }