Revert of Remove GP from drawstate, revision of invariant output for GP

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 @@
         generate the same shader code. To test for identical code generation use getGLProcessorKey*/
     bool isEqual(const GrFragmentProcessor& that) const {
         if (this->classID() != that.classID() ||
             !this->hasSameTransforms(that) ||
             !this->hasSameTextureAccesses(that)) {
             return false;
         }
         return this->onIsEqual(that);
     }
 
-    /**
-     * 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;
-
 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.
      *
      * When the transformation has perspective, the transformed coordinates will have
      * 3 components. Otherwise they'll have 2. 
      *
@@ skipping 14 matching lines @@
      */
     void setWillReadDstColor() { fWillReadDstColor = true; }
 
     /**
      * If the prceossor will generate a result that does not depend on the input color value then it
      * must call this function from its constructor. Otherwise, when its generated backend-specific
      * code might fail during variable binding due to unused variables.
      */
     void setWillNotUseInputColor() { fWillUseInputColor = false; }
 
-    /**
-     * Subclass implements this to support getConstantColorComponents(...).
-     */
-    virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const = 0;
-
 private:
     /**
      * 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;
 
     SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
     bool                                         fWillReadDstColor;
     bool                                         fWillUseInputColor;
 
     typedef GrProcessor INHERITED;
 };
 
 #endif