Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 616 insertions, 0 deletions

diff --git a/layout/generic/TextDrawTarget.h b/layout/generic/TextDrawTarget.h
new file mode 100644
index 0000000000..551dde2ff0
--- /dev/null
+++ b/layout/generic/TextDrawTarget.h
@@ -0,0 +1,616 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef TextDrawTarget_h
+#define TextDrawTarget_h
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/layers/RenderRootStateManager.h"
+#include "mozilla/layers/WebRenderLayerManager.h"
+#include "mozilla/layers/WebRenderBridgeChild.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/layers/StackingContextHelper.h"
+#include "mozilla/layers/IpcResourceUpdateQueue.h"
+
+namespace mozilla {
+namespace layout {
+
+using namespace gfx;
+
+// This class is a fake DrawTarget, used to intercept text draw calls, while
+// also collecting up the other aspects of text natively.
+//
+// When using advanced-layers in nsDisplayText's constructor, we construct this
+// and run the full painting algorithm with this as the DrawTarget. This is
+// done to avoid having to massively refactor gecko's text painting code (which
+// has lots of components shared between other rendering algorithms).
+//
+// In some phases of the painting algorithm, we can grab the relevant values
+// and feed them directly into TextDrawTarget. For instance, selections,
+// decorations, and shadows are handled in this manner. In those cases we can
+// also short-circuit the painting algorithm to save work.
+//
+// In other phases, the computed values are sufficiently buried in complex
+// code that it's best for us to just intercept the final draw calls. This
+// is how we handle computing the glyphs of the main text and text-emphasis
+// (see our overloaded FillGlyphs implementation).
+//
+// To be clear: this is a big hack. With time we hope to refactor the codebase
+// so that all the elements of text are handled directly by TextDrawTarget,
+// which is to say everything is done like we do selections and shadows now.
+// This design is a good step for doing this work incrementally.
+//
+// This is also likely to be a bit buggy (missing or misinterpreted info)
+// while we further develop the design.
+//
+// TextDrawTarget doesn't yet support all features. See mHasUnsupportedFeatures
+// for details.
+class TextDrawTarget : public DrawTarget {
+ public:
+  explicit TextDrawTarget(wr::DisplayListBuilder& aBuilder,
+                          wr::IpcResourceUpdateQueue& aResources,
+                          const layers::StackingContextHelper& aSc,
+                          layers::RenderRootStateManager* aManager,
+                          nsDisplayItem* aItem, nsRect& aBounds,
+                          bool aCallerDoesSaveRestore = false)
+      : mCallerDoesSaveRestore(aCallerDoesSaveRestore), mBuilder(aBuilder) {
+    Reinitialize(aResources, aSc, aManager, aItem, aBounds);
+  }
+
+  // Prevent this from being copied
+  TextDrawTarget(const TextDrawTarget& src) = delete;
+  TextDrawTarget& operator=(const TextDrawTarget&) = delete;
+
+  ~TextDrawTarget() { MOZ_ASSERT(mFinished); }
+
+  void Reinitialize(wr::IpcResourceUpdateQueue& aResources,
+                    const layers::StackingContextHelper& aSc,
+                    layers::RenderRootStateManager* aManager,
+                    nsDisplayItem* aItem, nsRect& aBounds) {
+    mResources = &aResources;
+    mSc = &aSc;
+    mManager = aManager;
+    mHasUnsupportedFeatures = false;
+    mHasShadows = false;
+
+    SetPermitSubpixelAA(true);
+
+    // Compute clip/bounds
+    auto appUnitsPerDevPixel =
+        aItem->Frame()->PresContext()->AppUnitsPerDevPixel();
+    LayoutDeviceRect layoutBoundsRect =
+        LayoutDeviceRect::FromAppUnits(aBounds, appUnitsPerDevPixel);
+    LayoutDeviceRect layoutClipRect = layoutBoundsRect;
+    mBoundsRect = wr::ToLayoutRect(layoutBoundsRect);
+
+    // Add 1 pixel of dirty area around clip rect to allow us to paint
+    // antialiased pixels beyond the measured text extents.
+    layoutClipRect.Inflate(1);
+    mSize = IntSize::Ceil(layoutClipRect.Width(), layoutClipRect.Height());
+    mClipStack.ClearAndRetainStorage();
+    mClipStack.AppendElement(layoutClipRect);
+
+    mBackfaceVisible = !aItem->BackfaceIsHidden();
+
+    if (!mCallerDoesSaveRestore) {
+      mBuilder.Save();
+    }
+  }
+
+  void FoundUnsupportedFeature() { mHasUnsupportedFeatures = true; }
+  bool CheckHasUnsupportedFeatures() {
+    MOZ_ASSERT(mCallerDoesSaveRestore);
+#ifdef DEBUG
+    MOZ_ASSERT(!mFinished);
+    mFinished = true;
+#endif
+    return mHasUnsupportedFeatures;
+  }
+
+  bool Finish() {
+    MOZ_ASSERT(!mCallerDoesSaveRestore);
+#ifdef DEBUG
+    mFinished = true;
+#endif
+    if (mHasUnsupportedFeatures) {
+      mBuilder.Restore();
+      return false;
+    }
+    mBuilder.ClearSave();
+    return true;
+  }
+
+  wr::FontInstanceFlags GetWRGlyphFlags() const { return mWRGlyphFlags; }
+  void SetWRGlyphFlags(wr::FontInstanceFlags aFlags) { mWRGlyphFlags = aFlags; }
+
+  class AutoRestoreWRGlyphFlags {
+   public:
+    ~AutoRestoreWRGlyphFlags() {
+      if (mTarget) {
+        mTarget->SetWRGlyphFlags(mFlags);
+      }
+    }
+
+    void Save(TextDrawTarget* aTarget) {
+      // This allows for recursive saves, in case the flags need to be modified
+      // under multiple conditions (i.e. transforms and synthetic italics),
+      // since the flags will be restored to the first saved value in the
+      // destructor on scope exit.
+      if (!mTarget) {
+        // Only record the first save with the original flags that will be
+        // restored.
+        mTarget = aTarget;
+        mFlags = aTarget->GetWRGlyphFlags();
+      } else {
+        // Ensure that this is actually a recursive save to the same target
+        MOZ_ASSERT(
+            mTarget == aTarget,
+            "Recursive save of WR glyph flags to different TextDrawTargets");
+      }
+    }
+
+   private:
+    TextDrawTarget* mTarget = nullptr;
+    wr::FontInstanceFlags mFlags = {0};
+  };
+
+  // This overload just stores the glyphs/font/color.
+  void FillGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer,
+                  const Pattern& aPattern,
+                  const DrawOptions& aOptions) override {
+    // Make sure we're only given boring color patterns
+    MOZ_RELEASE_ASSERT(aOptions.mCompositionOp == CompositionOp::OP_OVER);
+    MOZ_RELEASE_ASSERT(aOptions.mAlpha == 1.0f);
+    MOZ_RELEASE_ASSERT(aPattern.GetType() == PatternType::COLOR);
+
+    // Make sure the font exists, and can be serialized
+    MOZ_RELEASE_ASSERT(aFont);
+    if (!aFont->CanSerialize()) {
+      FoundUnsupportedFeature();
+      return;
+    }
+
+    auto* colorPat = static_cast<const ColorPattern*>(&aPattern);
+    auto color = wr::ToColorF(colorPat->mColor);
+    MOZ_ASSERT(aBuffer.mNumGlyphs);
+    auto glyphs = Range<const wr::GlyphInstance>(
+        reinterpret_cast<const wr::GlyphInstance*>(aBuffer.mGlyphs),
+        aBuffer.mNumGlyphs);
+    // MSVC won't let us use offsetof on the following directly so we give it a
+    // name with typedef
+    typedef std::remove_reference<decltype(aBuffer.mGlyphs[0])>::type GlyphType;
+    // Compare gfx::Glyph and wr::GlyphInstance to make sure that they are
+    // structurally equivalent to ensure that our cast above was ok
+    static_assert(
+        std::is_same<decltype(aBuffer.mGlyphs[0].mIndex),
+                     decltype(glyphs[0].index)>() &&
+            std::is_same<decltype(aBuffer.mGlyphs[0].mPosition.x.value),
+                         decltype(glyphs[0].point.x)>() &&
+            std::is_same<decltype(aBuffer.mGlyphs[0].mPosition.y.value),
+                         decltype(glyphs[0].point.y)>() &&
+            offsetof(GlyphType, mIndex) == offsetof(wr::GlyphInstance, index) &&
+            offsetof(GlyphType, mPosition) ==
+                offsetof(wr::GlyphInstance, point) &&
+            offsetof(decltype(aBuffer.mGlyphs[0].mPosition), x) ==
+                offsetof(decltype(glyphs[0].point), x) &&
+            offsetof(decltype(aBuffer.mGlyphs[0].mPosition), y) ==
+                offsetof(decltype(glyphs[0].point), y) &&
+            std::is_standard_layout<
+                std::remove_reference<decltype(aBuffer.mGlyphs[0])>>::value &&
+            std::is_standard_layout<
+                std::remove_reference<decltype(glyphs[0])>>::value &&
+            sizeof(aBuffer.mGlyphs[0]) == sizeof(glyphs[0]) &&
+            sizeof(aBuffer.mGlyphs[0].mPosition) == sizeof(glyphs[0].point),
+        "glyph buf types don't match");
+
+    wr::GlyphOptions glyphOptions;
+    glyphOptions.render_mode =
+        wr::ToFontRenderMode(aOptions.mAntialiasMode, GetPermitSubpixelAA());
+    glyphOptions.flags = mWRGlyphFlags;
+
+    mManager->WrBridge()->PushGlyphs(mBuilder, *mResources, glyphs, aFont,
+                                     color, *mSc, mBoundsRect, ClipRect(),
+                                     mBackfaceVisible, &glyphOptions);
+  }
+
+  void PushClipRect(const Rect& aRect) override {
+    LayoutDeviceRect rect = LayoutDeviceRect::FromUnknownRect(aRect);
+    rect = rect.Intersect(mClipStack.LastElement());
+    mClipStack.AppendElement(rect);
+  }
+
+  void PopClip() override { mClipStack.RemoveLastElement(); }
+
+  IntSize GetSize() const override { return mSize; }
+
+  void AppendShadow(const wr::Shadow& aShadow, bool aInflate) {
+    mBuilder.PushShadow(mBoundsRect, ClipRect(), mBackfaceVisible, aShadow,
+                        aInflate);
+    mHasShadows = true;
+  }
+
+  void TerminateShadows() {
+    if (mHasShadows) {
+      mBuilder.PopAllShadows();
+      mHasShadows = false;
+    }
+  }
+
+  void AppendSelectionRect(const LayoutDeviceRect& aRect,
+                           const DeviceColor& aColor) {
+    auto rect = wr::ToLayoutRect(aRect);
+    auto color = wr::ToColorF(aColor);
+    mBuilder.PushRect(rect, ClipRect(), mBackfaceVisible, false, false, color);
+  }
+
+  // This function is basically designed to slide into the decoration drawing
+  // code of nsCSSRendering with minimum disruption, to minimize the
+  // chances of implementation drift. As such, it mostly looks like a call
+  // to a skia-style StrokeLine method: two end-points, with a thickness
+  // and style. Notably the end-points are *centered* in the block direction,
+  // even though webrender wants a rect-like representation, where the points
+  // are on corners.
+  //
+  // So we mangle the format here in a single centralized place, where neither
+  // webrender nor nsCSSRendering has to care about this mismatch.
+  //
+  // NOTE: we assume the points are axis-aligned, and aStart should be used
+  // as the top-left corner of the rect.
+  void AppendDecoration(const Point& aStart, const Point& aEnd,
+                        const float aThickness, const bool aVertical,
+                        const DeviceColor& aColor,
+                        const StyleTextDecorationStyle aStyle) {
+    auto pos = LayoutDevicePoint::FromUnknownPoint(aStart);
+    LayoutDeviceSize size;
+
+    if (aVertical) {
+      pos.x -= aThickness / 2;  // adjust from center to corner
+      size = LayoutDeviceSize(aThickness,
+                              ViewAs<LayoutDevicePixel>(aEnd.y - aStart.y));
+    } else {
+      pos.y -= aThickness / 2;  // adjust from center to corner
+      size = LayoutDeviceSize(ViewAs<LayoutDevicePixel>(aEnd.x - aStart.x),
+                              aThickness);
+    }
+
+    wr::Line decoration;
+    decoration.bounds = wr::ToLayoutRect(LayoutDeviceRect(pos, size));
+    decoration.wavyLineThickness = 0;  // dummy value, unused
+    decoration.color = wr::ToColorF(aColor);
+    decoration.orientation = aVertical ? wr::LineOrientation::Vertical
+                                       : wr::LineOrientation::Horizontal;
+
+    switch (aStyle) {
+      case StyleTextDecorationStyle::Solid:
+        decoration.style = wr::LineStyle::Solid;
+        break;
+      case StyleTextDecorationStyle::Dotted:
+        decoration.style = wr::LineStyle::Dotted;
+        break;
+      case StyleTextDecorationStyle::Dashed:
+        decoration.style = wr::LineStyle::Dashed;
+        break;
+      // Wavy lines should go through AppendWavyDecoration
+      case StyleTextDecorationStyle::Wavy:
+      // Double lines should be lowered to two solid lines
+      case StyleTextDecorationStyle::Double:
+      default:
+        MOZ_CRASH("TextDrawTarget received unsupported line style");
+    }
+
+    mBuilder.PushLine(ClipRect(), mBackfaceVisible, decoration);
+  }
+
+  // Seperated out from AppendDecoration because Wavy Lines are completely
+  // different, and trying to merge the concept is more of a mess than it's
+  // worth.
+  void AppendWavyDecoration(const Rect& aBounds, const float aThickness,
+                            const bool aVertical, const DeviceColor& aColor) {
+    wr::Line decoration;
+
+    decoration.bounds =
+        wr::ToLayoutRect(LayoutDeviceRect::FromUnknownRect(aBounds));
+    decoration.wavyLineThickness = aThickness;
+    decoration.color = wr::ToColorF(aColor);
+    decoration.orientation = aVertical ? wr::LineOrientation::Vertical
+                                       : wr::LineOrientation::Horizontal;
+    decoration.style = wr::LineStyle::Wavy;
+
+    mBuilder.PushLine(ClipRect(), mBackfaceVisible, decoration);
+  }
+
+  layers::WebRenderBridgeChild* WrBridge() { return mManager->WrBridge(); }
+  layers::WebRenderLayerManager* WrLayerManager() {
+    return mManager->LayerManager();
+  }
+
+  Maybe<wr::ImageKey> DefineImage(const IntSize& aSize, uint32_t aStride,
+                                  SurfaceFormat aFormat, const uint8_t* aData) {
+    wr::ImageKey key = mManager->WrBridge()->GetNextImageKey();
+    wr::ImageDescriptor desc(aSize, aStride, aFormat);
+    Range<uint8_t> bytes(const_cast<uint8_t*>(aData), aStride * aSize.height);
+    if (mResources->AddImage(key, desc, bytes)) {
+      return Some(key);
+    }
+    return Nothing();
+  }
+
+  void PushImage(wr::ImageKey aKey, const Rect& aBounds, const Rect& aClip,
+                 wr::ImageRendering aFilter, const wr::ColorF& aColor) {
+    if (!aClip.Intersects(GeckoClipRect().ToUnknownRect())) {
+      return;
+    }
+    mBuilder.PushImage(wr::ToLayoutRect(aBounds), wr::ToLayoutRect(aClip), true,
+                       false, aFilter, aKey, true, aColor);
+  }
+
+  LayoutDeviceRect GeckoClipRect() { return mClipStack.LastElement(); }
+
+ private:
+  wr::LayoutRect ClipRect() {
+    return wr::ToLayoutRect(mClipStack.LastElement());
+  }
+  // Whether anything unsupported was encountered. This will result in this
+  // text being emitted as a blob, which means subpixel-AA can't be used and
+  // that performance will probably be a bit worse. At this point, we've
+  // properly implemented everything that shows up a lot, so you can assume
+  // that the remaining things we don't implement are fairly rare. The complete
+  // set of things that we don't implement are as follows:
+  //
+  // * Unserializable Fonts: WR lives across an IPC boundary
+  // * Text-Combine-Upright Squishing: no one's really bothered to impl it yet
+  // * Text-Stroke: not a real standard (exists for webcompat)
+  // * SVG Glyphs: not a real standard (we got overzealous with svg)
+  // * Color Glyphs (Emoji) With Transparency: requires us to apply transparency
+  //   with a composited layer (a single emoji can be many single-color glyphs)
+  //
+  // The transparent colored-glyphs issue is probably the most valuable to fix,
+  // since ideally it would also result in us fixing transparency for all
+  // intersecting glyphs (which currently look bad with or without webrender,
+  // so there's no fallback like with emoji). Specifically, transparency
+  // looks bad for "cursive" fonts where glyphs overlap at the seams. Since
+  // this is more common for non-latin scripts (e.g. मनीष), this amounts to us
+  // treating non-latin scripts poorly... unless they're emoji. Yikes!
+  bool mHasUnsupportedFeatures = false;
+
+  // The caller promises to call Save/Restore on the builder as needed.
+  bool mCallerDoesSaveRestore = false;
+#ifdef DEBUG
+  bool mFinished = false;
+#endif
+
+  // Whether PopAllShadows needs to be called
+  bool mHasShadows = false;
+
+  // Things used to push to webrender
+  wr::DisplayListBuilder& mBuilder;
+  wr::IpcResourceUpdateQueue* mResources;
+  const layers::StackingContextHelper* mSc;
+  layers::RenderRootStateManager* mManager;
+
+  // Computed facts
+  IntSize mSize;
+  wr::LayoutRect mBoundsRect;
+  AutoTArray<LayoutDeviceRect, 3> mClipStack;
+  bool mBackfaceVisible;
+
+  wr::FontInstanceFlags mWRGlyphFlags = {0};
+
+  // The rest of this is dummy implementations of DrawTarget's API
+ public:
+  DrawTargetType GetType() const override {
+    return DrawTargetType::SOFTWARE_RASTER;
+  }
+
+  BackendType GetBackendType() const override {
+    return BackendType::WEBRENDER_TEXT;
+  }
+
+  bool IsRecording() const override { return true; }
+
+  already_AddRefed<SourceSurface> Snapshot() override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return nullptr;
+  }
+
+  already_AddRefed<SourceSurface> IntoLuminanceSource(
+      LuminanceType aLuminanceType, float aOpacity) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return nullptr;
+  }
+
+  void Flush() override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void DrawSurface(SourceSurface* aSurface, const Rect& aDest,
+                   const Rect& aSource, const DrawSurfaceOptions& aSurfOptions,
+                   const DrawOptions& aOptions) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void DrawFilter(FilterNode* aNode, const Rect& aSourceRect,
+                  const Point& aDestPoint,
+                  const DrawOptions& aOptions) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void DrawSurfaceWithShadow(SourceSurface* aSurface, const Point& aDest,
+                             const ShadowOptions& aShadow,
+                             CompositionOp aOperator) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void ClearRect(const Rect& aRect) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void CopySurface(SourceSurface* aSurface, const IntRect& aSourceRect,
+                   const IntPoint& aDestination) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void FillRect(const Rect& aRect, const Pattern& aPattern,
+                const DrawOptions& aOptions = DrawOptions()) override {
+    MOZ_RELEASE_ASSERT(aPattern.GetType() == PatternType::COLOR);
+
+    if (!aRect.Intersects(GeckoClipRect().ToUnknownRect())) {
+      return;
+    }
+    auto rect = wr::ToLayoutRect(LayoutDeviceRect::FromUnknownRect(aRect));
+    auto color =
+        wr::ToColorF(static_cast<const ColorPattern&>(aPattern).mColor);
+    mBuilder.PushRect(rect, ClipRect(), mBackfaceVisible, false, false, color);
+  }
+
+  void StrokeRect(const Rect& aRect, const Pattern& aPattern,
+                  const StrokeOptions& aStrokeOptions,
+                  const DrawOptions& aOptions) override {
+    MOZ_RELEASE_ASSERT(aPattern.GetType() == PatternType::COLOR &&
+                       aStrokeOptions.mDashLength == 0);
+
+    wr::LayoutSideOffsets widths = {
+        aStrokeOptions.mLineWidth, aStrokeOptions.mLineWidth,
+        aStrokeOptions.mLineWidth, aStrokeOptions.mLineWidth};
+    wr::ColorF color =
+        wr::ToColorF(static_cast<const ColorPattern&>(aPattern).mColor);
+    wr::BorderSide sides[4] = {{color, wr::BorderStyle::Solid},
+                               {color, wr::BorderStyle::Solid},
+                               {color, wr::BorderStyle::Solid},
+                               {color, wr::BorderStyle::Solid}};
+    wr::BorderRadius radius = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
+    LayoutDeviceRect rect = LayoutDeviceRect::FromUnknownRect(aRect);
+    rect.Inflate(aStrokeOptions.mLineWidth / 2);
+    if (!rect.Intersects(GeckoClipRect())) {
+      return;
+    }
+    wr::LayoutRect bounds = wr::ToLayoutRect(rect);
+    mBuilder.PushBorder(bounds, ClipRect(), true, widths,
+                        Range<const wr::BorderSide>(sides, 4), radius);
+  }
+
+  void StrokeLine(const Point& aStart, const Point& aEnd,
+                  const Pattern& aPattern, const StrokeOptions& aStrokeOptions,
+                  const DrawOptions& aOptions) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void Stroke(const Path* aPath, const Pattern& aPattern,
+              const StrokeOptions& aStrokeOptions,
+              const DrawOptions& aOptions) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void Fill(const Path* aPath, const Pattern& aPattern,
+            const DrawOptions& aOptions) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void StrokeGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer,
+                    const Pattern& aPattern,
+                    const StrokeOptions& aStrokeOptions,
+                    const DrawOptions& aOptions) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void Mask(const Pattern& aSource, const Pattern& aMask,
+            const DrawOptions& aOptions) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void MaskSurface(const Pattern& aSource, SourceSurface* aMask, Point aOffset,
+                   const DrawOptions& aOptions) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  bool Draw3DTransformedSurface(SourceSurface* aSurface,
+                                const Matrix4x4& aMatrix) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void PushClip(const Path* aPath) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void PushDeviceSpaceClipRects(const IntRect* aRects,
+                                uint32_t aCount) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+
+  void PushLayer(bool aOpaque, Float aOpacity, SourceSurface* aMask,
+                 const Matrix& aMaskTransform, const IntRect& aBounds,
+                 bool aCopyBackground) override {
+    // Fine to pretend we do this
+  }
+
+  void PopLayer() override {
+    // Fine to pretend we do this
+  }
+
+  already_AddRefed<SourceSurface> CreateSourceSurfaceFromData(
+      unsigned char* aData, const IntSize& aSize, int32_t aStride,
+      SurfaceFormat aFormat) const override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return nullptr;
+  }
+
+  already_AddRefed<SourceSurface> OptimizeSourceSurface(
+      SourceSurface* aSurface) const override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return nullptr;
+  }
+
+  already_AddRefed<SourceSurface> CreateSourceSurfaceFromNativeSurface(
+      const NativeSurface& aSurface) const override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return nullptr;
+  }
+
+  already_AddRefed<DrawTarget> CreateSimilarDrawTarget(
+      const IntSize& aSize, SurfaceFormat aFormat) const override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return nullptr;
+  }
+
+  bool CanCreateSimilarDrawTarget(const IntSize& aSize,
+                                  SurfaceFormat aFormat) const override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return false;
+  }
+
+  virtual RefPtr<DrawTarget> CreateClippedDrawTarget(
+      const Rect& aBounds, SurfaceFormat aFormat) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return nullptr;
+  }
+
+  already_AddRefed<PathBuilder> CreatePathBuilder(
+      FillRule aFillRule) const override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return nullptr;
+  }
+
+  already_AddRefed<FilterNode> CreateFilter(FilterType aType) override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return nullptr;
+  }
+
+  already_AddRefed<GradientStops> CreateGradientStops(
+      GradientStop* aStops, uint32_t aNumStops,
+      ExtendMode aExtendMode) const override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+    return nullptr;
+  }
+
+  void DetachAllSnapshots() override {
+    MOZ_CRASH("TextDrawTarget: Method shouldn't be called");
+  }
+};
+
+}  // namespace layout
+}  // namespace mozilla
+
+#endif