Add m-esr52 at 52.6.0

1 files changed, 564 insertions, 0 deletions

diff --git a/gfx/thebes/gfxGDIFont.cpp b/gfx/thebes/gfxGDIFont.cpp
new file mode 100644
index 000000000..e6ceeaf6d
--- /dev/null
+++ b/gfx/thebes/gfxGDIFont.cpp
@@ -0,0 +1,564 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "gfxGDIFont.h"
+
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/WindowsVersion.h"
+
+#include <algorithm>
+#include "gfxWindowsPlatform.h"
+#include "gfxContext.h"
+#include "mozilla/Preferences.h"
+#include "nsUnicodeProperties.h"
+#include "gfxFontConstants.h"
+#include "gfxTextRun.h"
+
+#include "cairo-win32.h"
+
+#define ROUND(x) floor((x) + 0.5)
+
+using namespace mozilla;
+using namespace mozilla::unicode;
+
+static inline cairo_antialias_t
+GetCairoAntialiasOption(gfxFont::AntialiasOption anAntialiasOption)
+{
+    switch (anAntialiasOption) {
+    default:
+    case gfxFont::kAntialiasDefault:
+        return CAIRO_ANTIALIAS_DEFAULT;
+    case gfxFont::kAntialiasNone:
+        return CAIRO_ANTIALIAS_NONE;
+    case gfxFont::kAntialiasGrayscale:
+        return CAIRO_ANTIALIAS_GRAY;
+    case gfxFont::kAntialiasSubpixel:
+        return CAIRO_ANTIALIAS_SUBPIXEL;
+    }
+}
+
+gfxGDIFont::gfxGDIFont(GDIFontEntry *aFontEntry,
+                       const gfxFontStyle *aFontStyle,
+                       bool aNeedsBold,
+                       AntialiasOption anAAOption)
+    : gfxFont(aFontEntry, aFontStyle, anAAOption),
+      mFont(nullptr),
+      mFontFace(nullptr),
+      mMetrics(nullptr),
+      mSpaceGlyph(0),
+      mNeedsBold(aNeedsBold),
+      mScriptCache(nullptr)
+{
+    Initialize();
+}
+
+gfxGDIFont::~gfxGDIFont()
+{
+    if (mScaledFont) {
+        cairo_scaled_font_destroy(mScaledFont);
+    }
+    if (mFontFace) {
+        cairo_font_face_destroy(mFontFace);
+    }
+    if (mFont) {
+        ::DeleteObject(mFont);
+    }
+    if (mScriptCache) {
+        ScriptFreeCache(&mScriptCache);
+    }
+    delete mMetrics;
+}
+
+gfxFont*
+gfxGDIFont::CopyWithAntialiasOption(AntialiasOption anAAOption)
+{
+    return new gfxGDIFont(static_cast<GDIFontEntry*>(mFontEntry.get()),
+                          &mStyle, mNeedsBold, anAAOption);
+}
+
+bool
+gfxGDIFont::ShapeText(DrawTarget     *aDrawTarget,
+                      const char16_t *aText,
+                      uint32_t        aOffset,
+                      uint32_t        aLength,
+                      Script          aScript,
+                      bool            aVertical,
+                      gfxShapedText  *aShapedText)
+{
+    if (!mIsValid) {
+        NS_WARNING("invalid font! expect incorrect text rendering");
+        return false;
+    }
+
+    // Ensure the cairo font is set up, so there's no risk it'll fall back to
+    // creating a "toy" font internally (see bug 544617).
+    // We must check that this succeeded, otherwise we risk cairo creating the
+    // wrong kind of font internally as a fallback (bug 744480).
+    if (!SetupCairoFont(aDrawTarget)) {
+        return false;
+    }
+
+    return gfxFont::ShapeText(aDrawTarget, aText, aOffset, aLength, aScript,
+                              aVertical, aShapedText);
+}
+
+const gfxFont::Metrics&
+gfxGDIFont::GetHorizontalMetrics()
+{
+    return *mMetrics;
+}
+
+uint32_t
+gfxGDIFont::GetSpaceGlyph()
+{
+    return mSpaceGlyph;
+}
+
+bool
+gfxGDIFont::SetupCairoFont(DrawTarget* aDrawTarget)
+{
+    if (!mScaledFont ||
+        cairo_scaled_font_status(mScaledFont) != CAIRO_STATUS_SUCCESS) {
+        // Don't cairo_set_scaled_font as that would propagate the error to
+        // the cairo_t, precluding any further drawing.
+        return false;
+    }
+    cairo_set_scaled_font(gfxFont::RefCairo(aDrawTarget), mScaledFont);
+    return true;
+}
+
+gfxFont::RunMetrics
+gfxGDIFont::Measure(const gfxTextRun *aTextRun,
+                    uint32_t aStart, uint32_t aEnd,
+                    BoundingBoxType aBoundingBoxType,
+                    DrawTarget *aRefDrawTarget,
+                    Spacing *aSpacing,
+                    uint16_t aOrientation)
+{
+    gfxFont::RunMetrics metrics =
+        gfxFont::Measure(aTextRun, aStart, aEnd, aBoundingBoxType,
+                         aRefDrawTarget, aSpacing, aOrientation);
+
+    // if aBoundingBoxType is LOOSE_INK_EXTENTS
+    // and the underlying cairo font may be antialiased,
+    // we can't trust Windows to have considered all the pixels
+    // so we need to add "padding" to the bounds.
+    // (see bugs 475968, 439831, compare also bug 445087)
+    if (aBoundingBoxType == LOOSE_INK_EXTENTS &&
+        mAntialiasOption != kAntialiasNone &&
+        metrics.mBoundingBox.width > 0) {
+        metrics.mBoundingBox.x -= aTextRun->GetAppUnitsPerDevUnit();
+        metrics.mBoundingBox.width += aTextRun->GetAppUnitsPerDevUnit() * 3;
+    }
+
+    return metrics;
+}
+
+void
+gfxGDIFont::Initialize()
+{
+    NS_ASSERTION(!mMetrics, "re-creating metrics? this will leak");
+
+    LOGFONTW logFont;
+
+    // Figure out if we want to do synthetic oblique styling.
+    GDIFontEntry* fe = static_cast<GDIFontEntry*>(GetFontEntry());
+    bool wantFakeItalic = mStyle.style != NS_FONT_STYLE_NORMAL &&
+                          fe->IsUpright() && mStyle.allowSyntheticStyle;
+
+    // If the font's family has an actual italic face (but font matching
+    // didn't choose it), we have to use a cairo transform instead of asking
+    // GDI to italicize, because that would use a different face and result
+    // in a possible glyph ID mismatch between shaping and rendering.
+    //
+    // We use the mFamilyHasItalicFace flag in the entry in case of user fonts,
+    // where the *CSS* family may not know about italic faces that are present
+    // in the *GDI* family, and which GDI would use if we asked it to perform
+    // the "italicization".
+    bool useCairoFakeItalic = wantFakeItalic && fe->mFamilyHasItalicFace;
+
+    if (mAdjustedSize == 0.0) {
+        mAdjustedSize = mStyle.size;
+        if (mStyle.sizeAdjust > 0.0 && mAdjustedSize > 0.0) {
+            // to implement font-size-adjust, we first create the "unadjusted" font
+            FillLogFont(logFont, mAdjustedSize,
+                        wantFakeItalic && !useCairoFakeItalic);
+            mFont = ::CreateFontIndirectW(&logFont);
+
+            // initialize its metrics so we can calculate size adjustment
+            Initialize();
+
+            // Unless the font was so small that GDI metrics rounded to zero,
+            // calculate the properly adjusted size, and then proceed
+            // to recreate mFont and recalculate metrics
+            if (mMetrics->xHeight > 0.0 && mMetrics->emHeight > 0.0) {
+                gfxFloat aspect = mMetrics->xHeight / mMetrics->emHeight;
+                mAdjustedSize = mStyle.GetAdjustedSize(aspect);
+            }
+
+            // delete the temporary font and metrics
+            ::DeleteObject(mFont);
+            mFont = nullptr;
+            delete mMetrics;
+            mMetrics = nullptr;
+        } else if (mStyle.sizeAdjust == 0.0) {
+            mAdjustedSize = 0.0;
+        }
+    }
+
+    // (bug 724231) for local user fonts, we don't use GDI's synthetic bold,
+    // as it could lead to a different, incompatible face being used
+    // but instead do our own multi-striking
+    if (mNeedsBold && GetFontEntry()->IsLocalUserFont()) {
+        mApplySyntheticBold = true;
+    }
+
+    // this may end up being zero
+    mAdjustedSize = ROUND(mAdjustedSize);
+    FillLogFont(logFont, mAdjustedSize, wantFakeItalic && !useCairoFakeItalic);
+    mFont = ::CreateFontIndirectW(&logFont);
+
+    mMetrics = new gfxFont::Metrics;
+    ::memset(mMetrics, 0, sizeof(*mMetrics));
+
+    AutoDC dc;
+    SetGraphicsMode(dc.GetDC(), GM_ADVANCED);
+    AutoSelectFont selectFont(dc.GetDC(), mFont);
+
+    // Get font metrics if size > 0
+    if (mAdjustedSize > 0.0) {
+
+        OUTLINETEXTMETRIC oMetrics;
+        TEXTMETRIC& metrics = oMetrics.otmTextMetrics;
+
+        if (0 < GetOutlineTextMetrics(dc.GetDC(), sizeof(oMetrics), &oMetrics)) {
+            mMetrics->strikeoutSize = (double)oMetrics.otmsStrikeoutSize;
+            mMetrics->strikeoutOffset = (double)oMetrics.otmsStrikeoutPosition;
+            mMetrics->underlineSize = (double)oMetrics.otmsUnderscoreSize;
+            mMetrics->underlineOffset = (double)oMetrics.otmsUnderscorePosition;
+
+            const MAT2 kIdentityMatrix = { {0, 1}, {0, 0}, {0, 0}, {0, 1} };
+            GLYPHMETRICS gm;
+            DWORD len = GetGlyphOutlineW(dc.GetDC(), char16_t('x'), GGO_METRICS, &gm, 0, nullptr, &kIdentityMatrix);
+            if (len == GDI_ERROR || gm.gmptGlyphOrigin.y <= 0) {
+                // 56% of ascent, best guess for true type
+                mMetrics->xHeight =
+                    ROUND((double)metrics.tmAscent * DEFAULT_XHEIGHT_FACTOR);
+            } else {
+                mMetrics->xHeight = gm.gmptGlyphOrigin.y;
+            }
+            len = GetGlyphOutlineW(dc.GetDC(), char16_t('H'), GGO_METRICS, &gm, 0, nullptr, &kIdentityMatrix);
+            if (len == GDI_ERROR || gm.gmptGlyphOrigin.y <= 0) {
+                mMetrics->capHeight = metrics.tmAscent - metrics.tmInternalLeading;
+            } else {
+                mMetrics->capHeight = gm.gmptGlyphOrigin.y;
+            }
+            mMetrics->emHeight = metrics.tmHeight - metrics.tmInternalLeading;
+            gfxFloat typEmHeight = (double)oMetrics.otmAscent - (double)oMetrics.otmDescent;
+            mMetrics->emAscent = ROUND(mMetrics->emHeight * (double)oMetrics.otmAscent / typEmHeight);
+            mMetrics->emDescent = mMetrics->emHeight - mMetrics->emAscent;
+            if (oMetrics.otmEMSquare > 0) {
+                mFUnitsConvFactor = float(mAdjustedSize / oMetrics.otmEMSquare);
+            }
+        } else {
+            // Make a best-effort guess at extended metrics
+            // this is based on general typographic guidelines
+
+            // GetTextMetrics can fail if the font file has been removed
+            // or corrupted recently.
+            BOOL result = GetTextMetrics(dc.GetDC(), &metrics);
+            if (!result) {
+                NS_WARNING("Missing or corrupt font data, fasten your seatbelt");
+                mIsValid = false;
+                memset(mMetrics, 0, sizeof(*mMetrics));
+                return;
+            }
+
+            mMetrics->xHeight =
+                ROUND((float)metrics.tmAscent * DEFAULT_XHEIGHT_FACTOR);
+            mMetrics->strikeoutSize = 1;
+            mMetrics->strikeoutOffset = ROUND(mMetrics->xHeight * 0.5f); // 50% of xHeight
+            mMetrics->underlineSize = 1;
+            mMetrics->underlineOffset = -ROUND((float)metrics.tmDescent * 0.30f); // 30% of descent
+            mMetrics->emHeight = metrics.tmHeight - metrics.tmInternalLeading;
+            mMetrics->emAscent = metrics.tmAscent - metrics.tmInternalLeading;
+            mMetrics->emDescent = metrics.tmDescent;
+            mMetrics->capHeight = mMetrics->emAscent;
+        }
+
+        mMetrics->internalLeading = metrics.tmInternalLeading;
+        mMetrics->externalLeading = metrics.tmExternalLeading;
+        mMetrics->maxHeight = metrics.tmHeight;
+        mMetrics->maxAscent = metrics.tmAscent;
+        mMetrics->maxDescent = metrics.tmDescent;
+        mMetrics->maxAdvance = metrics.tmMaxCharWidth;
+        mMetrics->aveCharWidth = std::max<gfxFloat>(1, metrics.tmAveCharWidth);
+        // The font is monospace when TMPF_FIXED_PITCH is *not* set!
+        // See http://msdn2.microsoft.com/en-us/library/ms534202(VS.85).aspx
+        if (!(metrics.tmPitchAndFamily & TMPF_FIXED_PITCH)) {
+            mMetrics->maxAdvance = mMetrics->aveCharWidth;
+        }
+
+        // For fonts with USE_TYPO_METRICS set in the fsSelection field,
+        // let the OS/2 sTypo* metrics override the previous values.
+        // (see http://www.microsoft.com/typography/otspec/os2.htm#fss)
+        // Using the equivalent values from oMetrics provides inconsistent
+        // results with CFF fonts, so we instead rely on OS2Table.
+        gfxFontEntry::AutoTable os2Table(mFontEntry,
+                                         TRUETYPE_TAG('O','S','/','2'));
+        if (os2Table) {
+            uint32_t len;
+            const OS2Table *os2 =
+                reinterpret_cast<const OS2Table*>(hb_blob_get_data(os2Table,
+                                                                   &len));
+            if (len >= offsetof(OS2Table, sTypoLineGap) + sizeof(int16_t)) {
+                const uint16_t kUseTypoMetricsMask = 1 << 7;
+                if ((uint16_t(os2->fsSelection) & kUseTypoMetricsMask)) {
+                    double ascent = int16_t(os2->sTypoAscender);
+                    double descent = int16_t(os2->sTypoDescender);
+                    double lineGap = int16_t(os2->sTypoLineGap);
+                    mMetrics->maxAscent = ROUND(ascent * mFUnitsConvFactor);
+                    mMetrics->maxDescent = -ROUND(descent * mFUnitsConvFactor);
+                    mMetrics->maxHeight =
+                        mMetrics->maxAscent + mMetrics->maxDescent;
+                    mMetrics->internalLeading =
+                        mMetrics->maxHeight - mMetrics->emHeight;
+                    gfxFloat lineHeight =
+                        ROUND((ascent - descent + lineGap) * mFUnitsConvFactor);
+                    lineHeight = std::max(lineHeight, mMetrics->maxHeight);
+                    mMetrics->externalLeading =
+                        lineHeight - mMetrics->maxHeight;
+                }
+            }
+            // although sxHeight and sCapHeight are signed fields, we consider
+            // negative values to be erroneous and just ignore them
+            if (uint16_t(os2->version) >= 2) {
+                // version 2 and later includes the x-height and cap-height fields
+                if (len >= offsetof(OS2Table, sxHeight) + sizeof(int16_t) &&
+                    int16_t(os2->sxHeight) > 0) {
+                    mMetrics->xHeight = ROUND(int16_t(os2->sxHeight) * mFUnitsConvFactor);
+                }
+                if (len >= offsetof(OS2Table, sCapHeight) + sizeof(int16_t) &&
+                    int16_t(os2->sCapHeight) > 0) {
+                    mMetrics->capHeight = ROUND(int16_t(os2->sCapHeight) * mFUnitsConvFactor);
+                }
+            }
+        }
+
+        WORD glyph;
+        SIZE size;
+        DWORD ret = GetGlyphIndicesW(dc.GetDC(), L" ", 1, &glyph,
+                                     GGI_MARK_NONEXISTING_GLYPHS);
+        if (ret != GDI_ERROR && glyph != 0xFFFF) {
+            mSpaceGlyph = glyph;
+            // Cache the width of a single space.
+            GetTextExtentPoint32W(dc.GetDC(), L" ", 1, &size);
+            mMetrics->spaceWidth = ROUND(size.cx);
+        } else {
+            mMetrics->spaceWidth = mMetrics->aveCharWidth;
+        }
+
+        // Cache the width of digit zero, if available.
+        ret = GetGlyphIndicesW(dc.GetDC(), L"0", 1, &glyph,
+                               GGI_MARK_NONEXISTING_GLYPHS);
+        if (ret != GDI_ERROR && glyph != 0xFFFF) {
+            GetTextExtentPoint32W(dc.GetDC(), L"0", 1, &size);
+            mMetrics->zeroOrAveCharWidth = ROUND(size.cx);
+        } else {
+            mMetrics->zeroOrAveCharWidth = mMetrics->aveCharWidth;
+        }
+
+        SanitizeMetrics(mMetrics, GetFontEntry()->mIsBadUnderlineFont);
+    } else {
+        mFUnitsConvFactor = 0.0; // zero-sized font: all values scale to zero
+    }
+
+    if (IsSyntheticBold()) {
+        mMetrics->aveCharWidth += GetSyntheticBoldOffset();
+        mMetrics->maxAdvance += GetSyntheticBoldOffset();
+    }
+
+    mFontFace = cairo_win32_font_face_create_for_logfontw_hfont(&logFont,
+                                                                mFont);
+
+    cairo_matrix_t sizeMatrix, ctm;
+    cairo_matrix_init_identity(&ctm);
+    cairo_matrix_init_scale(&sizeMatrix, mAdjustedSize, mAdjustedSize);
+
+    if (useCairoFakeItalic) {
+        // Skew the matrix to do fake italic if it wasn't already applied
+        // via the LOGFONT
+        double skewfactor = OBLIQUE_SKEW_FACTOR;
+        cairo_matrix_t style;
+        cairo_matrix_init(&style,
+                          1,                //xx
+                          0,                //yx
+                          -1 * skewfactor,  //xy
+                          1,                //yy
+                          0,                //x0
+                          0);               //y0
+        cairo_matrix_multiply(&sizeMatrix, &sizeMatrix, &style);
+    }
+
+    cairo_font_options_t *fontOptions = cairo_font_options_create();
+    if (mAntialiasOption != kAntialiasDefault) {
+        cairo_font_options_set_antialias(fontOptions,
+            GetCairoAntialiasOption(mAntialiasOption));
+    }
+    mScaledFont = cairo_scaled_font_create(mFontFace, &sizeMatrix,
+                                           &ctm, fontOptions);
+    cairo_font_options_destroy(fontOptions);
+
+    if (!mScaledFont ||
+        cairo_scaled_font_status(mScaledFont) != CAIRO_STATUS_SUCCESS) {
+#ifdef DEBUG
+        char warnBuf[1024];
+        SprintfLiteral(warnBuf, "Failed to create scaled font: %s status: %d",
+                       NS_ConvertUTF16toUTF8(mFontEntry->Name()).get(),
+                       mScaledFont ? cairo_scaled_font_status(mScaledFont) : 0);
+        NS_WARNING(warnBuf);
+#endif
+        mIsValid = false;
+    } else {
+        mIsValid = true;
+    }
+
+#if 0
+    printf("Font: %p (%s) size: %f adjusted size: %f valid: %s\n", this,
+           NS_ConvertUTF16toUTF8(GetName()).get(), mStyle.size, mAdjustedSize, (mIsValid ? "yes" : "no"));
+    printf("    emHeight: %f emAscent: %f emDescent: %f\n", mMetrics->emHeight, mMetrics->emAscent, mMetrics->emDescent);
+    printf("    maxAscent: %f maxDescent: %f maxAdvance: %f\n", mMetrics->maxAscent, mMetrics->maxDescent, mMetrics->maxAdvance);
+    printf("    internalLeading: %f externalLeading: %f\n", mMetrics->internalLeading, mMetrics->externalLeading);
+    printf("    spaceWidth: %f aveCharWidth: %f\n", mMetrics->spaceWidth, mMetrics->aveCharWidth);
+    printf("    xHeight: %f capHeight: %f\n", mMetrics->xHeight, mMetrics->capHeight);
+    printf("    uOff: %f uSize: %f stOff: %f stSize: %f\n",
+           mMetrics->underlineOffset, mMetrics->underlineSize, mMetrics->strikeoutOffset, mMetrics->strikeoutSize);
+#endif
+}
+
+void
+gfxGDIFont::FillLogFont(LOGFONTW& aLogFont, gfxFloat aSize,
+                        bool aUseGDIFakeItalic)
+{
+    GDIFontEntry *fe = static_cast<GDIFontEntry*>(GetFontEntry());
+
+    uint16_t weight;
+    if (fe->IsUserFont()) {
+        if (fe->IsLocalUserFont()) {
+            // for local user fonts, don't change the original weight
+            // in the entry's logfont, because that could alter the
+            // choice of actual face used (bug 724231)
+            weight = 0;
+        } else {
+            // avoid GDI synthetic bold which occurs when weight
+            // specified is >= font data weight + 200
+            weight = mNeedsBold ? 700 : 200;
+        }
+    } else {
+        weight = mNeedsBold ? 700 : fe->Weight();
+    }
+
+    fe->FillLogFont(&aLogFont, weight, aSize, 
+                    (mAntialiasOption == kAntialiasSubpixel) ? true : false);
+
+    // If GDI synthetic italic is wanted, force the lfItalic field to true
+    if (aUseGDIFakeItalic) {
+        aLogFont.lfItalic = 1;
+    }
+}
+
+uint32_t
+gfxGDIFont::GetGlyph(uint32_t aUnicode, uint32_t aVarSelector)
+{
+    // Callback used only for fonts that lack a 'cmap' table.
+
+    // We don't support variation selector sequences or non-BMP characters
+    // in the legacy bitmap, vector or postscript fonts that might use
+    // this code path.
+    if (aUnicode > 0xffff || aVarSelector) {
+        return 0;
+    }
+
+    if (!mGlyphIDs) {
+        mGlyphIDs = MakeUnique<nsDataHashtable<nsUint32HashKey,uint32_t>>(64);
+    }
+
+    uint32_t gid;
+    if (mGlyphIDs->Get(aUnicode, &gid)) {
+        return gid;
+    }
+
+    wchar_t ch = aUnicode;
+    WORD glyph;
+    DWORD ret = ScriptGetCMap(nullptr, &mScriptCache, &ch, 1, 0, &glyph);
+    if (ret != S_OK) {
+        AutoDC dc;
+        AutoSelectFont fs(dc.GetDC(), GetHFONT());
+        if (ret == E_PENDING) {
+            // Try ScriptGetCMap again now that we've set up the font.
+            ret = ScriptGetCMap(dc.GetDC(), &mScriptCache, &ch, 1, 0, &glyph);
+        }
+        if (ret != S_OK) {
+            // If ScriptGetCMap still failed, fall back to GetGlyphIndicesW
+            // (see bug 1105807).
+            ret = GetGlyphIndicesW(dc.GetDC(), &ch, 1, &glyph,
+                                   GGI_MARK_NONEXISTING_GLYPHS);
+            if (ret == GDI_ERROR || glyph == 0xFFFF) {
+                glyph = 0;
+            }
+        }
+    }
+
+    mGlyphIDs->Put(aUnicode, glyph);
+    return glyph;
+}
+
+int32_t
+gfxGDIFont::GetGlyphWidth(DrawTarget& aDrawTarget, uint16_t aGID)
+{
+    if (!mGlyphWidths) {
+        mGlyphWidths = MakeUnique<nsDataHashtable<nsUint32HashKey,int32_t>>(128);
+    }
+
+    int32_t width;
+    if (mGlyphWidths->Get(aGID, &width)) {
+        return width;
+    }
+
+    DCFromDrawTarget dc(aDrawTarget);
+    AutoSelectFont fs(dc, GetHFONT());
+
+    int devWidth;
+    if (GetCharWidthI(dc, aGID, 1, nullptr, &devWidth)) {
+        // clamp value to range [0..0x7fff], and convert to 16.16 fixed-point
+        devWidth = std::min(std::max(0, devWidth), 0x7fff);
+        width = devWidth << 16;
+        mGlyphWidths->Put(aGID, width);
+        return width;
+    }
+
+    return -1;
+}
+
+void
+gfxGDIFont::AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                                   FontCacheSizes* aSizes) const
+{
+    gfxFont::AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
+    aSizes->mFontInstances += aMallocSizeOf(mMetrics);
+    if (mGlyphWidths) {
+        aSizes->mFontInstances +=
+            mGlyphWidths->ShallowSizeOfIncludingThis(aMallocSizeOf);
+    }
+}
+
+void
+gfxGDIFont::AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                                   FontCacheSizes* aSizes) const
+{
+    aSizes->mFontInstances += aMallocSizeOf(this);
+    AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
+}