Revert of Pass clip to context

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 "GrBitmapTextContext.h"
@@ skipping 202 matching lines @@
     return SkNEW_ARGS(SkGpuDevice, (rt, props, flags));
 }
 
 SkGpuDevice::~SkGpuDevice() {
     if (fDrawProcs) {
         delete fDrawProcs;
     }
 
     delete fTextContext;
 
+    if (fContext->getClip() == &fClipData) {
+        fContext->setClip(NULL);
+    }
+
     fRenderTarget->unref();
     fContext->unref();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkGpuDevice::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
                                int x, int y) {
     DO_DEFERRED_CLEAR();
 
@@ skipping 37 matching lines @@
 
 void SkGpuDevice::onAttachToCanvas(SkCanvas* canvas) {
     INHERITED::onAttachToCanvas(canvas);
 
     // Canvas promises that this ptr is valid until onDetachFromCanvas is called
     fClipStack.reset(SkRef(canvas->getClipStack()));
 }
 
 void SkGpuDevice::onDetachFromCanvas() {
     INHERITED::onDetachFromCanvas();
-    fClip.reset();
+    fClipData.reset();
     fClipStack.reset(NULL);
 }
 
 // call this every draw call, to ensure that the context reflects our state,
 // and not the state from some other canvas/device
 void SkGpuDevice::prepareDraw(const SkDraw& draw) {
     SkASSERT(fClipStack.get());
 
     SkASSERT(draw.fClipStack && draw.fClipStack == fClipStack);
 
-    fClip.setClipStack(fClipStack, &this->getOrigin());
+    fClipData.setClipStack(fClipStack, &this->getOrigin());
+
+    fContext->setClip(&fClipData);
 
     DO_DEFERRED_CLEAR();
 }
 
 GrRenderTarget* SkGpuDevice::accessRenderTarget() {
     DO_DEFERRED_CLEAR();
     return fRenderTarget;
 }
 
 void SkGpuDevice::clearAll() {
@@ skipping 51 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPaint", fContext);
 
     GrPaint grPaint;
     SkPaint2GrPaintShader(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint);
 
-    fContext->drawPaint(fRenderTarget, fClip, grPaint, *draw.fMatrix);
+    fContext->drawPaint(fRenderTarget, grPaint, *draw.fMatrix);
 }
 
 // must be in SkCanvas::PointMode order
 static const GrPrimitiveType gPointMode2PrimtiveType[] = {
     kPoints_GrPrimitiveType,
     kLines_GrPrimitiveType,
     kLineStrip_GrPrimitiveType
 };
 
 void SkGpuDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
                              size_t count, const SkPoint pts[], const SkPaint& paint) {
     CHECK_FOR_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw);
 
     SkScalar width = paint.getStrokeWidth();
     if (width < 0) {
         return;
     }
 
     if (paint.getPathEffect() && 2 == count && SkCanvas::kLines_PointMode == mode) {
         GrStrokeInfo strokeInfo(paint, SkPaint::kStroke_Style);
         GrPaint grPaint;
         SkPaint2GrPaintShader(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint);
         SkPath path;
         path.setIsVolatile(true);
         path.moveTo(pts[0]);
         path.lineTo(pts[1]);
-        fContext->drawPath(fRenderTarget, fClip, grPaint, *draw.fMatrix, path, strokeInfo);
+        fContext->drawPath(fRenderTarget, grPaint, *draw.fMatrix, path, strokeInfo);
         return;
     }
 
     // we only handle hairlines and paints without path effects or mask filters,
     // else we let the SkDraw call our drawPath()
     if (width > 0 || paint.getPathEffect() || paint.getMaskFilter()) {
         draw.drawPoints(mode, count, pts, paint, true);
         return;
     }
 
     GrPaint grPaint;
     SkPaint2GrPaintShader(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint);
 
     fContext->drawVertices(fRenderTarget,
-                           fClip,
                            grPaint,
                            *draw.fMatrix,
                            gPointMode2PrimtiveType[mode],
                            SkToS32(count),
                            (SkPoint*)pts,
                            NULL,
                            NULL,
                            NULL,
                            0);
 }
@@ skipping 50 matching lines @@
         SkPath path;
         path.setIsVolatile(true);
         path.addRect(rect);
         this->drawPath(draw, path, paint, NULL, true);
         return;
     }
 
     GrPaint grPaint;
     SkPaint2GrPaintShader(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint);
 
-    fContext->drawRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, rect, &strokeInfo);
+    fContext->drawRect(fRenderTarget, grPaint, *draw.fMatrix, rect, &strokeInfo);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rect,
                             const SkPaint& paint) {
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawRRect", fContext);
     CHECK_FOR_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw);
 
@@ skipping 14 matching lines @@
                                                             &maskRect)) {
                     SkIRect finalIRect;
                     maskRect.roundOut(&finalIRect);
                     if (draw.fClip->quickReject(finalIRect)) {
                         // clipped out
                         return;
                     }
                     if (paint.getMaskFilter()->directFilterRRectMaskGPU(fContext,
                                                                         fRenderTarget,
                                                                         &grPaint,
-                                                                        fClip,
                                                                         *draw.fMatrix,
                                                                         strokeInfo.getStrokeRec(),
                                                                         devRRect)) {
                         return;
                     }
                 }
 
             }
         }
 
@@ skipping 12 matching lines @@
 
 
     if (usePath) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRRect(rect);
         this->drawPath(draw, path, paint, NULL, true);
         return;
     }
 
-    fContext->drawRRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, rect, strokeInfo);
+    fContext->drawRRect(fRenderTarget, grPaint, *draw.fMatrix, rect, strokeInfo);
 }
 
 void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
                              const SkRRect& inner, const SkPaint& paint) {
     SkStrokeRec stroke(paint);
     if (stroke.isFillStyle()) {
 
         CHECK_FOR_ANNOTATION(paint);
         CHECK_SHOULD_DRAW(draw);
 
         GrPaint grPaint;
         SkPaint2GrPaintShader(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint);
 
         if (NULL == paint.getMaskFilter() && NULL == paint.getPathEffect()) {
-            fContext->drawDRRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, outer, inner);
+            fContext->drawDRRect(fRenderTarget, grPaint, *draw.fMatrix, outer, inner);
             return;
         }
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRRect(outer);
     path.addRRect(inner);
     path.setFillType(SkPath::kEvenOdd_FillType);
 
@@ skipping 26 matching lines @@
         SkPath path;
         path.setIsVolatile(true);
         path.addOval(oval);
         this->drawPath(draw, path, paint, NULL, true);
         return;
     }
 
     GrPaint grPaint;
     SkPaint2GrPaintShader(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint);
 
-    fContext->drawOval(fRenderTarget, fClip, grPaint, *draw.fMatrix, oval, strokeInfo);
+    fContext->drawOval(fRenderTarget, grPaint, *draw.fMatrix, oval, strokeInfo);
 }
 
 #include "SkMaskFilter.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // helpers for applying mask filters
 namespace {
 
 // Draw a mask using the supplied paint. Since the coverage/geometry
 // is already burnt into the mask this boils down to a rect draw.
 // Return true if the mask was successfully drawn.
 bool draw_mask(GrContext* context,
                GrRenderTarget* rt,
-               const GrClip& clip,
                const SkMatrix& viewMatrix,
                const SkRect& maskRect,
                GrPaint* grp,
                GrTexture* mask) {
     SkMatrix matrix;
     matrix.setTranslate(-maskRect.fLeft, -maskRect.fTop);
     matrix.postIDiv(mask->width(), mask->height());
 
     grp->addCoverageProcessor(GrSimpleTextureEffect::Create(mask, matrix,
                                                             kDevice_GrCoordSet))->unref();
 
     SkMatrix inverse;
     if (!viewMatrix.invert(&inverse)) {
         return false;
     }
-    context->drawNonAARectWithLocalMatrix(rt, clip, *grp, SkMatrix::I(), maskRect, inverse);
+    context->drawNonAARectWithLocalMatrix(rt, *grp, SkMatrix::I(), maskRect, inverse);
     return true;
 }
 
 bool draw_with_mask_filter(GrContext* context,
                            GrRenderTarget* rt,
-                           const GrClip& clipData,
                            const SkMatrix& viewMatrix,
                            const SkPath& devPath,
                            SkMaskFilter* filter,
                            const SkRegion& clip,
                            GrPaint* grp,
                            SkPaint::Style style) {
     SkMask  srcM, dstM;
 
     if (!SkDraw::DrawToMask(devPath, &clip.getBounds(), filter, &viewMatrix, &srcM,
                             SkMask::kComputeBoundsAndRenderImage_CreateMode, style)) {
@@ skipping 21 matching lines @@
     SkAutoTUnref<GrTexture> texture(
         context->refScratchTexture(desc, GrContext::kApprox_ScratchTexMatch));
     if (!texture) {
         return false;
     }
     texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                                dstM.fImage, dstM.fRowBytes);
 
     SkRect maskRect = SkRect::Make(dstM.fBounds);
 
-    return draw_mask(context, rt, clipData, viewMatrix, maskRect, grp, texture);
+    return draw_mask(context, rt, viewMatrix, maskRect, grp, texture);
 }
 
 // Create a mask of 'devPath' and place the result in 'mask'.
 GrTexture* create_mask_GPU(GrContext* context,
                            GrRenderTarget* rt,
                            const SkRect& maskRect,
                            const SkPath& devPath,
                            const GrStrokeInfo& strokeInfo,
                            bool doAA,
                            int sampleCnt) {
@@ skipping 11 matching lines @@
         desc.fConfig = kAlpha_8_GrPixelConfig;
     }
 
     GrTexture* mask = context->refScratchTexture(desc,GrContext::kApprox_ScratchTexMatch);
     if (NULL == mask) {
         return NULL;
     }
 
     SkRect clipRect = SkRect::MakeWH(maskRect.width(), maskRect.height());
 
+    GrContext::AutoClip ac(context, clipRect);
+
     context->clear(NULL, 0x0, true, mask->asRenderTarget());
 
     GrPaint tempPaint;
     tempPaint.setAntiAlias(doAA);
     tempPaint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);
 
-    // setup new clip
-    GrClip clip(clipRect);
-
     // Draw the mask into maskTexture with the path's top-left at the origin using tempPaint.
     SkMatrix translate;
     translate.setTranslate(-maskRect.fLeft, -maskRect.fTop);
-    context->drawPath(mask->asRenderTarget(), clip, tempPaint, translate, devPath, strokeInfo);
+    context->drawPath(mask->asRenderTarget(), tempPaint, translate, devPath, strokeInfo);
     return mask;
 }
 
 SkBitmap wrap_texture(GrTexture* texture) {
     SkBitmap result;
     result.setInfo(texture->surfacePriv().info());
     result.setPixelRef(SkNEW_ARGS(SkGrPixelRef, (result.info(), texture)))->unref();
     return result;
 }
 
