/* -*- 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/. */

#include "nsNumberControlFrame.h"

#include "HTMLInputElement.h"
#include "ICUUtils.h"
#include "nsIFocusManager.h"
#include "nsIPresShell.h"
#include "nsFocusManager.h"
#include "nsFontMetrics.h"
#include "nsCheckboxRadioFrame.h"
#include "nsGkAtoms.h"
#include "nsNameSpaceManager.h"
#include "nsStyleConsts.h"
#include "mozilla/BasicEvents.h"
#include "mozilla/EventStates.h"
#include "nsContentUtils.h"
#include "nsContentCreatorFunctions.h"
#include "nsCSSPseudoElements.h"
#include "nsThreadUtils.h"
#include "mozilla/FloatingPoint.h"
#include "mozilla/dom/MutationEventBinding.h"

#ifdef ACCESSIBILITY
#include "mozilla/a11y/AccTypes.h"
#endif

using namespace mozilla;
using namespace mozilla::dom;

nsIFrame* NS_NewNumberControlFrame(nsIPresShell* aPresShell,
                                   ComputedStyle* aStyle) {
  return new (aPresShell) nsNumberControlFrame(aStyle);
}

NS_IMPL_FRAMEARENA_HELPERS(nsNumberControlFrame)

NS_QUERYFRAME_HEAD(nsNumberControlFrame)
  NS_QUERYFRAME_ENTRY(nsNumberControlFrame)
  NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
  NS_QUERYFRAME_ENTRY(nsIFormControlFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)

nsNumberControlFrame::nsNumberControlFrame(ComputedStyle* aStyle)
    : nsContainerFrame(aStyle, kClassID), mHandlingInputEvent(false) {}

void nsNumberControlFrame::DestroyFrom(nsIFrame* aDestructRoot,
                                       PostDestroyData& aPostDestroyData) {
  NS_ASSERTION(
      !GetPrevContinuation() && !GetNextContinuation(),
      "nsNumberControlFrame should not have continuations; if it does we "
      "need to call RegUnregAccessKey only for the first");
  nsCheckboxRadioFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false);
  aPostDestroyData.AddAnonymousContent(mOuterWrapper.forget());
  nsContainerFrame::DestroyFrom(aDestructRoot, aPostDestroyData);
}

nscoord nsNumberControlFrame::GetMinISize(gfxContext* aRenderingContext) {
  nscoord result;
  DISPLAY_MIN_INLINE_SIZE(this, result);

  nsIFrame* kid = mFrames.FirstChild();
  if (kid) {  // display:none?
    result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext, kid,
                                                  nsLayoutUtils::MIN_ISIZE);
  } else {
    result = 0;
  }

  return result;
}

nscoord nsNumberControlFrame::GetPrefISize(gfxContext* aRenderingContext) {
  nscoord result;
  DISPLAY_PREF_INLINE_SIZE(this, result);

  nsIFrame* kid = mFrames.FirstChild();
  if (kid) {  // display:none?
    result = nsLayoutUtils::IntrinsicForContainer(aRenderingContext, kid,
                                                  nsLayoutUtils::PREF_ISIZE);
  } else {
    result = 0;
  }

  return result;
}

