remove 'deprecated' region from SkDraw

src/gpu/SkGpuDevice.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 "SkGpuDevice.h"
 
 #include "GrBlurUtils.h"
@@ skipping 14 matching lines @@
 #include "SkGrPriv.h"
 #include "SkImage_Base.h"
 #include "SkImageCacherator.h"
 #include "SkImageFilter.h"
 #include "SkLayerInfo.h"
 #include "SkMaskFilter.h"
 #include "SkNinePatchIter.h"
 #include "SkPathEffect.h"
 #include "SkPicture.h"
 #include "SkPictureData.h"
+#include "SkRasterClip.h"
 #include "SkRRect.h"
 #include "SkRecord.h"
 #include "SkStroke.h"
 #include "SkSurface.h"
 #include "SkSurface_Gpu.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
 #include "SkVertState.h"
 #include "SkXfermode.h"
 #include "batches/GrRectBatchFactory.h"
@@ skipping 463 matching lines @@
         usePath = true;
     }
 
     if (usePath) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRect(rect);
         GrBlurUtils::drawPathWithMaskFilter(fContext, fDrawContext,
                                             fClip, path, paint,
                                             *draw.fMatrix, nullptr,
-                                            draw.fClip->getBounds(), true);
+                                            draw.fRC->getBounds(), true);
         return;
     }
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
                           this->surfaceProps().isGammaCorrect(), &grPaint)) {
         return;
     }
 
     GrStrokeInfo strokeInfo(paint);
@@ skipping 17 matching lines @@
 
     GrStrokeInfo strokeInfo(paint);
     if (paint.getMaskFilter()) {
         // try to hit the fast path for drawing filtered round rects
 
         SkRRect devRRect;
         if (rect.transform(*draw.fMatrix, &devRRect)) {
             if (devRRect.allCornersCircular()) {
                 SkRect maskRect;
                 if (paint.getMaskFilter()->canFilterMaskGPU(devRRect,
-                                                            draw.fClip->getBounds(),
+                                                            draw.fRC->getBounds(),
                                                             *draw.fMatrix,
                                                             &maskRect)) {
                     SkIRect finalIRect;
                     maskRect.roundOut(&finalIRect);
-                    if (draw.fClip->quickReject(finalIRect)) {
+                    if (draw.fRC->quickReject(finalIRect)) {
                         // clipped out
                         return;
                     }
                     if (paint.getMaskFilter()->directFilterRRectMaskGPU(fContext->textureProvider(),
                                                                         fDrawContext,
                                                                         &grPaint,
                                                                         fClip,
                                                                         *draw.fMatrix,
                                                                         strokeInfo,
                                                                         devRRect)) {
                         return;
                     }
                 }
 
             }
         }
     }
 
     if (paint.getMaskFilter() || paint.getPathEffect()) {
         // The only mask filter the native rrect drawing code could've handle was taken
         // care of above.
         // A path effect will presumably transform this rrect into something else.
         SkPath path;
         path.setIsVolatile(true);
         path.addRRect(rect);
         GrBlurUtils::drawPathWithMaskFilter(fContext, fDrawContext,
                                             fClip, path, paint,
                                             *draw.fMatrix, nullptr,
-                                            draw.fClip->getBounds(), true);
+                                            draw.fRC->getBounds(), true);
         return;
     }
 
     SkASSERT(!strokeInfo.isDashed());
 
     fDrawContext->drawRRect(fClip, grPaint, *draw.fMatrix, rect, strokeInfo);
 }
 
 
 void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
@@ skipping 25 matching lines @@
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRRect(outer);
     path.addRRect(inner);
     path.setFillType(SkPath::kEvenOdd_FillType);
 
     GrBlurUtils::drawPathWithMaskFilter(fContext, fDrawContext,
                                         fClip, path, paint,
                                         *draw.fMatrix, nullptr,
-                                        draw.fClip->getBounds(), true);
+                                        draw.fRC->getBounds(), true);
 }
 
 
 /////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawOval", fContext);
     CHECK_SHOULD_DRAW(draw);
 
@@ skipping 49 matching lines @@
             return;
         }
     }
 
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPath", fContext);
 
     GrBlurUtils::drawPathWithMaskFilter(fContext, fDrawContext,
                                         fClip, origSrcPath, paint,
                                         *draw.fMatrix, prePathMatrix,
-                                        draw.fClip->getBounds(), pathIsMutable);
+                                        draw.fRC->getBounds(), pathIsMutable);
 }
 
 static const int kBmpSmallTileSize = 1 << 10;
 
 static inline int get_tile_count(const SkIRect& srcRect, int tileSize)  {
     int tilesX = (srcRect.fRight / tileSize) - (srcRect.fLeft / tileSize) + 1;
     int tilesY = (srcRect.fBottom / tileSize) - (srcRect.fTop / tileSize) + 1;
     return tilesX * tilesY;
 }
 
@@ skipping 952 matching lines @@
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
                           this->surfaceProps().isGammaCorrect(), &grPaint)) {
         return;
     }
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawText(fClip, grPaint, paint, *draw.fMatrix,
-                           (const char *)text, byteLength, x, y, draw.fClip->getBounds());
+                           (const char *)text, byteLength, x, y, draw.fRC->getBounds());
 }
 
 void SkGpuDevice::drawPosText(const SkDraw& draw, const void* text, size_t byteLength,
                               const SkScalar pos[], int scalarsPerPos,
                               const SkPoint& offset, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPosText", fContext);
     CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
                           this->surfaceProps().isGammaCorrect(), &grPaint)) {
         return;
     }
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawPosText(fClip, grPaint, paint, *draw.fMatrix,
                               (const char *)text, byteLength, pos, scalarsPerPos, offset,
-                              draw.fClip->getBounds());
+                              draw.fRC->getBounds());
 }
 
 void SkGpuDevice::drawTextBlob(const SkDraw& draw, const SkTextBlob* blob, SkScalar x, SkScalar y,
                                const SkPaint& paint, SkDrawFilter* drawFilter) {
     ASSERT_SINGLE_OWNER
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawTextBlob", fContext);
     CHECK_SHOULD_DRAW(draw);
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawTextBlob(fClip, paint, *draw.fMatrix,
-                               blob, x, y, drawFilter, draw.fClip->getBounds());
+                               blob, x, y, drawFilter, draw.fRC->getBounds());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkGpuDevice::onShouldDisableLCD(const SkPaint& paint) const {
     return GrTextUtils::ShouldDisableLCD(paint);
 }
 
 void SkGpuDevice::flush() {
     ASSERT_SINGLE_OWNER
@@ skipping 116 matching lines @@
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif