Add optional sw generated path coverage mask caching

src/gpu/GrSWMaskHelper.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrSWMaskHelper.h"
 
 #include "GrCaps.h"
@@ skipping 81 matching lines @@
     fDraw.fDst      = fPixels;
     fRasterClip.setRect(bounds);
     fDraw.fRC       = &fRasterClip;
     fDraw.fMatrix   = &fMatrix;
     return true;
 }
 
 /**
  * Get a texture (from the texture cache) of the correct size & format.
  */
-GrTexture* GrSWMaskHelper::createTexture() {
+GrTexture* GrSWMaskHelper::createTexture(TextureType textureType) {
     GrSurfaceDesc desc;
     desc.fWidth = fPixels.width();
     desc.fHeight = fPixels.height();
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
-    return fTexProvider->createApproxTexture(desc);
+    if (TextureType::kApproximateFit == textureType) {
+        return fTexProvider->createApproxTexture(desc);
+    } else {
+        return fTexProvider->createTexture(desc, SkBudgeted::kYes);
+    }
 }
 
 /**
  * Move the result of the software mask generation back to the gpu
  */
 void GrSWMaskHelper::toTexture(GrTexture *texture) {
     // Since we're uploading to it, and it's compressed, 'texture' shouldn't
     // have a render target.
     SkASSERT(!texture->asRenderTarget());
 
@@ skipping 12 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 /**
  * Software rasterizes shape to A8 mask and uploads the result to a scratch texture. Returns the
  * resulting texture on success; nullptr on failure.
  */
 GrTexture* GrSWMaskHelper::DrawShapeMaskToTexture(GrTextureProvider* texProvider,
                                                   const GrShape& shape,
                                                   const SkIRect& resultBounds,
                                                   bool antiAlias,
+                                                  TextureType textureType,
                                                   const SkMatrix* matrix) {
     GrSWMaskHelper helper(texProvider);
 
     if (!helper.init(resultBounds, matrix)) {
         return nullptr;
     }
 
     helper.drawShape(shape, SkRegion::kReplace_Op, antiAlias, 0xFF);
 
-    GrTexture* texture(helper.createTexture());
+    GrTexture* texture(helper.createTexture(textureType));
     if (!texture) {
         return nullptr;
     }
 
     helper.toTexture(texture);
 
     return texture;
 }
 
 void GrSWMaskHelper::DrawToTargetWithShapeMask(GrTexture* texture,
                                                GrDrawContext* drawContext,
                                                const GrPaint& paint,
                                                const GrUserStencilSettings& userStencilSettings,
                                                const GrClip& clip,
                                                const SkMatrix& viewMatrix,
-                                               const SkIRect& rect) {
+                                               const SkIPoint& textureOriginInDeviceSpace,
+                                               const SkIRect& deviceSpaceRectToDraw) {
     SkMatrix invert;
     if (!viewMatrix.invert(&invert)) {
         return;
     }
 
-    SkRect dstRect = SkRect::MakeLTRB(SK_Scalar1 * rect.fLeft,
-                                      SK_Scalar1 * rect.fTop,
-                                      SK_Scalar1 * rect.fRight,
-                                      SK_Scalar1 * rect.fBottom);
+    SkRect dstRect = SkRect::Make(deviceSpaceRectToDraw);
 
     // We use device coords to compute the texture coordinates. We take the device coords and apply
     // a translation so that the top-left of the device bounds maps to 0,0, and then a scaling
     // matrix to normalized coords.
     SkMatrix maskMatrix;
     maskMatrix.setIDiv(texture->width(), texture->height());
-    maskMatrix.preTranslate(SkIntToScalar(-rect.fLeft), SkIntToScalar(-rect.fTop));
+    maskMatrix.preTranslate(SkIntToScalar(-textureOriginInDeviceSpace.fX),
+                            SkIntToScalar(-textureOriginInDeviceSpace.fY));
 
     GrPipelineBuilder pipelineBuilder(paint, drawContext->mustUseHWAA(paint));
     pipelineBuilder.setUserStencil(&userStencilSettings);
 
     pipelineBuilder.addCoverageFragmentProcessor(
                          GrSimpleTextureEffect::Make(texture,
                                                      nullptr,
                                                      maskMatrix,
                                                      GrTextureParams::kNone_FilterMode,
                                                      kDevice_GrCoordSet));
 
     SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAFill(paint.getColor(),
                                                                         SkMatrix::I(),
                                                                         dstRect, nullptr, &invert));
     drawContext->drawBatch(pipelineBuilder, clip, batch);
 }