void nsNumberControlFrame::Reflow(nsPresContext* aPresContext,
                                  ReflowOutput& aDesiredSize,
                                  const ReflowInput& aReflowInput,
                                  nsReflowStatus& aStatus) {
  MarkInReflow();
  DO_GLOBAL_REFLOW_COUNT("nsNumberControlFrame");
  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");

  NS_ASSERTION(mOuterWrapper, "Outer wrapper div must exist!");

  NS_ASSERTION(
      !GetPrevContinuation() && !GetNextContinuation(),
      "nsNumberControlFrame should not have continuations; if it does we "
      "need to call RegUnregAccessKey only for the first");

  NS_ASSERTION(!mFrames.FirstChild() || !mFrames.FirstChild()->GetNextSibling(),
               "We expect at most one direct child frame");

  if (mState & NS_FRAME_FIRST_REFLOW) {
    nsCheckboxRadioFrame::RegUnRegAccessKey(this, true);
  }

  const WritingMode myWM = aReflowInput.GetWritingMode();

  // The ISize of our content box, which is the available ISize
  // for our anonymous content:
  const nscoord contentBoxISize = aReflowInput.ComputedISize();
  nscoord contentBoxBSize = aReflowInput.ComputedBSize();

  // Figure out our border-box sizes as well (by adding borderPadding to
  // content-box sizes):
  const nscoord borderBoxISize =
      contentBoxISize +
      aReflowInput.ComputedLogicalBorderPadding().IStartEnd(myWM);

  nscoord borderBoxBSize;
  if (contentBoxBSize != NS_INTRINSICSIZE) {
    borderBoxBSize =
        contentBoxBSize +
        aReflowInput.ComputedLogicalBorderPadding().BStartEnd(myWM);
  }  // else, we'll figure out borderBoxBSize after we resolve contentBoxBSize.

  nsIFrame* outerWrapperFrame = mOuterWrapper->GetPrimaryFrame();

  if (!outerWrapperFrame) {  // display:none?
    if (contentBoxBSize == NS_INTRINSICSIZE) {
      contentBoxBSize = 0;
      borderBoxBSize =
          aReflowInput.ComputedLogicalBorderPadding().BStartEnd(myWM);
    }
  } else {
    NS_ASSERTION(outerWrapperFrame == mFrames.FirstChild(), "huh?");

    ReflowOutput wrappersDesiredSize(aReflowInput);

    WritingMode wrapperWM = outerWrapperFrame->GetWritingMode();
    LogicalSize availSize = aReflowInput.ComputedSize(wrapperWM);
    availSize.BSize(wrapperWM) = NS_UNCONSTRAINEDSIZE;

    ReflowInput wrapperReflowInput(aPresContext, aReflowInput,
                                   outerWrapperFrame, availSize);

    // Convert wrapper margin into my own writing-mode (in case it differs):
    LogicalMargin wrapperMargin =
        wrapperReflowInput.ComputedLogicalMargin().ConvertTo(myWM, wrapperWM);

    // offsets of wrapper frame within this frame:
    LogicalPoint wrapperOffset(
        myWM,
        aReflowInput.ComputedLogicalBorderPadding().IStart(myWM) +
            wrapperMargin.IStart(myWM),
        aReflowInput.ComputedLogicalBorderPadding().BStart(myWM) +
            wrapperMargin.BStart(myWM));

    nsReflowStatus childStatus;
    // We initially reflow the child with a dummy containerSize; positioning
    // will be fixed later.
    const nsSize dummyContainerSize;
    ReflowChild(outerWrapperFrame, aPresContext, wrappersDesiredSize,
                wrapperReflowInput, myWM, wrapperOffset, dummyContainerSize, 0,
                childStatus);
    MOZ_ASSERT(childStatus.IsFullyComplete(),
               "We gave our child unconstrained available block-size, "
               "so it should be complete");

    nscoord wrappersMarginBoxBSize =
        wrappersDesiredSize.BSize(myWM) + wrapperMargin.BStartEnd(myWM);

    if (contentBoxBSize == NS_INTRINSICSIZE) {
      // We are intrinsically sized -- we should shrinkwrap the outer wrapper's
      // block-size:
      contentBoxBSize = wrappersMarginBoxBSize;

      // Make sure we obey min/max-bsize in the case when we're doing intrinsic
      // sizing (we get it for free when we have a non-intrinsic
      // aReflowInput.ComputedBSize()).  Note that we do this before
      // adjusting for borderpadding, since ComputedMaxBSize and
      // ComputedMinBSize are content heights.
      contentBoxBSize =
          NS_CSS_MINMAX(contentBoxBSize, aReflowInput.ComputedMinBSize(),
                        aReflowInput.ComputedMaxBSize());

      borderBoxBSize =
          contentBoxBSize +
          aReflowInput.ComputedLogicalBorderPadding().BStartEnd(myWM);
    }

    // Center child in block axis
    nscoord extraSpace = contentBoxBSize - wrappersMarginBoxBSize;
    wrapperOffset.B(myWM) += std::max(0, extraSpace / 2);

    // Needed in FinishReflowChild, for logical-to-physical conversion:
    nsSize borderBoxSize =
        LogicalSize(myWM, borderBoxISize, borderBoxBSize).GetPhysicalSize(myWM);

    // Place the child
    FinishReflowChild(outerWrapperFrame, aPresContext, wrappersDesiredSize,
                      &wrapperReflowInput, myWM, wrapperOffset, borderBoxSize,
                      0);

    nsSize contentBoxSize = LogicalSize(myWM, contentBoxISize, contentBoxBSize)
                                .GetPhysicalSize(myWM);
    aDesiredSize.SetBlockStartAscent(
        wrappersDesiredSize.BlockStartAscent() +
        outerWrapperFrame->BStart(aReflowInput.GetWritingMode(),
                                  contentBoxSize));
  }

  LogicalSize logicalDesiredSize(myWM, borderBoxISize, borderBoxBSize);
  aDesiredSize.SetSize(myWM, logicalDesiredSize);

  aDesiredSize.SetOverflowAreasToDesiredBounds();

  if (outerWrapperFrame) {
    ConsiderChildOverflow(aDesiredSize.mOverflowAreas, outerWrapperFrame);
  }

  FinishAndStoreOverflow(&aDesiredSize);

  MOZ_ASSERT(aStatus.IsEmpty(), "This type of frame can't be split.");

  NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}

void nsNumberControlFrame::SyncDisabledState() {
  EventStates eventStates = mContent->AsElement()->State();
  if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
    mTextField->SetAttr(kNameSpaceID_None, nsGkAtoms::disabled, EmptyString(),
                        true);
  } else {
    mTextField->UnsetAttr(kNameSpaceID_None, nsGkAtoms::disabled, true);
  }
}

nsresult nsNumberControlFrame::AttributeChanged(int32_t aNameSpaceID,
                                                nsAtom* aAttribute,
                                                int32_t aModType) {
  // nsGkAtoms::disabled is handled by SyncDisabledState
  if (aNameSpaceID == kNameSpaceID_None) {
    if (aAttribute == nsGkAtoms::placeholder ||
        aAttribute == nsGkAtoms::readonly ||
        aAttribute == nsGkAtoms::tabindex) {
      if (aModType == MutationEvent_Binding::REMOVAL) {
        mTextField->UnsetAttr(aNameSpaceID, aAttribute, true);
      } else {
        MOZ_ASSERT(aModType == MutationEvent_Binding::ADDITION ||
                   aModType == MutationEvent_Binding::MODIFICATION);
        nsAutoString value;
        mContent->AsElement()->GetAttr(aNameSpaceID, aAttribute, value);
        mTextField->SetAttr(aNameSpaceID, aAttribute, value, true);
      }
    }
  }

  return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
}

void nsNumberControlFrame::ContentStatesChanged(EventStates aStates) {
  if (aStates.HasState(NS_EVENT_STATE_DISABLED)) {
    nsContentUtils::AddScriptRunner(new SyncDisabledStateEvent(this));
  }
}

nsITextControlFrame* nsNumberControlFrame::GetTextFieldFrame() {
  return do_QueryFrame(GetAnonTextControl()->GetPrimaryFrame());
}

class FocusTextField : public Runnable {
 public:
  FocusTextField(nsIContent* aNumber, nsIContent* aTextField)
      : mozilla::Runnable("FocusTextField"),
        mNumber(aNumber),
        mTextField(aTextField) {}

  NS_IMETHOD Run() override {
    if (mNumber->AsElement()->State().HasState(NS_EVENT_STATE_FOCUS)) {
      HTMLInputElement::FromNode(mTextField)->Focus(IgnoreErrors());
    }

    return NS_OK;
  }

 private:
  nsCOMPtr<nsIContent> mNumber;
  nsCOMPtr<nsIContent> mTextField;
};

already_AddRefed<Element> nsNumberControlFrame::MakeAnonymousElement(
    Element* aParent, nsAtom* aTagName, CSSPseudoElementType aPseudoType) {
  // Get the NodeInfoManager and tag necessary to create the anonymous divs.
  Document* doc = mContent->GetComposedDoc();
  RefPtr<Element> resultElement = doc->CreateHTMLElement(aTagName);
  resultElement->SetPseudoElementType(aPseudoType);

  if (aPseudoType == CSSPseudoElementType::mozNumberSpinDown ||
      aPseudoType == CSSPseudoElementType::mozNumberSpinUp) {
    resultElement->SetAttr(kNameSpaceID_None, nsGkAtoms::role,
                           NS_LITERAL_STRING("button"), false);
  }

  if (aParent) {
    aParent->AppendChildTo(resultElement, false);
  }

  return resultElement.forget();
}

nsresult nsNumberControlFrame::CreateAnonymousContent(
    nsTArray<ContentInfo>& aElements) {
  // We create an anonymous tree for our input element that is structured as
  // follows:
  //
  // input
  //   div      - outer wrapper with "display:flex" by default
  //     input  - text input field
  //     div    - spin box wrapping up/down arrow buttons
  //       div  - spin up (up arrow button)
  //       div  - spin down (down arrow button)
  //
  // If you change this, be careful to change the destruction order in
  // nsNumberControlFrame::DestroyFrom.

  // Create the anonymous outer wrapper:
  mOuterWrapper = MakeAnonymousElement(nullptr, nsGkAtoms::div,
                                       CSSPseudoElementType::mozNumberWrapper);

  aElements.AppendElement(mOuterWrapper);

  // Create the ::-moz-number-text pseudo-element:
  mTextField = MakeAnonymousElement(mOuterWrapper, nsGkAtoms::input,
                                    CSSPseudoElementType::mozNumberText);

  mTextField->SetAttr(kNameSpaceID_None, nsGkAtoms::type,
                      NS_LITERAL_STRING("text"), false);

  HTMLInputElement* content = HTMLInputElement::FromNode(mContent);
  HTMLInputElement* textField = HTMLInputElement::FromNode(mTextField);

  // Initialize the text field value:
  nsAutoString value;
  content->GetValue(value, CallerType::System);
  SetValueOfAnonTextControl(value);

  // If we're readonly, make sure our anonymous text control is too:
  nsAutoString readonly;
  if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::readonly,
                                     readonly)) {
    mTextField->SetAttr(kNameSpaceID_None, nsGkAtoms::readonly, readonly,
                        false);
  }

  // Propogate our tabindex:
  textField->SetTabIndex(content->TabIndex(), IgnoreErrors());

  // Initialize the text field's placeholder, if ours is set:
  nsAutoString placeholder;
  if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder,
                                     placeholder)) {
    mTextField->SetAttr(kNameSpaceID_None, nsGkAtoms::placeholder, placeholder,
                        false);
  }

  if (mContent->AsElement()->State().HasState(NS_EVENT_STATE_FOCUS)) {
    // We don't want to focus the frame but the text field.
    RefPtr<FocusTextField> focusJob = new FocusTextField(mContent, mTextField);
    nsContentUtils::AddScriptRunner(focusJob);
  }

  SyncDisabledState();  // Sync disabled state of 'mTextField'.

  if (StyleDisplay()->mAppearance == StyleAppearance::Textfield) {
    // The author has elected to hide the spinner by setting this
    // -moz-appearance. We will reframe if it changes.
    return NS_OK;
  }

  // Create the ::-moz-number-spin-box pseudo-element:
  mSpinBox = MakeAnonymousElement(mOuterWrapper, nsGkAtoms::div,
                                  CSSPseudoElementType::mozNumberSpinBox);

  // Create the ::-moz-number-spin-up pseudo-element:
  mSpinUp = MakeAnonymousElement(mSpinBox, nsGkAtoms::div,
                                 CSSPseudoElementType::mozNumberSpinUp);

  // Create the ::-moz-number-spin-down pseudo-element:
  mSpinDown = MakeAnonymousElement(mSpinBox, nsGkAtoms::div,
                                   CSSPseudoElementType::mozNumberSpinDown);

  return NS_OK;
}

void nsNumberControlFrame::SetFocus(bool aOn, bool aRepaint) {
  GetTextFieldFrame()->SetFocus(aOn, aRepaint);
}

nsresult nsNumberControlFrame::SetFormProperty(nsAtom* aName,
                                               const nsAString& aValue) {
  return GetTextFieldFrame()->SetFormProperty(aName, aValue);
}

HTMLInputElement* nsNumberControlFrame::GetAnonTextControl() {
  return HTMLInputElement::FromNode(mTextField);
}

/* static */ nsNumberControlFrame*
nsNumberControlFrame::GetNumberControlFrameForTextField(nsIFrame* aFrame) {
  // If aFrame is the anon text field for an <input type=number> then we expect
  // the frame of its mContent's grandparent to be that input's frame. We
  // have to check for this via the content tree because we don't know whether
  // extra frames will be wrapped around any of the elements between aFrame and
  // the nsNumberControlFrame that we're looking for (e.g. flex wrappers).
  nsIContent* content = aFrame->GetContent();
  if (content->IsInNativeAnonymousSubtree() && content->GetParent() &&
      content->GetParent()->GetParent()) {
    nsIContent* grandparent = content->GetParent()->GetParent();
    if (grandparent->IsHTMLElement(nsGkAtoms::input) &&
        grandparent->AsElement()->AttrValueIs(
            kNameSpaceID_None, nsGkAtoms::type, nsGkAtoms::number,
            eCaseMatters)) {
      return do_QueryFrame(grandparent->GetPrimaryFrame());
    }
  }
  return nullptr;
}

/* static */ nsNumberControlFrame*
nsNumberControlFrame::GetNumberControlFrameForSpinButton(nsIFrame* aFrame) {
  // If aFrame is a spin button for an <input type=number> then we expect the
  // frame of its mContent's great-grandparent to be that input's frame. We
  // have to check for this via the content tree because we don't know whether
  // extra frames will be wrapped around any of the elements between aFrame and
  // the nsNumberControlFrame that we're looking for (e.g. flex wrappers).
  nsIContent* content = aFrame->GetContent();
  if (content->IsInNativeAnonymousSubtree() && content->GetParent() &&
      content->GetParent()->GetParent() &&
      content->GetParent()->GetParent()->GetParent()) {
    nsIContent* greatgrandparent =
        content->GetParent()->GetParent()->GetParent();
    if (greatgrandparent->IsHTMLElement(nsGkAtoms::input) &&
        greatgrandparent->AsElement()->AttrValueIs(
            kNameSpaceID_None, nsGkAtoms::type, nsGkAtoms::number,
            eCaseMatters)) {
      return do_QueryFrame(greatgrandparent->GetPrimaryFrame());
    }
  }
  return nullptr;
}

int32_t nsNumberControlFrame::GetSpinButtonForPointerEvent(
    WidgetGUIEvent* aEvent) const {
  MOZ_ASSERT(aEvent->mClass == eMouseEventClass, "Unexpected event type");

  if (!mSpinBox) {
    // we don't have a spinner
    return eSpinButtonNone;
  }
  if (aEvent->mOriginalTarget == mSpinUp) {
    return eSpinButtonUp;
  }
  if (aEvent->mOriginalTarget == mSpinDown) {
    return eSpinButtonDown;
  }
  if (aEvent->mOriginalTarget == mSpinBox) {
    // In the case that the up/down buttons are hidden (display:none) we use
    // just the spin box element, spinning up if the pointer is over the top
    // half of the element, or down if it's over the bottom half. This is
    // important to handle since this is the state things are in for the
    // default UA style sheet. See the comment in forms.css for why.
    LayoutDeviceIntPoint absPoint = aEvent->mRefPoint;
    nsPoint point = nsLayoutUtils::GetEventCoordinatesRelativeTo(
        aEvent, absPoint, mSpinBox->GetPrimaryFrame());
    if (point != nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE)) {
      if (point.y < mSpinBox->GetPrimaryFrame()->GetSize().height / 2) {
        return eSpinButtonUp;
      }
      return eSpinButtonDown;
    }
  }
  return eSpinButtonNone;
}

void nsNumberControlFrame::SpinnerStateChanged() const {
  MOZ_ASSERT(mSpinUp && mSpinDown,
             "We should not be called when we have no spinner");

  nsIFrame* spinUpFrame = mSpinUp->GetPrimaryFrame();
  if (spinUpFrame && spinUpFrame->IsThemed()) {
    spinUpFrame->InvalidateFrame();
  }
  nsIFrame* spinDownFrame = mSpinDown->GetPrimaryFrame();
  if (spinDownFrame && spinDownFrame->IsThemed()) {
    spinDownFrame->InvalidateFrame();
  }
}

bool nsNumberControlFrame::SpinnerUpButtonIsDepressed() const {
  return HTMLInputElement::FromNode(mContent)
      ->NumberSpinnerUpButtonIsDepressed();
}

bool nsNumberControlFrame::SpinnerDownButtonIsDepressed() const {
  return HTMLInputElement::FromNode(mContent)
      ->NumberSpinnerDownButtonIsDepressed();
}

bool nsNumberControlFrame::IsFocused() const {
  // Normally this depends on the state of our anonymous text control (which
  // takes focus for us), but in the case that it does not have a frame we will
  // have focus ourself.
  return mTextField->State().HasState(NS_EVENT_STATE_FOCUS) ||
         mContent->AsElement()->State().HasState(NS_EVENT_STATE_FOCUS);
}

void nsNumberControlFrame::HandleFocusEvent(WidgetEvent* aEvent) {
  if (aEvent->mOriginalTarget != mTextField) {
    // Move focus to our text field
    RefPtr<HTMLInputElement> textField = HTMLInputElement::FromNode(mTextField);
    textField->Focus(IgnoreErrors());
  }
}

void nsNumberControlFrame::HandleSelectCall() {
  RefPtr<HTMLInputElement> textField = HTMLInputElement::FromNode(mTextField);
  textField->Select();
}

#define STYLES_DISABLING_NATIVE_THEMING                          \
  NS_AUTHOR_SPECIFIED_BACKGROUND | NS_AUTHOR_SPECIFIED_PADDING | \
      NS_AUTHOR_SPECIFIED_BORDER

bool nsNumberControlFrame::ShouldUseNativeStyleForSpinner() const {
  MOZ_ASSERT(mSpinUp && mSpinDown,
             "We should not be called when we have no spinner");

  nsIFrame* spinUpFrame = mSpinUp->GetPrimaryFrame();
  nsIFrame* spinDownFrame = mSpinDown->GetPrimaryFrame();

  return spinUpFrame &&
         spinUpFrame->StyleDisplay()->mAppearance ==
             StyleAppearance::SpinnerUpbutton &&
         !PresContext()->HasAuthorSpecifiedRules(
             spinUpFrame, STYLES_DISABLING_NATIVE_THEMING) &&
         spinDownFrame &&
         spinDownFrame->StyleDisplay()->mAppearance ==
             StyleAppearance::SpinnerDownbutton &&
         !PresContext()->HasAuthorSpecifiedRules(
             spinDownFrame, STYLES_DISABLING_NATIVE_THEMING);
}

void nsNumberControlFrame::AppendAnonymousContentTo(
    nsTArray<nsIContent*>& aElements, uint32_t aFilter) {
  // Only one direct anonymous child:
  if (mOuterWrapper) {
    aElements.AppendElement(mOuterWrapper);
  }
}

