Revert of Fix UB function problems for shaders and mask.

src/core/SkBlitMask_D32.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlitMask.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
@@ skipping 58 matching lines @@
                        color, clip.width(), clip.height());
         return true;
     }
 
     return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-static void BW_RowProc_Blend(
-        SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
-    const uint8_t* SK_RESTRICT mask = static_cast<const uint8_t*>(maskIn);
+static void BW_RowProc_Blend(SkPMColor* SK_RESTRICT dst,
+                             const uint8_t* SK_RESTRICT mask,
+                             const SkPMColor* SK_RESTRICT src, int count) {
     int i, octuple = (count + 7) >> 3;
     for (i = 0; i < octuple; ++i) {
         int m = *mask++;
         if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); }
         if (m & 0x40) { dst[1] = SkPMSrcOver(src[1], dst[1]); }
         if (m & 0x20) { dst[2] = SkPMSrcOver(src[2], dst[2]); }
         if (m & 0x10) { dst[3] = SkPMSrcOver(src[3], dst[3]); }
         if (m & 0x08) { dst[4] = SkPMSrcOver(src[4], dst[4]); }
         if (m & 0x04) { dst[5] = SkPMSrcOver(src[5], dst[5]); }
         if (m & 0x02) { dst[6] = SkPMSrcOver(src[6], dst[6]); }
         if (m & 0x01) { dst[7] = SkPMSrcOver(src[7], dst[7]); }
         src += 8;
         dst += 8;
     }
     count &= 7;
     if (count > 0) {
         int m = *mask;
         do {
             if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); }
             m <<= 1;
             src += 1;
             dst += 1;
         } while (--count > 0);
     }
 }
 
-static void BW_RowProc_Opaque(
-        SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
-    const uint8_t* SK_RESTRICT mask = static_cast<const uint8_t*>(maskIn);
+static void BW_RowProc_Opaque(SkPMColor* SK_RESTRICT dst,
+                              const uint8_t* SK_RESTRICT mask,
+                              const SkPMColor* SK_RESTRICT src, int count) {
     int i, octuple = (count + 7) >> 3;
     for (i = 0; i < octuple; ++i) {
         int m = *mask++;
         if (m & 0x80) { dst[0] = src[0]; }
         if (m & 0x40) { dst[1] = src[1]; }
         if (m & 0x20) { dst[2] = src[2]; }
         if (m & 0x10) { dst[3] = src[3]; }
         if (m & 0x08) { dst[4] = src[4]; }
         if (m & 0x04) { dst[5] = src[5]; }
         if (m & 0x02) { dst[6] = src[6]; }
         if (m & 0x01) { dst[7] = src[7]; }
         src += 8;
         dst += 8;
     }
     count &= 7;
     if (count > 0) {
         int m = *mask;
         do {
             if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); }
             m <<= 1;
             src += 1;
             dst += 1;
         } while (--count > 0);
     }
 }
 
-static void A8_RowProc_Blend(
-        SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
-    const uint8_t* SK_RESTRICT mask = static_cast<const uint8_t*>(maskIn);
+static void A8_RowProc_Blend(SkPMColor* SK_RESTRICT dst,
+                             const uint8_t* SK_RESTRICT mask,
+                             const SkPMColor* SK_RESTRICT src, int count) {
     for (int i = 0; i < count; ++i) {
         if (mask[i]) {
             dst[i] = SkBlendARGB32(src[i], dst[i], mask[i]);
         }
     }
 }
 
 // expand the steps that SkAlphaMulQ performs, but this way we can
 //  exand.. add.. combine
 // instead of
 // expand..combine add expand..combine
 //
 #define EXPAND0(v, m, s)    ((v) & (m)) * (s)
 #define EXPAND1(v, m, s)    (((v) >> 8) & (m)) * (s)
 #define COMBINE(e0, e1, m)  ((((e0) >> 8) & (m)) | ((e1) & ~(m)))
 
-static void A8_RowProc_Opaque(
-        SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
-    const uint8_t* SK_RESTRICT mask = static_cast<const uint8_t*>(maskIn);
+static void A8_RowProc_Opaque(SkPMColor* SK_RESTRICT dst,
+                              const uint8_t* SK_RESTRICT mask,
+                              const SkPMColor* SK_RESTRICT src, int count) {
     for (int i = 0; i < count; ++i) {
         int m = mask[i];
         if (m) {
             m += (m >> 7);
 #if 1
             // this is slightly slower than the expand/combine version, but it
             // is much closer to the old results, so we use it for now to reduce
             // rebaselining.
             dst[i] = SkAlphaMulQ(src[i], m) + SkAlphaMulQ(dst[i], 256 - m);
 #else
@@ skipping 12 matching lines @@
 static int upscale31To255(int value) {
     value = (value << 3) | (value >> 2);
     return value;
 }
 
 static int src_alpha_blend(int src, int dst, int srcA, int mask) {
 
     return dst + SkAlphaMul(src - SkAlphaMul(srcA, dst), mask);
 }
 
-static void LCD16_RowProc_Blend(
-        SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
-    const uint8_t* SK_RESTRICT mask = static_cast<const uint8_t*>(maskIn);
+static void LCD16_RowProc_Blend(SkPMColor* SK_RESTRICT dst,
+                                const uint16_t* SK_RESTRICT mask,
+                                const SkPMColor* SK_RESTRICT src, int count) {
     for (int i = 0; i < count; ++i) {
         uint16_t m = mask[i];
         if (0 == m) {
             continue;
         }
 
         SkPMColor s = src[i];
         SkPMColor d = dst[i];
 
         int srcA = SkGetPackedA32(s);
@@ skipping 20 matching lines @@
 
         // LCD blitting is only supported if the dst is known/required
         // to be opaque
         dst[i] = SkPackARGB32(0xFF,
                               src_alpha_blend(srcR, dstR, srcA, maskR),
                               src_alpha_blend(srcG, dstG, srcA, maskG),
                               src_alpha_blend(srcB, dstB, srcA, maskB));
     }
 }
 
-static void LCD16_RowProc_Opaque(
-        SkPMColor* SK_RESTRICT dst, const void* maskIn, const SkPMColor* SK_RESTRICT src, int count) {
-    const uint8_t* SK_RESTRICT mask = static_cast<const uint8_t*>(maskIn);
+static void LCD16_RowProc_Opaque(SkPMColor* SK_RESTRICT dst,
+                                 const uint16_t* SK_RESTRICT mask,
+                                 const SkPMColor* SK_RESTRICT src, int count) {
     for (int i = 0; i < count; ++i) {
         uint16_t m = mask[i];
         if (0 == m) {
             continue;
         }
 
         SkPMColor s = src[i];
         SkPMColor d = dst[i];
 
         int srcR = SkGetPackedR32(s);
@@ skipping 55 matching lines @@
             if (flags & kSrcIsOpaque_RowFlag) {
                 index |= 1;
             }
             SkASSERT((size_t)index < SK_ARRAY_COUNT(gProcs));
             return gProcs[index];
         default:
             break;
     }
     return nullptr;
 }