SkASSERT firing because pointer wraps negative.

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 <cstddef>
 #include <cstring>
 #include <type_traits>
@@ skipping 391 matching lines @@
 
 
     return shouldUseMipMaps;
 }
 
 namespace {
 
 class DTIBufferFiller
 {
 public:
-    explicit DTIBufferFiller(intptr_t bufferAsInt)
+    explicit DTIBufferFiller(uintptr_t bufferAsInt)
         : bufferAsInt_(bufferAsInt) {}
 
     void fillMember(const void* source, size_t memberOffset, size_t size) {
         memcpy(reinterpret_cast<void*>(bufferAsInt_ + memberOffset), source, size);
     }
 
 private:
 
-    intptr_t bufferAsInt_;
+    uintptr_t bufferAsInt_;
 };
 }
 
 #define FILL_MEMBER(bufferFiller, member, source) \
     bufferFiller.fillMember(source, \
                offsetof(DeferredTextureImage, member), \
                sizeof(DeferredTextureImage::member));
 
 size_t SkImage::getDeferredTextureImageData(const GrContextThreadSafeProxy& proxy,
                                             const DeferredTextureImageUsageParams params[],
@@ skipping 113 matching lines @@
     size_t colorSpaceOffset = 0;
     size_t colorSpaceSize = 0;
     if (info.colorSpace()) {
         colorSpaceOffset = size;
         colorSpaceSize = info.colorSpace()->writeToMemory(nullptr);
         size += colorSpaceSize;
     }
     if (!fillMode) {
         return size;
     }
-    intptr_t bufferAsInt = reinterpret_cast<intptr_t>(buffer);
-    intptr_t pixelsAsInt = bufferAsInt + pixelOffset;
+    uintptr_t bufferAsInt = reinterpret_cast<uintptr_t>(buffer);
+    uintptr_t pixelsAsInt = bufferAsInt + pixelOffset;
     void* pixels = reinterpret_cast<void*>(pixelsAsInt);
     void* ct = nullptr;
     if (ctSize) {
         ct = reinterpret_cast<void*>(bufferAsInt + ctOffset);
     }
 
     memcpy(reinterpret_cast<void*>(SkAlign8(pixelsAsInt)), pixmap.addr(), pixmap.getSafeSize());
     if (ctSize) {
         memcpy(ct, pixmap.ctable()->readColors(), ctSize);
     }
@@ skipping 30 matching lines @@
     } else {
         memset(reinterpret_cast<void*>(bufferAsInt +
                                        offsetof(DeferredTextureImage, fColorSpace)),
                0, sizeof(DeferredTextureImage::fColorSpace));
         memset(reinterpret_cast<void*>(bufferAsInt +
                                        offsetof(DeferredTextureImage, fColorSpaceSize)),
                0, sizeof(DeferredTextureImage::fColorSpaceSize));
     }
 
     // Fill in the mipmap levels if they exist
-    intptr_t mipLevelPtr = pixelsAsInt + SkAlign8(pixmap.getSafeSize());
+    uintptr_t mipLevelPtr = pixelsAsInt + SkAlign8(pixmap.getSafeSize());
 
     if (useMipMaps) {
         static_assert(std::is_standard_layout<MipMapLevelData>::value,
                       "offsetof, which we use below, requires the type have a standard layout");
 
         SkAutoTDelete<SkMipMap> mipmaps(SkMipMap::Build(pixmap, gammaTreatment, nullptr));
         // SkMipMap holds only the mipmap levels it generates.
         // A programmer can use the data they provided to SkMipMap::Build as level 0.
         // So the SkMipMap provides levels 1-x but it stores them in its own
         // range 0-(x-1).
@@ skipping 90 matching lines @@
     }
     SkAutoTUnref<GrTexture> texture(GrUploadMipMapToTexture(ctx, info, texels, mipLevelCount));
     if (!texture) {
         return nullptr;
     }
     texture->texturePriv().setGammaTreatment(gammaTreatment);
     return sk_make_sp<SkImage_Gpu>(texture->width(), texture->height(), kNeedNewImageUniqueID,
                                    info.alphaType(), texture, sk_ref_sp(info.colorSpace()),
                                    budgeted);
 }