Add mip support to *DeferredTextureImageData functions.

src/image/SkImage_Gpu.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAutoPixmapStorage.h"
 #include "GrCaps.h"
 #include "GrContext.h"
@@ skipping 310 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class DeferredTextureImage {
 public:
     SkImage* newImage(GrContext* context, SkBudgeted) const;
 
 private:
     uint32_t fContextUniqueID;
+    struct MipMapLevelData {
+        void* fPixelData;
+        size_t fRowBytes;
+    };
     struct Data {
         SkImageInfo fInfo;
-        void*       fPixelData;
-        size_t      fRowBytes;
         int         fColorTableCnt;
         uint32_t*   fColorTableData;
+        int         fMipMapLevelCount;
+        // The fMipMapLevelData array may contain more than 1 element.
+        // It contains fMipMapLevelCount elements.
+        // That means this struct's size is not known at compile-time.
+        MipMapLevelData fMipMapLevelData[1];
     };
     Data fData;
 
     friend class SkImage;
 };
 
 size_t SkImage::getDeferredTextureImageData(const GrContextThreadSafeProxy& proxy,
                                             const DeferredTextureImageUsageParams[],
                                             int paramCnt, void* buffer) const {
     const bool fillMode = SkToBool(buffer);
@@ skipping 30 matching lines @@
         info = SkImageInfo::MakeN32(this->width(), this->height(), at);
         pixelSize = SkAlign8(SkAutoPixmapStorage::AllocSize(info, nullptr));
         if (fillMode) {
             pixmap.alloc(info);
             if (!this->readPixels(pixmap, 0, 0, SkImage::kDisallow_CachingHint)) {
                 return 0;
             }
             SkASSERT(!pixmap.ctable());
         }
     }
+    int mipMapLevelCount = 1;
     size_t size = 0;
     size_t dtiSize = SkAlign8(sizeof(DeferredTextureImage));
     size += dtiSize;
+    size += mipMapLevelCount * sizeof(DeferredTextureImage::MipMapLevelData);
     size_t pixelOffset = size;
     size += pixelSize;
     size_t ctOffset = size;
     size += ctSize;
     if (!fillMode) {
         return size;
     }
     intptr_t bufferAsInt = reinterpret_cast<intptr_t>(buffer);
     void* pixels = reinterpret_cast<void*>(bufferAsInt + pixelOffset);
     SkPMColor* ct = nullptr;
     if (ctSize) {
         ct = reinterpret_cast<SkPMColor*>(bufferAsInt + ctOffset);
     }
 
     memcpy(pixels, pixmap.addr(), pixmap.getSafeSize());
     if (ctSize) {
         memcpy(ct, pixmap.ctable()->readColors(), ctSize);
     }
 
     SkASSERT(info == pixmap.info());
     size_t rowBytes = pixmap.rowBytes();
     DeferredTextureImage* dti = new (buffer) DeferredTextureImage();
     dti->fContextUniqueID = proxy.fContextUniqueID;
     dti->fData.fInfo = info;
-    dti->fData.fPixelData = pixels;
-    dti->fData.fRowBytes = rowBytes;
     dti->fData.fColorTableCnt = ctCount;
     dti->fData.fColorTableData = ct;
+    dti->fData.fMipMapLevelCount = mipMapLevelCount;
+    dti->fData.fMipMapLevelData[0].fPixelData = pixels;
+    dti->fData.fMipMapLevelData[0].fRowBytes = rowBytes;
     return size;
 }
 
 sk_sp<SkImage> SkImage::MakeFromDeferredTextureImageData(GrContext* context, const void* data,
                                                          SkBudgeted budgeted) {
     if (!data) {
         return nullptr;
     }
     const DeferredTextureImage* dti = reinterpret_cast<const DeferredTextureImage*>(data);
 
     if (!context || context->uniqueID() != dti->fContextUniqueID) {
         return nullptr;
     }
     SkAutoTUnref<SkColorTable> colorTable;
     if (dti->fData.fColorTableCnt) {
         SkASSERT(dti->fData.fColorTableData);
         colorTable.reset(new SkColorTable(dti->fData.fColorTableData, dti->fData.fColorTableCnt));
     }
+    SkASSERT(dti->fData.fMipMapLevelCount == 1);
     SkPixmap pixmap;
-    pixmap.reset(dti->fData.fInfo, dti->fData.fPixelData, dti->fData.fRowBytes, colorTable.get());
+    pixmap.reset(dti->fData.fInfo, dti->fData.fMipMapLevelData[0].fPixelData,
+                 dti->fData.fMipMapLevelData[0].fRowBytes, colorTable.get());
     return SkImage::MakeTextureFromPixmap(context, pixmap, budgeted);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrTexture* GrDeepCopyTexture(GrTexture* src, SkBudgeted budgeted) {
     GrContext* ctx = src->getContext();
 
     GrSurfaceDesc desc = src->desc();
     GrTexture* dst = ctx->textureProvider()->createTexture(desc, budgeted, nullptr, 0);
     if (!dst) {
         return nullptr;
     }
 
     const SkIRect srcR = SkIRect::MakeWH(desc.fWidth, desc.fHeight);
     const SkIPoint dstP = SkIPoint::Make(0, 0);
     ctx->copySurface(dst, src, srcR, dstP);
     ctx->flushSurfaceWrites(dst);
     return dst;
 }