Change SkShader;asFragmentProcessor signature to no longer take skpaint\grcolor*

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
 
 #include "GrProcessor.h"

[robertphillips, 2015/08/28 21:33:05]

Do we even need this include ?

[bsalomon, 2015/08/29 01:42:50]

Done.

+#include "GrInvariantOutput.h"
 
 class GrCoordTransform;
 class GrGLSLCaps;
 class GrGLFragmentProcessor;
 class GrProcessorKeyBuilder;
 
 /** Provides custom fragment shader code. Fragment processors receive an input color (vec4f) and
     produce an output color. They may reference textures and uniforms. They may use
     GrCoordTransforms to receive a transformation of the local coordinates that map from local space
     to the fragment being processed.
@@ skipping 53 matching lines @@
     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.
      */
-    void computeInvariantOutput(GrInvariantOutput* inout) const;
+    void computeInvariantOutput(GrInvariantOutput* inout) const {
+        this->onComputeInvariantOutput(inout);
+    }
 
 protected:
     void addTextureAccess(const GrTextureAccess* textureAccess) 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 82 matching lines @@
     int                                          fNumTransformsExclChildren;
 
     // TODO: These must convert their processors to pending-execution refs when the parent is
     // converted (do this automatically in GrProgramElement?).
     SkTArray<const GrFragmentProcessor*, true>   fChildProcessors;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif