Revert "Revert "Revert "guard old apis for querying byte-size of a bitmap/imageinfo/pixmap"""

This reverts commit cd284c532376d16fcc4ed75baf3da65c3e4a2e95.

Reason for revert:

assert fired in SkMallocPixelRef.cpp:61: fatal error: "assert(info.computeByteSize(rowBytes) == info.getSafeSize(rowBytes))"

google3 thinks it was from surface_rowbytes

Original change's description:
> Revert "Revert "guard old apis for querying byte-size of a bitmap/imageinfo/pixmap""
> 
> This reverts commit 809cbedd4b252be221b2ac3b4269d312fd8f53a0.
> 
> Bug: skia:
> Change-Id: I680d8daeeeeb15526b44c1305d8fb0c6bfa38e1d
> Reviewed-on: https://skia-review.googlesource.com/52665
> Commit-Queue: Mike Reed <reed@google.com>
> Reviewed-by: Florin Malita <fmalita@chromium.org>

TBR=fmalita@chromium.org,reed@google.com

Change-Id: I41e3f7a3f791cc8183291847e783ed8a53bc91d2
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/53802
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>

6 files changed, 34 insertions, 36 deletions

diff --git a/src/core/SkAutoPixmapStorage.cpp b/src/core/SkAutoPixmapStorage.cpp
index df0c0fa878..be13e7197f 100644
--- a/src/core/SkAutoPixmapStorage.cpp
+++ b/src/core/SkAutoPixmapStorage.cpp
@@ -29,7 +29,7 @@ size_t SkAutoPixmapStorage::AllocSize(const SkImageInfo& info, size_t* rowBytes)
     if (rowBytes) {
         *rowBytes = rb;
     }
-    return info.computeByteSize(rb);
+    return info.getSafeSize(rb);
 }
 
 bool SkAutoPixmapStorage::tryAlloc(const SkImageInfo& info) {
@@ -58,7 +58,7 @@ const SkData* SkAutoPixmapStorage::detachPixelsAsData() {
         return nullptr;
     }
 
-    auto data = SkData::MakeFromMalloc(fStorage, this->computeByteSize());
+    auto data = SkData::MakeFromMalloc(fStorage, this->getSafeSize());
     fStorage = nullptr;
     this->INHERITED::reset();
 
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 4c4f76ae95..9de2261a9a 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -678,7 +678,7 @@ bool SkBitmap::ReadRawPixels(SkReadBuffer* buffer, SkBitmap* bitmap) {
     }
 
     // write_raw_pixels() always writes snug buffers with rowBytes == minRowBytes().
-    size_t bytes = info.computeMinByteSize();
+    size_t bytes = info.getSafeSize(info.minRowBytes());
     if (!buffer->validate(bytes != 0)) {
         return false;
     }
diff --git a/src/core/SkBitmapCache.cpp b/src/core/SkBitmapCache.cpp
index 8d3991a9d5..b8767644a2 100644
--- a/src/core/SkBitmapCache.cpp
+++ b/src/core/SkBitmapCache.cpp
@@ -160,7 +160,7 @@ public:
 
     const Key& getKey() const override { return fKey; }
     size_t bytesUsed() const override {
-        return sizeof(fKey) + fInfo.computeByteSize(fRowBytes);
+        return sizeof(fKey) + fInfo.getSafeSize(fRowBytes);
     }
     bool canBePurged() override {
         SkAutoMutexAcquire ama(fMutex);
@@ -289,7 +289,7 @@ SkBitmapCache::RecPtr SkBitmapCache::Alloc(const SkBitmapCacheDesc& desc, const
     }
 
     const size_t rb = info.minRowBytes();
-    size_t size = info.computeByteSize(rb);
+    size_t size = info.getSafeSize(rb);
     if (0 == size) {
         return nullptr;
     }
diff --git a/src/core/SkMallocPixelRef.cpp b/src/core/SkMallocPixelRef.cpp
index 807eb06b30..50ee91c676 100644
--- a/src/core/SkMallocPixelRef.cpp
+++ b/src/core/SkMallocPixelRef.cpp
@@ -35,39 +35,38 @@ sk_sp<SkPixelRef> SkMallocPixelRef::MakeDirect(const SkImageInfo& info,
 }
 
 
-sk_sp<SkPixelRef> SkMallocPixelRef::MakeUsing(void*(*allocProc)(size_t),
-                                              const SkImageInfo& info,
-                                              size_t rowBytes) {
-    if (rowBytes == 0) {
-        rowBytes = info.minRowBytes();
+sk_sp<SkPixelRef> SkMallocPixelRef::MakeUsing(void*(*alloc)(size_t),
+                                           const SkImageInfo& info,
+                                           size_t requestedRowBytes) {
+    if (!is_valid(info)) {
+        return nullptr;
     }
 
-    if (!is_valid(info) || !info.validRowBytes(rowBytes)) {
-        return nullptr;
+    // only want to permit 31bits of rowBytes
+    int64_t minRB = (int64_t)info.minRowBytes64();
+    if (minRB < 0 || !sk_64_isS32(minRB)) {
+        return nullptr;    // allocation will be too large
+    }
+    if (requestedRowBytes > 0 && (int32_t)requestedRowBytes < minRB) {
+        return nullptr;    // cannot meet requested rowbytes
     }
 
-    size_t size = 0;
-    // if the info is empty, or rowBytes is 0 (which can be valid), then we don't need to compute
-    // a size.
-    if (!info.isEmpty() && rowBytes > 0) {
-#ifdef SK_SUPPORT_LEGACY_SAFESIZE64
-        int64_t bigSize = (int64_t)info.height() * rowBytes;
-        if (!sk_64_isS32(bigSize)) {
-            return nullptr;
-        }
+    int32_t rowBytes;
+    if (requestedRowBytes) {
+        rowBytes = SkToS32(requestedRowBytes);
+    } else {
+        rowBytes = minRB;
+    }
 
-        size = sk_64_asS32(bigSize);
-        SkASSERT(size >= info.getSafeSize(rowBytes));
-        SkASSERT(info.computeByteSize(rowBytes) == info.getSafeSize(rowBytes));
-#else
-        size = info.computeByteSize(rowBytes);
-#endif
-        if (size == 0) {
-            return nullptr; // overflow
-        }
+    int64_t bigSize = (int64_t)info.height() * rowBytes;
+    if (!sk_64_isS32(bigSize)) {
+        return nullptr;
     }
 
-    void* addr = allocProc(size);
+    size_t size = sk_64_asS32(bigSize);
+    SkASSERT(size >= info.getSafeSize(rowBytes));
+    SkASSERT(info.getSafeSize(rowBytes) == info.computeByteSize(rowBytes));
+    void* addr = alloc(size);
     if (nullptr == addr) {
         return nullptr;
     }
@@ -109,11 +108,10 @@ sk_sp<SkPixelRef> SkMallocPixelRef::MakeWithData(const SkImageInfo& info,
                                                 size_t rowBytes,
                                                 sk_sp<SkData> data) {
     SkASSERT(data != nullptr);
-    if (!is_valid(info) || !info.validRowBytes(rowBytes)) {
+    if (!is_valid(info)) {
         return nullptr;
     }
-    size_t sizeNeeded = info.computeByteSize(rowBytes);
-    if (!info.isEmpty() && (sizeNeeded == 0 || data->size() < sizeNeeded)) {
+    if ((rowBytes < info.minRowBytes()) || (data->size() < info.getSafeSize(rowBytes))) {
         return nullptr;
     }
     // must get this address before we call release
diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp
index 460907f164..98036cf8a0 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -400,7 +400,7 @@ static void generateMask(const SkMask& mask, const SkPath& path,
     } else {
         dst.reset(info, mask.fImage, dstRB);
     }
-    sk_bzero(dst.writable_addr(), dst.computeByteSize());
+    sk_bzero(dst.writable_addr(), dst.getSafeSize());
 
     SkDraw  draw;
     draw.fDst   = dst;
diff --git a/src/core/SkSpecialImage.cpp b/src/core/SkSpecialImage.cpp
index db4fadcce2..db40329204 100644
--- a/src/core/SkSpecialImage.cpp
+++ b/src/core/SkSpecialImage.cpp
@@ -219,7 +219,7 @@ public:
 
     SkAlphaType alphaType() const override { return fBitmap.alphaType(); }
 
-    size_t getSize() const override { return fBitmap.computeByteSize(); }
+    size_t getSize() const override { return fBitmap.getSize(); }
 
     void onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) const override {
         SkRect dst = SkRect::MakeXYWH(x, y,