remove 'deprecated' region from SkDraw

src/xps/SkXPSDevice.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 "SkTypes.h"
 #if defined(SK_BUILD_FOR_WIN32)
 
@@ skipping 17 matching lines @@
 #include "SkGeometry.h"
 #include "SkGlyphCache.h"
 #include "SkHRESULT.h"
 #include "SkImageEncoder.h"
 #include "SkIStream.h"
 #include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkPathEffect.h"
 #include "SkPathOps.h"
 #include "SkPoint.h"
+#include "SkRasterClip.h"
 #include "SkRasterizer.h"
 #include "SkSFNTHeader.h"
 #include "SkShader.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
 #include "SkTLazy.h"
 #include "SkTScopedComPtr.h"
 #include "SkTTCFHeader.h"
 #include "SkTypefacePriv.h"
@@ skipping 1155 matching lines @@
     SkPath path;
     path.addRRect(rr);
     this->drawPath(d, path, paint, nullptr, true);
 }
 
 void SkXPSDevice::internalDrawRect(const SkDraw& d,
                                    const SkRect& r,
                                    bool transformRect,
                                    const SkPaint& paint) {
     //Exit early if there is nothing to draw.
-    if (d.fClip->isEmpty() ||
+    if (d.fRC->isEmpty() ||
         (paint.getAlpha() == 0 && paint.getXfermode() == nullptr)) {
         return;
     }
 
     //Path the rect if we can't optimize it.
     if (rect_must_be_pathed(paint, *d.fMatrix)) {
         SkPath tmp;
         tmp.addRect(r);
         tmp.setFillType(SkPath::kWinding_FillType);
         this->drawPath(d, tmp, paint, nullptr, true);
@@ skipping 295 matching lines @@
 }
 
 void SkXPSDevice::drawPath(const SkDraw& d,
                            const SkPath& platonicPath,
                            const SkPaint& origPaint,
                            const SkMatrix* prePathMatrix,
                            bool pathIsMutable) {
     SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
 
     // nothing to draw
-    if (d.fClip->isEmpty() ||
+    if (d.fRC->isEmpty() ||
         (paint->getAlpha() == 0 && paint->getXfermode() == nullptr)) {
         return;
     }
 
     SkPath modifiedPath;
     const bool paintHasPathEffect = paint->getPathEffect()
                                  || paint->getStyle() != SkPaint::kFill_Style;
 
     //Apply pre-path matrix [Platonic-path -> Skeletal-path].
     SkMatrix matrix = *d.fMatrix;
@@ skipping 62 matching lines @@
                         &fill,
                         &stroke));
 
     //Rasterizer
     if (rasterizer) {
         SkIRect clipIRect;
         SkVector ppuScale;
         this->convertToPpm(filter,
                            &matrix,
                            &ppuScale,
-                           d.fClip->getBounds(),
+                           d.fRC->getBounds(),
                            &clipIRect);
 
         SkMask* mask = nullptr;
 
         //[Fillable-path -> Mask]
         SkMask rasteredMask;
         if (rasterizer->rasterize(
                 *fillablePath,
                 matrix,
                 &clipIRect,
@@ skipping 17 matching lines @@
         return;
     }
 
     //Mask filter
     if (filter) {
         SkIRect clipIRect;
         SkVector ppuScale;
         this->convertToPpm(filter,
                            &matrix,
                            &ppuScale,
-                           d.fClip->getBounds(),
+                           d.fRC->getBounds(),
                            &clipIRect);
 
         //[Fillable-path -> Pixel-path]
         SkPath* pixelPath = pathIsMutable ? fillablePath : &modifiedPath;
         fillablePath->transform(matrix, pixelPath);
 
         SkMask* mask = nullptr;
 
         //[Pixel-path -> Mask]
         SkMask rasteredMask;
@@ skipping 97 matching lines @@
     //Add the path to the active visual collection.
     SkTScopedComPtr<IXpsOMVisualCollection> currentVisuals;
     HRVM(this->fCurrentXpsCanvas->GetVisuals(&currentVisuals),
          "Could not get current visuals for shaded path.");
     HRVM(currentVisuals->Append(shadedPath.get()),
          "Could not add shaded path to current visuals.");
 }
 
 HRESULT SkXPSDevice::clip(IXpsOMVisual* xpsVisual, const SkDraw& d) {
     SkPath clipPath;
-    SkAssertResult(d.fClip->getBoundaryPath(&clipPath));
+    if (d.fRC->isBW()) {
+        SkAssertResult(d.fRC->bwRgn().getBoundaryPath(&clipPath));
+    } else {
+        // Don't have a way to turn a AAClip into a path, so we just use the bounds.
+        // TODO: consider using fClipStack instead?
+        clipPath.addRect(SkRect::Make(d.fRC->getBounds()));
+    }
 
     return this->clipToPath(xpsVisual, clipPath, XPS_FILL_RULE_EVENODD);
 }
 HRESULT SkXPSDevice::clipToPath(IXpsOMVisual* xpsVisual,
                                 const SkPath& clipPath,
                                 XPS_FILL_RULE fillRule) {
     //Create the geometry.
     SkTScopedComPtr<IXpsOMGeometry> clipGeometry;
     HRM(this->fXpsFactory->CreateGeometry(&clipGeometry),
         "Could not create clip geometry.");
@@ skipping 11 matching lines @@
     HRM(clipGeometry->SetFillRule(fillRule),
         "Could not set fill rule.");
     HRM(xpsVisual->SetClipGeometryLocal(clipGeometry.get()),
         "Could not set clip geometry.");
 
     return S_OK;
 }
 
 void SkXPSDevice::drawBitmap(const SkDraw& d, const SkBitmap& bitmap,
                              const SkMatrix& matrix, const SkPaint& paint) {
-    if (d.fClip->isEmpty()) {
+    if (d.fRC->isEmpty()) {
         return;
     }
 
     SkIRect srcRect;
     srcRect.set(0, 0, bitmap.width(), bitmap.height());
 
     //Create the new shaded path.
     SkTScopedComPtr<IXpsOMPath> shadedPath;
     HRVM(this->fXpsFactory->CreatePath(&shadedPath),
          "Could not create path for bitmap.");
@@ skipping 448 matching lines @@
         //SkXPSDevice* dev = new SkXPSDevice(this);
         //SkSize s = SkSize::Make(width, height);
         //dev->BeginCanvas(s, s, SkMatrix::I());
         //return dev;
     }
 #endif
     return new SkXPSDevice(this->fXpsFactory.get());
 }
 
 #endif//defined(SK_BUILD_FOR_WIN32)