Make GrTextContext be owned by the GrDrawContext

src/gpu/GrDrawContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
+#include "GrAtlasTextContext.h"
 #include "GrBatch.h"
 #include "GrBatchTest.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawContext.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
+#include "GrRenderTarget.h"
+#include "GrRenderTargetPriv.h"
+#include "GrStencilAndCoverTextContext.h"
 
 #define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == fContext)
 #define RETURN_IF_ABANDONED        if (!fDrawTarget) { return; }
 #define RETURN_FALSE_IF_ABANDONED  if (!fDrawTarget) { return false; }
 #define RETURN_NULL_IF_ABANDONED   if (!fDrawTarget) { return NULL; }
 
 class AutoCheckFlush {
 public:
     AutoCheckFlush(GrContext* context) : fContext(context) { SkASSERT(context); }
     ~AutoCheckFlush() { fContext->flushIfNecessary(); }
 
 private:
     GrContext* fContext;
 };
 
-GrDrawContext::GrDrawContext(GrContext* context, GrDrawTarget* drawTarget)
+GrDrawContext::GrDrawContext(GrContext* context,
+                             GrDrawTarget* drawTarget,
+                             const SkDeviceProperties& devProps,
+                             bool useDFT)
     : fContext(context)
-    , fDrawTarget(SkRef(drawTarget)) {
+    , fDrawTarget(SkRef(drawTarget))
+    , fTextContext(NULL)
+    , fDevProps(SkNEW_ARGS(SkDeviceProperties, (devProps)))
+    , fUseDFT(useDFT) {
 }
 
 GrDrawContext::~GrDrawContext() {
     SkSafeUnref(fDrawTarget);
+    SkDELETE(fTextContext);
+    SkDELETE(fDevProps);
 }
 
 void GrDrawContext::copySurface(GrRenderTarget* dst, GrSurface* src,
                                 const SkIRect& srcRect, const SkIPoint& dstPoint) {
     if (!this->prepareToDraw(dst)) {
         return;
     }
 
     fDrawTarget->copySurface(dst, src, srcRect, dstPoint);
 }
 
-void GrDrawContext::drawText(GrPipelineBuilder* pipelineBuilder, GrBatch* batch) {
-    fDrawTarget->drawBatch(pipelineBuilder, batch);
+GrTextContext* GrDrawContext::createTextContext(GrRenderTarget* renderTarget,
+                                                const SkDeviceProperties& leakyProperties,
+                                                bool enableDistanceFieldFonts) {
+    if (fContext->caps()->shaderCaps()->pathRenderingSupport() && renderTarget->isMultisampled()) {
+        GrStencilAttachment* sb = renderTarget->renderTargetPriv().attachStencilAttachment();
+        if (sb) {
+            return GrStencilAndCoverTextContext::Create(fContext, this, 
+                                                        leakyProperties,
+                                                        enableDistanceFieldFonts);
+        }
+    } 
+
+    return GrAtlasTextContext::Create(fContext, this, leakyProperties, enableDistanceFieldFonts);
+}
+
+void GrDrawContext::drawText(GrRenderTarget* rt, const GrClip& clip, const GrPaint& grPaint,
+                             const SkPaint& skPaint,
+                             const SkMatrix& viewMatrix,
+                             const char text[], size_t byteLength,
+                             SkScalar x, SkScalar y, const SkIRect& clipBounds) {
+    if (!fTextContext) {
+        fTextContext = this->createTextContext(rt, *fDevProps, fUseDFT);
+    }
+
+    fTextContext->drawText(rt, clip, grPaint, skPaint, viewMatrix,
+                           text, byteLength, x, y, clipBounds);
+
+}
+void GrDrawContext::drawPosText(GrRenderTarget* rt, const GrClip& clip, const GrPaint& grPaint,
+                                const SkPaint& skPaint,
+                                const SkMatrix& viewMatrix,
+                                const char text[], size_t byteLength,
+                                const SkScalar pos[], int scalarsPerPosition,
+                                const SkPoint& offset, const SkIRect& clipBounds) {
+    if (!fTextContext) {
+        fTextContext = this->createTextContext(rt, *fDevProps, fUseDFT);
+    }
+
+    fTextContext->drawPosText(rt, clip, grPaint, skPaint, viewMatrix, text, byteLength,
+                               pos, scalarsPerPosition, offset, clipBounds);
+
+}
+void GrDrawContext::drawTextBlob(GrRenderTarget* rt, const GrClip& clip, const SkPaint& skPaint,
+                                 const SkMatrix& viewMatrix, const SkTextBlob* blob,
+                                 SkScalar x, SkScalar y,
+                                 SkDrawFilter* filter, const SkIRect& clipBounds) {
+    if (!fTextContext) {
+        fTextContext = this->createTextContext(rt, *fDevProps, fUseDFT);
+    }
+
+    fTextContext->drawTextBlob(rt, clip, skPaint, viewMatrix, blob, x, y, filter, clipBounds);
 }
 
 void GrDrawContext::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,
@@ skipping 1078 matching lines @@
 }
 
 bool GrDrawContext::prepareToDraw(GrRenderTarget* rt) {
     RETURN_FALSE_IF_ABANDONED
 
     ASSERT_OWNED_RESOURCE(rt);
     SkASSERT(rt);
     return true;
 }
 
+void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrBatch* batch) {
+    fDrawTarget->drawBatch(pipelineBuilder, batch);
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 BATCH_TEST_DEFINE(StrokeRectBatch) {
     StrokeRectBatch::Geometry geometry;
     geometry.fViewMatrix = GrTest::TestMatrix(random);
     geometry.fColor = GrRandomColor(random);
     geometry.fRect = GrTest::TestRect(random);
     geometry.fStrokeWidth = random->nextBool() ? 0.0f : 1.0f;
@@ skipping 107 matching lines @@
     return DrawVerticesBatch::Create(geometry, type, viewMatrix,
                                      positions.begin(), vertexCount,
                                      indices.begin(), hasIndices ? vertexCount : 0,
                                      colors.begin(),
                                      texCoords.begin(),
                                      bounds);
 }
 
 #endif