Snap optdrawstate in inorder draw buffer and pass into gpu

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
 
@@ skipping 42 matching lines @@
     virtual ~GrGpu();
 
     GrContext* getContext() { return fContext; }
     const GrContext* getContext() const { return fContext; }
 
     /**
      * Gets the capabilities of the draw target.
      */
     const GrDrawTargetCaps* caps() const { return fCaps.get(); }
 
-    /**
-     * Sets the draw state object for the gpu. Note that this does not
-     * make a copy. The GrGpu will take a reference to passed object.
-     * Passing NULL will cause the GrGpu to use its own internal draw
-     * state object rather than an externally provided one.
-     */
-    void setDrawState(GrDrawState*  drawState);
-
-    /**
-     * Read-only access to the GrGpu current draw state.
-     */
-    const GrDrawState& getDrawState() const { return *fDrawState; }
-
-    /**
-     * Read-write access to the GrGpu current draw state. Note that
-     * this doesn't ref.
-     */
-    GrDrawState* drawState() { return fDrawState; }
-
     GrPathRendering* pathRendering() {
         return fPathRendering.get();
     }
 
     // Called by GrContext when the underlying backend context has been destroyed.
     // GrGpu should use this to ensure that no backend API calls will be made from
     // here onward, including in its destructor. Subclasses should call
     // INHERITED::contextAbandoned() if they override this.
     virtual void contextAbandoned();
 
@@ skipping 203 matching lines @@
      * can be optionally cleared.
      */
     void clear(const SkIRect* rect,
                GrColor color,
                bool canIgnoreRect,
                GrRenderTarget* renderTarget);
 
 
     void clearStencilClip(const SkIRect& rect,
                           bool insideClip,
-                          GrRenderTarget* renderTarget = NULL);
+                          GrRenderTarget* renderTarget);
 
     /**
      * Discards the contents render target. NULL indicates that the current render target should
      * be discarded.
      **/
     virtual void discard(GrRenderTarget* = NULL) = 0;
 
     /**
      * This is can be called before allocating a texture to be a dst for copySurface. It will
      * populate the origin, config, and flags fields of the desc such that copySurface is more
@@ skipping 78 matching lines @@
                              const SkIPoint& dstPoint) = 0;
 
     /**
      * Sets source of vertex data for the next draw. Data does not have to be
      * in the buffer until drawIndexed, drawNonIndexed, or drawIndexedInstances.
      *
      * @param buffer        vertex buffer containing vertex data. Must be
      *                      unlocked before draw call. Vertex size is queried
      *                      from current GrDrawState.
      */
-    void setVertexSourceToBuffer(const GrVertexBuffer* buffer);
+    void setVertexSourceToBuffer(const GrVertexBuffer* buffer, size_t vertexStride);
 
     /**
      * Sets source of index data for the next indexed draw. Data does not have
      * to be in the buffer until drawIndexed.
      *
      * @param buffer index buffer containing indices. Must be unlocked
      *               before indexed draw call.
      */
     void setIndexSourceToBuffer(const GrIndexBuffer* buffer);
 
-    virtual void draw(const GrDrawTarget::DrawInfo&,
+    virtual void draw(const GrOptDrawState&,
+                      const GrDrawTarget::DrawInfo&,
                       const GrClipMaskManager::ScissorState&);
-    virtual void stencilPath(const GrPath*,
+    virtual void stencilPath(const GrOptDrawState&,
+                             const GrPath*,
                              const GrClipMaskManager::ScissorState&,
                              const GrStencilSettings&);
-    virtual void drawPath(const GrPath*,
+    virtual void drawPath(const GrOptDrawState&,
+                          const GrPath*,
                           const GrClipMaskManager::ScissorState&,
                           const GrStencilSettings&,
                           const GrDeviceCoordTexture* dstCopy);
-    virtual void drawPaths(const GrPathRange*,
+    virtual void drawPaths(const GrOptDrawState&,
+                           const GrPathRange*,
                            const uint32_t indices[],
                            int count,
                            const float transforms[],
                            GrDrawTarget::PathTransformType,
                            const GrClipMaskManager::ScissorState&,
                            const GrStencilSettings&,
                            const GrDeviceCoordTexture*);
 
-protected:
-    DrawType PrimTypeToDrawType(GrPrimitiveType type) {
+    static DrawType PrimTypeToDrawType(GrPrimitiveType type) {
         switch (type) {
             case kTriangles_GrPrimitiveType:
             case kTriangleStrip_GrPrimitiveType:
             case kTriangleFan_GrPrimitiveType:
                 return kDrawTriangles_DrawType;
             case kPoints_GrPrimitiveType:
                 return kDrawPoints_DrawType;
             case kLines_GrPrimitiveType:
             case kLineStrip_GrPrimitiveType:
                 return kDrawLines_DrawType;
             default:
                 SkFAIL("Unexpected primitive type");
                 return kDrawTriangles_DrawType;
         }
     }
 
+protected:
     // Functions used to map clip-respecting stencil tests into normal
     // stencil funcs supported by GPUs.
     static GrStencilFunc ConvertStencilFunc(bool stencilInClip,
                                             GrStencilFunc func);
     static void ConvertStencilFuncAndMask(GrStencilFunc func,
                                           bool clipInStencil,
                                           unsigned int clipBit,
                                           unsigned int userBits,
                                           unsigned int* ref,
                                           unsigned int* mask);
@@ skipping 45 matching lines @@
                          bool canIgnoreRect) = 0;
 
 
     // Overridden by backend specific classes to perform a clear of the stencil clip bits.  This is
     // ONLY used by the the clip target
     virtual void onClearStencilClip(GrRenderTarget*,
                                     const SkIRect& rect,
                                     bool insideClip) = 0;
 
     // overridden by backend-specific derived class to perform the draw call.
-    virtual void onDraw(const GrDrawTarget::DrawInfo&) = 0;
+    virtual void onDraw(const GrOptDrawState&, const GrDrawTarget::DrawInfo&) = 0;
 
     // overridden by backend-specific derived class to perform the read pixels.
     virtual bool onReadPixels(GrRenderTarget* target,
                               int left, int top, int width, int height,
                               GrPixelConfig,
                               void* buffer,
                               size_t rowBytes) = 0;
 
     // overridden by backend-specific derived class to perform the texture update
     virtual bool onWriteTexturePixels(GrTexture* texture,
                                       int left, int top, int width, int height,
                                       GrPixelConfig config, const void* buffer,
                                       size_t rowBytes) = 0;
 
     // overridden by backend-specific derived class to perform the resolve
     virtual void onResolveRenderTarget(GrRenderTarget* target) = 0;
 
     // width and height may be larger than rt (if underlying API allows it).
     // Should attach the SB to the RT. Returns false if compatible sb could
     // not be created.
     virtual bool createStencilBufferForRenderTarget(GrRenderTarget*, int width, int height) = 0;
 
     // attaches an existing SB to an existing RT.
     virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*) = 0;
 
     // The GrGpu typically records the clients requested state and then flushes
     // deltas from previous state at draw time. This function does the
     // backend-specific flush of the state.
     // returns false if current state is unsupported.
-    virtual bool flushGraphicsState(DrawType,
+    virtual bool flushGraphicsState(const GrOptDrawState&,
+                                    DrawType,
                                     const GrClipMaskManager::ScissorState&,
                                     const GrDeviceCoordTexture* dstCopy) = 0;
 
     // clears target's entire stencil buffer to 0
     virtual void clearStencil(GrRenderTarget* target) = 0;
 
     // Given a rt, find or create a stencil buffer and attach it
     bool attachStencilBufferToRenderTarget(GrRenderTarget* target);
 
     virtual void didAddGpuTraceMarker() = 0;
     virtual void didRemoveGpuTraceMarker() = 0;
 
     void resetContext() {
         this->onResetContext(fResetBits);
         fResetBits = 0;
         ++fResetTimestamp;
     }
 
     void handleDirtyContext() {
         if (fResetBits) {
             this->resetContext();
         }
     }
 
     GeometrySrcState                                                    fGeoSrcState;
     ResetTimestamp                                                      fResetTimestamp;
     uint32_t                                                            fResetBits;
     // these are mutable so they can be created on-demand
     mutable GrIndexBuffer*                                              fQuadIndexBuffer;
-    GrDrawState                                                         fDefaultDrawState;
-    GrDrawState*                                                        fDrawState;
     // To keep track that we always have at least as many debug marker adds as removes
     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