Rename GrOptDrawState to GrPipeline and GrDrawState to GrPipelineBuilder

src/gpu/GrPipeline.h

 /*
- * Copyright 2014 Google Inc.
+ * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
-#ifndef GrOptDrawState_DEFINED
-#define GrOptDrawState_DEFINED
+#ifndef GrPipeline_DEFINED
+#define GrPipeline_DEFINED
 
 #include "GrColor.h"
 #include "GrGpu.h"
 #include "GrPendingFragmentStage.h"
 #include "GrProgramDesc.h"
 #include "GrStencil.h"
 #include "GrTypesPriv.h"
 #include "SkMatrix.h"
 #include "SkRefCnt.h"
 
 class GrDeviceCoordTexture;
-class GrDrawState;
 class GrPathProcessor;
+class GrPipelineBuilder;
 
 /**
- * Class that holds an optimized version of a GrDrawState. It is meant to be an immutable class,
- * and contains all data needed to set the state for a gpu draw.
+ * 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.
  */
-class GrOptDrawState {
+class GrPipeline {
 public:
-    SK_DECLARE_INST_COUNT(GrOptDrawState)
+    SK_DECLARE_INST_COUNT(GrPipeline)
 
-    GrOptDrawState(const GrDrawState& drawState, const GrPrimitiveProcessor*,
-                   const GrDrawTargetCaps&, const GrScissorState&,
-                   const GrDeviceCoordTexture* dstCopy);
+    GrPipeline(const GrPipelineBuilder& pipelineBuilder, const GrPrimitiveProcessor*,
+               const GrDrawTargetCaps&, const GrScissorState&,
+               const GrDeviceCoordTexture* dstCopy);
 
     /*
-     * Returns true if it is possible to combine the two GrOptDrawStates and it will update 'this'
+     * Returns true if it is possible to combine the two GrPipelines and it will update 'this'
      * to subsume 'that''s draw.
      */
-    bool isEqual(const GrOptDrawState& that) const;
+    bool isEqual(const GrPipeline& that) const;
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Effect Stages
     /// Each stage hosts a GrProcessor. The effect produces an output color or coverage in the
     /// fragment shader. Its inputs are the output from the previous stage as well as some variables
     /// available to it in the fragment and vertex shader (e.g. the vertex position, the dst color,
     /// the fragment position, local coordinates).
     ///
@@ skipping 64 matching lines @@
     bool isHWAntialiasState() const { return SkToBool(fFlags & kHWAA_Flag); }
     bool mustSkip() const { return NULL == this->getRenderTarget(); }
 
     /// @}
 
     /**
      * Gets whether the target is drawing clockwise, counterclockwise,
      * or both faces.
      * @return the current draw face(s).
      */
-    GrDrawState::DrawFace getDrawFace() const { return fDrawFace; }
+    GrPipelineBuilder::DrawFace getDrawFace() const { return fDrawFace; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
 
     const GrDeviceCoordTexture* getDstCopy() const { return fDstCopy.texture() ? &fDstCopy : NULL; }
 
     const GrProgramDesc::DescInfo& descInfo() const { return fDescInfo; }
 
     const GrGeometryProcessor::InitBT& getInitBatchTracker() const { return fInitBT; }
 
 private:
     /**
      * Alter the program desc and inputs (attribs and processors) based on the blend optimization.
      */
-    void adjustProgramFromOptimizations(const GrDrawState& ds,
+    void adjustProgramFromOptimizations(const GrPipelineBuilder& ds,
                                         GrXferProcessor::OptFlags,
                                         const GrProcOptInfo& colorPOI,
                                         const GrProcOptInfo& coveragePOI,
                                         int* firstColorStageIdx,
                                         int* firstCoverageStageIdx);
 
     /**
      * 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 GrDrawState& ds, GrXferProcessor::OptFlags,
+    void setOutputStateInfo(const GrPipelineBuilder& ds, GrXferProcessor::OptFlags,
                             const GrDrawTargetCaps&);
 
     enum Flags {
         kDither_Flag            = 0x1,
         kHWAA_Flag              = 0x2,
     };
 
     typedef GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> RenderTarget;
     typedef SkSTArray<8, GrPendingFragmentStage> FragmentStageArray;
     typedef GrPendingProgramElement<const GrXferProcessor> ProgramXferProcessor;
     RenderTarget                        fRenderTarget;
     GrScissorState                      fScissorState;
     GrStencilSettings                   fStencilSettings;
-    GrDrawState::DrawFace               fDrawFace;
+    GrPipelineBuilder::DrawFace               fDrawFace;
     GrDeviceCoordTexture                fDstCopy;
     uint32_t                            fFlags;
     ProgramXferProcessor                fXferProcessor;
     FragmentStageArray                  fFragmentStages;
     GrProgramDesc::DescInfo             fDescInfo;
     GrGeometryProcessor::InitBT         fInitBT;
 
     // This function is equivalent to the offset into fFragmentStages where coverage stages begin.
     int                                 fNumColorStages;
 
     GrProgramDesc fDesc;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif