Initial implementation of GPU no filter NinePatch

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"
 #include "GrCaps.h"
 #include "GrDrawContext.h"
 #include "GrStrokeInfo.h"
 #include "GrTextureParamsAdjuster.h"
 #include "SkDraw.h"
 #include "SkGrPriv.h"
 #include "SkMaskFilter.h"
 #include "effects/GrBicubicEffect.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "effects/GrTextureDomain.h"
 
 static inline bool use_shader(bool textureIsAlphaOnly, const SkPaint& paint) {
     return textureIsAlphaOnly && paint.getShader();
 }
 
-/** Determines how to combine the texture FP with the paint's color and SkShader, if any. */
-static const GrFragmentProcessor* mix_texture_fp_with_paint_color_and_shader(
-                                                            const GrFragmentProcessor* textureFP,
-                                                            bool textureIsAlphaOnly,
-                                                            GrContext* context,
-                                                            const SkMatrix& viewMatrix,
-                                                            const SkPaint& paint) {
-    // According to the SkCanvas API, we only consider the shader if the bitmap or image being
-    // rendered is alpha-only.
-    if (textureIsAlphaOnly) {
-        if (const SkShader* shader = paint.getShader()) {
-            SkAutoTUnref<const GrFragmentProcessor> shaderFP(
-                shader->asFragmentProcessor(context,
-                                            viewMatrix,
-                                            nullptr,
-                                            paint.getFilterQuality()));
-            if (!shaderFP) {
-                return nullptr;
-            }
-            const GrFragmentProcessor* fpSeries[] = { shaderFP, textureFP };
-            return GrFragmentProcessor::RunInSeries(fpSeries, 2);
-        } else {
-            return GrFragmentProcessor::MulOutputByInputUnpremulColor(textureFP);
-        }
-    } else {
-        return GrFragmentProcessor::MulOutputByInputAlpha(textureFP);
-    }
-}
-
 void SkGpuDevice::drawTextureAdjuster(GrTextureAdjuster* adjuster,
                                       bool alphaOnly,
                                       const SkRect* srcRect,
                                       const SkRect* dstRect,
                                       SkCanvas::SrcRectConstraint constraint,
                                       const SkMatrix& viewMatrix,
                                       const GrClip& clip,
                                       const SkPaint& paint) {
     // Figure out the actual dst and src rect by clipping the src rect to the bounds of the
     // adjuster. If the src rect is clipped then the dst rect must be recomputed. Also determine
@@ skipping 84 matching lines @@
         if (!srcToDstMatrix.invert(&tempMatrix)) {
             return;
         }
         textureMatrix = &tempMatrix;
     }
     SkAutoTUnref<const GrFragmentProcessor> fp(adjuster->createFragmentProcessor(
         *textureMatrix, 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)) {
+    if (!SkPaintToGrPaintWithTexture(fContext, paint, viewMatrix, fp, alphaTexture, &grPaint)) {
         return;
     }
 
     if (canUseTextureCoordsAsLocalCoords) {
         fDrawContext->fillRectToRect(clip, grPaint, viewMatrix, clippedDstRect, clippedSrcRect);
         return;
     }
 
     if (!mf) {
         fDrawContext->drawRect(clip, grPaint, viewMatrix, clippedDstRect);
@@ skipping 12 matching lines @@
                                       rec,
                                       rrect)) {
         return;
     }
     SkPath rectPath;
     rectPath.addRect(clippedDstRect);
     GrBlurUtils::drawPathWithMaskFilter(this->context(), fDrawContext, fRenderTarget, fClip,
                                         rectPath, &grPaint, viewMatrix, mf, paint.getPathEffect(),
                                         GrStrokeInfo::FillInfo());
 }