Fix SkScalerContext_FreeType::generateFontMetrics.

gm/coloremoji.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 
 #include "Resources.h"
@@ skipping 59 matching lines @@
 
     void onDraw(SkCanvas* canvas) override {
 
         canvas->drawColor(sk_tool_utils::color_to_565(SK_ColorGRAY));
 
         SkPaint paint;
         paint.setTypeface(emojiFont.typeface);
         const char* text = emojiFont.text;
 
         // draw text at different point sizes
-        const int textSize[] = { 10, 30, 50, };
-        const int textYOffset[] = { 10, 40, 100, };
-        SkASSERT(sizeof(textSize) == sizeof(textYOffset));
-        size_t y_offset = 0;
-        for (size_t y = 0; y < sizeof(textSize) / sizeof(int); y++) {
-            paint.setTextSize(SkIntToScalar(textSize[y]));
-            canvas->drawText(text, strlen(text), 10, SkIntToScalar(textYOffset[y]), paint);
-            y_offset += textYOffset[y];
+        static constexpr SkScalar textSizes[] = { 10, 30, 50, };
+        SkPaint::FontMetrics metrics;
+        SkScalar y = 0;
+        for (const SkScalar& textSize : textSizes) {
+            paint.setTextSize(textSize);
+            paint.getFontMetrics(&metrics);
+            y += -metrics.fAscent;
+            canvas->drawText(text, strlen(text), 10, y, paint);
+            y += metrics.fDescent + metrics.fLeading;
         }
 
+        y += 20;
+        SkScalar savedY = y;
         // draw with shaders and image filters
         for (int makeLinear = 0; makeLinear < 2; makeLinear++) {
             for (int makeBlur = 0; makeBlur < 2; makeBlur++) {
                 for (int makeGray = 0; makeGray < 2; makeGray++) {
                     SkPaint shaderPaint;
                     shaderPaint.setTypeface(sk_ref_sp(paint.getTypeface()));
                     if (SkToBool(makeLinear)) {
                         shaderPaint.setShader(MakeLinear());
                     }
 
                     if (SkToBool(makeBlur) && SkToBool(makeGray)) {
                         sk_sp<SkImageFilter> grayScale(make_grayscale(nullptr));
                         sk_sp<SkImageFilter> blur(make_blur(3.0f, std::move(grayScale)));
                         shaderPaint.setImageFilter(std::move(blur));
                     } else if (SkToBool(makeBlur)) {
                         shaderPaint.setImageFilter(make_blur(3.0f, nullptr));
                     } else if (SkToBool(makeGray)) {
                         shaderPaint.setImageFilter(make_grayscale(nullptr));
                     }
                     shaderPaint.setTextSize(30);
-                    canvas->drawText(text, strlen(text), 380, SkIntToScalar(y_offset),
-                                     shaderPaint);
-                    y_offset += 32;
+                    shaderPaint.getFontMetrics(&metrics);
+                    y += -metrics.fAscent;
+                    canvas->drawText(text, strlen(text), 380, y, shaderPaint);
+                    y += metrics.fDescent + metrics.fLeading;
                 }
             }
         }
-
         // setup work needed to draw text with different clips
-        canvas->translate(10, 160);
+        canvas->translate(10, savedY);
         paint.setTextSize(40);
 
         // compute the bounds of the text
         SkRect bounds;
         paint.measureText(text, strlen(text), &bounds);
 
         const SkScalar boundsHalfWidth = bounds.width() * SK_ScalarHalf;
         const SkScalar boundsHalfHeight = bounds.height() * SK_ScalarHalf;
         const SkScalar boundsQuarterWidth = boundsHalfWidth * SK_ScalarHalf;
         const SkScalar boundsQuarterHeight = boundsHalfHeight * SK_ScalarHalf;
 
         SkRect upperLeftClip = SkRect::MakeXYWH(bounds.left(), bounds.top(),
                                                 boundsHalfWidth, boundsHalfHeight);
         SkRect lowerRightClip = SkRect::MakeXYWH(bounds.centerX(), bounds.centerY(),
                                                  boundsHalfWidth, boundsHalfHeight);
         SkRect interiorClip = bounds;
         interiorClip.inset(boundsQuarterWidth, boundsQuarterHeight);
 
-        const SkRect clipRects[] = { bounds, upperLeftClip, lowerRightClip, interiorClip };
+        static const SkRect clipRects[] = { bounds, upperLeftClip, lowerRightClip, interiorClip };
 
         SkPaint clipHairline;
         clipHairline.setColor(SK_ColorWHITE);
         clipHairline.setStyle(SkPaint::kStroke_Style);
 
-        for (size_t x = 0; x < sizeof(clipRects) / sizeof(SkRect); ++x) {
+        for (const SkRect& clipRect : clipRects) {
+            canvas->translate(0, bounds.height());
             canvas->save();
-            canvas->drawRect(clipRects[x], clipHairline);
+            canvas->drawRect(clipRect, clipHairline);
             paint.setAlpha(0x20);
             canvas->drawText(text, strlen(text), 0, 0, paint);
-            canvas->clipRect(clipRects[x]);
+            canvas->clipRect(clipRect);
             paint.setAlpha(0xFF);
             canvas->drawText(text, strlen(text), 0, 0, paint);
             canvas->restore();
-            canvas->translate(0, bounds.height() + SkIntToScalar(25));
+            canvas->translate(0, SkIntToScalar(25));
         }
     }
 
     typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM(return new ColorEmojiGM;)
 
 }