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.
      */
     const SkMatrix& getLocalMatrix() const { return fLocalMatrix; }
 
     /**
      *  Set the shader's local matrix.
      *  @param localM   The shader's new local matrix.
      */
     void setLocalMatrix(const SkMatrix& localM) { fLocalMatrix = localM; }

[scroggo, 2014/04/24 17:02:53]

Can we go ahead and put this function behind a flag?

#ifdef SK_SUPPORT_DEPRECATED_SET_LOCAL_MATRIX
    void setLocalMatrix(...)
#endif

If so, we need to include the new flag in common_conditions.gypi for
skia_android_framework. Chrome also uses it, so we'll need to add the flag to
skia_for_chromium_defines.gypi (in Skia) and the GN build file for chromium
trunk/src/skia/skia_gn_files.gypi (in Chromium).

I guess we currently still need the flag for drawVertices. Florin added a flag
for calls that can only be called internally in
https://codereview.chromium.org/246023008/ (which has not yet been submitted).
We could use that, or we could make it private with a friend class for
drawVertices. (This would have the option of limiting our internal call sites
more.)

 
     /**
      *  Reset the shader's local matrix to identity.
      */
     void resetLocalMatrix() { fLocalMatrix.reset(); }
 
     enum TileMode {
         /** replicate the edge color if the shader draws outside of its
          *  original bounds
          */
@@ skipping 299 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.
+     *  @param localMatrix  The new local matrix to replace the original shader's one.
+     *  @return             Returns a new shader object. Note: this function never returns null.

[scroggo, 2014/04/24 17:02:53]

What if the caller calls with a NULL shader?

[Dominik Grewe, 2014/04/24 17:16:47]

Good point. I currently assert that it's not NULL but we might just want to
return NULL in that case.

+    */
+    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);

[scroggo, 2014/04/24 17:02:53]

This function may call getLocalMatrix (e.g. SkBitmapProcShader). We'll need to
pass our local matrix to this function somehow (maybe we just add a parameter;
not sure what is the best way). SkPictureShader is a little more elaborate:
buildBitmapShader calls getLocalMatrix, and is called by asNewEffect.

I would guess that asABitmap and asAGradient might, too, but I haven't
investigated.

[Dominik Grewe, 2014/04/24 17:16:47]

Thinking about this, I'm not sure what I've done here works... Any function may
call getLocalMatrix() and it will of course use the original shader's one. All
I've done here is to change the local matrix to the outside world, but anything
internal won't see it.
Guess I'll need to rethink this a bit...

+    }
+
+    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLocalMatrixShaderWrapper);
+
+protected:
+    SkLocalMatrixShaderWrapper(SkShader* shader, const SkMatrix& localMatrix);

[scroggo, 2014/04/24 17:02:53]

Any reason not to make this private?

[Dominik Grewe, 2014/04/24 17:16:47]

As long as we never have any subclasses we can make it private.

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

My vote would be to make it private unless/until we think we have a reason for a
subclass.

+    SkLocalMatrixShaderWrapper(SkReadBuffer& buffer);
+    virtual void flatten(SkWriteBuffer& buffer);
+
+private:
+    SkAutoTUnref<SkShader> fShader;
+
+    typedef SkShader INHERITED;
+};
+
 #endif