Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 1147 insertions, 0 deletions

diff --git a/layout/xul/nsTextBoxFrame.cpp b/layout/xul/nsTextBoxFrame.cpp
new file mode 100644
index 0000000000..817b23a559
--- /dev/null
+++ b/layout/xul/nsTextBoxFrame.cpp
@@ -0,0 +1,1147 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=4 sw=2 sts=2 et cindent: */
+/* 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 "nsTextBoxFrame.h"
+
+#include "gfx2DGlue.h"
+#include "gfxUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/layers/RenderRootStateManager.h"
+#include "mozilla/gfx/2D.h"
+#include "nsFontMetrics.h"
+#include "nsReadableUtils.h"
+#include "nsCOMPtr.h"
+#include "nsCRT.h"
+#include "nsGkAtoms.h"
+#include "nsPresContext.h"
+#include "gfxContext.h"
+#include "nsIContent.h"
+#include "nsNameSpaceManager.h"
+#include "nsBoxLayoutState.h"
+#include "nsMenuBarListener.h"
+#include "nsString.h"
+#include "nsITheme.h"
+#include "nsUnicharUtils.h"
+#include "nsContentUtils.h"
+#include "nsDisplayList.h"
+#include "nsCSSRendering.h"
+#include "nsIReflowCallback.h"
+#include "nsBoxFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsUnicodeProperties.h"
+#include "TextDrawTarget.h"
+
+#ifdef ACCESSIBILITY
+#  include "nsAccessibilityService.h"
+#endif
+
+#include "nsBidiUtils.h"
+#include "nsBidiPresUtils.h"
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+class nsAccessKeyInfo {
+ public:
+  int32_t mAccesskeyIndex;
+  nscoord mBeforeWidth, mAccessWidth, mAccessUnderlineSize, mAccessOffset;
+};
+
+bool nsTextBoxFrame::gAlwaysAppendAccessKey = false;
+bool nsTextBoxFrame::gAccessKeyPrefInitialized = false;
+bool nsTextBoxFrame::gInsertSeparatorBeforeAccessKey = false;
+bool nsTextBoxFrame::gInsertSeparatorPrefInitialized = false;
+
+nsIFrame* NS_NewTextBoxFrame(PresShell* aPresShell, ComputedStyle* aStyle) {
+  return new (aPresShell) nsTextBoxFrame(aStyle, aPresShell->GetPresContext());
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsTextBoxFrame)
+
+NS_QUERYFRAME_HEAD(nsTextBoxFrame)
+  NS_QUERYFRAME_ENTRY(nsTextBoxFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsLeafBoxFrame)
+
+nsresult nsTextBoxFrame::AttributeChanged(int32_t aNameSpaceID,
+                                          nsAtom* aAttribute,
+                                          int32_t aModType) {
+  bool aResize;
+  bool aRedraw;
+
+  UpdateAttributes(aAttribute, aResize, aRedraw);
+
+  if (aResize) {
+    PresShell()->FrameNeedsReflow(this, IntrinsicDirty::StyleChange,
+                                  NS_FRAME_IS_DIRTY);
+  } else if (aRedraw) {
+    nsBoxLayoutState state(PresContext());
+    XULRedraw(state);
+  }
+
+  // If the accesskey changed, register for the new value
+  // The old value has been unregistered in nsXULElement::SetAttr
+  if (aAttribute == nsGkAtoms::accesskey || aAttribute == nsGkAtoms::control)
+    RegUnregAccessKey(true);
+
+  return NS_OK;
+}
+
+nsTextBoxFrame::nsTextBoxFrame(ComputedStyle* aStyle,
+                               nsPresContext* aPresContext)
+    : nsLeafBoxFrame(aStyle, aPresContext, kClassID),
+      mAccessKeyInfo(nullptr),
+      mCropType(CropRight),
+      mAscent(0),
+      mNeedsReflowCallback(false) {
+  MarkIntrinsicISizesDirty();
+}
+
+nsTextBoxFrame::~nsTextBoxFrame() { delete mAccessKeyInfo; }
+
+void nsTextBoxFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
+                          nsIFrame* aPrevInFlow) {
+  nsLeafBoxFrame::Init(aContent, aParent, aPrevInFlow);
+
+  bool aResize;
+  bool aRedraw;
+  UpdateAttributes(nullptr, aResize, aRedraw); /* update all */
+
+  // register access key
+  RegUnregAccessKey(true);
+}
+
+void nsTextBoxFrame::DestroyFrom(nsIFrame* aDestructRoot,
+                                 PostDestroyData& aPostDestroyData) {
+  // unregister access key
+  RegUnregAccessKey(false);
+  nsLeafBoxFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
+}
+
+bool nsTextBoxFrame::AlwaysAppendAccessKey() {
+  if (!gAccessKeyPrefInitialized) {
+    gAccessKeyPrefInitialized = true;
+
+    const char* prefName = "intl.menuitems.alwaysappendaccesskeys";
+    nsAutoString val;
+    Preferences::GetLocalizedString(prefName, val);
+    gAlwaysAppendAccessKey = val.EqualsLiteral("true");
+  }
+  return gAlwaysAppendAccessKey;
+}
+
+bool nsTextBoxFrame::InsertSeparatorBeforeAccessKey() {
+  if (!gInsertSeparatorPrefInitialized) {
+    gInsertSeparatorPrefInitialized = true;
+
+    const char* prefName = "intl.menuitems.insertseparatorbeforeaccesskeys";
+    nsAutoString val;
+    Preferences::GetLocalizedString(prefName, val);
+    gInsertSeparatorBeforeAccessKey = val.EqualsLiteral("true");
+  }
+  return gInsertSeparatorBeforeAccessKey;
+}
+
+class nsAsyncAccesskeyUpdate final : public nsIReflowCallback {
+ public:
+  explicit nsAsyncAccesskeyUpdate(nsIFrame* aFrame) : mWeakFrame(aFrame) {}
+
+  virtual bool ReflowFinished() override {
+    bool shouldFlush = false;
+    nsTextBoxFrame* frame = static_cast<nsTextBoxFrame*>(mWeakFrame.GetFrame());
+    if (frame) {
+      shouldFlush = frame->UpdateAccesskey(mWeakFrame);
+    }
+    delete this;
+    return shouldFlush;
+  }
+
+  virtual void ReflowCallbackCanceled() override { delete this; }
+
+  WeakFrame mWeakFrame;
+};
+
+bool nsTextBoxFrame::UpdateAccesskey(WeakFrame& aWeakThis) {
+  nsAutoString accesskey;
+  mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey,
+                                 accesskey);
+
+  if (!accesskey.Equals(mAccessKey)) {
+    // Need to get clean mTitle.
+    RecomputeTitle();
+    mAccessKey = accesskey;
+    UpdateAccessTitle();
+    PresShell()->FrameNeedsReflow(this, IntrinsicDirty::StyleChange,
+                                  NS_FRAME_IS_DIRTY);
+    return true;
+  }
+  return false;
+}
+
+void nsTextBoxFrame::UpdateAttributes(nsAtom* aAttribute, bool& aResize,
+                                      bool& aRedraw) {
+  bool doUpdateTitle = false;
+  aResize = false;
+  aRedraw = false;
+
+  if (aAttribute == nullptr || aAttribute == nsGkAtoms::crop) {
+    static dom::Element::AttrValuesArray strings[] = {
+        nsGkAtoms::left,  nsGkAtoms::start, nsGkAtoms::center,
+        nsGkAtoms::right, nsGkAtoms::end,   nsGkAtoms::none,
+        nullptr};
+    CroppingStyle cropType;
+    switch (mContent->AsElement()->FindAttrValueIn(
+        kNameSpaceID_None, nsGkAtoms::crop, strings, eCaseMatters)) {
+      case 0:
+      case 1:
+        cropType = CropLeft;
+        break;
+      case 2:
+        cropType = CropCenter;
+        break;
+      case 3:
+      case 4:
+        cropType = CropRight;
+        break;
+      case 5:
+        cropType = CropNone;
+        break;
+      default:
+        cropType = CropAuto;
+        break;
+    }
+
+    if (cropType != mCropType) {
+      aResize = true;
+      mCropType = cropType;
+    }
+  }
+
+  if (aAttribute == nullptr || aAttribute == nsGkAtoms::value) {
+    RecomputeTitle();
+    doUpdateTitle = true;
+  }
+
+  if (aAttribute == nullptr || aAttribute == nsGkAtoms::accesskey) {
+    mNeedsReflowCallback = true;
+    // Ensure that layout is refreshed and reflow callback called.
+    aResize = true;
+  }
+
+  if (doUpdateTitle) {
+    UpdateAccessTitle();
+    aResize = true;
+  }
+}
+
+class nsDisplayXULTextBox final : public nsPaintedDisplayItem {
+ public:
+  nsDisplayXULTextBox(nsDisplayListBuilder* aBuilder, nsTextBoxFrame* aFrame)
+      : nsPaintedDisplayItem(aBuilder, aFrame) {
+    MOZ_COUNT_CTOR(nsDisplayXULTextBox);
+  }
+#ifdef NS_BUILD_REFCNT_LOGGING
+  MOZ_COUNTED_DTOR_OVERRIDE(nsDisplayXULTextBox)
+#endif
+
+  virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
+  virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
+                           bool* aSnap) const override;
+  NS_DISPLAY_DECL_NAME("XULTextBox", TYPE_XUL_TEXT_BOX)
+
+  virtual nsRect GetComponentAlphaBounds(
+      nsDisplayListBuilder* aBuilder) const override;
+
+  void PaintTextToContext(gfxContext* aCtx, nsPoint aOffset,
+                          const nscolor* aColor);
+
+  virtual bool CreateWebRenderCommands(
+      mozilla::wr::DisplayListBuilder& aBuilder,
+      mozilla::wr::IpcResourceUpdateQueue& aResources,
+      const StackingContextHelper& aSc,
+      mozilla::layers::RenderRootStateManager* aManager,
+      nsDisplayListBuilder* aDisplayListBuilder) override;
+};
+
+static void PaintTextShadowCallback(gfxContext* aCtx, nsPoint aShadowOffset,
+                                    const nscolor& aShadowColor, void* aData) {
+  reinterpret_cast<nsDisplayXULTextBox*>(aData)->PaintTextToContext(
+      aCtx, aShadowOffset, &aShadowColor);
+}
+
+void nsDisplayXULTextBox::Paint(nsDisplayListBuilder* aBuilder,
+                                gfxContext* aCtx) {
+  DrawTargetAutoDisableSubpixelAntialiasing disable(aCtx->GetDrawTarget(),
+                                                    IsSubpixelAADisabled());
+
+  // Paint the text shadow before doing any foreground stuff
+  nsRect drawRect =
+      static_cast<nsTextBoxFrame*>(mFrame)->mTextDrawRect + ToReferenceFrame();
+  nsLayoutUtils::PaintTextShadow(mFrame, aCtx, drawRect, GetPaintRect(),
+                                 mFrame->StyleText()->mColor.ToColor(),
+                                 PaintTextShadowCallback, (void*)this);
+
+  PaintTextToContext(aCtx, nsPoint(0, 0), nullptr);
+}
+
+void nsDisplayXULTextBox::PaintTextToContext(gfxContext* aCtx, nsPoint aOffset,
+                                             const nscolor* aColor) {
+  static_cast<nsTextBoxFrame*>(mFrame)->PaintTitle(
+      *aCtx, GetPaintRect(), ToReferenceFrame() + aOffset, aColor);
+}
+
+bool nsDisplayXULTextBox::CreateWebRenderCommands(
+    mozilla::wr::DisplayListBuilder& aBuilder,
+    mozilla::wr::IpcResourceUpdateQueue& aResources,
+    const StackingContextHelper& aSc,
+    mozilla::layers::RenderRootStateManager* aManager,
+    nsDisplayListBuilder* aDisplayListBuilder) {
+  bool snap = false;
+  auto bounds = GetBounds(aDisplayListBuilder, &snap);
+
+  if (bounds.IsEmpty()) {
+    return true;
+  }
+
+  auto appUnitsPerDevPixel = Frame()->PresContext()->AppUnitsPerDevPixel();
+  gfx::Point deviceOffset =
+      LayoutDevicePoint::FromAppUnits(bounds.TopLeft(), appUnitsPerDevPixel)
+          .ToUnknownPoint();
+
+  RefPtr<mozilla::layout::TextDrawTarget> textDrawer =
+      new mozilla::layout::TextDrawTarget(aBuilder, aResources, aSc, aManager,
+                                          this, bounds);
+  RefPtr<gfxContext> captureCtx =
+      gfxContext::CreateOrNull(textDrawer, deviceOffset);
+
+  Paint(aDisplayListBuilder, captureCtx);
+  textDrawer->TerminateShadows();
+
+  return textDrawer->Finish();
+}
+
+nsRect nsDisplayXULTextBox::GetBounds(nsDisplayListBuilder* aBuilder,
+                                      bool* aSnap) const {
+  *aSnap = false;
+  return mFrame->InkOverflowRectRelativeToSelf() + ToReferenceFrame();
+}
+
+nsRect nsDisplayXULTextBox::GetComponentAlphaBounds(
+    nsDisplayListBuilder* aBuilder) const {
+  return static_cast<nsTextBoxFrame*>(mFrame)->GetComponentAlphaBounds() +
+         ToReferenceFrame();
+}
+
+void nsTextBoxFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                                      const nsDisplayListSet& aLists) {
+  if (!IsVisibleForPainting()) return;
+
+  nsLeafBoxFrame::BuildDisplayList(aBuilder, aLists);
+
+  aLists.Content()->AppendNewToTop<nsDisplayXULTextBox>(aBuilder, this);
+}
+
+void nsTextBoxFrame::PaintTitle(gfxContext& aRenderingContext,
+                                const nsRect& aDirtyRect, nsPoint aPt,
+                                const nscolor* aOverrideColor) {
+  if (mTitle.IsEmpty()) return;
+
+  DrawText(aRenderingContext, aDirtyRect, mTextDrawRect + aPt, aOverrideColor);
+}
+
+void nsTextBoxFrame::DrawText(gfxContext& aRenderingContext,
+                              const nsRect& aDirtyRect, const nsRect& aTextRect,
+                              const nscolor* aOverrideColor) {
+  nsPresContext* presContext = PresContext();
+  int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
+  DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
+
+  // paint the title
+  nscolor overColor = 0;
+  nscolor underColor = 0;
+  nscolor strikeColor = 0;
+  uint8_t overStyle = 0;
+  uint8_t underStyle = 0;
+  uint8_t strikeStyle = 0;
+
+  // Begin with no decorations
+  auto decorations = StyleTextDecorationLine::NONE;
+  // A mask of all possible line decorations.
+  auto decorMask = StyleTextDecorationLine::UNDERLINE |
+                   StyleTextDecorationLine::OVERLINE |
+                   StyleTextDecorationLine::LINE_THROUGH;
+
+  WritingMode wm = GetWritingMode();
+  bool vertical = wm.IsVertical();
+
+  nsIFrame* f = this;
+  do {  // find decoration colors
+    ComputedStyle* context = f->Style();
+    if (!context->HasTextDecorationLines()) {
+      break;
+    }
+    const nsStyleTextReset* styleText = context->StyleTextReset();
+
+    // a decoration defined here
+    if (decorMask & styleText->mTextDecorationLine) {
+      nscolor color;
+      if (aOverrideColor) {
+        color = *aOverrideColor;
+      } else {
+        color = styleText->mTextDecorationColor.CalcColor(*context);
+      }
+      uint8_t style = styleText->mTextDecorationStyle;
+
+      if (StyleTextDecorationLine::UNDERLINE & decorMask &
+          styleText->mTextDecorationLine) {
+        underColor = color;
+        underStyle = style;
+        decorMask &= ~StyleTextDecorationLine::UNDERLINE;
+        decorations |= StyleTextDecorationLine::UNDERLINE;
+      }
+      if (StyleTextDecorationLine::OVERLINE & decorMask &
+          styleText->mTextDecorationLine) {
+        overColor = color;
+        overStyle = style;
+        decorMask &= ~StyleTextDecorationLine::OVERLINE;
+        decorations |= StyleTextDecorationLine::OVERLINE;
+      }
+      if (StyleTextDecorationLine::LINE_THROUGH & decorMask &
+          styleText->mTextDecorationLine) {
+        strikeColor = color;
+        strikeStyle = style;
+        decorMask &= ~StyleTextDecorationLine::LINE_THROUGH;
+        decorations |= StyleTextDecorationLine::LINE_THROUGH;
+      }
+    }
+  } while (decorMask && (f = nsLayoutUtils::GetParentOrPlaceholderFor(f)));
+
+  RefPtr<nsFontMetrics> fontMet =
+      nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
+  fontMet->SetVertical(wm.IsVertical());
+  fontMet->SetTextOrientation(StyleVisibility()->mTextOrientation);
+
+  nscoord offset;
+  nscoord size;
+  nscoord ascent = fontMet->MaxAscent();
+
+  nsPoint baselinePt;
+  if (wm.IsVertical()) {
+    baselinePt.x = presContext->RoundAppUnitsToNearestDevPixels(
+        aTextRect.x + (wm.IsVerticalRL() ? aTextRect.width - ascent : ascent));
+    baselinePt.y = aTextRect.y;
+  } else {
+    baselinePt.x = aTextRect.x;
+    baselinePt.y =
+        presContext->RoundAppUnitsToNearestDevPixels(aTextRect.y + ascent);
+  }
+
+  nsCSSRendering::PaintDecorationLineParams params;
+  params.dirtyRect = ToRect(presContext->AppUnitsToGfxUnits(aDirtyRect));
+  params.pt = Point(presContext->AppUnitsToGfxUnits(aTextRect.x),
+                    presContext->AppUnitsToGfxUnits(aTextRect.y));
+  params.icoordInFrame =
+      Float(PresContext()->AppUnitsToGfxUnits(mTextDrawRect.x));
+  params.lineSize = Size(presContext->AppUnitsToGfxUnits(aTextRect.width), 0);
+  params.ascent = presContext->AppUnitsToGfxUnits(ascent);
+  params.vertical = vertical;
+
+  // XXX todo: vertical-mode support for decorations not tested yet,
+  // probably won't be positioned correctly
+
+  // Underlines are drawn before overlines, and both before the text
+  // itself, per http://www.w3.org/TR/CSS21/zindex.html point 7.2.1.4.1.1.
+  // (We don't apply this rule to the access-key underline because we only
+  // find out where that is as a side effect of drawing the text, in the
+  // general case -- see below.)
+  if (decorations & (StyleTextDecorationLine::OVERLINE |
+                     StyleTextDecorationLine::UNDERLINE)) {
+    fontMet->GetUnderline(offset, size);
+    params.lineSize.height = presContext->AppUnitsToGfxUnits(size);
+    if ((decorations & StyleTextDecorationLine::UNDERLINE) &&
+        underStyle != NS_STYLE_TEXT_DECORATION_STYLE_NONE) {
+      params.color = underColor;
+      params.offset = presContext->AppUnitsToGfxUnits(offset);
+      params.decoration = StyleTextDecorationLine::UNDERLINE;
+      params.style = underStyle;
+      nsCSSRendering::PaintDecorationLine(this, *drawTarget, params);
+    }
+    if ((decorations & StyleTextDecorationLine::OVERLINE) &&
+        overStyle != NS_STYLE_TEXT_DECORATION_STYLE_NONE) {
+      params.color = overColor;
+      params.offset = params.ascent;
+      params.decoration = StyleTextDecorationLine::OVERLINE;
+      params.style = overStyle;
+      nsCSSRendering::PaintDecorationLine(this, *drawTarget, params);
+    }
+  }
+
+  RefPtr<gfxContext> refContext =
+      PresShell()->CreateReferenceRenderingContext();
+  DrawTarget* refDrawTarget = refContext->GetDrawTarget();
+
+  CalculateUnderline(refDrawTarget, *fontMet);
+
+  DeviceColor color = ToDeviceColor(
+      aOverrideColor ? *aOverrideColor : StyleText()->mColor.ToColor());
+  ColorPattern colorPattern(color);
+  aRenderingContext.SetDeviceColor(color);
+
+  nsresult rv = NS_ERROR_FAILURE;
+
+  if (mState & NS_FRAME_IS_BIDI) {
+    presContext->SetBidiEnabled();
+    nsBidiLevel level = nsBidiPresUtils::BidiLevelFromStyle(Style());
+    if (mAccessKeyInfo && mAccessKeyInfo->mAccesskeyIndex != kNotFound) {
+      // We let the RenderText function calculate the mnemonic's
+      // underline position for us.
+      nsBidiPositionResolve posResolve;
+      posResolve.logicalIndex = mAccessKeyInfo->mAccesskeyIndex;
+      rv = nsBidiPresUtils::RenderText(
+          mCroppedTitle.get(), mCroppedTitle.Length(), level, presContext,
+          aRenderingContext, refDrawTarget, *fontMet, baselinePt.x,
+          baselinePt.y, &posResolve, 1);
+      mAccessKeyInfo->mBeforeWidth = posResolve.visualLeftTwips;
+      mAccessKeyInfo->mAccessWidth = posResolve.visualWidth;
+    } else {
+      rv = nsBidiPresUtils::RenderText(
+          mCroppedTitle.get(), mCroppedTitle.Length(), level, presContext,
+          aRenderingContext, refDrawTarget, *fontMet, baselinePt.x,
+          baselinePt.y);
+    }
+  }
+  if (NS_FAILED(rv)) {
+    fontMet->SetTextRunRTL(false);
+
+    if (mAccessKeyInfo && mAccessKeyInfo->mAccesskeyIndex != kNotFound) {
+      // In the simple (non-BiDi) case, we calculate the mnemonic's
+      // underline position by getting the text metric.
+      // XXX are attribute values always two byte?
+      if (mAccessKeyInfo->mAccesskeyIndex > 0)
+        mAccessKeyInfo->mBeforeWidth = nsLayoutUtils::AppUnitWidthOfString(
+            mCroppedTitle.get(), mAccessKeyInfo->mAccesskeyIndex, *fontMet,
+            refDrawTarget);
+      else
+        mAccessKeyInfo->mBeforeWidth = 0;
+    }
+
+    fontMet->DrawString(mCroppedTitle.get(), mCroppedTitle.Length(),
+                        baselinePt.x, baselinePt.y, &aRenderingContext,
+                        refDrawTarget);
+  }
+
+  if (mAccessKeyInfo && mAccessKeyInfo->mAccesskeyIndex != kNotFound) {
+    nsRect r(aTextRect.x + mAccessKeyInfo->mBeforeWidth,
+             aTextRect.y + mAccessKeyInfo->mAccessOffset,
+             mAccessKeyInfo->mAccessWidth,
+             mAccessKeyInfo->mAccessUnderlineSize);
+    Rect devPxRect = NSRectToSnappedRect(r, appUnitsPerDevPixel, *drawTarget);
+    drawTarget->FillRect(devPxRect, colorPattern);
+  }
+
+  // Strikeout is drawn on top of the text, per
+  // http://www.w3.org/TR/CSS21/zindex.html point 7.2.1.4.1.1.
+  if ((decorations & StyleTextDecorationLine::LINE_THROUGH) &&
+      strikeStyle != NS_STYLE_TEXT_DECORATION_STYLE_NONE) {
+    fontMet->GetStrikeout(offset, size);
+    params.color = strikeColor;
+    params.lineSize.height = presContext->AppUnitsToGfxUnits(size);
+    params.offset = presContext->AppUnitsToGfxUnits(offset);
+    params.decoration = StyleTextDecorationLine::LINE_THROUGH;
+    params.style = strikeStyle;
+    nsCSSRendering::PaintDecorationLine(this, *drawTarget, params);
+  }
+}
+
+void nsTextBoxFrame::CalculateUnderline(DrawTarget* aDrawTarget,
+                                        nsFontMetrics& aFontMetrics) {
+  if (mAccessKeyInfo && mAccessKeyInfo->mAccesskeyIndex != kNotFound) {
+    // Calculate all fields of mAccessKeyInfo which
+    // are the same for both BiDi and non-BiDi frames.
+    const char16_t* titleString = mCroppedTitle.get();
+    aFontMetrics.SetTextRunRTL(false);
+    mAccessKeyInfo->mAccessWidth = nsLayoutUtils::AppUnitWidthOfString(
+        titleString[mAccessKeyInfo->mAccesskeyIndex], aFontMetrics,
+        aDrawTarget);
+
+    nscoord offset, baseline;
+    aFontMetrics.GetUnderline(offset, mAccessKeyInfo->mAccessUnderlineSize);
+    baseline = aFontMetrics.MaxAscent();
+    mAccessKeyInfo->mAccessOffset = baseline - offset;
+  }
+}
+
+nscoord nsTextBoxFrame::CalculateTitleForWidth(gfxContext& aRenderingContext,
+                                               nscoord aWidth) {
+  DrawTarget* drawTarget = aRenderingContext.GetDrawTarget();
+
+  if (mTitle.IsEmpty()) {
+    mCroppedTitle.Truncate();
+    return 0;
+  }
+
+  RefPtr<nsFontMetrics> fm = nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
+
+  // see if the text will completely fit in the width given
+  nscoord titleWidth = nsLayoutUtils::AppUnitWidthOfStringBidi(
+      mTitle, this, *fm, aRenderingContext);
+  if (titleWidth <= aWidth) {
+    mCroppedTitle = mTitle;
+    if (HasRTLChars(mTitle) ||
+        StyleVisibility()->mDirection == StyleDirection::Rtl) {
+      AddStateBits(NS_FRAME_IS_BIDI);
+    }
+    return titleWidth;  // fits, done.
+  }
+
+  const nsDependentString& kEllipsis = nsContentUtils::GetLocalizedEllipsis();
+  if (mCropType != CropNone) {
+    // start with an ellipsis
+    mCroppedTitle.Assign(kEllipsis);
+
+    // see if the width is even smaller than the ellipsis
+    // if so, clear the text (XXX set as many '.' as we can?).
+    fm->SetTextRunRTL(false);
+    titleWidth =
+        nsLayoutUtils::AppUnitWidthOfString(kEllipsis, *fm, drawTarget);
+
+    if (titleWidth > aWidth) {
+      mCroppedTitle.SetLength(0);
+      return 0;
+    }
+
+    // if the ellipsis fits perfectly, no use in trying to insert
+    if (titleWidth == aWidth) return titleWidth;
+
+    aWidth -= titleWidth;
+  } else {
+    mCroppedTitle.Truncate(0);
+    titleWidth = 0;
+  }
+
+  using mozilla::unicode::ClusterIterator;
+  using mozilla::unicode::ClusterReverseIterator;
+
+  // ok crop things
+  switch (mCropType) {
+    case CropAuto:
+    case CropNone:
+    case CropRight: {
+      ClusterIterator iter(mTitle.Data(), mTitle.Length());
+      const char16_t* dataBegin = iter;
+      const char16_t* pos = dataBegin;
+      nscoord charWidth;
+      nscoord totalWidth = 0;
+
+      while (!iter.AtEnd()) {
+        iter.Next();
+        const char16_t* nextPos = iter;
+        ptrdiff_t length = nextPos - pos;
+        charWidth =
+            nsLayoutUtils::AppUnitWidthOfString(pos, length, *fm, drawTarget);
+        if (totalWidth + charWidth > aWidth) {
+          break;
+        }
+
+        if (UTF16_CODE_UNIT_IS_BIDI(*pos)) {
+          AddStateBits(NS_FRAME_IS_BIDI);
+        }
+        pos = nextPos;
+        totalWidth += charWidth;
+      }
+
+      if (pos == dataBegin) {
+        return titleWidth;
+      }
+
+      // insert what character we can in.
+      nsAutoString title(mTitle);
+      title.Truncate(pos - dataBegin);
+      mCroppedTitle.Insert(title, 0);
+    } break;
+
+    case CropLeft: {
+      ClusterReverseIterator iter(mTitle.Data(), mTitle.Length());
+      const char16_t* dataEnd = iter;
+      const char16_t* prevPos = dataEnd;
+      nscoord charWidth;
+      nscoord totalWidth = 0;
+
+      while (!iter.AtEnd()) {
+        iter.Next();
+        const char16_t* pos = iter;
+        ptrdiff_t length = prevPos - pos;
+        charWidth =
+            nsLayoutUtils::AppUnitWidthOfString(pos, length, *fm, drawTarget);
+        if (totalWidth + charWidth > aWidth) {
+          break;
+        }
+
+        if (UTF16_CODE_UNIT_IS_BIDI(*pos)) {
+          AddStateBits(NS_FRAME_IS_BIDI);
+        }
+        prevPos = pos;
+        totalWidth += charWidth;
+      }
+
+      if (prevPos == dataEnd) {
+        return titleWidth;
+      }
+
+      nsAutoString copy;
+      mTitle.Right(copy, dataEnd - prevPos);
+      mCroppedTitle += copy;
+    } break;
+
+    case CropCenter: {
+      nscoord stringWidth = nsLayoutUtils::AppUnitWidthOfStringBidi(
+          mTitle, this, *fm, aRenderingContext);
+      if (stringWidth <= aWidth) {
+        // the entire string will fit in the maximum width
+        mCroppedTitle.Insert(mTitle, 0);
+        break;
+      }
+
+      // determine how much of the string will fit in the max width
+      nscoord charWidth = 0;
+      nscoord totalWidth = 0;
+      ClusterIterator leftIter(mTitle.Data(), mTitle.Length());
+      ClusterReverseIterator rightIter(mTitle.Data(), mTitle.Length());
+      const char16_t* dataBegin = leftIter;
+      const char16_t* dataEnd = rightIter;
+      const char16_t* leftPos = dataBegin;
+      const char16_t* rightPos = dataEnd;
+      const char16_t* pos;
+      ptrdiff_t length;
+      nsAutoString leftString, rightString;
+
+      while (leftPos < rightPos) {
+        leftIter.Next();
+        pos = leftIter;
+        length = pos - leftPos;
+        charWidth = nsLayoutUtils::AppUnitWidthOfString(leftPos, length, *fm,
+                                                        drawTarget);
+        if (totalWidth + charWidth > aWidth) {
+          break;
+        }
+
+        if (UTF16_CODE_UNIT_IS_BIDI(*leftPos)) {
+          AddStateBits(NS_FRAME_IS_BIDI);
+        }
+
+        leftString.Append(leftPos, length);
+        leftPos = pos;
+        totalWidth += charWidth;
+
+        if (leftPos >= rightPos) {
+          break;
+        }
+
+        rightIter.Next();
+        pos = rightIter;
+        length = rightPos - pos;
+        charWidth =
+            nsLayoutUtils::AppUnitWidthOfString(pos, length, *fm, drawTarget);
+        if (totalWidth + charWidth > aWidth) {
+          break;
+        }
+
+        if (UTF16_CODE_UNIT_IS_BIDI(*pos)) {
+          AddStateBits(NS_FRAME_IS_BIDI);
+        }
+
+        rightString.Insert(pos, 0, length);
+        rightPos = pos;
+        totalWidth += charWidth;
+      }
+
+      mCroppedTitle = leftString + kEllipsis + rightString;
+    } break;
+  }
+
+  return nsLayoutUtils::AppUnitWidthOfStringBidi(mCroppedTitle, this, *fm,
+                                                 aRenderingContext);
+}
+
+#define OLD_ELLIPSIS u"..."_ns
+
+// the following block is to append the accesskey to mTitle if there is an
+// accesskey but the mTitle doesn't have the character
+void nsTextBoxFrame::UpdateAccessTitle() {
+  /*
+   * Note that if you change appending access key label spec,
+   * you need to maintain same logic in following methods. See bug 324159.
+   * toolkit/components/prompts/src/CommonDialog.jsm (setLabelForNode)
+   * toolkit/content/widgets/text.js (formatAccessKey)
+   */
+  int32_t menuAccessKey;
+  nsMenuBarListener::GetMenuAccessKey(&menuAccessKey);
+  if (!menuAccessKey || mAccessKey.IsEmpty()) return;
+
+  if (!AlwaysAppendAccessKey() &&
+      FindInReadable(mAccessKey, mTitle, nsCaseInsensitiveStringComparator))
+    return;
+
+  nsAutoString accessKeyLabel;
+  accessKeyLabel += '(';
+  accessKeyLabel += mAccessKey;
+  ToUpperCase(accessKeyLabel);
+  accessKeyLabel += ')';
+
+  if (mTitle.IsEmpty()) {
+    mTitle = accessKeyLabel;
+    return;
+  }
+
+  if (StringEndsWith(mTitle, accessKeyLabel)) {
+    // Never append another "(X)" if the title already ends with "(X)".
+    return;
+  }
+
+  const nsDependentString& kEllipsis = nsContentUtils::GetLocalizedEllipsis();
+  uint32_t offset = mTitle.Length();
+  if (StringEndsWith(mTitle, kEllipsis)) {
+    offset -= kEllipsis.Length();
+  } else if (StringEndsWith(mTitle, OLD_ELLIPSIS)) {
+    // Try to check with our old ellipsis (for old addons)
+    offset -= OLD_ELLIPSIS.Length();
+  } else {
+    // Try to check with
+    // our default ellipsis (for non-localized addons) or ':'
+    const char16_t kLastChar = mTitle.Last();
+    if (kLastChar == char16_t(0x2026) || kLastChar == char16_t(':')) offset--;
+  }
+
+  if (InsertSeparatorBeforeAccessKey() && offset > 0 &&
+      !NS_IS_SPACE(mTitle[offset - 1])) {
+    mTitle.Insert(' ', offset);
+    offset++;
+  }
+
+  mTitle.Insert(accessKeyLabel, offset);
+}
+
+void nsTextBoxFrame::UpdateAccessIndex() {
+  int32_t menuAccessKey;
+  nsMenuBarListener::GetMenuAccessKey(&menuAccessKey);
+  if (menuAccessKey) {
+    if (mAccessKey.IsEmpty()) {
+      if (mAccessKeyInfo) {
+        delete mAccessKeyInfo;
+        mAccessKeyInfo = nullptr;
+      }
+    } else {
+      if (!mAccessKeyInfo) {
+        mAccessKeyInfo = new nsAccessKeyInfo();
+        if (!mAccessKeyInfo) return;
+      }
+
+      nsAString::const_iterator start, end;
+
+      mCroppedTitle.BeginReading(start);
+      mCroppedTitle.EndReading(end);
+
+      // remember the beginning of the string
+      nsAString::const_iterator originalStart = start;
+
+      bool found;
+      if (!AlwaysAppendAccessKey()) {
+        // not appending access key - do case-sensitive search
+        // first
+        found = FindInReadable(mAccessKey, start, end);
+        if (!found) {
+          // didn't find it - perform a case-insensitive search
+          start = originalStart;
+          found = FindInReadable(mAccessKey, start, end,
+                                 nsCaseInsensitiveStringComparator);
+        }
+      } else {
+        found = RFindInReadable(mAccessKey, start, end,
+                                nsCaseInsensitiveStringComparator);
+      }
+
+      if (found)
+        mAccessKeyInfo->mAccesskeyIndex = Distance(originalStart, start);
+      else
+        mAccessKeyInfo->mAccesskeyIndex = kNotFound;
+    }
+  }
+}
+
+void nsTextBoxFrame::RecomputeTitle() {
+  mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value, mTitle);
+
+  // This doesn't handle language-specific uppercasing/lowercasing
+  // rules, unlike textruns.
+  StyleTextTransform textTransform = StyleText()->mTextTransform;
+  if (textTransform.case_ == StyleTextTransformCase::Uppercase) {
+    ToUpperCase(mTitle);
+  } else if (textTransform.case_ == StyleTextTransformCase::Lowercase) {
+    ToLowerCase(mTitle);
+  }
+  // We can't handle StyleTextTransformCase::Capitalize because we
+  // have no clue about word boundaries here.  We also don't handle
+  // the full-width or full-size-kana transforms.
+}
+
+void nsTextBoxFrame::DidSetComputedStyle(ComputedStyle* aOldComputedStyle) {
+  nsLeafBoxFrame::DidSetComputedStyle(aOldComputedStyle);
+
+  if (!aOldComputedStyle) {
+    // We're just being initialized
+    return;
+  }
+
+  const nsStyleText* oldTextStyle = aOldComputedStyle->StyleText();
+  if (oldTextStyle->mTextTransform != StyleText()->mTextTransform) {
+    RecomputeTitle();
+    UpdateAccessTitle();
+  }
+}
+
+NS_IMETHODIMP
+nsTextBoxFrame::DoXULLayout(nsBoxLayoutState& aBoxLayoutState) {
+  if (mNeedsReflowCallback) {
+    nsIReflowCallback* cb = new nsAsyncAccesskeyUpdate(this);
+    if (cb) {
+      PresShell()->PostReflowCallback(cb);
+    }
+    mNeedsReflowCallback = false;
+  }
+
+  nsresult rv = nsLeafBoxFrame::DoXULLayout(aBoxLayoutState);
+
+  CalcDrawRect(*aBoxLayoutState.GetRenderingContext());
+
+  const nsStyleText* textStyle = StyleText();
+
+  nsRect scrollBounds(nsPoint(0, 0), GetSize());
+  nsRect textRect = mTextDrawRect;
+
+  RefPtr<nsFontMetrics> fontMet =
+      nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
+  nsBoundingMetrics metrics = fontMet->GetInkBoundsForInkOverflow(
+      mCroppedTitle.get(), mCroppedTitle.Length(),
+      aBoxLayoutState.GetRenderingContext()->GetDrawTarget());
+
+  WritingMode wm = GetWritingMode();
+  LogicalRect tr(wm, textRect, GetSize());
+
+  tr.IStart(wm) -= metrics.leftBearing;
+  tr.ISize(wm) = metrics.width;
+  // In DrawText() we always draw with the baseline at MaxAscent() (relative to
+  // mTextDrawRect),
+  tr.BStart(wm) += fontMet->MaxAscent() - metrics.ascent;
+  tr.BSize(wm) = metrics.ascent + metrics.descent;
+
+  textRect = tr.GetPhysicalRect(wm, GetSize());
+
+  // Our scrollable overflow is our bounds; our ink overflow may
+  // extend beyond that.
+  nsRect visualBounds;
+  visualBounds.UnionRect(scrollBounds, textRect);
+  OverflowAreas overflow(visualBounds, scrollBounds);
+
+  if (textStyle->HasTextShadow()) {
+    // text-shadow extends our visual but not scrollable bounds
+    nsRect& vis = overflow.InkOverflow();
+    vis.UnionRect(vis,
+                  nsLayoutUtils::GetTextShadowRectsUnion(mTextDrawRect, this));
+  }
+  FinishAndStoreOverflow(overflow, GetSize());
+
+  return rv;
+}
+
+nsRect nsTextBoxFrame::GetComponentAlphaBounds() const {
+  if (StyleText()->HasTextShadow()) {
+    return InkOverflowRectRelativeToSelf();
+  }
+  return mTextDrawRect;
+}
+
+bool nsTextBoxFrame::XULComputesOwnOverflowArea() { return true; }
+
+/* virtual */
+void nsTextBoxFrame::MarkIntrinsicISizesDirty() {
+  mNeedsRecalc = true;
+  nsLeafBoxFrame::MarkIntrinsicISizesDirty();
+}
+
+void nsTextBoxFrame::GetTextSize(gfxContext& aRenderingContext,
+                                 const nsString& aString, nsSize& aSize,
+                                 nscoord& aAscent) {
+  RefPtr<nsFontMetrics> fontMet =
+      nsLayoutUtils::GetFontMetricsForFrame(this, 1.0f);
+  aSize.height = fontMet->MaxHeight();
+  aSize.width = nsLayoutUtils::AppUnitWidthOfStringBidi(aString, this, *fontMet,
+                                                        aRenderingContext);
+  aAscent = fontMet->MaxAscent();
+}
+
+void nsTextBoxFrame::CalcTextSize(nsBoxLayoutState& aBoxLayoutState) {
+  if (mNeedsRecalc) {
+    nsSize size;
+    gfxContext* rendContext = aBoxLayoutState.GetRenderingContext();
+    if (rendContext) {
+      GetTextSize(*rendContext, mTitle, size, mAscent);
+      if (GetWritingMode().IsVertical()) {
+        std::swap(size.width, size.height);
+      }
+      mTextSize = size;
+      mNeedsRecalc = false;
+    }
+  }
+}
+
+void nsTextBoxFrame::CalcDrawRect(gfxContext& aRenderingContext) {
+  WritingMode wm = GetWritingMode();
+
+  LogicalRect textRect(wm, LogicalPoint(wm, 0, 0), GetLogicalSize(wm));
+  nsMargin borderPadding;
+  GetXULBorderAndPadding(borderPadding);
+  textRect.Deflate(wm, LogicalMargin(wm, borderPadding));
+
+  // determine (cropped) title and underline position
+  // determine (cropped) title which fits in aRect, and its width
+  // (where "width" is the text measure along its baseline, i.e. actually
+  // a physical height in vertical writing modes)
+  nscoord titleWidth =
+      CalculateTitleForWidth(aRenderingContext, textRect.ISize(wm));
+
+#ifdef ACCESSIBILITY
+  // Make sure to update the accessible tree in case when cropped title is
+  // changed.
+  nsAccessibilityService* accService = GetAccService();
+  if (accService) {
+    accService->UpdateLabelValue(PresShell(), mContent, mCroppedTitle);
+  }
+#endif
+
+  // determine if and at which position to put the underline
+  UpdateAccessIndex();
+
+  // make the rect as small as our (cropped) text.
+  nscoord outerISize = textRect.ISize(wm);
+  textRect.ISize(wm) = titleWidth;
+
+  // Align our text within the overall rect by checking our text-align property.
+  const nsStyleText* textStyle = StyleText();
+  if (textStyle->mTextAlign == StyleTextAlign::Center) {
+    textRect.IStart(wm) += (outerISize - textRect.ISize(wm)) / 2;
+  } else if (textStyle->mTextAlign == StyleTextAlign::End ||
+             (textStyle->mTextAlign == StyleTextAlign::Left &&
+              wm.IsBidiRTL()) ||
+             (textStyle->mTextAlign == StyleTextAlign::Right &&
+              wm.IsBidiLTR())) {
+    textRect.IStart(wm) += (outerISize - textRect.ISize(wm));
+  }
+
+  mTextDrawRect = textRect.GetPhysicalRect(wm, GetSize());
+}
+
+/**
+ * Ok return our dimensions
+ */
+nsSize nsTextBoxFrame::GetXULPrefSize(nsBoxLayoutState& aBoxLayoutState) {
+  CalcTextSize(aBoxLayoutState);
+
+  nsSize size = mTextSize;
+  DISPLAY_PREF_SIZE(this, size);
+
+  AddXULBorderAndPadding(size);
+  bool widthSet, heightSet;
+  nsIFrame::AddXULPrefSize(this, size, widthSet, heightSet);
+
+  return size;
+}
+
+/**
+ * Ok return our dimensions
+ */
+nsSize nsTextBoxFrame::GetXULMinSize(nsBoxLayoutState& aBoxLayoutState) {
+  CalcTextSize(aBoxLayoutState);
+
+  nsSize size = mTextSize;
+  DISPLAY_MIN_SIZE(this, size);
+
+  // if there is cropping our min width becomes our border and padding
+  if (mCropType != CropNone && mCropType != CropAuto) {
+    if (GetWritingMode().IsVertical()) {
+      size.height = 0;
+    } else {
+      size.width = 0;
+    }
+  }
+
+  AddXULBorderAndPadding(size);
+  bool widthSet, heightSet;
+  nsIFrame::AddXULMinSize(this, size, widthSet, heightSet);
+
+  return size;
+}
+
+nscoord nsTextBoxFrame::GetXULBoxAscent(nsBoxLayoutState& aBoxLayoutState) {
+  CalcTextSize(aBoxLayoutState);
+
+  nscoord ascent = mAscent;
+
+  nsMargin m(0, 0, 0, 0);
+  GetXULBorderAndPadding(m);
+
+  WritingMode wm = GetWritingMode();
+  ascent += LogicalMargin(wm, m).BStart(wm);
+
+  return ascent;
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult nsTextBoxFrame::GetFrameName(nsAString& aResult) const {
+  MakeFrameName(u"TextBox"_ns, aResult);
+  aResult += u"[value="_ns + mTitle + u"]"_ns;
+  return NS_OK;
+}
+#endif
+
+// If you make changes to this function, check its counterparts
+// in nsBoxFrame and nsXULLabelFrame
+nsresult nsTextBoxFrame::RegUnregAccessKey(bool aDoReg) {
+  // if we have no content, we can't do anything
+  if (!mContent) return NS_ERROR_FAILURE;
+
+  // check if we have a |control| attribute
+  // do this check first because few elements have control attributes, and we
+  // can weed out most of the elements quickly.
+
+  // XXXjag a side-effect is that we filter out anonymous <label>s
+  // in e.g. <menu>, <menuitem>, <button>. These <label>s inherit
+  // |accesskey| and would otherwise register themselves, overwriting
+  // the content we really meant to be registered.
+  if (!mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::control))
+    return NS_OK;
+
+  // see if we even have an access key
+  nsAutoString accessKey;
+  mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey,
+                                 accessKey);
+
+  if (accessKey.IsEmpty()) return NS_OK;
+
+  // With a valid PresContext we can get the ESM
+  // and (un)register the access key
+  EventStateManager* esm = PresContext()->EventStateManager();
+
+  uint32_t key = accessKey.First();
+  if (aDoReg)
+    esm->RegisterAccessKey(mContent->AsElement(), key);
+  else
+    esm->UnregisterAccessKey(mContent->AsElement(), key);
+
+  return NS_OK;
+}