Don't allow nullptr in texels array params (unless using a transfer buffer).

src/gpu/gl/GrGLGpu.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLGpu.h"
 #include "GrGLGLSL.h"
 #include "GrGLStencilAttachment.h"
@@ skipping 908 matching lines @@
  * @param caps           The capabilities of the GL device.
  * @param internalFormat The data format used for the internal storage of the texture.
  * @param externalFormat The data format used for the external storage of the texture.
  * @param externalType   The type of the data used for the external storage of the texture.
  * @param texels         The texel data of the texture being created.
  * @param baseWidth      The width of the texture's base mipmap level
  * @param baseHeight     The height of the texture's base mipmap level
  * @param succeeded      Set to true if allocating and populating the texture completed
  *                       without error.
  */
-static void allocate_and_populate_uncompressed_texture(const GrSurfaceDesc& desc,
+static bool allocate_and_populate_uncompressed_texture(const GrSurfaceDesc& desc,
                                                        const GrGLInterface& interface,
                                                        const GrGLCaps& caps,
                                                        GrGLenum target,
                                                        GrGLenum internalFormat,
                                                        GrGLenum externalFormat,
                                                        GrGLenum externalType,
                                                        const SkTArray<GrMipLevel>& texels,
-                                                       int baseWidth, int baseHeight,
-                                                       bool* succeeded) {
+                                                       int baseWidth, int baseHeight) {
     CLEAR_ERROR_BEFORE_ALLOC(&interface);
 
     bool useTexStorage = caps.isConfigTexSupportEnabled(desc.fConfig);
     // We can only use TexStorage if we know we will not later change the storage requirements.
     // This means if we may later want to add mipmaps, we cannot use TexStorage.
     // Right now, we cannot know if we will later add mipmaps or not.
     // The only time we can use TexStorage is when we already have the
     // mipmaps.
     useTexStorage &= texels.count() > 1;
 
     if (useTexStorage) {
         // We never resize or change formats of textures.
         GL_ALLOC_CALL(&interface,
                       TexStorage2D(target,
                                    texels.count(),
                                    internalFormat,
                                    desc.fWidth, desc.fHeight));
         GrGLenum error = check_alloc_error(desc, &interface);
         if (error != GR_GL_NO_ERROR) {
-            *succeeded = false;
+            return  false;
         } else {
             for (int currentMipLevel = 0; currentMipLevel < texels.count(); currentMipLevel++) {
                 const void* currentMipData = texels[currentMipLevel].fPixels;
                 if (currentMipData == nullptr) {
                     continue;
                 }
                 int twoToTheMipLevel = 1 << currentMipLevel;
                 int currentWidth = SkTMax(1, desc.fWidth / twoToTheMipLevel);
                 int currentHeight = SkTMax(1, desc.fHeight / twoToTheMipLevel);
 
                 GR_GL_CALL(&interface,
                            TexSubImage2D(target,
                                          currentMipLevel,
                                          0, // left
                                          0, // top
                                          currentWidth,
                                          currentHeight,
                                          externalFormat, externalType,
                                          currentMipData));
             }
-            *succeeded = true;
+            return true;
         }
     } else {
-        *succeeded = true;
-        for (int currentMipLevel = 0; currentMipLevel < texels.count(); currentMipLevel++) {
-            int twoToTheMipLevel = 1 << currentMipLevel;
-            int currentWidth = SkTMax(1, baseWidth / twoToTheMipLevel);
-            int currentHeight = SkTMax(1, baseHeight / twoToTheMipLevel);
-            const void* currentMipData = texels[currentMipLevel].fPixels;
-            // Even if curremtMipData is nullptr, continue to call TexImage2D.
-            // This will allocate texture memory which we can later populate.
+        if (texels.empty()) {
             GL_ALLOC_CALL(&interface,
                           TexImage2D(target,
-                                     currentMipLevel,
+                                     0,
                                      internalFormat,
-                                     currentWidth,
-                                     currentHeight,
+                                     baseWidth,
+                                     baseHeight,
                                      0, // border
                                      externalFormat, externalType,
-                                     currentMipData));
+                                     nullptr));
             GrGLenum error = check_alloc_error(desc, &interface);
             if (error != GR_GL_NO_ERROR) {
-                *succeeded = false;
-                break;
+                return false;
+            }
+        } else {
+            for (int currentMipLevel = 0; currentMipLevel < texels.count(); currentMipLevel++) {
+                int twoToTheMipLevel = 1 << currentMipLevel;
+                int currentWidth = SkTMax(1, baseWidth / twoToTheMipLevel);
+                int currentHeight = SkTMax(1, baseHeight / twoToTheMipLevel);
+                const void* currentMipData = texels[currentMipLevel].fPixels;
+                // Even if curremtMipData is nullptr, continue to call TexImage2D.
+                // This will allocate texture memory which we can later populate.
+                GL_ALLOC_CALL(&interface,
+                              TexImage2D(target,
+                                         currentMipLevel,
+                                         internalFormat,
+                                         currentWidth,
+                                         currentHeight,
+                                         0, // border
+                                         externalFormat, externalType,
+                                         currentMipData));
+                GrGLenum error = check_alloc_error(desc, &interface);
+                if (error != GR_GL_NO_ERROR) {
+                    return false;
+                }
             }
         }
     }
+    return true;
 }
 
 /**
  * Creates storage space for the texture and fills it with texels.
  *
  * @param desc           The surface descriptor for the texture being created.
  * @param interface      The GL interface in use.
  * @param caps           The capabilities of the GL device.
  * @param internalFormat The data format used for the internal storage of the texture.
  * @param texels         The texel data of the texture being created.
@@ skipping 113 matching lines @@
 
     // texels is const.
     // But we may need to flip the texture vertically to prepare it.
     // Rather than flip in place and alter the incoming data,
     // we allocate a new buffer to flip into.
     // This means we need to make a non-const shallow copy of texels.
     SkTArray<GrMipLevel> texelsShallowCopy(texels);
 
     for (int currentMipLevel = texelsShallowCopy.count() - 1; currentMipLevel >= 0;
          currentMipLevel--) {
-        SkASSERT(texelsShallowCopy[currentMipLevel].fPixels ||
-                 kNewTexture_UploadType == uploadType || kTransfer_UploadType == uploadType);
+        SkASSERT(texelsShallowCopy[currentMipLevel].fPixels || kTransfer_UploadType == uploadType);
     }
 
     const GrGLInterface* interface = this->glInterface();
     const GrGLCaps& caps = this->glCaps();
 
     size_t bpp = GrBytesPerPixel(dataConfig);
 
     if (width == 0 || height == 0) {
         return false;
     }
 
     for (int currentMipLevel = 0; currentMipLevel < texelsShallowCopy.count(); currentMipLevel++) {
         int twoToTheMipLevel = 1 << currentMipLevel;
         int currentWidth = SkTMax(1, width / twoToTheMipLevel);
         int currentHeight = SkTMax(1, height / twoToTheMipLevel);
 
-        if (texelsShallowCopy[currentMipLevel].fPixels == nullptr) {
-            continue;
-        }
-
         if (currentHeight > SK_MaxS32 ||
             currentWidth > SK_MaxS32) {
             return false;
         }
         if (!GrSurfacePriv::AdjustWritePixelParams(desc.fWidth, desc.fHeight, bpp, &left, &top,
                                                &currentWidth,
                                                &currentHeight,
                                                &texelsShallowCopy[currentMipLevel].fPixels,
                                                &texelsShallowCopy[currentMipLevel].fRowBytes)) {
             return false;
@@ skipping 15 matching lines @@
     /*
      *  Check whether to allocate a temporary buffer for flipping y or
      *  because our srcData has extra bytes past each row. If so, we need
      *  to trim those off here, since GL ES may not let us specify
      *  GL_UNPACK_ROW_LENGTH.
      */
     bool restoreGLRowLength = false;
     bool swFlipY = false;
     bool glFlipY = false;
 
-    if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
+    if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin && !texelsShallowCopy.empty()) {
         if (caps.unpackFlipYSupport()) {
             glFlipY = true;
         } else {
             swFlipY = true;
         }
     }
 
     // in case we need a temporary, trimmed copy of the src pixels
     SkAutoSMalloc<128 * 128> tempStorage;
 
     // find the combined size of all the mip levels and the relative offset of
     // each into the collective buffer
     size_t combined_buffer_size = 0;
     SkTArray<size_t> individual_mip_offsets(texelsShallowCopy.count());
     for (int currentMipLevel = 0; currentMipLevel < texelsShallowCopy.count(); currentMipLevel++) {
         int twoToTheMipLevel = 1 << currentMipLevel;
         int currentWidth = SkTMax(1, width / twoToTheMipLevel);
         int currentHeight = SkTMax(1, height / twoToTheMipLevel);
         const size_t trimmedSize = currentWidth * bpp * currentHeight;
         individual_mip_offsets.push_back(combined_buffer_size);
         combined_buffer_size += trimmedSize;
     }
     char* buffer = (char*)tempStorage.reset(combined_buffer_size);
 
     for (int currentMipLevel = 0; currentMipLevel < texelsShallowCopy.count(); currentMipLevel++) {
-        if (texelsShallowCopy[currentMipLevel].fPixels == nullptr) {
-            continue;
-        }
-
         int twoToTheMipLevel = 1 << currentMipLevel;
         int currentWidth = SkTMax(1, width / twoToTheMipLevel);
         int currentHeight = SkTMax(1, height / twoToTheMipLevel);
         const size_t trimRowBytes = currentWidth * bpp;
 
         /*
          *  check whether to allocate a temporary buffer for flipping y or
          *  because our srcData has extra bytes past each row. If so, we need
          *  to trim those off here, since GL ES may not let us specify
          *  GL_UNPACK_ROW_LENGTH.
@@ skipping 26 matching lines @@
                     dst += trimRowBytes;
                 }
                 // now point data to our copied version
                 texelsShallowCopy[currentMipLevel].fPixels = buffer +
                     individual_mip_offsets[currentMipLevel];
                 texelsShallowCopy[currentMipLevel].fRowBytes = trimRowBytes;
             }
         } else {
             return false;
         }
+    }
+
+    if (!texelsShallowCopy.empty()) {
         if (glFlipY) {
             GR_GL_CALL(interface, PixelStorei(GR_GL_UNPACK_FLIP_Y, GR_GL_TRUE));
         }
         GR_GL_CALL(interface, PixelStorei(GR_GL_UNPACK_ALIGNMENT,
                                           config_alignment(desc.fConfig)));
     }
 
     bool succeeded = true;
     if (kNewTexture_UploadType == uploadType &&
         0 == left && 0 == top &&
         desc.fWidth == width && desc.fHeight == height &&
         !desc.fTextureStorageAllocator.fAllocateTextureStorage) {
-        allocate_and_populate_uncompressed_texture(desc, *interface, caps, target,
-                                                   internalFormat, externalFormat,
-                                                   externalType, texelsShallowCopy,
-                                                   width, height, &succeeded);
+        succeeded = allocate_and_populate_uncompressed_texture(desc, *interface, caps, target,
+                                                               internalFormat, externalFormat,
+                                                               externalType, texelsShallowCopy,
+                                                               width, height);
     } else {
         if (swFlipY || glFlipY) {
             top = desc.fHeight - (top + height);
         }
         for (int currentMipLevel = 0; currentMipLevel < texelsShallowCopy.count();
              currentMipLevel++) {
             int twoToTheMipLevel = 1 << currentMipLevel;
             int currentWidth = SkTMax(1, width / twoToTheMipLevel);
             int currentHeight = SkTMax(1, height / twoToTheMipLevel);
-            if (texelsShallowCopy[currentMipLevel].fPixels == nullptr) {
-                continue;
-            }
 
             GL_CALL(TexSubImage2D(target,
                                   currentMipLevel,
                                   left, top,
                                   currentWidth,
                                   currentHeight,
                                   externalFormat, externalType,
                                   texelsShallowCopy[currentMipLevel].fPixels));
         }
     }
 
     restore_pixelstore_state(*interface, caps, restoreGLRowLength, glFlipY);
 
     return succeeded;
 }
 
 // TODO: This function is using a lot of wonky semantics like, if width == -1
 // then set width = desc.fWdith ... blah. A better way to do it might be to
 // create a CompressedTexData struct that takes a desc/ptr and figures out
 // the proper upload semantics. Then users can construct this function how they
 // see fit if they want to go against the "standard" way to do it.
 bool GrGLGpu::uploadCompressedTexData(const GrSurfaceDesc& desc,
                                       GrGLenum target,
                                       const SkTArray<GrMipLevel>& texels,
                                       UploadType uploadType,
                                       int left, int top, int width, int height) {
     SkASSERT(this->caps()->isConfigTexturable(desc.fConfig));
-    SkASSERT(kTransfer_UploadType != uploadType &&
-             (texels[0].fPixels || kNewTexture_UploadType != uploadType));
 
     // No support for software flip y, yet...
     SkASSERT(kBottomLeft_GrSurfaceOrigin != desc.fOrigin);
 
     const GrGLInterface* interface = this->glInterface();
     const GrGLCaps& caps = this->glCaps();
 
     if (-1 == width) {
         width = desc.fWidth;
     }
@@ skipping 20 matching lines @@
 
     if (kNewTexture_UploadType == uploadType) {
         return allocate_and_populate_compressed_texture(desc, *interface, caps, target,
                                                         internalFormat, texels, width, height);
     } else {
         // Paletted textures can't be updated.
         if (GR_GL_PALETTE8_RGBA8 == internalFormat) {
             return false;
         }
         for (int currentMipLevel = 0; currentMipLevel < texels.count(); currentMipLevel++) {
-            if (texels[currentMipLevel].fPixels == nullptr) {
-                continue;
-            }
+            SkASSERT(texels[currentMipLevel].fPixels || kTransfer_UploadType == uploadType);
 
             int twoToTheMipLevel = 1 << currentMipLevel;
             int currentWidth = SkTMax(1, width / twoToTheMipLevel);
             int currentHeight = SkTMax(1, height / twoToTheMipLevel);
 
             // Make sure that the width and height that we pass to OpenGL
             // is a multiple of the block size.
             size_t dataSize = GrCompressedFormatDataSize(desc.fConfig, currentWidth,
                                                          currentHeight);
             GL_CALL(CompressedTexSubImage2D(target,
@@ skipping 458 matching lines @@
     }
     return true;
 }
 
 bool GrGLGpu::createTextureExternalAllocatorImpl(const GrSurfaceDesc& desc,
                                                  GrGLTextureInfo* info,
                                                  const SkTArray<GrMipLevel>& texels) {
     // We do not make SkTArray available outside of Skia,
     // and so we do not want to allow mipmaps to external
     // allocators just yet.
-    SkASSERT(texels.count() == 1);
-    SkSTArray<1, GrMipLevel> texelsShallowCopy(1);
-    texelsShallowCopy.push_back(texels[0]);
+    SkASSERT(texels.count() < 2);
 
+    const void* pixels = nullptr;
+    if (!texels.empty()) {
+        pixels = texels.begin()->fPixels;
+    }
     switch (desc.fTextureStorageAllocator.fAllocateTextureStorage(
                     desc.fTextureStorageAllocator.fCtx, reinterpret_cast<GrBackendObject>(info),
-                    desc.fWidth, desc.fHeight, desc.fConfig, texelsShallowCopy[0].fPixels,
-                    desc.fOrigin)) {
+                    desc.fWidth, desc.fHeight, desc.fConfig, pixels, desc.fOrigin)) {
         case GrTextureStorageAllocator::Result::kSucceededAndUploaded:
             return true;
         case GrTextureStorageAllocator::Result::kFailed:
             return false;
         case GrTextureStorageAllocator::Result::kSucceededWithoutUpload:
             break;
     }
 
     if (!this->uploadTexData(desc, info->fTarget, kNewTexture_UploadType, 0, 0,
                              desc.fWidth, desc.fHeight,
-                             desc.fConfig, texelsShallowCopy)) {
+                             desc.fConfig, texels)) {
         desc.fTextureStorageAllocator.fDeallocateTextureStorage(
                 desc.fTextureStorageAllocator.fCtx, reinterpret_cast<GrBackendObject>(info));
         return false;
     }
     return true;
 }
 
 GrStencilAttachment* GrGLGpu::createStencilAttachmentForRenderTarget(const GrRenderTarget* rt,
                                                                      int width,
                                                                      int height) {
@@ skipping 593 matching lines @@
     GrPixelConfig rtConfig = target->config();
     return this->glCaps().readPixelsSupported(rtConfig, readConfig, getIntegerv, bindRenderTarget);
 }
 
 bool GrGLGpu::readPixelsSupported(GrPixelConfig rtConfig, GrPixelConfig readConfig) {
     auto bindRenderTarget = [this, rtConfig]() -> bool {
         GrTextureDesc desc;
         desc.fConfig = rtConfig;
         desc.fWidth = desc.fHeight = 16;
         desc.fFlags = kRenderTarget_GrSurfaceFlag;
-        SkAutoTUnref<GrTexture> temp(this->createTexture(desc, SkBudgeted::kNo, nullptr, 0));
+        SkAutoTUnref<GrTexture> temp(this->createTexture(desc,
+                                     SkBudgeted::kNo));
         if (!temp) {
             return false;
         }
         GrGLRenderTarget* glrt = static_cast<GrGLRenderTarget*>(temp->asRenderTarget());
         this->flushRenderTarget(glrt, &SkIRect::EmptyIRect());
         return true;
     };
     auto getIntegerv = [this](GrGLenum query, GrGLint* value) {
         GR_GL_GetIntegerv(this->glInterface(), query, value);
     };
@@ skipping 1850 matching lines @@
         if (GR_GL_TEXTURE_EXTERNAL == glTexture->target() ||
             GR_GL_TEXTURE_RECTANGLE == glTexture->target()) {
             copyParams->fFilter = GrTextureParams::kNone_FilterMode;
             copyParams->fWidth = texture->width();
             copyParams->fHeight = texture->height();
             return true;
         }
     }
     return false;
 }