GrTessellator: don't reuse the previous vertex buffer on a cache miss.

src/gpu/batches/GrTessellatingPathRenderer.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 "GrTessellatingPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 43 matching lines @@
     const TessInfo* info = static_cast<const TessInfo*>(data->data());
     if (info->fTolerance == 0 || info->fTolerance < 3.0f * tol) {
         *actualCount = info->fCount;
         return true;
     }
     return false;
 }
 
 class StaticVertexAllocator : public GrTessellator::VertexAllocator {
 public:
-    StaticVertexAllocator(SkAutoTUnref<GrVertexBuffer>& vertexBuffer,
-                          GrResourceProvider* resourceProvider,
-                          bool canMapVB)
-      : fVertexBuffer(vertexBuffer)
-      , fResourceProvider(resourceProvider)
+    StaticVertexAllocator(GrResourceProvider* resourceProvider, bool canMapVB)
+      : fResourceProvider(resourceProvider)
       , fCanMapVB(canMapVB)
       , fVertices(nullptr) {
     }
     SkPoint* lock(int vertexCount) override {
         size_t size = vertexCount * sizeof(SkPoint);
-        if (!fVertexBuffer.get() || fVertexBuffer->gpuMemorySize() < size) {
-            fVertexBuffer.reset(fResourceProvider->createVertexBuffer(
-                size, GrResourceProvider::kStatic_BufferUsage, 0));
-        }
+        fVertexBuffer.reset(fResourceProvider->createVertexBuffer(
+            size, GrResourceProvider::kStatic_BufferUsage, 0));
         if (!fVertexBuffer.get()) {
             return nullptr;
         }
         if (fCanMapVB) {
             fVertices = static_cast<SkPoint*>(fVertexBuffer->map());
         } else {
             fVertices = new SkPoint[vertexCount];
         }
         return fVertices;
     }
     void unlock(int actualCount) override {
         if (fCanMapVB) {
             fVertexBuffer->unmap();
         } else {
             fVertexBuffer->updateData(fVertices, actualCount * sizeof(SkPoint));
             delete[] fVertices;
         }
         fVertices = nullptr;
     }
+    GrVertexBuffer* vertexBuffer() { return fVertexBuffer.get(); }
 private:
-    SkAutoTUnref<GrVertexBuffer>& fVertexBuffer;
+    SkAutoTUnref<GrVertexBuffer> fVertexBuffer;
     GrResourceProvider* fResourceProvider;
     bool fCanMapVB;
     SkPoint* fVertices;
 };
 
 }  // namespace
 
 GrTessellatingPathRenderer::GrTessellatingPathRenderer() {
 }
 
@@ skipping 46 matching lines @@
         GrUniqueKey::Builder builder(&key, kDomain, 2 + clipBoundsSize32 + strokeDataSize32);
         builder[0] = fPath.getGenerationID();
         builder[1] = fPath.getFillType();
         // For inverse fills, the tessellation is dependent on clip bounds.
         if (fPath.isInverseFillType()) {
             memcpy(&builder[2], &fClipBounds, sizeof(fClipBounds));
         }
         fStroke.asUniqueKeyFragment(&builder[2 + clipBoundsSize32]);
         builder.finish();
         GrResourceProvider* rp = target->resourceProvider();
-        SkAutoTUnref<GrVertexBuffer> vertexBuffer(rp->findAndRefTByUniqueKey<GrVertexBuffer>(key));
+        SkAutoTUnref<GrVertexBuffer> cachedVertexBuffer(
+            rp->findAndRefTByUniqueKey<GrVertexBuffer>(key));
         int actualCount;
         SkScalar screenSpaceTol = GrPathUtils::kDefaultTolerance;
         SkScalar tol = GrPathUtils::scaleToleranceToSrc(
             screenSpaceTol, fViewMatrix, fPath.getBounds());
-        if (cache_match(vertexBuffer.get(), tol, &actualCount)) {
-            this->drawVertices(target, gp, vertexBuffer.get(), 0, actualCount);
+        if (cache_match(cachedVertexBuffer.get(), tol, &actualCount)) {
+            this->drawVertices(target, gp, cachedVertexBuffer.get(), 0, actualCount);
             return;
         }
 
         SkPath path;
         GrStrokeInfo stroke(fStroke);
         if (stroke.isDashed()) {
             if (!stroke.applyDashToPath(&path, &stroke, fPath)) {
                 return;
             }
         } else {
             path = fPath;
         }
         if (!stroke.isFillStyle()) {
             stroke.setResScale(SkScalarAbs(fViewMatrix.getMaxScale()));
             if (!stroke.applyToPath(&path, path)) {
                 return;
             }
             stroke.setFillStyle();
         }
         bool isLinear;
         bool canMapVB = GrCaps::kNone_MapFlags != target->caps().mapBufferFlags();
-        StaticVertexAllocator allocator(vertexBuffer, target->resourceProvider(), canMapVB);
+        StaticVertexAllocator allocator(rp, canMapVB);
         int count = GrTessellator::PathToTriangles(path, tol, fClipBounds, &allocator, &isLinear);
         if (count == 0) {
             return;
         }
-        this->drawVertices(target, gp, vertexBuffer.get(), 0, count);
+        this->drawVertices(target, gp, allocator.vertexBuffer(), 0, count);
         if (!fPath.isVolatile()) {
             TessInfo info;
             info.fTolerance = isLinear ? 0 : tol;
             info.fCount = count;
             SkAutoTUnref<SkData> data(SkData::NewWithCopy(&info, sizeof(info)));
             key.setCustomData(data.get());
-            target->resourceProvider()->assignUniqueKeyToResource(key, vertexBuffer.get());
+            rp->assignUniqueKeyToResource(key, allocator.vertexBuffer());
             SkPathPriv::AddGenIDChangeListener(fPath, new PathInvalidator(key));
         }
     }
 
     void onPrepareDraws(Target* target) const override {
         SkAutoTUnref<const GrGeometryProcessor> gp;
         {
             using namespace GrDefaultGeoProcFactory;
 
             Color color(fColor);
@@ skipping 108 matching lines @@
     bool result = viewMatrix.invert(&vmi);
     if (!result) {
         SkFAIL("Cannot invert matrix\n");
     }
     vmi.mapRect(&clipBounds);
     GrStrokeInfo strokeInfo = GrTest::TestStrokeInfo(random);
     return TessellatingPathBatch::Create(color, path, strokeInfo, viewMatrix, clipBounds);
 }
 
 #endif