Dont try to draw glyphs with unexpected mask formats

src/gpu/GrFontScaler.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrFontScaler.h"
 #include "SkDescriptor.h"
@@ skipping 85 matching lines @@
                 *d++ = (mask & (1 << i)) ? (INT_TYPE)(~0UL) : 0;
             }
         }
         dst = reinterpret_cast<INT_TYPE*>(reinterpret_cast<intptr_t>(dst) + dstRowBytes);
         src += srcRowBytes;
     }
 }
 }
 
 bool GrFontScaler::getPackedGlyphImage(const SkGlyph& glyph, int width, int height, int dstRB,
-                                       void* dst) {
+                                       GrMaskFormat expectedMaskFormat, void* dst) {
     SkASSERT(glyph.fWidth == width);
     SkASSERT(glyph.fHeight == height);
     const void* src = fStrike->findImage(glyph);
     if (NULL == src) {
         return false;
     }
 
+    // crbug:510931
+    // Retrieving the image from the cache can actually change the mask format.  This case is very
+    // uncommon so for now we just draw a clear box for these glyphs.

[robertphillips, 2015/07/30 14:36:26]

this->getPackedGlyphMaskFormat ?

+    if (getPackedGlyphMaskFormat(glyph) != expectedMaskFormat) {
+        const int bpp = GrMaskFormatBytesPerPixel(expectedMaskFormat);
+        for (int y = 0; y < height; y++) {
+            sk_bzero(dst, width * bpp);
+            dst = (char*)dst + dstRB;
+        }
+        return true;
+    }
+
     int srcRB = glyph.rowBytes();
     // The windows font host sometimes has BW glyphs in a non-BW strike. So it is important here to
     // check the glyph's format, not the strike's format, and to be able to convert to any of the
     // GrMaskFormats.
     if (SkMask::kBW_Format == glyph.fMaskFormat) {
         // expand bits to our mask type
         const uint8_t* bits = reinterpret_cast<const uint8_t*>(src);

[robertphillips, 2015/07/30 14:36:26]

what happened to the "this->" ?

-        switch (this->getMaskFormat()) {
+        switch (getMaskFormat()) {
             case kA8_GrMaskFormat:{
                 uint8_t* bytes = reinterpret_cast<uint8_t*>(dst);
                 expand_bits(bytes, bits, width, height, dstRB, srcRB);
                 break;
             }
             case kA565_GrMaskFormat: {
                 uint16_t* rgb565 = reinterpret_cast<uint16_t*>(dst);
                 expand_bits(rgb565, bits, width, height, dstRB, srcRB);
                 break;
             }
             default:
                 SkFAIL("Invalid GrMaskFormat");
         }
     } else if (srcRB == dstRB) {
         memcpy(dst, src, dstRB * height);
     } else {

[robertphillips, 2015/07/30 14:36:26]

here too ?

-        const int bbp = GrMaskFormatBytesPerPixel(this->getMaskFormat());
+        const int bpp = GrMaskFormatBytesPerPixel(getMaskFormat());
         for (int y = 0; y < height; y++) {
-            memcpy(dst, src, width * bbp);
+            memcpy(dst, src, width * bpp);
             src = (const char*)src + srcRB;
             dst = (char*)dst + dstRB;
         }
     }
     return true;
 }
 
 bool GrFontScaler::getPackedGlyphDFImage(const SkGlyph& glyph, int width, int height, void* dst) {
     SkASSERT(glyph.fWidth + 2*SK_DistanceFieldPad == width);
     SkASSERT(glyph.fHeight + 2*SK_DistanceFieldPad == height);
     const void* image = fStrike->findImage(glyph);
     if (NULL == image) {
         return false;
     }
+
     // now generate the distance field
     SkASSERT(dst);
     SkMask::Format maskFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
     if (SkMask::kA8_Format == maskFormat) {
         // make the distance field from the image
         SkGenerateDistanceFieldFromA8Image((unsigned char*)dst,
                                            (unsigned char*)image,
                                            glyph.fWidth, glyph.fHeight,
                                            glyph.rowBytes());
     } else if (SkMask::kBW_Format == maskFormat) {
@@ skipping 11 matching lines @@
 
 const SkPath* GrFontScaler::getGlyphPath(const SkGlyph& glyph) {
     return fStrike->findPath(glyph);
 }
 
 const SkGlyph& GrFontScaler::grToSkGlyph(GrGlyph::PackedID id) {
     return fStrike->getGlyphIDMetrics(GrGlyph::UnpackID(id),
                                       GrGlyph::UnpackFixedX(id),
                                       GrGlyph::UnpackFixedY(id));
 }