Make GrBatchAtlas robust against attempts to add large rects.

src/gpu/GrBatchAtlas.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 "GrBatchAtlas.h"
 #include "GrBatchFlushState.h"
 #include "GrRectanizer.h"
@@ skipping 98 matching lines @@
     fDirtyRect.setEmpty();
     SkDEBUGCODE(fDirty = false;)
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrBatchAtlas::GrBatchAtlas(GrTexture* texture, int numPlotsX, int numPlotsY)
     : fTexture(texture)
     , fAtlasGeneration(kInvalidAtlasGeneration + 1) {
 
-    int plotWidth = texture->width() / numPlotsX;
-    int plotHeight = texture->height() / numPlotsY;
+    fPlotWidth = texture->width() / numPlotsX;
+    fPlotHeight = texture->height() / numPlotsY;
     SkASSERT(numPlotsX * numPlotsY <= BulkUseTokenUpdater::kMaxPlots);
-    SkASSERT(plotWidth * numPlotsX == texture->width());
-    SkASSERT(plotHeight * numPlotsY == texture->height());
+    SkASSERT(fPlotWidth * numPlotsX == texture->width());
+    SkASSERT(fPlotHeight * numPlotsY == texture->height());
 
     SkDEBUGCODE(fNumPlots = numPlotsX * numPlotsY;)
 
     // We currently do not support compressed atlases...
     SkASSERT(!GrPixelConfigIsCompressed(texture->desc().fConfig));
 
     // set up allocated plots
     fPlotArray = new SkAutoTUnref<BatchPlot>[numPlotsX * numPlotsY];
 
     SkAutoTUnref<BatchPlot>* currPlot = fPlotArray;
     for (int y = numPlotsY - 1, r = 0; y >= 0; --y, ++r) {
         for (int x = numPlotsX - 1, c = 0; x >= 0; --x, ++c) {
             uint32_t index = r * numPlotsX + c;
-            currPlot->reset(new BatchPlot(index, 1, x, y, plotWidth, plotHeight,
+            currPlot->reset(new BatchPlot(index, 1, x, y, fPlotWidth, fPlotHeight,
                                           texture->desc().fConfig));
 
             // build LRU list
             fPlotList.addToHead(currPlot->get());
             ++currPlot;
         }
     }
 }
 
 GrBatchAtlas::~GrBatchAtlas() {
@@ skipping 24 matching lines @@
         );
         plot->setLastUploadToken(lastUploadToken);
     }
     *id = plot->id();
 }
 
 bool GrBatchAtlas::addToAtlas(AtlasID* id, GrDrawBatch::Target* target,
                               int width, int height, const void* image, SkIPoint16* loc) {
     // We should already have a texture, TODO clean this up
     SkASSERT(fTexture);
+    if (width > fPlotWidth || height > fPlotHeight) {
+        return false;
+    }
 
     // now look through all allocated plots for one we can share, in Most Recently Refed order
     GrBatchPlotList::Iter plotIter;
     plotIter.init(fPlotList, GrBatchPlotList::Iter::kHead_IterStart);
     BatchPlot* plot;
     while ((plot = plotIter.get())) {
         SkASSERT(GrBytesPerPixel(fTexture->desc().fConfig) == plot->bpp());
         if (plot->addSubImage(width, height, image, loc)) {
             this->updatePlot(target, id, plot);
             return true;
@@ skipping 47 matching lines @@
             plotsp->uploadToTexture(writePixels, texture);
         }
     );
     newPlot->setLastUploadToken(lastUploadToken);
 
     *id = newPlot->id();
 
     fAtlasGeneration++;
     return true;
 }