Made isEqual in GrFragmentProcessor recursive

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 56 matching lines @@
 
     /** Do any of the coordtransforms for this processor require local coords? */
     bool usesLocalCoords() const { return fUsesLocalCoords; }
 
     /** Returns true if this and other processor conservatively draw identically. It can only return
         true when the two processor are of the same subclass (i.e. they return the same object from
         from getFactory()).
 
         A return value of true from isEqual() should not be used to test whether the processor would
         generate the same shader code. To test for identical code generation use getGLProcessorKey*/
-    bool isEqual(const GrFragmentProcessor& that, bool ignoreCoordTransforms) const {
-        if (this->classID() != that.classID() ||
-            !this->hasSameTextureAccesses(that)) {
-            return false;
-        }
-        if (ignoreCoordTransforms) {
-            if (this->numTransforms() != that.numTransforms()) {
-                return false;
-            }
-        } else if (!this->hasSameTransforms(that)) {
-            return false;
-        }
-        return this->onIsEqual(that);
-    }
+    bool isEqual(const GrFragmentProcessor& that, bool ignoreCoordTransforms) const;
 
     /**
      * This function is used to perform optimizations. When called the invarientOuput param
      * indicate whether the input components to this processor in the FS will have known values.
      * In inout the validFlags member is a bitfield of GrColorComponentFlags. The isSingleComponent
      * member indicates whether the input will be 1 or 4 bytes. The function updates the members of
      * 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.
+     *
+     * Note: this function will NOT be recursive; it will be up to the parent proc to figure out
+     * what invariants its output can have given its children.

[tomhudson, 2015/08/17 17:33:10]

Please clarify: It's hard for me to understand how any proc can return a value
here without inspecting its children.

[joshualitt, 2015/08/17 17:38:41]

I think the confusion here is that the parent can combine its children's output
anyway it wants, including a recursive implementation.  Maybe we want to say 'it
is up to the parent to fully implement this function, no default recursive
implementation is supplied'

[bsalomon, 2015/08/17 18:04:16]

Perhaps the comment should be on the virtual and not on the public non-virtual
since this is info for a subclass implementor and not for someone writing code
that uses this class.

[wangyix, 2015/08/17 19:07:46]

Done.

      */
     void computeInvariantOutput(GrInvariantOutput* inout) const;
 
 protected:
     /**
      * 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 66 matching lines @@
      * The same goes for fTextureAccesses with textures.
      */
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
 
     SkTArray<GrFragmentStage, false>             fChildProcessors;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif