Alloc glyph image correctly for SkMask::k3D_Format.

This removes the no longer used outside Skia
SK_SUPPORT_LEGACY_EMBOSSMASKFILTER define, and either deletes the code
it guards or updates it to use the new emboss mask filter factory. This
re-enables the code to test the emboss mask filter. Also added is a test
to ensure that embossed text is drawn correctly, as before this glyphs
did not allocate the proper amount of memory for the k3D_Format which
this mask filter produces. This also fixes SkEmbossMask::Emboss to write
the whole of the mul and add planes to avoid pixel differences and
MemorySanitizer errors.

Change-Id: Ib492c72a19d6a27d140e3cd48179a3ca9ce313f5
Reviewed-on: https://skia-review.googlesource.com/70260
Commit-Queue: Ben Wagner <bungeman@google.com>
Reviewed-by: Herb Derby <herb@google.com>

4 files changed, 66 insertions, 71 deletions

diff --git a/src/core/SkGlyph.h b/src/core/SkGlyph.h
index 06c1d76fb3..b54635277b 100644
--- a/src/core/SkGlyph.h
+++ b/src/core/SkGlyph.h
@@ -172,34 +172,57 @@ public:
      */
     static unsigned ComputeRowBytes(unsigned width, SkMask::Format format) {
         unsigned rb = width;
-        if (SkMask::kBW_Format == format) {
+        switch (format) {
+        case SkMask::kBW_Format:
             rb = BitsToBytes(rb);
-        } else if (SkMask::kARGB32_Format == format) {
+            break;
+        case SkMask::kA8_Format:
+            rb = SkAlign4(rb);
+            break;
+        case SkMask::k3D_Format:
+            rb = SkAlign4(rb);
+            break;
+        case SkMask::kARGB32_Format:
             rb <<= 2;
-        } else if (SkMask::kLCD16_Format == format) {
+            break;
+        case SkMask::kLCD16_Format:
             rb = SkAlign4(rb << 1);
-        } else {
-            rb = SkAlign4(rb);
+            break;
+        default:
+            SK_ABORT("Unknown mask format.");
+            break;
         }
         return rb;
     }
 
     size_t allocImage(SkArenaAlloc* alloc) {
         size_t allocSize;
-        if (SkMask::kBW_Format == fMaskFormat) {
+        switch (static_cast<SkMask::Format>(fMaskFormat)) {
+        case SkMask::kBW_Format:
             allocSize = BitsToBytes(fWidth) * fHeight;
             fImage = alloc->makeArrayDefault<char>(allocSize);
-        } else if (SkMask::kARGB32_Format == fMaskFormat) {
+            break;
+        case SkMask::kA8_Format:
+            allocSize = SkAlign4(fWidth) * fHeight;
+            fImage = alloc->makeArrayDefault<char>(allocSize);
+            break;
+        case SkMask::k3D_Format:
+            allocSize = SkAlign4(fWidth) * fHeight * 3;
+            fImage = alloc->makeArrayDefault<char>(allocSize);
+            break;
+        case SkMask::kARGB32_Format:
             allocSize = fWidth * fHeight;
             fImage = alloc->makeArrayDefault<uint32_t>(fWidth * fHeight);
             allocSize *= sizeof(uint32_t);
-        } else if (SkMask::kLCD16_Format == fMaskFormat) {
+            break;
+        case SkMask::kLCD16_Format:
             allocSize = SkAlign2(fWidth) * fHeight;
             fImage = alloc->makeArrayDefault<uint16_t>(allocSize);
             allocSize *= sizeof(uint16_t);
-        } else {
-            allocSize = SkAlign4(fWidth) * fHeight;
-            fImage = alloc->makeArrayDefault<char>(allocSize);
+            break;
+        default:
+            SK_ABORT("Unknown mask format.");
+            break;
         }
         return allocSize;
     }
diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp
index 8a1ab60ae8..828f978287 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -26,8 +26,6 @@
 #include "SkStrokeRec.h"
 #include "SkWriteBuffer.h"
 
-#define ComputeBWRowBytes(width)        (((unsigned)(width) + 7) >> 3)
-
 void SkGlyph::toMask(SkMask* mask) const {
     SkASSERT(mask);
 
diff --git a/src/effects/SkEmbossMask.cpp b/src/effects/SkEmbossMask.cpp
index c73d0c8406..e081186564 100644
--- a/src/effects/SkEmbossMask.cpp
+++ b/src/effects/SkEmbossMask.cpp
@@ -68,47 +68,41 @@ void SkEmbossMask::Emboss(SkMask* mask, const SkEmbossMaskFilter::Light& light)
         int next_row = neq_to_mask(y, maxy) & rowBytes;
 
         for (int x = 0; x <= maxx; x++) {
-            if (alpha[x]) {
-                int nx = alpha[x + neq_to_one(x, maxx)] - alpha[x - nonzero_to_one(x)];
-                int ny = alpha[x + next_row] - alpha[x - prev_row];
-
-                SkFixed numer = lx * nx + ly * ny + lz_dot_nz;
-                int     mul = ambient;
-                int     add = 0;
-
-                if (numer > 0) {  // preflight when numer/denom will be <= 0
-                    int denom = SkSqrt32(nx * nx + ny * ny + kDelta*kDelta);
-                    SkFixed dot = numer / denom;
-                    dot >>= 8;  // now dot is 2^8 instead of 2^16
-                    mul = SkFastMin32(mul + dot, 255);
-
-                    // now for the reflection
-
-                    //  R = 2 (Light * Normal) Normal - Light
-                    //  hilite = R * Eye(0, 0, 1)
-
-                    int hilite = (2 * dot - lz_dot8) * lz_dot8 >> 8;
-                    if (hilite > 0) {
-                        // pin hilite to 255, since our fast math is also a little sloppy
-                        hilite = SkClampMax(hilite, 255);
-
-                        // specular is 4.4
-                        // would really like to compute the fractional part of this
-                        // and then possibly cache a 256 table for a given specular
-                        // value in the light, and just pass that in to this function.
-                        add = hilite;
-                        for (int i = specular >> 4; i > 0; --i) {
-                            add = div255(add * hilite);
-                        }
+            int nx = alpha[x + neq_to_one(x, maxx)] - alpha[x - nonzero_to_one(x)];
+            int ny = alpha[x + next_row] - alpha[x - prev_row];
+
+            SkFixed numer = lx * nx + ly * ny + lz_dot_nz;
+            int     mul = ambient;
+            int     add = 0;
+
+            if (numer > 0) {  // preflight when numer/denom will be <= 0
+                int denom = SkSqrt32(nx * nx + ny * ny + kDelta*kDelta);
+                SkFixed dot = numer / denom;
+                dot >>= 8;  // now dot is 2^8 instead of 2^16
+                mul = SkFastMin32(mul + dot, 255);
+
+                // now for the reflection
+
+                //  R = 2 (Light * Normal) Normal - Light
+                //  hilite = R * Eye(0, 0, 1)
+
+                int hilite = (2 * dot - lz_dot8) * lz_dot8 >> 8;
+                if (hilite > 0) {
+                    // pin hilite to 255, since our fast math is also a little sloppy
+                    hilite = SkClampMax(hilite, 255);
+
+                    // specular is 4.4
+                    // would really like to compute the fractional part of this
+                    // and then possibly cache a 256 table for a given specular
+                    // value in the light, and just pass that in to this function.
+                    add = hilite;
+                    for (int i = specular >> 4; i > 0; --i) {
+                        add = div255(add * hilite);
                     }
                 }
-                multiply[x] = SkToU8(mul);
-                additive[x] = SkToU8(add);
-
-            //  multiply[x] = 0xFF;
-            //  additive[x] = 0;
-            //  ((uint8_t*)alpha)[x] = alpha[x] * multiply[x] >> 8;
             }
+            multiply[x] = SkToU8(mul);
+            additive[x] = SkToU8(add);
         }
         alpha += rowBytes;
         multiply += rowBytes;
diff --git a/src/effects/SkEmbossMaskFilter.cpp b/src/effects/SkEmbossMaskFilter.cpp
index 4caef9ef0b..b51e2545b6 100644
--- a/src/effects/SkEmbossMaskFilter.cpp
+++ b/src/effects/SkEmbossMaskFilter.cpp
@@ -17,26 +17,6 @@ sk_sp<SkMaskFilter> SkEmbossMaskFilter::Make(SkScalar blurSigma, const Light& li
     return sk_sp<SkMaskFilter>(new SkEmbossMaskFilter(blurSigma, light));
 }
 
-#ifdef SK_SUPPORT_LEGACY_EMBOSSMASKFILTER
-sk_sp<SkMaskFilter> SkBlurMaskFilter::MakeEmboss(SkScalar blurSigma, const SkScalar direction[3],
-                                                 SkScalar ambient, SkScalar specular) {
-    if (direction == nullptr) {
-        return nullptr;
-    }
-
-    SkEmbossMaskFilter::Light   light;
-
-    memcpy(light.fDirection, direction, sizeof(light.fDirection));
-    // ambient should be 0...1 as a scalar
-    light.fAmbient = SkUnitScalarClampToByte(ambient);
-    // specular should be 0..15.99 as a scalar
-    static const SkScalar kSpecularMultiplier = SkIntToScalar(255) / 16;
-    light.fSpecular = static_cast<U8CPU>(SkScalarPin(specular, 0, 16) * kSpecularMultiplier + 0.5);
-
-    return SkEmbossMaskFilter::Make(blurSigma, light);
-}
-#endif
-
 ///////////////////////////////////////////////////////////////////////////////
 
 static void normalize(SkScalar v[3]) {