Add m-esr52 at 52.6.0

1 files changed, 1241 insertions, 0 deletions

diff --git a/layout/xul/nsTextBoxFrame.cpp b/layout/xul/nsTextBoxFrame.cpp
new file mode 100644
index 000000000..c82d3d6b9
--- /dev/null
+++ b/layout/xul/nsTextBoxFrame.cpp
@@ -0,0 +1,1241 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=4 sw=4 sts=4 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/gfx/2D.h"
+#include "nsFontMetrics.h"
+#include "nsReadableUtils.h"
+#include "nsCOMPtr.h"
+#include "nsGkAtoms.h"
+#include "nsPresContext.h"
+#include "nsRenderingContext.h"
+#include "nsStyleContext.h"
+#include "nsIContent.h"
+#include "nsNameSpaceManager.h"
+#include "nsBoxLayoutState.h"
+#include "nsMenuBarListener.h"
+#include "nsXPIDLString.h"
+#include "nsIServiceManager.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMXULLabelElement.h"
+#include "mozilla/EventStateManager.h"
+#include "nsITheme.h"
+#include "nsUnicharUtils.h"
+#include "nsContentUtils.h"
+#include "nsDisplayList.h"
+#include "nsCSSRendering.h"
+#include "nsIReflowCallback.h"
+#include "nsBoxFrame.h"
+#include "mozilla/Preferences.h"
+#include "nsLayoutUtils.h"
+#include "mozilla/Attributes.h"
+#include "nsUnicodeProperties.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 (nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+    return new (aPresShell) nsTextBoxFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsTextBoxFrame)
+
+NS_QUERYFRAME_HEAD(nsTextBoxFrame)
+  NS_QUERYFRAME_ENTRY(nsTextBoxFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsLeafBoxFrame)
+
+nsresult
+nsTextBoxFrame::AttributeChanged(int32_t         aNameSpaceID,
+                                 nsIAtom*        aAttribute,
+                                 int32_t         aModType)
+{
+    bool aResize;
+    bool aRedraw;
+
+    UpdateAttributes(aAttribute, aResize, aRedraw);
+
+    if (aResize) {
+        PresContext()->PresShell()->
+            FrameNeedsReflow(this, nsIPresShell::eStyleChange,
+                             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(nsStyleContext* aContext):
+  nsLeafBoxFrame(aContext), mAccessKeyInfo(nullptr), mCropType(CropRight),
+  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)
+{
+    // unregister access key
+    RegUnregAccessKey(false);
+    nsLeafBoxFrame::DestroyFrom(aDestructRoot);
+}
+
+bool
+nsTextBoxFrame::AlwaysAppendAccessKey()
+{
+  if (!gAccessKeyPrefInitialized) 
+  {
+    gAccessKeyPrefInitialized = true;
+
+    const char* prefName = "intl.menuitems.alwaysappendaccesskeys";
+    nsAdoptingString val = Preferences::GetLocalizedString(prefName);
+    gAlwaysAppendAccessKey = val.EqualsLiteral("true");
+  }
+  return gAlwaysAppendAccessKey;
+}
+
+bool
+nsTextBoxFrame::InsertSeparatorBeforeAccessKey()
+{
+  if (!gInsertSeparatorPrefInitialized)
+  {
+    gInsertSeparatorPrefInitialized = true;
+
+    const char* prefName = "intl.menuitems.insertseparatorbeforeaccesskeys";
+    nsAdoptingString val = Preferences::GetLocalizedString(prefName);
+    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;
+    }
+
+    nsWeakFrame mWeakFrame;
+};
+
+bool
+nsTextBoxFrame::UpdateAccesskey(nsWeakFrame& aWeakThis)
+{
+    nsAutoString accesskey;
+    nsCOMPtr<nsIDOMXULLabelElement> labelElement = do_QueryInterface(mContent);
+    NS_ENSURE_TRUE(aWeakThis.IsAlive(), false);
+    if (labelElement) {
+        // Accesskey may be stored on control.
+        labelElement->GetAccessKey(accesskey);
+        NS_ENSURE_TRUE(aWeakThis.IsAlive(), false);
+    }
+    else {
+        mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accesskey);
+    }
+
+    if (!accesskey.Equals(mAccessKey)) {
+        // Need to get clean mTitle.
+        RecomputeTitle();
+        mAccessKey = accesskey;
+        UpdateAccessTitle();
+        PresContext()->PresShell()->
+            FrameNeedsReflow(this, nsIPresShell::eStyleChange,
+                             NS_FRAME_IS_DIRTY);
+        return true;
+    }
+    return false;
+}
+
+void
+nsTextBoxFrame::UpdateAttributes(nsIAtom*         aAttribute,
+                                 bool&          aResize,
+                                 bool&          aRedraw)
+{
+    bool doUpdateTitle = false;
+    aResize = false;
+    aRedraw = false;
+
+    if (aAttribute == nullptr || aAttribute == nsGkAtoms::crop) {
+        static nsIContent::AttrValuesArray strings[] =
+          {&nsGkAtoms::left, &nsGkAtoms::start, &nsGkAtoms::center,
+           &nsGkAtoms::right, &nsGkAtoms::end, &nsGkAtoms::none, nullptr};
+        CroppingStyle cropType;
+        switch (mContent->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 : public nsDisplayItem {
+public:
+  nsDisplayXULTextBox(nsDisplayListBuilder* aBuilder,
+                      nsTextBoxFrame* aFrame) :
+    nsDisplayItem(aBuilder, aFrame),
+    mDisableSubpixelAA(false)
+  {
+    MOZ_COUNT_CTOR(nsDisplayXULTextBox);
+  }
+#ifdef NS_BUILD_REFCNT_LOGGING
+  virtual ~nsDisplayXULTextBox() {
+    MOZ_COUNT_DTOR(nsDisplayXULTextBox);
+  }
+#endif
+
+  virtual void Paint(nsDisplayListBuilder* aBuilder,
+                     nsRenderingContext* aCtx) override;
+  virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
+                           bool* aSnap) override;
+  NS_DISPLAY_DECL_NAME("XULTextBox", TYPE_XUL_TEXT_BOX)
+
+  virtual nsRect GetComponentAlphaBounds(nsDisplayListBuilder* aBuilder) override;
+
+  virtual void DisableComponentAlpha() override {
+    mDisableSubpixelAA = true;
+  }
+
+  void PaintTextToContext(nsRenderingContext* aCtx,
+                          nsPoint aOffset,
+                          const nscolor* aColor);
+
+  bool mDisableSubpixelAA;
+};
+
+static void
+PaintTextShadowCallback(nsRenderingContext* aCtx,
+                        nsPoint aShadowOffset,
+                        const nscolor& aShadowColor,
+                        void* aData)
+{
+  reinterpret_cast<nsDisplayXULTextBox*>(aData)->
+           PaintTextToContext(aCtx, aShadowOffset, &aShadowColor);
+}
+
+void
+nsDisplayXULTextBox::Paint(nsDisplayListBuilder* aBuilder,
+                           nsRenderingContext* aCtx)
+{
+  DrawTargetAutoDisableSubpixelAntialiasing disable(aCtx->GetDrawTarget(),
+                                                    mDisableSubpixelAA);
+
+  // Paint the text shadow before doing any foreground stuff
+  nsRect drawRect = static_cast<nsTextBoxFrame*>(mFrame)->mTextDrawRect +
+                    ToReferenceFrame();
+  nsLayoutUtils::PaintTextShadow(mFrame, aCtx,
+                                 drawRect, mVisibleRect,
+                                 mFrame->StyleColor()->mColor,
+                                 PaintTextShadowCallback,
+                                 (void*)this);
+
+  PaintTextToContext(aCtx, nsPoint(0, 0), nullptr);
+}
+
+void
+nsDisplayXULTextBox::PaintTextToContext(nsRenderingContext* aCtx,
+                                        nsPoint aOffset,
+                                        const nscolor* aColor)
+{
+  static_cast<nsTextBoxFrame*>(mFrame)->
+    PaintTitle(*aCtx, mVisibleRect, ToReferenceFrame() + aOffset, aColor);
+}
+
+nsRect
+nsDisplayXULTextBox::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) {
+  *aSnap = false;
+  return mFrame->GetVisualOverflowRectRelativeToSelf() + ToReferenceFrame();
+}
+
+nsRect
+nsDisplayXULTextBox::GetComponentAlphaBounds(nsDisplayListBuilder* aBuilder)
+{
+  return static_cast<nsTextBoxFrame*>(mFrame)->GetComponentAlphaBounds() +
+      ToReferenceFrame();
+}
+
+void
+nsTextBoxFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,
+                                 const nsRect&           aDirtyRect,
+                                 const nsDisplayListSet& aLists)
+{
+    if (!IsVisibleForPainting(aBuilder))
+        return;
+
+    nsLeafBoxFrame::BuildDisplayList(aBuilder, aDirtyRect, aLists);
+    
+    aLists.Content()->AppendNewToTop(new (aBuilder)
+        nsDisplayXULTextBox(aBuilder, this));
+}
+
+void
+nsTextBoxFrame::PaintTitle(nsRenderingContext& aRenderingContext,
+                           const nsRect&        aDirtyRect,
+                           nsPoint              aPt,
+                           const nscolor*       aOverrideColor)
+{
+    if (mTitle.IsEmpty())
+        return;
+
+    DrawText(aRenderingContext, aDirtyRect, mTextDrawRect + aPt, aOverrideColor);
+}
+
+void
+nsTextBoxFrame::DrawText(nsRenderingContext& 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
+    uint8_t decorations = NS_STYLE_TEXT_DECORATION_LINE_NONE;
+    // A mask of all possible decorations.
+    uint8_t decorMask = NS_STYLE_TEXT_DECORATION_LINE_LINES_MASK;
+
+    WritingMode wm = GetWritingMode();
+    bool vertical = wm.IsVertical();
+
+    nsIFrame* f = this;
+    do {  // find decoration colors
+      nsStyleContext* context = f->StyleContext();
+      if (!context->HasTextDecorationLines()) {
+        break;
+      }
+      const nsStyleTextReset* styleText = context->StyleTextReset();
+
+      if (decorMask & styleText->mTextDecorationLine) {  // a decoration defined here
+        nscolor color;
+        if (aOverrideColor) {
+          color = *aOverrideColor;
+        } else {
+          color = context->StyleColor()->
+            CalcComplexColor(styleText->mTextDecorationColor);
+        }
+        uint8_t style = styleText->mTextDecorationStyle;
+
+        if (NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE & decorMask &
+              styleText->mTextDecorationLine) {
+          underColor = color;
+          underStyle = style;
+          decorMask &= ~NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE;
+          decorations |= NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE;
+        }
+        if (NS_STYLE_TEXT_DECORATION_LINE_OVERLINE & decorMask &
+              styleText->mTextDecorationLine) {
+          overColor = color;
+          overStyle = style;
+          decorMask &= ~NS_STYLE_TEXT_DECORATION_LINE_OVERLINE;
+          decorations |= NS_STYLE_TEXT_DECORATION_LINE_OVERLINE;
+        }
+        if (NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH & decorMask &
+              styleText->mTextDecorationLine) {
+          strikeColor = color;
+          strikeStyle = style;
+          decorMask &= ~NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH;
+          decorations |= NS_STYLE_TEXT_DECORATION_LINE_LINE_THROUGH;
+        }
+      }
+    } while (0 != 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 & (NS_STYLE_TEXT_DECORATION_LINE_OVERLINE |
+                       NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE)) {
+      fontMet->GetUnderline(offset, size);
+      params.lineSize.height = presContext->AppUnitsToGfxUnits(size);
+      if ((decorations & NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE) &&
+          underStyle != NS_STYLE_TEXT_DECORATION_STYLE_NONE) {
+        params.color = underColor;
+        params.offset = presContext->AppUnitsToGfxUnits(offset);
+        params.decoration = NS_STYLE_TEXT_DECORATION_LINE_UNDERLINE;
+        params.style = underStyle;
+        nsCSSRendering::PaintDecorationLine(this, *drawTarget, params);
+      }
+      if ((decorations & NS_STYLE_TEXT_DECORATION_LINE_OVERLINE) &&
+          overStyle != NS_STYLE_TEXT_DECORATION_STYLE_NONE) {
+        params.color = overColor;
+        params.offset = params.ascent;
+        params.decoration = NS_STYLE_TEXT_DECORATION_LINE_OVERLINE;
+        params.style = overStyle;
+        nsCSSRendering::PaintDecorationLine(this, *drawTarget, params);
+      }
+    }
+
+    nsRenderingContext refContext(
+        PresContext()->PresShell()->CreateReferenceRenderingContext());
+    DrawTarget* refDrawTarget = refContext.GetDrawTarget();
+
+    CalculateUnderline(refDrawTarget, *fontMet);
+
+    nscolor c = aOverrideColor ? *aOverrideColor : StyleColor()->mColor;
+    ColorPattern color(ToDeviceColor(c));
+    aRenderingContext.ThebesContext()->SetColor(Color::FromABGR(c));
+
+    nsresult rv = NS_ERROR_FAILURE;
+
+    if (mState & NS_FRAME_IS_BIDI) {
+      presContext->SetBidiEnabled();
+      nsBidiLevel level = nsBidiPresUtils::BidiLevelFromStyle(StyleContext());
+      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, color);
+    }
+
+    // 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 & NS_STYLE_TEXT_DECORATION_LINE_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 = NS_STYLE_TEXT_DECORATION_LINE_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(nsRenderingContext& 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 == NS_STYLE_DIRECTION_RTL) {
+            mState |= 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 (UCS2_CHAR_IS_BIDI(*pos)) {
+                    mState |= 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 (UCS2_CHAR_IS_BIDI(*pos)) {
+                    mState |= 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 (UCS2_CHAR_IS_BIDI(*leftPos)) {
+                    mState |= 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 (UCS2_CHAR_IS_BIDI(*pos)) {
+                    mState |= 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 NS_LITERAL_STRING("...")
+
+// 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/content/commonDialog.js (setLabelForNode)
+     * toolkit/content/widgets/text.xml (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;
+    }
+
+    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->GetAttr(kNameSpaceID_None, nsGkAtoms::value, mTitle);
+
+  // This doesn't handle language-specific uppercasing/lowercasing
+  // rules, unlike textruns.
+  uint8_t textTransform = StyleText()->mTextTransform;
+  if (textTransform == NS_STYLE_TEXT_TRANSFORM_UPPERCASE) {
+    ToUpperCase(mTitle);
+  } else if (textTransform == NS_STYLE_TEXT_TRANSFORM_LOWERCASE) {
+    ToLowerCase(mTitle);
+  }
+  // We can't handle NS_STYLE_TEXT_TRANSFORM_CAPITALIZE because we
+  // have no clue about word boundaries here.  We also don't handle
+  // NS_STYLE_TEXT_TRANSFORM_FULL_WIDTH.
+}
+
+void
+nsTextBoxFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)
+{
+  if (!aOldStyleContext) {
+    // We're just being initialized
+    return;
+  }
+
+  const nsStyleText* oldTextStyle = aOldStyleContext->PeekStyleText();
+  // We should really have oldTextStyle here, since we asked for our
+  // nsStyleText during Init(), but if it's not there for some reason
+  // just assume the worst and recompute mTitle.
+  if (!oldTextStyle ||
+      oldTextStyle->mTextTransform != StyleText()->mTextTransform) {
+    RecomputeTitle();
+    UpdateAccessTitle();
+  }
+}
+
+NS_IMETHODIMP
+nsTextBoxFrame::DoXULLayout(nsBoxLayoutState& aBoxLayoutState)
+{
+    if (mNeedsReflowCallback) {
+        nsIReflowCallback* cb = new nsAsyncAccesskeyUpdate(this);
+        if (cb) {
+            PresContext()->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->GetInkBoundsForVisualOverflow(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 visual overflow may
+    // extend beyond that.
+    nsRect visualBounds;
+    visualBounds.UnionRect(scrollBounds, textRect);
+    nsOverflowAreas overflow(visualBounds, scrollBounds);
+
+    if (textStyle->mTextShadow) {
+      // text-shadow extends our visual but not scrollable bounds
+      nsRect &vis = overflow.VisualOverflow();
+      vis.UnionRect(vis, nsLayoutUtils::GetTextShadowRectsUnion(mTextDrawRect, this));
+    }
+    FinishAndStoreOverflow(overflow, GetSize());
+
+    return rv;
+}
+
+nsRect
+nsTextBoxFrame::GetComponentAlphaBounds()
+{
+  if (StyleText()->mTextShadow) {
+    return GetVisualOverflowRectRelativeToSelf();
+  }
+  return mTextDrawRect;
+}
+
+bool
+nsTextBoxFrame::ComputesOwnOverflowArea()
+{
+    return true;
+}
+
+/* virtual */ void
+nsTextBoxFrame::MarkIntrinsicISizesDirty()
+{
+    mNeedsRecalc = true;
+    nsLeafBoxFrame::MarkIntrinsicISizesDirty();
+}
+
+void
+nsTextBoxFrame::GetTextSize(nsRenderingContext& 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;
+        nsRenderingContext* rendContext = aBoxLayoutState.GetRenderingContext();
+        if (rendContext) {
+            GetTextSize(*rendContext, mTitle, size, mAscent);
+            if (GetWritingMode().IsVertical()) {
+                Swap(size.width, size.height);
+            }
+            mTextSize = size;
+            mNeedsRecalc = false;
+        }
+    }
+}
+
+void
+nsTextBoxFrame::CalcDrawRect(nsRenderingContext &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(PresContext()->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 == NS_STYLE_TEXT_ALIGN_CENTER) {
+      textRect.IStart(wm) += (outerISize - textRect.ISize(wm)) / 2;
+    } else if (textStyle->mTextAlign == NS_STYLE_TEXT_ALIGN_END ||
+             (textStyle->mTextAlign == NS_STYLE_TEXT_ALIGN_LEFT &&
+              !wm.IsBidiLTR()) ||
+             (textStyle->mTextAlign == NS_STYLE_TEXT_ALIGN_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);
+
+    AddBorderAndPadding(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;
+        }
+    }
+
+    AddBorderAndPadding(size);
+    bool widthSet, heightSet;
+    nsIFrame::AddXULMinSize(aBoxLayoutState, 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(NS_LITERAL_STRING("TextBox"), aResult);
+    aResult += NS_LITERAL_STRING("[value=") + mTitle + NS_LITERAL_STRING("]");
+    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->HasAttr(kNameSpaceID_None, nsGkAtoms::control))
+        return NS_OK;
+
+    // see if we even have an access key
+    nsAutoString accessKey;
+    mContent->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, key);
+    else
+        esm->UnregisterAccessKey(mContent, key);
+
+    return NS_OK;
+}