Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 542 insertions, 0 deletions

diff --git a/gfx/thebes/gfxFontMissingGlyphs.cpp b/gfx/thebes/gfxFontMissingGlyphs.cpp
new file mode 100644
index 0000000000..949a71228c
--- /dev/null
+++ b/gfx/thebes/gfxFontMissingGlyphs.cpp
@@ -0,0 +1,542 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * 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 "gfxFontMissingGlyphs.h"
+
+#include "gfxUtils.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Helpers.h"
+#include "mozilla/gfx/PathHelpers.h"
+#include "mozilla/LinkedList.h"
+#include "mozilla/RefPtr.h"
+#include "nsDeviceContext.h"
+#include "nsLayoutUtils.h"
+#include "TextDrawTarget.h"
+#include "LayerUserData.h"
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+#define X 255
+static const uint8_t gMiniFontData[] = {
+    0, X, 0, 0, X, 0, X, X, X, X, X, X, X, 0, X, X, X, X, X, X, X, X, X, X,
+    X, X, X, X, X, X, X, X, X, X, X, 0, 0, X, X, X, X, 0, X, X, X, X, X, X,
+    X, 0, X, 0, X, 0, 0, 0, X, 0, 0, X, X, 0, X, X, 0, 0, X, 0, 0, 0, 0, X,
+    X, 0, X, X, 0, X, X, 0, X, X, 0, X, X, 0, 0, X, 0, X, X, 0, 0, X, 0, 0,
+    X, 0, X, 0, X, 0, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, 0, 0, X,
+    X, X, X, X, X, X, X, X, X, X, X, 0, X, 0, 0, X, 0, X, X, X, X, X, X, X,
+    X, 0, X, 0, X, 0, X, 0, 0, 0, 0, X, 0, 0, X, 0, 0, X, X, 0, X, 0, 0, X,
+    X, 0, X, 0, 0, X, X, 0, X, X, 0, X, X, 0, 0, X, 0, X, X, 0, 0, X, 0, 0,
+    0, X, 0, 0, X, 0, X, X, X, X, X, X, 0, 0, X, X, X, X, X, X, X, 0, 0, X,
+    X, X, X, 0, 0, X, X, 0, X, X, X, 0, 0, X, X, X, X, 0, X, X, X, X, 0, 0,
+};
+#undef X
+
+/* Parameters that control the rendering of hexboxes. They look like this:
+
+        BMP codepoints           non-BMP codepoints
+      (U+0000 - U+FFFF)         (U+10000 - U+10FFFF)
+
+         +---------+              +-------------+
+         |         |              |             |
+         | HHH HHH |              | HHH HHH HHH |
+         | HHH HHH |              | HHH HHH HHH |
+         | HHH HHH |              | HHH HHH HHH |
+         | HHH HHH |              | HHH HHH HHH |
+         | HHH HHH |              | HHH HHH HHH |
+         |         |              |             |
+         | HHH HHH |              | HHH HHH HHH |
+         | HHH HHH |              | HHH HHH HHH |
+         | HHH HHH |              | HHH HHH HHH |
+         | HHH HHH |              | HHH HHH HHH |
+         | HHH HHH |              | HHH HHH HHH |
+         |         |              |             |
+         +---------+              +-------------+
+*/
+
+/** Width of a minifont glyph (see above) */
+static const int MINIFONT_WIDTH = 3;
+/** Height of a minifont glyph (see above) */
+static const int MINIFONT_HEIGHT = 5;
+/**
+ * Gap between minifont glyphs (both horizontal and vertical) and also
+ * the minimum desired gap between the box border and the glyphs
+ */
+static const int HEX_CHAR_GAP = 1;
+/**
+ * The amount of space between the vertical edge of the glyphbox and the
+ * box border. We make this nonzero so that when multiple missing glyphs
+ * occur consecutively there's a gap between their rendered boxes.
+ */
+static const int BOX_HORIZONTAL_INSET = 1;
+/** The width of the border */
+static const int BOX_BORDER_WIDTH = 1;
+/**
+ * The scaling factor for the border opacity; this is multiplied by the current
+ * opacity being used to draw the text.
+ */
+static const Float BOX_BORDER_OPACITY = 0.5;
+
+#ifndef MOZ_GFX_OPTIMIZE_MOBILE
+
+class GlyphAtlas {
+ public:
+  GlyphAtlas(RefPtr<SourceSurface>&& aSurface, const DeviceColor& aColor)
+      : mSurface(std::move(aSurface)), mColor(aColor) {}
+  ~GlyphAtlas() = default;
+
+  already_AddRefed<SourceSurface> Surface() const {
+    RefPtr surface = mSurface;
+    return surface.forget();
+  }
+  DeviceColor Color() const { return mColor; }
+
+ private:
+  RefPtr<SourceSurface> mSurface;
+  DeviceColor mColor;
+};
+
+// This is an owning reference that we will manage via exchange() and
+// explicit new/delete operations.
+static std::atomic<GlyphAtlas*> gGlyphAtlas;
+
+/**
+ * Generates a new colored mini-font atlas from the mini-font mask.
+ */
+static GlyphAtlas* MakeGlyphAtlas(const DeviceColor& aColor) {
+  RefPtr<DrawTarget> glyphDrawTarget =
+      gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
+          IntSize(MINIFONT_WIDTH * 16, MINIFONT_HEIGHT),
+          SurfaceFormat::B8G8R8A8);
+  if (!glyphDrawTarget) {
+    return nullptr;
+  }
+  RefPtr<SourceSurface> glyphMask =
+      glyphDrawTarget->CreateSourceSurfaceFromData(
+          const_cast<uint8_t*>(gMiniFontData),
+          IntSize(MINIFONT_WIDTH * 16, MINIFONT_HEIGHT), MINIFONT_WIDTH * 16,
+          SurfaceFormat::A8);
+  if (!glyphMask) {
+    return nullptr;
+  }
+  glyphDrawTarget->MaskSurface(ColorPattern(aColor), glyphMask, Point(0, 0),
+                               DrawOptions(1.0f, CompositionOp::OP_SOURCE));
+  RefPtr<SourceSurface> surface = glyphDrawTarget->Snapshot();
+  if (!surface) {
+    return nullptr;
+  }
+  return new GlyphAtlas(std::move(surface), aColor);
+}
+
+/**
+ * Reuse the current mini-font atlas if the color matches, otherwise regenerate
+ * it.
+ */
+static inline already_AddRefed<SourceSurface> GetGlyphAtlas(
+    const DeviceColor& aColor) {
+  // Get the opaque color, ignoring any transparency which will be handled
+  // later.
+  DeviceColor color(aColor.r, aColor.g, aColor.b);
+
+  // Atomically grab the current GlyphAtlas pointer (if any). Because we
+  // exchange with nullptr here, no other thread will be able to touch the
+  // currAtlas record while we're using it; if they try, they'll just see
+  // the null that we stored.
+  GlyphAtlas* currAtlas = gGlyphAtlas.exchange(nullptr);
+
+  if (currAtlas && currAtlas->Color() == color) {
+    // If its color is right, grab a reference to its surface.
+    RefPtr<SourceSurface> surface = currAtlas->Surface();
+    // Now put the currAtlas record back in the global. If some other thread
+    // has stored an atlas there in the meantime, we just discard it.
+    delete gGlyphAtlas.exchange(currAtlas);
+    return surface.forget();
+  }
+
+  // Make a new atlas in the color we want.
+  GlyphAtlas* atlas = MakeGlyphAtlas(color);
+  RefPtr<SourceSurface> surface = atlas ? atlas->Surface() : nullptr;
+
+  // Store the newly-created atlas in the global; release any other.
+  delete gGlyphAtlas.exchange(atlas);
+  return surface.forget();
+}
+
+/**
+ * Clear any cached glyph atlas resources.
+ */
+static void PurgeGlyphAtlas() { delete gGlyphAtlas.exchange(nullptr); }
+
+// WebRender layer manager user data that will get signaled when the layer
+// manager is destroyed.
+class WRUserData : public layers::LayerUserData,
+                   public LinkedListElement<WRUserData> {
+ public:
+  explicit WRUserData(layers::WebRenderLayerManager* aManager);
+
+  ~WRUserData();
+
+  static void Assign(layers::WebRenderLayerManager* aManager) {
+    if (!aManager->HasUserData(&sWRUserDataKey)) {
+      aManager->SetUserData(&sWRUserDataKey, new WRUserData(aManager));
+    }
+  }
+
+  void Remove() { mManager->RemoveUserData(&sWRUserDataKey); }
+
+  layers::WebRenderLayerManager* mManager;
+
+  static UserDataKey sWRUserDataKey;
+};
+
+static void DestroyImageKey(void* aClosure) {
+  auto* key = static_cast<wr::ImageKey*>(aClosure);
+  delete key;
+}
+
+static RefPtr<SourceSurface> gWRGlyphAtlas[8];
+static LinkedList<WRUserData> gWRUsers;
+UserDataKey WRUserData::sWRUserDataKey;
+
+/**
+ * Generates a transformed WebRender mini-font atlas for a given orientation.
+ */
+static already_AddRefed<SourceSurface> MakeWRGlyphAtlas(const Matrix* aMat) {
+  IntSize size(MINIFONT_WIDTH * 16, MINIFONT_HEIGHT);
+  // If the orientation is transposed, width/height are swapped.
+  if (aMat && aMat->_11 == 0) {
+    std::swap(size.width, size.height);
+  }
+  RefPtr<DrawTarget> ref =
+      gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget();
+  RefPtr<DrawTarget> dt =
+      gfxPlatform::GetPlatform()->CreateSimilarSoftwareDrawTarget(
+          ref, size, SurfaceFormat::B8G8R8A8);
+  if (!dt) {
+    return nullptr;
+  }
+  if (aMat) {
+    // Select appropriate transform matrix based on whether the
+    // orientation is transposed.
+    dt->SetTransform(aMat->_11 == 0
+                         ? Matrix(0.0f, copysign(1.0f, aMat->_12),
+                                  copysign(1.0f, aMat->_21), 0.0f,
+                                  aMat->_21 < 0 ? MINIFONT_HEIGHT : 0.0f,
+                                  aMat->_12 < 0 ? MINIFONT_WIDTH * 16 : 0.0f)
+                         : Matrix(copysign(1.0f, aMat->_11), 0.0f, 0.0f,
+                                  copysign(1.0f, aMat->_22),
+                                  aMat->_11 < 0 ? MINIFONT_WIDTH * 16 : 0.0f,
+                                  aMat->_22 < 0 ? MINIFONT_HEIGHT : 0.0f));
+  }
+  RefPtr<SourceSurface> mask = dt->CreateSourceSurfaceFromData(
+      const_cast<uint8_t*>(gMiniFontData),
+      IntSize(MINIFONT_WIDTH * 16, MINIFONT_HEIGHT), MINIFONT_WIDTH * 16,
+      SurfaceFormat::A8);
+  if (!mask) {
+    return nullptr;
+  }
+  dt->MaskSurface(ColorPattern(DeviceColor::MaskOpaqueWhite()), mask,
+                  Point(0, 0));
+  return dt->Snapshot();
+}
+
+/**
+ * Clear any cached WebRender glyph atlas resources.
+ */
+static void PurgeWRGlyphAtlas() {
+  // For each WR layer manager, we need go through each atlas orientation
+  // and see if it has a stashed image key. If it does, remove the image
+  // from the layer manager.
+  for (WRUserData* user : gWRUsers) {
+    auto* manager = user->mManager;
+    for (size_t i = 0; i < 8; i++) {
+      if (gWRGlyphAtlas[i]) {
+        auto* key = static_cast<wr::ImageKey*>(gWRGlyphAtlas[i]->GetUserData(
+            reinterpret_cast<UserDataKey*>(manager)));
+        if (key) {
+          manager->GetRenderRootStateManager()->AddImageKeyForDiscard(*key);
+        }
+      }
+    }
+  }
+  // Remove the layer managers' destroy notifications only after processing
+  // so as not to mess up gWRUsers iteration.
+  while (!gWRUsers.isEmpty()) {
+    gWRUsers.popFirst()->Remove();
+  }
+  // Finally, clear out the atlases.
+  for (size_t i = 0; i < 8; i++) {
+    gWRGlyphAtlas[i] = nullptr;
+  }
+}
+
+WRUserData::WRUserData(layers::WebRenderLayerManager* aManager)
+    : mManager(aManager) {
+  gWRUsers.insertFront(this);
+}
+
+WRUserData::~WRUserData() {
+  // When the layer manager is destroyed, we need go through each
+  // atlas and remove any assigned image keys.
+  if (isInList()) {
+    for (size_t i = 0; i < 8; i++) {
+      if (gWRGlyphAtlas[i]) {
+        gWRGlyphAtlas[i]->RemoveUserData(
+            reinterpret_cast<UserDataKey*>(mManager));
+      }
+    }
+  }
+}
+
+static already_AddRefed<SourceSurface> GetWRGlyphAtlas(DrawTarget& aDrawTarget,
+                                                       const Matrix* aMat) {
+  uint32_t key = 0;
+  // Encode orientation in the key.
+  if (aMat) {
+    if (aMat->_11 == 0) {
+      key |= 4 | (aMat->_12 < 0 ? 1 : 0) | (aMat->_21 < 0 ? 2 : 0);
+    } else {
+      key |= (aMat->_11 < 0 ? 1 : 0) | (aMat->_22 < 0 ? 2 : 0);
+    }
+  }
+
+  // Check if an atlas was already created, or create one if necessary.
+  RefPtr<SourceSurface> atlas = gWRGlyphAtlas[key];
+  if (!atlas) {
+    atlas = MakeWRGlyphAtlas(aMat);
+    gWRGlyphAtlas[key] = atlas;
+  }
+
+  // The atlas may exist, but an image key may not be assigned for it to
+  // the given layer manager, or it may no longer be valid.
+  auto* tdt = static_cast<layout::TextDrawTarget*>(&aDrawTarget);
+  auto* manager = tdt->WrLayerManager();
+  auto* imageKey = static_cast<wr::ImageKey*>(
+      atlas->GetUserData(reinterpret_cast<UserDataKey*>(manager)));
+  if (!imageKey || !manager->WrBridge()->MatchesNamespace(*imageKey)) {
+    // No image key, so we need to map the atlas' data for transfer to WR.
+    RefPtr<DataSourceSurface> dataSurface = atlas->GetDataSurface();
+    if (!dataSurface) {
+      return nullptr;
+    }
+    DataSourceSurface::ScopedMap map(dataSurface, DataSourceSurface::READ);
+    if (!map.IsMapped()) {
+      return nullptr;
+    }
+    // Transfer the data and get an image key for it.
+    Maybe<wr::ImageKey> result = tdt->DefineImage(
+        atlas->GetSize(), map.GetStride(), atlas->GetFormat(), map.GetData());
+    if (!result.isSome()) {
+      return nullptr;
+    }
+    // Assign the image key to the atlas.
+    atlas->AddUserData(reinterpret_cast<UserDataKey*>(manager),
+                       new wr::ImageKey(result.ref()), DestroyImageKey);
+    // Create a user data notification for when the layer manager is
+    // destroyed so we can clean up any assigned image keys.
+    WRUserData::Assign(manager);
+  }
+  return atlas.forget();
+}
+
+static void DrawHexChar(uint32_t aDigit, Float aLeft, Float aTop,
+                        DrawTarget& aDrawTarget, SourceSurface* aAtlas,
+                        const DeviceColor& aColor,
+                        const Matrix* aMat = nullptr) {
+  Rect dest(aLeft, aTop, MINIFONT_WIDTH, MINIFONT_HEIGHT);
+  if (aDrawTarget.GetBackendType() == BackendType::WEBRENDER_TEXT) {
+    // For WR, we need to get the image key assigned to the given WR layer
+    // manager for referencing the image.
+    auto* tdt = static_cast<layout::TextDrawTarget*>(&aDrawTarget);
+    auto* manager = tdt->WrLayerManager();
+    auto* key = static_cast<wr::ImageKey*>(
+        aAtlas->GetUserData(reinterpret_cast<UserDataKey*>(manager)));
+    MOZ_ASSERT(key);
+    // Transform the bounds of the atlas into the given orientation, and then
+    // also transform a small clip rect which will be used to select the given
+    // digit from the atlas.
+    Rect bounds(aLeft - aDigit * MINIFONT_WIDTH, aTop, MINIFONT_WIDTH * 16,
+                MINIFONT_HEIGHT);
+    if (aMat) {
+      // Width and height may be negative after the transform, so move the rect
+      // if necessary and fix size.
+      bounds = aMat->TransformRect(bounds);
+      bounds.x += std::min(bounds.width, 0.0f);
+      bounds.y += std::min(bounds.height, 0.0f);
+      bounds.width = fabs(bounds.width);
+      bounds.height = fabs(bounds.height);
+      dest = aMat->TransformRect(dest);
+      dest.x += std::min(dest.width, 0.0f);
+      dest.y += std::min(dest.height, 0.0f);
+      dest.width = fabs(dest.width);
+      dest.height = fabs(dest.height);
+    }
+    // Finally, push the colored image with point filtering.
+    tdt->PushImage(*key, bounds, dest, wr::ImageRendering::Pixelated,
+                   wr::ToColorF(aColor));
+  } else {
+    // For the normal case, just draw the given digit from the atlas. Point
+    // filtering is used to ensure the mini-font rectangles stay sharp with any
+    // scaling. Handle any transparency here as well.
+    aDrawTarget.DrawSurface(
+        aAtlas, dest,
+        Rect(aDigit * MINIFONT_WIDTH, 0, MINIFONT_WIDTH, MINIFONT_HEIGHT),
+        DrawSurfaceOptions(SamplingFilter::POINT),
+        DrawOptions(aColor.a, CompositionOp::OP_OVER, AntialiasMode::NONE));
+  }
+}
+
+void gfxFontMissingGlyphs::Purge() {
+  PurgeGlyphAtlas();
+  PurgeWRGlyphAtlas();
+}
+
+#else  // MOZ_GFX_OPTIMIZE_MOBILE
+
+void gfxFontMissingGlyphs::Purge() {}
+
+#endif
+
+void gfxFontMissingGlyphs::Shutdown() { Purge(); }
+
+void gfxFontMissingGlyphs::DrawMissingGlyph(uint32_t aChar, const Rect& aRect,
+                                            DrawTarget& aDrawTarget,
+                                            const Pattern& aPattern,
+                                            const Matrix* aMat) {
+  Rect rect(aRect);
+  // If there is an orientation transform, reorient the bounding rect.
+  if (aMat) {
+    rect.MoveBy(-aRect.BottomLeft());
+    rect = aMat->TransformBounds(rect);
+    rect.MoveBy(aRect.BottomLeft());
+  }
+
+  // If we're currently drawing with some kind of pattern, we just draw the
+  // missing-glyph data in black.
+  DeviceColor color = aPattern.GetType() == PatternType::COLOR
+                          ? static_cast<const ColorPattern&>(aPattern).mColor
+                          : ToDeviceColor(sRGBColor::OpaqueBlack());
+
+  // Stroke a rectangle so that the stroke's left edge is inset one pixel
+  // from the left edge of the glyph box and the stroke's right edge
+  // is inset one pixel from the right edge of the glyph box.
+  Float halfBorderWidth = BOX_BORDER_WIDTH / 2.0;
+  Float borderLeft = rect.X() + BOX_HORIZONTAL_INSET + halfBorderWidth;
+  Float borderRight = rect.XMost() - BOX_HORIZONTAL_INSET - halfBorderWidth;
+  Rect borderStrokeRect(borderLeft, rect.Y() + halfBorderWidth,
+                        borderRight - borderLeft,
+                        rect.Height() - 2.0 * halfBorderWidth);
+  if (!borderStrokeRect.IsEmpty()) {
+    ColorPattern adjustedColor(color);
+    adjustedColor.mColor.a *= BOX_BORDER_OPACITY;
+#ifdef MOZ_GFX_OPTIMIZE_MOBILE
+    aDrawTarget.FillRect(borderStrokeRect, adjustedColor);
+#else
+    StrokeOptions strokeOptions(BOX_BORDER_WIDTH);
+    aDrawTarget.StrokeRect(borderStrokeRect, adjustedColor, strokeOptions);
+#endif
+  }
+
+#ifndef MOZ_GFX_OPTIMIZE_MOBILE
+  RefPtr<SourceSurface> atlas =
+      aDrawTarget.GetBackendType() == BackendType::WEBRENDER_TEXT
+          ? GetWRGlyphAtlas(aDrawTarget, aMat)
+          : GetGlyphAtlas(color);
+  if (!atlas) {
+    return;
+  }
+
+  Point center = rect.Center();
+  Float halfGap = HEX_CHAR_GAP / 2.f;
+  Float top = -(MINIFONT_HEIGHT + halfGap);
+
+  // Figure out a scaling factor that will fit the glyphs in the target rect
+  // both horizontally and vertically.
+  Float width = HEX_CHAR_GAP + MINIFONT_WIDTH + HEX_CHAR_GAP + MINIFONT_WIDTH +
+                ((aChar < 0x10000) ? 0 : HEX_CHAR_GAP + MINIFONT_WIDTH) +
+                HEX_CHAR_GAP;
+  Float height = HEX_CHAR_GAP + MINIFONT_HEIGHT + HEX_CHAR_GAP +
+                 MINIFONT_HEIGHT + HEX_CHAR_GAP;
+  Float scaling = std::min(rect.Height() / height, rect.Width() / width);
+
+  // We always want integer scaling, otherwise the "bitmap" glyphs will look
+  // even uglier than usual when scaled to the target.
+  int32_t devPixelsPerCSSPx = std::max<int32_t>(1, std::floor(scaling));
+
+  Matrix tempMat;
+  if (aMat) {
+    // If there is an orientation transform, since draw target transforms may
+    // not be supported, scale and translate it so that it can be directly used
+    // for rendering the mini font without changing the draw target transform.
+    tempMat = Matrix(*aMat)
+                  .PostScale(devPixelsPerCSSPx, devPixelsPerCSSPx)
+                  .PostTranslate(center);
+    aMat = &tempMat;
+  } else {
+    // Otherwise, scale and translate the draw target transform assuming it
+    // supports that.
+    tempMat = aDrawTarget.GetTransform();
+    aDrawTarget.SetTransform(Matrix(tempMat).PreTranslate(center).PreScale(
+        devPixelsPerCSSPx, devPixelsPerCSSPx));
+  }
+
+  if (aChar < 0x10000) {
+    if (rect.Width() >= 2 * (MINIFONT_WIDTH + HEX_CHAR_GAP) &&
+        rect.Height() >= 2 * MINIFONT_HEIGHT + HEX_CHAR_GAP) {
+      // Draw 4 digits for BMP
+      Float left = -(MINIFONT_WIDTH + halfGap);
+      DrawHexChar((aChar >> 12) & 0xF, left, top, aDrawTarget, atlas, color,
+                  aMat);
+      DrawHexChar((aChar >> 8) & 0xF, halfGap, top, aDrawTarget, atlas, color,
+                  aMat);
+      DrawHexChar((aChar >> 4) & 0xF, left, halfGap, aDrawTarget, atlas, color,
+                  aMat);
+      DrawHexChar(aChar & 0xF, halfGap, halfGap, aDrawTarget, atlas, color,
+                  aMat);
+    }
+  } else {
+    if (rect.Width() >= 3 * (MINIFONT_WIDTH + HEX_CHAR_GAP) &&
+        rect.Height() >= 2 * MINIFONT_HEIGHT + HEX_CHAR_GAP) {
+      // Draw 6 digits for non-BMP
+      Float first = -(MINIFONT_WIDTH * 1.5 + HEX_CHAR_GAP);
+      Float second = -(MINIFONT_WIDTH / 2.0);
+      Float third = (MINIFONT_WIDTH / 2.0 + HEX_CHAR_GAP);
+      DrawHexChar((aChar >> 20) & 0xF, first, top, aDrawTarget, atlas, color,
+                  aMat);
+      DrawHexChar((aChar >> 16) & 0xF, second, top, aDrawTarget, atlas, color,
+                  aMat);
+      DrawHexChar((aChar >> 12) & 0xF, third, top, aDrawTarget, atlas, color,
+                  aMat);
+      DrawHexChar((aChar >> 8) & 0xF, first, halfGap, aDrawTarget, atlas, color,
+                  aMat);
+      DrawHexChar((aChar >> 4) & 0xF, second, halfGap, aDrawTarget, atlas,
+                  color, aMat);
+      DrawHexChar(aChar & 0xF, third, halfGap, aDrawTarget, atlas, color, aMat);
+    }
+  }
+
+  if (!aMat) {
+    // The draw target transform was changed, so it must be restored to
+    // the original value.
+    aDrawTarget.SetTransform(tempMat);
+  }
+#endif
+}
+
+Float gfxFontMissingGlyphs::GetDesiredMinWidth(uint32_t aChar,
+                                               uint32_t aAppUnitsPerDevPixel) {
+  /**
+   * The minimum desired width for a missing-glyph glyph box. I've laid it out
+   * like this so you can see what goes where.
+   */
+  Float width = BOX_HORIZONTAL_INSET + BOX_BORDER_WIDTH + HEX_CHAR_GAP +
+                MINIFONT_WIDTH + HEX_CHAR_GAP + MINIFONT_WIDTH +
+                ((aChar < 0x10000) ? 0 : HEX_CHAR_GAP + MINIFONT_WIDTH) +
+                HEX_CHAR_GAP + BOX_BORDER_WIDTH + BOX_HORIZONTAL_INSET;
+  // Note that this will give us floating-point division, so the width will
+  // -not- be snapped to integer multiples of its basic pixel value
+  width *= Float(AppUnitsPerCSSPixel()) / aAppUnitsPerDevPixel;
+  return width;
+}