@@ skipping 84 matching lines @@
             SkIRect finalIRect;
             maskRect.roundOut(&finalIRect);
             if (draw.fClip->quickReject(finalIRect)) {
                 // clipped out
                 return;
             }
 
             if (paint.getMaskFilter()->directFilterMaskGPU(fContext,
                                                            fRenderTarget,
                                                            &grPaint,
-                                                           fClip,
                                                            viewMatrix,
                                                            stroke,
                                                            *devPathPtr)) {
                 // the mask filter was able to draw itself directly, so there's nothing
                 // left to do.
                 return;
             }
 
 
             SkAutoTUnref<GrTexture> mask(create_mask_GPU(fContext,
                                                          fRenderTarget,
                                                          maskRect,
                                                          *devPathPtr,
                                                          strokeInfo,
                                                          grPaint.isAntiAlias(),
                                                          fRenderTarget->numSamples()));
             if (mask) {
                 GrTexture* filtered;
 
                 if (paint.getMaskFilter()->filterMaskGPU(mask, viewMatrix, maskRect, &filtered, true)) {
                     // filterMaskGPU gives us ownership of a ref to the result
                     SkAutoTUnref<GrTexture> atu(filtered);
-                    if (draw_mask(fContext,
-                                  fRenderTarget,
-                                  fClip,
-                                  viewMatrix,
-                                  maskRect,
-                                  &grPaint,
+                    if (draw_mask(fContext, fRenderTarget, viewMatrix, maskRect, &grPaint,
                                   filtered)) {
                         // This path is completely drawn
                         return;
                     }
                 }
             }
         }
 
         // draw the mask on the CPU - this is a fallthrough path in case the
         // GPU path fails
         SkPaint::Style style = stroke.isHairlineStyle() ? SkPaint::kStroke_Style :
                                                           SkPaint::kFill_Style;
-        draw_with_mask_filter(fContext, fRenderTarget, fClip, viewMatrix, *devPathPtr,
+        draw_with_mask_filter(fContext, fRenderTarget, viewMatrix, *devPathPtr,
                               paint.getMaskFilter(), *draw.fClip, &grPaint, style);
         return;
     }
 
-    fContext->drawPath(fRenderTarget, fClip, grPaint, viewMatrix, *pathPtr, strokeInfo);
+    fContext->drawPath(fRenderTarget, grPaint, viewMatrix, *pathPtr, strokeInfo);
 }
 
 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 12 matching lines @@
         return kBmpSmallTileSize;
     } else {
         return maxTileSize;
     }
 }
 
 // Given a bitmap, an optional src rect, and a context with a clip and matrix determine what
 // pixels from the bitmap are necessary.
 static void determine_clipped_src_rect(const GrContext* context,
                                        const GrRenderTarget* rt,
-                                       const GrClip& clip,
                                        const SkMatrix& viewMatrix,
                                        const SkBitmap& bitmap,
                                        const SkRect* srcRectPtr,
                                        SkIRect* clippedSrcIRect) {
-    clip.getConservativeBounds(rt, clippedSrcIRect, NULL);
+    const GrClip* clip = context->getClip();
+    clip->getConservativeBounds(rt, clippedSrcIRect, NULL);
     SkMatrix inv;
     if (!viewMatrix.invert(&inv)) {
         clippedSrcIRect->setEmpty();
         return;
     }
     SkRect clippedSrcRect = SkRect::Make(*clippedSrcIRect);
     inv.mapRect(&clippedSrcRect);
     if (srcRectPtr) {
         // we've setup src space 0,0 to map to the top left of the src rect.
         clippedSrcRect.offset(srcRectPtr->fLeft, srcRectPtr->fTop);
@@ skipping 16 matching lines @@
                                    int maxTileSize,
                                    int* tileSize,
                                    SkIRect* clippedSrcRect) const {
     // if bitmap is explictly texture backed then just use the texture
     if (bitmap.getTexture()) {
         return false;
     }
 
     // if it's larger than the max tile size, then we have no choice but tiling.
     if (bitmap.width() > maxTileSize || bitmap.height() > maxTileSize) {
-        determine_clipped_src_rect(fContext, fRenderTarget, fClip, viewMatrix, bitmap,
-                                   srcRectPtr, clippedSrcRect);
+        determine_clipped_src_rect(fContext, fRenderTarget, viewMatrix, bitmap, srcRectPtr,
+                                   clippedSrcRect);
         *tileSize = determine_tile_size(bitmap, *clippedSrcRect, maxTileSize);
         return true;
     }
 
     if (bitmap.width() * bitmap.height() < 4 * kBmpSmallTileSize * kBmpSmallTileSize) {
         return false;
     }
 
     // if the entire texture is already in our cache then no reason to tile it
     if (GrIsBitmapInCache(fContext, bitmap, &params)) {
         return false;
     }
 
     // At this point we know we could do the draw by uploading the entire bitmap
     // as a texture. However, if the texture would be large compared to the
     // cache size and we don't require most of it for this draw then tile to
     // reduce the amount of upload and cache spill.
 
     // assumption here is that sw bitmap size is a good proxy for its size as
     // a texture
     size_t bmpSize = bitmap.getSize();
     size_t cacheSize;
     fContext->getResourceCacheLimits(NULL, &cacheSize);
     if (bmpSize < cacheSize / 2) {
         return false;
     }
 
     // Figure out how much of the src we will need based on the src rect and clipping.
-    determine_clipped_src_rect(fContext, fRenderTarget, fClip, viewMatrix, bitmap, srcRectPtr,
+    determine_clipped_src_rect(fContext, fRenderTarget, viewMatrix, bitmap, srcRectPtr,
                                clippedSrcRect);
     *tileSize = kBmpSmallTileSize; // already know whole bitmap fits in one max sized tile.
     size_t usedTileBytes = get_tile_count(*clippedSrcRect, kBmpSmallTileSize) *
                            kBmpSmallTileSize * kBmpSmallTileSize;
 
     return usedTileBytes < 2 * bmpSize;
 }
 
 void SkGpuDevice::drawBitmap(const SkDraw& origDraw,
                              const SkBitmap& bitmap,
@@ skipping 453 matching lines @@
 
     // Construct a GrPaint by setting the bitmap texture as the first effect and then configuring
     // the rest from the SkPaint.
     GrPaint grPaint;
     grPaint.addColorProcessor(fp);
     bool alphaOnly = !(kAlpha_8_SkColorType == bitmap.colorType());
     GrColor paintColor = (alphaOnly) ? SkColor2GrColorJustAlpha(paint.getColor()) :
                                        SkColor2GrColor(paint.getColor());
     SkPaint2GrPaintNoShader(this->context(), fRenderTarget, paint, paintColor, false, &grPaint);
 
-    fContext->drawNonAARectToRect(fRenderTarget, fClip, grPaint, viewMatrix, dstRect,
-                                  paintRect);
+    fContext->drawNonAARectToRect(fRenderTarget, grPaint, viewMatrix, dstRect, paintRect);
 }
 
 bool SkGpuDevice::filterTexture(GrContext* context, GrTexture* texture,
                                 const SkImageFilter* filter,
                                 const SkImageFilter::Context& ctx,
                                 SkBitmap* result, SkIPoint* offset) {
     SkASSERT(filter);
 
     // FIXME: plumb actual surface props such that we don't have to lie about the flags here
     //        (https://code.google.com/p/skia/issues/detail?id=3148).
     SkDeviceImageFilterProxy proxy(this, SkSurfaceProps(0, getLeakyProperties().pixelGeometry()));
 
     if (filter->canFilterImageGPU()) {
+        // Set the clip wide open and the matrix to identity.
+        GrContext::AutoWideOpenIdentityDraw awo(context);
         return filter->filterImageGPU(&proxy, wrap_texture(texture), ctx, result, offset);
     } else {
         return false;
     }
 }
 
 void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
                              int left, int top, const SkPaint& paint) {
     // drawSprite is defined to be in device coords.
     CHECK_SHOULD_DRAW(draw);
@@ skipping 35 matching lines @@
         }
     }
 
     GrPaint grPaint;
     grPaint.addColorTextureProcessor(texture, SkMatrix::I());
 
     SkPaint2GrPaintNoShader(this->context(), fRenderTarget, paint,
                             SkColor2GrColorJustAlpha(paint.getColor()), false, &grPaint);
 
     fContext->drawNonAARectToRect(fRenderTarget,
-                                  fClip,
                                   grPaint,
                                   SkMatrix::I(),
                                   SkRect::MakeXYWH(SkIntToScalar(left),
                                                    SkIntToScalar(top),
                                                    SkIntToScalar(w),
                                                    SkIntToScalar(h)),
                                   SkRect::MakeXYWH(0,
                                                    0,
                                                    SK_Scalar1 * w / texture->width(),
                                                    SK_Scalar1 * h / texture->height()));
@@ skipping 102 matching lines @@
     SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(x),
                                       SkIntToScalar(y),
                                       SkIntToScalar(w),
                                       SkIntToScalar(h));
 
     // The device being drawn may not fill up its texture (e.g. saveLayer uses approximate
     // scratch texture).
     SkRect srcRect = SkRect::MakeWH(SK_Scalar1 * w / devTex->width(),
                                     SK_Scalar1 * h / devTex->height());
 
-    fContext->drawNonAARectToRect(fRenderTarget, fClip, grPaint, SkMatrix::I(), dstRect,
-                                  srcRect);
+    fContext->drawNonAARectToRect(fRenderTarget, grPaint, SkMatrix::I(), dstRect, srcRect);
 }
 
 bool SkGpuDevice::canHandleImageFilter(const SkImageFilter* filter) {
     return filter->canFilterImageGPU();
 }
 
 bool SkGpuDevice::filterImage(const SkImageFilter* filter, const SkBitmap& src,
                               const SkImageFilter::Context& ctx,
                               SkBitmap* result, SkIPoint* offset) {
     // want explicitly our impl, so guard against a subclass of us overriding it
@@ skipping 113 matching lines @@
         for (int i = 0; i < vertexCount; ++i) {
             color = colors[i];
             if (paint.getAlpha() != 255) {
                 color = SkColorSetA(color, SkMulDiv255Round(SkColorGetA(color), paint.getAlpha()));
             }
             convertedColors[i] = SkColor2GrColor(color);
         }
         colors = convertedColors.get();
     }
     fContext->drawVertices(fRenderTarget,
-                           fClip,
                            grPaint,
                            *draw.fMatrix,
                            primType,
                            vertexCount,
                            vertices,
                            texs,
                            colors,
                            outIndices,
                            indexCount);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawText(const SkDraw& draw, const void* text,
                            size_t byteLength, SkScalar x, SkScalar y,
                            const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawText", fContext);
 
     GrPaint grPaint;
     SkPaint2GrPaintShader(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint);
 
     SkDEBUGCODE(this->validate();)
 
-    if (!fTextContext->drawText(fRenderTarget, fClip, grPaint, paint, *draw.fMatrix,
-                                (const char *)text, byteLength, x, y)) {
+    if (!fTextContext->drawText(fRenderTarget, grPaint, paint, *draw.fMatrix, (const char *)text,
+                                byteLength, x, y)) {
         // this will just call our drawPath()
         draw.drawText_asPaths((const char*)text, byteLength, x, y, paint);
     }
 }
 
 void SkGpuDevice::drawPosText(const SkDraw& draw, const void* text, size_t byteLength,
                               const SkScalar pos[], int scalarsPerPos,
                               const SkPoint& offset, const SkPaint& paint) {
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPosText", fContext);
     CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
     SkPaint2GrPaintShader(this->context(), fRenderTarget, paint, *draw.fMatrix, true, &grPaint);
 
     SkDEBUGCODE(this->validate();)
 
-    if (!fTextContext->drawPosText(fRenderTarget, fClip, grPaint, paint, *draw.fMatrix,
-                                   (const char *)text, byteLength, pos, scalarsPerPos, offset)) {
+    if (!fTextContext->drawPosText(fRenderTarget, grPaint, paint, *draw.fMatrix, (const char *)text,
+                                   byteLength, pos, scalarsPerPos, offset)) {
         // this will just call our drawPath()
         draw.drawPosText_asPaths((const char*)text, byteLength, pos, scalarsPerPos, offset, paint);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkGpuDevice::onShouldDisableLCD(const SkPaint& paint) const {
     if (paint.getShader() ||
         !SkXfermode::IsMode(paint.getXfermode(), SkXfermode::kSrcOver_Mode) ||
@@ skipping 118 matching lines @@
 #endif
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif