Add m-esr52 at 52.6.0

1 files changed, 1676 insertions, 0 deletions

diff --git a/dom/html/HTMLTextAreaElement.cpp b/dom/html/HTMLTextAreaElement.cpp
new file mode 100644
index 000000000..42bc02435
--- /dev/null
+++ b/dom/html/HTMLTextAreaElement.cpp
@@ -0,0 +1,1676 @@
+/* -*- 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 "mozilla/dom/HTMLTextAreaElement.h"
+
+#include "mozAutoDocUpdate.h"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/HTMLFormSubmission.h"
+#include "mozilla/dom/HTMLTextAreaElementBinding.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventStates.h"
+#include "mozilla/MouseEvents.h"
+#include "nsAttrValueInlines.h"
+#include "nsContentCID.h"
+#include "nsContentCreatorFunctions.h"
+#include "nsError.h"
+#include "nsFocusManager.h"
+#include "nsIComponentManager.h"
+#include "nsIConstraintValidation.h"
+#include "nsIControllers.h"
+#include "nsIDocument.h"
+#include "nsIDOMHTMLFormElement.h"
+#include "nsIFormControlFrame.h"
+#include "nsIFormControl.h"
+#include "nsIForm.h"
+#include "nsIFrame.h"
+#include "nsISupportsPrimitives.h"
+#include "nsITextControlFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsLinebreakConverter.h"
+#include "nsMappedAttributes.h"
+#include "nsPIDOMWindow.h"
+#include "nsPresContext.h"
+#include "nsPresState.h"
+#include "nsReadableUtils.h"
+#include "nsRuleData.h"
+#include "nsStyleConsts.h"
+#include "nsTextEditorState.h"
+#include "nsIController.h"
+
+static NS_DEFINE_CID(kXULControllersCID,  NS_XULCONTROLLERS_CID);
+
+#define NS_NO_CONTENT_DISPATCH (1 << 0)
+
+NS_IMPL_NS_NEW_HTML_ELEMENT_CHECK_PARSER(TextArea)
+
+namespace mozilla {
+namespace dom {
+
+HTMLTextAreaElement::HTMLTextAreaElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo,
+                                         FromParser aFromParser)
+  : nsGenericHTMLFormElementWithState(aNodeInfo),
+    mValueChanged(false),
+    mLastValueChangeWasInteractive(false),
+    mHandlingSelect(false),
+    mDoneAddingChildren(!aFromParser),
+    mInhibitStateRestoration(!!(aFromParser & FROM_PARSER_FRAGMENT)),
+    mDisabledChanged(false),
+    mCanShowInvalidUI(true),
+    mCanShowValidUI(true),
+    mState(this)
+{
+  AddMutationObserver(this);
+
+  // Set up our default state.  By default we're enabled (since we're
+  // a control type that can be disabled but not actually disabled
+  // right now), optional, and valid.  We are NOT readwrite by default
+  // until someone calls UpdateEditableState on us, apparently!  Also
+  // by default we don't have to show validity UI and so forth.
+  AddStatesSilently(NS_EVENT_STATE_ENABLED |
+                    NS_EVENT_STATE_OPTIONAL |
+                    NS_EVENT_STATE_VALID);
+}
+
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(HTMLTextAreaElement,
+                                   nsGenericHTMLFormElementWithState,
+                                   mValidity,
+                                   mControllers,
+                                   mState)
+
+NS_IMPL_ADDREF_INHERITED(HTMLTextAreaElement, Element)
+NS_IMPL_RELEASE_INHERITED(HTMLTextAreaElement, Element)
+
+
+// QueryInterface implementation for HTMLTextAreaElement
+NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(HTMLTextAreaElement)
+  NS_INTERFACE_TABLE_INHERITED(HTMLTextAreaElement,
+                               nsIDOMHTMLTextAreaElement,
+                               nsITextControlElement,
+                               nsIDOMNSEditableElement,
+                               nsIMutationObserver,
+                               nsIConstraintValidation)
+NS_INTERFACE_TABLE_TAIL_INHERITING(nsGenericHTMLFormElementWithState)
+
+
+// nsIDOMHTMLTextAreaElement
+
+nsresult
+HTMLTextAreaElement::Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const
+{
+  *aResult = nullptr;
+  already_AddRefed<mozilla::dom::NodeInfo> ni =
+    RefPtr<mozilla::dom::NodeInfo>(aNodeInfo).forget();
+  RefPtr<HTMLTextAreaElement> it = new HTMLTextAreaElement(ni);
+
+  nsresult rv = const_cast<HTMLTextAreaElement*>(this)->CopyInnerTo(it);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (mValueChanged) {
+    // Set our value on the clone.
+    nsAutoString value;
+    GetValueInternal(value, true);
+
+    // SetValueInternal handles setting mValueChanged for us
+    rv = it->SetValueInternal(value, nsTextEditorState::eSetValue_Notify);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  it->mLastValueChangeWasInteractive = mLastValueChangeWasInteractive;
+  it.forget(aResult);
+  return NS_OK;
+}
+
+// nsIConstraintValidation
+NS_IMPL_NSICONSTRAINTVALIDATION_EXCEPT_SETCUSTOMVALIDITY(HTMLTextAreaElement)
+
+
+NS_IMETHODIMP
+HTMLTextAreaElement::GetForm(nsIDOMHTMLFormElement** aForm)
+{
+  return nsGenericHTMLFormElementWithState::GetForm(aForm);
+}
+
+
+// nsIContent
+
+NS_IMETHODIMP
+HTMLTextAreaElement::Select()
+{
+  // XXX Bug?  We have to give the input focus before contents can be
+  // selected
+
+  FocusTristate state = FocusState();
+  if (state == eUnfocusable) {
+    return NS_OK;
+  }
+
+  nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+
+  RefPtr<nsPresContext> presContext = GetPresContext(eForComposedDoc);
+  if (state == eInactiveWindow) {
+    if (fm)
+      fm->SetFocus(this, nsIFocusManager::FLAG_NOSCROLL);
+    SelectAll(presContext);
+    return NS_OK;
+  }
+
+  nsEventStatus status = nsEventStatus_eIgnore;
+  WidgetGUIEvent event(true, eFormSelect, nullptr);
+  // XXXbz HTMLInputElement guards against this reentering; shouldn't we?
+  EventDispatcher::Dispatch(static_cast<nsIContent*>(this), presContext,
+                            &event, nullptr, &status);
+
+  // If the DOM event was not canceled (e.g. by a JS event handler
+  // returning false)
+  if (status == nsEventStatus_eIgnore) {
+    if (fm) {
+      fm->SetFocus(this, nsIFocusManager::FLAG_NOSCROLL);
+
+      // ensure that the element is actually focused
+      nsCOMPtr<nsIDOMElement> focusedElement;
+      fm->GetFocusedElement(getter_AddRefs(focusedElement));
+      if (SameCOMIdentity(static_cast<nsIDOMNode*>(this), focusedElement)) {
+        // Now Select all the text!
+        SelectAll(presContext);
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::SelectAll(nsPresContext* aPresContext)
+{
+  nsIFormControlFrame* formControlFrame = GetFormControlFrame(true);
+
+  if (formControlFrame) {
+    formControlFrame->SetFormProperty(nsGkAtoms::select, EmptyString());
+  }
+
+  return NS_OK;
+}
+
+bool
+HTMLTextAreaElement::IsHTMLFocusable(bool aWithMouse,
+                                     bool *aIsFocusable, int32_t *aTabIndex)
+{
+  if (nsGenericHTMLFormElementWithState::IsHTMLFocusable(aWithMouse, aIsFocusable,
+                                                         aTabIndex))
+  {
+    return true;
+  }
+
+  // disabled textareas are not focusable
+  *aIsFocusable = !IsDisabled();
+  return false;
+}
+
+NS_IMPL_BOOL_ATTR(HTMLTextAreaElement, Autofocus, autofocus)
+NS_IMPL_UINT_ATTR_NON_ZERO_DEFAULT_VALUE(HTMLTextAreaElement, Cols, cols, DEFAULT_COLS)
+NS_IMPL_BOOL_ATTR(HTMLTextAreaElement, Disabled, disabled)
+NS_IMPL_NON_NEGATIVE_INT_ATTR(HTMLTextAreaElement, MaxLength, maxlength)
+NS_IMPL_NON_NEGATIVE_INT_ATTR(HTMLTextAreaElement, MinLength, minlength)
+NS_IMPL_STRING_ATTR(HTMLTextAreaElement, Name, name)
+NS_IMPL_BOOL_ATTR(HTMLTextAreaElement, ReadOnly, readonly)
+NS_IMPL_BOOL_ATTR(HTMLTextAreaElement, Required, required)
+NS_IMPL_UINT_ATTR_NON_ZERO_DEFAULT_VALUE(HTMLTextAreaElement, Rows, rows, DEFAULT_ROWS_TEXTAREA)
+NS_IMPL_STRING_ATTR(HTMLTextAreaElement, Wrap, wrap)
+NS_IMPL_STRING_ATTR(HTMLTextAreaElement, Placeholder, placeholder)
+  
+int32_t
+HTMLTextAreaElement::TabIndexDefault()
+{
+  return 0;
+}
+
+NS_IMETHODIMP 
+HTMLTextAreaElement::GetType(nsAString& aType)
+{
+  aType.AssignLiteral("textarea");
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+HTMLTextAreaElement::GetValue(nsAString& aValue)
+{
+  GetValueInternal(aValue, true);
+  return NS_OK;
+}
+
+void
+HTMLTextAreaElement::GetValueInternal(nsAString& aValue, bool aIgnoreWrap) const
+{
+  mState.GetValue(aValue, aIgnoreWrap);
+}
+
+NS_IMETHODIMP_(nsIEditor*)
+HTMLTextAreaElement::GetTextEditor()
+{
+  return GetEditor();
+}
+
+NS_IMETHODIMP_(nsISelectionController*)
+HTMLTextAreaElement::GetSelectionController()
+{
+  return mState.GetSelectionController();
+}
+
+NS_IMETHODIMP_(nsFrameSelection*)
+HTMLTextAreaElement::GetConstFrameSelection()
+{
+  return mState.GetConstFrameSelection();
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::BindToFrame(nsTextControlFrame* aFrame)
+{
+  return mState.BindToFrame(aFrame);
+}
+
+NS_IMETHODIMP_(void)
+HTMLTextAreaElement::UnbindFromFrame(nsTextControlFrame* aFrame)
+{
+  if (aFrame) {
+    mState.UnbindFromFrame(aFrame);
+  }
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::CreateEditor()
+{
+  return mState.PrepareEditor();
+}
+
+NS_IMETHODIMP_(nsIContent*)
+HTMLTextAreaElement::GetRootEditorNode()
+{
+  return mState.GetRootNode();
+}
+
+NS_IMETHODIMP_(Element*)
+HTMLTextAreaElement::CreatePlaceholderNode()
+{
+  NS_ENSURE_SUCCESS(mState.CreatePlaceholderNode(), nullptr);
+  return mState.GetPlaceholderNode();
+}
+
+NS_IMETHODIMP_(Element*)
+HTMLTextAreaElement::GetPlaceholderNode()
+{
+  return mState.GetPlaceholderNode();
+}
+
+NS_IMETHODIMP_(void)
+HTMLTextAreaElement::UpdatePlaceholderVisibility(bool aNotify)
+{
+  mState.UpdatePlaceholderVisibility(aNotify);
+}
+
+NS_IMETHODIMP_(bool)
+HTMLTextAreaElement::GetPlaceholderVisibility()
+{
+  return mState.GetPlaceholderVisibility();
+}
+
+nsresult
+HTMLTextAreaElement::SetValueInternal(const nsAString& aValue,
+                                      uint32_t aFlags)
+{
+  // Need to set the value changed flag here, so that
+  // nsTextControlFrame::UpdateValueDisplay retrieves the correct value
+  // if needed.
+  SetValueChanged(true);
+  aFlags |= nsTextEditorState::eSetValue_Notify;
+  if (!mState.SetValue(aValue, aFlags)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+HTMLTextAreaElement::SetValue(const nsAString& aValue)
+{
+  // If the value has been set by a script, we basically want to keep the
+  // current change event state. If the element is ready to fire a change
+  // event, we should keep it that way. Otherwise, we should make sure the
+  // element will not fire any event because of the script interaction.
+  //
+  // NOTE: this is currently quite expensive work (too much string
+  // manipulation). We should probably optimize that.
+  nsAutoString currentValue;
+  GetValueInternal(currentValue, true);
+
+  nsresult rv =
+    SetValueInternal(aValue, nsTextEditorState::eSetValue_ByContent);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (mFocusedValue.Equals(currentValue)) {
+    GetValueInternal(mFocusedValue, true);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+HTMLTextAreaElement::SetUserInput(const nsAString& aValue)
+{
+  if (!nsContentUtils::IsCallerChrome()) {
+    return NS_ERROR_DOM_SECURITY_ERR;
+  }
+  return SetValueInternal(aValue, nsTextEditorState::eSetValue_BySetUserInput);
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::SetValueChanged(bool aValueChanged)
+{
+  bool previousValue = mValueChanged;
+
+  mValueChanged = aValueChanged;
+  if (!aValueChanged && !mState.IsEmpty()) {
+    mState.EmptyValue();
+  }
+
+  if (mValueChanged != previousValue) {
+    UpdateState(true);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::GetDefaultValue(nsAString& aDefaultValue)
+{
+  if (!nsContentUtils::GetNodeTextContent(this, false, aDefaultValue, fallible)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+  return NS_OK;
+}  
+
+NS_IMETHODIMP
+HTMLTextAreaElement::SetDefaultValue(const nsAString& aDefaultValue)
+{
+  ErrorResult error;
+  SetDefaultValue(aDefaultValue, error);
+  return error.StealNSResult();
+}
+
+void
+HTMLTextAreaElement::SetDefaultValue(const nsAString& aDefaultValue, ErrorResult& aError)
+{
+  nsresult rv = nsContentUtils::SetNodeTextContent(this, aDefaultValue, true);
+  if (NS_SUCCEEDED(rv) && !mValueChanged) {
+    Reset();
+  }
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+  }
+}
+
+bool
+HTMLTextAreaElement::ParseAttribute(int32_t aNamespaceID,
+                                    nsIAtom* aAttribute,
+                                    const nsAString& aValue,
+                                    nsAttrValue& aResult)
+{
+  if (aNamespaceID == kNameSpaceID_None) {
+    if (aAttribute == nsGkAtoms::maxlength ||
+        aAttribute == nsGkAtoms::minlength) {
+      return aResult.ParseNonNegativeIntValue(aValue);
+    } else if (aAttribute == nsGkAtoms::cols) {
+      aResult.ParseIntWithFallback(aValue, DEFAULT_COLS);
+      return true;
+    } else if (aAttribute == nsGkAtoms::rows) {
+      aResult.ParseIntWithFallback(aValue, DEFAULT_ROWS_TEXTAREA);
+      return true;
+    }
+  }
+  return nsGenericHTMLElement::ParseAttribute(aNamespaceID, aAttribute, aValue,
+                                              aResult);
+}
+
+void
+HTMLTextAreaElement::MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
+                                           nsRuleData* aData)
+{
+  if (aData->mSIDs & NS_STYLE_INHERIT_BIT(Text)) {
+    // wrap=off
+    nsCSSValue* whiteSpace = aData->ValueForWhiteSpace();
+    if (whiteSpace->GetUnit() == eCSSUnit_Null) {
+      const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::wrap);
+      if (value && value->Type() == nsAttrValue::eString &&
+          value->Equals(nsGkAtoms::OFF, eIgnoreCase)) {
+        whiteSpace->SetIntValue(NS_STYLE_WHITESPACE_PRE, eCSSUnit_Enumerated);
+      }
+    }
+  }
+
+  nsGenericHTMLFormElementWithState::MapDivAlignAttributeInto(aAttributes, aData);
+  nsGenericHTMLFormElementWithState::MapCommonAttributesInto(aAttributes, aData);
+}
+
+nsChangeHint
+HTMLTextAreaElement::GetAttributeChangeHint(const nsIAtom* aAttribute,
+                                            int32_t aModType) const
+{
+  nsChangeHint retval =
+      nsGenericHTMLFormElementWithState::GetAttributeChangeHint(aAttribute, aModType);
+  if (aAttribute == nsGkAtoms::rows ||
+      aAttribute == nsGkAtoms::cols) {
+    retval |= NS_STYLE_HINT_REFLOW;
+  } else if (aAttribute == nsGkAtoms::wrap) {
+    retval |= nsChangeHint_ReconstructFrame;
+  } else if (aAttribute == nsGkAtoms::placeholder) {
+    retval |= nsChangeHint_ReconstructFrame;
+  }
+  return retval;
+}
+
+NS_IMETHODIMP_(bool)
+HTMLTextAreaElement::IsAttributeMapped(const nsIAtom* aAttribute) const
+{
+  static const MappedAttributeEntry attributes[] = {
+    { &nsGkAtoms::wrap },
+    { nullptr }
+  };
+
+  static const MappedAttributeEntry* const map[] = {
+    attributes,
+    sDivAlignAttributeMap,
+    sCommonAttributeMap,
+  };
+
+  return FindAttributeDependence(aAttribute, map);
+}
+
+nsMapRuleToAttributesFunc
+HTMLTextAreaElement::GetAttributeMappingFunction() const
+{
+  return &MapAttributesIntoRule;
+}
+
+bool
+HTMLTextAreaElement::IsDisabledForEvents(EventMessage aMessage)
+{
+  nsIFormControlFrame* formControlFrame = GetFormControlFrame(false);
+  nsIFrame* formFrame = do_QueryFrame(formControlFrame);
+  return IsElementDisabledForEvents(aMessage, formFrame);
+}
+
+nsresult
+HTMLTextAreaElement::PreHandleEvent(EventChainPreVisitor& aVisitor)
+{
+  aVisitor.mCanHandle = false;
+  if (IsDisabledForEvents(aVisitor.mEvent->mMessage)) {
+    return NS_OK;
+  }
+
+  // Don't dispatch a second select event if we are already handling
+  // one.
+  if (aVisitor.mEvent->mMessage == eFormSelect) {
+    if (mHandlingSelect) {
+      return NS_OK;
+    }
+    mHandlingSelect = true;
+  }
+
+  // If noContentDispatch is true we will not allow content to handle
+  // this event.  But to allow middle mouse button paste to work we must allow 
+  // middle clicks to go to text fields anyway.
+  if (aVisitor.mEvent->mFlags.mNoContentDispatch) {
+    aVisitor.mItemFlags |= NS_NO_CONTENT_DISPATCH;
+  }
+  if (aVisitor.mEvent->mMessage == eMouseClick &&
+      aVisitor.mEvent->AsMouseEvent()->button ==
+        WidgetMouseEvent::eMiddleButton) {
+    aVisitor.mEvent->mFlags.mNoContentDispatch = false;
+  }
+
+  // Fire onchange (if necessary), before we do the blur, bug 370521.
+  if (aVisitor.mEvent->mMessage == eBlur) {
+    FireChangeEventIfNeeded();
+  }
+
+  return nsGenericHTMLFormElementWithState::PreHandleEvent(aVisitor);
+}
+
+void
+HTMLTextAreaElement::FireChangeEventIfNeeded()
+{
+  nsString value;
+  GetValueInternal(value, true);
+
+  if (mFocusedValue.Equals(value)) {
+    return;
+  }
+
+  // Dispatch the change event.
+  mFocusedValue = value;
+  nsContentUtils::DispatchTrustedEvent(OwnerDoc(),
+                                       static_cast<nsIContent*>(this),
+                                       NS_LITERAL_STRING("change"), true,
+                                       false);
+}
+
+nsresult
+HTMLTextAreaElement::PostHandleEvent(EventChainPostVisitor& aVisitor)
+{
+  if (aVisitor.mEvent->mMessage == eFormSelect) {
+    mHandlingSelect = false;
+  }
+
+  if (aVisitor.mEvent->mMessage == eFocus ||
+      aVisitor.mEvent->mMessage == eBlur) {
+    if (aVisitor.mEvent->mMessage == eFocus) {
+      // If the invalid UI is shown, we should show it while focusing (and
+      // update). Otherwise, we should not.
+      GetValueInternal(mFocusedValue, true);
+      mCanShowInvalidUI = !IsValid() && ShouldShowValidityUI();
+
+      // If neither invalid UI nor valid UI is shown, we shouldn't show the valid
+      // UI while typing.
+      mCanShowValidUI = ShouldShowValidityUI();
+    } else { // eBlur
+      mCanShowInvalidUI = true;
+      mCanShowValidUI = true;
+    }
+
+    UpdateState(true);
+  }
+
+  // Reset the flag for other content besides this text field
+  aVisitor.mEvent->mFlags.mNoContentDispatch =
+    ((aVisitor.mItemFlags & NS_NO_CONTENT_DISPATCH) != 0);
+
+  return NS_OK;
+}
+
+void
+HTMLTextAreaElement::DoneAddingChildren(bool aHaveNotified)
+{
+  if (!mValueChanged) {
+    if (!mDoneAddingChildren) {
+      // Reset now that we're done adding children if the content sink tried to
+      // sneak some text in without calling AppendChildTo.
+      Reset();
+    }
+
+    if (!mInhibitStateRestoration) {
+      nsresult rv = GenerateStateKey();
+      if (NS_SUCCEEDED(rv)) {
+        RestoreFormControlState();
+      }
+    }
+  }
+
+  mDoneAddingChildren = true;
+}
+
+bool
+HTMLTextAreaElement::IsDoneAddingChildren()
+{
+  return mDoneAddingChildren;
+}
+
+// Controllers Methods
+
+nsIControllers*
+HTMLTextAreaElement::GetControllers(ErrorResult& aError)
+{
+  if (!mControllers)
+  {
+    nsresult rv;
+    mControllers = do_CreateInstance(kXULControllersCID, &rv);
+    if (NS_FAILED(rv)) {
+      aError.Throw(rv);
+      return nullptr;
+    }
+
+    nsCOMPtr<nsIController> controller = do_CreateInstance("@mozilla.org/editor/editorcontroller;1", &rv);
+    if (NS_FAILED(rv)) {
+      aError.Throw(rv);
+      return nullptr;
+    }
+
+    mControllers->AppendController(controller);
+
+    controller = do_CreateInstance("@mozilla.org/editor/editingcontroller;1", &rv);
+    if (NS_FAILED(rv)) {
+      aError.Throw(rv);
+      return nullptr;
+    }
+
+    mControllers->AppendController(controller);
+  }
+
+  return mControllers;
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::GetControllers(nsIControllers** aResult)
+{
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  ErrorResult error;
+  *aResult = GetControllers(error);
+  NS_IF_ADDREF(*aResult);
+
+  return error.StealNSResult();
+}
+
+uint32_t
+HTMLTextAreaElement::GetTextLength()
+{
+  nsAutoString val;
+  GetValue(val);
+  return val.Length();
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::GetTextLength(int32_t *aTextLength)
+{
+  NS_ENSURE_ARG_POINTER(aTextLength);
+  *aTextLength = GetTextLength();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::GetSelectionStart(int32_t *aSelectionStart)
+{
+  NS_ENSURE_ARG_POINTER(aSelectionStart);
+
+  ErrorResult error;
+  Nullable<uint32_t> selStart(GetSelectionStart(error));
+  if (error.Failed()) {
+    return error.StealNSResult();
+  }
+
+  *aSelectionStart = int32_t(selStart.Value());
+  return error.StealNSResult();
+}
+
+Nullable<uint32_t>
+HTMLTextAreaElement::GetSelectionStart(ErrorResult& aError)
+{
+  int32_t selStart, selEnd;
+  nsresult rv = GetSelectionRange(&selStart, &selEnd);
+
+  if (NS_FAILED(rv) && mState.IsSelectionCached()) {
+    return Nullable<uint32_t>(mState.GetSelectionProperties().GetStart());
+  }
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+  }
+  return Nullable<uint32_t>(selStart);
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::SetSelectionStart(int32_t aSelectionStart)
+{
+  ErrorResult error;
+  Nullable<uint32_t> selStart(aSelectionStart);
+  SetSelectionStart(selStart, error);
+  return error.StealNSResult();
+}
+
+void
+HTMLTextAreaElement::SetSelectionStart(const Nullable<uint32_t>& aSelectionStart,
+                                       ErrorResult& aError)
+{
+  int32_t selStart = 0;
+  if (!aSelectionStart.IsNull()) {
+    selStart = aSelectionStart.Value();
+  }
+
+  if (mState.IsSelectionCached()) {
+    mState.GetSelectionProperties().SetStart(selStart);
+    return;
+  }
+
+  nsAutoString direction;
+  nsresult rv = GetSelectionDirection(direction);
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+    return;
+  }
+  int32_t start, end;
+  rv = GetSelectionRange(&start, &end);
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+    return;
+  }
+  start = selStart;
+  if (end < start) {
+    end = start;
+  }
+  rv = SetSelectionRange(start, end, direction);
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+  }
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::GetSelectionEnd(int32_t *aSelectionEnd)
+{
+  NS_ENSURE_ARG_POINTER(aSelectionEnd);
+
+  ErrorResult error;
+  Nullable<uint32_t> selEnd(GetSelectionEnd(error));
+  if (error.Failed()) {
+    return error.StealNSResult();
+  }
+
+  *aSelectionEnd = int32_t(selEnd.Value());
+  return NS_OK;
+}
+
+Nullable<uint32_t>
+HTMLTextAreaElement::GetSelectionEnd(ErrorResult& aError)
+{
+  int32_t selStart, selEnd;
+  nsresult rv = GetSelectionRange(&selStart, &selEnd);
+
+  if (NS_FAILED(rv) && mState.IsSelectionCached()) {
+    return Nullable<uint32_t>(mState.GetSelectionProperties().GetEnd());
+  }
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+  }
+  return Nullable<uint32_t>(selEnd);
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::SetSelectionEnd(int32_t aSelectionEnd)
+{
+  ErrorResult error;
+  Nullable<uint32_t> selEnd(aSelectionEnd);
+  SetSelectionEnd(selEnd, error);
+  return error.StealNSResult();
+}
+
+void
+HTMLTextAreaElement::SetSelectionEnd(const Nullable<uint32_t>& aSelectionEnd,
+                                     ErrorResult& aError)
+{
+  int32_t selEnd = 0;
+  if (!aSelectionEnd.IsNull()) {
+    selEnd = aSelectionEnd.Value();
+  }
+
+  if (mState.IsSelectionCached()) {
+    mState.GetSelectionProperties().SetEnd(selEnd);
+    return;
+  }
+
+  nsAutoString direction;
+  nsresult rv = GetSelectionDirection(direction);
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+    return;
+  }
+  int32_t start, end;
+  rv = GetSelectionRange(&start, &end);
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+    return;
+  }
+  end = selEnd;
+  if (start > end) {
+    start = end;
+  }
+  rv = SetSelectionRange(start, end, direction);
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+  }
+}
+
+nsresult
+HTMLTextAreaElement::GetSelectionRange(int32_t* aSelectionStart,
+                                       int32_t* aSelectionEnd)
+{
+  nsIFormControlFrame* formControlFrame = GetFormControlFrame(true);
+  nsITextControlFrame* textControlFrame = do_QueryFrame(formControlFrame);
+  if (textControlFrame) {
+    return textControlFrame->GetSelectionRange(aSelectionStart, aSelectionEnd);
+  }
+
+  return NS_ERROR_FAILURE;
+}
+
+static void
+DirectionToName(nsITextControlFrame::SelectionDirection dir, nsAString& aDirection)
+{
+  if (dir == nsITextControlFrame::eNone) {
+    aDirection.AssignLiteral("none");
+  } else if (dir == nsITextControlFrame::eForward) {
+    aDirection.AssignLiteral("forward");
+  } else if (dir == nsITextControlFrame::eBackward) {
+    aDirection.AssignLiteral("backward");
+  } else {
+    NS_NOTREACHED("Invalid SelectionDirection value");
+  }
+}
+
+nsresult
+HTMLTextAreaElement::GetSelectionDirection(nsAString& aDirection)
+{
+  ErrorResult error;
+  GetSelectionDirection(aDirection, error);
+  return error.StealNSResult();
+}
+
+void
+HTMLTextAreaElement::GetSelectionDirection(nsAString& aDirection, ErrorResult& aError)
+{
+  nsresult rv = NS_ERROR_FAILURE;
+  nsIFormControlFrame* formControlFrame = GetFormControlFrame(true);
+  nsITextControlFrame* textControlFrame = do_QueryFrame(formControlFrame);
+  if (textControlFrame) {
+    nsITextControlFrame::SelectionDirection dir;
+    rv = textControlFrame->GetSelectionRange(nullptr, nullptr, &dir);
+    if (NS_SUCCEEDED(rv)) {
+      DirectionToName(dir, aDirection);
+    }
+  }
+
+  if (NS_FAILED(rv)) {
+    if (mState.IsSelectionCached()) {
+      DirectionToName(mState.GetSelectionProperties().GetDirection(), aDirection);
+      return;
+    }
+    aError.Throw(rv);
+  }
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::SetSelectionDirection(const nsAString& aDirection)
+{
+  ErrorResult error;
+  SetSelectionDirection(aDirection, error);
+  return error.StealNSResult();
+}
+
+void
+HTMLTextAreaElement::SetSelectionDirection(const nsAString& aDirection,
+                                           ErrorResult& aError)
+{
+  if (mState.IsSelectionCached()) {
+    nsITextControlFrame::SelectionDirection dir = nsITextControlFrame::eNone;
+    if (aDirection.EqualsLiteral("forward")) {
+      dir = nsITextControlFrame::eForward;
+    } else if (aDirection.EqualsLiteral("backward")) {
+      dir = nsITextControlFrame::eBackward;
+    }
+    mState.GetSelectionProperties().SetDirection(dir);
+    return;
+  }
+
+  int32_t start, end;
+  nsresult rv = GetSelectionRange(&start, &end);
+  if (NS_SUCCEEDED(rv)) {
+    rv = SetSelectionRange(start, end, aDirection);
+  }
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+  }
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::SetSelectionRange(int32_t aSelectionStart,
+                                       int32_t aSelectionEnd,
+                                       const nsAString& aDirection)
+{
+  ErrorResult error;
+  Optional<nsAString> dir;
+  dir = &aDirection;
+  SetSelectionRange(aSelectionStart, aSelectionEnd, dir, error);
+  return error.StealNSResult();
+}
+
+void
+HTMLTextAreaElement::SetSelectionRange(uint32_t aSelectionStart,
+                                       uint32_t aSelectionEnd,
+                                       const Optional<nsAString>& aDirection,
+                                       ErrorResult& aError)
+{
+  nsresult rv = NS_ERROR_FAILURE;
+  nsIFormControlFrame* formControlFrame = GetFormControlFrame(true);
+  nsITextControlFrame* textControlFrame = do_QueryFrame(formControlFrame);
+  if (textControlFrame) {
+    // Default to forward, even if not specified.
+    // Note that we don't currently support directionless selections, so
+    // "none" is treated like "forward".
+    nsITextControlFrame::SelectionDirection dir = nsITextControlFrame::eForward;
+    if (aDirection.WasPassed() && aDirection.Value().EqualsLiteral("backward")) {
+      dir = nsITextControlFrame::eBackward;
+    }
+
+    rv = textControlFrame->SetSelectionRange(aSelectionStart, aSelectionEnd, dir);
+    if (NS_SUCCEEDED(rv)) {
+      rv = textControlFrame->ScrollSelectionIntoView();
+      RefPtr<AsyncEventDispatcher> asyncDispatcher =
+        new AsyncEventDispatcher(this, NS_LITERAL_STRING("select"),
+                                 true, false);
+      asyncDispatcher->PostDOMEvent();
+    }
+  }
+
+  if (NS_FAILED(rv)) {
+    aError.Throw(rv);
+  }
+}
+
+void
+HTMLTextAreaElement::SetRangeText(const nsAString& aReplacement,
+                                  ErrorResult& aRv)
+{
+  int32_t start, end;
+  aRv = GetSelectionRange(&start, &end);
+  if (aRv.Failed()) {
+    if (mState.IsSelectionCached()) {
+      start = mState.GetSelectionProperties().GetStart();
+      end = mState.GetSelectionProperties().GetEnd();
+      aRv = NS_OK;
+    }
+  }
+
+  SetRangeText(aReplacement, start, end, mozilla::dom::SelectionMode::Preserve,
+               aRv, start, end);
+}
+
+void
+HTMLTextAreaElement::SetRangeText(const nsAString& aReplacement,
+                                  uint32_t aStart, uint32_t aEnd,
+                                  const SelectionMode& aSelectMode,
+                                  ErrorResult& aRv, int32_t aSelectionStart,
+                                  int32_t aSelectionEnd)
+{
+  if (aStart > aEnd) {
+    aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
+    return;
+  }
+
+  nsAutoString value;
+  GetValueInternal(value, false);
+  uint32_t inputValueLength = value.Length();
+
+  if (aStart > inputValueLength) {
+    aStart = inputValueLength;
+  }
+
+  if (aEnd > inputValueLength) {
+    aEnd = inputValueLength;
+  }
+
+  if (aSelectionStart == -1 && aSelectionEnd == -1) {
+    aRv = GetSelectionRange(&aSelectionStart, &aSelectionEnd);
+    if (aRv.Failed()) {
+      if (mState.IsSelectionCached()) {
+        aSelectionStart = mState.GetSelectionProperties().GetStart();
+        aSelectionEnd = mState.GetSelectionProperties().GetEnd();
+        aRv = NS_OK;
+      }
+    }
+  }
+
+  if (aStart <= aEnd) {
+    value.Replace(aStart, aEnd - aStart, aReplacement);
+    nsresult rv =
+      SetValueInternal(value, nsTextEditorState::eSetValue_ByContent);
+    if (NS_FAILED(rv)) {
+      aRv.Throw(rv);
+      return;
+    }
+  }
+
+  uint32_t newEnd = aStart + aReplacement.Length();
+  int32_t delta =  aReplacement.Length() - (aEnd - aStart);
+
+  switch (aSelectMode) {
+    case mozilla::dom::SelectionMode::Select:
+    {
+      aSelectionStart = aStart;
+      aSelectionEnd = newEnd;
+    }
+    break;
+    case mozilla::dom::SelectionMode::Start:
+    {
+      aSelectionStart = aSelectionEnd = aStart;
+    }
+    break;
+    case mozilla::dom::SelectionMode::End:
+    {
+      aSelectionStart = aSelectionEnd = newEnd;
+    }
+    break;
+    case mozilla::dom::SelectionMode::Preserve:
+    {
+      if ((uint32_t)aSelectionStart > aEnd) {
+        aSelectionStart += delta;
+      } else if ((uint32_t)aSelectionStart > aStart) {
+        aSelectionStart = aStart;
+      }
+
+      if ((uint32_t)aSelectionEnd > aEnd) {
+        aSelectionEnd += delta;
+      } else if ((uint32_t)aSelectionEnd > aStart) {
+        aSelectionEnd = newEnd;
+      }
+    }
+    break;
+    default:
+      MOZ_CRASH("Unknown mode!");
+  }
+
+  Optional<nsAString> direction;
+  SetSelectionRange(aSelectionStart, aSelectionEnd, direction, aRv);
+}
+
+nsresult
+HTMLTextAreaElement::Reset()
+{
+  nsresult rv;
+
+  // To get the initial spellchecking, reset value to
+  // empty string before setting the default value.
+  rv = SetValue(EmptyString());
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsAutoString resetVal;
+  GetDefaultValue(resetVal);
+  rv = SetValue(resetVal);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  SetValueChanged(false);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::SubmitNamesValues(HTMLFormSubmission* aFormSubmission)
+{
+  // Disabled elements don't submit
+  if (IsDisabled()) {
+    return NS_OK;
+  }
+
+  //
+  // Get the name (if no name, no submit)
+  //
+  nsAutoString name;
+  GetAttr(kNameSpaceID_None, nsGkAtoms::name, name);
+  if (name.IsEmpty()) {
+    return NS_OK;
+  }
+
+  //
+  // Get the value
+  //
+  nsAutoString value;
+  GetValueInternal(value, false);
+
+  //
+  // Submit
+  //
+  return aFormSubmission->AddNameValuePair(name, value);
+}
+
+NS_IMETHODIMP
+HTMLTextAreaElement::SaveState()
+{
+  nsresult rv = NS_OK;
+
+  // Only save if value != defaultValue (bug 62713)
+  nsPresState *state = nullptr;
+  if (mValueChanged) {
+    state = GetPrimaryPresState();
+    if (state) {
+      nsAutoString value;
+      GetValueInternal(value, true);
+
+      rv = nsLinebreakConverter::ConvertStringLineBreaks(
+               value,
+               nsLinebreakConverter::eLinebreakPlatform,
+               nsLinebreakConverter::eLinebreakContent);
+
+      if (NS_FAILED(rv)) {
+        NS_ERROR("Converting linebreaks failed!");
+        return rv;
+      }
+
+      nsCOMPtr<nsISupportsString> pState =
+        do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID);
+      if (!pState) {
+        return NS_ERROR_OUT_OF_MEMORY;
+      }
+      pState->SetData(value);
+      state->SetStateProperty(pState);
+    }
+  }
+
+  if (mDisabledChanged) {
+    if (!state) {
+      state = GetPrimaryPresState();
+      rv = NS_OK;
+    }
+    if (state) {
+      // We do not want to save the real disabled state but the disabled
+      // attribute.
+      state->SetDisabled(HasAttr(kNameSpaceID_None, nsGkAtoms::disabled));
+    }
+  }
+  return rv;
+}
+
+bool
+HTMLTextAreaElement::RestoreState(nsPresState* aState)
+{
+  nsCOMPtr<nsISupportsString> state
+    (do_QueryInterface(aState->GetStateProperty()));
+  
+  if (state) {
+    nsAutoString data;
+    state->GetData(data);
+    nsresult rv = SetValue(data);
+    NS_ENSURE_SUCCESS(rv, false);
+  }
+
+  if (aState->IsDisabledSet()) {
+    SetDisabled(aState->GetDisabled());
+  }
+
+  return false;
+}
+
+EventStates
+HTMLTextAreaElement::IntrinsicState() const
+{
+  EventStates state = nsGenericHTMLFormElementWithState::IntrinsicState();
+
+  if (HasAttr(kNameSpaceID_None, nsGkAtoms::required)) {
+    state |= NS_EVENT_STATE_REQUIRED;
+  } else {
+    state |= NS_EVENT_STATE_OPTIONAL;
+  }
+
+  if (IsCandidateForConstraintValidation()) {
+    if (IsValid()) {
+      state |= NS_EVENT_STATE_VALID;
+    } else {
+      state |= NS_EVENT_STATE_INVALID;
+      // :-moz-ui-invalid always apply if the element suffers from a custom
+      // error and never applies if novalidate is set on the form owner.
+      if ((!mForm || !mForm->HasAttr(kNameSpaceID_None, nsGkAtoms::novalidate)) &&
+          (GetValidityState(VALIDITY_STATE_CUSTOM_ERROR) ||
+           (mCanShowInvalidUI && ShouldShowValidityUI()))) {
+        state |= NS_EVENT_STATE_MOZ_UI_INVALID;
+      }
+    }
+
+    // :-moz-ui-valid applies if all the following are true:
+    // 1. The element is not focused, or had either :-moz-ui-valid or
+    //    :-moz-ui-invalid applying before it was focused ;
+    // 2. The element is either valid or isn't allowed to have
+    //    :-moz-ui-invalid applying ;
+    // 3. The element has no form owner or its form owner doesn't have the
+    //    novalidate attribute set ;
+    // 4. The element has already been modified or the user tried to submit the
+    //    form owner while invalid.
+    if ((!mForm || !mForm->HasAttr(kNameSpaceID_None, nsGkAtoms::novalidate)) &&
+        (mCanShowValidUI && ShouldShowValidityUI() &&
+         (IsValid() || (state.HasState(NS_EVENT_STATE_MOZ_UI_INVALID) &&
+                        !mCanShowInvalidUI)))) {
+      state |= NS_EVENT_STATE_MOZ_UI_VALID;
+    }
+  }
+
+  if (HasAttr(kNameSpaceID_None, nsGkAtoms::placeholder) &&
+      IsValueEmpty()) {
+    state |= NS_EVENT_STATE_PLACEHOLDERSHOWN;
+  }
+
+  return state;
+}
+
+nsresult
+HTMLTextAreaElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
+                                nsIContent* aBindingParent,
+                                bool aCompileEventHandlers)
+{
+  nsresult rv = nsGenericHTMLFormElementWithState::BindToTree(aDocument, aParent,
+                                                              aBindingParent,
+                                                              aCompileEventHandlers);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // If there is a disabled fieldset in the parent chain, the element is now
+  // barred from constraint validation and can't suffer from value missing.
+  UpdateValueMissingValidityState();
+  UpdateBarredFromConstraintValidation();
+
+  // And now make sure our state is up to date
+  UpdateState(false);
+
+  return rv;
+}
+
+void
+HTMLTextAreaElement::UnbindFromTree(bool aDeep, bool aNullParent)
+{
+  nsGenericHTMLFormElementWithState::UnbindFromTree(aDeep, aNullParent);
+
+  // We might be no longer disabled because of parent chain changed.
+  UpdateValueMissingValidityState();
+  UpdateBarredFromConstraintValidation();
+
+  // And now make sure our state is up to date
+  UpdateState(false);
+}
+
+nsresult
+HTMLTextAreaElement::BeforeSetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+                                   nsAttrValueOrString* aValue,
+                                   bool aNotify)
+{
+  if (aNotify && aName == nsGkAtoms::disabled &&
+      aNameSpaceID == kNameSpaceID_None) {
+    mDisabledChanged = true;
+  }
+
+  return nsGenericHTMLFormElementWithState::BeforeSetAttr(aNameSpaceID, aName,
+                                                 aValue, aNotify);
+}
+
+void
+HTMLTextAreaElement::CharacterDataChanged(nsIDocument* aDocument,
+                                          nsIContent* aContent,
+                                          CharacterDataChangeInfo* aInfo)
+{
+  ContentChanged(aContent);
+}
+
+void
+HTMLTextAreaElement::ContentAppended(nsIDocument* aDocument,
+                                     nsIContent* aContainer,
+                                     nsIContent* aFirstNewContent,
+                                     int32_t /* unused */)
+{
+  ContentChanged(aFirstNewContent);
+}
+
+void
+HTMLTextAreaElement::ContentInserted(nsIDocument* aDocument,
+                                     nsIContent* aContainer,
+                                     nsIContent* aChild,
+                                     int32_t /* unused */)
+{
+  ContentChanged(aChild);
+}
+
+void
+HTMLTextAreaElement::ContentRemoved(nsIDocument* aDocument,
+                                    nsIContent* aContainer,
+                                    nsIContent* aChild,
+                                    int32_t aIndexInContainer,
+                                    nsIContent* aPreviousSibling)
+{
+  ContentChanged(aChild);
+}
+
+void
+HTMLTextAreaElement::ContentChanged(nsIContent* aContent)
+{
+  if (!mValueChanged && mDoneAddingChildren &&
+      nsContentUtils::IsInSameAnonymousTree(this, aContent)) {
+    // Hard to say what the reset can trigger, so be safe pending
+    // further auditing.
+    nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
+    Reset();
+  }
+}
+
+nsresult
+HTMLTextAreaElement::AfterSetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+                                  const nsAttrValue* aValue, bool aNotify)
+{
+  if (aNameSpaceID == kNameSpaceID_None) {
+    if (aName == nsGkAtoms::required || aName == nsGkAtoms::disabled ||
+        aName == nsGkAtoms::readonly) {
+      UpdateValueMissingValidityState();
+
+      // This *has* to be called *after* validity has changed.
+      if (aName == nsGkAtoms::readonly || aName == nsGkAtoms::disabled) {
+        UpdateBarredFromConstraintValidation();
+      }
+    } else if (aName == nsGkAtoms::maxlength) {
+      UpdateTooLongValidityState();
+    } else if (aName == nsGkAtoms::minlength) {
+      UpdateTooShortValidityState();
+    }
+
+    UpdateState(aNotify);
+  }
+
+  return nsGenericHTMLFormElementWithState::AfterSetAttr(aNameSpaceID, aName, aValue,
+                                                         aNotify);
+  }
+
+nsresult
+HTMLTextAreaElement::CopyInnerTo(Element* aDest)
+{
+  nsresult rv = nsGenericHTMLFormElementWithState::CopyInnerTo(aDest);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aDest->OwnerDoc()->IsStaticDocument()) {
+    nsAutoString value;
+    GetValueInternal(value, true);
+    return static_cast<HTMLTextAreaElement*>(aDest)->SetValue(value);
+  }
+  return NS_OK;
+}
+
+bool
+HTMLTextAreaElement::IsMutable() const
+{
+  return (!HasAttr(kNameSpaceID_None, nsGkAtoms::readonly) && !IsDisabled());
+}
+
+bool
+HTMLTextAreaElement::IsValueEmpty() const
+{
+  nsAutoString value;
+  GetValueInternal(value, true);
+
+  return value.IsEmpty();
+}
+
+// nsIConstraintValidation
+
+NS_IMETHODIMP
+HTMLTextAreaElement::SetCustomValidity(const nsAString& aError)
+{
+  nsIConstraintValidation::SetCustomValidity(aError);
+
+  UpdateState(true);
+
+  return NS_OK;
+}
+
+bool
+HTMLTextAreaElement::IsTooLong()
+{
+  if (!mValueChanged ||
+      !mLastValueChangeWasInteractive ||
+      !HasAttr(kNameSpaceID_None, nsGkAtoms::maxlength)) {
+    return false;
+  }
+
+  int32_t maxLength = -1;
+  GetMaxLength(&maxLength);
+
+  // Maxlength of -1 means parsing error.
+  if (maxLength == -1) {
+    return false;
+  }
+
+  int32_t textLength = -1;
+  GetTextLength(&textLength);
+
+  return textLength > maxLength;
+}
+
+bool
+HTMLTextAreaElement::IsTooShort()
+{
+  if (!mValueChanged ||
+      !mLastValueChangeWasInteractive ||
+      !HasAttr(kNameSpaceID_None, nsGkAtoms::minlength)) {
+    return false;
+  }
+
+  int32_t minLength = -1;
+  GetMinLength(&minLength);
+
+  // Minlength of -1 means parsing error.
+  if (minLength == -1) {
+    return false;
+  }
+
+  int32_t textLength = -1;
+  GetTextLength(&textLength);
+
+  return textLength && textLength < minLength;
+}
+
+bool
+HTMLTextAreaElement::IsValueMissing() const
+{
+  if (!HasAttr(kNameSpaceID_None, nsGkAtoms::required) || !IsMutable()) {
+    return false;
+  }
+
+  return IsValueEmpty();
+}
+
+void
+HTMLTextAreaElement::UpdateTooLongValidityState()
+{
+  SetValidityState(VALIDITY_STATE_TOO_LONG, IsTooLong());
+}
+
+void
+HTMLTextAreaElement::UpdateTooShortValidityState()
+{
+  SetValidityState(VALIDITY_STATE_TOO_SHORT, IsTooShort());
+}
+
+void
+HTMLTextAreaElement::UpdateValueMissingValidityState()
+{
+  SetValidityState(VALIDITY_STATE_VALUE_MISSING, IsValueMissing());
+}
+
+void
+HTMLTextAreaElement::UpdateBarredFromConstraintValidation()
+{
+  SetBarredFromConstraintValidation(HasAttr(kNameSpaceID_None,
+                                            nsGkAtoms::readonly) ||
+                                    IsDisabled());
+}
+
+nsresult
+HTMLTextAreaElement::GetValidationMessage(nsAString& aValidationMessage,
+                                          ValidityStateType aType)
+{
+  nsresult rv = NS_OK;
+
+  switch (aType)
+  {
+    case VALIDITY_STATE_TOO_LONG:
+      {
+        nsXPIDLString message;
+        int32_t maxLength = -1;
+        int32_t textLength = -1;
+        nsAutoString strMaxLength;
+        nsAutoString strTextLength;
+
+        GetMaxLength(&maxLength);
+        GetTextLength(&textLength);
+
+        strMaxLength.AppendInt(maxLength);
+        strTextLength.AppendInt(textLength);
+
+        const char16_t* params[] = { strMaxLength.get(), strTextLength.get() };
+        rv = nsContentUtils::FormatLocalizedString(nsContentUtils::eDOM_PROPERTIES,
+                                                   "FormValidationTextTooLong",
+                                                   params, message);
+        aValidationMessage = message;
+      }
+      break;
+    case VALIDITY_STATE_TOO_SHORT:
+      {
+        nsXPIDLString message;
+        int32_t minLength = -1;
+        int32_t textLength = -1;
+        nsAutoString strMinLength;
+        nsAutoString strTextLength;
+
+        GetMinLength(&minLength);
+        GetTextLength(&textLength);
+
+        strMinLength.AppendInt(minLength);
+        strTextLength.AppendInt(textLength);
+
+        const char16_t* params[] = { strMinLength.get(), strTextLength.get() };
+        rv = nsContentUtils::FormatLocalizedString(nsContentUtils::eDOM_PROPERTIES,
+                                                   "FormValidationTextTooShort",
+                                                   params, message);
+        aValidationMessage = message;
+      }
+      break;
+    case VALIDITY_STATE_VALUE_MISSING:
+      {
+        nsXPIDLString message;
+        rv = nsContentUtils::GetLocalizedString(nsContentUtils::eDOM_PROPERTIES,
+                                                "FormValidationValueMissing",
+                                                message);
+        aValidationMessage = message;
+      }
+      break;
+    default:
+      rv = nsIConstraintValidation::GetValidationMessage(aValidationMessage, aType);
+  }
+
+  return rv;
+}
+
+NS_IMETHODIMP_(bool)
+HTMLTextAreaElement::IsSingleLineTextControl() const
+{
+  return false;
+}
+
+NS_IMETHODIMP_(bool)
+HTMLTextAreaElement::IsTextArea() const
+{
+  return true;
+}
+
+NS_IMETHODIMP_(bool)
+HTMLTextAreaElement::IsPlainTextControl() const
+{
+  // need to check our HTML attribute and/or CSS.
+  return true;
+}
+
+NS_IMETHODIMP_(bool)
+HTMLTextAreaElement::IsPasswordTextControl() const
+{
+  return false;
+}
+
+NS_IMETHODIMP_(int32_t)
+HTMLTextAreaElement::GetCols()
+{
+  return Cols();
+}
+
+NS_IMETHODIMP_(int32_t)
+HTMLTextAreaElement::GetWrapCols()
+{
+  // wrap=off means -1 for wrap width no matter what cols is
+  nsHTMLTextWrap wrapProp;
+  nsITextControlElement::GetWrapPropertyEnum(this, wrapProp);
+  if (wrapProp == nsITextControlElement::eHTMLTextWrap_Off) {
+    // do not wrap when wrap=off
+    return 0;
+  }
+
+  // Otherwise we just wrap at the given number of columns
+  return GetCols();
+}
+
+
+NS_IMETHODIMP_(int32_t)
+HTMLTextAreaElement::GetRows()
+{
+  const nsAttrValue* attr = GetParsedAttr(nsGkAtoms::rows);
+  if (attr && attr->Type() == nsAttrValue::eInteger) {
+    int32_t rows = attr->GetIntegerValue();
+    return (rows <= 0) ? DEFAULT_ROWS_TEXTAREA : rows;
+  }
+
+  return DEFAULT_ROWS_TEXTAREA;
+}
+
+NS_IMETHODIMP_(void)
+HTMLTextAreaElement::GetDefaultValueFromContent(nsAString& aValue)
+{
+  GetDefaultValue(aValue);
+}
+
+NS_IMETHODIMP_(bool)
+HTMLTextAreaElement::ValueChanged() const
+{
+  return mValueChanged;
+}
+
+NS_IMETHODIMP_(void)
+HTMLTextAreaElement::GetTextEditorValue(nsAString& aValue,
+                                        bool aIgnoreWrap) const
+{
+  mState.GetValue(aValue, aIgnoreWrap);
+}
+
+NS_IMETHODIMP_(void)
+HTMLTextAreaElement::InitializeKeyboardEventListeners()
+{
+  mState.InitializeKeyboardEventListeners();
+}
+
+NS_IMETHODIMP_(void)
+HTMLTextAreaElement::OnValueChanged(bool aNotify, bool aWasInteractiveUserChange)
+{
+  mLastValueChangeWasInteractive = aWasInteractiveUserChange;
+
+  // Update the validity state
+  bool validBefore = IsValid();
+  UpdateTooLongValidityState();
+  UpdateTooShortValidityState();
+  UpdateValueMissingValidityState();
+
+  if (validBefore != IsValid() ||
+      HasAttr(kNameSpaceID_None, nsGkAtoms::placeholder)) {
+    UpdateState(aNotify);
+  }
+}
+
+NS_IMETHODIMP_(bool)
+HTMLTextAreaElement::HasCachedSelection()
+{
+  return mState.IsSelectionCached();
+}
+
+void
+HTMLTextAreaElement::FieldSetDisabledChanged(bool aNotify)
+{
+  UpdateValueMissingValidityState();
+  UpdateBarredFromConstraintValidation();
+
+  nsGenericHTMLFormElementWithState::FieldSetDisabledChanged(aNotify);
+}
+
+JSObject*
+HTMLTextAreaElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+  return HTMLTextAreaElementBinding::Wrap(aCx, this, aGivenProto);
+}
+
+} // namespace dom
+} // namespace mozilla