Make GrBatchAtlas robust against attempts to add large rects.

src/gpu/batches/GrAADistanceFieldPathRenderer.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 207 matching lines @@
                                                  &vertexBuffer,
                                                  &flushInfo.fVertexOffset);
         flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
         flushInfo.fIndexBuffer.reset(target->resourceProvider()->refQuadIndexBuffer());
         if (!vertices || !flushInfo.fIndexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         flushInfo.fInstancesToFlush = 0;
+        // Pointer to the next set of vertices to write.
+        intptr_t offset = reinterpret_cast<intptr_t>(vertices);
         for (int i = 0; i < instanceCount; i++) {
             const Geometry& args = fGeoData[i];
 
             // get mip level
             SkScalar maxScale = this->viewMatrix().getMaxScale();
             const SkRect& bounds = args.fShape.bounds();
             SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height());
             SkScalar size = maxScale * maxDim;
             uint32_t desiredDimension;
             if (size <= kSmallMIP) {
@@ skipping 18 matching lines @@
                 shapeData = new ShapeData;
                 if (!this->addPathToAtlas(target,
                                           &flushInfo,
                                           atlas,
                                           shapeData,
                                           args.fShape,
                                           args.fAntiAlias,
                                           desiredDimension,
                                           scale)) {
                     SkDebugf("Can't rasterize path\n");
-                    return;
+                    continue;
                 }
             }
 
             atlas->setLastUseToken(shapeData->fID, target->nextDrawToken());
 
-            // Now set vertices
-            intptr_t offset = reinterpret_cast<intptr_t>(vertices);
-            offset += i * kVerticesPerQuad * vertexStride;
             this->writePathVertices(target,
                                     atlas,
                                     offset,
                                     args.fColor,
                                     vertexStride,
                                     this->viewMatrix(),
-                                    args.fShape,
                                     shapeData);
+            offset += kVerticesPerQuad * vertexStride;
             flushInfo.fInstancesToFlush++;
         }
 
         this->flush(target, &flushInfo);
     }
 
     bool addPathToAtlas(GrVertexBatch::Target* target,
                         FlushInfo* flushInfo,
                         GrBatchAtlas* atlas,
                         ShapeData* shapeData,
@@ skipping 70 matching lines @@
         SkAutoSMalloc<1024> dfStorage(width * height * sizeof(unsigned char));
 
         // Generate signed distance field
         SkGenerateDistanceFieldFromA8Image((unsigned char*)dfStorage.get(),
                                            (const unsigned char*)dst.addr(),
                                            dst.width(), dst.height(), dst.rowBytes());
 
         // add to atlas
         SkIPoint16 atlasLocation;
         GrBatchAtlas::AtlasID id;
-        bool success = atlas->addToAtlas(&id, target, width, height, dfStorage.get(),
-                                         &atlasLocation);
-        if (!success) {
+       if (!atlas->addToAtlas(&id, target, width, height, dfStorage.get(), &atlasLocation)) {
             this->flush(target, flushInfo);
-
-            SkDEBUGCODE(success =) atlas->addToAtlas(&id, target, width, height,
-                                                     dfStorage.get(), &atlasLocation);
-            SkASSERT(success);
-
+            if (!atlas->addToAtlas(&id, target, width, height, dfStorage.get(), &atlasLocation)) {
+                return false;
+            }
         }
 
         // add to cache
         shapeData->fKey.set(shape, dimension);
         shapeData->fScale = scale;
         shapeData->fID = id;
         // change the scaled rect to match the size of the inset distance field
         scaledBounds.fRight = scaledBounds.fLeft +
             SkIntToScalar(devPathBounds.width() - 2*SK_DistanceFieldInset);
         scaledBounds.fBottom = scaledBounds.fTop +
@@ skipping 15 matching lines @@
 #endif
         return true;
     }
 
     void writePathVertices(GrDrawBatch::Target* target,
                            GrBatchAtlas* atlas,
                            intptr_t offset,
                            GrColor color,
                            size_t vertexStride,
                            const SkMatrix& viewMatrix,
-                           const GrShape& shape,
                            const ShapeData* shapeData) const {
         GrTexture* texture = atlas->getTexture();
 
         SkScalar dx = shapeData->fBounds.fLeft;
         SkScalar dy = shapeData->fBounds.fTop;
         SkScalar width = shapeData->fBounds.width();
         SkScalar height = shapeData->fBounds.height();
 
         SkScalar invScale = 1.0f / shapeData->fScale;
         dx *= invScale;
@@ skipping 20 matching lines @@
         // vertex texture coords
         SkPoint* textureCoords = (SkPoint*)(offset + sizeof(SkPoint) + sizeof(GrColor));
         textureCoords->setRectFan(tx / texture->width(),
                                   ty / texture->height(),
                                   (tx + shapeData->fBounds.width()) / texture->width(),
                                   (ty + shapeData->fBounds.height())  / texture->height(),
                                   vertexStride);
     }
 
     void flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const {
-        GrMesh mesh;
-        int maxInstancesPerDraw =
-            static_cast<int>(flushInfo->fIndexBuffer->gpuMemorySize() / sizeof(uint16_t) / 6);
-        mesh.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
-            flushInfo->fIndexBuffer, flushInfo->fVertexOffset, kVerticesPerQuad,
-            kIndicesPerQuad, flushInfo->fInstancesToFlush, maxInstancesPerDraw);
-        target->draw(flushInfo->fGeometryProcessor.get(), mesh);
-        flushInfo->fVertexOffset += kVerticesPerQuad * flushInfo->fInstancesToFlush;
-        flushInfo->fInstancesToFlush = 0;
+        if (flushInfo->fInstancesToFlush) {
+            GrMesh mesh;
+            int maxInstancesPerDraw =
+                static_cast<int>(flushInfo->fIndexBuffer->gpuMemorySize() / sizeof(uint16_t) / 6);
+            mesh.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
+                flushInfo->fIndexBuffer, flushInfo->fVertexOffset, kVerticesPerQuad,
+                kIndicesPerQuad, flushInfo->fInstancesToFlush, maxInstancesPerDraw);
+            target->draw(flushInfo->fGeometryProcessor.get(), mesh);
+            flushInfo->fVertexOffset += kVerticesPerQuad * flushInfo->fInstancesToFlush;
+            flushInfo->fInstancesToFlush = 0;
+        }
     }
 
     GrColor color() const { return fGeoData[0].fColor; }
     const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         AADistanceFieldPathBatch* that = t->cast<AADistanceFieldPathBatch>();
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                     that->bounds(), caps)) {
@@ skipping 139 matching lines @@
                                         shape,
                                         antiAlias,
                                         viewMatrix,
                                         gTestStruct.fAtlas,
                                         &gTestStruct.fShapeCache,
                                         &gTestStruct.fShapeList,
                                         gammaCorrect);
 }
 
 #endif