Stop aggregating texture/buffer access objects in GrFragmentProcessor parents.

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 49 matching lines @@
      * 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 sk_sp<GrFragmentProcessor> RunInSeries(sk_sp<GrFragmentProcessor>*, int cnt);
 
     GrFragmentProcessor()
         : INHERITED()
         , fUsesDistanceVectorField(false)
-        , fUsesLocalCoords(false)
-        , fNumTexturesExclChildren(0)
-        , fNumBuffersExclChildren(0) {}
+        , fUsesLocalCoords(false) {}
 
     ~GrFragmentProcessor() override;
 
     GrGLSLFragmentProcessor* createGLSLInstance() const;
 
     void getGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const {
         this->onGetGLSLProcessorKey(caps, b);
         for (int i = 0; i < fChildProcessors.count(); ++i) {
             fChildProcessors[i]->getGLSLProcessorKey(caps, b);
         }
     }
 
-    int numTexturesExclChildren() const { return fNumTexturesExclChildren; }
-
-    int numBuffersExclChildren() const { return fNumBuffersExclChildren; }
-
     int numCoordTransforms() const { return fCoordTransforms.count(); }
 
     /** Returns the coordinate transformation at index. index must be valid according to
         numTransforms(). */
     const GrCoordTransform& coordTransform(int index) const { return *fCoordTransforms[index]; }
 
     const SkTArray<const GrCoordTransform*, true>& coordTransforms() const {
         return fCoordTransforms;
     }
 
-    void gatherCoordTransforms(SkTArray<const GrCoordTransform*, true>* outTransforms) const {
-        if (!fCoordTransforms.empty()) {
-            outTransforms->push_back_n(fCoordTransforms.count(), fCoordTransforms.begin());
-        }
-    }
-
     int numChildProcessors() const { return fChildProcessors.count(); }
 
     const GrFragmentProcessor& childProcessor(int index) const { return *fChildProcessors[index]; }
 
     /** Do any of the coordtransforms for this processor require local coords? */
     bool usesLocalCoords() const { return fUsesLocalCoords; }
 
     /** Does this FP need a vector to the nearest edge? */
     bool usesDistanceVectorField() const { return fUsesDistanceVectorField; }
 
@@ skipping 14 matching lines @@
      * inout to indicate known values of its output. A component of the color member only has
      * meaning if the corresponding bit in validFlags is set.
      */
     void computeInvariantOutput(GrInvariantOutput* inout) const {
         this->onComputeInvariantOutput(inout);
     }
 
     /**
      * Pre-order traversal of a FP hierarchy, or of the forest of FPs in a GrPipeline. In the latter
      * case the tree rooted at each FP in the GrPipeline is visited successively.
-     * */
+     */
     class Iter : public SkNoncopyable {
     public:
         explicit Iter(const GrFragmentProcessor* fp) { fFPStack.push_back(fp); }
         explicit Iter(const GrPipeline& pipeline);
         const GrFragmentProcessor* next();
 
     private:
         SkSTArray<4, const GrFragmentProcessor*, true> fFPStack;
     };
 
     /**
-     * Iterates over all the GrCoordTransforms in a GrPipeline's GrFragmentProcessors. FPs are
-     * visited in the same order as Iter and each of an FP's coord transforms are visited linearly.
+     * Iterates over all the Ts owned by a GrFragmentProcessor and its children or over all the Ts
+     * owned by the forest of GrFragmentProcessors in a GrPipeline. FPs are visited in the same
+     * order as Iter and each of an FP's Ts are visited in order.
      */
-    class CoordTransformIter : public SkNoncopyable {
+    template <typename T, typename BASE,
+              int (BASE::*COUNT)() const,
+              const T& (BASE::*GET)(int) const>
+    class FPItemIter : public SkNoncopyable {
     public:
-        explicit CoordTransformIter(const GrPipeline& pipeline)
+        explicit FPItemIter(const GrFragmentProcessor* fp)
+                : fCurrFP(nullptr)
+                , fCTIdx(0)
+                , fFPIter(fp) {
+            fCurrFP = fFPIter.next();
+        }
+        explicit FPItemIter(const GrPipeline& pipeline)
                 : fCurrFP(nullptr)
                 , fCTIdx(0)
                 , fFPIter(pipeline) {
             fCurrFP = fFPIter.next();
         }
-        const GrCoordTransform* next();
+
+        const T* next() {
+            if (!fCurrFP) {
+                return nullptr;
+            }
+            while (fCTIdx == (fCurrFP->*COUNT)()) {
+                fCTIdx = 0;
+                fCurrFP = fFPIter.next();
+                if (!fCurrFP) {
+                    return nullptr;
+                }
+            }
+            return &(fCurrFP->*GET)(fCTIdx++);
+        }
 
     private:
         const GrFragmentProcessor*  fCurrFP;
         int                         fCTIdx;
         GrFragmentProcessor::Iter   fFPIter;
     };
 
+    using CoordTransformIter = FPItemIter<GrCoordTransform,
+                                          GrFragmentProcessor,
+                                          &GrFragmentProcessor::numCoordTransforms,
+                                          &GrFragmentProcessor::coordTransform>;
+
+    using TextureAccessIter = FPItemIter<GrTextureAccess,
+                                         GrProcessor,
+                                         &GrProcessor::numTextures,
+                                         &GrProcessor::textureAccess>;
+
 protected:
     void addTextureAccess(const GrTextureAccess* textureAccess) override;
     void addBufferAccess(const GrBufferAccess*) override;
 
     /**
      * Fragment Processor subclasses call this from their constructor to register coordinate
      * transformations. Coord transforms provide a mechanism for a processor to receive coordinates
      * in their FS code. The matrix expresses a transformation from local space. For a given
      * fragment the matrix will be applied to the local coordinate that maps to the fragment.
      *
@@ skipping 54 matching lines @@
      */
     virtual bool onIsEqual(const GrFragmentProcessor&) const = 0;
 
     bool hasSameTransforms(const GrFragmentProcessor&) const;
 
     bool                                       fUsesLocalCoords;
 
     SkSTArray<4, const GrCoordTransform*, true> fCoordTransforms;
 
     /**
-     * A processor stores the texture accesses of this proc, followed by all the accesses of this
-     * proc's children. In other words, each proc stores all the accesses 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 accesses
-     * respectively. The following shows what the array of each proc's texture accesses 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 buffer accesses.
-     */
-    int                                         fNumTexturesExclChildren;
-    int                                         fNumBuffersExclChildren;
-
-    /**
      * 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