Make "alpha only" be a property of GrTextureProducer

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 70 matching lines @@
             !may_color_bleed(srcRect, transformedRect, srcRectToDeviceSpace, isMSAA)) {
             return true;
         }
     }
     return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawTextureProducer(GrTextureProducer* producer,
-                                      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
     // the matrix that maps the src rect to the dst rect.
     SkRect clippedSrcRect;
@@ skipping 26 matching lines @@
             clippedDstRect = *dstRect;
             if (!srcToDstMatrix.setRectToRect(srcBounds, *dstRect, SkMatrix::kFill_ScaleToFit)) {
                 return;
             }
         } else {
             clippedDstRect = srcBounds;
             srcToDstMatrix.reset();
         }
     }
 
-    this->drawTextureProducerImpl(producer, alphaOnly, clippedSrcRect, clippedDstRect, constraint,
-                                  viewMatrix, srcToDstMatrix, clip, paint);
+    this->drawTextureProducerImpl(producer, clippedSrcRect, clippedDstRect, constraint, viewMatrix,
+                                  srcToDstMatrix, clip, paint);
 }
 
 void SkGpuDevice::drawTextureProducerImpl(GrTextureProducer* producer,
-                                          bool alphaTexture,
                                           const SkRect& clippedSrcRect,
                                           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 SkMaskFilter* mf = paint.getMaskFilter();
     // 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;
+    bool canUseTextureCoordsAsLocalCoords = !use_shader(producer->isAlphaOnly(), paint) && !mf;
 
     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;
@@ skipping 27 matching lines @@
         }
         textureMatrix = &tempMatrix;
     }
     SkAutoTUnref<const GrFragmentProcessor> fp(producer->createFragmentProcessor(
         *textureMatrix, clippedSrcRect, constraintMode, coordsAllInsideSrcRect, filterMode));
     if (!fp) {
         return;
     }
 
     GrPaint grPaint;
-    if (!SkPaintToGrPaintWithTexture(fContext, paint, viewMatrix, fp, alphaTexture, &grPaint)) {
+    if (!SkPaintToGrPaintWithTexture(fContext, paint, viewMatrix, fp, producer->isAlphaOnly(),
+                                     &grPaint)) {
         return;
     }
 
     if (canUseTextureCoordsAsLocalCoords) {
         fDrawContext->fillRectToRect(clip, grPaint, viewMatrix, clippedDstRect, clippedSrcRect);
         return;
     }
 
     if (!mf) {
         fDrawContext->drawRect(clip, grPaint, viewMatrix, clippedDstRect);
@@ skipping 13 matching lines @@
                                       rrect)) {
         return;
     }
     SkPath rectPath;
     rectPath.addRect(clippedDstRect);
     rectPath.setIsVolatile(true);
     GrBlurUtils::drawPathWithMaskFilter(this->context(), fDrawContext, fClip,
                                         rectPath, &grPaint, viewMatrix, mf, paint.getPathEffect(),
                                         GrStrokeInfo::FillInfo(), true);
 }