Make "alpha only" be a property of GrTextureProducer

src/gpu/GrTextureParamsAdjuster.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrTextureMaker_DEFINED
 #define GrTextureMaker_DEFINED
 
@@ skipping 52 matching lines @@
                                     const SkMatrix& textureMatrix,
                                     const SkRect& constraintRect,
                                     FilterConstraint filterConstraint,
                                     bool coordsLimitedToConstraintRect,
                                     const GrTextureParams::FilterMode* filterOrNullForBicubic) = 0;
 
     virtual ~GrTextureProducer() {}
 
     int width() const { return fWidth; }
     int height() const { return fHeight; }
+    bool isAlphaOnly() const { return fIsAlphaOnly; }
 
 protected:
-    GrTextureProducer(int width, int height) : fWidth(width), fHeight(height) {}
+    GrTextureProducer(int width, int height, bool isAlphaOnly)
+        : fWidth(width)
+        , fHeight(height)
+        , fIsAlphaOnly(isAlphaOnly) {}
 
     /** Helper for creating a key for a copy from an original key. */
     static void MakeCopyKeyFromOrigKey(const GrUniqueKey& origKey,
                                        const CopyParams& copyParams,
                                        GrUniqueKey* copyKey) {
         SkASSERT(!copyKey->isValid());
         if (origKey.isValid()) {
             static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
             GrUniqueKey::Builder builder(copyKey, origKey, kDomain, 3);
             builder[0] = copyParams.fFilter;
@@ skipping 11 matching lines @@
     virtual void makeCopyKey(const CopyParams&, GrUniqueKey* copyKey) = 0;
 
     /**
     *  If a stretched version of the texture is generated, it may be cached (assuming that
     *  makeCopyKey() returns true). In that case, the maker is notified in case it
     *  wants to note that for when the maker is destroyed.
     */
     virtual void didCacheCopy(const GrUniqueKey& copyKey) = 0;
 
 private:
-    const int fWidth;
-    const int fHeight;
+    const int   fWidth;
+    const int   fHeight;
+    const bool  fIsAlphaOnly;
 
     typedef SkNoncopyable INHERITED;
 };
 
 /**
  * Base class for sources that start out as textures. Optionally allows for a content area subrect.
  * The intent is not to use content area for subrect rendering. Rather, the pixels outside the
  * content area have undefined values and shouldn't be read *regardless* of filtering mode or
  * the SkCanvas::SrcRectConstraint used for subrect draws.
  */
 class GrTextureAdjuster : public GrTextureProducer {
 public:
     /** Makes the subset of the texture safe to use with the given texture parameters.
         outOffset will be the top-left corner of the subset if a copy is not made. Otherwise,
         the copy will be tight to the contents and outOffset will be (0, 0). If the copy's size
         does not match subset's dimensions then the contents are scaled to fit the copy.*/
     GrTexture* refTextureSafeForParams(const GrTextureParams&, SkIPoint* outOffset);
 
     const GrFragmentProcessor* createFragmentProcessor(
                                 const SkMatrix& textureMatrix,
                                 const SkRect& constraintRect,
                                 FilterConstraint,
                                 bool coordsLimitedToConstraintRect,
                                 const GrTextureParams::FilterMode* filterOrNullForBicubic) override;
 
 protected:
     /** The whole texture is content. */
-    explicit GrTextureAdjuster(GrTexture* original)
-        : INHERITED(original->width(), original->height())
+    explicit GrTextureAdjuster(GrTexture* original, bool isAlphaOnly)
+        : INHERITED(original->width(), original->height(), isAlphaOnly)
         , fOriginal(original) {}
 
-    GrTextureAdjuster(GrTexture* original, const SkIRect& contentArea);
+    GrTextureAdjuster(GrTexture* original, const SkIRect& contentArea, bool isAlphaOnly);
 
     GrTexture* originalTexture() const { return fOriginal; }
 
     /** Returns the content area or null for the whole original texture */
     const SkIRect* contentAreaOrNull() { return fContentArea.getMaybeNull(); }
 
 private:
     SkTLazy<SkIRect>    fContentArea;
     GrTexture*          fOriginal;
 
@@ skipping 12 matching lines @@
     GrTexture* refTextureForParams(const GrTextureParams&);
 
     const GrFragmentProcessor* createFragmentProcessor(
                                 const SkMatrix& textureMatrix,
                                 const SkRect& constraintRect,
                                 FilterConstraint filterConstraint,
                                 bool coordsLimitedToConstraintRect,
                                 const GrTextureParams::FilterMode* filterOrNullForBicubic) override;
 
 protected:
-    GrTextureMaker(GrContext* context, int width, int height)
-        : INHERITED(width, height)
+    GrTextureMaker(GrContext* context, int width, int height, bool isAlphaOnly)
+        : INHERITED(width, height, isAlphaOnly)
         , fContext(context) {}
 
     /**
      *  Return the maker's "original" texture. It is the responsibility of the maker to handle any
      *  caching of the original if desired.
      */
     virtual GrTexture* refOriginalTexture() = 0;
 
     /**
      *  Return a new (uncached) texture that is the stretch of the maker's original.
      *
      *  The base-class handles general logic for this, and only needs access to the following
      *  method:
      *  - refOriginalTexture()
      *
      *  Subclass may override this if they can handle creating the texture more directly than
      *  by copying.
      */
     virtual GrTexture* generateTextureForParams(const CopyParams&);
 
     GrContext* context() const { return fContext; }
 
 private:
     GrContext*  fContext;
 
     typedef GrTextureProducer INHERITED;
 };
 
 #endif