sk_sp for gpu.

include/gpu/GrFragmentProcessor.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrFragmentProcessor_DEFINED
 #define GrFragmentProcessor_DEFINED
 
@@ skipping 13 matching lines @@
 class GrFragmentProcessor : public GrProcessor {
 public:
     /**
     *  In many instances (e.g. SkShader::asFragmentProcessor() implementations) it is desirable to
     *  only consider the input color's alpha. However, there is a competing desire to have reusable
     *  GrFragmentProcessor subclasses that can be used in other scenarios where the entire input
     *  color is considered. This function exists to filter the input color and pass it to a FP. It
     *  does so by returning a parent FP that multiplies the passed in FPs output by the parent's
     *  input alpha. The passed in FP will not receive an input color.
     */
-    static const GrFragmentProcessor* MulOutputByInputAlpha(const GrFragmentProcessor*);
+    static sk_sp<GrFragmentProcessor> MulOutputByInputAlpha(sk_sp<GrFragmentProcessor>);
 
     /**
      *  Similar to the above but it modulates the output r,g,b of the child processor by the input
      *  rgb and then multiplies all the components by the input alpha. This effectively modulates
      *  the child processor's premul color by a unpremul'ed input and produces a premul output
      */
-    static const GrFragmentProcessor* MulOutputByInputUnpremulColor(const GrFragmentProcessor*);
+    static sk_sp<GrFragmentProcessor> MulOutputByInputUnpremulColor(sk_sp<GrFragmentProcessor>);
 
     /**
      *  Returns a parent fragment processor that adopts the passed fragment processor as a child.
      *  The parent will ignore its input color and instead feed the passed in color as input to the
      *  child.
      */
-    static const GrFragmentProcessor* OverrideInput(const GrFragmentProcessor*, GrColor);
+    static sk_sp<GrFragmentProcessor> OverrideInput(sk_sp<GrFragmentProcessor>, GrColor);
 
     /**
      * Returns a fragment processor that runs the passed in array of fragment processors in a
      * series. The original input is passed to the first, the first's output is passed to the
      * second, etc. The output of the returned processor is the output of the last processor of the
      * series.
+     *
+     * The array elements with be moved.
      */
-    static const GrFragmentProcessor* RunInSeries(const GrFragmentProcessor*[], int cnt);
+    static sk_sp<GrFragmentProcessor> RunInSeries(sk_sp<GrFragmentProcessor>*, int cnt);
 
     GrFragmentProcessor()
         : INHERITED()
         , fUsesLocalCoords(false)
         , fNumTexturesExclChildren(0)
         , fNumBuffersExclChildren(0)
         , fNumTransformsExclChildren(0) {}
 
     ~GrFragmentProcessor() override;
 
@@ skipping 81 matching lines @@
 
     /**
      * FragmentProcessor subclasses call this from their constructor to register any child
      * FragmentProcessors they have. This must be called AFTER all texture accesses and coord
      * transforms have been added.
      * This is for processors whose shader code will be composed of nested processors whose output
      * colors will be combined somehow to produce its output color.  Registering these child
      * processors will allow the ProgramBuilder to automatically handle their transformed coords and
      * texture accesses and mangle their uniform and output color names.
      */
-    int registerChildProcessor(const GrFragmentProcessor* child);
+    int registerChildProcessor(sk_sp<GrFragmentProcessor> child);
 
     /**
      * Subclass implements this to support getConstantColorComponents(...).
      *
      * Note: it's up to the subclass implementation to do any recursive call to compute the child
      * procs' output invariants; computeInvariantOutput will not be recursive.
      */
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const = 0;
 
 private:
@@ skipping 11 matching lines @@
     /**
      * Subclass implements this to support isEqual(). It will only be called if it is known that
      * the two processors are of the same subclass (i.e. they return the same object from
      * getFactory()). The processor subclass should not compare its coord transforms as that will
      * be performed automatically in the non-virtual isEqual().
      */
     virtual bool onIsEqual(const GrFragmentProcessor&) const = 0;
 
     bool hasSameTransforms(const GrFragmentProcessor&) const;
 
-    bool                                            fUsesLocalCoords;
+    bool                                       fUsesLocalCoords;
 
     /**
      * fCoordTransforms stores the transforms of this proc, followed by all the transforms of this
      * proc's children. In other words, each proc stores all the transforms of its subtree as if
      * they were collected using preorder traversal.
      *
      * Example:
      * Suppose we have frag proc A, who has two children B and D. B has a child C, and D has
      * two children E and F. Suppose procs A, B, C, D, E, F have 1, 2, 1, 1, 3, 2 transforms
      * respectively. The following shows what the fCoordTransforms array of each proc would contain:
      *
      *                                   (A)
      *                        [a1,b1,b2,c1,d1,e1,e2,e3,f1,f2]
      *                                  /    \
      *                                /        \
      *                            (B)           (D)
      *                        [b1,b2,c1]   [d1,e1,e2,e3,f1,f2]
      *                          /             /    \
      *                        /             /        \
      *                      (C)          (E)          (F)
      *                     [c1]      [e1,e2,e3]      [f1,f2]
      *
      * The same goes for fTextureAccesses with textures.
      */
-    SkSTArray<4, const GrCoordTransform*, true>     fCoordTransforms;
-    int                                             fNumTexturesExclChildren;
-    int                                             fNumBuffersExclChildren;
-    int                                             fNumTransformsExclChildren;
-    SkSTArray<1, const GrFragmentProcessor*, true>  fChildProcessors;
+    SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms;
+    int                                         fNumTexturesExclChildren;
+    int                                         fNumBuffersExclChildren;
+    int                                         fNumTransformsExclChildren;
+
+    /**
+     * This is not SkSTArray<1, sk_sp<GrFragmentProcessor>> because this class holds strong
+     * references until notifyRefCntIsZero and then it holds pending executions.
+     */
+    SkSTArray<1, GrFragmentProcessor*, true>    fChildProcessors;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif