Adding upstream version 115.7.0esr.upstream/115.7.0esr

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

17 files changed, 4187 insertions, 0 deletions

diff --git a/accessible/html/HTMLCanvasAccessible.cpp b/accessible/html/HTMLCanvasAccessible.cpp
new file mode 100644
index 0000000000..91e3f1c57d
--- /dev/null
+++ b/accessible/html/HTMLCanvasAccessible.cpp
@@ -0,0 +1,16 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "HTMLCanvasAccessible.h"
+
+#include "Role.h"
+
+using namespace mozilla::a11y;
+
+HTMLCanvasAccessible::HTMLCanvasAccessible(nsIContent* aContent,
+                                           DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+role HTMLCanvasAccessible::NativeRole() const { return roles::CANVAS; }
diff --git a/accessible/html/HTMLCanvasAccessible.h b/accessible/html/HTMLCanvasAccessible.h
new file mode 100644
index 0000000000..fc38906652
--- /dev/null
+++ b/accessible/html/HTMLCanvasAccessible.h
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_HTMLCanvasAccessible_h__
+#define mozilla_a11y_HTMLCanvasAccessible_h__
+
+#include "HyperTextAccessibleWrap.h"
+
+namespace mozilla {
+namespace a11y {
+
+/**
+ * HTML canvas accessible (html:canvas).
+ */
+class HTMLCanvasAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLCanvasAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // nsISupports
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLCanvasAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+
+ protected:
+  virtual ~HTMLCanvasAccessible() {}
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/html/HTMLElementAccessibles.cpp b/accessible/html/HTMLElementAccessibles.cpp
new file mode 100644
index 0000000000..518506fe75
--- /dev/null
+++ b/accessible/html/HTMLElementAccessibles.cpp
@@ -0,0 +1,233 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "HTMLElementAccessibles.h"
+
+#include "CacheConstants.h"
+#include "DocAccessible.h"
+#include "nsAccUtils.h"
+#include "nsTextEquivUtils.h"
+#include "Relation.h"
+#include "Role.h"
+#include "States.h"
+
+#include "mozilla/dom/HTMLLabelElement.h"
+#include "mozilla/dom/HTMLDetailsElement.h"
+#include "mozilla/dom/HTMLSummaryElement.h"
+
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLHRAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLHRAccessible::NativeRole() const { return roles::SEPARATOR; }
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLBRAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLBRAccessible::NativeRole() const { return roles::WHITESPACE; }
+
+uint64_t HTMLBRAccessible::NativeState() const { return states::READONLY; }
+
+ENameValueFlag HTMLBRAccessible::NativeName(nsString& aName) const {
+  aName = static_cast<char16_t>('\n');  // Newline char
+  return eNameOK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLLabelAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+ENameValueFlag HTMLLabelAccessible::NativeName(nsString& aName) const {
+  nsTextEquivUtils::GetNameFromSubtree(this, aName);
+  return aName.IsEmpty() ? eNameOK : eNameFromSubtree;
+}
+
+Relation HTMLLabelAccessible::RelationByType(RelationType aType) const {
+  Relation rel = AccessibleWrap::RelationByType(aType);
+  if (aType == RelationType::LABEL_FOR) {
+    dom::HTMLLabelElement* label = dom::HTMLLabelElement::FromNode(mContent);
+    rel.AppendTarget(mDoc, label->GetControl());
+  }
+
+  return rel;
+}
+
+void HTMLLabelAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
+                                              nsAtom* aAttribute,
+                                              int32_t aModType,
+                                              const nsAttrValue* aOldValue,
+                                              uint64_t aOldState) {
+  HyperTextAccessibleWrap::DOMAttributeChanged(aNameSpaceID, aAttribute,
+                                               aModType, aOldValue, aOldState);
+
+  if (aAttribute == nsGkAtoms::_for) {
+    mDoc->QueueCacheUpdate(this, CacheDomain::Relations);
+    SendCache(CacheDomain::Actions, CacheUpdateType::Update);
+  }
+}
+
+bool HTMLLabelAccessible::HasPrimaryAction() const {
+  return nsCoreUtils::IsLabelWithControl(mContent);
+}
+
+void HTMLLabelAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
+  if (aIndex == 0) {
+    if (HasPrimaryAction()) {
+      aName.AssignLiteral("click");
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsHTMLOuputAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+Relation HTMLOutputAccessible::RelationByType(RelationType aType) const {
+  Relation rel = AccessibleWrap::RelationByType(aType);
+  if (aType == RelationType::CONTROLLED_BY) {
+    rel.AppendIter(new IDRefsIterator(mDoc, mContent, nsGkAtoms::_for));
+  }
+
+  return rel;
+}
+
+void HTMLOutputAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
+                                               nsAtom* aAttribute,
+                                               int32_t aModType,
+                                               const nsAttrValue* aOldValue,
+                                               uint64_t aOldState) {
+  HyperTextAccessibleWrap::DOMAttributeChanged(aNameSpaceID, aAttribute,
+                                               aModType, aOldValue, aOldState);
+
+  if (aAttribute == nsGkAtoms::_for) {
+    mDoc->QueueCacheUpdate(this, CacheDomain::Relations);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSummaryAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLSummaryAccessible::HTMLSummaryAccessible(nsIContent* aContent,
+                                             DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {
+  mGenericTypes |= eButton;
+}
+
+bool HTMLSummaryAccessible::HasPrimaryAction() const { return true; }
+
+void HTMLSummaryAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
+  if (aIndex != eAction_Click) {
+    return;
+  }
+
+  dom::HTMLSummaryElement* summary =
+      dom::HTMLSummaryElement::FromNode(mContent);
+  if (!summary) {
+    return;
+  }
+
+  dom::HTMLDetailsElement* details = summary->GetDetails();
+  if (!details) {
+    return;
+  }
+
+  if (details->Open()) {
+    aName.AssignLiteral("collapse");
+  } else {
+    aName.AssignLiteral("expand");
+  }
+}
+
+uint64_t HTMLSummaryAccessible::NativeState() const {
+  uint64_t state = HyperTextAccessibleWrap::NativeState();
+
+  dom::HTMLSummaryElement* summary =
+      dom::HTMLSummaryElement::FromNode(mContent);
+  if (!summary) {
+    return state;
+  }
+
+  dom::HTMLDetailsElement* details = summary->GetDetails();
+  if (!details) {
+    return state;
+  }
+
+  if (details->Open()) {
+    state |= states::EXPANDED;
+  } else {
+    state |= states::COLLAPSED;
+  }
+
+  return state;
+}
+
+HTMLSummaryAccessible* HTMLSummaryAccessible::FromDetails(
+    LocalAccessible* details) {
+  if (!dom::HTMLDetailsElement::FromNodeOrNull(details->GetContent())) {
+    return nullptr;
+  }
+
+  HTMLSummaryAccessible* summaryAccessible = nullptr;
+  for (uint32_t i = 0; i < details->ChildCount(); i++) {
+    // Iterate through the children of our details accessible to locate main
+    // summary. This iteration includes the anonymous summary if the details
+    // element was not explicitly created with one.
+    LocalAccessible* child = details->LocalChildAt(i);
+    auto* summary =
+        mozilla::dom::HTMLSummaryElement::FromNodeOrNull(child->GetContent());
+    if (summary && summary->IsMainSummary()) {
+      summaryAccessible = static_cast<HTMLSummaryAccessible*>(child);
+      break;
+    }
+  }
+
+  return summaryAccessible;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSummaryAccessible: Widgets
+
+bool HTMLSummaryAccessible::IsWidget() const { return true; }
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLHeaderOrFooterAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLHeaderOrFooterAccessible::NativeRole() const {
+  // Only map header and footer if they are direct descendants of the body tag.
+  // If other sectioning or sectioning root elements, they become sections.
+  nsIContent* parent = mContent->GetParent();
+  while (parent) {
+    if (parent->IsAnyOfHTMLElements(
+            nsGkAtoms::article, nsGkAtoms::aside, nsGkAtoms::nav,
+            nsGkAtoms::section, nsGkAtoms::main, nsGkAtoms::blockquote,
+            nsGkAtoms::details, nsGkAtoms::dialog, nsGkAtoms::fieldset,
+            nsGkAtoms::figure, nsGkAtoms::td)) {
+      break;
+    }
+    parent = parent->GetParent();
+  }
+
+  // No sectioning or sectioning root elements found.
+  if (!parent) {
+    return roles::LANDMARK;
+  }
+
+  return roles::SECTION;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSectionAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLSectionAccessible::NativeRole() const {
+  nsAutoString name;
+  const_cast<HTMLSectionAccessible*>(this)->Name(name);
+  return name.IsEmpty() ? roles::SECTION : roles::REGION;
+}
diff --git a/accessible/html/HTMLElementAccessibles.h b/accessible/html/HTMLElementAccessibles.h
new file mode 100644
index 0000000000..b45e945912
--- /dev/null
+++ b/accessible/html/HTMLElementAccessibles.h
@@ -0,0 +1,160 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_HTMLElementAccessibles_h__
+#define mozilla_a11y_HTMLElementAccessibles_h__
+
+#include "BaseAccessibles.h"
+
+namespace mozilla {
+namespace a11y {
+
+/**
+ * Used for HTML hr element.
+ */
+class HTMLHRAccessible : public LeafAccessible {
+ public:
+  HTMLHRAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : LeafAccessible(aContent, aDoc) {}
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+};
+
+/**
+ * Used for HTML br element.
+ */
+class HTMLBRAccessible : public LeafAccessible {
+ public:
+  HTMLBRAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : LeafAccessible(aContent, aDoc) {
+    mType = eHTMLBRType;
+    mGenericTypes |= eText;
+  }
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+
+ protected:
+  // LocalAccessible
+  virtual ENameValueFlag NativeName(nsString& aName) const override;
+};
+
+/**
+ * Used for HTML label element.
+ */
+class HTMLLabelAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLLabelAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLLabelAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual Relation RelationByType(RelationType aType) const override;
+
+  // ActionAccessible
+  virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
+  virtual bool HasPrimaryAction() const override;
+
+ protected:
+  virtual ~HTMLLabelAccessible() {}
+  virtual ENameValueFlag NativeName(nsString& aName) const override;
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+};
+
+/**
+ * Used for HTML output element.
+ */
+class HTMLOutputAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLOutputAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLOutputAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual Relation RelationByType(RelationType aType) const override;
+
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+
+ protected:
+  virtual ~HTMLOutputAccessible() {}
+};
+
+/**
+ * Accessible for the HTML summary element.
+ */
+class HTMLSummaryAccessible : public HyperTextAccessibleWrap {
+ public:
+  enum { eAction_Click = 0 };
+
+  HTMLSummaryAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // Check that the given LocalAccessible belongs to a details frame.
+  // If so, find and return the accessible for the detail frame's
+  // main summary.
+  static HTMLSummaryAccessible* FromDetails(LocalAccessible* aDetails);
+
+  // LocalAccessible
+  virtual uint64_t NativeState() const override;
+
+  // ActionAccessible
+  virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
+  virtual bool HasPrimaryAction() const override;
+
+  // Widgets
+  virtual bool IsWidget() const override;
+};
+
+/**
+ * Used for HTML header and footer elements.
+ */
+class HTMLHeaderOrFooterAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLHeaderOrFooterAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLHeaderOrFooterAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+
+ protected:
+  virtual ~HTMLHeaderOrFooterAccessible() {}
+};
+
+/**
+ * Used for HTML section element.
+ */
+class HTMLSectionAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLSectionAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLSectionAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+
+ protected:
+  virtual ~HTMLSectionAccessible() = default;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/html/HTMLFormControlAccessible.cpp b/accessible/html/HTMLFormControlAccessible.cpp
new file mode 100644
index 0000000000..a2470b6035
--- /dev/null
+++ b/accessible/html/HTMLFormControlAccessible.cpp
@@ -0,0 +1,995 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "HTMLFormControlAccessible.h"
+
+#include "CacheConstants.h"
+#include "DocAccessible-inl.h"
+#include "LocalAccessible-inl.h"
+#include "nsAccUtils.h"
+#include "nsEventShell.h"
+#include "nsTextEquivUtils.h"
+#include "Relation.h"
+#include "Role.h"
+#include "States.h"
+
+#include "nsContentList.h"
+#include "mozilla/dom/HTMLInputElement.h"
+#include "mozilla/dom/HTMLTextAreaElement.h"
+#include "nsIFormControl.h"
+#include "nsITextControlFrame.h"
+#include "nsNameSpaceManager.h"
+#include "mozilla/dom/ScriptSettings.h"
+
+#include "mozilla/EditorBase.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/TextEditor.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLFormAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLFormAccessible::NativeRole() const {
+  nsAutoString name;
+  const_cast<HTMLFormAccessible*>(this)->Name(name);
+  return name.IsEmpty() ? roles::FORM : roles::FORM_LANDMARK;
+}
+
+void HTMLFormAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
+                                             nsAtom* aAttribute,
+                                             int32_t aModType,
+                                             const nsAttrValue* aOldValue,
+                                             uint64_t aOldState) {
+  HyperTextAccessibleWrap::DOMAttributeChanged(aNameSpaceID, aAttribute,
+                                               aModType, aOldValue, aOldState);
+  if (aAttribute == nsGkAtoms::autocomplete) {
+    dom::HTMLFormElement* formEl = dom::HTMLFormElement::FromNode(mContent);
+
+    nsIHTMLCollection* controls = formEl->Elements();
+    uint32_t length = controls->Length();
+    for (uint32_t i = 0; i < length; i++) {
+      if (LocalAccessible* acc = mDoc->GetAccessible(controls->Item(i))) {
+        if (acc->IsTextField() && !acc->IsPassword()) {
+          if (!acc->Elm()->HasAttr(nsGkAtoms::list_) &&
+              !acc->Elm()->AttrValueIs(kNameSpaceID_None,
+                                       nsGkAtoms::autocomplete, nsGkAtoms::OFF,
+                                       eIgnoreCase)) {
+            RefPtr<AccEvent> stateChangeEvent =
+                new AccStateChangeEvent(acc, states::SUPPORTS_AUTOCOMPLETION);
+            mDoc->FireDelayedEvent(stateChangeEvent);
+          }
+        }
+      }
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLRadioButtonAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+uint64_t HTMLRadioButtonAccessible::NativeState() const {
+  uint64_t state = AccessibleWrap::NativeState();
+
+  state |= states::CHECKABLE;
+
+  HTMLInputElement* input = HTMLInputElement::FromNode(mContent);
+  if (input && input->Checked()) state |= states::CHECKED;
+
+  return state;
+}
+
+void HTMLRadioButtonAccessible::GetPositionAndSetSize(int32_t* aPosInSet,
+                                                      int32_t* aSetSize) {
+  Unused << ComputeGroupAttributes(aPosInSet, aSetSize);
+}
+
+void HTMLRadioButtonAccessible::DOMAttributeChanged(
+    int32_t aNameSpaceID, nsAtom* aAttribute, int32_t aModType,
+    const nsAttrValue* aOldValue, uint64_t aOldState) {
+  if (aAttribute == nsGkAtoms::name) {
+    // If our name changed, it's possible our MEMBER_OF relation
+    // also changed. Push a cache update for Relations.
+    mDoc->QueueCacheUpdate(this, CacheDomain::Relations);
+  } else {
+    // Otherwise, handle this attribute change the way our parent
+    // class wants us to handle it.
+    RadioButtonAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute,
+                                               aModType, aOldValue, aOldState);
+  }
+}
+
+Relation HTMLRadioButtonAccessible::ComputeGroupAttributes(
+    int32_t* aPosInSet, int32_t* aSetSize) const {
+  Relation rel = Relation();
+  int32_t namespaceId = mContent->NodeInfo()->NamespaceID();
+  nsAutoString tagName;
+  mContent->NodeInfo()->GetName(tagName);
+
+  nsAutoString type;
+  mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::type, type);
+  nsAutoString name;
+  mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::name, name);
+
+  RefPtr<nsContentList> inputElms;
+
+  nsCOMPtr<nsIFormControl> formControlNode(do_QueryInterface(mContent));
+  if (dom::Element* formElm = formControlNode->GetForm()) {
+    inputElms = NS_GetContentList(formElm, namespaceId, tagName);
+  } else {
+    inputElms = NS_GetContentList(mContent->OwnerDoc(), namespaceId, tagName);
+  }
+  NS_ENSURE_TRUE(inputElms, rel);
+
+  uint32_t inputCount = inputElms->Length(false);
+
+  // Compute posinset and setsize.
+  int32_t indexOf = 0;
+  int32_t count = 0;
+
+  for (uint32_t index = 0; index < inputCount; index++) {
+    nsIContent* inputElm = inputElms->Item(index, false);
+    if (inputElm->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                           type, eCaseMatters) &&
+        inputElm->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name,
+                                           name, eCaseMatters) &&
+        mDoc->HasAccessible(inputElm)) {
+      count++;
+      rel.AppendTarget(mDoc->GetAccessible(inputElm));
+      if (inputElm == mContent) indexOf = count;
+    }
+  }
+
+  *aPosInSet = indexOf;
+  *aSetSize = count;
+  return rel;
+}
+
+Relation HTMLRadioButtonAccessible::RelationByType(RelationType aType) const {
+  if (aType == RelationType::MEMBER_OF) {
+    int32_t unusedPos, unusedSetSize;
+    return ComputeGroupAttributes(&unusedPos, &unusedSetSize);
+  }
+
+  return LocalAccessible::RelationByType(aType);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLButtonAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLButtonAccessible::HTMLButtonAccessible(nsIContent* aContent,
+                                           DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {
+  mGenericTypes |= eButton;
+}
+
+bool HTMLButtonAccessible::HasPrimaryAction() const { return true; }
+
+void HTMLButtonAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
+  if (aIndex == eAction_Click) aName.AssignLiteral("press");
+}
+
+uint64_t HTMLButtonAccessible::State() {
+  uint64_t state = HyperTextAccessibleWrap::State();
+  if (state == states::DEFUNCT) return state;
+
+  // Inherit states from input@type="file" suitable for the button. Note,
+  // no special processing for unavailable state since inheritance is supplied
+  // other code paths.
+  if (mParent && mParent->IsHTMLFileInput()) {
+    uint64_t parentState = mParent->State();
+    state |= parentState & (states::BUSY | states::REQUIRED | states::HASPOPUP |
+                            states::INVALID);
+  }
+
+  return state;
+}
+
+uint64_t HTMLButtonAccessible::NativeState() const {
+  uint64_t state = HyperTextAccessibleWrap::NativeState();
+
+  ElementState elmState = mContent->AsElement()->State();
+  if (elmState.HasState(ElementState::DEFAULT)) state |= states::DEFAULT;
+
+  return state;
+}
+
+role HTMLButtonAccessible::NativeRole() const { return roles::PUSHBUTTON; }
+
+ENameValueFlag HTMLButtonAccessible::NativeName(nsString& aName) const {
+  // No need to check @value attribute for buttons since this attribute results
+  // in native anonymous text node and the name is calculated from subtree.
+  // The same magic works for @alt and @value attributes in case of type="image"
+  // element that has no valid @src (note if input@type="image" has an image
+  // then neither @alt nor @value attributes are used to generate a visual label
+  // and thus we need to obtain the accessible name directly from attribute
+  // value). Also the same algorithm works in case of default labels for
+  // type="submit"/"reset"/"image" elements.
+
+  ENameValueFlag nameFlag = LocalAccessible::NativeName(aName);
+  if (!aName.IsEmpty() || !mContent->IsHTMLElement(nsGkAtoms::input) ||
+      !mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                          nsGkAtoms::image, eCaseMatters)) {
+    return nameFlag;
+  }
+
+  if (!mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::alt,
+                                      aName)) {
+    mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value, aName);
+  }
+
+  aName.CompressWhitespace();
+  return eNameOK;
+}
+
+void HTMLButtonAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
+                                               nsAtom* aAttribute,
+                                               int32_t aModType,
+                                               const nsAttrValue* aOldValue,
+                                               uint64_t aOldState) {
+  HyperTextAccessibleWrap::DOMAttributeChanged(aNameSpaceID, aAttribute,
+                                               aModType, aOldValue, aOldState);
+
+  if (aAttribute == nsGkAtoms::value) {
+    dom::Element* elm = Elm();
+    if (elm->IsHTMLElement(nsGkAtoms::input) ||
+        (elm->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type, nsGkAtoms::image,
+                          eCaseMatters) &&
+         !elm->HasAttr(kNameSpaceID_None, nsGkAtoms::alt))) {
+      if (!nsAccUtils::HasARIAAttr(elm, nsGkAtoms::aria_labelledby) &&
+          !nsAccUtils::HasARIAAttr(elm, nsGkAtoms::aria_label)) {
+        mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, this);
+      }
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLButtonAccessible: Widgets
+
+bool HTMLButtonAccessible::IsWidget() const { return true; }
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTextFieldAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLTextFieldAccessible::HTMLTextFieldAccessible(nsIContent* aContent,
+                                                 DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {
+  mType = mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                             nsGkAtoms::password, eIgnoreCase)
+              ? eHTMLTextPasswordFieldType
+              : eHTMLTextFieldType;
+}
+
+role HTMLTextFieldAccessible::NativeRole() const {
+  if (mType == eHTMLTextPasswordFieldType) {
+    return roles::PASSWORD_TEXT;
+  }
+  if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::list_)) {
+    return roles::EDITCOMBOBOX;
+  }
+  return roles::ENTRY;
+}
+
+already_AddRefed<AccAttributes> HTMLTextFieldAccessible::NativeAttributes() {
+  RefPtr<AccAttributes> attributes =
+      HyperTextAccessibleWrap::NativeAttributes();
+
+  // Expose type for text input elements as it gives some useful context,
+  // especially for mobile.
+  if (const nsAttrValue* attr =
+          mContent->AsElement()->GetParsedAttr(nsGkAtoms::type)) {
+    RefPtr<nsAtom> inputType = attr->GetAsAtom();
+    if (inputType) {
+      if (!ARIARoleMap() && inputType == nsGkAtoms::search) {
+        attributes->SetAttribute(nsGkAtoms::xmlroles, nsGkAtoms::searchbox);
+      }
+      attributes->SetAttribute(nsGkAtoms::textInputType, inputType);
+    }
+  }
+  // If this element  has the placeholder attribute set,
+  // and if that is not identical to the name, expose it as an object attribute.
+  nsString placeholderText;
+  if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder,
+                                     placeholderText)) {
+    nsAutoString name;
+    const_cast<HTMLTextFieldAccessible*>(this)->Name(name);
+    if (!name.Equals(placeholderText)) {
+      attributes->SetAttribute(nsGkAtoms::placeholder,
+                               std::move(placeholderText));
+    }
+  }
+
+  return attributes.forget();
+}
+
+ENameValueFlag HTMLTextFieldAccessible::NativeName(nsString& aName) const {
+  ENameValueFlag nameFlag = LocalAccessible::NativeName(aName);
+  if (!aName.IsEmpty()) return nameFlag;
+
+  if (!aName.IsEmpty()) return eNameOK;
+
+  // text inputs and textareas might have useful placeholder text
+  mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder,
+                                 aName);
+  return eNameOK;
+}
+
+void HTMLTextFieldAccessible::Value(nsString& aValue) const {
+  aValue.Truncate();
+  if (NativeState() & states::PROTECTED) {  // Don't return password text!
+    return;
+  }
+
+  HTMLTextAreaElement* textArea = HTMLTextAreaElement::FromNode(mContent);
+  if (textArea) {
+    textArea->GetValue(aValue);
+    return;
+  }
+
+  HTMLInputElement* input = HTMLInputElement::FromNode(mContent);
+  if (input) {
+    // Pass NonSystem as the caller type, to be safe.  We don't expect to have a
+    // file input here.
+    input->GetValue(aValue, CallerType::NonSystem);
+  }
+}
+
+bool HTMLTextFieldAccessible::AttributeChangesState(nsAtom* aAttribute) {
+  if (aAttribute == nsGkAtoms::readonly || aAttribute == nsGkAtoms::list_ ||
+      aAttribute == nsGkAtoms::autocomplete) {
+    return true;
+  }
+
+  return LocalAccessible::AttributeChangesState(aAttribute);
+}
+
+void HTMLTextFieldAccessible::ApplyARIAState(uint64_t* aState) const {
+  HyperTextAccessibleWrap::ApplyARIAState(aState);
+  aria::MapToState(aria::eARIAAutoComplete, mContent->AsElement(), aState);
+}
+
+uint64_t HTMLTextFieldAccessible::NativeState() const {
+  uint64_t state = HyperTextAccessibleWrap::NativeState();
+
+  // Text fields are always editable, even if they are also read only or
+  // disabled.
+  state |= states::EDITABLE;
+
+  // can be focusable, focused, protected. readonly, unavailable, selected
+  if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                         nsGkAtoms::password, eIgnoreCase)) {
+    state |= states::PROTECTED;
+  }
+
+  if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::readonly)) {
+    state |= states::READONLY;
+  }
+
+  // Is it an <input> or a <textarea> ?
+  HTMLInputElement* input = HTMLInputElement::FromNode(mContent);
+  state |= input && input->IsSingleLineTextControl() ? states::SINGLE_LINE
+                                                     : states::MULTI_LINE;
+
+  if (state & (states::PROTECTED | states::MULTI_LINE | states::READONLY |
+               states::UNAVAILABLE)) {
+    return state;
+  }
+
+  // Expose autocomplete state if it has associated autocomplete list.
+  if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::list_)) {
+    return state | states::SUPPORTS_AUTOCOMPLETION | states::HASPOPUP;
+  }
+
+  if (Preferences::GetBool("browser.formfill.enable")) {
+    // Check to see if autocompletion is allowed on this input. We don't expose
+    // it for password fields even though the entire password can be remembered
+    // for a page if the user asks it to be. However, the kind of autocomplete
+    // we're talking here is based on what the user types, where a popup of
+    // possible choices comes up.
+    nsAutoString autocomplete;
+    mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::autocomplete,
+                                   autocomplete);
+
+    if (!autocomplete.LowerCaseEqualsLiteral("off")) {
+      Element* formElement = input->GetForm();
+      if (formElement) {
+        formElement->GetAttr(kNameSpaceID_None, nsGkAtoms::autocomplete,
+                             autocomplete);
+      }
+
+      if (!formElement || !autocomplete.LowerCaseEqualsLiteral("off")) {
+        state |= states::SUPPORTS_AUTOCOMPLETION;
+      }
+    }
+  }
+
+  return state;
+}
+
+bool HTMLTextFieldAccessible::HasPrimaryAction() const { return true; }
+
+void HTMLTextFieldAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
+  if (aIndex == eAction_Click) aName.AssignLiteral("activate");
+}
+
+bool HTMLTextFieldAccessible::DoAction(uint8_t aIndex) const {
+  if (aIndex != 0) return false;
+
+  if (FocusMgr()->IsFocused(this)) {
+    // This already has focus, so TakeFocus()will do nothing. However, the user
+    // might be activating this element because they dismissed a touch keyboard
+    // and want to bring it back.
+    DoCommand();
+  } else {
+    TakeFocus();
+  }
+  return true;
+}
+
+already_AddRefed<EditorBase> HTMLTextFieldAccessible::GetEditor() const {
+  RefPtr<TextControlElement> textControlElement =
+      TextControlElement::FromNodeOrNull(mContent);
+  if (!textControlElement) {
+    return nullptr;
+  }
+  RefPtr<TextEditor> textEditor = textControlElement->GetTextEditor();
+  return textEditor.forget();
+}
+
+void HTMLTextFieldAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
+                                                  nsAtom* aAttribute,
+                                                  int32_t aModType,
+                                                  const nsAttrValue* aOldValue,
+                                                  uint64_t aOldState) {
+  if (aAttribute == nsGkAtoms::placeholder) {
+    mDoc->QueueCacheUpdate(this, CacheDomain::NameAndDescription);
+    return;
+  }
+  HyperTextAccessibleWrap::DOMAttributeChanged(aNameSpaceID, aAttribute,
+                                               aModType, aOldValue, aOldState);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTextFieldAccessible: Widgets
+
+bool HTMLTextFieldAccessible::IsWidget() const { return true; }
+
+LocalAccessible* HTMLTextFieldAccessible::ContainerWidget() const {
+  if (!mParent || mParent->Role() != roles::AUTOCOMPLETE) {
+    return nullptr;
+  }
+  return mParent;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLFileInputAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLFileInputAccessible::HTMLFileInputAccessible(nsIContent* aContent,
+                                                 DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {
+  mType = eHTMLFileInputType;
+}
+
+role HTMLFileInputAccessible::NativeRole() const {
+  // No specific role in AT APIs. We use GROUPING so that the label will be
+  // reported by screen readers when focus enters this control .
+  return roles::GROUPING;
+}
+
+nsresult HTMLFileInputAccessible::HandleAccEvent(AccEvent* aEvent) {
+  nsresult rv = HyperTextAccessibleWrap::HandleAccEvent(aEvent);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Redirect state change events for inherited states to child controls. Note,
+  // unavailable state is not redirected. That's a standard for unavailable
+  // state handling.
+  AccStateChangeEvent* event = downcast_accEvent(aEvent);
+  if (event && (event->GetState() == states::BUSY ||
+                event->GetState() == states::REQUIRED ||
+                event->GetState() == states::HASPOPUP ||
+                event->GetState() == states::INVALID)) {
+    LocalAccessible* button = LocalChildAt(0);
+    if (button && button->Role() == roles::PUSHBUTTON) {
+      RefPtr<AccStateChangeEvent> childEvent = new AccStateChangeEvent(
+          button, event->GetState(), event->IsStateEnabled(),
+          event->FromUserInput());
+      nsEventShell::FireEvent(childEvent);
+    }
+  }
+
+  return NS_OK;
+}
+
+LocalAccessible* HTMLFileInputAccessible::CurrentItem() const {
+  // Allow aria-activedescendant to override.
+  if (LocalAccessible* item = HyperTextAccessibleWrap::CurrentItem()) {
+    return item;
+  }
+
+  // The HTML file input itself gets DOM focus, not the button inside it.
+  // For a11y, we want the button to get focus.
+  LocalAccessible* button = LocalFirstChild();
+  if (!button) {
+    MOZ_ASSERT_UNREACHABLE("File input doesn't contain a button");
+    return nullptr;
+  }
+  MOZ_ASSERT(button->IsButton());
+  return button;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSpinnerAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLSpinnerAccessible::NativeRole() const { return roles::SPINBUTTON; }
+
+void HTMLSpinnerAccessible::Value(nsString& aValue) const {
+  HTMLTextFieldAccessible::Value(aValue);
+  if (!aValue.IsEmpty()) return;
+
+  // Pass NonSystem as the caller type, to be safe.  We don't expect to have a
+  // file input here.
+  HTMLInputElement::FromNode(mContent)->GetValue(aValue, CallerType::NonSystem);
+}
+
+double HTMLSpinnerAccessible::MaxValue() const {
+  double value = HTMLTextFieldAccessible::MaxValue();
+  if (!std::isnan(value)) return value;
+
+  return HTMLInputElement::FromNode(mContent)->GetMaximum().toDouble();
+}
+
+double HTMLSpinnerAccessible::MinValue() const {
+  double value = HTMLTextFieldAccessible::MinValue();
+  if (!std::isnan(value)) return value;
+
+  return HTMLInputElement::FromNode(mContent)->GetMinimum().toDouble();
+}
+
+double HTMLSpinnerAccessible::Step() const {
+  double value = HTMLTextFieldAccessible::Step();
+  if (!std::isnan(value)) return value;
+
+  return HTMLInputElement::FromNode(mContent)->GetStep().toDouble();
+}
+
+double HTMLSpinnerAccessible::CurValue() const {
+  double value = HTMLTextFieldAccessible::CurValue();
+  if (!std::isnan(value)) return value;
+
+  return HTMLInputElement::FromNode(mContent)->GetValueAsDecimal().toDouble();
+}
+
+bool HTMLSpinnerAccessible::SetCurValue(double aValue) {
+  ErrorResult er;
+  HTMLInputElement::FromNode(mContent)->SetValueAsNumber(aValue, er);
+  return !er.Failed();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLRangeAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLRangeAccessible::NativeRole() const { return roles::SLIDER; }
+
+bool HTMLRangeAccessible::IsWidget() const { return true; }
+
+void HTMLRangeAccessible::Value(nsString& aValue) const {
+  LeafAccessible::Value(aValue);
+  if (!aValue.IsEmpty()) return;
+
+  // Pass NonSystem as the caller type, to be safe.  We don't expect to have a
+  // file input here.
+  HTMLInputElement::FromNode(mContent)->GetValue(aValue, CallerType::NonSystem);
+}
+
+double HTMLRangeAccessible::MaxValue() const {
+  double value = LeafAccessible::MaxValue();
+  if (!std::isnan(value)) return value;
+
+  return HTMLInputElement::FromNode(mContent)->GetMaximum().toDouble();
+}
+
+double HTMLRangeAccessible::MinValue() const {
+  double value = LeafAccessible::MinValue();
+  if (!std::isnan(value)) return value;
+
+  return HTMLInputElement::FromNode(mContent)->GetMinimum().toDouble();
+}
+
+double HTMLRangeAccessible::Step() const {
+  double value = LeafAccessible::Step();
+  if (!std::isnan(value)) return value;
+
+  return HTMLInputElement::FromNode(mContent)->GetStep().toDouble();
+}
+
+double HTMLRangeAccessible::CurValue() const {
+  double value = LeafAccessible::CurValue();
+  if (!std::isnan(value)) return value;
+
+  return HTMLInputElement::FromNode(mContent)->GetValueAsDecimal().toDouble();
+}
+
+bool HTMLRangeAccessible::SetCurValue(double aValue) {
+  nsAutoString strValue;
+  strValue.AppendFloat(aValue);
+  HTMLInputElement::FromNode(mContent)->SetUserInput(
+      strValue, *nsContentUtils::GetSystemPrincipal());
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLGroupboxAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLGroupboxAccessible::HTMLGroupboxAccessible(nsIContent* aContent,
+                                               DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+role HTMLGroupboxAccessible::NativeRole() const { return roles::GROUPING; }
+
+nsIContent* HTMLGroupboxAccessible::GetLegend() const {
+  for (nsIContent* legendContent = mContent->GetFirstChild(); legendContent;
+       legendContent = legendContent->GetNextSibling()) {
+    if (legendContent->NodeInfo()->Equals(nsGkAtoms::legend,
+                                          mContent->GetNameSpaceID())) {
+      // Either XHTML namespace or no namespace
+      return legendContent;
+    }
+  }
+
+  return nullptr;
+}
+
+ENameValueFlag HTMLGroupboxAccessible::NativeName(nsString& aName) const {
+  ENameValueFlag nameFlag = LocalAccessible::NativeName(aName);
+  if (!aName.IsEmpty()) return nameFlag;
+
+  nsIContent* legendContent = GetLegend();
+  if (legendContent) {
+    nsTextEquivUtils::AppendTextEquivFromContent(this, legendContent, &aName);
+  }
+
+  aName.CompressWhitespace();
+  return eNameOK;
+}
+
+Relation HTMLGroupboxAccessible::RelationByType(RelationType aType) const {
+  Relation rel = HyperTextAccessibleWrap::RelationByType(aType);
+  // No override for label, so use <legend> for this <fieldset>
+  if (aType == RelationType::LABELLED_BY) rel.AppendTarget(mDoc, GetLegend());
+
+  return rel;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLLegendAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLLegendAccessible::HTMLLegendAccessible(nsIContent* aContent,
+                                           DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+Relation HTMLLegendAccessible::RelationByType(RelationType aType) const {
+  Relation rel = HyperTextAccessibleWrap::RelationByType(aType);
+  if (aType != RelationType::LABEL_FOR) return rel;
+
+  LocalAccessible* groupbox = LocalParent();
+  if (groupbox && groupbox->Role() == roles::GROUPING) {
+    rel.AppendTarget(groupbox);
+  }
+
+  return rel;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLFigureAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLFigureAccessible::HTMLFigureAccessible(nsIContent* aContent,
+                                           DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+ENameValueFlag HTMLFigureAccessible::NativeName(nsString& aName) const {
+  ENameValueFlag nameFlag = HyperTextAccessibleWrap::NativeName(aName);
+  if (!aName.IsEmpty()) return nameFlag;
+
+  nsIContent* captionContent = Caption();
+  if (captionContent) {
+    nsTextEquivUtils::AppendTextEquivFromContent(this, captionContent, &aName);
+  }
+
+  aName.CompressWhitespace();
+  return eNameOK;
+}
+
+Relation HTMLFigureAccessible::RelationByType(RelationType aType) const {
+  Relation rel = HyperTextAccessibleWrap::RelationByType(aType);
+  if (aType == RelationType::LABELLED_BY) rel.AppendTarget(mDoc, Caption());
+
+  return rel;
+}
+
+nsIContent* HTMLFigureAccessible::Caption() const {
+  for (nsIContent* childContent = mContent->GetFirstChild(); childContent;
+       childContent = childContent->GetNextSibling()) {
+    if (childContent->NodeInfo()->Equals(nsGkAtoms::figcaption,
+                                         mContent->GetNameSpaceID())) {
+      return childContent;
+    }
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLFigcaptionAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLFigcaptionAccessible::HTMLFigcaptionAccessible(nsIContent* aContent,
+                                                   DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+Relation HTMLFigcaptionAccessible::RelationByType(RelationType aType) const {
+  Relation rel = HyperTextAccessibleWrap::RelationByType(aType);
+  if (aType != RelationType::LABEL_FOR) return rel;
+
+  LocalAccessible* figure = LocalParent();
+  if (figure && figure->GetContent()->NodeInfo()->Equals(
+                    nsGkAtoms::figure, mContent->GetNameSpaceID())) {
+    rel.AppendTarget(figure);
+  }
+
+  return rel;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLProgressAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLProgressAccessible::NativeRole() const { return roles::PROGRESSBAR; }
+
+uint64_t HTMLProgressAccessible::NativeState() const {
+  uint64_t state = LeafAccessible::NativeState();
+
+  // An undetermined progressbar (i.e. without a value) has a mixed state.
+  nsAutoString attrValue;
+  mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value,
+                                 attrValue);
+  if (attrValue.IsEmpty()) {
+    state |= states::MIXED;
+  }
+
+  return state;
+}
+
+bool HTMLProgressAccessible::IsWidget() const { return true; }
+
+void HTMLProgressAccessible::Value(nsString& aValue) const {
+  LeafAccessible::Value(aValue);
+  if (!aValue.IsEmpty()) {
+    return;
+  }
+
+  double maxValue = MaxValue();
+  if (std::isnan(maxValue) || maxValue == 0) {
+    return;
+  }
+
+  double curValue = CurValue();
+  if (std::isnan(curValue)) {
+    return;
+  }
+
+  // Treat the current value bigger than maximum as 100%.
+  double percentValue =
+      (curValue < maxValue) ? (curValue / maxValue) * 100 : 100;
+
+  aValue.AppendFloat(percentValue);
+  aValue.Append('%');
+}
+
+double HTMLProgressAccessible::MaxValue() const {
+  double value = LeafAccessible::MaxValue();
+  if (!std::isnan(value)) {
+    return value;
+  }
+
+  nsAutoString strValue;
+  if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::max,
+                                     strValue)) {
+    nsresult result = NS_OK;
+    value = strValue.ToDouble(&result);
+    if (NS_SUCCEEDED(result)) {
+      return value;
+    }
+  }
+
+  return 1;
+}
+
+double HTMLProgressAccessible::MinValue() const {
+  double value = LeafAccessible::MinValue();
+  return std::isnan(value) ? 0 : value;
+}
+
+double HTMLProgressAccessible::Step() const {
+  double value = LeafAccessible::Step();
+  return std::isnan(value) ? 0 : value;
+}
+
+double HTMLProgressAccessible::CurValue() const {
+  double value = LeafAccessible::CurValue();
+  if (!std::isnan(value)) {
+    return value;
+  }
+
+  nsAutoString attrValue;
+  if (!mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value,
+                                      attrValue)) {
+    return UnspecifiedNaN<double>();
+  }
+
+  nsresult error = NS_OK;
+  value = attrValue.ToDouble(&error);
+  return NS_FAILED(error) ? UnspecifiedNaN<double>() : value;
+}
+
+bool HTMLProgressAccessible::SetCurValue(double aValue) {
+  return false;  // progress meters are readonly.
+}
+
+void HTMLProgressAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
+                                                 nsAtom* aAttribute,
+                                                 int32_t aModType,
+                                                 const nsAttrValue* aOldValue,
+                                                 uint64_t aOldState) {
+  LeafAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute, aModType,
+                                      aOldValue, aOldState);
+
+  if (aAttribute == nsGkAtoms::value) {
+    mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE, this);
+
+    uint64_t currState = NativeState();
+    if ((aOldState ^ currState) & states::MIXED) {
+      RefPtr<AccEvent> stateChangeEvent = new AccStateChangeEvent(
+          this, states::MIXED, (currState & states::MIXED));
+      mDoc->FireDelayedEvent(stateChangeEvent);
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLMeterAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLMeterAccessible::NativeRole() const { return roles::METER; }
+
+bool HTMLMeterAccessible::IsWidget() const { return true; }
+
+void HTMLMeterAccessible::Value(nsString& aValue) const {
+  LeafAccessible::Value(aValue);
+  if (!aValue.IsEmpty()) {
+    return;
+  }
+
+  // If we did not get a value from the above LeafAccessible call,
+  // we should check to see if the meter has inner text.
+  // If it does, we'll use that as our value.
+  nsTextEquivUtils::AppendFromDOMChildren(mContent, &aValue);
+  aValue.CompressWhitespace();
+  if (!aValue.IsEmpty()) {
+    return;
+  }
+
+  // If no inner text is found, use curValue
+  double curValue = CurValue();
+  if (std::isnan(curValue)) {
+    return;
+  }
+
+  aValue.AppendFloat(curValue);
+}
+
+double HTMLMeterAccessible::MaxValue() const {
+  double max = LeafAccessible::MaxValue();
+  double min = MinValue();
+
+  if (!std::isnan(max)) {
+    return max > min ? max : min;
+  }
+
+  // If we didn't find a max value, check for the max attribute
+  nsAutoString strValue;
+  if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::max,
+                                     strValue)) {
+    nsresult result = NS_OK;
+    max = strValue.ToDouble(&result);
+    if (NS_SUCCEEDED(result)) {
+      return max > min ? max : min;
+    }
+  }
+
+  return 1 > min ? 1 : min;
+}
+
+double HTMLMeterAccessible::MinValue() const {
+  double min = LeafAccessible::MinValue();
+  if (!std::isnan(min)) {
+    return min;
+  }
+
+  nsAutoString strValue;
+  if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::min,
+                                     strValue)) {
+    nsresult result = NS_OK;
+    min = strValue.ToDouble(&result);
+    if (NS_SUCCEEDED(result)) {
+      return min;
+    }
+  }
+
+  return 0;
+}
+
+double HTMLMeterAccessible::CurValue() const {
+  double value = LeafAccessible::CurValue();
+  double minValue = MinValue();
+
+  if (std::isnan(value)) {
+    /* If we didn't find a value from the LeafAccessible call above, check
+     * for a value attribute */
+    nsAutoString attrValue;
+    if (!mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value,
+                                        attrValue)) {
+      return minValue;
+    }
+
+    // If we find a value attribute, attempt to convert it to a double
+    nsresult error = NS_OK;
+    value = attrValue.ToDouble(&error);
+    if (NS_FAILED(error)) {
+      return minValue;
+    }
+  }
+
+  /* If we end up with a defined value, verify it falls between
+   * our established min/max. Otherwise, snap it to the nearest boundary. */
+  double maxValue = MaxValue();
+  if (value > maxValue) {
+    value = maxValue;
+  } else if (value < minValue) {
+    value = minValue;
+  }
+
+  return value;
+}
+
+bool HTMLMeterAccessible::SetCurValue(double aValue) {
+  return false;  // meters are readonly.
+}
+
+void HTMLMeterAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
+                                              nsAtom* aAttribute,
+                                              int32_t aModType,
+                                              const nsAttrValue* aOldValue,
+                                              uint64_t aOldState) {
+  LeafAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute, aModType,
+                                      aOldValue, aOldState);
+
+  if (aAttribute == nsGkAtoms::value) {
+    mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE, this);
+  }
+}
diff --git a/accessible/html/HTMLFormControlAccessible.h b/accessible/html/HTMLFormControlAccessible.h
new file mode 100644
index 0000000000..9107e39a04
--- /dev/null
+++ b/accessible/html/HTMLFormControlAccessible.h
@@ -0,0 +1,387 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef MOZILLA_A11Y_HTMLFormControlAccessible_H_
+#define MOZILLA_A11Y_HTMLFormControlAccessible_H_
+
+#include "FormControlAccessible.h"
+#include "HyperTextAccessibleWrap.h"
+#include "mozilla/a11y/AccTypes.h"
+#include "mozilla/dom/Element.h"
+#include "AccAttributes.h"
+#include "nsAccUtils.h"
+#include "Relation.h"
+
+namespace mozilla {
+class EditorBase;
+namespace a11y {
+
+/**
+ * Accessible for HTML input@type="radio" element.
+ */
+class HTMLRadioButtonAccessible : public RadioButtonAccessible {
+ public:
+  HTMLRadioButtonAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : RadioButtonAccessible(aContent, aDoc) {
+    // Ignore "RadioStateChange" DOM event in lieu of document observer
+    // state change notification.
+    mStateFlags |= eIgnoreDOMUIEvent;
+    mType = eHTMLRadioButtonType;
+  }
+
+  // LocalAccessible
+  virtual uint64_t NativeState() const override;
+  virtual Relation RelationByType(RelationType aType) const override;
+
+ protected:
+  virtual void GetPositionAndSetSize(int32_t* aPosInSet,
+                                     int32_t* aSetSize) override;
+
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+
+ private:
+  Relation ComputeGroupAttributes(int32_t* aPosInSet, int32_t* aSetSize) const;
+};
+
+/**
+ * Accessible for HTML input@type="button", @type="submit", @type="image"
+ * and HTML button elements.
+ */
+class HTMLButtonAccessible : public HyperTextAccessibleWrap {
+ public:
+  enum { eAction_Click = 0 };
+
+  HTMLButtonAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // LocalAccessible
+  virtual mozilla::a11y::role NativeRole() const override;
+  virtual uint64_t State() override;
+  virtual uint64_t NativeState() const override;
+
+  // ActionAccessible
+  virtual bool HasPrimaryAction() const override;
+  virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
+
+  // Widgets
+  virtual bool IsWidget() const override;
+
+ protected:
+  // LocalAccessible
+  virtual ENameValueFlag NativeName(nsString& aName) const override;
+
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+};
+
+/**
+ * Accessible for HTML input@type="text", input@type="password", textarea
+ * and other HTML text controls.
+ */
+class HTMLTextFieldAccessible : public HyperTextAccessibleWrap {
+ public:
+  enum { eAction_Click = 0 };
+
+  HTMLTextFieldAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLTextFieldAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // HyperTextAccessible
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY virtual already_AddRefed<EditorBase> GetEditor()
+      const override;
+
+  // LocalAccessible
+  virtual void Value(nsString& aValue) const override;
+  virtual void ApplyARIAState(uint64_t* aState) const override;
+  virtual mozilla::a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+  virtual already_AddRefed<AccAttributes> NativeAttributes() override;
+  virtual bool AttributeChangesState(nsAtom* aAttribute) override;
+
+  // ActionAccessible
+  virtual bool HasPrimaryAction() const override;
+  virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
+  virtual bool DoAction(uint8_t aIndex) const override;
+
+  // Widgets
+  virtual bool IsWidget() const override;
+  virtual LocalAccessible* ContainerWidget() const override;
+
+ protected:
+  virtual ~HTMLTextFieldAccessible() {}
+
+  // LocalAccessible
+  virtual ENameValueFlag NativeName(nsString& aName) const override;
+
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+};
+
+/**
+ * Accessible for input@type="file" element.
+ */
+class HTMLFileInputAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLFileInputAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // LocalAccessible
+  virtual mozilla::a11y::role NativeRole() const override;
+  virtual nsresult HandleAccEvent(AccEvent* aAccEvent) override;
+  virtual LocalAccessible* CurrentItem() const override;
+};
+
+/**
+ * Used for HTML input@type="number".
+ */
+class HTMLSpinnerAccessible final : public HTMLTextFieldAccessible {
+ public:
+  HTMLSpinnerAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HTMLTextFieldAccessible(aContent, aDoc) {
+    mGenericTypes |= eNumericValue;
+  }
+
+  // LocalAccessible
+  virtual mozilla::a11y::role NativeRole() const override;
+  virtual void Value(nsString& aValue) const override;
+
+  virtual double MaxValue() const override;
+  virtual double MinValue() const override;
+  virtual double CurValue() const override;
+  virtual double Step() const override;
+  virtual bool SetCurValue(double aValue) override;
+};
+
+/**
+ * Used for input@type="range" element.
+ */
+class HTMLRangeAccessible : public LeafAccessible {
+ public:
+  HTMLRangeAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : LeafAccessible(aContent, aDoc) {
+    mGenericTypes |= eNumericValue;
+  }
+
+  // LocalAccessible
+  virtual void Value(nsString& aValue) const override;
+  virtual mozilla::a11y::role NativeRole() const override;
+
+  // Value
+  virtual double MaxValue() const override;
+  virtual double MinValue() const override;
+  virtual double CurValue() const override;
+  virtual double Step() const override;
+  virtual bool SetCurValue(double aValue) override;
+
+  // Widgets
+  virtual bool IsWidget() const override;
+};
+
+/**
+ * Accessible for HTML fieldset element.
+ */
+class HTMLGroupboxAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLGroupboxAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // LocalAccessible
+  virtual mozilla::a11y::role NativeRole() const override;
+  virtual Relation RelationByType(RelationType aType) const override;
+
+ protected:
+  // LocalAccessible
+  virtual ENameValueFlag NativeName(nsString& aName) const override;
+
+  // HTMLGroupboxAccessible
+  nsIContent* GetLegend() const;
+};
+
+/**
+ * Accessible for HTML legend element.
+ */
+class HTMLLegendAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLLegendAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // LocalAccessible
+  virtual Relation RelationByType(RelationType aType) const override;
+};
+
+/**
+ * Accessible for HTML5 figure element.
+ */
+class HTMLFigureAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLFigureAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // LocalAccessible
+  virtual Relation RelationByType(RelationType aType) const override;
+
+ protected:
+  // LocalAccessible
+  virtual ENameValueFlag NativeName(nsString& aName) const override;
+
+  // HTMLLegendAccessible
+  nsIContent* Caption() const;
+};
+
+/**
+ * Accessible for HTML5 figcaption element.
+ */
+class HTMLFigcaptionAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLFigcaptionAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // LocalAccessible
+  virtual Relation RelationByType(RelationType aType) const override;
+};
+
+/**
+ * Used for HTML form element.
+ */
+class HTMLFormAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLFormAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLFormAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+
+ protected:
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+
+  virtual ~HTMLFormAccessible() = default;
+};
+
+/**
+ * Accessible for HTML progress element.
+ */
+
+class HTMLProgressAccessible : public LeafAccessible {
+ public:
+  HTMLProgressAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : LeafAccessible(aContent, aDoc) {
+    // Ignore 'ValueChange' DOM event in lieu of @value attribute change
+    // notifications.
+    mStateFlags |= eIgnoreDOMUIEvent;
+    mGenericTypes |= eNumericValue;
+    mType = eProgressType;
+  }
+
+  // LocalAccessible
+  virtual void Value(nsString& aValue) const override;
+  virtual mozilla::a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+
+  // Value
+  virtual double MaxValue() const override;
+  virtual double MinValue() const override;
+  virtual double CurValue() const override;
+  virtual double Step() const override;
+  virtual bool SetCurValue(double aValue) override;
+
+  // Widgets
+  virtual bool IsWidget() const override;
+
+ protected:
+  virtual ~HTMLProgressAccessible() {}
+
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+};
+
+/**
+ * Accessible for HTML meter element.
+ */
+
+class HTMLMeterAccessible : public LeafAccessible {
+ public:
+  HTMLMeterAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : LeafAccessible(aContent, aDoc) {
+    // Ignore 'ValueChange' DOM event in lieu of @value attribute change
+    // notifications.
+    mStateFlags |= eIgnoreDOMUIEvent;
+    mGenericTypes |= eNumericValue;
+    mType = eProgressType;
+  }
+
+  // LocalAccessible
+  virtual void Value(nsString& aValue) const override;
+  virtual mozilla::a11y::role NativeRole() const override;
+
+  // Value
+  virtual double MaxValue() const override;
+  virtual double MinValue() const override;
+  virtual double CurValue() const override;
+  virtual bool SetCurValue(double aValue) override;
+
+  // Widgets
+  virtual bool IsWidget() const override;
+
+ protected:
+  virtual ~HTMLMeterAccessible() {}
+
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+};
+
+/**
+ * Accessible for HTML date/time inputs.
+ */
+template <a11y::role R>
+class HTMLDateTimeAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLDateTimeAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HyperTextAccessibleWrap(aContent, aDoc) {
+    mType = eHTMLDateTimeFieldType;
+  }
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLDateTimeAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual mozilla::a11y::role NativeRole() const override { return R; }
+  virtual already_AddRefed<AccAttributes> NativeAttributes() override {
+    RefPtr<AccAttributes> attributes =
+        HyperTextAccessibleWrap::NativeAttributes();
+    // Unfortunately, an nsStaticAtom can't be passed as a
+    // template argument, so fetch the type from the DOM.
+    if (const nsAttrValue* attr =
+            mContent->AsElement()->GetParsedAttr(nsGkAtoms::type)) {
+      RefPtr<nsAtom> inputType = attr->GetAsAtom();
+      if (inputType) {
+        attributes->SetAttribute(nsGkAtoms::textInputType, inputType);
+      }
+    }
+    return attributes.forget();
+  }
+
+  // Widgets
+  virtual bool IsWidget() const override { return true; }
+
+ protected:
+  virtual ~HTMLDateTimeAccessible() {}
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/html/HTMLImageMapAccessible.cpp b/accessible/html/HTMLImageMapAccessible.cpp
new file mode 100644
index 0000000000..dfcd003e6e
--- /dev/null
+++ b/accessible/html/HTMLImageMapAccessible.cpp
@@ -0,0 +1,190 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "HTMLImageMapAccessible.h"
+
+#include "ARIAMap.h"
+#include "nsAccUtils.h"
+#include "DocAccessible-inl.h"
+#include "EventTree.h"
+#include "Role.h"
+
+#include "nsIFrame.h"
+#include "nsImageFrame.h"
+#include "nsImageMap.h"
+#include "nsIURI.h"
+#include "nsLayoutUtils.h"
+#include "mozilla/dom/HTMLAreaElement.h"
+
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLImageMapAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLImageMapAccessible::HTMLImageMapAccessible(nsIContent* aContent,
+                                               DocAccessible* aDoc)
+    : ImageAccessible(aContent, aDoc) {
+  mType = eImageMapType;
+
+  UpdateChildAreas(false);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLImageMapAccessible: LocalAccessible public
+
+role HTMLImageMapAccessible::NativeRole() const { return roles::IMAGE_MAP; }
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLImageMapAccessible: public
+
+void HTMLImageMapAccessible::UpdateChildAreas(bool aDoFireEvents) {
+  if (!mContent || !mContent->GetPrimaryFrame()) {
+    return;
+  }
+  nsImageFrame* imageFrame = do_QueryFrame(mContent->GetPrimaryFrame());
+
+  // If image map is not initialized yet then we trigger one time more later.
+  nsImageMap* imageMapObj = imageFrame->GetExistingImageMap();
+  if (!imageMapObj) return;
+
+  TreeMutation mt(this, TreeMutation::kNoEvents & !aDoFireEvents);
+
+  // Remove areas that are not a valid part of the image map anymore.
+  for (int32_t childIdx = mChildren.Length() - 1; childIdx >= 0; childIdx--) {
+    LocalAccessible* area = mChildren.ElementAt(childIdx);
+    if (area->GetContent()->GetPrimaryFrame()) continue;
+
+    mt.BeforeRemoval(area);
+    RemoveChild(area);
+  }
+
+  // Insert new areas into the tree.
+  uint32_t areaElmCount = imageMapObj->AreaCount();
+  for (uint32_t idx = 0; idx < areaElmCount; idx++) {
+    nsIContent* areaContent = imageMapObj->GetAreaAt(idx);
+    LocalAccessible* area = mChildren.SafeElementAt(idx);
+    if (!area || area->GetContent() != areaContent) {
+      RefPtr<LocalAccessible> area = new HTMLAreaAccessible(areaContent, mDoc);
+      mDoc->BindToDocument(area, aria::GetRoleMap(areaContent->AsElement()));
+
+      if (!InsertChildAt(idx, area)) {
+        mDoc->UnbindFromDocument(area);
+        break;
+      }
+
+      mt.AfterInsertion(area);
+    }
+  }
+
+  mt.Done();
+}
+
+LocalAccessible* HTMLImageMapAccessible::GetChildAccessibleFor(
+    const nsINode* aNode) const {
+  uint32_t length = mChildren.Length();
+  for (uint32_t i = 0; i < length; i++) {
+    LocalAccessible* area = mChildren[i];
+    if (area->GetContent() == aNode) return area;
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLAreaAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLAreaAccessible::HTMLAreaAccessible(nsIContent* aContent,
+                                       DocAccessible* aDoc)
+    : HTMLLinkAccessible(aContent, aDoc) {
+  // Make HTML area DOM element not accessible. HTML image map accessible
+  // manages its tree itself.
+  mStateFlags |= eNotNodeMapEntry;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLAreaAccessible: LocalAccessible
+
+ENameValueFlag HTMLAreaAccessible::NativeName(nsString& aName) const {
+  ENameValueFlag nameFlag = LocalAccessible::NativeName(aName);
+  if (!aName.IsEmpty()) return nameFlag;
+
+  if (!mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::alt,
+                                      aName)) {
+    Value(aName);
+  }
+
+  return eNameOK;
+}
+
+void HTMLAreaAccessible::Description(nsString& aDescription) const {
+  aDescription.Truncate();
+
+  // Still to do - follow IE's standard here
+  RefPtr<dom::HTMLAreaElement> area =
+      dom::HTMLAreaElement::FromNodeOrNull(mContent);
+  if (area) area->GetShape(aDescription);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLAreaAccessible: LocalAccessible public
+
+LocalAccessible* HTMLAreaAccessible::LocalChildAtPoint(
+    int32_t aX, int32_t aY, EWhichChildAtPoint aWhichChild) {
+  // Don't walk into area accessibles.
+  return this;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLImageMapAccessible: HyperLinkAccessible
+
+uint32_t HTMLAreaAccessible::StartOffset() {
+  // Image map accessible is not hypertext accessible therefore
+  // StartOffset/EndOffset implementations of LocalAccessible doesn't work here.
+  // We return index in parent because image map contains area links only which
+  // are embedded objects.
+  // XXX: image map should be a hypertext accessible.
+  return IndexInParent();
+}
+
+uint32_t HTMLAreaAccessible::EndOffset() { return IndexInParent() + 1; }
+
+nsRect HTMLAreaAccessible::RelativeBounds(nsIFrame** aBoundingFrame) const {
+  nsIFrame* frame = GetFrame();
+  if (!frame) return nsRect();
+
+  nsImageFrame* imageFrame = do_QueryFrame(frame);
+  nsImageMap* map = imageFrame->GetImageMap();
+
+  nsRect bounds;
+  nsresult rv = map->GetBoundsForAreaContent(mContent, bounds);
+
+  if (NS_FAILED(rv)) return nsRect();
+
+  // XXX Areas are screwy; they return their rects as a pair of points, one pair
+  // stored into the width and height.
+  *aBoundingFrame = frame;
+  bounds.SizeTo(bounds.Width() - bounds.X(), bounds.Height() - bounds.Y());
+  return bounds;
+}
+
+nsRect HTMLAreaAccessible::ParentRelativeBounds() {
+  nsIFrame* boundingFrame = nullptr;
+  nsRect relativeBoundsRect = RelativeBounds(&boundingFrame);
+  if (MOZ_UNLIKELY(!boundingFrame)) {
+    // Area is not attached to an image map?
+    return nsRect();
+  }
+
+  // The relative bounds returned above are relative to this area's
+  // image map, which is technically already "parent relative".
+  // Because area elements are `display:none` to layout, they can't
+  // have transforms or other styling applied directly, and so we
+  // don't apply any additional transforms here. Any transform
+  // at the image map layer will be taken care of when computing bounds
+  // in the parent process.
+  return relativeBoundsRect;
+}
diff --git a/accessible/html/HTMLImageMapAccessible.h b/accessible/html/HTMLImageMapAccessible.h
new file mode 100644
index 0000000000..2dc1779ddd
--- /dev/null
+++ b/accessible/html/HTMLImageMapAccessible.h
@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_HTMLImageMapAccessible_h__
+#define mozilla_a11y_HTMLImageMapAccessible_h__
+
+#include "HTMLLinkAccessible.h"
+#include "ImageAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+/**
+ * Used for HTML image maps.
+ */
+class HTMLImageMapAccessible final : public ImageAccessible {
+ public:
+  HTMLImageMapAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // nsISupports and cycle collector
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLImageMapAccessible, ImageAccessible)
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+
+  /**
+   * Update area children of the image map.
+   */
+  void UpdateChildAreas(bool aDoFireEvents = true);
+
+  /**
+   * Return accessible of child node.
+   */
+  LocalAccessible* GetChildAccessibleFor(const nsINode* aNode) const;
+
+ protected:
+  virtual ~HTMLImageMapAccessible() {}
+};
+
+/**
+ * Accessible for image map areas - must be child of image.
+ */
+class HTMLAreaAccessible final : public HTMLLinkAccessible {
+ public:
+  HTMLAreaAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // LocalAccessible
+  virtual void Description(nsString& aDescription) const override;
+  virtual LocalAccessible* LocalChildAtPoint(
+      int32_t aX, int32_t aY, EWhichChildAtPoint aWhichChild) override;
+  virtual nsRect RelativeBounds(nsIFrame** aBoundingFrame) const override;
+  virtual nsRect ParentRelativeBounds() override;
+
+  // HyperLinkAccessible
+  virtual uint32_t StartOffset() override;
+  virtual uint32_t EndOffset() override;
+
+  virtual bool IsAcceptableChild(nsIContent* aEl) const override {
+    return false;
+  }
+
+ protected:
+  // LocalAccessible
+  virtual ENameValueFlag NativeName(nsString& aName) const override;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// LocalAccessible downcasting method
+
+inline HTMLImageMapAccessible* LocalAccessible::AsImageMap() {
+  return IsImageMap() ? static_cast<HTMLImageMapAccessible*>(this) : nullptr;
+}
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/html/HTMLLinkAccessible.cpp b/accessible/html/HTMLLinkAccessible.cpp
new file mode 100644
index 0000000000..629e4f74cc
--- /dev/null
+++ b/accessible/html/HTMLLinkAccessible.cpp
@@ -0,0 +1,129 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "HTMLLinkAccessible.h"
+
+#include "CacheConstants.h"
+#include "nsCoreUtils.h"
+#include "DocAccessible.h"
+#include "Role.h"
+#include "States.h"
+
+#include "nsContentUtils.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/MutationEventBinding.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLLinkAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLLinkAccessible::HTMLLinkAccessible(nsIContent* aContent,
+                                       DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {
+  mType = eHTMLLinkType;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIAccessible
+
+role HTMLLinkAccessible::NativeRole() const { return roles::LINK; }
+
+uint64_t HTMLLinkAccessible::NativeState() const {
+  return HyperTextAccessibleWrap::NativeState() & ~states::READONLY;
+}
+
+uint64_t HTMLLinkAccessible::NativeLinkState() const {
+  dom::ElementState state = mContent->AsElement()->State();
+  if (state.HasState(dom::ElementState::UNVISITED)) {
+    return states::LINKED;
+  }
+
+  if (state.HasState(dom::ElementState::VISITED)) {
+    return states::LINKED | states::TRAVERSED;
+  }
+
+  // This is a either named anchor (a link with also a name attribute) or
+  // it doesn't have any attributes. Check if 'click' event handler is
+  // registered, otherwise bail out.
+  return nsCoreUtils::HasClickListener(mContent) ? states::LINKED : 0;
+}
+
+uint64_t HTMLLinkAccessible::NativeInteractiveState() const {
+  uint64_t state = HyperTextAccessibleWrap::NativeInteractiveState();
+
+  // This is how we indicate it is a named anchor. In other words, this anchor
+  // can be selected as a location :) There is no other better state to use to
+  // indicate this.
+  if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::name)) {
+    state |= states::SELECTABLE;
+  }
+
+  return state;
+}
+
+void HTMLLinkAccessible::Value(nsString& aValue) const {
+  aValue.Truncate();
+
+  HyperTextAccessible::Value(aValue);
+  if (aValue.IsEmpty()) {
+    nsContentUtils::GetLinkLocation(mContent->AsElement(), aValue);
+  }
+}
+
+bool HTMLLinkAccessible::HasPrimaryAction() const {
+  return IsLinked() || HyperTextAccessible::HasPrimaryAction();
+  ;
+}
+
+void HTMLLinkAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
+  aName.Truncate();
+
+  if (!IsLinked()) {
+    HyperTextAccessible::ActionNameAt(aIndex, aName);
+    return;
+  }
+
+  // Action 0 (default action): Jump to link
+  if (aIndex == eAction_Jump) aName.AssignLiteral("jump");
+}
+
+bool HTMLLinkAccessible::AttributeChangesState(nsAtom* aAttribute) {
+  return aAttribute == nsGkAtoms::href ||
+         HyperTextAccessibleWrap::AttributeChangesState(aAttribute);
+}
+
+void HTMLLinkAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
+                                             nsAtom* aAttribute,
+                                             int32_t aModType,
+                                             const nsAttrValue* aOldValue,
+                                             uint64_t aOldState) {
+  HyperTextAccessibleWrap::DOMAttributeChanged(aNameSpaceID, aAttribute,
+                                               aModType, aOldValue, aOldState);
+
+  if (aAttribute == nsGkAtoms::href &&
+      (aModType == dom::MutationEvent_Binding::ADDITION ||
+       aModType == dom::MutationEvent_Binding::REMOVAL)) {
+    SendCache(CacheDomain::Actions, CacheUpdateType::Update);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HyperLinkAccessible
+
+bool HTMLLinkAccessible::IsLink() const {
+  // Expose HyperLinkAccessible unconditionally.
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLLinkAccessible
+
+bool HTMLLinkAccessible::IsLinked() const {
+  dom::ElementState state = mContent->AsElement()->State();
+  return state.HasAtLeastOneOfStates(dom::ElementState::VISITED_OR_UNVISITED);
+}
diff --git a/accessible/html/HTMLLinkAccessible.h b/accessible/html/HTMLLinkAccessible.h
new file mode 100644
index 0000000000..781db3583f
--- /dev/null
+++ b/accessible/html/HTMLLinkAccessible.h
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_HTMLLinkAccessible_h__
+#define mozilla_a11y_HTMLLinkAccessible_h__
+
+#include "HyperTextAccessibleWrap.h"
+
+namespace mozilla {
+namespace a11y {
+
+class HTMLLinkAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLLinkAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLLinkAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual void Value(nsString& aValue) const override;
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+  virtual uint64_t NativeLinkState() const override;
+  virtual uint64_t NativeInteractiveState() const override;
+
+  // ActionAccessible
+  virtual bool HasPrimaryAction() const override;
+  virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
+
+  // HyperLinkAccessible
+  virtual bool IsLink() const override;
+
+  /**
+   * Returns true if the link has href attribute.
+   */
+  bool IsLinked() const;
+
+ protected:
+  virtual ~HTMLLinkAccessible() {}
+
+  virtual bool AttributeChangesState(nsAtom* aAttribute) override;
+
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+
+  enum { eAction_Jump = 0 };
+};
+
+inline HTMLLinkAccessible* LocalAccessible::AsHTMLLink() {
+  return IsHTMLLink() ? static_cast<HTMLLinkAccessible*>(this) : nullptr;
+}
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/html/HTMLListAccessible.cpp b/accessible/html/HTMLListAccessible.cpp
new file mode 100644
index 0000000000..39fc6149b9
--- /dev/null
+++ b/accessible/html/HTMLListAccessible.cpp
@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=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 "HTMLListAccessible.h"
+
+#include "AccAttributes.h"
+#include "DocAccessible.h"
+#include "EventTree.h"
+#include "nsAccUtils.h"
+#include "nsPersistentProperties.h"
+#include "Role.h"
+#include "States.h"
+
+#include "nsLayoutUtils.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLListAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLListAccessible::NativeRole() const {
+  a11y::role r = GetAccService()->MarkupRole(mContent);
+  return r != roles::NOTHING ? r : roles::LIST;
+}
+
+uint64_t HTMLListAccessible::NativeState() const {
+  return HyperTextAccessibleWrap::NativeState() | states::READONLY;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLLIAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLLIAccessible::HTMLLIAccessible(nsIContent* aContent, DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {
+  mType = eHTMLLiType;
+}
+
+role HTMLLIAccessible::NativeRole() const {
+  a11y::role r = GetAccService()->MarkupRole(mContent);
+  return r != roles::NOTHING ? r : roles::LISTITEM;
+}
+
+uint64_t HTMLLIAccessible::NativeState() const {
+  return HyperTextAccessibleWrap::NativeState() | states::READONLY;
+}
+
+nsRect HTMLLIAccessible::BoundsInAppUnits() const {
+  nsRect rect = AccessibleWrap::BoundsInAppUnits();
+
+  LocalAccessible* bullet = Bullet();
+  nsIFrame* frame = GetFrame();
+  MOZ_ASSERT(!(bullet && !frame), "Cannot have a bullet if there is no frame");
+
+  if (bullet && frame &&
+      frame->StyleList()->mListStylePosition !=
+          StyleListStylePosition::Inside) {
+    nsRect bulletRect = bullet->BoundsInAppUnits();
+    return rect.Union(bulletRect);
+  }
+
+  return rect;
+}
+
+LocalAccessible* HTMLLIAccessible::Bullet() const {
+  LocalAccessible* firstChild = LocalFirstChild();
+  if (firstChild && firstChild->NativeRole() == roles::LISTITEM_MARKER) {
+    return firstChild;
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLListBulletAccessible
+////////////////////////////////////////////////////////////////////////////////
+HTMLListBulletAccessible::HTMLListBulletAccessible(nsIContent* aContent,
+                                                   DocAccessible* aDoc)
+    : LeafAccessible(aContent, aDoc) {
+  mGenericTypes |= eText;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLListBulletAccessible: LocalAccessible
+
+ENameValueFlag HTMLListBulletAccessible::Name(nsString& aName) const {
+  nsLayoutUtils::GetMarkerSpokenText(mContent, aName);
+  return eNameOK;
+}
+
+role HTMLListBulletAccessible::NativeRole() const {
+  return roles::LISTITEM_MARKER;
+}
+
+uint64_t HTMLListBulletAccessible::NativeState() const {
+  return LeafAccessible::NativeState() | states::READONLY;
+}
+
+already_AddRefed<AccAttributes> HTMLListBulletAccessible::NativeAttributes() {
+  RefPtr<AccAttributes> attributes = new AccAttributes();
+  return attributes.forget();
+}
+
+void HTMLListBulletAccessible::AppendTextTo(nsAString& aText,
+                                            uint32_t aStartOffset,
+                                            uint32_t aLength) {
+  nsAutoString bulletText;
+  Name(bulletText);
+  aText.Append(Substring(bulletText, aStartOffset, aLength));
+}
diff --git a/accessible/html/HTMLListAccessible.h b/accessible/html/HTMLListAccessible.h
new file mode 100644
index 0000000000..73c8857d92
--- /dev/null
+++ b/accessible/html/HTMLListAccessible.h
@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=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/. */
+
+#ifndef mozilla_a11y_HTMLListAccessible_h__
+#define mozilla_a11y_HTMLListAccessible_h__
+
+#include "BaseAccessibles.h"
+#include "HyperTextAccessibleWrap.h"
+
+namespace mozilla {
+namespace a11y {
+
+class HTMLListBulletAccessible;
+
+/**
+ * Used for HTML list (like HTML ul).
+ */
+class HTMLListAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLListAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HyperTextAccessibleWrap(aContent, aDoc) {
+    mGenericTypes |= eList;
+  }
+
+  // nsISupports
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLListAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+
+ protected:
+  virtual ~HTMLListAccessible() {}
+};
+
+/**
+ * Used for HTML list item (e.g. HTML li).
+ */
+class HTMLLIAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLLIAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // nsISupports
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLLIAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual nsRect BoundsInAppUnits() const override;
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+
+  // HTMLLIAccessible
+  LocalAccessible* Bullet() const;
+
+ protected:
+  virtual ~HTMLLIAccessible() {}
+};
+
+/**
+ * Used for bullet of HTML list item element (for example, HTML li).
+ */
+class HTMLListBulletAccessible : public LeafAccessible {
+ public:
+  HTMLListBulletAccessible(nsIContent* aContent, DocAccessible* aDoc);
+  virtual ~HTMLListBulletAccessible() {}
+
+  // LocalAccessible
+  virtual ENameValueFlag Name(nsString& aName) const override;
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+  virtual already_AddRefed<AccAttributes> NativeAttributes() override;
+  virtual void AppendTextTo(nsAString& aText, uint32_t aStartOffset = 0,
+                            uint32_t aLength = UINT32_MAX) override;
+};
+
+inline HTMLLIAccessible* LocalAccessible::AsHTMLListItem() {
+  return IsHTMLListItem() ? static_cast<HTMLLIAccessible*>(this) : nullptr;
+}
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/html/HTMLSelectAccessible.cpp b/accessible/html/HTMLSelectAccessible.cpp
new file mode 100644
index 0000000000..0366ce19ed
--- /dev/null
+++ b/accessible/html/HTMLSelectAccessible.cpp
@@ -0,0 +1,474 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "HTMLSelectAccessible.h"
+
+#include "LocalAccessible-inl.h"
+#include "nsAccessibilityService.h"
+#include "nsAccUtils.h"
+#include "DocAccessible.h"
+#include "nsEventShell.h"
+#include "nsTextEquivUtils.h"
+#include "Role.h"
+#include "States.h"
+
+#include "nsCOMPtr.h"
+#include "mozilla/dom/HTMLOptionElement.h"
+#include "mozilla/dom/HTMLOptGroupElement.h"
+#include "mozilla/dom/HTMLSelectElement.h"
+#include "nsComboboxControlFrame.h"
+#include "nsContainerFrame.h"
+#include "nsListControlFrame.h"
+
+using namespace mozilla::a11y;
+using namespace mozilla::dom;
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSelectListAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLSelectListAccessible::HTMLSelectListAccessible(nsIContent* aContent,
+                                                   DocAccessible* aDoc)
+    : AccessibleWrap(aContent, aDoc) {
+  mGenericTypes |= eListControl | eSelect;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSelectListAccessible: LocalAccessible public
+
+uint64_t HTMLSelectListAccessible::NativeState() const {
+  uint64_t state = AccessibleWrap::NativeState();
+  if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::multiple)) {
+    state |= states::MULTISELECTABLE | states::EXTSELECTABLE;
+  }
+
+  return state;
+}
+
+role HTMLSelectListAccessible::NativeRole() const { return roles::LISTBOX; }
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSelectListAccessible: SelectAccessible
+
+bool HTMLSelectListAccessible::SelectAll() {
+  return mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::multiple)
+             ? AccessibleWrap::SelectAll()
+             : false;
+}
+
+bool HTMLSelectListAccessible::UnselectAll() {
+  return mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::multiple)
+             ? AccessibleWrap::UnselectAll()
+             : false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSelectListAccessible: Widgets
+
+bool HTMLSelectListAccessible::IsWidget() const { return true; }
+
+bool HTMLSelectListAccessible::IsActiveWidget() const {
+  return FocusMgr()->HasDOMFocus(mContent);
+}
+
+bool HTMLSelectListAccessible::AreItemsOperable() const { return true; }
+
+LocalAccessible* HTMLSelectListAccessible::CurrentItem() const {
+  nsListControlFrame* listControlFrame = do_QueryFrame(GetFrame());
+  if (listControlFrame) {
+    nsCOMPtr<nsIContent> activeOptionNode =
+        listControlFrame->GetCurrentOption();
+    if (activeOptionNode) {
+      DocAccessible* document = Document();
+      if (document) return document->GetAccessible(activeOptionNode);
+    }
+  }
+  return nullptr;
+}
+
+void HTMLSelectListAccessible::SetCurrentItem(const LocalAccessible* aItem) {
+  if (!aItem->GetContent()->IsElement()) return;
+
+  aItem->GetContent()->AsElement()->SetAttr(
+      kNameSpaceID_None, nsGkAtoms::selected, u"true"_ns, true);
+}
+
+bool HTMLSelectListAccessible::IsAcceptableChild(nsIContent* aEl) const {
+  return aEl->IsAnyOfHTMLElements(nsGkAtoms::option, nsGkAtoms::optgroup);
+}
+
+bool HTMLSelectListAccessible::AttributeChangesState(nsAtom* aAttribute) {
+  return aAttribute == nsGkAtoms::multiple ||
+         LocalAccessible::AttributeChangesState(aAttribute);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSelectOptionAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLSelectOptionAccessible::HTMLSelectOptionAccessible(nsIContent* aContent,
+                                                       DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSelectOptionAccessible: LocalAccessible public
+
+role HTMLSelectOptionAccessible::NativeRole() const {
+  if (GetCombobox()) return roles::COMBOBOX_OPTION;
+
+  return roles::OPTION;
+}
+
+ENameValueFlag HTMLSelectOptionAccessible::NativeName(nsString& aName) const {
+  if (auto* option = dom::HTMLOptionElement::FromNode(mContent)) {
+    option->GetAttr(nsGkAtoms::label, aName);
+    if (!aName.IsEmpty()) {
+      return eNameOK;
+    }
+    option->GetText(aName);
+    return eNameFromSubtree;
+  }
+  if (auto* group = dom::HTMLOptGroupElement::FromNode(mContent)) {
+    group->GetLabel(aName);
+    return aName.IsEmpty() ? eNameOK : eNameFromSubtree;
+  }
+  MOZ_ASSERT_UNREACHABLE("What content do we have?");
+  return eNameFromSubtree;
+}
+
+void HTMLSelectOptionAccessible::DOMAttributeChanged(
+    int32_t aNameSpaceID, nsAtom* aAttribute, int32_t aModType,
+    const nsAttrValue* aOldValue, uint64_t aOldState) {
+  HyperTextAccessibleWrap::DOMAttributeChanged(aNameSpaceID, aAttribute,
+                                               aModType, aOldValue, aOldState);
+
+  if (aAttribute == nsGkAtoms::label) {
+    dom::Element* elm = Elm();
+    if (!nsAccUtils::HasARIAAttr(elm, nsGkAtoms::aria_labelledby) &&
+        !nsAccUtils::HasARIAAttr(elm, nsGkAtoms::aria_label)) {
+      mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, this);
+    }
+  }
+}
+
+uint64_t HTMLSelectOptionAccessible::NativeState() const {
+  // As a HTMLSelectOptionAccessible we can have the following states:
+  // SELECTABLE, SELECTED, FOCUSED, FOCUSABLE, OFFSCREEN
+  // Upcall to LocalAccessible, but skip HyperTextAccessible impl
+  // because we don't want EDITABLE or SELECTABLE_TEXT
+  uint64_t state = LocalAccessible::NativeState();
+
+  LocalAccessible* select = GetSelect();
+  if (!select) return state;
+
+  uint64_t selectState = select->State();
+  if (selectState & states::INVISIBLE) return state;
+
+  // Are we selected?
+  HTMLOptionElement* option = HTMLOptionElement::FromNode(mContent);
+  bool selected = option && option->Selected();
+  if (selected) state |= states::SELECTED;
+
+  if (selectState & states::OFFSCREEN) {
+    state |= states::OFFSCREEN;
+  } else if (selectState & states::COLLAPSED) {
+    // <select> is COLLAPSED: add OFFSCREEN, if not the currently
+    // visible option
+    if (!selected) {
+      state |= states::OFFSCREEN;
+      // Ensure the invisible state is removed. Otherwise, group info will skip
+      // this option. Furthermore, this gets cached and this doesn't get
+      // invalidated even once the select is expanded.
+      state &= ~states::INVISIBLE;
+    } else {
+      // Clear offscreen and invisible for currently showing option
+      state &= ~(states::OFFSCREEN | states::INVISIBLE);
+      state |= selectState & states::OPAQUE1;
+    }
+  } else {
+    // XXX list frames are weird, don't rely on LocalAccessible's general
+    // visibility implementation unless they get reimplemented in layout
+    state &= ~states::OFFSCREEN;
+    // <select> is not collapsed: compare bounds to calculate OFFSCREEN
+    LocalAccessible* listAcc = LocalParent();
+    if (listAcc) {
+      LayoutDeviceIntRect optionRect = Bounds();
+      LayoutDeviceIntRect listRect = listAcc->Bounds();
+      if (optionRect.Y() < listRect.Y() ||
+          optionRect.YMost() > listRect.YMost()) {
+        state |= states::OFFSCREEN;
+      }
+    }
+  }
+
+  return state;
+}
+
+uint64_t HTMLSelectOptionAccessible::NativeInteractiveState() const {
+  return NativelyUnavailable() ? states::UNAVAILABLE
+                               : states::FOCUSABLE | states::SELECTABLE;
+}
+
+nsRect HTMLSelectOptionAccessible::RelativeBounds(
+    nsIFrame** aBoundingFrame) const {
+  LocalAccessible* combobox = GetCombobox();
+  if (combobox && (combobox->State() & states::COLLAPSED)) {
+    return combobox->RelativeBounds(aBoundingFrame);
+  }
+
+  return HyperTextAccessibleWrap::RelativeBounds(aBoundingFrame);
+}
+
+void HTMLSelectOptionAccessible::ActionNameAt(uint8_t aIndex,
+                                              nsAString& aName) {
+  if (aIndex == eAction_Select) aName.AssignLiteral("select");
+}
+
+bool HTMLSelectOptionAccessible::HasPrimaryAction() const { return true; }
+
+void HTMLSelectOptionAccessible::SetSelected(bool aSelect) {
+  HTMLOptionElement* option = HTMLOptionElement::FromNode(mContent);
+  if (option) option->SetSelected(aSelect);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSelectOptionAccessible: Widgets
+
+LocalAccessible* HTMLSelectOptionAccessible::ContainerWidget() const {
+  LocalAccessible* parent = LocalParent();
+  if (parent && parent->IsHTMLOptGroup()) {
+    parent = parent->LocalParent();
+  }
+
+  return parent && parent->IsListControl() ? parent : nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLSelectOptGroupAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+role HTMLSelectOptGroupAccessible::NativeRole() const {
+  return roles::GROUPING;
+}
+
+uint64_t HTMLSelectOptGroupAccessible::NativeInteractiveState() const {
+  return NativelyUnavailable() ? states::UNAVAILABLE : 0;
+}
+
+bool HTMLSelectOptGroupAccessible::IsAcceptableChild(nsIContent* aEl) const {
+  return aEl->IsCharacterData() || aEl->IsHTMLElement(nsGkAtoms::option);
+}
+
+bool HTMLSelectOptGroupAccessible::HasPrimaryAction() const { return false; }
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLComboboxAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLComboboxAccessible::HTMLComboboxAccessible(nsIContent* aContent,
+                                               DocAccessible* aDoc)
+    : AccessibleWrap(aContent, aDoc) {
+  mType = eHTMLComboboxType;
+  mGenericTypes |= eCombobox;
+  mStateFlags |= eNoKidsFromDOM;
+
+  if ((nsComboboxControlFrame*)do_QueryFrame(GetFrame())) {
+    mListAccessible = new HTMLComboboxListAccessible(mParent, mContent, mDoc);
+    Document()->BindToDocument(mListAccessible, nullptr);
+    AppendChild(mListAccessible);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLComboboxAccessible: LocalAccessible
+
+role HTMLComboboxAccessible::NativeRole() const { return roles::COMBOBOX; }
+
+bool HTMLComboboxAccessible::RemoveChild(LocalAccessible* aChild) {
+  MOZ_ASSERT(aChild == mListAccessible);
+  if (AccessibleWrap::RemoveChild(aChild)) {
+    mListAccessible = nullptr;
+    return true;
+  }
+  return false;
+}
+
+void HTMLComboboxAccessible::Shutdown() {
+  MOZ_ASSERT(!mDoc || mDoc->IsDefunct() || !mListAccessible);
+  if (mListAccessible) {
+    mListAccessible->Shutdown();
+    mListAccessible = nullptr;
+  }
+
+  AccessibleWrap::Shutdown();
+}
+
+uint64_t HTMLComboboxAccessible::NativeState() const {
+  // As a HTMLComboboxAccessible we can have the following states:
+  // FOCUSED, FOCUSABLE, HASPOPUP, EXPANDED, COLLAPSED
+  // Get focus status from base class
+  uint64_t state = LocalAccessible::NativeState();
+
+  nsComboboxControlFrame* comboFrame = do_QueryFrame(GetFrame());
+  if (comboFrame && comboFrame->IsDroppedDown()) {
+    state |= states::EXPANDED;
+  } else {
+    state |= states::COLLAPSED;
+  }
+
+  state |= states::HASPOPUP;
+  return state;
+}
+
+void HTMLComboboxAccessible::Description(nsString& aDescription) const {
+  aDescription.Truncate();
+  // First check to see if combo box itself has a description, perhaps through
+  // tooltip (title attribute) or via aria-describedby
+  LocalAccessible::Description(aDescription);
+  if (!aDescription.IsEmpty()) return;
+
+  // Otherwise use description of selected option.
+  LocalAccessible* option = SelectedOption();
+  if (option) option->Description(aDescription);
+}
+
+void HTMLComboboxAccessible::Value(nsString& aValue) const {
+  // Use accessible name of selected option.
+  LocalAccessible* option = SelectedOption();
+  if (option) option->Name(aValue);
+}
+
+bool HTMLComboboxAccessible::HasPrimaryAction() const { return true; }
+
+void HTMLComboboxAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
+  if (aIndex != HTMLComboboxAccessible::eAction_Click) return;
+
+  nsComboboxControlFrame* comboFrame = do_QueryFrame(GetFrame());
+  if (!comboFrame) return;
+
+  if (comboFrame->IsDroppedDown()) {
+    aName.AssignLiteral("close");
+  } else {
+    aName.AssignLiteral("open");
+  }
+}
+
+bool HTMLComboboxAccessible::IsAcceptableChild(nsIContent* aEl) const {
+  return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLComboboxAccessible: Widgets
+
+bool HTMLComboboxAccessible::IsWidget() const { return true; }
+
+bool HTMLComboboxAccessible::IsActiveWidget() const {
+  return FocusMgr()->HasDOMFocus(mContent);
+}
+
+bool HTMLComboboxAccessible::AreItemsOperable() const {
+  nsComboboxControlFrame* comboboxFrame = do_QueryFrame(GetFrame());
+  return comboboxFrame && comboboxFrame->IsDroppedDown();
+}
+
+LocalAccessible* HTMLComboboxAccessible::CurrentItem() const {
+  return AreItemsOperable() ? mListAccessible->CurrentItem() : nullptr;
+}
+
+void HTMLComboboxAccessible::SetCurrentItem(const LocalAccessible* aItem) {
+  if (AreItemsOperable()) mListAccessible->SetCurrentItem(aItem);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLComboboxAccessible: protected
+
+LocalAccessible* HTMLComboboxAccessible::SelectedOption() const {
+  HTMLSelectElement* select = HTMLSelectElement::FromNode(mContent);
+  int32_t selectedIndex = select->SelectedIndex();
+
+  if (selectedIndex >= 0) {
+    HTMLOptionElement* option = select->Item(selectedIndex);
+    if (option) {
+      DocAccessible* document = Document();
+      if (document) return document->GetAccessible(option);
+    }
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLComboboxListAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLComboboxListAccessible::HTMLComboboxListAccessible(LocalAccessible* aParent,
+                                                       nsIContent* aContent,
+                                                       DocAccessible* aDoc)
+    : HTMLSelectListAccessible(aContent, aDoc) {
+  mStateFlags |= eSharedNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLComboboxAccessible: LocalAccessible
+
+role HTMLComboboxListAccessible::NativeRole() const {
+  return roles::COMBOBOX_LIST;
+}
+
+uint64_t HTMLComboboxListAccessible::NativeState() const {
+  // As a HTMLComboboxListAccessible we can have the following states:
+  // FOCUSED, FOCUSABLE, FLOATING, INVISIBLE
+  // Get focus status from base class
+  uint64_t state = LocalAccessible::NativeState();
+
+  nsComboboxControlFrame* comboFrame = do_QueryFrame(mParent->GetFrame());
+  if (comboFrame && comboFrame->IsDroppedDown()) {
+    state |= states::FLOATING;
+  } else {
+    state |= states::INVISIBLE;
+  }
+
+  return state;
+}
+
+nsRect HTMLComboboxListAccessible::RelativeBounds(
+    nsIFrame** aBoundingFrame) const {
+  *aBoundingFrame = nullptr;
+
+  LocalAccessible* comboAcc = LocalParent();
+  if (!comboAcc) return nsRect();
+
+  if (0 == (comboAcc->State() & states::COLLAPSED)) {
+    return HTMLSelectListAccessible::RelativeBounds(aBoundingFrame);
+  }
+
+  // Get the first option.
+  nsIContent* content = mContent->GetFirstChild();
+  if (!content) return nsRect();
+
+  nsIFrame* frame = content->GetPrimaryFrame();
+  if (!frame) {
+    *aBoundingFrame = nullptr;
+    return nsRect();
+  }
+
+  *aBoundingFrame = frame->GetParent();
+  return (*aBoundingFrame)->GetRect();
+}
+
+bool HTMLComboboxListAccessible::IsAcceptableChild(nsIContent* aEl) const {
+  return aEl->IsAnyOfHTMLElements(nsGkAtoms::option, nsGkAtoms::optgroup);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLComboboxListAccessible: Widgets
+
+bool HTMLComboboxListAccessible::IsActiveWidget() const {
+  return mParent && mParent->IsActiveWidget();
+}
+
+bool HTMLComboboxListAccessible::AreItemsOperable() const {
+  return mParent && mParent->AreItemsOperable();
+}
diff --git a/accessible/html/HTMLSelectAccessible.h b/accessible/html/HTMLSelectAccessible.h
new file mode 100644
index 0000000000..e2498a52f8
--- /dev/null
+++ b/accessible/html/HTMLSelectAccessible.h
@@ -0,0 +1,216 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_HTMLSelectAccessible_h__
+#define mozilla_a11y_HTMLSelectAccessible_h__
+
+#include "HTMLFormControlAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+/**
+ *  Selects, Listboxes and Comboboxes, are made up of a number of different
+ *  widgets, some of which are shared between the two. This file contains
+ *  all of the widgets for both of the Selects, for HTML only.
+ *
+ *  Listbox:
+ *     - HTMLSelectListAccessible
+ *        - HTMLSelectOptionAccessible
+ *
+ *  Comboboxes:
+ *     - HTMLComboboxAccessible
+ *        - HTMLComboboxListAccessible  [ inserted in accessible tree ]
+ *           - HTMLSelectOptionAccessible(s)
+ */
+
+/*
+ * The list that contains all the options in the select.
+ */
+class HTMLSelectListAccessible : public AccessibleWrap {
+ public:
+  HTMLSelectListAccessible(nsIContent* aContent, DocAccessible* aDoc);
+  virtual ~HTMLSelectListAccessible() {}
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+  virtual bool IsAcceptableChild(nsIContent* aEl) const override;
+  virtual bool AttributeChangesState(nsAtom* aAttribute) override;
+
+  // SelectAccessible
+  virtual bool SelectAll() override;
+  virtual bool UnselectAll() override;
+
+  // Widgets
+  virtual bool IsWidget() const override;
+  virtual bool IsActiveWidget() const override;
+  virtual bool AreItemsOperable() const override;
+  virtual LocalAccessible* CurrentItem() const override;
+  virtual void SetCurrentItem(const LocalAccessible* aItem) override;
+};
+
+/*
+ * Options inside the select, contained within the list
+ */
+class HTMLSelectOptionAccessible : public HyperTextAccessibleWrap {
+ public:
+  enum { eAction_Select = 0 };
+
+  HTMLSelectOptionAccessible(nsIContent* aContent, DocAccessible* aDoc);
+  virtual ~HTMLSelectOptionAccessible() {}
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+  virtual uint64_t NativeInteractiveState() const override;
+
+  virtual nsRect RelativeBounds(nsIFrame** aBoundingFrame) const override;
+  virtual void SetSelected(bool aSelect) override;
+
+  // ActionAccessible
+  virtual bool HasPrimaryAction() const override;
+  virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
+
+  // Widgets
+  virtual LocalAccessible* ContainerWidget() const override;
+
+ protected:
+  // LocalAccessible
+  virtual ENameValueFlag NativeName(nsString& aName) const override;
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+
+ private:
+  /**
+   * Return a select accessible the option belongs to if any.
+   */
+  LocalAccessible* GetSelect() const {
+    LocalAccessible* parent = mParent;
+    if (parent && parent->IsHTMLOptGroup()) {
+      parent = parent->LocalParent();
+    }
+
+    if (parent && parent->IsListControl()) {
+      LocalAccessible* combobox = parent->LocalParent();
+      return combobox && combobox->IsCombobox() ? combobox : mParent;
+    }
+
+    return nullptr;
+  }
+
+  /**
+   * Return a combobox accessible the option belongs to if any.
+   */
+  LocalAccessible* GetCombobox() const {
+    LocalAccessible* parent = mParent;
+    if (parent && parent->IsHTMLOptGroup()) {
+      parent = parent->LocalParent();
+    }
+
+    if (parent && parent->IsListControl()) {
+      LocalAccessible* combobox = parent->LocalParent();
+      return combobox && combobox->IsCombobox() ? combobox : nullptr;
+    }
+
+    return nullptr;
+  }
+};
+
+/*
+ * Opt Groups inside the select, contained within the list
+ */
+class HTMLSelectOptGroupAccessible : public HTMLSelectOptionAccessible {
+ public:
+  HTMLSelectOptGroupAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HTMLSelectOptionAccessible(aContent, aDoc) {
+    mType = eHTMLOptGroupType;
+  }
+  virtual ~HTMLSelectOptGroupAccessible() {}
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeInteractiveState() const override;
+  virtual bool IsAcceptableChild(nsIContent* aEl) const override;
+
+  // ActionAccessible
+  virtual bool HasPrimaryAction() const override;
+};
+
+/** ------------------------------------------------------ */
+/**  Finally, the Combobox widgets                         */
+/** ------------------------------------------------------ */
+
+class HTMLComboboxListAccessible;
+
+/*
+ * A class the represents the HTML Combobox widget.
+ */
+class HTMLComboboxAccessible final : public AccessibleWrap {
+ public:
+  enum { eAction_Click = 0 };
+
+  HTMLComboboxAccessible(nsIContent* aContent, DocAccessible* aDoc);
+  virtual ~HTMLComboboxAccessible() {}
+
+  // LocalAccessible
+  virtual void Shutdown() override;
+  virtual void Description(nsString& aDescription) const override;
+  virtual void Value(nsString& aValue) const override;
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+  virtual bool RemoveChild(LocalAccessible* aChild) override;
+  virtual bool IsAcceptableChild(nsIContent* aEl) const override;
+
+  // ActionAccessible
+  virtual bool HasPrimaryAction() const override;
+  virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
+
+  // Widgets
+  virtual bool IsWidget() const override;
+  virtual bool IsActiveWidget() const override;
+  virtual bool AreItemsOperable() const override;
+  virtual LocalAccessible* CurrentItem() const override;
+  virtual void SetCurrentItem(const LocalAccessible* aItem) override;
+
+  HTMLComboboxListAccessible* List() const { return mListAccessible; }
+
+  /**
+   * Return selected option.
+   */
+  LocalAccessible* SelectedOption() const;
+
+ private:
+  RefPtr<HTMLComboboxListAccessible> mListAccessible;
+};
+
+/*
+ * A class that represents the window that lives to the right
+ * of the drop down button inside the Select. This is the window
+ * that is made visible when the button is pressed.
+ */
+class HTMLComboboxListAccessible : public HTMLSelectListAccessible {
+ public:
+  HTMLComboboxListAccessible(LocalAccessible* aParent, nsIContent* aContent,
+                             DocAccessible* aDoc);
+  virtual ~HTMLComboboxListAccessible() {}
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+  virtual nsRect RelativeBounds(nsIFrame** aBoundingFrame) const override;
+  virtual bool IsAcceptableChild(nsIContent* aEl) const override;
+
+  // Widgets
+  virtual bool IsActiveWidget() const override;
+  virtual bool AreItemsOperable() const override;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/html/HTMLTableAccessible.cpp b/accessible/html/HTMLTableAccessible.cpp
new file mode 100644
index 0000000000..b2b4e65460
--- /dev/null
+++ b/accessible/html/HTMLTableAccessible.cpp
@@ -0,0 +1,769 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "HTMLTableAccessible.h"
+
+#include <stdint.h>
+#include "mozilla/DebugOnly.h"
+
+#include "nsAccessibilityService.h"
+#include "AccAttributes.h"
+#include "ARIAMap.h"
+#include "CacheConstants.h"
+#include "DocAccessible.h"
+#include "LocalAccessible-inl.h"
+#include "nsTextEquivUtils.h"
+#include "Relation.h"
+#include "Role.h"
+#include "States.h"
+
+#include "mozilla/PresShell.h"
+#include "mozilla/a11y/TableAccessible.h"
+#include "mozilla/a11y/TableCellAccessible.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/HTMLTableElement.h"
+#include "mozilla/dom/NameSpaceConstants.h"
+#include "nsCaseTreatment.h"
+#include "nsColor.h"
+#include "nsCOMPtr.h"
+#include "nsCoreUtils.h"
+#include "nsDebug.h"
+#include "nsIHTMLCollection.h"
+#include "nsITableCellLayout.h"
+#include "nsFrameSelection.h"
+#include "nsError.h"
+#include "nsGkAtoms.h"
+#include "nsLiteralString.h"
+#include "nsMargin.h"
+#include "nsQueryFrame.h"
+#include "nsSize.h"
+#include "nsStringFwd.h"
+#include "nsTableCellFrame.h"
+#include "nsTableWrapperFrame.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableCellAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLTableCellAccessible::HTMLTableCellAccessible(nsIContent* aContent,
+                                                 DocAccessible* aDoc)
+    : HyperTextAccessibleWrap(aContent, aDoc) {
+  mType = eHTMLTableCellType;
+  mGenericTypes |= eTableCell;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableCellAccessible: LocalAccessible implementation
+
+role HTMLTableCellAccessible::NativeRole() const {
+  // We implement this rather than using the markup maps because we only want
+  // this role to be returned if this is a valid cell. An invalid cell (e.g. if
+  // the table has role="none") won't use this class, so it will get a generic
+  // role, since the markup map doesn't specify a role.
+  if (mContent->IsMathMLElement(nsGkAtoms::mtd_)) {
+    return roles::MATHML_CELL;
+  }
+  return roles::CELL;
+}
+
+uint64_t HTMLTableCellAccessible::NativeState() const {
+  uint64_t state = HyperTextAccessibleWrap::NativeState();
+
+  nsIFrame* frame = mContent->GetPrimaryFrame();
+  NS_ASSERTION(frame, "No frame for valid cell accessible!");
+
+  if (frame && frame->IsSelected()) {
+    state |= states::SELECTED;
+  }
+
+  return state;
+}
+
+uint64_t HTMLTableCellAccessible::NativeInteractiveState() const {
+  return HyperTextAccessibleWrap::NativeInteractiveState() | states::SELECTABLE;
+}
+
+already_AddRefed<AccAttributes> HTMLTableCellAccessible::NativeAttributes() {
+  RefPtr<AccAttributes> attributes =
+      HyperTextAccessibleWrap::NativeAttributes();
+
+  // We only need to expose table-cell-index to clients. If we're in the content
+  // process, we don't need this, so building a CachedTableAccessible is very
+  // wasteful. This will be exposed by RemoteAccessible in the parent process
+  // instead.
+  if (!IPCAccessibilityActive()) {
+    if (const TableCellAccessible* cell = AsTableCell()) {
+      TableAccessible* table = cell->Table();
+      const uint32_t row = cell->RowIdx();
+      const uint32_t col = cell->ColIdx();
+      const int32_t cellIdx = table->CellIndexAt(row, col);
+      if (cellIdx != -1) {
+        attributes->SetAttribute(nsGkAtoms::tableCellIndex, cellIdx);
+      }
+    }
+  }
+
+  // abbr attribute
+
+  // Pick up object attribute from abbr DOM element (a child of the cell) or
+  // from abbr DOM attribute.
+  nsString abbrText;
+  if (ChildCount() == 1) {
+    LocalAccessible* abbr = LocalFirstChild();
+    if (abbr->IsAbbreviation()) {
+      nsIContent* firstChildNode = abbr->GetContent()->GetFirstChild();
+      if (firstChildNode) {
+        nsTextEquivUtils::AppendTextEquivFromTextContent(firstChildNode,
+                                                         &abbrText);
+      }
+    }
+  }
+  if (abbrText.IsEmpty()) {
+    mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::abbr,
+                                   abbrText);
+  }
+
+  if (!abbrText.IsEmpty()) {
+    attributes->SetAttribute(nsGkAtoms::abbr, std::move(abbrText));
+  }
+
+  // axis attribute
+  nsString axisText;
+  mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::axis, axisText);
+  if (!axisText.IsEmpty()) {
+    attributes->SetAttribute(nsGkAtoms::axis, std::move(axisText));
+  }
+
+  return attributes.forget();
+}
+
+void HTMLTableCellAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
+                                                  nsAtom* aAttribute,
+                                                  int32_t aModType,
+                                                  const nsAttrValue* aOldValue,
+                                                  uint64_t aOldState) {
+  HyperTextAccessibleWrap::DOMAttributeChanged(aNameSpaceID, aAttribute,
+                                               aModType, aOldValue, aOldState);
+
+  if (aAttribute == nsGkAtoms::headers || aAttribute == nsGkAtoms::abbr ||
+      aAttribute == nsGkAtoms::scope) {
+    mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_OBJECT_ATTRIBUTE_CHANGED,
+                           this);
+    if (HTMLTableAccessible* table = Table()) {
+      // Modifying these attributes can also modify our table's classification
+      // as either a layout or data table. Queue an update on the table itself
+      // to re-compute our "layout guess"
+      mDoc->QueueCacheUpdate(table, CacheDomain::Table);
+    }
+    mDoc->QueueCacheUpdate(this, CacheDomain::Table);
+  } else if (aAttribute == nsGkAtoms::rowspan ||
+             aAttribute == nsGkAtoms::colspan) {
+    if (HTMLTableAccessible* table = Table()) {
+      // Modifying these attributes can also modify our table's classification
+      // as either a layout or data table. Queue an update on the table itself
+      // to re-compute our "layout guess"
+      mDoc->QueueCacheUpdate(table, CacheDomain::Table);
+    }
+    mDoc->QueueCacheUpdate(this, CacheDomain::Table);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableCellAccessible implementation
+
+HTMLTableAccessible* HTMLTableCellAccessible::Table() const {
+  LocalAccessible* parent = const_cast<HTMLTableCellAccessible*>(this);
+  while ((parent = parent->LocalParent())) {
+    if (parent->IsHTMLTable()) {
+      return HTMLTableAccessible::GetFrom(parent);
+    }
+  }
+
+  return nullptr;
+}
+
+uint32_t HTMLTableCellAccessible::ColExtent() const {
+  int32_t rowIdx = -1, colIdx = -1;
+  if (NS_FAILED(GetCellIndexes(rowIdx, colIdx))) {
+    // This probably isn't a table according to the layout engine; e.g. it has
+    // display: block.
+    return 1;
+  }
+
+  HTMLTableAccessible* table = Table();
+  if (NS_WARN_IF(!table)) {
+    // This can happen where there is a <tr> inside a <div role="table"> such as
+    // in Monorail.
+    return 1;
+  }
+
+  return table->ColExtentAt(rowIdx, colIdx);
+}
+
+uint32_t HTMLTableCellAccessible::RowExtent() const {
+  int32_t rowIdx = -1, colIdx = -1;
+  if (NS_FAILED(GetCellIndexes(rowIdx, colIdx))) {
+    // This probably isn't a table according to the layout engine; e.g. it has
+    // display: block.
+    return 1;
+  }
+
+  HTMLTableAccessible* table = Table();
+  if (NS_WARN_IF(!table)) {
+    // This can happen where there is a <tr> inside a <div role="table"> such as
+    // in Monorail.
+    return 1;
+  }
+
+  return table->RowExtentAt(rowIdx, colIdx);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableCellAccessible: protected implementation
+
+nsITableCellLayout* HTMLTableCellAccessible::GetCellLayout() const {
+  return do_QueryFrame(mContent->GetPrimaryFrame());
+}
+
+nsresult HTMLTableCellAccessible::GetCellIndexes(int32_t& aRowIdx,
+                                                 int32_t& aColIdx) const {
+  nsITableCellLayout* cellLayout = GetCellLayout();
+  NS_ENSURE_STATE(cellLayout);
+
+  return cellLayout->GetCellIndexes(aRowIdx, aColIdx);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableHeaderCellAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLTableHeaderCellAccessible::HTMLTableHeaderCellAccessible(
+    nsIContent* aContent, DocAccessible* aDoc)
+    : HTMLTableCellAccessible(aContent, aDoc) {}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableHeaderCellAccessible: LocalAccessible implementation
+
+role HTMLTableHeaderCellAccessible::NativeRole() const {
+  dom::Element* el = Elm();
+  if (!el) {
+    return roles::NOTHING;
+  }
+
+  // Check value of @scope attribute.
+  static mozilla::dom::Element::AttrValuesArray scopeValues[] = {
+      nsGkAtoms::col, nsGkAtoms::colgroup, nsGkAtoms::row, nsGkAtoms::rowgroup,
+      nullptr};
+  int32_t valueIdx = el->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::scope,
+                                         scopeValues, eCaseMatters);
+
+  switch (valueIdx) {
+    case 0:
+    case 1:
+      return roles::COLUMNHEADER;
+    case 2:
+    case 3:
+      return roles::ROWHEADER;
+  }
+
+  dom::Element* nextEl = el->GetNextElementSibling();
+  dom::Element* prevEl = el->GetPreviousElementSibling();
+  // If this is the only cell in its row, it's a column header.
+  if (!nextEl && !prevEl) {
+    return roles::COLUMNHEADER;
+  }
+  const bool nextIsHeader = nextEl && nsCoreUtils::IsHTMLTableHeader(nextEl);
+  const bool prevIsHeader = prevEl && nsCoreUtils::IsHTMLTableHeader(prevEl);
+  // If this has a header on both sides, it is a column header.
+  if (prevIsHeader && nextIsHeader) {
+    return roles::COLUMNHEADER;
+  }
+  // If this has a header on one side and only a single normal cell on the
+  // other, it's a column header.
+  if (nextIsHeader && prevEl && !prevEl->GetPreviousElementSibling()) {
+    return roles::COLUMNHEADER;
+  }
+  if (prevIsHeader && nextEl && !nextEl->GetNextElementSibling()) {
+    return roles::COLUMNHEADER;
+  }
+  // If this has a normal cell next to it, it 's a row header.
+  if ((nextEl && !nextIsHeader) || (prevEl && !prevIsHeader)) {
+    return roles::ROWHEADER;
+  }
+  // If this has a row span, it could be a row header.
+  if (RowExtent() > 1) {
+    // It isn't a row header if it has 1 or more consecutive headers next to it.
+    if (prevIsHeader &&
+        (!prevEl->GetPreviousElementSibling() ||
+         nsCoreUtils::IsHTMLTableHeader(prevEl->GetPreviousElementSibling()))) {
+      return roles::COLUMNHEADER;
+    }
+    if (nextIsHeader &&
+        (!nextEl->GetNextElementSibling() ||
+         nsCoreUtils::IsHTMLTableHeader(nextEl->GetNextElementSibling()))) {
+      return roles::COLUMNHEADER;
+    }
+    return roles::ROWHEADER;
+  }
+  // Otherwise, assume it's a column header.
+  return roles::COLUMNHEADER;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableRowAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+// LocalAccessible protected
+ENameValueFlag HTMLTableRowAccessible::NativeName(nsString& aName) const {
+  // For table row accessibles, we only want to calculate the name from the
+  // sub tree if an ARIA role is present.
+  if (HasStrongARIARole()) {
+    return AccessibleWrap::NativeName(aName);
+  }
+
+  return eNameOK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableAccessible: LocalAccessible
+
+bool HTMLTableAccessible::InsertChildAt(uint32_t aIndex,
+                                        LocalAccessible* aChild) {
+  // Move caption accessible so that it's the first child. Check for the first
+  // caption only, because nsAccessibilityService ensures we don't create
+  // accessibles for the other captions, since only the first is actually
+  // visible.
+  return HyperTextAccessible::InsertChildAt(
+      aChild->IsHTMLCaption() ? 0 : aIndex, aChild);
+}
+
+uint64_t HTMLTableAccessible::NativeState() const {
+  return LocalAccessible::NativeState() | states::READONLY;
+}
+
+ENameValueFlag HTMLTableAccessible::NativeName(nsString& aName) const {
+  ENameValueFlag nameFlag = LocalAccessible::NativeName(aName);
+  if (!aName.IsEmpty()) {
+    return nameFlag;
+  }
+
+  // Use table caption as a name.
+  LocalAccessible* caption = Caption();
+  if (caption) {
+    nsIContent* captionContent = caption->GetContent();
+    if (captionContent) {
+      nsTextEquivUtils::AppendTextEquivFromContent(this, captionContent,
+                                                   &aName);
+      if (!aName.IsEmpty()) {
+        return eNameOK;
+      }
+    }
+  }
+
+  // If no caption then use summary as a name.
+  mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::summary, aName);
+  return eNameOK;
+}
+
+void HTMLTableAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
+                                              nsAtom* aAttribute,
+                                              int32_t aModType,
+                                              const nsAttrValue* aOldValue,
+                                              uint64_t aOldState) {
+  HyperTextAccessibleWrap::DOMAttributeChanged(aNameSpaceID, aAttribute,
+                                               aModType, aOldValue, aOldState);
+
+  if (aAttribute == nsGkAtoms::summary) {
+    nsAutoString name;
+    ARIAName(name);
+    if (name.IsEmpty()) {
+      if (!Caption()) {
+        // XXX: Should really be checking if caption provides a name.
+        mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, this);
+      }
+    }
+
+    mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_OBJECT_ATTRIBUTE_CHANGED,
+                           this);
+    mDoc->QueueCacheUpdate(this, CacheDomain::Table);
+  }
+}
+
+already_AddRefed<AccAttributes> HTMLTableAccessible::NativeAttributes() {
+  RefPtr<AccAttributes> attributes = AccessibleWrap::NativeAttributes();
+
+  if (mContent->IsMathMLElement(nsGkAtoms::mtable_)) {
+    GetAccService()->MarkupAttributes(this, attributes);
+  }
+
+  if (IsProbablyLayoutTable()) {
+    attributes->SetAttribute(nsGkAtoms::layout_guess, true);
+  }
+
+  return attributes.forget();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableAccessible: LocalAccessible
+
+Relation HTMLTableAccessible::RelationByType(RelationType aType) const {
+  Relation rel = AccessibleWrap::RelationByType(aType);
+  if (aType == RelationType::LABELLED_BY) {
+    rel.AppendTarget(Caption());
+  }
+
+  return rel;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableAccessible: Table
+
+LocalAccessible* HTMLTableAccessible::Caption() const {
+  LocalAccessible* child = mChildren.SafeElementAt(0, nullptr);
+  // Since this is an HTML table the caption needs to be a caption
+  // element with no ARIA role (except for a reduntant role='caption').
+  // If we did a full Role() calculation here we risk getting into an infinite
+  // loop where the parent role would depend on its name which would need to be
+  // calculated by retrieving the caption (bug 1420773.)
+  return child && child->NativeRole() == roles::CAPTION &&
+                 (!child->HasStrongARIARole() ||
+                  child->IsARIARole(nsGkAtoms::caption))
+             ? child
+             : nullptr;
+}
+
+uint32_t HTMLTableAccessible::ColCount() const {
+  nsTableWrapperFrame* tableFrame = GetTableWrapperFrame();
+  return tableFrame ? tableFrame->GetColCount() : 0;
+}
+
+uint32_t HTMLTableAccessible::RowCount() {
+  nsTableWrapperFrame* tableFrame = GetTableWrapperFrame();
+  return tableFrame ? tableFrame->GetRowCount() : 0;
+}
+
+uint32_t HTMLTableAccessible::ColExtentAt(uint32_t aRowIdx, uint32_t aColIdx) {
+  nsTableWrapperFrame* tableFrame = GetTableWrapperFrame();
+  if (!tableFrame) {
+    return 1;
+  }
+
+  return tableFrame->GetEffectiveColSpanAt(aRowIdx, aColIdx);
+}
+
+uint32_t HTMLTableAccessible::RowExtentAt(uint32_t aRowIdx, uint32_t aColIdx) {
+  nsTableWrapperFrame* tableFrame = GetTableWrapperFrame();
+  if (!tableFrame) {
+    return 1;
+  }
+
+  return tableFrame->GetEffectiveRowSpanAt(aRowIdx, aColIdx);
+}
+
+bool HTMLTableAccessible::IsProbablyLayoutTable() {
+  // Implement a heuristic to determine if table is most likely used for layout.
+
+  // XXX do we want to look for rowspan or colspan, especialy that span all but
+  // a couple cells  at the beginning or end of a row/col, and especially when
+  // they occur at the edge of a table?
+
+  // XXX For now debugging descriptions are always on via SHOW_LAYOUT_HEURISTIC
+  // This will allow release trunk builds to be used by testers to refine
+  // the algorithm. Integrate it into Logging.
+  // Change to |#define SHOW_LAYOUT_HEURISTIC DEBUG| before final release
+#ifdef SHOW_LAYOUT_HEURISTIC
+#  define RETURN_LAYOUT_ANSWER(isLayout, heuristic)                         \
+    {                                                                       \
+      mLayoutHeuristic = isLayout                                           \
+                             ? nsLiteralString(u"layout table: " heuristic) \
+                             : nsLiteralString(u"data table: " heuristic);  \
+      return isLayout;                                                      \
+    }
+#else
+#  define RETURN_LAYOUT_ANSWER(isLayout, heuristic) \
+    { return isLayout; }
+#endif
+
+  MOZ_ASSERT(!IsDefunct(), "Table accessible should not be defunct");
+
+  // Need to see all elements while document is being edited.
+  if (Document()->State() & states::EDITABLE) {
+    RETURN_LAYOUT_ANSWER(false, "In editable document");
+  }
+
+  // Check to see if an ARIA role overrides the role from native markup,
+  // but for which we still expose table semantics (treegrid, for example).
+  if (HasARIARole()) {
+    RETURN_LAYOUT_ANSWER(false, "Has role attribute");
+  }
+
+  dom::Element* el = Elm();
+  if (el->IsMathMLElement(nsGkAtoms::mtable_)) {
+    RETURN_LAYOUT_ANSWER(false, "MathML matrix");
+  }
+
+  MOZ_ASSERT(el->IsHTMLElement(nsGkAtoms::table),
+             "Table should not be built by CSS display:table style");
+
+  // Check if datatable attribute has "0" value.
+  if (el->AttrValueIs(kNameSpaceID_None, nsGkAtoms::datatable, u"0"_ns,
+                      eCaseMatters)) {
+    RETURN_LAYOUT_ANSWER(true, "Has datatable = 0 attribute, it's for layout");
+  }
+
+  // Check for legitimate data table attributes.
+  if (el->Element::HasNonEmptyAttr(nsGkAtoms::summary)) {
+    RETURN_LAYOUT_ANSWER(false, "Has summary -- legitimate table structures");
+  }
+
+  // Check for legitimate data table elements.
+  LocalAccessible* caption = LocalFirstChild();
+  if (caption && caption->IsHTMLCaption() && caption->HasChildren()) {
+    RETURN_LAYOUT_ANSWER(false,
+                         "Not empty caption -- legitimate table structures");
+  }
+
+  for (nsIContent* childElm = el->GetFirstChild(); childElm;
+       childElm = childElm->GetNextSibling()) {
+    if (!childElm->IsHTMLElement()) continue;
+
+    if (childElm->IsAnyOfHTMLElements(nsGkAtoms::col, nsGkAtoms::colgroup,
+                                      nsGkAtoms::tfoot, nsGkAtoms::thead)) {
+      RETURN_LAYOUT_ANSWER(
+          false,
+          "Has col, colgroup, tfoot or thead -- legitimate table structures");
+    }
+
+    if (childElm->IsHTMLElement(nsGkAtoms::tbody)) {
+      for (nsIContent* rowElm = childElm->GetFirstChild(); rowElm;
+           rowElm = rowElm->GetNextSibling()) {
+        if (rowElm->IsHTMLElement(nsGkAtoms::tr)) {
+          if (LocalAccessible* row = Document()->GetAccessible(rowElm)) {
+            if (const nsRoleMapEntry* roleMapEntry = row->ARIARoleMap()) {
+              if (roleMapEntry->role != roles::ROW) {
+                RETURN_LAYOUT_ANSWER(true, "Repurposed tr with different role");
+              }
+            }
+          }
+
+          for (nsIContent* cellElm = rowElm->GetFirstChild(); cellElm;
+               cellElm = cellElm->GetNextSibling()) {
+            if (cellElm->IsHTMLElement()) {
+              if (cellElm->NodeInfo()->Equals(nsGkAtoms::th)) {
+                RETURN_LAYOUT_ANSWER(false,
+                                     "Has th -- legitimate table structures");
+              }
+
+              if (cellElm->AsElement()->HasAttr(kNameSpaceID_None,
+                                                nsGkAtoms::headers) ||
+                  cellElm->AsElement()->HasAttr(kNameSpaceID_None,
+                                                nsGkAtoms::scope) ||
+                  cellElm->AsElement()->HasAttr(kNameSpaceID_None,
+                                                nsGkAtoms::abbr)) {
+                RETURN_LAYOUT_ANSWER(false,
+                                     "Has headers, scope, or abbr attribute -- "
+                                     "legitimate table structures");
+              }
+
+              if (LocalAccessible* cell = Document()->GetAccessible(cellElm)) {
+                if (const nsRoleMapEntry* roleMapEntry = cell->ARIARoleMap()) {
+                  if (roleMapEntry->role != roles::CELL &&
+                      roleMapEntry->role != roles::COLUMNHEADER &&
+                      roleMapEntry->role != roles::ROWHEADER &&
+                      roleMapEntry->role != roles::GRID_CELL) {
+                    RETURN_LAYOUT_ANSWER(true,
+                                         "Repurposed cell with different role");
+                  }
+                }
+                if (cell->ChildCount() == 1 &&
+                    cell->LocalFirstChild()->IsAbbreviation()) {
+                  RETURN_LAYOUT_ANSWER(
+                      false, "has abbr -- legitimate table structures");
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Check for nested tables.
+  nsCOMPtr<nsIHTMLCollection> nestedTables =
+      el->GetElementsByTagName(u"table"_ns);
+  if (nestedTables->Length() > 0) {
+    RETURN_LAYOUT_ANSWER(true, "Has a nested table within it");
+  }
+
+  // If only 1 column or only 1 row, it's for layout.
+  auto colCount = ColCount();
+  if (colCount <= 1) {
+    RETURN_LAYOUT_ANSWER(true, "Has only 1 column");
+  }
+  auto rowCount = RowCount();
+  if (rowCount <= 1) {
+    RETURN_LAYOUT_ANSWER(true, "Has only 1 row");
+  }
+
+  // Check for many columns.
+  if (colCount >= 5) {
+    RETURN_LAYOUT_ANSWER(false, ">=5 columns");
+  }
+
+  // Now we know there are 2-4 columns and 2 or more rows. Check to see if
+  // there are visible borders on the cells.
+  // XXX currently, we just check the first cell -- do we really need to do
+  // more?
+  nsTableWrapperFrame* tableFrame = do_QueryFrame(el->GetPrimaryFrame());
+  if (!tableFrame) {
+    RETURN_LAYOUT_ANSWER(false, "table with no frame!");
+  }
+
+  nsIFrame* cellFrame = tableFrame->GetCellFrameAt(0, 0);
+  if (!cellFrame) {
+    RETURN_LAYOUT_ANSWER(false, "table's first cell has no frame!");
+  }
+
+  nsMargin border = cellFrame->StyleBorder()->GetComputedBorder();
+  if (border.top && border.bottom && border.left && border.right) {
+    RETURN_LAYOUT_ANSWER(false, "Has nonzero border-width on table cell");
+  }
+
+  // Rules for non-bordered tables with 2-4 columns and 2+ rows from here on
+  // forward.
+
+  // Check for styled background color across rows (alternating background
+  // color is a common feature for data tables).
+  auto childCount = ChildCount();
+  nscolor rowColor = 0;
+  nscolor prevRowColor;
+  for (auto childIdx = 0U; childIdx < childCount; childIdx++) {
+    LocalAccessible* child = LocalChildAt(childIdx);
+    if (child->IsHTMLTableRow()) {
+      prevRowColor = rowColor;
+      nsIFrame* rowFrame = child->GetFrame();
+      MOZ_ASSERT(rowFrame, "Table hierarchy got screwed up");
+      if (!rowFrame) {
+        RETURN_LAYOUT_ANSWER(false, "Unexpected table hierarchy");
+      }
+
+      rowColor = rowFrame->StyleBackground()->BackgroundColor(rowFrame);
+
+      if (childIdx > 0 && prevRowColor != rowColor) {
+        RETURN_LAYOUT_ANSWER(false,
+                             "2 styles of row background color, non-bordered");
+      }
+    }
+  }
+
+  // Check for many rows.
+  const uint32_t kMaxLayoutRows = 20;
+  if (rowCount > kMaxLayoutRows) {  // A ton of rows, this is probably for data
+    RETURN_LAYOUT_ANSWER(false, ">= kMaxLayoutRows (20) and non-bordered");
+  }
+
+  // Check for very wide table.
+  nsIFrame* documentFrame = Document()->GetFrame();
+  nsSize documentSize = documentFrame->GetSize();
+  if (documentSize.width > 0) {
+    nsSize tableSize = GetFrame()->GetSize();
+    int32_t percentageOfDocWidth = (100 * tableSize.width) / documentSize.width;
+    if (percentageOfDocWidth > 95) {
+      // 3-4 columns, no borders, not a lot of rows, and 95% of the doc's width
+      // Probably for layout
+      RETURN_LAYOUT_ANSWER(
+          true, "<= 4 columns, table width is 95% of document width");
+    }
+  }
+
+  // Two column rules.
+  if (rowCount * colCount <= 10) {
+    RETURN_LAYOUT_ANSWER(true, "2-4 columns, 10 cells or less, non-bordered");
+  }
+
+  static const nsLiteralString tags[] = {u"embed"_ns, u"object"_ns,
+                                         u"iframe"_ns};
+  for (const auto& tag : tags) {
+    nsCOMPtr<nsIHTMLCollection> descendants = el->GetElementsByTagName(tag);
+    if (descendants->Length() > 0) {
+      RETURN_LAYOUT_ANSWER(true,
+                           "Has no borders, and has iframe, object or embed, "
+                           "typical of advertisements");
+    }
+  }
+
+  RETURN_LAYOUT_ANSWER(false,
+                       "No layout factor strong enough, so will guess data");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLTableAccessible: protected implementation
+
+void HTMLTableAccessible::Description(nsString& aDescription) const {
+  // Helpful for debugging layout vs. data tables
+  aDescription.Truncate();
+  LocalAccessible::Description(aDescription);
+  if (!aDescription.IsEmpty()) {
+    return;
+  }
+
+  // Use summary as description if it weren't used as a name.
+  // XXX: get rid code duplication with NameInternal().
+  LocalAccessible* caption = Caption();
+  if (caption) {
+    nsIContent* captionContent = caption->GetContent();
+    if (captionContent) {
+      nsAutoString captionText;
+      nsTextEquivUtils::AppendTextEquivFromContent(this, captionContent,
+                                                   &captionText);
+
+      if (!captionText.IsEmpty()) {  // summary isn't used as a name.
+        mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::summary,
+                                       aDescription);
+      }
+    }
+  }
+
+#ifdef SHOW_LAYOUT_HEURISTIC
+  if (aDescription.IsEmpty()) {
+    bool isProbablyForLayout = IsProbablyLayoutTable();
+    aDescription = mLayoutHeuristic;
+  }
+  printf("\nTABLE: %s\n", NS_ConvertUTF16toUTF8(mLayoutHeuristic).get());
+#endif
+}
+
+nsTableWrapperFrame* HTMLTableAccessible::GetTableWrapperFrame() const {
+  nsTableWrapperFrame* tableFrame = do_QueryFrame(mContent->GetPrimaryFrame());
+  if (tableFrame && tableFrame->PrincipalChildList().FirstChild()) {
+    return tableFrame;
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLCaptionAccessible
+////////////////////////////////////////////////////////////////////////////////
+
+Relation HTMLCaptionAccessible::RelationByType(RelationType aType) const {
+  Relation rel = HyperTextAccessible::RelationByType(aType);
+  if (aType == RelationType::LABEL_FOR) {
+    rel.AppendTarget(LocalParent());
+  }
+
+  return rel;
+}
+
+role HTMLCaptionAccessible::NativeRole() const { return roles::CAPTION; }
diff --git a/accessible/html/HTMLTableAccessible.h b/accessible/html/HTMLTableAccessible.h
new file mode 100644
index 0000000000..d738f64aa1
--- /dev/null
+++ b/accessible/html/HTMLTableAccessible.h
@@ -0,0 +1,190 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_HTMLTableAccessible_h__
+#define mozilla_a11y_HTMLTableAccessible_h__
+
+#include "HyperTextAccessibleWrap.h"
+
+class nsITableCellLayout;
+class nsTableCellFrame;
+class nsTableWrapperFrame;
+
+namespace mozilla {
+
+namespace a11y {
+
+class HTMLTableAccessible;
+
+/**
+ * HTML table cell accessible (html:td).
+ */
+class HTMLTableCellAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLTableCellAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // nsISupports
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLTableCellAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+  virtual uint64_t NativeState() const override;
+  virtual uint64_t NativeInteractiveState() const override;
+  virtual already_AddRefed<AccAttributes> NativeAttributes() override;
+
+ protected:
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+  // HTMLTableCellAccessible
+ public:
+  HTMLTableAccessible* Table() const;
+  uint32_t ColExtent() const;
+  uint32_t RowExtent() const;
+
+  static HTMLTableCellAccessible* GetFrom(LocalAccessible* aAcc) {
+    if (aAcc->IsHTMLTableCell()) {
+      return static_cast<HTMLTableCellAccessible*>(aAcc);
+    }
+    return nullptr;
+  }
+
+ protected:
+  virtual ~HTMLTableCellAccessible() {}
+
+  /**
+   * Return nsITableCellLayout of the table cell frame.
+   */
+  nsITableCellLayout* GetCellLayout() const;
+
+  /**
+   * Return row and column indices of the cell.
+   */
+  nsresult GetCellIndexes(int32_t& aRowIdx, int32_t& aColIdx) const;
+};
+
+/**
+ * HTML table row/column header accessible (html:th or html:td@scope).
+ */
+class HTMLTableHeaderCellAccessible : public HTMLTableCellAccessible {
+ public:
+  HTMLTableHeaderCellAccessible(nsIContent* aContent, DocAccessible* aDoc);
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+};
+
+/**
+ * HTML table row accessible (html:tr).
+ */
+class HTMLTableRowAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLTableRowAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HyperTextAccessibleWrap(aContent, aDoc) {
+    mType = eHTMLTableRowType;
+    mGenericTypes |= eTableRow;
+  }
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLTableRowAccessible,
+                                       HyperTextAccessibleWrap)
+
+ protected:
+  virtual ~HTMLTableRowAccessible() {}
+
+  // LocalAccessible
+  virtual ENameValueFlag NativeName(nsString& aName) const override;
+};
+
+/**
+ * HTML table accessible (html:table).
+ */
+
+// To turn on table debugging descriptions define SHOW_LAYOUT_HEURISTIC
+// This allow release trunk builds to be used by testers to refine the
+// data vs. layout heuristic
+// #define SHOW_LAYOUT_HEURISTIC
+
+class HTMLTableAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLTableAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HyperTextAccessibleWrap(aContent, aDoc) {
+    mType = eHTMLTableType;
+    mGenericTypes |= eTable;
+  }
+
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLTableAccessible,
+                                       HyperTextAccessibleWrap)
+
+  // HTMLTableAccessible
+  LocalAccessible* Caption() const;
+  uint32_t ColCount() const;
+  uint32_t RowCount();
+  uint32_t ColExtentAt(uint32_t aRowIdx, uint32_t aColIdx);
+  uint32_t RowExtentAt(uint32_t aRowIdx, uint32_t aColIdx);
+  bool IsProbablyLayoutTable();
+
+  static HTMLTableAccessible* GetFrom(LocalAccessible* aAcc) {
+    if (aAcc->IsHTMLTable()) {
+      return static_cast<HTMLTableAccessible*>(aAcc);
+    }
+    return nullptr;
+  }
+
+  // LocalAccessible
+  virtual void Description(nsString& aDescription) const override;
+  virtual uint64_t NativeState() const override;
+  virtual already_AddRefed<AccAttributes> NativeAttributes() override;
+  virtual Relation RelationByType(RelationType aRelationType) const override;
+
+  virtual bool InsertChildAt(uint32_t aIndex, LocalAccessible* aChild) override;
+
+ protected:
+  virtual ~HTMLTableAccessible() {}
+
+  // LocalAccessible
+  virtual ENameValueFlag NativeName(nsString& aName) const override;
+
+  virtual void DOMAttributeChanged(int32_t aNameSpaceID, nsAtom* aAttribute,
+                                   int32_t aModType,
+                                   const nsAttrValue* aOldValue,
+                                   uint64_t aOldState) override;
+
+  // HTMLTableAccessible
+
+#ifdef SHOW_LAYOUT_HEURISTIC
+  nsString mLayoutHeuristic;
+#endif
+
+ private:
+  /**
+   * Get table wrapper frame, or return null if there is no inner table.
+   */
+  nsTableWrapperFrame* GetTableWrapperFrame() const;
+};
+
+/**
+ * HTML caption accessible (html:caption).
+ */
+class HTMLCaptionAccessible : public HyperTextAccessibleWrap {
+ public:
+  HTMLCaptionAccessible(nsIContent* aContent, DocAccessible* aDoc)
+      : HyperTextAccessibleWrap(aContent, aDoc) {
+    mType = eHTMLCaptionType;
+  }
+
+  // LocalAccessible
+  virtual a11y::role NativeRole() const override;
+  virtual Relation RelationByType(RelationType aRelationType) const override;
+
+ protected:
+  virtual ~HTMLCaptionAccessible() {}
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/html/moz.build b/accessible/html/moz.build
new file mode 100644
index 0000000000..3a246373da
--- /dev/null
+++ b/accessible/html/moz.build
@@ -0,0 +1,52 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+UNIFIED_SOURCES += [
+    "HTMLCanvasAccessible.cpp",
+    "HTMLElementAccessibles.cpp",
+    "HTMLFormControlAccessible.cpp",
+    "HTMLImageMapAccessible.cpp",
+    "HTMLLinkAccessible.cpp",
+    "HTMLListAccessible.cpp",
+    "HTMLSelectAccessible.cpp",
+    "HTMLTableAccessible.cpp",
+]
+
+LOCAL_INCLUDES += [
+    "/accessible/base",
+    "/accessible/generic",
+    "/accessible/xpcom",
+    "/layout/forms",
+    "/layout/generic",
+    "/layout/tables",
+    "/layout/xul",
+]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk":
+    LOCAL_INCLUDES += [
+        "/accessible/atk",
+    ]
+elif CONFIG["MOZ_WIDGET_TOOLKIT"] == "windows":
+    LOCAL_INCLUDES += [
+        "/accessible/windows/ia2",
+        "/accessible/windows/msaa",
+    ]
+elif CONFIG["MOZ_WIDGET_TOOLKIT"] == "cocoa":
+    LOCAL_INCLUDES += [
+        "/accessible/mac",
+    ]
+elif CONFIG["MOZ_WIDGET_TOOLKIT"] == "android":
+    LOCAL_INCLUDES += [
+        "/accessible/android",
+    ]
+else:
+    LOCAL_INCLUDES += [
+        "/accessible/other",
+    ]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"