Revert "Centralize mask byte calculations"

This reverts commit 8994150a43.

Reason for revert: Breaks mask rowbytes calc.

Original change's description:
> Centralize mask byte calculations
> 
> These calculations are usually done in place around the code,
> but most implementation don't take the care needed for safe calculation.
> 
> I have provided safe implementations for use around the code. It
> will take a while to track down all the independant implementations
> and convert them over.
> 
> BUG=skia:7515
> 
> Change-Id: Ice6a9be2e8e5ebef18d472adb26c17b03177ef47
> Reviewed-on: https://skia-review.googlesource.com/111120
> Reviewed-by: Mike Reed <reed@google.com>
> Commit-Queue: Herb Derby <herb@google.com>

TBR=herb@google.com,reed@google.com

Change-Id: I2ce6c5e647fb684c6472022517ad777d29c8177c
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:7515
Reviewed-on: https://skia-review.googlesource.com/112640
Reviewed-by: Herb Derby <herb@google.com>
Commit-Queue: Herb Derby <herb@google.com>

src/core/SkMask.cpp

@@ -12,86 +12,24 @@
 /** returns the product if it is positive and fits in 31 bits. Otherwise this
     returns 0.
  */
-static size_t safe_mul(size_t a, size_t b) {
+static int32_t safeMul32(int32_t a, int32_t b) {
-    SkSafeMath safe;
+    int64_t size = sk_64_mul(a, b);
-    size_t r = safe.mul(a, b);
+    if (size > 0 && sk_64_isS32(size)) {
-    if (safe) {
+        return sk_64_asS32(size);
-        return r;
     }
-
     return 0;
 }
 
-static size_t safe_align4(size_t v) {
-    uint64_t adjusted = v + 3;
-    uint64_t possible = adjusted > v ? (adjusted & ~3) : 0;
-    return SkTFitsIn<size_t>(possible) ? possible : 0;
-}
-
 size_t SkMask::computeImageSize() const {
-    auto height = fBounds.height();
+    return safeMul32(fBounds.height(), fRowBytes);
-    auto safeHeight = SkTo<uint32_t>(height >= 0 ? height : 0);
-    return safe_mul(safeHeight, fRowBytes);
 }
 
 size_t SkMask::computeTotalImageSize() const {
-    return ComputeImageSize(fFormat, fBounds.width(), fBounds.height());
+    size_t size = this->computeImageSize();
+    if (fFormat == SkMask::k3D_Format) {
+        size = safeMul32(SkToS32(size), 3);
     }
-
+    return size;
-static size_t bits_to_bytes(size_t bits) {
-    return (bits + 7) >> 3;
-}
-
-size_t SkMask::AlignmentForMask(SkMask::Format format) {
-    switch (format) {
-        case SkMask::kBW_Format:
-            return alignof(uint8_t);
-        case SkMask::kA8_Format:
-            return alignof(uint8_t);
-        case SkMask::k3D_Format:
-            return alignof(uint8_t);
-        case SkMask::kARGB32_Format:
-            return alignof(uint32_t);
-        case SkMask::kLCD16_Format:
-            return alignof(uint16_t);
-        default:
-            SK_ABORT("Unknown mask format.");
-            break;
-    }
-    // Should not reach here.
-    return alignof(uint64_t);
-}
-
-size_t SkMask::ComputeRowBytes(SkMask::Format format, int32_t width) {
-    auto safeWidth = SkTo<uint32_t>(width >= 0 ? width : 0);
-    switch (format) {
-        case SkMask::kBW_Format:
-            // Always safe.
-            return SkTo<size_t>(bits_to_bytes(safeWidth));
-        case SkMask::kA8_Format:
-            return safe_align4(static_cast<size_t>(safeWidth));
-        case SkMask::k3D_Format:
-            return safe_align4(static_cast<size_t>(safeWidth));
-        case SkMask::kARGB32_Format:
-            return safe_mul(safeWidth, sizeof(uint32_t));
-        case SkMask::kLCD16_Format:
-            return safe_align4(safe_mul(safeWidth, sizeof(uint16_t)));
-        default:
-            SK_ABORT("Unknown mask format.");
-            break;
-    }
-    // Should not reach here.
-    return 0;
-}
-
-size_t SkMask::ComputeImageSize(SkMask::Format format, int32_t width, int32_t height) {
-    size_t size = ComputeRowBytes(format, width);
-    if (format == SkMask::k3D_Format) {
-        size = safe_mul(size, 3);
-    }
-    auto safeHeight = SkTo<uint32_t>(height >= 0 ? height : 0);
-    auto result = safe_mul(size, safeHeight);
-    return result;
 }
 
 /** We explicitly use this allocator for SkBimap pixels, so that we can

src/core/SkMask.h

@@ -118,12 +118,6 @@ struct SkMask {
         kUninit_Alloc,
         kZeroInit_Alloc,
     };
-
-    static size_t AlignmentForMask(SkMask::Format format);
-    // Return 0 if overflow.
-    static size_t ComputeRowBytes(SkMask::Format format, int32_t width);
-    // Return 0 if overflow.
-    static size_t ComputeImageSize(SkMask::Format format, int32_t width, int32_t height);
     static uint8_t* AllocImage(size_t bytes, AllocType = kUninit_Alloc);
     static void FreeImage(void* image);