Move SkShader::fLocalMatrix into SkShader constructor.

include/core/SkShader.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkShader_DEFINED
 #define SkShader_DEFINED
@@ skipping 16 matching lines @@
  *  shader, then the shader's color(s) are use instead, but they are
  *  modulated by the paint's alpha. This makes it easy to create a shader
  *  once (e.g. bitmap tiling or gradient) and then change its transparency
  *  w/o having to modify the original shader... only the paint's alpha needs
  *  to be modified.
  */
 class SK_API SkShader : public SkFlattenable {
 public:
     SK_DECLARE_INST_COUNT(SkShader)
 
-    SkShader();
+    SkShader(const SkMatrix* localMatrix = NULL);
     virtual ~SkShader();
 
     /**
      *  Returns true if the local matrix is not an identity matrix.
      */
     bool hasLocalMatrix() const { return !fLocalMatrix.isIdentity(); }
 
     /**
      *  Returns the local matrix.
      */
@@ skipping 316 matching lines @@
      *
      *  If the src is kA8_Config then that mask will be colorized using the color on
      *  the paint.
      *
      *  @param src  The bitmap to use inside the shader
      *  @param tmx  The tiling mode to use when sampling the bitmap in the x-direction.
      *  @param tmy  The tiling mode to use when sampling the bitmap in the y-direction.
      *  @return     Returns a new shader object. Note: this function never returns null.
     */
     static SkShader* CreateBitmapShader(const SkBitmap& src,
-                                        TileMode tmx, TileMode tmy);
+                                        TileMode tmx, TileMode tmy,
+                                        const SkMatrix* localMatrix = NULL);
 
     /** Call this to create a new shader that will draw with the specified picture.
      *
      *  @param src  The picture to use inside the shader (if not NULL, its ref count
      *              is incremented). The SkPicture must not be changed after
      *              successfully creating a picture shader.
      *              FIXME: src cannot be const due to SkCanvas::drawPicture
      *  @param tmx  The tiling mode to use when sampling the bitmap in the x-direction.
      *  @param tmy  The tiling mode to use when sampling the bitmap in the y-direction.
      *  @return     Returns a new shader object. Note: this function never returns null.
     */
     static SkShader* CreatePictureShader(SkPicture* src, TileMode tmx, TileMode tmy);
 
+    /** Call this to create a shader wrapper with a new local matrix. It behaves like the
+     *  original shader but with the local matrix replaced.
+     *
+     *  @param shader       The shader being wrapped.

[scroggo, 2014/04/24 18:24:47]

Should there be a comment that its ref count is incremented?

+     *  @param localMatrix  The new local matrix to replace the original shader's one.
+     *  @return             Returns a new shader object or NULL if shader is NULL.
+    */
+    static SkShader* CreateLocalMatrixWrapper(SkShader* shader, const SkMatrix& localMatrix);
+
     SK_TO_STRING_VIRT()
     SK_DEFINE_FLATTENABLE_TYPE(SkShader)
 
 protected:
 
     SkShader(SkReadBuffer& );
     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkMatrix            fLocalMatrix;
 
     bool computeTotalInverse(const SkMatrix& matrix, SkMatrix* totalInverse) const;
 
     typedef SkFlattenable INHERITED;
 };
 
+
+/**
+ *  Wrapper class for SkShader that allows us to overwrite the local matrix
+ *  without having to create the shader again.
+ */
+class SK_API SkLocalMatrixShaderWrapper : public SkShader {
+public:
+    static SkLocalMatrixShaderWrapper* Create(SkShader* shader, const SkMatrix& localMatrix) {
+        return SkNEW_ARGS(SkLocalMatrixShaderWrapper, (shader, localMatrix));
+    }
+
+    // Forward all methods to the wrapped shader, apart from hasLocalMatrix and
+    // getLocalMatrix which use the wrapper's local matrix.
+    virtual bool isOpaque() const SK_OVERRIDE { return fShader->isOpaque(); }
+    virtual bool validContext(const SkBitmap& device,
+                              const SkPaint& paint,
+                              const SkMatrix& matrix,
+                              SkMatrix* totalInverse = NULL) const SK_OVERRIDE {
+        return fShader->validContext(device, paint, matrix, totalInverse);
+    }
+    virtual Context* createContext(const SkBitmap& device,
+                                   const SkPaint& paint,
+                                   const SkMatrix& matrix,
+                                   void* storage) const SK_OVERRIDE {
+        return fShader->createContext(device, paint, matrix, storage);
+    }
+    virtual size_t contextSize() const SK_OVERRIDE { return fShader->contextSize(); }
+    virtual BitmapType asABitmap(SkBitmap* outTexture, SkMatrix* outMatrix,
+                                 TileMode xy[2]) const SK_OVERRIDE {
+        return fShader->asABitmap(outTexture, outMatrix, xy);
+    }
+    virtual GradientType asAGradient(GradientInfo* info) const SK_OVERRIDE {
+        return fShader->asAGradient(info);
+    }
+    virtual GrEffectRef* asNewEffect(GrContext* context, const SkPaint& paint) const SK_OVERRIDE {
+        return fShader->asNewEffect(context, paint);
+    }
+
+    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLocalMatrixShaderWrapper);
+
+protected:
+    SkLocalMatrixShaderWrapper(SkShader* shader, const SkMatrix& localMatrix);
+    SkLocalMatrixShaderWrapper(SkReadBuffer& buffer);
+    virtual void flatten(SkWriteBuffer& buffer);
+
+private:
+    SkAutoTUnref<SkShader> fShader;
+
+    typedef SkShader INHERITED;
+};
+
 #endif