Refactor GrGpu path rendering functions to GrPathRendering

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 "GrPipelineBuilder.h"
 #include "GrProgramDesc.h"
+#include "GrStencil.h"
+#include "GrTraceMarker.h"
+#include "GrXferProcessor.h"
 #include "SkPath.h"
 
+class GrBatchTracker;
 class GrContext;
 struct GrGLInterface;
+class GrIndexBuffer;
 class GrNonInstancedVertices;
 class GrPath;
 class GrPathRange;
 class GrPathRenderer;
 class GrPathRendererChain;
+class GrPathRendering;
 class GrPipeline;
 class GrPrimitiveProcessor;
+class GrRenderTarget;
 class GrStencilAttachment;
+class GrSurface;
+class GrTexture;
+class GrVertexBuffer;
 class GrVertices;
 
 class GrGpu : public SkRefCnt {
 public:
     /**
      * Create an instance of GrGpu that matches the specified backend. If the requested backend is
      * not supported (at compile-time or run-time) this returns NULL. The context will not be
      * fully constructed and should not be used by GrGpu until after this function returns.
      */
     static GrGpu* Create(GrBackend, GrBackendContext, const GrContextOptions&, GrContext* context);
 
     ////////////////////////////////////////////////////////////////////////////
 
     GrGpu(GrContext* context);
     ~GrGpu() override;
 
     GrContext* getContext() { return fContext; }
     const GrContext* getContext() const { return fContext; }
 
     /**
      * Gets the capabilities of the draw target.
      */
     const GrCaps* caps() const { return fCaps.get(); }
 
-    GrPathRendering* pathRendering() { return fPathRendering.get(); }
+    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();
 
     /**
      * The GrGpu object normally assumes that no outsider is setting state
      * within the underlying 3D API's context/device/whatever. This call informs
@@ skipping 231 matching lines @@
             SkASSERT(primProc && pipeline && desc && batchTracker);
         }
         const GrPrimitiveProcessor* fPrimitiveProcessor;
         const GrPipeline* fPipeline;
         const GrProgramDesc* fDesc;
         const GrBatchTracker* fBatchTracker;
     };
 
     void draw(const DrawArgs&, const GrVertices&);
 
-    /** None of these params are optional, pointers used just to avoid making copies. */
-    struct StencilPathState {
-        bool fUseHWAA;
-        GrRenderTarget* fRenderTarget;
-        const SkMatrix* fViewMatrix;
-        const GrStencilSettings* fStencil;
-        const GrScissorState* fScissor;
-    };
-
-    void stencilPath(const GrPath*, const StencilPathState&);
-
-    void drawPath(const DrawArgs&, const GrPath*, const GrStencilSettings&);
-    void drawPaths(const DrawArgs&,
-                   const GrPathRange*,
-                   const void* indices,
-                   GrDrawTarget::PathIndexType,
-                   const float transformValues[],
-                   GrDrawTarget::PathTransformType,
-                   int count,
-                   const GrStencilSettings&);
-
     ///////////////////////////////////////////////////////////////////////////
     // Debugging and Stats
 
     class Stats {
     public:
 #if GR_GPU_STATS
         Stats() { this->reset(); }
 
         void reset() {
             fRenderTargetBinds = 0;
@@ skipping 99 matching lines @@
     virtual void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color,
                          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 DrawArgs&, const GrNonInstancedVertices&) = 0;
-    virtual void onStencilPath(const GrPath*, const StencilPathState&) = 0;
 
-    virtual void onDrawPath(const DrawArgs&, const GrPath*, const GrStencilSettings&) = 0;
-    virtual void onDrawPaths(const DrawArgs&,
-                             const GrPathRange*,
-                             const void* indices,
-                             GrDrawTarget::PathIndexType,
-                             const float transformValues[],
-                             GrDrawTarget::PathTransformType,
-                             int count,
-                             const GrStencilSettings&) = 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,
@@ skipping 30 matching lines @@
 
     ResetTimestamp                                                      fResetTimestamp;
     uint32_t                                                            fResetBits;
     // 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;
 
+    friend class GrPathRendering;
     typedef SkRefCnt INHERITED;
 };
 
 #endif