Alloc glyph image correctly for SkMask::k3D_Format.

Re-enable the code to test the emboss mask filter, updating it to use
the new emboss mask filter factory.

Add a test to ensure that embossed text is drawn correctly, as before
glyphs did not allocate the proper amount of memory for the k3D_Format
which the emboss mask filter produces.

Fixes SkEmbossMask::Emboss to write the whole of the mul and add planes
to avoid pixel differences and MemorySanitizer errors.

Update the GPU to understand the k3D_Format and use just the alpha
plane, ignoring the mul and add plane which it currently cannot support.

Change-Id: I90edf34a918c06b0c6b24bfc43ce7031419eca41
Reviewed-on: https://skia-review.googlesource.com/70260
Reviewed-on: https://skia-review.googlesource.com/70962
Reviewed-on: https://skia-review.googlesource.com/71282
Reviewed-by: Ben Wagner <bungeman@google.com>
Commit-Queue: Ben Wagner <bungeman@google.com>

4 files changed, 68 insertions, 51 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/gpu/text/GrAtlasGlyphCache.cpp b/src/gpu/text/GrAtlasGlyphCache.cpp
index 80f4314b91..421160f28f 100644
--- a/src/gpu/text/GrAtlasGlyphCache.cpp
+++ b/src/gpu/text/GrAtlasGlyphCache.cpp
@@ -213,6 +213,8 @@ static inline GrMaskFormat get_packed_glyph_mask_format(const SkGlyph& glyph) {
             // fall through to kA8 -- we store BW glyphs in our 8-bit cache
         case SkMask::kA8_Format:
             return kA8_GrMaskFormat;
+        case SkMask::k3D_Format:
+            return kA8_GrMaskFormat; // ignore the mul and add planes, just use the mask
         case SkMask::kLCD16_Format:
             return kA565_GrMaskFormat;
         case SkMask::kARGB32_Format: