fix for using too much memory in GrBatchAtlas

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 "GrBatchTarget.h"
 #include "GrGpu.h"
@@ skipping 32 matching lines @@
     int genID() const { return fGenID; }
     GrBatchAtlas::AtlasID id() { return fID; }
 
     GrTexture* texture() const { return fTexture; }
 
     bool addSubImage(int width, int height, const void* image, SkIPoint16* loc, size_t rowBytes)  {
         if (!fRects->addRect(width, height, loc)) {
             return false;
         }
 
-        SkASSERT(fData);
+        if (!fData) {
+            fData = reinterpret_cast<unsigned char*>(sk_calloc_throw(fBytesPerPixel * fWidth *
+                                                                     fHeight));
+        }
         const unsigned char* imagePtr = (const unsigned char*)image;
         // point ourselves at the right starting spot
         unsigned char* dataPtr = fData;
         dataPtr += fBytesPerPixel * fWidth * loc->fY;
         dataPtr += fBytesPerPixel * loc->fX;
         // copy into the data buffer
         for (int i = 0; i < height; ++i) {
             memcpy(dataPtr, imagePtr, rowBytes);
             dataPtr += fBytesPerPixel * fWidth;
             imagePtr += rowBytes;
@@ skipping 17 matching lines @@
         SkASSERT(batchToken >= fLastUpload);
         fLastUpload = batchToken;
     }
     void setLastUseToken(BatchToken batchToken) {
         SkASSERT(batchToken >= fLastUse);
         fLastUse = batchToken;
     }
 
     void uploadToTexture(GrBatchTarget::TextureUploader uploader)  {
         // We should only be issuing uploads if we are in fact dirty
-        SkASSERT(fDirty);
+        SkASSERT(fDirty && fData && fTexture);
         TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), "GrBatchPlot::uploadToTexture");
-        SkASSERT(fTexture);
         size_t rowBytes = fBytesPerPixel * fRects->width();
         const unsigned char* dataPtr = fData;
         dataPtr += rowBytes * fDirtyRect.fTop;
         dataPtr += fBytesPerPixel * fDirtyRect.fLeft;
         uploader.writeTexturePixels(fTexture,
                                     fOffset.fX + fDirtyRect.fLeft, fOffset.fY + fDirtyRect.fTop,
                                     fDirtyRect.width(), fDirtyRect.height(),
                                     fTexture->config(), dataPtr, rowBytes);
         fDirtyRect.setEmpty();
         SkDEBUGCODE(fDirty = false;)
     }
 
     void resetRects() {
         SkASSERT(fRects);
         fRects->reset();
         fGenID++;
         fID = create_id(fIndex, fGenID);
 
         // zero out the plot
-        SkASSERT(fData);
-        memset(fData, 0, fBytesPerPixel * fWidth * fHeight);
+        if (fData) {
+            sk_bzero(fData, fBytesPerPixel * fWidth * fHeight);
+        }
 
         fDirtyRect.setEmpty();
         SkDEBUGCODE(fDirty = false;)
     }
 
     int x() const { return fX; }
     int y() const { return fY; }
 
 private:
     BatchPlot()
@@ skipping 34 matching lines @@
         fX = offX;
         fY = offY;
         fRects = GrRectanizer::Factory(width, height);
         fAtlas = atlas;
         fOffset.set(offX * width, offY * height);
         fBytesPerPixel = bpp;
         fData = NULL;
         fDirtyRect.setEmpty();
         SkDEBUGCODE(fDirty = false;)
         fTexture = texture;
-
-        // allocate backing store
-        fData = SkNEW_ARRAY(unsigned char, fBytesPerPixel * width * height);
-        memset(fData, 0, fBytesPerPixel * width * height);
     }
 
     BatchToken fLastUpload;
     BatchToken fLastUse;
 
     uint32_t fIndex;
     uint32_t fGenID;
     GrBatchAtlas::AtlasID fID;
     unsigned char* fData;
     int fWidth;
@@ skipping 183 matching lines @@
 }
 
 void GrBatchAtlas::setLastUseTokenBulk(const BulkUseTokenUpdater& updater, BatchToken batchToken) {
     int count = updater.fPlotsToUpdate.count();
     for (int i = 0; i < count; i++) {
         BatchPlot* plot = fPlotArray[updater.fPlotsToUpdate[i]];
         this->makeMRU(plot);
         plot->setLastUseToken(batchToken);
     }
 }