Split GrFragmentProcessor into its own header

Review URL: https://codereview.chromium.org/660573002

4 files changed, 116 insertions, 96 deletions

diff --git a/include/gpu/GrFragmentProcessor.h b/include/gpu/GrFragmentProcessor.h
new file mode 100644
index 0000000000..28778fd10a
--- /dev/null
+++ b/include/gpu/GrFragmentProcessor.h
@@ -0,0 +1,108 @@
+/*
+ * 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"
+
+class GrCoordTransform;
+
+/** 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.
+ */
+class GrFragmentProcessor : public GrProcessor {
+public:
+    GrFragmentProcessor()
+        : INHERITED()
+        , fWillReadDstColor(false)
+        , fWillUseInputColor(true) {}
+
+    virtual const GrBackendFragmentProcessorFactory& getFactory() const = 0;
+
+    int numTransforms() 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]; }
+
+    /** Will this prceossor read the destination pixel value? */
+    bool willReadDstColor() const { return fWillReadDstColor; }
+
+    /** Will this prceossor read the source color value? */
+    bool willUseInputColor() const { return fWillUseInputColor; }
+
+    /** Returns true if this and other prceossor conservatively draw identically. It can only return
+        true when the two prceossor 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 prceossor would
+        generate the same shader code. To test for identical code generation use the prceossor' keys
+        computed by the GrBackendProcessorFactory. */
+    bool isEqual(const GrFragmentProcessor& other) const {
+        if (&this->getFactory() != &other.getFactory()) {
+            return false;
+        }
+        bool result = this->onIsEqual(other);
+#ifdef SK_DEBUG
+        if (result) {
+            this->assertTexturesEqual(other);
+        }
+#endif
+        return result;
+    }
+
+protected:
+    /**
+     * Fragment Processor subclasses call this from their constructor to register coordinate
+     * transformations. The processor subclass manages the lifetime of the transformations (this
+     * function only stores a pointer). The GrCoordTransform is typically a member field of the
+     * GrProcessor subclass. When the matrix has perspective, the transformed coordinates will have
+     * 3 components. Otherwise they'll have 2. This must only be called from the constructor because
+     * GrProcessors are immutable.
+     */
+    void addCoordTransform(const GrCoordTransform*);
+
+    /**
+     * If the prceossor subclass will read the destination pixel value then it must call this function
+     * from its constructor. Otherwise, when its generated backend-specific prceossor class attempts
+     * to generate code that reads the destination pixel it will fail.
+     */
+    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; }
+
+private:
+    /** Subclass implements this to support isEqual(). It will only be called if it is known that
+        the two prceossor are of the same subclass (i.e. they return the same object from
+        getFactory()).*/
+    virtual bool onIsEqual(const GrFragmentProcessor& other) const = 0;
+
+    SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
+    bool                                         fWillReadDstColor;
+    bool                                         fWillUseInputColor;
+
+    typedef GrProcessor INHERITED;
+};
+
+/**
+ * This creates an effect outside of the effect memory pool. The effect's destructor will be called
+ * at global destruction time. NAME will be the name of the created GrProcessor.
+ */
+#define GR_CREATE_STATIC_FRAGMENT_PROCESSOR(NAME, FP_CLASS, ARGS)                                 \
+static SkAlignedSStorage<sizeof(FP_CLASS)> g_##NAME##_Storage;                                    \
+static GrFragmentProcessor* NAME SkNEW_PLACEMENT_ARGS(g_##NAME##_Storage.get(), FP_CLASS, ARGS);  \
+static SkAutoTDestroy<GrFragmentProcessor> NAME##_ad(NAME);
+
+#endif
diff --git a/include/gpu/GrGeometryProcessor.h b/include/gpu/GrGeometryProcessor.h
index fe7905a31b..5b509ca24f 100644
--- a/include/gpu/GrGeometryProcessor.h
+++ b/include/gpu/GrGeometryProcessor.h
@@ -9,7 +9,7 @@
 #define GrGeometryProcessor_DEFINED
 
 #include "GrProcessor.h"
-class GrBackendGeometryProcessorFactory;
+#include "GrShaderVar.h"
 
 /**
  * A GrGeomteryProcessor is used to perform computation in the vertex shader and
@@ -37,6 +37,12 @@ public:
 
     const VertexAttribArray& getVertexAttribs() const { return fVertexAttribs; }
 
+    /** Returns true if this and other effect conservatively draw identically. It can only return
+        true when the two effects 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 effects would
+        generate the same shader code. To test for identical code generation use the effects' keys
+        computed by the GrBackendEffectFactory. */
     bool isEqual(const GrGeometryProcessor& that) const {
         if (&this->getFactory() != &that.getFactory()) {
             return false;
diff --git a/include/gpu/GrProcessor.h b/include/gpu/GrProcessor.h
index 7991a069d1..b41f94d25a 100644
--- a/include/gpu/GrProcessor.h
+++ b/include/gpu/GrProcessor.h
@@ -12,12 +12,8 @@
 #include "GrColor.h"
 #include "GrProcessorUnitTest.h"
 #include "GrProgramElement.h"
-#include "GrShaderVar.h"
 #include "GrTextureAccess.h"
-#include "GrTypesPriv.h"
-#include "SkString.h"
 
-class GrBackendProcessorFactory;
 class GrContext;
 class GrCoordTransform;
 
@@ -240,93 +236,4 @@ private:
     typedef GrProgramElement INHERITED;
 };
 
-class GrFragmentProcessor : public GrProcessor {
-public:
-    GrFragmentProcessor()
-        : INHERITED()
-        , fWillReadDstColor(false)
-        , fWillUseInputColor(true) {}
-
-    virtual const GrBackendFragmentProcessorFactory& getFactory() const = 0;
-
-    int numTransforms() 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]; }
-
-    /** Will this effect read the destination pixel value? */
-    bool willReadDstColor() const { return fWillReadDstColor; }
-
-    /** Will this effect read the source color value? */
-    bool willUseInputColor() const { return fWillUseInputColor; }
-
-    /** Returns true if this and other effect conservatively draw identically. It can only return
-        true when the two effects 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 effects would
-        generate the same shader code. To test for identical code generation use the effects' keys
-        computed by the GrBackendEffectFactory. */
-    bool isEqual(const GrFragmentProcessor& other) const {
-        if (&this->getFactory() != &other.getFactory()) {
-            return false;
-        }
-        bool result = this->onIsEqual(other);
-#ifdef SK_DEBUG
-        if (result) {
-            this->assertTexturesEqual(other);
-        }
-#endif
-        return result;
-    }
-
-protected:
-    /**
-     * Fragment Processor subclasses call this from their constructor to register coordinate
-     * transformations. The processor subclass manages the lifetime of the transformations (this
-     * function only stores a pointer). The GrCoordTransform is typically a member field of the
-     * GrProcessor subclass. When the matrix has perspective, the transformed coordinates will have
-     * 3 components. Otherwise they'll have 2. This must only be called from the constructor because
-     * GrProcessors are immutable.
-     */
-    void addCoordTransform(const GrCoordTransform*);
-
-    /**
-     * If the effect subclass will read the destination pixel value then it must call this function
-     * from its constructor. Otherwise, when its generated backend-specific effect class attempts
-     * to generate code that reads the destination pixel it will fail.
-     */
-    void setWillReadDstColor() { fWillReadDstColor = true; }
-
-    /**
-     * If the effect 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; }
-
-private:
-    /** Subclass implements this to support isEqual(). It will only be called if it is known that
-        the two effects are of the same subclass (i.e. they return the same object from
-        getFactory()).*/
-    virtual bool onIsEqual(const GrFragmentProcessor& other) const = 0;
-
-    SkSTArray<4, const GrCoordTransform*, true>  fCoordTransforms;
-    bool                                         fWillReadDstColor;
-    bool                                         fWillUseInputColor;
-
-    typedef GrProcessor INHERITED;
-};
-
-/**
- * This creates an effect outside of the effect memory pool. The effect's destructor will be called
- * at global destruction time. NAME will be the name of the created GrProcessor.
- */
-#define GR_CREATE_STATIC_FRAGMENT_PROCESSOR(NAME, EFFECT_CLASS, ARGS)                             \
-static SkAlignedSStorage<sizeof(EFFECT_CLASS)> g_##NAME##_Storage;                                \
-static GrFragmentProcessor*                                                                       \
-NAME SkNEW_PLACEMENT_ARGS(g_##NAME##_Storage.get(), EFFECT_CLASS, ARGS);                          \
-static SkAutoTDestroy<GrFragmentProcessor> NAME##_ad(NAME);
-
 #endif
diff --git a/include/gpu/GrProcessorStage.h b/include/gpu/GrProcessorStage.h
index c961572c1d..6f8496db06 100644
--- a/include/gpu/GrProcessorStage.h
+++ b/include/gpu/GrProcessorStage.h
@@ -13,8 +13,7 @@
 
 #include "GrBackendProcessorFactory.h"
 #include "GrCoordTransform.h"
-#include "GrProcessor.h"
-#include "GrGeometryProcessor.h"
+#include "GrFragmentProcessor.h"
 #include "GrProgramElementRef.h"
 #include "SkMatrix.h"
 #include "SkShader.h"