Initial picture shader implementation

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
 
 #include "SkBitmap.h"
 #include "SkFlattenable.h"
 #include "SkMask.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
 
 class SkPath;
+class SkPicture;
 class GrContext;
 class GrEffectRef;
 
 /** \class SkShader
  *
  *  Shaders specify the source color(s) for what is being drawn. If a paint
  *  has no shader, then the paint's color is used. If the paint has a
  *  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
@@ skipping 309 matching lines @@
      *  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);
 
+    /** 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

[scroggo, 2014/04/11 15:23:15]

Is it part of the intended use case to allow the caller to continue to modify
the picture? I'm looking at this with an eye towards immutability of shaders. If
we don't want the client to be able to modify it, we could make this take
ownership of the picture instead of reffing it. (And when we split the picture
API into picture record and picture playback, this could take a playback.)

[f(malita), 2014/04/11 16:05:18]

The intent is to treat the picture (playback) as immutable. If we can adjust the
API to better reflect this, SGTM.

+     *              is incremented).
+     *  @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);
+
     SK_TO_STRING_VIRT()
     SK_DEFINE_FLATTENABLE_TYPE(SkShader)
 
 protected:
     enum MatrixClass {
         kLinear_MatrixClass,            // no perspective
         kFixedStepInX_MatrixClass,      // fast perspective, need to call fixedStepInX() each scanline
         kPerspective_MatrixClass        // slow perspective, need to mappoints each pixel
     };
     static MatrixClass ComputeMatrixClass(const SkMatrix&);
 
     // These can be called by your subclass after setContext() has been called
     uint8_t             getPaintAlpha() const { return fPaintAlpha; }
     const SkMatrix&     getTotalInverse() const { return fTotalInverse; }
     MatrixClass         getInverseClass() const { return (MatrixClass)fTotalInverseClass; }
 
     SkShader(SkReadBuffer& );
     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 private:
     SkMatrix            fLocalMatrix;
     SkMatrix            fTotalInverse;
     uint8_t             fPaintAlpha;
     uint8_t             fTotalInverseClass;
     SkDEBUGCODE(SkBool8 fInSetContext;)
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif