Rename GrOptDrawState to GrPipeline and GrDrawState to GrPipelineBuilder

src/gpu/GrGpu.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGpu_DEFINED
 #define GrGpu_DEFINED
 
 #include "GrDrawTarget.h"
 #include "GrPathRendering.h"
 #include "GrProgramDesc.h"
 #include "SkPath.h"
 
 class GrContext;
 class GrIndexBufferAllocPool;
-class GrOptDrawState;
 class GrPath;
 class GrPathRange;
 class GrPathRenderer;
 class GrPathRendererChain;
+class GrPipeline;
 class GrPrimitiveProcessor;
 class GrStencilBuffer;
 class GrVertexBufferAllocPool;
 
 class GrGpu : public SkRefCnt {
 public:
 
     /**
      * Additional blend coefficients for dual source blending, not exposed
      * through GrPaint/GrContext.
@@ skipping 266 matching lines @@
     static const ResetTimestamp kExpiredTimestamp = 0;
     // Returns a timestamp based on the number of times the context was reset.
     // This timestamp can be used to lazily detect when cached 3D context state
     // is dirty.
     ResetTimestamp getResetTimestamp() const { return fResetTimestamp; }
 
     GrContext::GPUStats* gpuStats() { return &fGPUStats; }
 
     virtual void buildProgramDesc(GrProgramDesc*,
                                   const GrPrimitiveProcessor&,
-                                  const GrOptDrawState&,
+                                  const GrPipeline&,
                                   const GrProgramDesc::DescInfo&,
                                   const GrBatchTracker&) const = 0;
 
     /**
      * Called at start and end of gpu trace marking
      * GR_CREATE_GPU_TRACE_MARKER(marker_str, target) will automatically call these at the start
      * and end of a code block respectively
      */
     void addGpuTraceMarker(const GrGpuTraceMarker* marker);
     void removeGpuTraceMarker(const GrGpuTraceMarker* marker);
@@ skipping 24 matching lines @@
     // and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the
     // src/dst bounds and non-empty.
     virtual bool copySurface(GrSurface* dst,
                              GrSurface* src,
                              const SkIRect& srcRect,
                              const SkIPoint& dstPoint) = 0;
 
     struct DrawArgs {
         typedef GrDrawTarget::DrawInfo DrawInfo;
         DrawArgs(const GrPrimitiveProcessor* primProc,
-                 const GrOptDrawState* optState,
+                 const GrPipeline* pipeline,
                  const GrProgramDesc* desc,
                  const GrBatchTracker* batchTracker)
             : fPrimitiveProcessor(primProc)
-            , fOptState(optState)
+            , fPipeline(pipeline)
             , fDesc(desc)
             , fBatchTracker(batchTracker) {
-            SkASSERT(primProc && optState && desc && batchTracker);
+            SkASSERT(primProc && pipeline && desc && batchTracker);
         }
         const GrPrimitiveProcessor* fPrimitiveProcessor;
-        const GrOptDrawState* fOptState;
+        const GrPipeline* fPipeline;
         const GrProgramDesc* fDesc;
         const GrBatchTracker* fBatchTracker;
     };
 
     void draw(const DrawArgs&, const GrDrawTarget::DrawInfo&);
 
     /** None of these params are optional, pointers used just to avoid making copies. */
     struct StencilPathState {
         bool fUseHWAA;
         GrRenderTarget* fRenderTarget;
@@ skipping 128 matching lines @@
     int                                                                 fGpuTraceMarkerCount;
     GrTraceMarkerSet                                                    fActiveTraceMarkers;
     GrTraceMarkerSet                                                    fStoredTraceMarkers;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
     GrContext*                                                          fContext;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif