Reduce error control flow in addGlyphToAtlas

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

Author: herbderby

src/gpu/text/GrStrikeCache.cpp

@@ -74,21 +74,20 @@ static void expand_bits(INT_TYPE* dst,
     }
 }
 
-static bool get_packed_glyph_image(const SkGlyph* glyph, int width,
+static void get_packed_glyph_image(const SkGlyph* glyph, int width,
                                    int height, int dstRB, GrMaskFormat expectedMaskFormat,
                                    void* dst, const SkMasks& masks) {
     SkASSERT(glyph->width() == width);
     SkASSERT(glyph->height() == height);
+
     const void* src = glyph->image();
-    if (src == nullptr) {
-        return false;
-    }
+    SkASSERT(src != nullptr);
 
-    // Convert if the glyph uses a 565 mask format since it is using LCD text rendering but the
-    // expected format is 8888 (will happen on macOS with Metal since that combination does not
-    // support 565).
     if (kA565_GrMaskFormat == GrGlyph::FormatFromSkGlyph(glyph->maskFormat()) &&
         kARGB_GrMaskFormat == expectedMaskFormat) {
+        // Convert if the glyph uses a 565 mask format since it is using LCD text rendering but the
+        // expected format is 8888 (will happen on macOS with Metal since that combination does not
+        // support 565).
         const int a565Bpp = GrMaskFormatBytesPerPixel(kA565_GrMaskFormat);
         const int argbBpp = GrMaskFormatBytesPerPixel(kARGB_GrMaskFormat);
         for (int y = 0; y < height; y++) {
@@ -104,53 +103,48 @@ static bool get_packed_glyph_image(const SkGlyph* glyph, int width,
                 dst = (char*)dst + argbBpp;
             }
         }
-        return true;
-    }
-
-    // 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.
-    if (GrGlyph::FormatFromSkGlyph(glyph->maskFormat()) != expectedMaskFormat) {
+    } else if (GrGlyph::FormatFromSkGlyph(glyph->maskFormat()) != expectedMaskFormat) {
+        // 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.
         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 (glyph->maskFormat() == SkMask::kBW_Format) {
-        // expand bits to our mask type
-        const uint8_t* bits = reinterpret_cast<const uint8_t*>(src);
-        switch (expectedMaskFormat) {
-            case kA8_GrMaskFormat:{
-                uint8_t* bytes = reinterpret_cast<uint8_t*>(dst);
-                expand_bits(bytes, bits, width, height, dstRB, srcRB);
-                break;
+    } else {
+        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 (glyph->maskFormat() == SkMask::kBW_Format) {
+            // expand bits to our mask type
+            const uint8_t* bits = reinterpret_cast<const uint8_t*>(src);
+            switch (expectedMaskFormat) {
+                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:
+                    SK_ABORT("Invalid GrMaskFormat");
             }
-            case kA565_GrMaskFormat: {
-                uint16_t* rgb565 = reinterpret_cast<uint16_t*>(dst);
-                expand_bits(rgb565, bits, width, height, dstRB, srcRB);
-                break;
+        } else if (srcRB == dstRB) {
+            memcpy(dst, src, dstRB * height);
+        } else {
+            const int bbp = GrMaskFormatBytesPerPixel(expectedMaskFormat);
+            for (int y = 0; y < height; y++) {
+                memcpy(dst, src, width * bbp);
+                src = (const char*) src + srcRB;
+                dst = (char*) dst + dstRB;
             }
-            default:
-                SK_ABORT("Invalid GrMaskFormat");
-        }
-    } else if (srcRB == dstRB) {
-        memcpy(dst, src, dstRB * height);
-    } else {
-        const int bbp = GrMaskFormatBytesPerPixel(expectedMaskFormat);
-        for (int y = 0; y < height; y++) {
-            memcpy(dst, src, width * bbp);
-            src = (const char*)src + srcRB;
-            dst = (char*)dst + dstRB;
         }
     }
-    return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -201,6 +195,7 @@ GrDrawOpAtlas::ErrorCode GrTextStrike::addGlyphToAtlas(
     size_t size = height * rowBytes;
 
     const SkGlyph* skGlyph = metricsAndImages->glyph(glyph->fPackedID);
+    if (skGlyph->image() == nullptr) { return GrDrawOpAtlas::ErrorCode::kError; }
 
     // Temporary storage for normalizing glyph image.
     SkAutoSMalloc<1024> storage(size);
@@ -210,11 +205,9 @@ GrDrawOpAtlas::ErrorCode GrTextStrike::addGlyphToAtlas(
         // Advance in one row and one column.
         dataPtr = (char*)(dataPtr) + rowBytes + bytesPerPixel;
     }
-    if (!get_packed_glyph_image(skGlyph, glyph->width(), glyph->height(),
-                                rowBytes, expectedMaskFormat,
-                                dataPtr, glyphCache->getMasks())) {
-        return GrDrawOpAtlas::ErrorCode::kError;
-    }
+
+    get_packed_glyph_image(skGlyph, glyph->width(), glyph->height(),
+            rowBytes, expectedMaskFormat, dataPtr, glyphCache->getMasks());
 
     GrDrawOpAtlas::ErrorCode result = fullAtlasManager->addToAtlas(
                                                 resourceProvider, glyphCache, this,