Separate out natively-texture image/bmp draws from cached-as-texture image/bmp draws

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
 
 #include "GrTextureParams.h"
 #include "GrResourceKey.h"
+#include "GrTexture.h"
 #include "SkTLazy.h"
 
 class GrContext;
-class GrTexture;
 class GrTextureParams;
 class GrUniqueKey;
 class SkBitmap;
 
 /**
  * Different GPUs and API extensions have different requirements with respect to what texture
  * sampling parameters may be used with textures of various types. This class facilitates making
  * texture compatible with a given GrTextureParams. There are two immediate subclasses defined
  * below. One is a base class for sources that are inherently texture-backed (e.g. a texture-backed
  * SkImage). It supports subsetting the original texture. The other is for use cases where the
@@ skipping 49 matching lines @@
  * 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);
 
+    enum FilterConstraint {
+        kYes_FilterConstraint,
+        kNo_FilterConstraint,
+    };
+
+    /**
+     * Helper for creating a fragment processor to sample the texture with a given filtering mode.
+     * It attempts to avoids making a copy of the texture and avoid using a texture domain unless
+     * necessary.
+     *
+     * @param textureMatrix                    Matrix to transform local coords by to compute
+     *                                         texture coords.
+     * @param constraintRect                   Subrect of content area to be rendered. Must be
+     *                                         clipped to the content area already.
+     * @param filterConstriant                 Indicates whether filtering is limited to
+     *                                         constraintRect.
+     * @param coordsLimitedToConstraintRect    Is it known that textureMatrix*localCoords is bound
+     *                                         by the portion of the texture indicated by
+     *                                         constraintRect (without consideration of filter
+     *                                         width, just the raw coords).
+     * @param filterOrNullForBicubic           If non-null indicates the filter mode. If null means
+     *                                         use bicubic filtering.
+     **/
+    const GrFragmentProcessor* createFragmentProcessor(
+        const SkMatrix& textureMatrix,
+        const SkRect& constraintRect,
+        FilterConstraint filterConstraint,
+        bool coordsLimitedToConstraintRect,
+        const GrTextureParams::FilterMode* filterOrNullForBicubic);
+
+    GrTexture* originalTexture() const { return fOriginal; }
+
+    void getContentArea(SkIRect* contentArea) const {
+        if (fContentArea.isValid()) {
+            *contentArea = *fContentArea.get();
+        } else {
+            *contentArea = SkIRect::MakeWH(fOriginal->width(), fOriginal->height());
+        }
+    }
+
 protected:
     /** The whole texture is content. */
     explicit GrTextureAdjuster(GrTexture* original): fOriginal(original) {}
 
     GrTextureAdjuster(GrTexture* original, const SkIRect& contentArea);
 
-    GrTexture* originalTexture() { return fOriginal; }
-
     /** Returns the content area or null for the whole original texture */
-    const SkIRect* contentArea() { return fContentArea.getMaybeNull(); }
+    const SkIRect* contentAreaOrNull() { return fContentArea.getMaybeNull(); }
 
 private:
     SkTLazy<SkIRect>    fContentArea;
     GrTexture*          fOriginal;
 
     typedef GrTextureProducer INHERITED;
 };
 
 /** 
  * Base class for sources that start out as something other than a texture (encoded image,
@@ skipping 41 matching lines @@
     virtual GrTexture* generateTextureForParams(GrContext*, const CopyParams&);
 
 private:
     const int fWidth;
     const int fHeight;
 
     typedef GrTextureProducer INHERITED;
 };
 
 #endif