In SkGpuDevice;drawTextureAdjuster perform texture w/h divide in texture matrix

src/gpu/SkGpuDevice_drawTexture.cpp

 /*
  * Copyright 2015 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 102 matching lines @@
                                           const SkRect& clippedDstRect,
                                           SkCanvas::SrcRectConstraint constraint,
                                           const SkMatrix& viewMatrix,
                                           const SkMatrix& srcToDstMatrix,
                                           const GrClip& clip,
                                           const SkPaint& paint) {
     // Specifying the texture coords as local coordinates is an attempt to enable more batching
     // by not baking anything about the srcRect, dstRect, or viewMatrix, into the texture FP. In
     // the future this should be an opaque optimization enabled by the combination of batch/GP and
     // FP.
-    const SkMatrix* textureFPMatrix;
-    SkMatrix tempMatrix;
+    SkMatrix textureFPMatrix;
     const SkMaskFilter* mf = paint.getMaskFilter();
     GrTexture* texture = adjuster->originalTexture();
     // The shader expects proper local coords, so we can't replace local coords with texture coords
     // if the shader will be used. If we have a mask filter we will change the underlying geometry
     // that is rendered.
     bool canUseTextureCoordsAsLocalCoords = !use_shader(alphaTexture, paint) && !mf;
     if (canUseTextureCoordsAsLocalCoords) {
-        textureFPMatrix = &SkMatrix::I();
+        textureFPMatrix.setIDiv(texture->width(), texture->height());
     } else {
-        if (!srcToDstMatrix.invert(&tempMatrix)) {
+        if (!srcToDstMatrix.invert(&textureFPMatrix)) {
             return;
         }
-        tempMatrix.postIDiv(texture->width(), texture->height());
-        textureFPMatrix = &tempMatrix;
+        textureFPMatrix.postIDiv(texture->width(), texture->height());
     }
 
     bool doBicubic;
     GrTextureParams::FilterMode fm =
         GrSkFilterQualityToGrFilterMode(paint.getFilterQuality(), viewMatrix, srcToDstMatrix,
                                         &doBicubic);
     const GrTextureParams::FilterMode* filterMode = doBicubic ? nullptr : &fm;
 
     GrTextureAdjuster::FilterConstraint constraintMode;
     if (SkCanvas::kFast_SrcRectConstraint == constraint) {
         constraintMode = GrTextureAdjuster::kNo_FilterConstraint;
     } else {
         constraintMode = GrTextureAdjuster::kYes_FilterConstraint;
     }
     
     // If we have to outset for AA then we will generate texture coords outside the src rect. The
     // same happens for any mask filter that extends the bounds rendered in the dst.
     // This is conservative as a mask filter does not have to expand the bounds rendered.
     bool coordsAllInsideSrcRect = !paint.isAntiAlias() && !mf;
 
     SkAutoTUnref<const GrFragmentProcessor> fp(adjuster->createFragmentProcessor(
-        *textureFPMatrix, clippedSrcRect, constraintMode, coordsAllInsideSrcRect, filterMode));
+        textureFPMatrix, clippedSrcRect, constraintMode, coordsAllInsideSrcRect, filterMode));
     if (!fp) {
         return;
     }
     fp.reset(mix_texture_fp_with_paint_color_and_shader(fp, alphaTexture, this->context(),
                                                         viewMatrix, paint));
     GrPaint grPaint;
     if (!SkPaintToGrPaintReplaceShader(fContext, paint, fp, &grPaint)) {
         return;
     }
 
     if (canUseTextureCoordsAsLocalCoords) {
-        SkRect localRect;
-        localRect.fLeft = clippedSrcRect.fLeft / texture->width();
-        localRect.fBottom = clippedSrcRect.fBottom / texture->height();
-        localRect.fRight = clippedSrcRect.fRight / texture->width();
-        localRect.fTop = clippedSrcRect.fTop / texture->height();
-        fDrawContext->fillRectToRect(clip, grPaint, viewMatrix, clippedDstRect, localRect);
+        fDrawContext->fillRectToRect(clip, grPaint, viewMatrix, clippedDstRect, clippedSrcRect);
         return;
     }
 
     if (!mf) {
         fDrawContext->drawRect(clip, grPaint, viewMatrix, clippedDstRect);
         return;
     }
 
     // First see if we can do the draw + mask filter direct to the dst.
     SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
     SkRRect rrect;
     rrect.setRect(clippedDstRect);
     if (mf->directFilterRRectMaskGPU(fContext->textureProvider(),
                                       fDrawContext,
                                       &grPaint,
                                       clip,
                                       viewMatrix,
                                       rec,
                                       rrect)) {
         return;
     }
     SkPath rectPath;
     rectPath.addRect(clippedDstRect);
     GrBlurUtils::drawPathWithMaskFilter(this->context(), fDrawContext, fRenderTarget, fClip,
                                         rectPath, &grPaint, viewMatrix, mf, paint.getPathEffect(),
                                         GrStrokeInfo::FillInfo());
 }