Add m-esr52 at 52.6.0

1 files changed, 3032 insertions, 0 deletions

diff --git a/dom/html/nsGenericHTMLElement.cpp b/dom/html/nsGenericHTMLElement.cpp
new file mode 100644
index 000000000..d75001a83
--- /dev/null
+++ b/dom/html/nsGenericHTMLElement.cpp
@@ -0,0 +1,3032 @@
+/* -*- 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/ArrayUtils.h"
+#include "mozilla/DeclarationBlockInlines.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/EventStates.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/Likely.h"
+
+#include "nscore.h"
+#include "nsGenericHTMLElement.h"
+#include "nsAttrValueInlines.h"
+#include "nsCOMPtr.h"
+#include "nsIAtom.h"
+#include "nsQueryObject.h"
+#include "nsIContentInlines.h"
+#include "nsIContentViewer.h"
+#include "mozilla/css/Declaration.h"
+#include "nsIDocument.h"
+#include "nsIDocumentEncoder.h"
+#include "nsIDOMHTMLDocument.h"
+#include "nsIDOMAttr.h"
+#include "nsIDOMDocumentFragment.h"
+#include "nsIDOMHTMLElement.h"
+#include "nsIDOMHTMLMenuElement.h"
+#include "nsIDOMWindow.h"
+#include "nsIDOMDocument.h"
+#include "nsMappedAttributes.h"
+#include "nsHTMLStyleSheet.h"
+#include "nsIHTMLDocument.h"
+#include "nsPIDOMWindow.h"
+#include "nsIURL.h"
+#include "nsEscape.h"
+#include "nsIFrameInlines.h"
+#include "nsIScrollableFrame.h"
+#include "nsView.h"
+#include "nsViewManager.h"
+#include "nsIWidget.h"
+#include "nsRange.h"
+#include "nsIPresShell.h"
+#include "nsPresContext.h"
+#include "nsIDocShell.h"
+#include "nsNameSpaceManager.h"
+#include "nsError.h"
+#include "nsScriptLoader.h"
+#include "nsRuleData.h"
+#include "nsIPrincipal.h"
+#include "nsContainerFrame.h"
+#include "nsStyleUtil.h"
+
+#include "nsPresState.h"
+#include "nsILayoutHistoryState.h"
+
+#include "nsHTMLParts.h"
+#include "nsContentUtils.h"
+#include "mozilla/dom/DirectionalityUtils.h"
+#include "nsString.h"
+#include "nsUnicharUtils.h"
+#include "nsGkAtoms.h"
+#include "nsIDOMEvent.h"
+#include "nsDOMCSSDeclaration.h"
+#include "nsITextControlFrame.h"
+#include "nsIForm.h"
+#include "nsIFormControl.h"
+#include "nsIDOMHTMLFormElement.h"
+#include "mozilla/dom/HTMLFormElement.h"
+#include "nsFocusManager.h"
+#include "nsAttrValueOrString.h"
+
+#include "mozilla/InternalMutationEvent.h"
+#include "nsDOMStringMap.h"
+
+#include "nsIEditor.h"
+#include "nsIEditorIMESupport.h"
+#include "nsLayoutUtils.h"
+#include "mozAutoDocUpdate.h"
+#include "nsHtml5Module.h"
+#include "nsITextControlElement.h"
+#include "mozilla/dom/Element.h"
+#include "HTMLFieldSetElement.h"
+#include "nsTextNode.h"
+#include "HTMLBRElement.h"
+#include "HTMLMenuElement.h"
+#include "nsDOMMutationObserver.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/FromParser.h"
+#include "mozilla/dom/Link.h"
+#include "mozilla/BloomFilter.h"
+
+#include "nsVariant.h"
+#include "nsDOMTokenList.h"
+#include "nsThreadUtils.h"
+#include "nsTextFragment.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/TouchEvent.h"
+#include "mozilla/ErrorResult.h"
+#include "nsHTMLDocument.h"
+#include "nsGlobalWindow.h"
+#include "mozilla/dom/HTMLBodyElement.h"
+#include "imgIContainer.h"
+#include "nsComputedDOMStyle.h"
+#include "mozilla/StyleSetHandle.h"
+#include "mozilla/StyleSetHandleInlines.h"
+#include "ReferrerPolicy.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+/**
+ * nsAutoFocusEvent is used to dispatch a focus event when a
+ * nsGenericHTMLFormElement is binded to the tree with the autofocus attribute
+ * enabled.
+ */
+class nsAutoFocusEvent : public Runnable
+{
+public:
+  explicit nsAutoFocusEvent(nsGenericHTMLFormElement* aElement) : mElement(aElement) {}
+
+  NS_IMETHOD Run() override {
+    nsFocusManager* fm = nsFocusManager::GetFocusManager();
+    if (!fm) {
+      return NS_ERROR_NULL_POINTER;
+    }
+
+    nsIDocument* document = mElement->OwnerDoc();
+
+    nsPIDOMWindowOuter* window = document->GetWindow();
+    if (!window) {
+      return NS_OK;
+    }
+
+    // Trying to found the top window (equivalent to window.top).
+    if (nsCOMPtr<nsPIDOMWindowOuter> top = window->GetTop()) {
+      window = top;
+    }
+
+    if (window->GetFocusedNode()) {
+      return NS_OK;
+    }
+
+    nsCOMPtr<nsIDocument> topDoc = window->GetExtantDoc();
+    if (topDoc && topDoc->GetReadyStateEnum() == nsIDocument::READYSTATE_COMPLETE) {
+      return NS_OK;
+    }
+
+    // If something is focused in the same document, ignore autofocus.
+    if (!fm->GetFocusedContent() ||
+        fm->GetFocusedContent()->OwnerDoc() != document) {
+      mozilla::ErrorResult rv;
+      mElement->Focus(rv);
+      return rv.StealNSResult();
+    }
+
+    return NS_OK;
+  }
+private:
+  // NOTE: nsGenericHTMLFormElement is saved as a nsGenericHTMLElement
+  // because AddRef/Release are ambiguous with nsGenericHTMLFormElement
+  // and Focus() is declared (and defined) in nsGenericHTMLElement class.
+  RefPtr<nsGenericHTMLElement> mElement;
+};
+
+NS_IMPL_ADDREF_INHERITED(nsGenericHTMLElement, nsGenericHTMLElementBase)
+NS_IMPL_RELEASE_INHERITED(nsGenericHTMLElement, nsGenericHTMLElementBase)
+
+NS_INTERFACE_MAP_BEGIN(nsGenericHTMLElement)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMHTMLElement)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMElement)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMNode)
+NS_INTERFACE_MAP_END_INHERITING(nsGenericHTMLElementBase)
+
+nsresult
+nsGenericHTMLElement::CopyInnerTo(Element* aDst)
+{
+  nsresult rv;
+  int32_t i, count = GetAttrCount();
+  for (i = 0; i < count; ++i) {
+    const nsAttrName *name = mAttrsAndChildren.AttrNameAt(i);
+    const nsAttrValue *value = mAttrsAndChildren.AttrAt(i);
+
+    nsAutoString valStr;
+    value->ToString(valStr);
+
+    if (name->Equals(nsGkAtoms::style, kNameSpaceID_None) &&
+        value->Type() == nsAttrValue::eCSSDeclaration) {
+      DeclarationBlock* decl = value->GetCSSDeclarationValue();
+      // We can't just set this as a string, because that will fail
+      // to reparse the string into style data until the node is
+      // inserted into the document.  Clone the Rule instead.
+      RefPtr<DeclarationBlock> declClone = decl->Clone();
+
+      rv = aDst->SetInlineStyleDeclaration(declClone, &valStr, false);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      continue;
+    }
+
+    rv = aDst->SetAttr(name->NamespaceID(), name->LocalName(),
+                       name->GetPrefix(), valStr, false);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsGenericHTMLElement::GetDataset(nsISupports** aDataset)
+{
+  *aDataset = Dataset().take();
+  return NS_OK;
+}
+
+static const nsAttrValue::EnumTable kDirTable[] = {
+  { "ltr", eDir_LTR },
+  { "rtl", eDir_RTL },
+  { "auto", eDir_Auto },
+  { nullptr, 0 }
+};
+
+void
+nsGenericHTMLElement::GetAccessKeyLabel(nsString& aLabel)
+{
+  nsAutoString suffix;
+  GetAccessKey(suffix);
+  if (!suffix.IsEmpty()) {
+    EventStateManager::GetAccessKeyLabelPrefix(this, aLabel);
+    aLabel.Append(suffix);
+  }
+}
+
+static bool IS_TABLE_CELL(nsIAtom* frameType) {
+  return nsGkAtoms::tableCellFrame == frameType ||
+    nsGkAtoms::bcTableCellFrame == frameType;
+}
+
+static bool
+IsOffsetParent(nsIFrame* aFrame)
+{
+  nsIAtom* frameType = aFrame->GetType();
+  
+  if (IS_TABLE_CELL(frameType) || frameType == nsGkAtoms::tableFrame) {
+    // Per the IDL for Element, only td, th, and table are acceptable offsetParents
+    // apart from body or positioned elements; we need to check the content type as
+    // well as the frame type so we ignore anonymous tables created by an element
+    // with display: table-cell with no actual table
+    nsIContent* content = aFrame->GetContent();
+
+    return content->IsAnyOfHTMLElements(nsGkAtoms::table,
+                                        nsGkAtoms::td,
+                                        nsGkAtoms::th);
+  }
+  return false;
+}
+
+Element*
+nsGenericHTMLElement::GetOffsetRect(CSSIntRect& aRect)
+{
+  aRect = CSSIntRect();
+
+  nsIFrame* frame = GetStyledFrame();
+  if (!frame) {
+    return nullptr;
+  }
+
+  nsIFrame* parent = frame->GetParent();
+  nsPoint origin(0, 0);
+
+  if (parent && parent->GetType() == nsGkAtoms::tableWrapperFrame &&
+      frame->GetType() == nsGkAtoms::tableFrame) {
+    origin = parent->GetPositionIgnoringScrolling();
+    parent = parent->GetParent();
+  }
+
+  nsIContent* offsetParent = nullptr;
+  Element* docElement = GetComposedDoc()->GetRootElement();
+  nsIContent* content = frame->GetContent();
+
+  if (content && (content->IsHTMLElement(nsGkAtoms::body) ||
+                  content == docElement)) {
+    parent = frame;
+  }
+  else {
+    const bool isPositioned = frame->IsAbsPosContainingBlock();
+    const bool isAbsolutelyPositioned = frame->IsAbsolutelyPositioned();
+    origin += frame->GetPositionIgnoringScrolling();
+
+    for ( ; parent ; parent = parent->GetParent()) {
+      content = parent->GetContent();
+
+      // Stop at the first ancestor that is positioned.
+      if (parent->IsAbsPosContainingBlock()) {
+        offsetParent = content;
+        break;
+      }
+
+      // Add the parent's origin to our own to get to the
+      // right coordinate system.
+      const bool isOffsetParent = !isPositioned && IsOffsetParent(parent);
+      if (!isAbsolutelyPositioned && !isOffsetParent) {
+        origin += parent->GetPositionIgnoringScrolling();
+      }
+
+      if (content) {
+        // If we've hit the document element, break here.
+        if (content == docElement) {
+          break;
+        }
+
+        // Break if the ancestor frame type makes it suitable as offset parent
+        // and this element is *not* positioned or if we found the body element.
+        if (isOffsetParent || content->IsHTMLElement(nsGkAtoms::body)) {
+          offsetParent = content;
+          break;
+        }
+      }
+    }
+
+    if (isAbsolutelyPositioned && !offsetParent) {
+      // If this element is absolutely positioned, but we don't have
+      // an offset parent it means this element is an absolutely
+      // positioned child that's not nested inside another positioned
+      // element, in this case the element's frame's parent is the
+      // frame for the HTML element so we fail to find the body in the
+      // parent chain. We want the offset parent in this case to be
+      // the body, so we just get the body element from the document.
+
+      nsCOMPtr<nsIDOMHTMLDocument> html_doc(do_QueryInterface(GetComposedDoc()));
+
+      if (html_doc) {
+        offsetParent = static_cast<nsHTMLDocument*>(html_doc.get())->GetBody();
+      }
+    }
+  }
+
+  // Subtract the parent border unless it uses border-box sizing.
+  if (parent &&
+      parent->StylePosition()->mBoxSizing != StyleBoxSizing::Border) {
+    const nsStyleBorder* border = parent->StyleBorder();
+    origin.x -= border->GetComputedBorderWidth(NS_SIDE_LEFT);
+    origin.y -= border->GetComputedBorderWidth(NS_SIDE_TOP);
+  }
+
+  // XXX We should really consider subtracting out padding for
+  // content-box sizing, but we should see what IE does....
+
+  // Get the union of all rectangles in this and continuation frames.
+  // It doesn't really matter what we use as aRelativeTo here, since
+  // we only care about the size. We just have to use something non-null.
+  nsRect rcFrame = nsLayoutUtils::GetAllInFlowRectsUnion(frame, frame);
+  rcFrame.MoveTo(origin);
+  aRect = CSSIntRect::FromAppUnitsRounded(rcFrame);
+
+  return offsetParent ? offsetParent->AsElement() : nullptr;
+}
+
+NS_IMETHODIMP
+nsGenericHTMLElement::InsertAdjacentHTML(const nsAString& aPosition,
+                                         const nsAString& aText)
+{
+  ErrorResult rv;
+  Element::InsertAdjacentHTML(aPosition, aText, rv);
+  return rv.StealNSResult();
+}
+
+bool
+nsGenericHTMLElement::Spellcheck()
+{
+  // Has the state has been explicitly set?
+  nsIContent* node;
+  for (node = this; node; node = node->GetParent()) {
+    if (node->IsHTMLElement()) {
+      static nsIContent::AttrValuesArray strings[] =
+        {&nsGkAtoms::_true, &nsGkAtoms::_false, nullptr};
+      switch (node->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::spellcheck,
+                                    strings, eCaseMatters)) {
+        case 0:                         // spellcheck = "true"
+          return true;
+        case 1:                         // spellcheck = "false"
+          return false;
+      }
+    }
+  }
+
+  // contenteditable/designMode are spellchecked by default
+  if (IsEditable()) {
+    return true;
+  }
+
+  // Is this a chrome element?
+  if (nsContentUtils::IsChromeDoc(OwnerDoc())) {
+    return false;                       // Not spellchecked by default
+  }
+
+  // Anything else that's not a form control is not spellchecked by default
+  nsCOMPtr<nsIFormControl> formControl = do_QueryObject(this);
+  if (!formControl) {
+    return false;                       // Not spellchecked by default
+  }
+
+  // Is this a multiline plaintext input?
+  int32_t controlType = formControl->GetType();
+  if (controlType == NS_FORM_TEXTAREA) {
+    return true;             // Spellchecked by default
+  }
+
+  // Is this anything other than an input text?
+  // Other inputs are not spellchecked.
+  if (controlType != NS_FORM_INPUT_TEXT) {
+    return false;                       // Not spellchecked by default
+  }
+
+  // Does the user want input text spellchecked by default?
+  // NOTE: Do not reflect a pref value of 0 back to the DOM getter.
+  // The web page should not know if the user has disabled spellchecking.
+  // We'll catch this in the editor itself.
+  int32_t spellcheckLevel = Preferences::GetInt("layout.spellcheckDefault", 1);
+  return spellcheckLevel == 2;           // "Spellcheck multi- and single-line"
+}
+
+bool
+nsGenericHTMLElement::InNavQuirksMode(nsIDocument* aDoc)
+{
+  return aDoc && aDoc->GetCompatibilityMode() == eCompatibility_NavQuirks;
+}
+
+void
+nsGenericHTMLElement::UpdateEditableState(bool aNotify)
+{
+  // XXX Should we do this only when in a document?
+  ContentEditableTristate value = GetContentEditableValue();
+  if (value != eInherit) {
+    DoSetEditableFlag(!!value, aNotify);
+    return;
+  }
+
+  nsStyledElement::UpdateEditableState(aNotify);
+}
+
+EventStates
+nsGenericHTMLElement::IntrinsicState() const
+{
+  EventStates state = nsGenericHTMLElementBase::IntrinsicState();
+
+  if (GetDirectionality() == eDir_RTL) {
+    state |= NS_EVENT_STATE_RTL;
+    state &= ~NS_EVENT_STATE_LTR;
+  } else { // at least for HTML, directionality is exclusively LTR or RTL
+    NS_ASSERTION(GetDirectionality() == eDir_LTR,
+                 "HTML element's directionality must be either RTL or LTR");
+    state |= NS_EVENT_STATE_LTR;
+    state &= ~NS_EVENT_STATE_RTL;
+  }
+
+  return state;
+}
+
+uint32_t
+nsGenericHTMLElement::EditableInclusiveDescendantCount()
+{
+  bool isEditable = IsInUncomposedDoc() && HasFlag(NODE_IS_EDITABLE) &&
+    GetContentEditableValue() == eTrue;
+  return EditableDescendantCount() + isEditable;
+}
+
+nsresult
+nsGenericHTMLElement::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
+                                 nsIContent* aBindingParent,
+                                 bool aCompileEventHandlers)
+{
+  nsresult rv = nsGenericHTMLElementBase::BindToTree(aDocument, aParent,
+                                                     aBindingParent,
+                                                     aCompileEventHandlers);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aDocument) {
+    RegAccessKey();
+    if (HasName()) {
+      aDocument->
+        AddToNameTable(this, GetParsedAttr(nsGkAtoms::name)->GetAtomValue());
+    }
+
+    if (HasFlag(NODE_IS_EDITABLE) && GetContentEditableValue() == eTrue) {
+      nsCOMPtr<nsIHTMLDocument> htmlDocument = do_QueryInterface(aDocument);
+      if (htmlDocument) {
+        htmlDocument->ChangeContentEditableCount(this, +1);
+      }
+    }
+  }
+
+  return rv;
+}
+
+void
+nsGenericHTMLElement::UnbindFromTree(bool aDeep, bool aNullParent)
+{
+  if (IsInUncomposedDoc()) {
+    UnregAccessKey();
+  }
+  
+  RemoveFromNameTable();
+
+  if (GetContentEditableValue() == eTrue) {
+    //XXXsmaug Fix this for Shadow DOM, bug 1066965.
+    nsCOMPtr<nsIHTMLDocument> htmlDocument = do_QueryInterface(GetUncomposedDoc());
+    if (htmlDocument) {
+      htmlDocument->ChangeContentEditableCount(this, -1);
+    }
+  }
+
+  nsStyledElement::UnbindFromTree(aDeep, aNullParent);
+}
+
+HTMLFormElement*
+nsGenericHTMLElement::FindAncestorForm(HTMLFormElement* aCurrentForm)
+{
+  NS_ASSERTION(!HasAttr(kNameSpaceID_None, nsGkAtoms::form) ||
+               IsHTMLElement(nsGkAtoms::img),
+               "FindAncestorForm should not be called if @form is set!");
+
+  // Make sure we don't end up finding a form that's anonymous from
+  // our point of view.
+  nsIContent* bindingParent = GetBindingParent();
+
+  nsIContent* content = this;
+  while (content != bindingParent && content) {
+    // If the current ancestor is a form, return it as our form
+    if (content->IsHTMLElement(nsGkAtoms::form)) {
+#ifdef DEBUG
+      if (!nsContentUtils::IsInSameAnonymousTree(this, content)) {
+        // It's possible that we started unbinding at |content| or
+        // some ancestor of it, and |content| and |this| used to all be
+        // anonymous.  Check for this the hard way.
+        for (nsIContent* child = this; child != content;
+             child = child->GetParent()) {
+          NS_ASSERTION(child->GetParent()->IndexOf(child) != -1,
+                       "Walked too far?");
+        }
+      }
+#endif
+      return static_cast<HTMLFormElement*>(content);
+    }
+
+    nsIContent *prevContent = content;
+    content = prevContent->GetParent();
+
+    if (!content && aCurrentForm) {
+      // We got to the root of the subtree we're in, and we're being removed
+      // from the DOM (the only time we get into this method with a non-null
+      // aCurrentForm).  Check whether aCurrentForm is in the same subtree.  If
+      // it is, we want to return aCurrentForm, since this case means that
+      // we're one of those inputs-in-a-table that have a hacked mForm pointer
+      // and a subtree containing both us and the form got removed from the
+      // DOM.
+      if (nsContentUtils::ContentIsDescendantOf(aCurrentForm, prevContent)) {
+        return aCurrentForm;
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+bool
+nsGenericHTMLElement::CheckHandleEventForAnchorsPreconditions(
+                        EventChainVisitor& aVisitor)
+{
+  NS_PRECONDITION(nsCOMPtr<Link>(do_QueryObject(this)),
+                  "should be called only when |this| implements |Link|");
+
+  if (!aVisitor.mPresContext) {
+    // We need a pres context to do link stuff. Some events (e.g. mutation
+    // events) don't have one.
+    // XXX: ideally, shouldn't we be able to do what we need without one?
+    return false; 
+  }
+
+  //Need to check if we hit an imagemap area and if so see if we're handling
+  //the event on that map or on a link farther up the tree.  If we're on a
+  //link farther up, do nothing.
+  nsCOMPtr<nsIContent> target = aVisitor.mPresContext->EventStateManager()->
+    GetEventTargetContent(aVisitor.mEvent);
+
+  return !target || !target->IsHTMLElement(nsGkAtoms::area) ||
+         IsHTMLElement(nsGkAtoms::area);
+}
+
+nsresult
+nsGenericHTMLElement::PreHandleEventForAnchors(EventChainPreVisitor& aVisitor)
+{
+  nsresult rv = nsGenericHTMLElementBase::PreHandleEvent(aVisitor);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!CheckHandleEventForAnchorsPreconditions(aVisitor)) {
+    return NS_OK;
+  }
+
+  return PreHandleEventForLinks(aVisitor);
+}
+
+nsresult
+nsGenericHTMLElement::PostHandleEventForAnchors(EventChainPostVisitor& aVisitor)
+{
+  if (!CheckHandleEventForAnchorsPreconditions(aVisitor)) {
+    return NS_OK;
+  }
+
+  return PostHandleEventForLinks(aVisitor);
+}
+
+bool
+nsGenericHTMLElement::IsHTMLLink(nsIURI** aURI) const
+{
+  NS_PRECONDITION(aURI, "Must provide aURI out param");
+
+  *aURI = GetHrefURIForAnchors().take();
+  // We promise out param is non-null if we return true, so base rv on it
+  return *aURI != nullptr;
+}
+
+already_AddRefed<nsIURI>
+nsGenericHTMLElement::GetHrefURIForAnchors() const
+{
+  // This is used by the three Link implementations and
+  // nsHTMLStyleElement.
+
+  // Get href= attribute (relative URI).
+
+  // We use the nsAttrValue's copy of the URI string to avoid copying.
+  nsCOMPtr<nsIURI> uri;
+  GetURIAttr(nsGkAtoms::href, nullptr, getter_AddRefs(uri));
+
+  return uri.forget();
+}
+
+nsresult
+nsGenericHTMLElement::AfterSetAttr(int32_t aNamespaceID, nsIAtom* aName,
+                                   const nsAttrValue* aValue, bool aNotify)
+{
+  if (aNamespaceID == kNameSpaceID_None) {
+    if (IsEventAttributeName(aName) && aValue) {
+      MOZ_ASSERT(aValue->Type() == nsAttrValue::eString,
+                 "Expected string value for script body");
+      nsresult rv = SetEventHandler(aName, aValue->GetStringValue());
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    else if (aNotify && aName == nsGkAtoms::spellcheck) {
+      SyncEditorsOnSubtree(this);
+    }
+    else if (aName == nsGkAtoms::dir) {
+      Directionality dir = eDir_LTR;
+      if (aValue && aValue->Type() == nsAttrValue::eEnum) {
+        SetHasValidDir();
+        Directionality dirValue = (Directionality)aValue->GetEnumValue();
+        if (dirValue == eDir_Auto) {
+          SetHasDirAuto();
+          ClearHasFixedDir();
+        } else {
+          dir = dirValue;
+          SetDirectionality(dir, aNotify);
+          ClearHasDirAuto();
+          SetHasFixedDir();
+        }
+      } else {
+        ClearHasValidDir();
+        ClearHasFixedDir();
+        if (NodeInfo()->Equals(nsGkAtoms::bdi)) {
+          SetHasDirAuto();
+        } else {
+          ClearHasDirAuto();
+          dir = RecomputeDirectionality(this, aNotify);
+        }
+      }
+      SetDirectionalityOnDescendants(this, dir, aNotify);
+    }
+  }
+
+  return nsGenericHTMLElementBase::AfterSetAttr(aNamespaceID, aName,
+                                                aValue, aNotify);
+}
+
+EventListenerManager*
+nsGenericHTMLElement::GetEventListenerManagerForAttr(nsIAtom* aAttrName,
+                                                     bool* aDefer)
+{
+  // Attributes on the body and frameset tags get set on the global object
+  if ((mNodeInfo->Equals(nsGkAtoms::body) ||
+       mNodeInfo->Equals(nsGkAtoms::frameset)) &&
+      // We only forward some event attributes from body/frameset to window
+      (0
+#define EVENT(name_, id_, type_, struct_) /* nothing */
+#define FORWARDED_EVENT(name_, id_, type_, struct_) \
+       || nsGkAtoms::on##name_ == aAttrName
+#define WINDOW_EVENT FORWARDED_EVENT
+#include "mozilla/EventNameList.h" // IWYU pragma: keep
+#undef WINDOW_EVENT
+#undef FORWARDED_EVENT
+#undef EVENT
+       )
+      ) {
+    nsPIDOMWindowInner *win;
+
+    // If we have a document, and it has a window, add the event
+    // listener on the window (the inner window). If not, proceed as
+    // normal.
+    // XXXbz sXBL/XBL2 issue: should we instead use GetComposedDoc() here,
+    // override BindToTree for those classes and munge event listeners there?
+    nsIDocument *document = OwnerDoc();
+
+    *aDefer = false;
+    if ((win = document->GetInnerWindow())) {
+      nsCOMPtr<EventTarget> piTarget(do_QueryInterface(win));
+
+      return piTarget->GetOrCreateListenerManager();
+    }
+
+    return nullptr;
+  }
+
+  return nsGenericHTMLElementBase::GetEventListenerManagerForAttr(aAttrName,
+                                                                  aDefer);
+}
+
+#define EVENT(name_, id_, type_, struct_) /* nothing; handled by nsINode */
+#define FORWARDED_EVENT(name_, id_, type_, struct_)                           \
+EventHandlerNonNull*                                                          \
+nsGenericHTMLElement::GetOn##name_()                                          \
+{                                                                             \
+  if (IsAnyOfHTMLElements(nsGkAtoms::body, nsGkAtoms::frameset)) {            \
+    /* XXXbz note to self: add tests for this! */                             \
+    if (nsPIDOMWindowInner* win = OwnerDoc()->GetInnerWindow()) {             \
+      nsGlobalWindow* globalWin = nsGlobalWindow::Cast(win);                  \
+      return globalWin->GetOn##name_();                                       \
+    }                                                                         \
+    return nullptr;                                                           \
+  }                                                                           \
+                                                                              \
+  return nsINode::GetOn##name_();                                             \
+}                                                                             \
+void                                                                          \
+nsGenericHTMLElement::SetOn##name_(EventHandlerNonNull* handler)              \
+{                                                                             \
+  if (IsAnyOfHTMLElements(nsGkAtoms::body, nsGkAtoms::frameset)) {            \
+    nsPIDOMWindowInner* win = OwnerDoc()->GetInnerWindow();                   \
+    if (!win) {                                                               \
+      return;                                                                 \
+    }                                                                         \
+                                                                              \
+    nsGlobalWindow* globalWin = nsGlobalWindow::Cast(win);                    \
+    return globalWin->SetOn##name_(handler);                                  \
+  }                                                                           \
+                                                                              \
+  return nsINode::SetOn##name_(handler);                                      \
+}
+#define ERROR_EVENT(name_, id_, type_, struct_)                               \
+already_AddRefed<EventHandlerNonNull>                                         \
+nsGenericHTMLElement::GetOn##name_()                                          \
+{                                                                             \
+  if (IsAnyOfHTMLElements(nsGkAtoms::body, nsGkAtoms::frameset)) {            \
+    /* XXXbz note to self: add tests for this! */                             \
+    if (nsPIDOMWindowInner* win = OwnerDoc()->GetInnerWindow()) {             \
+      nsGlobalWindow* globalWin = nsGlobalWindow::Cast(win);                  \
+      OnErrorEventHandlerNonNull* errorHandler = globalWin->GetOn##name_();   \
+      if (errorHandler) {                                                     \
+        RefPtr<EventHandlerNonNull> handler =                                 \
+          new EventHandlerNonNull(errorHandler);                              \
+        return handler.forget();                                              \
+      }                                                                       \
+    }                                                                         \
+    return nullptr;                                                           \
+  }                                                                           \
+                                                                              \
+  RefPtr<EventHandlerNonNull> handler = nsINode::GetOn##name_();              \
+  return handler.forget();                                                    \
+}                                                                             \
+void                                                                          \
+nsGenericHTMLElement::SetOn##name_(EventHandlerNonNull* handler)              \
+{                                                                             \
+  if (IsAnyOfHTMLElements(nsGkAtoms::body, nsGkAtoms::frameset)) {            \
+    nsPIDOMWindowInner* win = OwnerDoc()->GetInnerWindow();                   \
+    if (!win) {                                                               \
+      return;                                                                 \
+    }                                                                         \
+                                                                              \
+    nsGlobalWindow* globalWin = nsGlobalWindow::Cast(win);                    \
+    RefPtr<OnErrorEventHandlerNonNull> errorHandler;                          \
+    if (handler) {                                                            \
+      errorHandler = new OnErrorEventHandlerNonNull(handler);                 \
+    }                                                                         \
+    return globalWin->SetOn##name_(errorHandler);                             \
+  }                                                                           \
+                                                                              \
+  return nsINode::SetOn##name_(handler);                                      \
+}
+#include "mozilla/EventNameList.h" // IWYU pragma: keep
+#undef ERROR_EVENT
+#undef FORWARDED_EVENT
+#undef EVENT
+
+nsresult
+nsGenericHTMLElement::SetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+                              nsIAtom* aPrefix, const nsAString& aValue,
+                              bool aNotify)
+{
+  bool contentEditable = aNameSpaceID == kNameSpaceID_None &&
+                           aName == nsGkAtoms::contenteditable;
+  bool accessKey = aName == nsGkAtoms::accesskey && 
+                     aNameSpaceID == kNameSpaceID_None;
+
+  int32_t change = 0;
+  if (contentEditable) {
+    change = GetContentEditableValue() == eTrue ? -1 : 0;
+    SetMayHaveContentEditableAttr();
+  }
+
+  if (accessKey) {
+    UnregAccessKey();
+  }
+
+  nsresult rv = nsStyledElement::SetAttr(aNameSpaceID, aName, aPrefix, aValue,
+                                         aNotify);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (contentEditable) {
+    if (aValue.IsEmpty() || aValue.LowerCaseEqualsLiteral("true")) {
+      change += 1;
+    }
+
+    ChangeEditableState(change);
+  }
+
+  if (accessKey && !aValue.IsEmpty()) {
+    SetFlags(NODE_HAS_ACCESSKEY);
+    RegAccessKey();
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsGenericHTMLElement::UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
+                                bool aNotify)
+{
+  bool contentEditable = false;
+  int32_t contentEditableChange = 0;
+
+  // Check for event handlers
+  if (aNameSpaceID == kNameSpaceID_None) {
+    if (aAttribute == nsGkAtoms::name) {
+      // Have to do this before clearing flag. See RemoveFromNameTable
+      RemoveFromNameTable();
+      ClearHasName();
+    }
+    else if (aAttribute == nsGkAtoms::contenteditable) {
+      contentEditable = true;
+      contentEditableChange = GetContentEditableValue() == eTrue ? -1 : 0;
+    }
+    else if (aAttribute == nsGkAtoms::accesskey) {
+      // Have to unregister before clearing flag. See UnregAccessKey
+      UnregAccessKey();
+      UnsetFlags(NODE_HAS_ACCESSKEY);
+    }
+    else if (IsEventAttributeName(aAttribute)) {
+      if (EventListenerManager* manager = GetExistingListenerManager()) {
+        manager->RemoveEventHandler(aAttribute, EmptyString());
+      }
+    }
+  }
+
+  nsresult rv = nsGenericHTMLElementBase::UnsetAttr(aNameSpaceID, aAttribute,
+                                                    aNotify);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (contentEditable) {
+    ChangeEditableState(contentEditableChange);
+  }
+
+  return NS_OK;
+}
+
+void
+nsGenericHTMLElement::GetBaseTarget(nsAString& aBaseTarget) const
+{
+  OwnerDoc()->GetBaseTarget(aBaseTarget);
+}
+
+//----------------------------------------------------------------------
+
+bool
+nsGenericHTMLElement::ParseAttribute(int32_t aNamespaceID,
+                                     nsIAtom* aAttribute,
+                                     const nsAString& aValue,
+                                     nsAttrValue& aResult)
+{
+  if (aNamespaceID == kNameSpaceID_None) {
+    if (aAttribute == nsGkAtoms::dir) {
+      return aResult.ParseEnumValue(aValue, kDirTable, false);
+    }
+  
+    if (aAttribute == nsGkAtoms::tabindex) {
+      return aResult.ParseIntValue(aValue);
+    }
+
+    if (aAttribute == nsGkAtoms::referrerpolicy) {
+      return ParseReferrerAttribute(aValue, aResult);
+    }
+
+    if (aAttribute == nsGkAtoms::name) {
+      // Store name as an atom.  name="" means that the element has no name,
+      // not that it has an emptystring as the name.
+      RemoveFromNameTable();
+      if (aValue.IsEmpty()) {
+        ClearHasName();
+        return false;
+      }
+
+      aResult.ParseAtom(aValue);
+
+      if (CanHaveName(NodeInfo()->NameAtom())) {
+        SetHasName();
+        AddToNameTable(aResult.GetAtomValue());
+      }
+      
+      return true;
+    }
+
+    if (aAttribute == nsGkAtoms::contenteditable) {
+      aResult.ParseAtom(aValue);
+      return true;
+    }
+
+    if (aAttribute == nsGkAtoms::rel) {
+      aResult.ParseAtomArray(aValue);
+      return true;
+    }
+  }
+
+  return nsGenericHTMLElementBase::ParseAttribute(aNamespaceID, aAttribute,
+                                                  aValue, aResult);
+}
+
+bool
+nsGenericHTMLElement::ParseBackgroundAttribute(int32_t aNamespaceID,
+                                               nsIAtom* aAttribute,
+                                               const nsAString& aValue,
+                                               nsAttrValue& aResult)
+{
+  if (aNamespaceID == kNameSpaceID_None &&
+      aAttribute == nsGkAtoms::background &&
+      !aValue.IsEmpty()) {
+    // Resolve url to an absolute url
+    nsIDocument* doc = OwnerDoc();
+    nsCOMPtr<nsIURI> baseURI = GetBaseURI();
+    nsCOMPtr<nsIURI> uri;
+    nsresult rv = nsContentUtils::NewURIWithDocumentCharset(
+        getter_AddRefs(uri), aValue, doc, baseURI);
+    if (NS_FAILED(rv)) {
+      return false;
+    }
+
+    nsString value(aValue);
+    RefPtr<nsStringBuffer> buffer = nsCSSValue::BufferFromString(value);
+    if (MOZ_UNLIKELY(!buffer)) {
+      return false;
+    }
+
+    mozilla::css::URLValue *url =
+      new mozilla::css::URLValue(uri, buffer, baseURI, doc->GetDocumentURI(),
+                                 NodePrincipal());
+    aResult.SetTo(url, &aValue);
+    return true;
+  }
+
+  return false;
+}
+
+bool
+nsGenericHTMLElement::IsAttributeMapped(const nsIAtom* aAttribute) const
+{
+  static const MappedAttributeEntry* const map[] = {
+    sCommonAttributeMap
+  };
+  
+  return FindAttributeDependence(aAttribute, map);
+}
+
+nsMapRuleToAttributesFunc
+nsGenericHTMLElement::GetAttributeMappingFunction() const
+{
+  return &MapCommonAttributesInto;
+}
+
+nsIFormControlFrame*
+nsGenericHTMLElement::GetFormControlFrame(bool aFlushFrames)
+{
+  if (aFlushFrames && IsInComposedDoc()) {
+    // Cause a flush of the frames, so we get up-to-date frame information
+    GetComposedDoc()->FlushPendingNotifications(Flush_Frames);
+  }
+  nsIFrame* frame = GetPrimaryFrame();
+  if (frame) {
+    nsIFormControlFrame* form_frame = do_QueryFrame(frame);
+    if (form_frame) {
+      return form_frame;
+    }
+
+    // If we have generated content, the primary frame will be a
+    // wrapper frame..  out real frame will be in its child list.
+    for (frame = frame->PrincipalChildList().FirstChild();
+         frame;
+         frame = frame->GetNextSibling()) {
+      form_frame = do_QueryFrame(frame);
+      if (form_frame) {
+        return form_frame;
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+nsPresContext*
+nsGenericHTMLElement::GetPresContext(PresContextFor aFor)
+{
+  // Get the document
+  nsIDocument* doc = (aFor == eForComposedDoc) ?
+    GetComposedDoc() : GetUncomposedDoc();
+  if (doc) {
+    // Get presentation shell.
+    nsIPresShell *presShell = doc->GetShell();
+    if (presShell) {
+      return presShell->GetPresContext();
+    }
+  }
+
+  return nullptr;
+}
+
+static const nsAttrValue::EnumTable kDivAlignTable[] = {
+  { "left", NS_STYLE_TEXT_ALIGN_MOZ_LEFT },
+  { "right", NS_STYLE_TEXT_ALIGN_MOZ_RIGHT },
+  { "center", NS_STYLE_TEXT_ALIGN_MOZ_CENTER },
+  { "middle", NS_STYLE_TEXT_ALIGN_MOZ_CENTER },
+  { "justify", NS_STYLE_TEXT_ALIGN_JUSTIFY },
+  { nullptr, 0 }
+};
+
+static const nsAttrValue::EnumTable kFrameborderTable[] = {
+  { "yes", NS_STYLE_FRAME_YES },
+  { "no", NS_STYLE_FRAME_NO },
+  { "1", NS_STYLE_FRAME_1 },
+  { "0", NS_STYLE_FRAME_0 },
+  { nullptr, 0 }
+};
+
+static const nsAttrValue::EnumTable kScrollingTable[] = {
+  { "yes", NS_STYLE_FRAME_YES },
+  { "no", NS_STYLE_FRAME_NO },
+  { "on", NS_STYLE_FRAME_ON },
+  { "off", NS_STYLE_FRAME_OFF },
+  { "scroll", NS_STYLE_FRAME_SCROLL },
+  { "noscroll", NS_STYLE_FRAME_NOSCROLL },
+  { "auto", NS_STYLE_FRAME_AUTO },
+  { nullptr, 0 }
+};
+
+static const nsAttrValue::EnumTable kTableVAlignTable[] = {
+  { "top",     NS_STYLE_VERTICAL_ALIGN_TOP },
+  { "middle",  NS_STYLE_VERTICAL_ALIGN_MIDDLE },
+  { "bottom",  NS_STYLE_VERTICAL_ALIGN_BOTTOM },
+  { "baseline",NS_STYLE_VERTICAL_ALIGN_BASELINE },
+  { nullptr,   0 }
+};
+
+bool
+nsGenericHTMLElement::ParseAlignValue(const nsAString& aString,
+                                      nsAttrValue& aResult)
+{
+  static const nsAttrValue::EnumTable kAlignTable[] = {
+    { "left",      NS_STYLE_TEXT_ALIGN_LEFT },
+    { "right",     NS_STYLE_TEXT_ALIGN_RIGHT },
+
+    { "top",       NS_STYLE_VERTICAL_ALIGN_TOP },
+    { "middle",    NS_STYLE_VERTICAL_ALIGN_MIDDLE_WITH_BASELINE },
+    { "bottom",    NS_STYLE_VERTICAL_ALIGN_BASELINE },
+
+    { "center",    NS_STYLE_VERTICAL_ALIGN_MIDDLE_WITH_BASELINE },
+    { "baseline",  NS_STYLE_VERTICAL_ALIGN_BASELINE },
+
+    { "texttop",   NS_STYLE_VERTICAL_ALIGN_TEXT_TOP },
+    { "absmiddle", NS_STYLE_VERTICAL_ALIGN_MIDDLE },
+    { "abscenter", NS_STYLE_VERTICAL_ALIGN_MIDDLE },
+    { "absbottom", NS_STYLE_VERTICAL_ALIGN_BOTTOM },
+    { nullptr,     0 }
+  };
+
+  return aResult.ParseEnumValue(aString, kAlignTable, false);
+}
+
+//----------------------------------------
+
+static const nsAttrValue::EnumTable kTableHAlignTable[] = {
+  { "left",   NS_STYLE_TEXT_ALIGN_LEFT },
+  { "right",  NS_STYLE_TEXT_ALIGN_RIGHT },
+  { "center", NS_STYLE_TEXT_ALIGN_CENTER },
+  { "char",   NS_STYLE_TEXT_ALIGN_CHAR },
+  { "justify",NS_STYLE_TEXT_ALIGN_JUSTIFY },
+  { nullptr,  0 }
+};
+
+bool
+nsGenericHTMLElement::ParseTableHAlignValue(const nsAString& aString,
+                                            nsAttrValue& aResult)
+{
+  return aResult.ParseEnumValue(aString, kTableHAlignTable, false);
+}
+
+//----------------------------------------
+
+// This table is used for td, th, tr, col, thead, tbody and tfoot.
+static const nsAttrValue::EnumTable kTableCellHAlignTable[] = {
+  { "left",   NS_STYLE_TEXT_ALIGN_MOZ_LEFT },
+  { "right",  NS_STYLE_TEXT_ALIGN_MOZ_RIGHT },
+  { "center", NS_STYLE_TEXT_ALIGN_MOZ_CENTER },
+  { "char",   NS_STYLE_TEXT_ALIGN_CHAR },
+  { "justify",NS_STYLE_TEXT_ALIGN_JUSTIFY },
+  { "middle", NS_STYLE_TEXT_ALIGN_MOZ_CENTER },
+  { "absmiddle", NS_STYLE_TEXT_ALIGN_CENTER },
+  { nullptr,  0 }
+};
+
+bool
+nsGenericHTMLElement::ParseTableCellHAlignValue(const nsAString& aString,
+                                                nsAttrValue& aResult)
+{
+  return aResult.ParseEnumValue(aString, kTableCellHAlignTable, false);
+}
+
+//----------------------------------------
+
+bool
+nsGenericHTMLElement::ParseTableVAlignValue(const nsAString& aString,
+                                            nsAttrValue& aResult)
+{
+  return aResult.ParseEnumValue(aString, kTableVAlignTable, false);
+}
+
+bool
+nsGenericHTMLElement::ParseDivAlignValue(const nsAString& aString,
+                                         nsAttrValue& aResult)
+{
+  return aResult.ParseEnumValue(aString, kDivAlignTable, false);
+}
+
+bool
+nsGenericHTMLElement::ParseImageAttribute(nsIAtom* aAttribute,
+                                          const nsAString& aString,
+                                          nsAttrValue& aResult)
+{
+  if ((aAttribute == nsGkAtoms::width) ||
+      (aAttribute == nsGkAtoms::height)) {
+    return aResult.ParseSpecialIntValue(aString);
+  }
+  if ((aAttribute == nsGkAtoms::hspace) ||
+      (aAttribute == nsGkAtoms::vspace) ||
+      (aAttribute == nsGkAtoms::border)) {
+    return aResult.ParseIntWithBounds(aString, 0);
+  }
+  return false;
+}
+
+bool
+nsGenericHTMLElement::ParseReferrerAttribute(const nsAString& aString,
+                                             nsAttrValue& aResult)
+{
+  static const nsAttrValue::EnumTable kReferrerTable[] = {
+    { net::kRPS_No_Referrer, static_cast<int16_t>(net::RP_No_Referrer) },
+    { net::kRPS_Origin, static_cast<int16_t>(net::RP_Origin) },
+    { net::kRPS_Origin_When_Cross_Origin, static_cast<int16_t>(net::RP_Origin_When_Crossorigin) },
+    { net::kRPS_No_Referrer_When_Downgrade, static_cast<int16_t>(net::RP_No_Referrer_When_Downgrade) },
+    { net::kRPS_Unsafe_URL, static_cast<int16_t>(net::RP_Unsafe_URL) },
+    { net::kRPS_Strict_Origin, static_cast<int16_t>(net::RP_Strict_Origin) },
+    { net::kRPS_Same_Origin, static_cast<int16_t>(net::RP_Same_Origin) },
+    { net::kRPS_Strict_Origin_When_Cross_Origin, static_cast<int16_t>(net::RP_Strict_Origin_When_Cross_Origin) },
+    { nullptr, 0 }
+  };
+  return aResult.ParseEnumValue(aString, kReferrerTable, false);
+}
+
+bool
+nsGenericHTMLElement::ParseFrameborderValue(const nsAString& aString,
+                                            nsAttrValue& aResult)
+{
+  return aResult.ParseEnumValue(aString, kFrameborderTable, false);
+}
+
+bool
+nsGenericHTMLElement::ParseScrollingValue(const nsAString& aString,
+                                          nsAttrValue& aResult)
+{
+  return aResult.ParseEnumValue(aString, kScrollingTable, false);
+}
+
+static inline void
+MapLangAttributeInto(const nsMappedAttributes* aAttributes, nsRuleData* aData)
+{
+  if (!(aData->mSIDs & (NS_STYLE_INHERIT_BIT(Font) |
+                        NS_STYLE_INHERIT_BIT(Text)))) {
+    return;
+  }
+
+  const nsAttrValue* langValue = aAttributes->GetAttr(nsGkAtoms::lang);
+  if (!langValue || langValue->Type() != nsAttrValue::eString) {
+    return;
+  }
+
+  if (aData->mSIDs & NS_STYLE_INHERIT_BIT(Font)) {
+    nsCSSValue* lang = aData->ValueForLang();
+    if (lang->GetUnit() == eCSSUnit_Null) {
+      lang->SetStringValue(langValue->GetStringValue(), eCSSUnit_Ident);
+    }
+  }
+  if (aData->mSIDs & NS_STYLE_INHERIT_BIT(Text)) {
+    nsCSSValue* emphasisPos = aData->ValueForTextEmphasisPosition();
+    if (emphasisPos->GetUnit() == eCSSUnit_Null) {
+      const nsAString& lang = langValue->GetStringValue();
+      if (nsStyleUtil::MatchesLanguagePrefix(lang, u"zh")) {
+        emphasisPos->SetIntValue(NS_STYLE_TEXT_EMPHASIS_POSITION_DEFAULT_ZH,
+                                eCSSUnit_Enumerated);
+      } else if (nsStyleUtil::MatchesLanguagePrefix(lang, u"ja") ||
+                 nsStyleUtil::MatchesLanguagePrefix(lang, u"mn")) {
+        // This branch is currently no part of the spec.
+        // See bug 1040668 comment 69 and comment 75.
+        emphasisPos->SetIntValue(NS_STYLE_TEXT_EMPHASIS_POSITION_DEFAULT,
+                                eCSSUnit_Enumerated);
+      }
+    }
+  }
+}
+
+/**
+ * Handle attributes common to all html elements
+ */
+void
+nsGenericHTMLElement::MapCommonAttributesIntoExceptHidden(const nsMappedAttributes* aAttributes,
+                                                          nsRuleData* aData)
+{
+  if (aData->mSIDs & NS_STYLE_INHERIT_BIT(UserInterface)) {
+    nsCSSValue* userModify = aData->ValueForUserModify();
+    if (userModify->GetUnit() == eCSSUnit_Null) {
+      const nsAttrValue* value =
+        aAttributes->GetAttr(nsGkAtoms::contenteditable);
+      if (value) {
+        if (value->Equals(nsGkAtoms::_empty, eCaseMatters) ||
+            value->Equals(nsGkAtoms::_true, eIgnoreCase)) {
+          userModify->SetIntValue(StyleUserModify::ReadWrite,
+                                  eCSSUnit_Enumerated);
+        }
+        else if (value->Equals(nsGkAtoms::_false, eIgnoreCase)) {
+            userModify->SetIntValue(StyleUserModify::ReadOnly,
+                                    eCSSUnit_Enumerated);
+        }
+      }
+    }
+  }
+
+  MapLangAttributeInto(aAttributes, aData);
+}
+
+void
+nsGenericHTMLElement::MapCommonAttributesInto(const nsMappedAttributes* aAttributes,
+                                              nsRuleData* aData)
+{
+  MapCommonAttributesIntoExceptHidden(aAttributes, aData);
+
+  if (aData->mSIDs & NS_STYLE_INHERIT_BIT(Display)) {
+    nsCSSValue* display = aData->ValueForDisplay();
+    if (display->GetUnit() == eCSSUnit_Null) {
+      if (aAttributes->IndexOfAttr(nsGkAtoms::hidden) >= 0) {
+        display->SetIntValue(StyleDisplay::None, eCSSUnit_Enumerated);
+      }
+    }
+  }
+}
+
+/* static */ const nsGenericHTMLElement::MappedAttributeEntry
+nsGenericHTMLElement::sCommonAttributeMap[] = {
+  { &nsGkAtoms::contenteditable },
+  { &nsGkAtoms::lang },
+  { &nsGkAtoms::hidden },
+  { nullptr }
+};
+
+/* static */ const Element::MappedAttributeEntry
+nsGenericHTMLElement::sImageMarginSizeAttributeMap[] = {
+  { &nsGkAtoms::width },
+  { &nsGkAtoms::height },
+  { &nsGkAtoms::hspace },
+  { &nsGkAtoms::vspace },
+  { nullptr }
+};
+
+/* static */ const Element::MappedAttributeEntry
+nsGenericHTMLElement::sImageAlignAttributeMap[] = {
+  { &nsGkAtoms::align },
+  { nullptr }
+};
+
+/* static */ const Element::MappedAttributeEntry
+nsGenericHTMLElement::sDivAlignAttributeMap[] = {
+  { &nsGkAtoms::align },
+  { nullptr }
+};
+
+/* static */ const Element::MappedAttributeEntry
+nsGenericHTMLElement::sImageBorderAttributeMap[] = {
+  { &nsGkAtoms::border },
+  { nullptr }
+};
+
+/* static */ const Element::MappedAttributeEntry
+nsGenericHTMLElement::sBackgroundAttributeMap[] = {
+  { &nsGkAtoms::background },
+  { &nsGkAtoms::bgcolor },
+  { nullptr }
+};
+
+/* static */ const Element::MappedAttributeEntry
+nsGenericHTMLElement::sBackgroundColorAttributeMap[] = {
+  { &nsGkAtoms::bgcolor },
+  { nullptr }
+};
+
+void
+nsGenericHTMLElement::MapImageAlignAttributeInto(const nsMappedAttributes* aAttributes,
+                                                 nsRuleData* aRuleData)
+{
+  if (aRuleData->mSIDs & NS_STYLE_INHERIT_BIT(Display)) {
+    const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
+    if (value && value->Type() == nsAttrValue::eEnum) {
+      int32_t align = value->GetEnumValue();
+      nsCSSValue* cssFloat = aRuleData->ValueForFloat();
+      if (cssFloat->GetUnit() == eCSSUnit_Null) {
+        if (align == NS_STYLE_TEXT_ALIGN_LEFT) {
+          cssFloat->SetIntValue(StyleFloat::Left, eCSSUnit_Enumerated);
+        } else if (align == NS_STYLE_TEXT_ALIGN_RIGHT) {
+          cssFloat->SetIntValue(StyleFloat::Right, eCSSUnit_Enumerated);
+        }
+      }
+      nsCSSValue* verticalAlign = aRuleData->ValueForVerticalAlign();
+      if (verticalAlign->GetUnit() == eCSSUnit_Null) {
+        switch (align) {
+        case NS_STYLE_TEXT_ALIGN_LEFT:
+        case NS_STYLE_TEXT_ALIGN_RIGHT:
+          break;
+        default:
+          verticalAlign->SetIntValue(align, eCSSUnit_Enumerated);
+          break;
+        }
+      }
+    }
+  }
+}
+
+void
+nsGenericHTMLElement::MapDivAlignAttributeInto(const nsMappedAttributes* aAttributes,
+                                               nsRuleData* aRuleData)
+{
+  if (aRuleData->mSIDs & NS_STYLE_INHERIT_BIT(Text)) {
+    nsCSSValue* textAlign = aRuleData->ValueForTextAlign();
+    if (textAlign->GetUnit() == eCSSUnit_Null) {
+      // align: enum
+      const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::align);
+      if (value && value->Type() == nsAttrValue::eEnum)
+        textAlign->SetIntValue(value->GetEnumValue(), eCSSUnit_Enumerated);
+    }
+  }
+}
+
+
+void
+nsGenericHTMLElement::MapImageMarginAttributeInto(const nsMappedAttributes* aAttributes,
+                                                  nsRuleData* aData)
+{
+  if (!(aData->mSIDs & NS_STYLE_INHERIT_BIT(Margin)))
+    return;
+
+  const nsAttrValue* value;
+
+  // hspace: value
+  value = aAttributes->GetAttr(nsGkAtoms::hspace);
+  if (value) {
+    nsCSSValue hval;
+    if (value->Type() == nsAttrValue::eInteger)
+      hval.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
+    else if (value->Type() == nsAttrValue::ePercent)
+      hval.SetPercentValue(value->GetPercentValue());
+
+    if (hval.GetUnit() != eCSSUnit_Null) {
+      nsCSSValue* left = aData->ValueForMarginLeft();
+      if (left->GetUnit() == eCSSUnit_Null)
+        *left = hval;
+      nsCSSValue* right = aData->ValueForMarginRight();
+      if (right->GetUnit() == eCSSUnit_Null)
+        *right = hval;
+    }
+  }
+
+  // vspace: value
+  value = aAttributes->GetAttr(nsGkAtoms::vspace);
+  if (value) {
+    nsCSSValue vval;
+    if (value->Type() == nsAttrValue::eInteger)
+      vval.SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
+    else if (value->Type() == nsAttrValue::ePercent)
+      vval.SetPercentValue(value->GetPercentValue());
+  
+    if (vval.GetUnit() != eCSSUnit_Null) {
+      nsCSSValue* top = aData->ValueForMarginTop();
+      if (top->GetUnit() == eCSSUnit_Null)
+        *top = vval;
+      nsCSSValue* bottom = aData->ValueForMarginBottom();
+      if (bottom->GetUnit() == eCSSUnit_Null)
+        *bottom = vval;
+    }
+  }
+}
+
+void
+nsGenericHTMLElement::MapImageSizeAttributesInto(const nsMappedAttributes* aAttributes,
+                                                 nsRuleData* aData)
+{
+  if (!(aData->mSIDs & NS_STYLE_INHERIT_BIT(Position)))
+    return;
+
+  // width: value
+  nsCSSValue* width = aData->ValueForWidth();
+  if (width->GetUnit() == eCSSUnit_Null) {
+    const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::width);
+    if (value && value->Type() == nsAttrValue::eInteger)
+      width->SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel);
+    else if (value && value->Type() == nsAttrValue::ePercent)
+      width->SetPercentValue(value->GetPercentValue());
+  }
+
+  // height: value
+  nsCSSValue* height = aData->ValueForHeight();
+  if (height->GetUnit() == eCSSUnit_Null) {
+    const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::height);
+    if (value && value->Type() == nsAttrValue::eInteger)
+      height->SetFloatValue((float)value->GetIntegerValue(), eCSSUnit_Pixel); 
+    else if (value && value->Type() == nsAttrValue::ePercent)
+      height->SetPercentValue(value->GetPercentValue());
+  }
+}
+
+void
+nsGenericHTMLElement::MapImageBorderAttributeInto(const nsMappedAttributes* aAttributes,
+                                                  nsRuleData* aData)
+{
+  if (!(aData->mSIDs & NS_STYLE_INHERIT_BIT(Border)))
+    return;
+
+  // border: pixels
+  const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::border);
+  if (!value)
+    return;
+  
+  nscoord val = 0;
+  if (value->Type() == nsAttrValue::eInteger)
+    val = value->GetIntegerValue();
+
+  nsCSSValue* borderLeftWidth = aData->ValueForBorderLeftWidth();
+  if (borderLeftWidth->GetUnit() == eCSSUnit_Null)
+    borderLeftWidth->SetFloatValue((float)val, eCSSUnit_Pixel);
+  nsCSSValue* borderTopWidth = aData->ValueForBorderTopWidth();
+  if (borderTopWidth->GetUnit() == eCSSUnit_Null)
+    borderTopWidth->SetFloatValue((float)val, eCSSUnit_Pixel);
+  nsCSSValue* borderRightWidth = aData->ValueForBorderRightWidth();
+  if (borderRightWidth->GetUnit() == eCSSUnit_Null)
+    borderRightWidth->SetFloatValue((float)val, eCSSUnit_Pixel);
+  nsCSSValue* borderBottomWidth = aData->ValueForBorderBottomWidth();
+  if (borderBottomWidth->GetUnit() == eCSSUnit_Null)
+    borderBottomWidth->SetFloatValue((float)val, eCSSUnit_Pixel);
+
+  nsCSSValue* borderLeftStyle = aData->ValueForBorderLeftStyle();
+  if (borderLeftStyle->GetUnit() == eCSSUnit_Null)
+    borderLeftStyle->SetIntValue(NS_STYLE_BORDER_STYLE_SOLID, eCSSUnit_Enumerated);
+  nsCSSValue* borderTopStyle = aData->ValueForBorderTopStyle();
+  if (borderTopStyle->GetUnit() == eCSSUnit_Null)
+    borderTopStyle->SetIntValue(NS_STYLE_BORDER_STYLE_SOLID, eCSSUnit_Enumerated);
+  nsCSSValue* borderRightStyle = aData->ValueForBorderRightStyle();
+  if (borderRightStyle->GetUnit() == eCSSUnit_Null)
+    borderRightStyle->SetIntValue(NS_STYLE_BORDER_STYLE_SOLID, eCSSUnit_Enumerated);
+  nsCSSValue* borderBottomStyle = aData->ValueForBorderBottomStyle();
+  if (borderBottomStyle->GetUnit() == eCSSUnit_Null)
+    borderBottomStyle->SetIntValue(NS_STYLE_BORDER_STYLE_SOLID, eCSSUnit_Enumerated);
+
+  nsCSSValue* borderLeftColor = aData->ValueForBorderLeftColor();
+  if (borderLeftColor->GetUnit() == eCSSUnit_Null)
+    borderLeftColor->SetIntValue(NS_COLOR_CURRENTCOLOR, eCSSUnit_EnumColor);
+  nsCSSValue* borderTopColor = aData->ValueForBorderTopColor();
+  if (borderTopColor->GetUnit() == eCSSUnit_Null)
+    borderTopColor->SetIntValue(NS_COLOR_CURRENTCOLOR, eCSSUnit_EnumColor);
+  nsCSSValue* borderRightColor = aData->ValueForBorderRightColor();
+  if (borderRightColor->GetUnit() == eCSSUnit_Null)
+    borderRightColor->SetIntValue(NS_COLOR_CURRENTCOLOR, eCSSUnit_EnumColor);
+  nsCSSValue* borderBottomColor = aData->ValueForBorderBottomColor();
+  if (borderBottomColor->GetUnit() == eCSSUnit_Null)
+    borderBottomColor->SetIntValue(NS_COLOR_CURRENTCOLOR, eCSSUnit_EnumColor);
+}
+
+void
+nsGenericHTMLElement::MapBackgroundInto(const nsMappedAttributes* aAttributes,
+                                        nsRuleData* aData)
+{
+  if (!(aData->mSIDs & NS_STYLE_INHERIT_BIT(Background)))
+    return;
+
+  nsPresContext* presContext = aData->mPresContext;
+  nsCSSValue* backImage = aData->ValueForBackgroundImage();
+  if (backImage->GetUnit() == eCSSUnit_Null &&
+      presContext->UseDocumentColors()) {
+    // background
+    nsAttrValue* value =
+      const_cast<nsAttrValue*>(aAttributes->GetAttr(nsGkAtoms::background));
+    // If the value is an image, or it is a URL and we attempted a load,
+    // put it in the style tree.
+    if (value) {
+      if (value->Type() == nsAttrValue::eURL) {
+        value->LoadImage(presContext->Document());
+      }
+      if (value->Type() == nsAttrValue::eImage) {
+        nsCSSValueList* list = backImage->SetListValue();
+        list->mValue.SetImageValue(value->GetImageValue());
+      }
+    }
+  }
+}
+
+void
+nsGenericHTMLElement::MapBGColorInto(const nsMappedAttributes* aAttributes,
+                                     nsRuleData* aData)
+{
+  if (!(aData->mSIDs & NS_STYLE_INHERIT_BIT(Background)))
+    return;
+
+  nsCSSValue* backColor = aData->ValueForBackgroundColor();
+  if (backColor->GetUnit() == eCSSUnit_Null &&
+      aData->mPresContext->UseDocumentColors()) {
+    const nsAttrValue* value = aAttributes->GetAttr(nsGkAtoms::bgcolor);
+    nscolor color;
+    if (value && value->GetColorValue(color)) {
+      backColor->SetColorValue(color);
+    }
+  }
+}
+
+void
+nsGenericHTMLElement::MapBackgroundAttributesInto(const nsMappedAttributes* aAttributes,
+                                                  nsRuleData* aData)
+{
+  MapBackgroundInto(aAttributes, aData);
+  MapBGColorInto(aAttributes, aData);
+}
+
+//----------------------------------------------------------------------
+
+nsresult
+nsGenericHTMLElement::SetAttrHelper(nsIAtom* aAttr, const nsAString& aValue)
+{
+  return SetAttr(kNameSpaceID_None, aAttr, aValue, true);
+}
+
+int32_t
+nsGenericHTMLElement::GetIntAttr(nsIAtom* aAttr, int32_t aDefault) const
+{
+  const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(aAttr);
+  if (attrVal && attrVal->Type() == nsAttrValue::eInteger) {
+    return attrVal->GetIntegerValue();
+  }
+  return aDefault;
+}
+
+nsresult
+nsGenericHTMLElement::SetIntAttr(nsIAtom* aAttr, int32_t aValue)
+{
+  nsAutoString value;
+  value.AppendInt(aValue);
+
+  return SetAttr(kNameSpaceID_None, aAttr, value, true);
+}
+
+uint32_t
+nsGenericHTMLElement::GetUnsignedIntAttr(nsIAtom* aAttr,
+                                         uint32_t aDefault) const
+{
+  const nsAttrValue* attrVal = mAttrsAndChildren.GetAttr(aAttr);
+  if (!attrVal || attrVal->Type() != nsAttrValue::eInteger) {
+    return aDefault;
+  }
+
+  return attrVal->GetIntegerValue();
+}
+
+void
+nsGenericHTMLElement::GetURIAttr(nsIAtom* aAttr, nsIAtom* aBaseAttr,
+                                 nsAString& aResult) const
+{
+  nsCOMPtr<nsIURI> uri;
+  bool hadAttr = GetURIAttr(aAttr, aBaseAttr, getter_AddRefs(uri));
+  if (!hadAttr) {
+    aResult.Truncate();
+    return;
+  }
+
+  if (!uri) {
+    // Just return the attr value
+    GetAttr(kNameSpaceID_None, aAttr, aResult);
+    return;
+  }
+
+  nsAutoCString spec;
+  uri->GetSpec(spec);
+  CopyUTF8toUTF16(spec, aResult);
+}
+
+bool
+nsGenericHTMLElement::GetURIAttr(nsIAtom* aAttr, nsIAtom* aBaseAttr, nsIURI** aURI) const
+{
+  *aURI = nullptr;
+
+  const nsAttrValue* attr = mAttrsAndChildren.GetAttr(aAttr);
+  if (!attr) {
+    return false;
+  }
+
+  nsCOMPtr<nsIURI> baseURI = GetBaseURI();
+
+  if (aBaseAttr) {
+    nsAutoString baseAttrValue;
+    if (GetAttr(kNameSpaceID_None, aBaseAttr, baseAttrValue)) {
+      nsCOMPtr<nsIURI> baseAttrURI;
+      nsresult rv =
+        nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(baseAttrURI),
+                                                  baseAttrValue, OwnerDoc(),
+                                                  baseURI);
+      if (NS_FAILED(rv)) {
+        return true;
+      }
+      baseURI.swap(baseAttrURI);
+    }
+  }
+
+  // Don't care about return value.  If it fails, we still want to
+  // return true, and *aURI will be null.
+  nsContentUtils::NewURIWithDocumentCharset(aURI,
+                                            attr->GetStringValue(),
+                                            OwnerDoc(), baseURI);
+  return true;
+}
+
+/* static */ bool
+nsGenericHTMLElement::IsScrollGrabAllowed(JSContext*, JSObject*)
+{
+  // Only allow scroll grabbing in chrome
+  nsIPrincipal* prin = nsContentUtils::SubjectPrincipal();
+  return nsContentUtils::IsSystemPrincipal(prin);
+}
+
+HTMLMenuElement*
+nsGenericHTMLElement::GetContextMenu() const
+{
+  nsAutoString value;
+  GetHTMLAttr(nsGkAtoms::contextmenu, value);
+  if (!value.IsEmpty()) {
+    //XXXsmaug How should this work in Shadow DOM?
+    nsIDocument* doc = GetUncomposedDoc();
+    if (doc) {
+      return HTMLMenuElement::FromContentOrNull(doc->GetElementById(value));
+    }
+  }
+  return nullptr;
+}
+
+NS_IMETHODIMP
+nsGenericHTMLElement::GetContextMenu(nsIDOMHTMLMenuElement** aContextMenu)
+{
+  NS_IF_ADDREF(*aContextMenu = GetContextMenu());
+  return NS_OK;
+}
+
+bool
+nsGenericHTMLElement::IsLabelable() const
+{
+  return IsAnyOfHTMLElements(nsGkAtoms::progress, nsGkAtoms::meter);
+}
+
+bool
+nsGenericHTMLElement::IsInteractiveHTMLContent(bool aIgnoreTabindex) const
+{
+  return IsAnyOfHTMLElements(nsGkAtoms::details, nsGkAtoms::embed,
+                             nsGkAtoms::keygen) ||
+         (!aIgnoreTabindex && HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex));
+}
+
+// static
+bool
+nsGenericHTMLElement::TouchEventsEnabled(JSContext* aCx, JSObject* aGlobal)
+{
+  return TouchEvent::PrefEnabled(aCx, aGlobal);
+}
+
+//----------------------------------------------------------------------
+
+nsGenericHTMLFormElement::nsGenericHTMLFormElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
+  : nsGenericHTMLElement(aNodeInfo)
+  , mForm(nullptr)
+  , mFieldSet(nullptr)
+{
+  // We should add the NS_EVENT_STATE_ENABLED bit here as needed, but
+  // that depends on our type, which is not initialized yet.  So we
+  // have to do this in subclasses.
+}
+
+nsGenericHTMLFormElement::~nsGenericHTMLFormElement()
+{
+  if (mFieldSet) {
+    mFieldSet->RemoveElement(this);
+  }
+
+  // Check that this element doesn't know anything about its form at this point.
+  NS_ASSERTION(!mForm, "mForm should be null at this point!");
+}
+
+NS_IMPL_ISUPPORTS_INHERITED(nsGenericHTMLFormElement,
+                            nsGenericHTMLElement,
+                            nsIFormControl)
+
+nsINode*
+nsGenericHTMLFormElement::GetScopeChainParent() const
+{
+  return mForm ? mForm : nsGenericHTMLElement::GetScopeChainParent();
+}
+
+bool
+nsGenericHTMLFormElement::IsNodeOfType(uint32_t aFlags) const
+{
+  return !(aFlags & ~(eCONTENT | eHTML_FORM_CONTROL));
+}
+
+void
+nsGenericHTMLFormElement::SaveSubtreeState()
+{
+  SaveState();
+
+  nsGenericHTMLElement::SaveSubtreeState();
+}
+
+void
+nsGenericHTMLFormElement::SetForm(nsIDOMHTMLFormElement* aForm)
+{
+  NS_PRECONDITION(aForm, "Don't pass null here");
+  NS_ASSERTION(!mForm,
+               "We don't support switching from one non-null form to another.");
+
+  // keep a *weak* ref to the form here
+  mForm = static_cast<HTMLFormElement*>(aForm);
+}
+
+void
+nsGenericHTMLFormElement::ClearForm(bool aRemoveFromForm)
+{
+  NS_ASSERTION((mForm != nullptr) == HasFlag(ADDED_TO_FORM),
+               "Form control should have had flag set correctly");
+
+  if (!mForm) {
+    return;
+  }
+  
+  if (aRemoveFromForm) {
+    nsAutoString nameVal, idVal;
+    GetAttr(kNameSpaceID_None, nsGkAtoms::name, nameVal);
+    GetAttr(kNameSpaceID_None, nsGkAtoms::id, idVal);
+
+    mForm->RemoveElement(this, true);
+
+    if (!nameVal.IsEmpty()) {
+      mForm->RemoveElementFromTable(this, nameVal,
+                                    HTMLFormElement::ElementRemoved);
+    }
+
+    if (!idVal.IsEmpty()) {
+      mForm->RemoveElementFromTable(this, idVal,
+                                    HTMLFormElement::ElementRemoved);
+    }
+  }
+
+  UnsetFlags(ADDED_TO_FORM);
+  mForm = nullptr;
+}
+
+Element*
+nsGenericHTMLFormElement::GetFormElement()
+{
+  return mForm;
+}
+
+HTMLFieldSetElement*
+nsGenericHTMLFormElement::GetFieldSet()
+{
+  return mFieldSet;
+}
+
+nsresult
+nsGenericHTMLFormElement::GetForm(nsIDOMHTMLFormElement** aForm)
+{
+  NS_ENSURE_ARG_POINTER(aForm);
+  NS_IF_ADDREF(*aForm = mForm);
+  return NS_OK;
+}
+
+nsIContent::IMEState
+nsGenericHTMLFormElement::GetDesiredIMEState()
+{
+  nsIEditor* editor = GetEditorInternal();
+  if (!editor)
+    return nsGenericHTMLElement::GetDesiredIMEState();
+  nsCOMPtr<nsIEditorIMESupport> imeEditor = do_QueryInterface(editor);
+  if (!imeEditor)
+    return nsGenericHTMLElement::GetDesiredIMEState();
+  IMEState state;
+  nsresult rv = imeEditor->GetPreferredIMEState(&state);
+  if (NS_FAILED(rv))
+    return nsGenericHTMLElement::GetDesiredIMEState();
+  return state;
+}
+
+nsresult
+nsGenericHTMLFormElement::BindToTree(nsIDocument* aDocument,
+                                     nsIContent* aParent,
+                                     nsIContent* aBindingParent,
+                                     bool aCompileEventHandlers)
+{
+  nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent,
+                                                 aBindingParent,
+                                                 aCompileEventHandlers);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // An autofocus event has to be launched if the autofocus attribute is
+  // specified and the element accept the autofocus attribute. In addition,
+  // the document should not be already loaded and the "browser.autofocus"
+  // preference should be 'true'.
+  if (IsAutofocusable() && HasAttr(kNameSpaceID_None, nsGkAtoms::autofocus) &&
+      Preferences::GetBool("browser.autofocus", true)) {
+    nsCOMPtr<nsIRunnable> event = new nsAutoFocusEvent(this);
+    rv = NS_DispatchToCurrentThread(event);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // If @form is set, the element *has* to be in a document, otherwise it
+  // wouldn't be possible to find an element with the corresponding id.
+  // If @form isn't set, the element *has* to have a parent, otherwise it
+  // wouldn't be possible to find a form ancestor.
+  // We should not call UpdateFormOwner if none of these conditions are
+  // fulfilled.
+  if (HasAttr(kNameSpaceID_None, nsGkAtoms::form) ? !!GetUncomposedDoc()
+                                                  : !!aParent) {
+    UpdateFormOwner(true, nullptr);
+  }
+
+  // Set parent fieldset which should be used for the disabled state.
+  UpdateFieldSet(false);
+
+  return NS_OK;
+}
+
+void
+nsGenericHTMLFormElement::UnbindFromTree(bool aDeep, bool aNullParent)
+{
+  // Save state before doing anything
+  SaveState();
+  
+  if (mForm) {
+    // Might need to unset mForm
+    if (aNullParent) {
+      // No more parent means no more form
+      ClearForm(true);
+    } else {
+      // Recheck whether we should still have an mForm.
+      if (HasAttr(kNameSpaceID_None, nsGkAtoms::form) ||
+          !FindAncestorForm(mForm)) {
+        ClearForm(true);
+      } else {
+        UnsetFlags(MAYBE_ORPHAN_FORM_ELEMENT);
+      }
+    }
+
+    if (!mForm) {
+      // Our novalidate state might have changed
+      UpdateState(false);
+    }
+  }
+
+  // We have to remove the form id observer if there was one.
+  // We will re-add one later if needed (during bind to tree).
+  if (nsContentUtils::HasNonEmptyAttr(this, kNameSpaceID_None,
+                                      nsGkAtoms::form)) {
+    RemoveFormIdObserver();
+  }
+
+  nsGenericHTMLElement::UnbindFromTree(aDeep, aNullParent);
+
+  // The element might not have a fieldset anymore.
+  UpdateFieldSet(false);
+}
+
+nsresult
+nsGenericHTMLFormElement::BeforeSetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+                                        nsAttrValueOrString* aValue,
+                                        bool aNotify)
+{
+  if (aNameSpaceID == kNameSpaceID_None) {
+    nsAutoString tmp;
+
+    // remove the control from the hashtable as needed
+
+    if (mForm && (aName == nsGkAtoms::name || aName == nsGkAtoms::id)) {
+      GetAttr(kNameSpaceID_None, aName, tmp);
+
+      if (!tmp.IsEmpty()) {
+        mForm->RemoveElementFromTable(this, tmp,
+                                      HTMLFormElement::AttributeUpdated);
+      }
+    }
+
+    if (mForm && aName == nsGkAtoms::type) {
+      GetAttr(kNameSpaceID_None, nsGkAtoms::name, tmp);
+
+      if (!tmp.IsEmpty()) {
+        mForm->RemoveElementFromTable(this, tmp,
+                                      HTMLFormElement::AttributeUpdated);
+      }
+
+      GetAttr(kNameSpaceID_None, nsGkAtoms::id, tmp);
+
+      if (!tmp.IsEmpty()) {
+        mForm->RemoveElementFromTable(this, tmp,
+                                      HTMLFormElement::AttributeUpdated);
+      }
+
+      mForm->RemoveElement(this, false);
+
+      // Removing the element from the form can make it not be the default
+      // control anymore.  Go ahead and notify on that change, though we might
+      // end up readding and becoming the default control again in
+      // AfterSetAttr.
+      // FIXME: Bug 656197
+      UpdateState(aNotify);
+    }
+
+    if (aName == nsGkAtoms::form) {
+      // If @form isn't set or set to the empty string, there were no observer
+      // so we don't have to remove it.
+      if (nsContentUtils::HasNonEmptyAttr(this, kNameSpaceID_None,
+                                          nsGkAtoms::form)) {
+        // The current form id observer is no longer needed.
+        // A new one may be added in AfterSetAttr.
+        RemoveFormIdObserver();
+      }
+    }
+  }
+
+  return nsGenericHTMLElement::BeforeSetAttr(aNameSpaceID, aName,
+                                             aValue, aNotify);
+}
+
+nsresult
+nsGenericHTMLFormElement::AfterSetAttr(int32_t aNameSpaceID, nsIAtom* aName,
+                                       const nsAttrValue* aValue, bool aNotify)
+{
+  if (aNameSpaceID == kNameSpaceID_None) {
+    // add the control to the hashtable as needed
+
+    if (mForm && (aName == nsGkAtoms::name || aName == nsGkAtoms::id) &&
+        aValue && !aValue->IsEmptyString()) {
+      MOZ_ASSERT(aValue->Type() == nsAttrValue::eAtom,
+                 "Expected atom value for name/id");
+      mForm->AddElementToTable(this,
+        nsDependentAtomString(aValue->GetAtomValue()));
+    }
+
+    if (mForm && aName == nsGkAtoms::type) {
+      nsAutoString tmp;
+
+      GetAttr(kNameSpaceID_None, nsGkAtoms::name, tmp);
+
+      if (!tmp.IsEmpty()) {
+        mForm->AddElementToTable(this, tmp);
+      }
+
+      GetAttr(kNameSpaceID_None, nsGkAtoms::id, tmp);
+
+      if (!tmp.IsEmpty()) {
+        mForm->AddElementToTable(this, tmp);
+      }
+
+      mForm->AddElement(this, false, aNotify);
+
+      // Adding the element to the form can make it be the default control .
+      // Go ahead and notify on that change.
+      // Note: no need to notify on CanBeDisabled(), since type attr
+      // changes can't affect that.
+      UpdateState(aNotify);
+    }
+
+    if (aName == nsGkAtoms::form) {
+      // We need a new form id observer.
+      //XXXsmaug How should this work in Shadow DOM?
+      nsIDocument* doc = GetUncomposedDoc();
+      if (doc) {
+        Element* formIdElement = nullptr;
+        if (aValue && !aValue->IsEmptyString()) {
+          formIdElement = AddFormIdObserver();
+        }
+
+        // Because we have a new @form value (or no more @form), we have to
+        // update our form owner.
+        UpdateFormOwner(false, formIdElement);
+      }
+    }
+  }
+
+  return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName,
+                                            aValue, aNotify);
+}
+
+nsresult
+nsGenericHTMLFormElement::PreHandleEvent(EventChainPreVisitor& aVisitor)
+{
+  if (aVisitor.mEvent->IsTrusted()) {
+    switch (aVisitor.mEvent->mMessage) {
+      case eFocus: {
+        // Check to see if focus has bubbled up from a form control's
+        // child textfield or button.  If that's the case, don't focus
+        // this parent file control -- leave focus on the child.
+        nsIFormControlFrame* formControlFrame = GetFormControlFrame(true);
+        if (formControlFrame &&
+            aVisitor.mEvent->mOriginalTarget == static_cast<nsINode*>(this))
+          formControlFrame->SetFocus(true, true);
+        break;
+      }
+      case eBlur: {
+        nsIFormControlFrame* formControlFrame = GetFormControlFrame(true);
+        if (formControlFrame)
+          formControlFrame->SetFocus(false, false);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  return nsGenericHTMLElement::PreHandleEvent(aVisitor);
+}
+
+/* virtual */
+bool
+nsGenericHTMLFormElement::IsDisabled() const
+{
+  return HasAttr(kNameSpaceID_None, nsGkAtoms::disabled) ||
+         (mFieldSet && mFieldSet->IsDisabled());
+}
+
+void
+nsGenericHTMLFormElement::ForgetFieldSet(nsIContent* aFieldset)
+{
+  if (mFieldSet == aFieldset) {
+    mFieldSet = nullptr;
+  }
+}
+
+bool
+nsGenericHTMLFormElement::CanBeDisabled() const
+{
+  int32_t type = GetType();
+  // It's easier to test the types that _cannot_ be disabled
+  return
+    type != NS_FORM_OBJECT &&
+    type != NS_FORM_OUTPUT;
+}
+
+bool
+nsGenericHTMLFormElement::IsHTMLFocusable(bool aWithMouse,
+                                          bool* aIsFocusable,
+                                          int32_t* aTabIndex)
+{
+  if (nsGenericHTMLElement::IsHTMLFocusable(aWithMouse, aIsFocusable, aTabIndex)) {
+    return true;
+  }
+
+#ifdef XP_MACOSX
+  *aIsFocusable =
+    (!aWithMouse || nsFocusManager::sMouseFocusesFormControl) && *aIsFocusable;
+#endif
+  return false;
+}
+
+EventStates
+nsGenericHTMLFormElement::IntrinsicState() const
+{
+  // If you add attribute-dependent states here, you need to add them them to
+  // AfterSetAttr too.  And add them to AfterSetAttr for all subclasses that
+  // implement IntrinsicState() and are affected by that attribute.
+  EventStates state = nsGenericHTMLElement::IntrinsicState();
+
+  if (CanBeDisabled()) {
+    // :enabled/:disabled
+    if (IsDisabled()) {
+      state |= NS_EVENT_STATE_DISABLED;
+      state &= ~NS_EVENT_STATE_ENABLED;
+    } else {
+      state &= ~NS_EVENT_STATE_DISABLED;
+      state |= NS_EVENT_STATE_ENABLED;
+    }
+  }
+  
+  if (mForm && mForm->IsDefaultSubmitElement(this)) {
+      NS_ASSERTION(IsSubmitControl(),
+                   "Default submit element that isn't a submit control.");
+      // We are the default submit element (:default)
+      state |= NS_EVENT_STATE_DEFAULT;
+  }
+
+  // Make the text controls read-write
+  if (!state.HasState(NS_EVENT_STATE_MOZ_READWRITE) &&
+      IsTextOrNumberControl(/*aExcludePassword*/ false)) {
+    bool roState = GetBoolAttr(nsGkAtoms::readonly);
+
+    if (!roState) {
+      state |= NS_EVENT_STATE_MOZ_READWRITE;
+      state &= ~NS_EVENT_STATE_MOZ_READONLY;
+    }
+  }
+
+  return state;
+}
+
+nsGenericHTMLFormElement::FocusTristate
+nsGenericHTMLFormElement::FocusState()
+{
+  // We can't be focused if we aren't in a (composed) document
+  nsIDocument* doc = GetComposedDoc();
+  if (!doc)
+    return eUnfocusable;
+
+  // first see if we are disabled or not. If disabled then do nothing.
+  if (IsDisabled()) {
+    return eUnfocusable;
+  }
+
+  // If the window is not active, do not allow the focus to bring the
+  // window to the front.  We update the focus controller, but do
+  // nothing else.
+  if (nsPIDOMWindowOuter* win = doc->GetWindow()) {
+    nsCOMPtr<nsPIDOMWindowOuter> rootWindow = win->GetPrivateRoot();
+
+    nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
+    if (fm && rootWindow) {
+      nsCOMPtr<mozIDOMWindowProxy> activeWindow;
+      fm->GetActiveWindow(getter_AddRefs(activeWindow));
+      if (activeWindow == rootWindow) {
+        return eActiveWindow;
+      }
+    }
+  }
+
+  return eInactiveWindow;
+}
+
+Element*
+nsGenericHTMLFormElement::AddFormIdObserver()
+{
+  NS_ASSERTION(GetUncomposedDoc(), "When adding a form id observer, "
+                                   "we should be in a document!");
+
+  nsAutoString formId;
+  nsIDocument* doc = OwnerDoc();
+  GetAttr(kNameSpaceID_None, nsGkAtoms::form, formId);
+  NS_ASSERTION(!formId.IsEmpty(),
+               "@form value should not be the empty string!");
+  nsCOMPtr<nsIAtom> atom = NS_Atomize(formId);
+
+  return doc->AddIDTargetObserver(atom, FormIdUpdated, this, false);
+}
+
+void
+nsGenericHTMLFormElement::RemoveFormIdObserver()
+{
+  /**
+   * We are using OwnerDoc() because we don't really care about having the
+   * element actually being in the tree. If it is not and @form value changes,
+   * this method will be called for nothing but removing an observer which does
+   * not exist doesn't cost so much (no entry in the hash table) so having a
+   * boolean for GetUncomposedDoc()/GetOwnerDoc() would make everything look
+   * more complex for nothing.
+   */
+
+  nsIDocument* doc = OwnerDoc();
+
+  // At this point, we may not have a document anymore. In that case, we can't
+  // remove the observer. The document did that for us.
+  if (!doc) {
+    return;
+  }
+
+  nsAutoString formId;
+  GetAttr(kNameSpaceID_None, nsGkAtoms::form, formId);
+  NS_ASSERTION(!formId.IsEmpty(),
+               "@form value should not be the empty string!");
+  nsCOMPtr<nsIAtom> atom = NS_Atomize(formId);
+
+  doc->RemoveIDTargetObserver(atom, FormIdUpdated, this, false);
+}
+
+
+/* static */
+bool
+nsGenericHTMLFormElement::FormIdUpdated(Element* aOldElement,
+                                        Element* aNewElement,
+                                        void* aData)
+{
+  nsGenericHTMLFormElement* element =
+    static_cast<nsGenericHTMLFormElement*>(aData);
+
+  NS_ASSERTION(element->IsHTMLElement(), "aData should be an HTML element");
+
+  element->UpdateFormOwner(false, aNewElement);
+
+  return true;
+}
+
+bool 
+nsGenericHTMLFormElement::IsElementDisabledForEvents(EventMessage aMessage,
+                                                     nsIFrame* aFrame)
+{
+  switch (aMessage) {
+    case eMouseMove:
+    case eMouseOver:
+    case eMouseOut:
+    case eMouseEnter:
+    case eMouseLeave:
+    case ePointerMove:
+    case ePointerOver:
+    case ePointerOut:
+    case ePointerEnter:
+    case ePointerLeave:
+    case eWheel:
+    case eLegacyMouseLineOrPageScroll:
+    case eLegacyMousePixelScroll:
+      return false;
+    default:
+      break;
+  }
+
+  bool disabled = IsDisabled();
+  if (!disabled && aFrame) {
+    const nsStyleUserInterface* uiStyle = aFrame->StyleUserInterface();
+    disabled = uiStyle->mUserInput == StyleUserInput::None ||
+               uiStyle->mUserInput == StyleUserInput::Disabled;
+
+  }
+  return disabled;
+}
+
+void
+nsGenericHTMLFormElement::UpdateFormOwner(bool aBindToTree,
+                                          Element* aFormIdElement)
+{
+  NS_PRECONDITION(!aBindToTree || !aFormIdElement,
+                  "aFormIdElement shouldn't be set if aBindToTree is true!");
+
+  bool needStateUpdate = false;
+  if (!aBindToTree) {
+    needStateUpdate = mForm && mForm->IsDefaultSubmitElement(this);
+    ClearForm(true);
+  }
+
+  HTMLFormElement *oldForm = mForm;
+
+  if (!mForm) {
+    // If @form is set, we have to use that to find the form.
+    nsAutoString formId;
+    if (GetAttr(kNameSpaceID_None, nsGkAtoms::form, formId)) {
+      if (!formId.IsEmpty()) {
+        Element* element = nullptr;
+
+        if (aBindToTree) {
+          element = AddFormIdObserver();
+        } else {
+          element = aFormIdElement;
+        }
+
+        NS_ASSERTION(GetUncomposedDoc(), "The element should be in a document "
+                                         "when UpdateFormOwner is called!");
+        NS_ASSERTION(!GetUncomposedDoc() ||
+                     element == GetUncomposedDoc()->GetElementById(formId),
+                     "element should be equals to the current element "
+                     "associated with the id in @form!");
+
+        if (element && element->IsHTMLElement(nsGkAtoms::form)) {
+          mForm = static_cast<HTMLFormElement*>(element);
+        }
+      }
+     } else {
+      // We now have a parent, so we may have picked up an ancestor form.  Search
+      // for it.  Note that if mForm is already set we don't want to do this,
+      // because that means someone (probably the content sink) has already set
+      // it to the right value.  Also note that even if being bound here didn't
+      // change our parent, we still need to search, since our parent chain
+      // probably changed _somewhere_.
+      mForm = FindAncestorForm();
+    }
+  }
+
+  if (mForm && !HasFlag(ADDED_TO_FORM)) {
+    // Now we need to add ourselves to the form
+    nsAutoString nameVal, idVal;
+    GetAttr(kNameSpaceID_None, nsGkAtoms::name, nameVal);
+    GetAttr(kNameSpaceID_None, nsGkAtoms::id, idVal);
+
+    SetFlags(ADDED_TO_FORM);
+
+    // Notify only if we just found this mForm.
+    mForm->AddElement(this, true, oldForm == nullptr);
+
+    if (!nameVal.IsEmpty()) {
+      mForm->AddElementToTable(this, nameVal);
+    }
+
+    if (!idVal.IsEmpty()) {
+      mForm->AddElementToTable(this, idVal);
+    }
+  }
+
+  if (mForm != oldForm || needStateUpdate) {
+    UpdateState(true);
+  }
+}
+
+void
+nsGenericHTMLFormElement::UpdateFieldSet(bool aNotify)
+{
+  nsIContent* parent = nullptr;
+  nsIContent* prev = nullptr;
+
+  for (parent = GetParent(); parent;
+       prev = parent, parent = parent->GetParent()) {
+    HTMLFieldSetElement* fieldset =
+      HTMLFieldSetElement::FromContent(parent);
+    if (fieldset &&
+        (!prev || fieldset->GetFirstLegend() != prev)) {
+      if (mFieldSet == fieldset) {
+        // We already have the right fieldset;
+        return;
+      }
+
+      if (mFieldSet) {
+        mFieldSet->RemoveElement(this);
+      }
+      mFieldSet = fieldset;
+      fieldset->AddElement(this);
+
+      // The disabled state may have changed
+      FieldSetDisabledChanged(aNotify);
+      return;
+    }
+  }
+
+  // No fieldset found.
+  if (mFieldSet) {
+    mFieldSet->RemoveElement(this);
+    mFieldSet = nullptr;
+    // The disabled state may have changed
+    FieldSetDisabledChanged(aNotify);
+  }
+}
+
+void
+nsGenericHTMLFormElement::FieldSetDisabledChanged(bool aNotify)
+{
+  UpdateState(aNotify);
+}
+
+bool
+nsGenericHTMLFormElement::IsLabelable() const
+{
+  // TODO: keygen should be in that list, see bug 101019.
+  uint32_t type = GetType();
+  return (type & NS_FORM_INPUT_ELEMENT && type != NS_FORM_INPUT_HIDDEN) ||
+         type & NS_FORM_BUTTON_ELEMENT ||
+         // type == NS_FORM_KEYGEN ||
+         type == NS_FORM_OUTPUT ||
+         type == NS_FORM_SELECT ||
+         type == NS_FORM_TEXTAREA;
+}
+
+//----------------------------------------------------------------------
+
+void
+nsGenericHTMLElement::Click()
+{
+  if (HandlingClick())
+    return;
+
+  // Strong in case the event kills it
+  nsCOMPtr<nsIDocument> doc = GetComposedDoc();
+
+  nsCOMPtr<nsIPresShell> shell;
+  RefPtr<nsPresContext> context;
+  if (doc) {
+    shell = doc->GetShell();
+    if (shell) {
+      context = shell->GetPresContext();
+    }
+  }
+
+  SetHandlingClick();
+
+  // Click() is never called from native code, but it may be
+  // called from chrome JS. Mark this event trusted if Click()
+  // is called from chrome code.
+  WidgetMouseEvent event(nsContentUtils::IsCallerChrome(),
+                         eMouseClick, nullptr, WidgetMouseEvent::eReal);
+  event.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_UNKNOWN;
+
+  EventDispatcher::Dispatch(static_cast<nsIContent*>(this), context, &event);
+
+  ClearHandlingClick();
+}
+
+bool
+nsGenericHTMLElement::IsHTMLFocusable(bool aWithMouse,
+                                      bool *aIsFocusable,
+                                      int32_t *aTabIndex)
+{
+  nsIDocument* doc = GetComposedDoc();
+  if (!doc || doc->HasFlag(NODE_IS_EDITABLE)) {
+    // In designMode documents we only allow focusing the document.
+    if (aTabIndex) {
+      *aTabIndex = -1;
+    }
+
+    *aIsFocusable = false;
+
+    return true;
+  }
+
+  int32_t tabIndex = TabIndex();
+  bool disabled = false;
+  bool disallowOverridingFocusability = true;
+
+  if (IsEditableRoot()) {
+    // Editable roots should always be focusable.
+    disallowOverridingFocusability = true;
+
+    // Ignore the disabled attribute in editable contentEditable/designMode
+    // roots.
+    if (!HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex)) {
+      // The default value for tabindex should be 0 for editable
+      // contentEditable roots.
+      tabIndex = 0;
+    }
+  }
+  else {
+    disallowOverridingFocusability = false;
+
+    // Just check for disabled attribute on form controls
+    disabled = IsDisabled();
+    if (disabled) {
+      tabIndex = -1;
+    }
+  }
+
+  if (aTabIndex) {
+    *aTabIndex = tabIndex;
+  }
+
+  // If a tabindex is specified at all, or the default tabindex is 0, we're focusable
+  *aIsFocusable =
+    (tabIndex >= 0 || (!disabled && HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex)));
+
+  return disallowOverridingFocusability;
+}
+
+void
+nsGenericHTMLElement::RegUnRegAccessKey(bool aDoReg)
+{
+  // first check to see if we have an access key
+  nsAutoString accessKey;
+  GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accessKey);
+  if (accessKey.IsEmpty()) {
+    return;
+  }
+
+  // We have an access key, so get the ESM from the pres context.
+  nsPresContext* presContext = GetPresContext(eForUncomposedDoc);
+
+  if (presContext) {
+    EventStateManager* esm = presContext->EventStateManager();
+
+    // Register or unregister as appropriate.
+    if (aDoReg) {
+      esm->RegisterAccessKey(this, (uint32_t)accessKey.First());
+    } else {
+      esm->UnregisterAccessKey(this, (uint32_t)accessKey.First());
+    }
+  }
+}
+
+bool
+nsGenericHTMLElement::PerformAccesskey(bool aKeyCausesActivation,
+                                       bool aIsTrustedEvent)
+{
+  nsPresContext* presContext = GetPresContext(eForUncomposedDoc);
+  if (!presContext) {
+    return false;
+  }
+
+  // It's hard to say what HTML4 wants us to do in all cases.
+  bool focused = true;
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    fm->SetFocus(this, nsIFocusManager::FLAG_BYKEY);
+
+    // Return true if the element became the current focus within its window.
+    nsPIDOMWindowOuter* window = OwnerDoc()->GetWindow();
+    focused = (window && window->GetFocusedNode());
+  }
+
+  if (aKeyCausesActivation) {
+    // Click on it if the users prefs indicate to do so.
+    nsAutoPopupStatePusher popupStatePusher(aIsTrustedEvent ?
+                                            openAllowed : openAbused);
+    DispatchSimulatedClick(this, aIsTrustedEvent, presContext);
+  }
+
+  return focused;
+}
+
+nsresult
+nsGenericHTMLElement::DispatchSimulatedClick(nsGenericHTMLElement* aElement,
+                                             bool aIsTrusted,
+                                             nsPresContext* aPresContext)
+{
+  WidgetMouseEvent event(aIsTrusted, eMouseClick, nullptr,
+                         WidgetMouseEvent::eReal);
+  event.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_KEYBOARD;
+  return EventDispatcher::Dispatch(ToSupports(aElement), aPresContext, &event);
+}
+
+nsresult
+nsGenericHTMLElement::GetEditor(nsIEditor** aEditor)
+{
+  *aEditor = nullptr;
+
+  // See also HTMLTextFieldAccessible::GetEditor.
+  if (!nsContentUtils::LegacyIsCallerChromeOrNativeCode()) {
+    return NS_ERROR_DOM_SECURITY_ERR;
+  }
+
+  NS_IF_ADDREF(*aEditor = GetEditorInternal());
+  return NS_OK;
+}
+
+already_AddRefed<nsIEditor>
+nsGenericHTMLElement::GetAssociatedEditor()
+{
+  // If contenteditable is ever implemented, it might need to do something different here?
+
+  nsCOMPtr<nsIEditor> editor = GetEditorInternal();
+  return editor.forget();
+}
+
+bool
+nsGenericHTMLElement::IsCurrentBodyElement()
+{
+  // TODO Bug 698498: Should this handle the case where GetBody returns a
+  //                  frameset?
+  if (!IsHTMLElement(nsGkAtoms::body)) {
+    return false;
+  }
+
+  nsCOMPtr<nsIDOMHTMLDocument> htmlDocument =
+    do_QueryInterface(GetUncomposedDoc());
+  if (!htmlDocument) {
+    return false;
+  }
+
+  nsCOMPtr<nsIDOMHTMLElement> htmlElement;
+  htmlDocument->GetBody(getter_AddRefs(htmlElement));
+  return htmlElement == static_cast<HTMLBodyElement*>(this);
+}
+
+// static
+void
+nsGenericHTMLElement::SyncEditorsOnSubtree(nsIContent* content)
+{
+  /* Sync this node */
+  nsGenericHTMLElement* element = FromContent(content);
+  if (element) {
+    nsCOMPtr<nsIEditor> editor = element->GetAssociatedEditor();
+    if (editor) {
+      editor->SyncRealTimeSpell();
+    }
+  }
+
+  /* Sync all children */
+  for (nsIContent* child = content->GetFirstChild();
+       child;
+       child = child->GetNextSibling()) {
+    SyncEditorsOnSubtree(child);
+  }
+}
+
+void
+nsGenericHTMLElement::RecompileScriptEventListeners()
+{
+    int32_t i, count = mAttrsAndChildren.AttrCount();
+    for (i = 0; i < count; ++i) {
+        const nsAttrName *name = mAttrsAndChildren.AttrNameAt(i);
+
+        // Eventlistenener-attributes are always in the null namespace
+        if (!name->IsAtom()) {
+            continue;
+        }
+
+        nsIAtom *attr = name->Atom();
+        if (!IsEventAttributeName(attr)) {
+            continue;
+        }
+
+        nsAutoString value;
+        GetAttr(kNameSpaceID_None, attr, value);
+        SetEventHandler(attr, value, true);
+    }
+}
+
+bool
+nsGenericHTMLElement::IsEditableRoot() const
+{
+  nsIDocument *document = GetComposedDoc();
+  if (!document) {
+    return false;
+  }
+
+  if (document->HasFlag(NODE_IS_EDITABLE)) {
+    return false;
+  }
+
+  if (GetContentEditableValue() != eTrue) {
+    return false;
+  }
+
+  nsIContent *parent = GetParent();
+
+  return !parent || !parent->HasFlag(NODE_IS_EDITABLE);
+}
+
+static void
+MakeContentDescendantsEditable(nsIContent *aContent, nsIDocument *aDocument)
+{
+  // If aContent is not an element, we just need to update its
+  // internal editable state and don't need to notify anyone about
+  // that.  For elements, we need to send a ContentStateChanged
+  // notification.
+  if (!aContent->IsElement()) {
+    aContent->UpdateEditableState(false);
+    return;
+  }
+
+  Element *element = aContent->AsElement();
+
+  element->UpdateEditableState(true);
+
+  for (nsIContent *child = aContent->GetFirstChild();
+       child;
+       child = child->GetNextSibling()) {
+    if (!child->HasAttr(kNameSpaceID_None, nsGkAtoms::contenteditable)) {
+      MakeContentDescendantsEditable(child, aDocument);
+    }
+  }
+}
+
+void
+nsGenericHTMLElement::ChangeEditableState(int32_t aChange)
+{
+  //XXXsmaug Fix this for Shadow DOM, bug 1066965.
+  nsIDocument* document = GetUncomposedDoc();
+  if (!document) {
+    return;
+  }
+
+  if (aChange != 0) {
+    nsCOMPtr<nsIHTMLDocument> htmlDocument =
+      do_QueryInterface(document);
+    if (htmlDocument) {
+      htmlDocument->ChangeContentEditableCount(this, aChange);
+    }
+
+    nsIContent* parent = GetParent();
+    while (parent) {
+      parent->ChangeEditableDescendantCount(aChange);
+      parent = parent->GetParent();
+    }
+  }
+
+  if (document->HasFlag(NODE_IS_EDITABLE)) {
+    document = nullptr;
+  }
+
+  // MakeContentDescendantsEditable is going to call ContentStateChanged for
+  // this element and all descendants if editable state has changed.
+  // We might as well wrap it all in one script blocker.
+  nsAutoScriptBlocker scriptBlocker;
+  MakeContentDescendantsEditable(this, document);
+}
+
+
+//----------------------------------------------------------------------
+
+nsGenericHTMLFormElementWithState::nsGenericHTMLFormElementWithState(
+    already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo
+  )
+  : nsGenericHTMLFormElement(aNodeInfo)
+{
+  mStateKey.SetIsVoid(true);
+}
+
+nsresult
+nsGenericHTMLFormElementWithState::GenerateStateKey()
+{
+  // Keep the key if already computed
+  if (!mStateKey.IsVoid()) {
+    return NS_OK;
+  }
+
+  nsIDocument* doc = GetUncomposedDoc();
+  if (!doc) {
+    return NS_OK;
+  }
+
+  // Generate the state key
+  nsresult rv = nsContentUtils::GenerateStateKey(this, doc, mStateKey);
+
+  if (NS_FAILED(rv)) {
+    mStateKey.SetIsVoid(true);
+    return rv;
+  }
+
+  // If the state key is blank, this is anonymous content or for whatever
+  // reason we are not supposed to save/restore state: keep it as such.
+  if (!mStateKey.IsEmpty()) {
+    // Add something unique to content so layout doesn't muck us up.
+    mStateKey += "-C";
+  }
+  return NS_OK;
+}
+
+nsPresState*
+nsGenericHTMLFormElementWithState::GetPrimaryPresState()
+{
+  if (mStateKey.IsEmpty()) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsILayoutHistoryState> history = GetLayoutHistory(false);
+
+  if (!history) {
+    return nullptr;
+  }
+
+  // Get the pres state for this key, if it doesn't exist, create one.
+  nsPresState* result = history->GetState(mStateKey);
+  if (!result) {
+    result = new nsPresState();
+    history->AddState(mStateKey, result);
+  }
+
+  return result;
+}
+
+already_AddRefed<nsILayoutHistoryState>
+nsGenericHTMLFormElementWithState::GetLayoutHistory(bool aRead)
+{
+  nsCOMPtr<nsIDocument> doc = GetUncomposedDoc();
+  if (!doc) {
+    return nullptr;
+  }
+
+  //
+  // Get the history
+  //
+  nsCOMPtr<nsILayoutHistoryState> history = doc->GetLayoutHistoryState();
+  if (!history) {
+    return nullptr;
+  }
+
+  if (aRead && !history->HasStates()) {
+    return nullptr;
+  }
+
+  return history.forget();
+}
+
+bool
+nsGenericHTMLFormElementWithState::RestoreFormControlState()
+{
+  if (mStateKey.IsEmpty()) {
+    return false;
+  }
+
+  nsCOMPtr<nsILayoutHistoryState> history =
+    GetLayoutHistory(true);
+  if (!history) {
+    return false;
+  }
+
+  nsPresState *state;
+  // Get the pres state for this key
+  state = history->GetState(mStateKey);
+  if (state) {
+    bool result = RestoreState(state);
+    history->RemoveState(mStateKey);
+    return result;
+  }
+
+  return false;
+}
+
+void
+nsGenericHTMLFormElementWithState::NodeInfoChanged()
+{
+  mStateKey.SetIsVoid(true);
+}
+
+nsSize
+nsGenericHTMLElement::GetWidthHeightForImage(RefPtr<imgRequestProxy>& aImageRequest)
+{
+  nsSize size(0,0);
+
+  nsIFrame* frame = GetPrimaryFrame(Flush_Layout);
+
+  if (frame) {
+    size = frame->GetContentRect().Size();
+
+    size.width = nsPresContext::AppUnitsToIntCSSPixels(size.width);
+    size.height = nsPresContext::AppUnitsToIntCSSPixels(size.height);
+  } else {
+    const nsAttrValue* value;
+    nsCOMPtr<imgIContainer> image;
+    if (aImageRequest) {
+      aImageRequest->GetImage(getter_AddRefs(image));
+    }
+
+    if ((value = GetParsedAttr(nsGkAtoms::width)) &&
+        value->Type() == nsAttrValue::eInteger) {
+      size.width = value->GetIntegerValue();
+    } else if (image) {
+      image->GetWidth(&size.width);
+    }
+
+    if ((value = GetParsedAttr(nsGkAtoms::height)) &&
+        value->Type() == nsAttrValue::eInteger) {
+      size.height = value->GetIntegerValue();
+    } else if (image) {
+      image->GetHeight(&size.height);
+    }
+  }
+
+  NS_ASSERTION(size.width >= 0, "negative width");
+  NS_ASSERTION(size.height >= 0, "negative height");
+  return size;
+}
+
+bool
+nsGenericHTMLElement::IsEventAttributeName(nsIAtom *aName)
+{
+  return nsContentUtils::IsEventAttributeName(aName, EventNameType_HTML);
+}
+
+/**
+ * Construct a URI from a string, as an element.src attribute
+ * would be set to. Helper for the media elements.
+ */
+nsresult
+nsGenericHTMLElement::NewURIFromString(const nsAString& aURISpec,
+                                       nsIURI** aURI)
+{
+  NS_ENSURE_ARG_POINTER(aURI);
+
+  *aURI = nullptr;
+
+  nsCOMPtr<nsIDocument> doc = OwnerDoc();
+
+  nsCOMPtr<nsIURI> baseURI = GetBaseURI();
+  nsresult rv = nsContentUtils::NewURIWithDocumentCharset(aURI, aURISpec,
+                                                          doc, baseURI);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool equal;
+  if (aURISpec.IsEmpty() &&
+      doc->GetDocumentURI() &&
+      NS_SUCCEEDED(doc->GetDocumentURI()->Equals(*aURI, &equal)) &&
+      equal) {
+    // Assume an element can't point to a fragment of its embedding
+    // document. Fail here instead of returning the recursive URI
+    // and waiting for the subsequent load to fail.
+    NS_RELEASE(*aURI);
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  return NS_OK;
+}
+
+static bool
+IsOrHasAncestorWithDisplayNone(Element* aElement, nsIPresShell* aPresShell)
+{
+  nsTArray<Element*> elementsToCheck;
+  for (Element* e = aElement; e; e = e->GetParentElement()) {
+    if (e->GetPrimaryFrame()) {
+      // e definitely isn't display:none and doesn't have a display:none
+      // ancestor.
+      break;
+    }
+    elementsToCheck.AppendElement(e);
+  }
+
+  if (elementsToCheck.IsEmpty()) {
+    return false;
+  }
+
+  StyleSetHandle styleSet = aPresShell->StyleSet();
+  RefPtr<nsStyleContext> sc;
+  for (int32_t i = elementsToCheck.Length() - 1; i >= 0; --i) {
+    if (sc) {
+      sc = styleSet->ResolveStyleFor(elementsToCheck[i], sc);
+    } else {
+      sc = nsComputedDOMStyle::GetStyleContextForElementNoFlush(elementsToCheck[i],
+                                                                nullptr, aPresShell);
+    }
+    if (sc->StyleDisplay()->mDisplay == StyleDisplay::None) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void
+nsGenericHTMLElement::GetInnerText(mozilla::dom::DOMString& aValue,
+                                   mozilla::ErrorResult& aError)
+{
+  if (!GetPrimaryFrame(Flush_Layout)) {
+    nsIPresShell* presShell = nsComputedDOMStyle::GetPresShellForContent(this);
+    if (!presShell || IsOrHasAncestorWithDisplayNone(this, presShell)) {
+      GetTextContentInternal(aValue, aError);
+      return;
+    }
+  }
+
+  nsRange::GetInnerTextNoFlush(aValue, aError, this, 0, this, GetChildCount());
+}
+
+void
+nsGenericHTMLElement::SetInnerText(const nsAString& aValue)
+{
+  // Batch possible DOMSubtreeModified events.
+  mozAutoSubtreeModified subtree(OwnerDoc(), nullptr);
+  FireNodeRemovedForChildren();
+
+  // Might as well stick a batch around this since we're performing several
+  // mutations.
+  mozAutoDocUpdate updateBatch(GetComposedDoc(),
+    UPDATE_CONTENT_MODEL, true);
+  nsAutoMutationBatch mb;
+
+  uint32_t childCount = GetChildCount();
+
+  mb.Init(this, true, false);
+  for (uint32_t i = 0; i < childCount; ++i) {
+    RemoveChildAt(0, true);
+  }
+  mb.RemovalDone();
+
+  nsString str;
+  const char16_t* s = aValue.BeginReading();
+  const char16_t* end = aValue.EndReading();
+  while (true) {
+    if (s != end && *s == '\r' && s + 1 != end && s[1] == '\n') {
+      // a \r\n pair should only generate one <br>, so just skip the \r
+      ++s;
+    }
+    if (s == end || *s == '\r' || *s == '\n') {
+      if (!str.IsEmpty()) {
+        RefPtr<nsTextNode> textContent =
+          new nsTextNode(NodeInfo()->NodeInfoManager());
+        textContent->SetText(str, true);
+        AppendChildTo(textContent, true);
+      }
+      if (s == end) {
+        break;
+      }
+      str.Truncate();
+      already_AddRefed<mozilla::dom::NodeInfo> ni =
+        NodeInfo()->NodeInfoManager()->GetNodeInfo(nsGkAtoms::br,
+          nullptr, kNameSpaceID_XHTML, nsIDOMNode::ELEMENT_NODE);
+      RefPtr<HTMLBRElement> br = new HTMLBRElement(ni);
+      AppendChildTo(br, true);
+    } else {
+      str.Append(*s);
+    }
+    ++s;
+  }
+
+  mb.NodesAdded();
+}