Dynamically allocate the GrDrawContexts

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 "GrAtlasTextContext.h"
 #include "GrBatchTest.h"
 #include "GrColor.h"
 #include "GrDrawContext.h"
 #include "GrOvalRenderer.h"
 #include "GrPathRenderer.h"
 #include "GrRenderTarget.h"
 #include "GrRenderTargetPriv.h"
 #include "GrResourceProvider.h"
 #include "GrStencilAndCoverTextContext.h"
+#include "SkSurfacePriv.h"
 
 #include "batches/GrBatch.h"
 #include "batches/GrDrawAtlasBatch.h"
 #include "batches/GrDrawVerticesBatch.h"
 #include "batches/GrRectBatchFactory.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 nullptr; }
+#define RETURN_IF_ABANDONED        if (fContext->abandoned()) { return; }
+#define RETURN_FALSE_IF_ABANDONED  if (fContext->abandoned()) { return false; }
+#define RETURN_NULL_IF_ABANDONED   if (fContext->abandoned()) { return nullptr; }
 
 class AutoCheckFlush {
 public:
     AutoCheckFlush(GrContext* context) : fContext(context) { SkASSERT(context); }
     ~AutoCheckFlush() { fContext->flushIfNecessary(); }
 
 private:
     GrContext* fContext;
 };
 
 GrDrawContext::GrDrawContext(GrContext* context,
                              GrDrawTarget* drawTarget,
-                             const SkSurfaceProps& surfaceProps)
+                             const SkSurfaceProps* surfaceProps)
     : fContext(context)
     , fDrawTarget(SkRef(drawTarget))
     , fTextContext(nullptr)
-    , fSurfaceProps(surfaceProps) {
+    , fSurfaceProps(SkSurfacePropsCopyOrDefault(surfaceProps)) {
 }
 
 GrDrawContext::~GrDrawContext() {
     SkSafeUnref(fDrawTarget);
-    delete fTextContext;
 }
 
 void GrDrawContext::copySurface(GrRenderTarget* dst, GrSurface* src,
                                 const SkIRect& srcRect, const SkIPoint& dstPoint) {
+    RETURN_IF_ABANDONED
+
     if (!this->prepareToDraw(dst)) {
         return;
     }
 
     fDrawTarget->copySurface(dst, src, srcRect, dstPoint);
 }
 
-GrTextContext* GrDrawContext::createTextContext(GrRenderTarget* renderTarget,
-                                                const SkSurfaceProps& surfaceProps) {
-    if (fContext->caps()->shaderCaps()->pathRenderingSupport() &&
-        renderTarget->isStencilBufferMultisampled() &&
-        fSurfaceProps.isUseDeviceIndependentFonts()) {
-        GrStencilAttachment* sb =
-            fContext->resourceProvider()->attachStencilAttachment(renderTarget);
-        if (sb) {
-            return GrStencilAndCoverTextContext::Create(fContext, surfaceProps);
-        }
-    } 
-
-    return GrAtlasTextContext::Create(fContext, surfaceProps);
-}
 
 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) {
+    RETURN_IF_ABANDONED
+
     if (!fTextContext) {
-        fTextContext = this->createTextContext(rt, fSurfaceProps);
+        fTextContext = fContext->textContext(fSurfaceProps, rt);
     }
 
     fTextContext->drawText(this, 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) {
+    RETURN_IF_ABANDONED
+
     if (!fTextContext) {
-        fTextContext = this->createTextContext(rt, fSurfaceProps);
+        fTextContext = fContext->textContext(fSurfaceProps, rt);
     }
 
     fTextContext->drawPosText(this, 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) {
+    RETURN_IF_ABANDONED
+
     if (!fTextContext) {
-        fTextContext = this->createTextContext(rt, fSurfaceProps);
+        fTextContext = fContext->textContext(fSurfaceProps, rt);
     }
 
     fTextContext->drawTextBlob(this, rt,
                                clip, skPaint, viewMatrix, blob, x, y, filter, clipBounds);
 }
 
 void GrDrawContext::drawPathsFromRange(const GrPipelineBuilder* pipelineBuilder,
                                        const SkMatrix& viewMatrix,
                                        const SkMatrix& localMatrix,
                                        GrColor color,
                                        GrPathRangeDraw* draw,
                                        int /*GrPathRendering::FillType*/ fill) {
+    RETURN_IF_ABANDONED
+
     fDrawTarget->drawPathsFromRange(*pipelineBuilder, viewMatrix, localMatrix, color, draw,
                                     (GrPathRendering::FillType) fill);
 }
 
 void GrDrawContext::discard(GrRenderTarget* renderTarget) {
     RETURN_IF_ABANDONED
     SkASSERT(renderTarget);
     AutoCheckFlush acf(fContext);
     if (!this->prepareToDraw(renderTarget)) {
         return;
@@ skipping 622 matching lines @@
 
 bool GrDrawContext::prepareToDraw(GrRenderTarget* rt) {
     RETURN_FALSE_IF_ABANDONED
 
     ASSERT_OWNED_RESOURCE(rt);
     SkASSERT(rt);
     return true;
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
+    RETURN_IF_ABANDONED
+
     fDrawTarget->drawBatch(*pipelineBuilder, batch);
 }