Remove GrContext from GrDrawTarget

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
@@ skipping 28 matching lines @@
 public:
     SK_DECLARE_INST_COUNT(GrDrawTarget)
 
     typedef GrPathRange::PathIndexType PathIndexType;
     typedef GrPathRendering::PathTransformType PathTransformType;
 
     ///////////////////////////////////////////////////////////////////////////
 
     // The context may not be fully constructed and should not be used during GrDrawTarget
     // construction.
-    GrDrawTarget(GrContext* context);
+    GrDrawTarget(GrGpu* gpu, GrResourceProvider*);
 
-    virtual ~GrDrawTarget() {}
+    virtual ~GrDrawTarget();
 
     /**
      * Empties the draw buffer of any queued up draws.
      */
     void reset() { this->onReset(); }
 
     /**
      * This plays any queued up draws to its GrGpu target. It also resets this object (i.e. flushing
      * is destructive).
      */
     void flush();
 
     /**
      * Gets the capabilities of the draw target.
      */
-    const GrCaps* caps() const { return fCaps.get(); }
+    const GrCaps* caps() const { return fCaps; }
 
     void drawBatch(GrPipelineBuilder*, GrBatch*);
 
     /**
      * Draws path into the stencil buffer. The fill must be either even/odd or
      * winding (not inverse or hairline). It will respect the HW antialias flag
      * on the GrPipelineBuilder (if possible in the 3D API).  Note, we will never have an inverse
      * fill with stencil path
      */
     void stencilPath(GrPipelineBuilder*, const GrPathProcessor*, const GrPath*,
@@ skipping 123 matching lines @@
                         const GrSurface* src,
                         const SkIRect& srcRect,
                         const SkIPoint& dstPoint);
 
     /**
      * Release any resources that are cached but not currently in use. This
      * is intended to give an application some recourse when resources are low.
      */
     virtual void purgeResources() {};
 
-    bool programUnitTest(int maxStages);
+    bool programUnitTest(GrContext* owner, int maxStages);
 
 protected:
     friend class GrCommandBuilder; // for PipelineInfo
     friend class GrInOrderCommandBuilder; // for PipelineInfo
     friend class GrReorderCommandBuilder; // for PipelineInfo
     friend class GrTargetCommands; // for PipelineInfo
 
-    GrContext* getContext() { return fContext; }
-    const GrContext* getContext() const { return fContext; }
-
-    GrGpu* getGpu() {
-        SkASSERT(fContext && fContext->getGpu());
-        return fContext->getGpu();
-    }
-    const GrGpu* getGpu() const {
-        SkASSERT(fContext && fContext->getGpu());
-        return fContext->getGpu();
-    }
+    GrGpu* getGpu() { return fGpu; }
+    const GrGpu* getGpu() const { return fGpu; }
 
     const GrTraceMarkerSet& getActiveTraceMarkers() { return fActiveTraceMarkers; }
 
     // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
     // but couldn't be made. Otherwise, returns true.  This method needs to be protected because it
     // needs to be accessed by GLPrograms to setup a correct drawstate
     bool setupDstReadIfNecessary(const GrPipelineBuilder&,
                                  const GrProcOptInfo& colorPOI,
                                  const GrProcOptInfo& coveragePOI,
                                  GrXferProcessor::DstTexture*,
@@ skipping 65 matching lines @@
     void getPathStencilSettingsForFilltype(GrPathRendering::FillType,
                                            const GrStencilAttachment*,
                                            GrStencilSettings*);
     virtual GrClipMaskManager* clipMaskManager() = 0;
     virtual bool setupClip(GrPipelineBuilder*,
                            GrPipelineBuilder::AutoRestoreFragmentProcessors*,
                            GrPipelineBuilder::AutoRestoreStencil*,
                            GrScissorState*,
                            const SkRect* devBounds) = 0;
 
-    // The context owns us, not vice-versa, so this ptr is not ref'ed by DrawTarget.
-    GrContext*                                                      fContext;
-    SkAutoTUnref<const GrCaps>                            fCaps;
+    GrGpu*                  fGpu;
+    const GrCaps*           fCaps;
+    GrResourceProvider*     fResourceProvider;
     // To keep track that we always have at least as many debug marker adds as removes
-    int                                                             fGpuTraceMarkerCount;
-    GrTraceMarkerSet                                                fActiveTraceMarkers;
-    GrTraceMarkerSet                                                fStoredTraceMarkers;
-    bool                                                            fFlushing;
+    int                     fGpuTraceMarkerCount;
+    GrTraceMarkerSet        fActiveTraceMarkers;
+    GrTraceMarkerSet        fStoredTraceMarkers;
+    bool                    fFlushing;
 
     typedef SkRefCnt INHERITED;
 };
 
 /*
  * This class is JUST for clip mask manager.  Everyone else should just use draw target above.
  */
 class GrClipTarget : public GrDrawTarget {
 public:
     GrClipTarget(GrContext*);
 
     /* Clip mask manager needs access to the context.
      * TODO we only need a very small subset of context in the CMM.
      */
-    GrContext* getContext() { return INHERITED::getContext(); }
-    const GrContext* getContext() const { return INHERITED::getContext(); }
+    GrContext* getContext() { return fContext; }
+    const GrContext* getContext() const { return fContext; }
 
     /**
      * Clip Mask Manager(and no one else) needs to clear private stencil bits.
      * ClipTarget subclass sets clip bit in the stencil buffer. The subclass
      * is free to clear the remaining bits to zero if masked clears are more
      * expensive than clearing all bits.
      */
     virtual void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* = NULL) = 0;
 
     /**
      * Release any resources that are cached but not currently in use. This
      * is intended to give an application some recourse when resources are low.
      */
     void purgeResources() override;
 
 protected:
     SkAutoTDelete<GrClipMaskManager> fClipMaskManager;
+    GrContext*                       fContext;
 
 private:
     GrClipMaskManager* clipMaskManager() override { return fClipMaskManager; }
 
     virtual bool setupClip(GrPipelineBuilder*,
                            GrPipelineBuilder::AutoRestoreFragmentProcessors*,
                            GrPipelineBuilder::AutoRestoreStencil*,
                            GrScissorState* scissorState,
                            const SkRect* devBounds) override;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif