Don't require GrPipelineBuilder to build GrPipeline

Change-Id: Ic978913aa9dd0811eac102755934d77b4853a568
Reviewed-on: https://skia-review.googlesource.com/7207
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>

10 files changed, 95 insertions, 160 deletions

diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp
index 96051eaaa5..c55d7a3af8 100644
--- a/src/gpu/GrPipeline.cpp
+++ b/src/gpu/GrPipeline.cpp
@@ -21,8 +21,6 @@
 
 GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
                                  GrPipelineOptimizations* optimizations) {
-    const GrPipelineBuilder& builder = *args.fPipelineBuilder;
-    const GrUserStencilSettings* userStencil = builder.getUserStencil();
     GrRenderTarget* rt = args.fRenderTargetContext->accessRenderTarget();
     if (!rt) {
         return nullptr;
@@ -33,36 +31,26 @@ GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
     SkASSERT(pipeline->fRenderTarget);
     pipeline->fScissorState = args.fAppliedClip->scissorState();
     pipeline->fWindowRectsState = args.fAppliedClip->windowRectsState();
-    pipeline->fUserStencilSettings = userStencil;
-    pipeline->fDrawFace = builder.getDrawFace();
+    pipeline->fUserStencilSettings = args.fUserStencil;
+    pipeline->fDrawFace = static_cast<int16_t>(args.fDrawFace);
 
-    pipeline->fFlags = 0;
-    if (builder.isHWAntialias()) {
-        pipeline->fFlags |= kHWAA_Flag;
-    }
-    if (builder.snapVerticesToPixelCenters()) {
-        pipeline->fFlags |= kSnapVertices_Flag;
-    }
-    if (builder.getDisableOutputConversionToSRGB()) {
-        pipeline->fFlags |= kDisableOutputConversionToSRGB_Flag;
-    }
-    if (builder.getAllowSRGBInputs()) {
-        pipeline->fFlags |= kAllowSRGBInputs_Flag;
-    }
-    if (builder.getUsesDistanceVectorField()) {
+    pipeline->fFlags = args.fFlags;
+    if (args.fProcessors->usesDistanceVectorField()) {
         pipeline->fFlags |= kUsesDistanceVectorField_Flag;
     }
     if (args.fAppliedClip->hasStencilClip()) {
         pipeline->fFlags |= kHasStencilClip_Flag;
     }
-    if (!userStencil->isDisabled(args.fAppliedClip->hasStencilClip())) {
+    if (!args.fUserStencil->isDisabled(args.fAppliedClip->hasStencilClip())) {
         pipeline->fFlags |= kStencilEnabled_Flag;
     }
 
+    bool isHWAA = kHWAntialias_Flag & args.fFlags;
+
     // Create XferProcessor from DS's XPFactory
     bool hasMixedSamples = args.fRenderTargetContext->hasMixedSamples() &&
-                           (builder.isHWAntialias() || pipeline->isStencilEnabled());
-    const GrXPFactory* xpFactory = builder.getXPFactory();
+                           (isHWAA || pipeline->isStencilEnabled());
+    const GrXPFactory* xpFactory = args.fProcessors->xpFactory();
     sk_sp<GrXferProcessor> xferProcessor;
     if (xpFactory) {
         xferProcessor.reset(xpFactory->createXferProcessor(
@@ -86,7 +74,7 @@ GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
     const GrXferProcessor* xpForOpts = xferProcessor ? xferProcessor.get() :
                                                        &GrPorterDuffXPFactory::SimpleSrcOverXP();
     optFlags = xpForOpts->getOptimizations(
-            args.fAnalysis, userStencil->doesWrite(args.fAppliedClip->hasStencilClip()),
+            args.fAnalysis, args.fUserStencil->doesWrite(args.fAppliedClip->hasStencilClip()),
             &overrideColor, *args.fCaps);
 
     // When path rendering the stencil settings are not always set on the GrPipelineBuilder
@@ -113,30 +101,32 @@ GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
 
     if ((optFlags & GrXferProcessor::kIgnoreColor_OptFlag) ||
         (optFlags & GrXferProcessor::kOverrideColor_OptFlag)) {
-        firstColorProcessorIdx = builder.numColorFragmentProcessors();
+        firstColorProcessorIdx = args.fProcessors->numColorFragmentProcessors();
     }
 
     bool usesLocalCoords = false;
 
     // Copy GrFragmentProcessors from GrPipelineBuilder to Pipeline
-    pipeline->fNumColorProcessors = builder.numColorFragmentProcessors() - firstColorProcessorIdx;
+    pipeline->fNumColorProcessors =
+            args.fProcessors->numColorFragmentProcessors() - firstColorProcessorIdx;
     int numTotalProcessors = pipeline->fNumColorProcessors +
-                             builder.numCoverageFragmentProcessors() - firstCoverageProcessorIdx;
+                             args.fProcessors->numCoverageFragmentProcessors() -
+                             firstCoverageProcessorIdx;
     if (args.fAppliedClip->clipCoverageFragmentProcessor()) {
         ++numTotalProcessors;
     }
     pipeline->fFragmentProcessors.reset(numTotalProcessors);
     int currFPIdx = 0;
-    for (int i = firstColorProcessorIdx; i < builder.numColorFragmentProcessors();
+    for (int i = firstColorProcessorIdx; i < args.fProcessors->numColorFragmentProcessors();
          ++i, ++currFPIdx) {
-        const GrFragmentProcessor* fp = builder.getColorFragmentProcessor(i);
+        const GrFragmentProcessor* fp = args.fProcessors->colorFragmentProcessor(i);
         pipeline->fFragmentProcessors[currFPIdx].reset(fp);
         usesLocalCoords = usesLocalCoords || fp->usesLocalCoords();
     }
 
-    for (int i = firstCoverageProcessorIdx; i < builder.numCoverageFragmentProcessors();
+    for (int i = firstCoverageProcessorIdx; i < args.fProcessors->numCoverageFragmentProcessors();
          ++i, ++currFPIdx) {
-        const GrFragmentProcessor* fp = builder.getCoverageFragmentProcessor(i);
+        const GrFragmentProcessor* fp = args.fProcessors->coverageFragmentProcessor(i);
         pipeline->fFragmentProcessors[currFPIdx].reset(fp);
         usesLocalCoords = usesLocalCoords || fp->usesLocalCoords();
     }
diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h
index f00fbf3ff5..e56330025f 100644
--- a/src/gpu/GrPipeline.h
+++ b/src/gpu/GrPipeline.h
@@ -60,6 +60,8 @@ struct GrPipelineAnalysis {
     bool fUsesPLSDstRead = false;
 };
 
+class GrProcessorSet;
+
 /**
  * Class that holds an optimized version of a GrPipelineBuilder. It is meant to be an immutable
  * class, and contains all data needed to set the state for a gpu draw.
@@ -69,11 +71,38 @@ public:
     ///////////////////////////////////////////////////////////////////////////
     /// @name Creation
 
+    enum Flags {
+        /**
+         * Perform HW anti-aliasing. This means either HW FSAA, if supported by the render target,
+         * or smooth-line rendering if a line primitive is drawn and line smoothing is supported by
+         * the 3D API.
+         */
+        kHWAntialias_Flag = 0x1,
+
+        /**
+         * Modifies the vertex shader so that vertices will be positioned at pixel centers.
+         */
+        kSnapVerticesToPixelCenters_Flag = 0x2,
+
+        /**
+         * Suppress linear -> sRGB conversion when rendering to sRGB render targets.
+         */
+        kDisableOutputConversionToSRGB_Flag = 0x4,
+
+        /**
+         * Allow sRGB -> linear conversion when reading from sRGB inputs.
+         */
+        kAllowSRGBInputs_Flag = 0x8,
+    };
+
     struct CreateArgs {
-        const GrPipelineBuilder* fPipelineBuilder;
-        GrAppliedClip* fAppliedClip;
-        GrRenderTargetContext* fRenderTargetContext;
-        const GrCaps* fCaps;
+        uint32_t fFlags = 0;
+        GrDrawFace fDrawFace = GrDrawFace::kBoth;
+        const GrProcessorSet* fProcessors = nullptr;
+        const GrUserStencilSettings* fUserStencil = &GrUserStencilSettings::kUnused;
+        GrAppliedClip* fAppliedClip = nullptr;
+        GrRenderTargetContext* fRenderTargetContext = nullptr;
+        const GrCaps* fCaps = nullptr;
         GrPipelineAnalysis fAnalysis;
         GrXferProcessor::DstTexture fDstTexture;
     };
@@ -168,8 +197,10 @@ public:
 
     const GrWindowRectsState& getWindowRectsState() const { return fWindowRectsState; }
 
-    bool isHWAntialiasState() const { return SkToBool(fFlags & kHWAA_Flag); }
-    bool snapVerticesToPixelCenters() const { return SkToBool(fFlags & kSnapVertices_Flag); }
+    bool isHWAntialiasState() const { return SkToBool(fFlags & kHWAntialias_Flag); }
+    bool snapVerticesToPixelCenters() const {
+        return SkToBool(fFlags & kSnapVerticesToPixelCenters_Flag);
+    }
     bool getDisableOutputConversionToSRGB() const {
         return SkToBool(fFlags & kDisableOutputConversionToSRGB_Flag);
     }
@@ -195,28 +226,15 @@ public:
      * or both faces.
      * @return the current draw face(s).
      */
-    GrDrawFace getDrawFace() const { return fDrawFace; }
-
+    GrDrawFace getDrawFace() const { return static_cast<GrDrawFace>(fDrawFace); }
 
 private:
     GrPipeline() { /** Initialized in factory function*/ }
 
-    /**
-     * Calculates the primary and secondary output types of the shader. For certain output types
-     * the function may adjust the blend coefficients. After this function is called the src and dst
-     * blend coeffs will represent those used by backend API.
-     */
-    void setOutputStateInfo(const GrPipelineBuilder& ds, GrXferProcessor::OptFlags,
-                            const GrCaps&);
-
-    enum Flags {
-        kHWAA_Flag                          = 0x1,
-        kSnapVertices_Flag                  = 0x2,
-        kDisableOutputConversionToSRGB_Flag = 0x4,
-        kAllowSRGBInputs_Flag               = 0x8,
-        kUsesDistanceVectorField_Flag       = 0x10,
-        kHasStencilClip_Flag                = 0x20,
-        kStencilEnabled_Flag                = 0x40,
+    enum PrivateFlags {
+        kUsesDistanceVectorField_Flag = 0x10,
+        kHasStencilClip_Flag = 0x20,
+        kStencilEnabled_Flag = 0x40,
     };
 
     typedef GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> RenderTarget;
@@ -227,8 +245,8 @@ private:
     GrScissorState                      fScissorState;
     GrWindowRectsState                  fWindowRectsState;
     const GrUserStencilSettings*        fUserStencilSettings;
-    GrDrawFace                          fDrawFace;
-    uint32_t                            fFlags;
+    uint16_t                            fDrawFace;
+    uint16_t                            fFlags;
     ProgramXferProcessor                fXferProcessor;
     FragmentProcessorArray              fFragmentProcessors;
 
diff --git a/src/gpu/GrPipelineBuilder.cpp b/src/gpu/GrPipelineBuilder.cpp
index ce3871873a..bbb8f5a159 100644
--- a/src/gpu/GrPipelineBuilder.cpp
+++ b/src/gpu/GrPipelineBuilder.cpp
@@ -17,23 +17,24 @@
 
 GrPipelineBuilder::GrPipelineBuilder(GrPaint&& paint, GrAAType aaType)
         : fFlags(0x0)
-        , fUserStencilSettings(&GrUserStencilSettings::kUnused)
         , fDrawFace(GrDrawFace::kBoth)
+        , fUserStencilSettings(&GrUserStencilSettings::kUnused)
         , fProcessors(std::move(paint)) {
-    this->setState(GrPipelineBuilder::kHWAntialias_Flag, GrAATypeIsHW(aaType));
-    // The processors have been moved out of paint, but its flags should still be unmodified.
-    this->setState(GrPipelineBuilder::kDisableOutputConversionToSRGB_Flag,
-                   paint.getDisableOutputConversionToSRGB());
-    this->setState(GrPipelineBuilder::kAllowSRGBInputs_Flag,
-                   paint.getAllowSRGBInputs());
-    this->setState(GrPipelineBuilder::kUsesDistanceVectorField_Flag,
-                   paint.usesDistanceVectorField());
+    if (GrAATypeIsHW(aaType)) {
+        fFlags |= GrPipeline::kHWAntialias_Flag;
+    }
+    if (paint.getDisableOutputConversionToSRGB()) {
+        fFlags |= GrPipeline::kDisableOutputConversionToSRGB_Flag;
+    }
+    if (paint.getAllowSRGBInputs()) {
+        fFlags |= GrPipeline::kAllowSRGBInputs_Flag;
+    }
 }
 
 bool GrPipelineBuilder::willXPNeedDstTexture(const GrCaps& caps,
                                              const GrPipelineAnalysis& analysis) const {
-    if (this->getXPFactory()) {
-        return this->getXPFactory()->willNeedDstTexture(caps, analysis);
+    if (fProcessors.xpFactory()) {
+        return fProcessors.xpFactory()->willNeedDstTexture(caps, analysis);
     }
     return GrPorterDuffXPFactory::SrcOverWillNeedDstTexture(caps, analysis);
 }
diff --git a/src/gpu/GrPipelineBuilder.h b/src/gpu/GrPipelineBuilder.h
index e0c4d3d46e..aca1925832 100644
--- a/src/gpu/GrPipelineBuilder.h
+++ b/src/gpu/GrPipelineBuilder.h
@@ -9,6 +9,7 @@
 #define GrPipelineBuilder_DEFINED
 
 #include "GrGpuResourceRef.h"
+#include "GrPipeline.h"
 #include "GrProcessorSet.h"
 #include "GrRenderTarget.h"
 #include "GrUserStencilSettings.h"
@@ -63,8 +64,6 @@ public:
     /// @name Blending
     ////
 
-    const GrXPFactory* getXPFactory() const { return fProcessors.xpFactory(); }
-
     /**
      * Checks whether the xp will need destination in a texture to correctly blend.
      */
@@ -78,7 +77,6 @@ public:
     ////
 
     bool hasUserStencilSettings() const { return !fUserStencilSettings->isUnused(); }
-    const GrUserStencilSettings* getUserStencil() const { return fUserStencilSettings; }
 
     /**
      * Sets the user stencil settings for the next draw.
@@ -88,7 +86,6 @@ public:
      * @param settings  the stencil settings to use.
      */
     void setUserStencil(const GrUserStencilSettings* settings) { fUserStencilSettings = settings; }
-    void disableUserStencil() { fUserStencilSettings = &GrUserStencilSettings::kUnused; }
 
     /// @}
 
@@ -96,77 +93,13 @@ public:
     /// @name State Flags
     ////
 
-    /**
-     *  Flags that affect rendering. Controlled using enable/disableState(). All
-     *  default to disabled.
-     */
-    enum Flags {
-        /**
-         * Perform HW anti-aliasing. This means either HW FSAA, if supported by the render target,
-         * or smooth-line rendering if a line primitive is drawn and line smoothing is supported by
-         * the 3D API.
-         */
-        kHWAntialias_Flag   = 0x01,
-
-        /**
-         * Modifies the vertex shader so that vertices will be positioned at pixel centers.
-         */
-        kSnapVerticesToPixelCenters_Flag = 0x02,
-
-        /**
-         * Suppress linear -> sRGB conversion when rendering to sRGB render targets.
-         */
-        kDisableOutputConversionToSRGB_Flag = 0x04,
-
-        /**
-         * Allow sRGB -> linear conversion when reading from sRGB inputs.
-         */
-        kAllowSRGBInputs_Flag = 0x08,
-
-        /**
-         * Signals that one or more FPs need access to the distance vector field to the nearest
-         * edge
-         */
-        kUsesDistanceVectorField_Flag = 0x10,
-
-        kLast_Flag = kUsesDistanceVectorField_Flag,
-    };
-
-    bool isHWAntialias() const { return SkToBool(fFlags & kHWAntialias_Flag); }
-    bool snapVerticesToPixelCenters() const {
-        return SkToBool(fFlags & kSnapVerticesToPixelCenters_Flag); }
-    bool getDisableOutputConversionToSRGB() const {
-        return SkToBool(fFlags & kDisableOutputConversionToSRGB_Flag); }
-    bool getAllowSRGBInputs() const {
-        return SkToBool(fFlags & kAllowSRGBInputs_Flag); }
-    bool getUsesDistanceVectorField() const {
-        return SkToBool(fFlags & kUsesDistanceVectorField_Flag); }
-
-    /**
-     * Enable render state settings.
-     *
-     * @param flags bitfield of Flags specifying the states to enable
-     */
-    void enableState(uint32_t flags) { fFlags |= flags; }
-
-    /**
-     * Disable render state settings.
-     *
-     * @param flags bitfield of Flags specifying the states to disable
-     */
-    void disableState(uint32_t flags) { fFlags &= ~(flags); }
+    bool isHWAntialias() const { return SkToBool(fFlags & GrPipeline::kHWAntialias_Flag); }
 
-    /**
-     * Enable or disable flags based on a boolean.
-     *
-     * @param flags bitfield of Flags to enable or disable
-     * @param enable    if true enable stateBits, otherwise disable
-     */
-    void setState(uint32_t flags, bool enable) {
+    void setSnapVerticesToPixelCenters(bool enable) {
         if (enable) {
-            this->enableState(flags);
+            fFlags |= GrPipeline::kSnapVerticesToPixelCenters_Flag;
         } else {
-            this->disableState(flags);
+            fFlags &= ~GrPipeline::kSnapVerticesToPixelCenters_Flag;
         }
     }
 
@@ -177,13 +110,6 @@ public:
     ////
 
     /**
-     * Gets whether the target is drawing clockwise, counterclockwise,
-     * or both faces.
-     * @return the current draw face(s).
-     */
-    GrDrawFace getDrawFace() const { return fDrawFace; }
-
-    /**
      * Controls whether clockwise, counterclockwise, or both faces are drawn.
      * @param face  the face(s) to draw.
      */
@@ -194,14 +120,17 @@ public:
 
     /// @}
 
-    ///////////////////////////////////////////////////////////////////////////
-
-    bool usePLSDstRead(const GrDrawOp*) const;
+    void initPipelineCreateArgs(GrPipeline::CreateArgs* args) const {
+        args->fFlags = fFlags;
+        args->fUserStencil = fUserStencilSettings;
+        args->fDrawFace = fDrawFace;
+        args->fProcessors = &fProcessors;
+    }
 
 private:
     uint32_t fFlags;
-    const GrUserStencilSettings* fUserStencilSettings;
     GrDrawFace fDrawFace;
+    const GrUserStencilSettings* fUserStencilSettings;
     GrProcessorSet fProcessors;
 };
 
diff --git a/src/gpu/GrProcessorSet.cpp b/src/gpu/GrProcessorSet.cpp
index 0d72d9bafe..6e7eeb844b 100644
--- a/src/gpu/GrProcessorSet.cpp
+++ b/src/gpu/GrProcessorSet.cpp
@@ -18,4 +18,5 @@ GrProcessorSet::GrProcessorSet(GrPaint&& paint) {
     for (auto& fp : paint.fCoverageFragmentProcessors) {
         fFragmentProcessors[i++] = fp.release();
     }
+    fUsesDistanceVectorField = paint.usesDistanceVectorField();
 }
diff --git a/src/gpu/GrProcessorSet.h b/src/gpu/GrProcessorSet.h
index de9c0a643a..a1d68a997a 100644
--- a/src/gpu/GrProcessorSet.h
+++ b/src/gpu/GrProcessorSet.h
@@ -50,10 +50,13 @@ public:
         analysis->fCoveragePOI.analyzeProcessors(fps, this->numCoverageFragmentProcessors());
     }
 
+    bool usesDistanceVectorField() const { return fUsesDistanceVectorField; }
+
 private:
     const GrXPFactory* fXPFactory = nullptr;
     SkAutoSTArray<4, const GrFragmentProcessor*> fFragmentProcessors;
     int fColorFragmentProcessorCnt;
+    bool fUsesDistanceVectorField;
 };
 
 #endif
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 39d5597ab6..0dd7d97da3 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -660,12 +660,7 @@ void GrRenderTargetContext::drawRect(const GrClip& clip,
 
         if (op) {
             GrPipelineBuilder pipelineBuilder(std::move(paint), aaType);
-
-            if (snapToPixelCenters) {
-                pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
-                                         snapToPixelCenters);
-            }
-
+            pipelineBuilder.setSnapVerticesToPixelCenters(snapToPixelCenters);
             this->getOpList()->addDrawOp(pipelineBuilder, this, clip, std::move(op));
             return;
         }
diff --git a/src/gpu/GrRenderTargetOpList.cpp b/src/gpu/GrRenderTargetOpList.cpp
index 144b399b2c..1c0243ba14 100644
--- a/src/gpu/GrRenderTargetOpList.cpp
+++ b/src/gpu/GrRenderTargetOpList.cpp
@@ -287,7 +287,7 @@ void GrRenderTargetOpList::addDrawOp(const GrPipelineBuilder& pipelineBuilder,
     }
 
     GrPipeline::CreateArgs args;
-    args.fPipelineBuilder = &pipelineBuilder;
+    pipelineBuilder.initPipelineCreateArgs(&args);
     args.fAppliedClip = &appliedClip;
     args.fRenderTargetContext = renderTargetContext;
     args.fCaps = this->caps();
diff --git a/tests/GpuSampleLocationsTest.cpp b/tests/GpuSampleLocationsTest.cpp
index b4c4fe5a94..a690400b01 100644
--- a/tests/GpuSampleLocationsTest.cpp
+++ b/tests/GpuSampleLocationsTest.cpp
@@ -99,7 +99,7 @@ static GrPipeline* construct_dummy_pipeline(GrRenderTargetContext* dc, void* sto
 
     GrAppliedClip dummyAppliedClip(SkRect::MakeLargest());
     GrPipeline::CreateArgs args;
-    args.fPipelineBuilder = &dummyBuilder;
+    dummyBuilder.initPipelineCreateArgs(&args);
     args.fRenderTargetContext = dc;
     args.fCaps = dc->caps();
     args.fAppliedClip = &dummyAppliedClip;
diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp
index b1c179b32a..0760a4fd0e 100644
--- a/tools/gpu/GrTest.cpp
+++ b/tools/gpu/GrTest.cpp
@@ -257,9 +257,7 @@ void GrRenderTargetContextPriv::testingOnly_addDrawOp(GrPaint&& paint,
     if (uss) {
         pipelineBuilder.setUserStencil(uss);
     }
-    if (snapToCenters) {
-        pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag, true);
-    }
+    pipelineBuilder.setSnapVerticesToPixelCenters(snapToCenters);
 
     fRenderTargetContext->getOpList()->addDrawOp(pipelineBuilder, fRenderTargetContext, GrNoClip(),
                                                  std::move(op));