Make GrTextContext be owned by the GrDrawContext

include/gpu/GrDrawContext.h

 /*
  * 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 GrDrawContext_DEFINED
 #define GrDrawContext_DEFINED
 
 #include "GrColor.h"
 #include "SkRefCnt.h"
 
 class GrBatch;
 class GrClip;
 class GrContext;
 class GrDrawTarget;
 class GrPaint;
 class GrPathProcessor;
 class GrPathRange;
 class GrPipelineBuilder;
 class GrRenderTarget;
 class GrStrokeInfo;
 class GrSurface;
+class GrTextContext;
+struct SkDeviceProperties;
+class SkDrawFilter;
 struct SkIPoint;
 struct SkIRect;
 class SkMatrix;
+class SkPaint;
 class SkPath;
 struct SkPoint;
 struct SkRect;
 class SkRRect;
-
+class SkTextBlob;
 
 /*
  * A helper object to orchestrate draws
  */
 class SK_API GrDrawContext : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrDrawContext)
 
+    ~GrDrawContext() override;
+
     void copySurface(GrRenderTarget* dst, GrSurface* src,
                      const SkIRect& srcRect, const SkIPoint& dstPoint);
 
-    // drawText and drawPaths are thanks to the GrAtlasTextContext and the 
-    // GrStencilAndCoverTextContext respectively
-    // TODO: remove these two
-    void drawText(GrPipelineBuilder* pipelineBuilder, GrBatch* batch);
+    void drawText(GrRenderTarget*, const GrClip&,  const GrPaint&, const SkPaint&,

[bsalomon, 2015/06/11 01:47:57]

Can we have a TODO (here or a bug) to remove the need for SkPaint? It seems
weird that we pass both paints. It'd be cleaner to extract the text params from
SkPaint and not pass the whole thing (equivalent to GrStrokeInfo).

[robertphillips, 2015/06/16 16:52:37]

Done.

+                  const SkMatrix& viewMatrix, const char text[], size_t byteLength,
+                  SkScalar x, SkScalar y, const SkIRect& clipBounds);
+    void drawPosText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&,
+                     const SkMatrix& viewMatrix, const char text[], size_t byteLength,
+                     const SkScalar pos[], int scalarsPerPosition,
+                     const SkPoint& offset, const SkIRect& clipBounds);
+    void drawTextBlob(GrRenderTarget*, const GrClip&, const SkPaint&,
+                      const SkMatrix& viewMatrix, const SkTextBlob*,
+                      SkScalar x, SkScalar y,
+                      SkDrawFilter*, const SkIRect& clipBounds);
 
+    // drawPaths is thanks to GrStencilAndCoverTextContext
+    // TODO: remove
     void drawPaths(GrPipelineBuilder* pipelineBuilder,
                    const GrPathProcessor* pathProc,
                    const GrPathRange* pathRange,
                    const void* indices,
                    int /*GrDrawTarget::PathIndexType*/ indexType,
                    const float transformValues[],
                    int /*GrDrawTarget::PathTransformType*/ transformType,
                    int count,
                    int /*GrPathRendering::FillType*/ fill);
 
@@ skipping 157 matching lines @@
      */
     void drawOval(GrRenderTarget*,
                   const GrClip&,
                   const GrPaint& paint,
                   const SkMatrix& viewMatrix,
                   const SkRect& oval,
                   const GrStrokeInfo& strokeInfo);
 
 
 private:
+    friend class GrAtlasTextContext; // for access to drawBatch
     friend class GrContext; // for ctor
 
-    GrDrawContext(GrContext* context, GrDrawTarget* drawTarget);
-    ~GrDrawContext() override;
+    GrDrawContext(GrContext*, GrDrawTarget*, const SkDeviceProperties&, bool useDFT);
 
     // Sets the paint. Returns true on success; false on failure.
     bool prepareToDraw(GrPipelineBuilder*,
                        GrRenderTarget* rt,
                        const GrClip&,
                        const GrPaint* paint);
+    GrTextContext* createTextContext(GrRenderTarget*, const SkDeviceProperties&, bool useDFT);
 
     // A simpler version of the above which just returns true on success; false on failure.  
     // Clip is *NOT* set
     bool prepareToDraw(GrRenderTarget* rt);
 
     void internalDrawPath(GrDrawTarget*,
                           GrPipelineBuilder*,
                           const SkMatrix& viewMatrix,
                           GrColor,
                           bool useAA,
                           const SkPath&,
                           const GrStrokeInfo&);
 
-    GrContext*     fContext;     // owning context -> no ref
-    GrDrawTarget*  fDrawTarget;
+    // This entry point allows the GrTextContext-derived classes to add their batches to
+    // the drawTarget.
+    void drawBatch(GrPipelineBuilder* pipelineBuilder, GrBatch* batch);
+
+    GrContext*          fContext;     // owning context -> no ref
+    GrDrawTarget*       fDrawTarget;
+    GrTextContext*      fTextContext; // lazily created

[bsalomon, 2015/06/11 01:47:57]

would we share these in the future when there is a DC per RT? Curious cuz the DC
params from TC draw methods are removed.

[robertphillips, 2015/06/16 16:52:37]

I think the TextContexts will have to morph a bit when we have a DC per RT. It
seems like we would want a portion that is specific to each DC (that, say, hold
the glyph bitmaps that need to be uploaded to flush the DC) and a portion that
is shared (which, say, manage the caches).

+
+    SkDeviceProperties* fDevProps;    // ptr b.c. SkDeviceProperties isn't public
+    bool                fUseDFT;
 };
 
 #endif