void nsNumberControlFrame::SetValueOfAnonTextControl(const nsAString& aValue) {
  if (mHandlingInputEvent) {
    // We have been called while our HTMLInputElement is processing a DOM
    // 'input' event targeted at our anonymous text control. Our
    // HTMLInputElement has taken the value of our anon text control and
    // called SetValueInternal on itself to keep its own value in sync. As a
    // result SetValueInternal has called us. In this one case we do not want
    // to update our anon text control, especially since aValue will be the
    // sanitized value, and only the internal value should be sanitized (not
    // the value shown to the user, and certainly we shouldn't change it as
    // they type).
    return;
  }

  // Init to aValue so that we set aValue as the value of our text control if
  // aValue isn't a valid number (in which case the HTMLInputElement's validity
  // state will be set to invalid) or if aValue can't be localized:
  nsAutoString localizedValue(aValue);

  // Try and localize the value we will set:
  Decimal val = HTMLInputElement::StringToDecimal(aValue);
  if (val.isFinite()) {
    ICUUtils::LanguageTagIterForContent langTagIter(mContent);
    ICUUtils::LocalizeNumber(val.toDouble(), langTagIter, localizedValue);
  }

  // We need to update the value of our anonymous text control here. Note that
  // this must be its value, and not its 'value' attribute (the default value),
  // since the default value is ignored once a user types into the text
  // control.
  //
  // Pass NonSystem as the caller type; this should work fine for actual number
  // inputs, and be safe in case our input has a type we don't expect for some
  // reason.
  HTMLInputElement::FromNode(mTextField)
      ->SetValue(localizedValue, CallerType::NonSystem, IgnoreErrors());
}

void nsNumberControlFrame::GetValueOfAnonTextControl(nsAString& aValue) {
  if (!mTextField) {
    aValue.Truncate();
    return;
  }

  HTMLInputElement::FromNode(mTextField)->GetValue(aValue, CallerType::System);

  // Here we need to de-localize any number typed in by the user. That is, we
  // need to convert it from the number format of the user's language, region,
  // etc. to the format that the HTML 5 spec defines to be a "valid
  // floating-point number":
  //
  //   http://www.whatwg.org/specs/web-apps/current-work/multipage/common-microsyntaxes.html#floating-point-numbers
  //
  // This is necessary to allow the number that we return to be parsed by
  // functions like HTMLInputElement::StringToDecimal (the HTML-5-conforming
  // parsing function) which don't know how to handle numbers that are
  // formatted differently (for example, with non-ASCII digits, with grouping
  // separator characters or with a decimal separator character other than
  // '.').

  ICUUtils::LanguageTagIterForContent langTagIter(mContent);
  double value = ICUUtils::ParseNumber(aValue, langTagIter);
  if (!IsFinite(value)) {
    aValue.Truncate();
    return;
  }
  if (value == HTMLInputElement::StringToDecimal(aValue).toDouble()) {
    // We want to preserve the formatting of the number as typed in by the user
    // whenever possible. Since the localized serialization parses to the same
    // number as the de-localized serialization, we can do that. This helps
    // prevent normalization of input such as "2e2" (which would otherwise be
    // converted to "200"). Content relies on this.
    //
    // Typically we will only get here for locales in which numbers are
    // formatted in the same way as they are for HTML5's "valid floating-point
    // number" format.
    return;
  }
  // We can't preserve the formatting, otherwise functions such as
  // HTMLInputElement::StringToDecimal would incorrectly process the number
  // input by the user. For example, "12.345" with lang=de de-localizes as
  // 12345, but HTMLInputElement::StringToDecimal would mistakenly parse it as
  // 12.345. Another example would be "12,345" with lang=de which de-localizes
  // as 12.345, but HTMLInputElement::StringToDecimal would parse it to NaN.
  aValue.Truncate();
  aValue.AppendFloat(value);
}

bool nsNumberControlFrame::AnonTextControlIsEmpty() {
  if (!mTextField) {
    return true;
  }
  nsAutoString value;
  HTMLInputElement::FromNode(mTextField)->GetValue(value, CallerType::System);
  return value.IsEmpty();
}

#ifdef ACCESSIBILITY
a11y::AccType nsNumberControlFrame::AccessibleType() {
  return a11y::eHTMLSpinnerType;
}
#endif