Adding upstream version 124.0.1.upstream/124.0.1

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

74 files changed, 25241 insertions, 0 deletions

diff --git a/accessible/base/ARIAMap.cpp b/accessible/base/ARIAMap.cpp
new file mode 100644
index 0000000000..01cc5d0417
--- /dev/null
+++ b/accessible/base/ARIAMap.cpp
@@ -0,0 +1,1687 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=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 "ARIAMap.h"
+
+#include "AccAttributes.h"
+#include "nsAccUtils.h"
+#include "nsCoreUtils.h"
+#include "mozilla/a11y/Role.h"
+#include "States.h"
+
+#include "nsAttrName.h"
+#include "nsWhitespaceTokenizer.h"
+
+#include "mozilla/BinarySearch.h"
+#include "mozilla/dom/Element.h"
+
+#include "nsUnicharUtils.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+using namespace mozilla::a11y::aria;
+
+static const uint32_t kGenericAccType = 0;
+
+/**
+ *  This list of WAI-defined roles are currently hardcoded.
+ *  Eventually we will most likely be loading an RDF resource that contains this
+ * information Using RDF will also allow for role extensibility. See bug 280138.
+ *
+ *  Definition of nsRoleMapEntry contains comments explaining this table.
+ *
+ *  When no Role enum mapping exists for an ARIA role, the role will be exposed
+ *  via the object attribute "xml-roles".
+ *
+ * Note: the list must remain alphabetically ordered to support binary search.
+ */
+
+static const nsRoleMapEntry sWAIRoleMaps[] = {
+    // clang-format off
+  { // alert
+    nsGkAtoms::alert,
+    roles::ALERT,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+#if defined(XP_MACOSX)
+    eAssertiveLiveAttr,
+#else
+    eNoLiveAttr,
+#endif
+    eAlert,
+    kNoReqStates
+  },
+  { // alertdialog
+    nsGkAtoms::alertdialog,
+    roles::DIALOG,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // application
+    nsGkAtoms::application,
+    roles::APPLICATION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // article
+    nsGkAtoms::article,
+    roles::ARTICLE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eReadonlyUntilEditable
+  },
+  { // banner
+    nsGkAtoms::banner,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // blockquote
+    nsGkAtoms::blockquote,
+    roles::BLOCKQUOTE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+  },
+  { // button
+    nsGkAtoms::button,
+    roles::PUSHBUTTON,
+    kUseMapRole,
+    eNoValue,
+    ePressAction,
+    eNoLiveAttr,
+    eButton,
+    kNoReqStates
+    // eARIAPressed is auto applied on any button
+  },
+  { // caption
+    nsGkAtoms::caption,
+    roles::CAPTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+  },
+  { // cell
+    nsGkAtoms::cell,
+    roles::CELL,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eTableCell,
+    kNoReqStates
+  },
+  { // checkbox
+    nsGkAtoms::checkbox,
+    roles::CHECKBUTTON,
+    kUseMapRole,
+    eNoValue,
+    eCheckUncheckAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIACheckableMixed,
+    eARIAReadonly
+  },
+  { // code
+    nsGkAtoms::code,
+    roles::CODE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+  },
+  { // columnheader
+    nsGkAtoms::columnheader,
+    roles::COLUMNHEADER,
+    kUseMapRole,
+    eNoValue,
+    eSortAction,
+    eNoLiveAttr,
+    eTableCell,
+    kNoReqStates,
+    eARIASelectableIfDefined,
+    eARIAReadonly
+  },
+  { // combobox, which consists of text input and popup
+    nsGkAtoms::combobox,
+    roles::EDITCOMBOBOX,
+    kUseMapRole,
+    eNoValue,
+    eOpenCloseAction,
+    eNoLiveAttr,
+    eCombobox,
+    states::COLLAPSED | states::HASPOPUP,
+    eARIAAutoComplete,
+    eARIAReadonly,
+    eARIAOrientation
+  },
+  { // comment
+    nsGkAtoms::comment,
+    roles::COMMENT,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+  },
+  { // complementary
+    nsGkAtoms::complementary,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // contentinfo
+    nsGkAtoms::contentinfo,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // definition
+    nsGkAtoms::definition,
+    roles::DEFINITION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+  },
+  { // deletion
+    nsGkAtoms::deletion,
+    roles::CONTENT_DELETION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+  },
+  { // dialog
+    nsGkAtoms::dialog,
+    roles::DIALOG,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // directory
+    nsGkAtoms::directory,
+    roles::LIST,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eList,
+    states::READONLY
+  },
+  { // doc-abstract
+    nsGkAtoms::docAbstract,
+    roles::SECTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-acknowledgments
+    nsGkAtoms::docAcknowledgments,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-afterword
+    nsGkAtoms::docAfterword,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-appendix
+    nsGkAtoms::docAppendix,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-backlink
+    nsGkAtoms::docBacklink,
+    roles::LINK,
+    kUseMapRole,
+    eNoValue,
+    eJumpAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::LINKED
+  },
+  { // doc-biblioentry
+    nsGkAtoms::docBiblioentry,
+    roles::LISTITEM,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::READONLY
+  },
+  { // doc-bibliography
+    nsGkAtoms::docBibliography,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-biblioref
+    nsGkAtoms::docBiblioref,
+    roles::LINK,
+    kUseMapRole,
+    eNoValue,
+    eJumpAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::LINKED
+  },
+  { // doc-chapter
+    nsGkAtoms::docChapter,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-colophon
+    nsGkAtoms::docColophon,
+    roles::SECTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-conclusion
+    nsGkAtoms::docConclusion,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-cover
+    nsGkAtoms::docCover,
+    roles::GRAPHIC,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-credit
+    nsGkAtoms::docCredit,
+    roles::SECTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-credits
+    nsGkAtoms::docCredits,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-dedication
+    nsGkAtoms::docDedication,
+    roles::SECTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-endnote
+    nsGkAtoms::docEndnote,
+    roles::LISTITEM,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::READONLY
+  },
+  { // doc-endnotes
+    nsGkAtoms::docEndnotes,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-epigraph
+    nsGkAtoms::docEpigraph,
+    roles::SECTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-epilogue
+    nsGkAtoms::docEpilogue,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-errata
+    nsGkAtoms::docErrata,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-example
+    nsGkAtoms::docExample,
+    roles::SECTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-footnote
+    nsGkAtoms::docFootnote,
+    roles::FOOTNOTE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-foreword
+    nsGkAtoms::docForeword,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-glossary
+    nsGkAtoms::docGlossary,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-glossref
+    nsGkAtoms::docGlossref,
+    roles::LINK,
+    kUseMapRole,
+    eNoValue,
+    eJumpAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::LINKED
+  },
+  { // doc-index
+    nsGkAtoms::docIndex,
+    roles::NAVIGATION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-introduction
+    nsGkAtoms::docIntroduction,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-noteref
+    nsGkAtoms::docNoteref,
+    roles::LINK,
+    kUseMapRole,
+    eNoValue,
+    eJumpAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::LINKED
+  },
+  { // doc-notice
+    nsGkAtoms::docNotice,
+    roles::NOTE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-pagebreak
+    nsGkAtoms::docPagebreak,
+    roles::SEPARATOR,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-pagelist
+    nsGkAtoms::docPagelist,
+    roles::NAVIGATION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-part
+    nsGkAtoms::docPart,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-preface
+    nsGkAtoms::docPreface,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-prologue
+    nsGkAtoms::docPrologue,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // doc-pullquote
+    nsGkAtoms::docPullquote,
+    roles::SECTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-qna
+    nsGkAtoms::docQna,
+    roles::SECTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-subtitle
+    nsGkAtoms::docSubtitle,
+    roles::HEADING,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-tip
+    nsGkAtoms::docTip,
+    roles::NOTE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // doc-toc
+    nsGkAtoms::docToc,
+    roles::NAVIGATION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // document
+    nsGkAtoms::document,
+    roles::NON_NATIVE_DOCUMENT,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eReadonlyUntilEditable
+  },
+  { // emphasis
+    nsGkAtoms::emphasis,
+    roles::EMPHASIS,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // feed
+    nsGkAtoms::feed,
+    roles::GROUPING,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // figure
+    nsGkAtoms::figure,
+    roles::FIGURE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // form
+    nsGkAtoms::form,
+    roles::FORM,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // generic
+    nsGkAtoms::generic,
+    roles::SECTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // graphics-document
+    nsGkAtoms::graphicsDocument,
+    roles::NON_NATIVE_DOCUMENT,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eReadonlyUntilEditable
+  },
+  { // graphics-object
+    nsGkAtoms::graphicsObject,
+    roles::GROUPING,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // graphics-symbol
+    nsGkAtoms::graphicsSymbol,
+    roles::GRAPHIC,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // grid
+    nsGkAtoms::grid,
+    roles::TABLE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eSelect | eTable,
+    kNoReqStates,
+    eARIAMultiSelectable,
+    eARIAReadonly,
+    eFocusableUntilDisabled
+  },
+  { // gridcell
+    nsGkAtoms::gridcell,
+    roles::GRID_CELL,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eTableCell,
+    kNoReqStates,
+    eARIASelectable,
+    eARIAReadonly
+  },
+  { // group
+    nsGkAtoms::group,
+    roles::GROUPING,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // heading
+    nsGkAtoms::heading,
+    roles::HEADING,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // image
+    nsGkAtoms::image,
+    roles::GRAPHIC,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // img
+    nsGkAtoms::img,
+    roles::GRAPHIC,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // insertion
+    nsGkAtoms::insertion,
+    roles::CONTENT_INSERTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+  },
+  { // key
+    nsGkAtoms::key,
+    roles::KEY,
+    kUseMapRole,
+    eNoValue,
+    ePressAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIAPressed
+  },
+  { // link
+    nsGkAtoms::link,
+    roles::LINK,
+    kUseMapRole,
+    eNoValue,
+    eJumpAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::LINKED
+  },
+  { // list
+    nsGkAtoms::list_,
+    roles::LIST,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eList,
+    states::READONLY
+  },
+  { // listbox
+    nsGkAtoms::listbox,
+    roles::LISTBOX,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eListControl | eSelect,
+    states::VERTICAL,
+    eARIAMultiSelectable,
+    eARIAReadonly,
+    eFocusableUntilDisabled,
+    eARIAOrientation
+  },
+  { // listitem
+    nsGkAtoms::listitem,
+    roles::LISTITEM,
+    kUseMapRole,
+    eNoValue,
+    eNoAction, // XXX: should depend on state, parent accessible
+    eNoLiveAttr,
+    kGenericAccType,
+    states::READONLY
+  },
+  { // log
+    nsGkAtoms::log_,
+    roles::NOTHING,
+    kUseNativeRole,
+    eNoValue,
+    eNoAction,
+    ePoliteLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // main
+    nsGkAtoms::main,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // mark
+    nsGkAtoms::mark,
+    roles::MARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+  },
+  { // marquee
+    nsGkAtoms::marquee,
+    roles::ANIMATION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eOffLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // math
+    nsGkAtoms::math,
+    roles::FLAT_EQUATION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // menu
+    nsGkAtoms::menu,
+    roles::MENUPOPUP,
+    kUseMapRole,
+    eNoValue,
+    eNoAction, // XXX: technically accessibles of menupopup role haven't
+               // any action, but menu can be open or close.
+    eNoLiveAttr,
+    kGenericAccType,
+    states::VERTICAL,
+    eARIAOrientation
+  },
+  { // menubar
+    nsGkAtoms::menubar,
+    roles::MENUBAR,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::HORIZONTAL,
+    eARIAOrientation
+  },
+  { // menuitem
+    nsGkAtoms::menuitem,
+    roles::MENUITEM,
+    kUseMapRole,
+    eNoValue,
+    eClickAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // menuitemcheckbox
+    nsGkAtoms::menuitemcheckbox,
+    roles::CHECK_MENU_ITEM,
+    kUseMapRole,
+    eNoValue,
+    eClickAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIACheckableMixed,
+    eARIAReadonly
+  },
+  { // menuitemradio
+    nsGkAtoms::menuitemradio,
+    roles::RADIO_MENU_ITEM,
+    kUseMapRole,
+    eNoValue,
+    eClickAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIACheckableBool,
+    eARIAReadonly
+  },
+  { // meter
+    nsGkAtoms::meter,
+    roles::METER,
+    kUseMapRole,
+    eHasValueMinMax,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::READONLY
+  },
+  { // navigation
+    nsGkAtoms::navigation,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // none
+    nsGkAtoms::none,
+    roles::NOTHING,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // note
+    nsGkAtoms::note_,
+    roles::NOTE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // option
+    nsGkAtoms::option,
+    roles::OPTION,
+    kUseMapRole,
+    eNoValue,
+    eSelectAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIASelectable,
+    eARIACheckedMixed
+  },
+  { // paragraph
+    nsGkAtoms::paragraph,
+    roles::PARAGRAPH,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+  },
+  { // presentation
+    nsGkAtoms::presentation,
+    roles::NOTHING,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // progressbar
+    nsGkAtoms::progressbar,
+    roles::PROGRESSBAR,
+    kUseMapRole,
+    eHasValueMinMax,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::READONLY,
+    eIndeterminateIfNoValue
+  },
+  { // radio
+    nsGkAtoms::radio,
+    roles::RADIOBUTTON,
+    kUseMapRole,
+    eNoValue,
+    eSelectAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIACheckableBool
+  },
+  { // radiogroup
+    nsGkAtoms::radiogroup,
+    roles::RADIO_GROUP,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIAOrientation,
+    eARIAReadonly
+  },
+  { // region
+    nsGkAtoms::region,
+    roles::REGION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // row
+    nsGkAtoms::row,
+    roles::ROW,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eTableRow,
+    kNoReqStates,
+    eARIASelectable
+  },
+  { // rowgroup
+    nsGkAtoms::rowgroup,
+    roles::GROUPING,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // rowheader
+    nsGkAtoms::rowheader,
+    roles::ROWHEADER,
+    kUseMapRole,
+    eNoValue,
+    eSortAction,
+    eNoLiveAttr,
+    eTableCell,
+    kNoReqStates,
+    eARIASelectableIfDefined,
+    eARIAReadonly
+  },
+  { // scrollbar
+    nsGkAtoms::scrollbar,
+    roles::SCROLLBAR,
+    kUseMapRole,
+    eHasValueMinMax,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::VERTICAL,
+    eARIAOrientation,
+    eARIAReadonly
+  },
+  { // search
+    nsGkAtoms::search,
+    roles::LANDMARK,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eLandmark,
+    kNoReqStates
+  },
+  { // searchbox
+    nsGkAtoms::searchbox,
+    roles::ENTRY,
+    kUseMapRole,
+    eNoValue,
+    eActivateAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIAAutoComplete,
+    eARIAMultiline,
+    eARIAReadonlyOrEditable
+  },
+  { // separator
+    nsGkAtoms::separator_,
+    roles::SEPARATOR,
+    kUseMapRole,
+    eHasValueMinMaxIfFocusable,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::HORIZONTAL,
+    eARIAOrientation
+  },
+  { // slider
+    nsGkAtoms::slider,
+    roles::SLIDER,
+    kUseMapRole,
+    eHasValueMinMax,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::HORIZONTAL,
+    eARIAOrientation,
+    eARIAReadonly
+  },
+  { // spinbutton
+    nsGkAtoms::spinbutton,
+    roles::SPINBUTTON,
+    kUseMapRole,
+    eHasValueMinMax,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIAReadonly
+  },
+  { // status
+    nsGkAtoms::status,
+    roles::STATUSBAR,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    ePoliteLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // strong
+    nsGkAtoms::strong,
+    roles::STRONG,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // subscript
+    nsGkAtoms::subscript,
+    roles::SUBSCRIPT,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType
+  },
+  { // suggestion
+    nsGkAtoms::suggestion,
+    roles::SUGGESTION,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+  },
+  { // superscript
+    nsGkAtoms::superscript,
+    roles::SUPERSCRIPT,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType
+  },
+  { // switch
+    nsGkAtoms::svgSwitch,
+    roles::SWITCH,
+    kUseMapRole,
+    eNoValue,
+    eCheckUncheckAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIACheckableBool,
+    eARIAReadonly
+  },
+  { // tab
+    nsGkAtoms::tab,
+    roles::PAGETAB,
+    kUseMapRole,
+    eNoValue,
+    eSwitchAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIASelectable
+  },
+  { // table
+    nsGkAtoms::table,
+    roles::TABLE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eTable,
+    kNoReqStates,
+    eARIASelectable
+  },
+  { // tablist
+    nsGkAtoms::tablist,
+    roles::PAGETABLIST,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eSelect,
+    states::HORIZONTAL,
+    eARIAOrientation,
+    eARIAMultiSelectable
+  },
+  { // tabpanel
+    nsGkAtoms::tabpanel,
+    roles::PROPERTYPAGE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // term
+    nsGkAtoms::term,
+    roles::TERM,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::READONLY
+  },
+  { // textbox
+    nsGkAtoms::textbox,
+    roles::ENTRY,
+    kUseMapRole,
+    eNoValue,
+    eActivateAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIAAutoComplete,
+    eARIAMultiline,
+    eARIAReadonlyOrEditable
+  },
+  { // time
+    nsGkAtoms::time,
+    roles::TIME,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kNoReqStates
+  },
+  { // timer
+    nsGkAtoms::timer,
+    roles::NOTHING,
+    kUseNativeRole,
+    eNoValue,
+    eNoAction,
+    eOffLiveAttr,
+    kNoReqStates
+  },
+  { // toolbar
+    nsGkAtoms::toolbar,
+    roles::TOOLBAR,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    states::HORIZONTAL,
+    eARIAOrientation
+  },
+  { // tooltip
+    nsGkAtoms::tooltip,
+    roles::TOOLTIP,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates
+  },
+  { // tree
+    nsGkAtoms::tree,
+    roles::OUTLINE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eSelect,
+    states::VERTICAL,
+    eARIAReadonly,
+    eARIAMultiSelectable,
+    eFocusableUntilDisabled,
+    eARIAOrientation
+  },
+  { // treegrid
+    nsGkAtoms::treegrid,
+    roles::TREE_TABLE,
+    kUseMapRole,
+    eNoValue,
+    eNoAction,
+    eNoLiveAttr,
+    eSelect | eTable,
+    kNoReqStates,
+    eARIAReadonly,
+    eARIAMultiSelectable,
+    eFocusableUntilDisabled,
+    eARIAOrientation
+  },
+  { // treeitem
+    nsGkAtoms::treeitem,
+    roles::OUTLINEITEM,
+    kUseMapRole,
+    eNoValue,
+    eActivateAction, // XXX: should expose second 'expand/collapse' action based
+                     // on states
+    eNoLiveAttr,
+    kGenericAccType,
+    kNoReqStates,
+    eARIASelectable,
+    eARIACheckedMixed
+  }
+    // clang-format on
+};
+
+static const nsRoleMapEntry sLandmarkRoleMap = {
+    nsGkAtoms::_empty, roles::NOTHING, kUseNativeRole,  eNoValue,
+    eNoAction,         eNoLiveAttr,    kGenericAccType, kNoReqStates};
+
+nsRoleMapEntry aria::gEmptyRoleMap = {
+    nsGkAtoms::_empty, roles::TEXT_CONTAINER, kUseMapRole,     eNoValue,
+    eNoAction,         eNoLiveAttr,           kGenericAccType, kNoReqStates};
+
+/**
+ * Universal (Global) states:
+ * The following state rules are applied to any accessible element,
+ * whether there is an ARIA role or not:
+ */
+static const EStateRule sWAIUnivStateMap[] = {
+    eARIABusy,     eARIACurrent, eARIADisabled,
+    eARIAExpanded,  // Currently under spec review but precedent exists
+    eARIAHasPopup,  // Note this is a tokenised attribute starting in ARIA 1.1
+    eARIAInvalid,  eARIAModal,
+    eARIARequired,  // XXX not global, Bug 553117
+    eARIANone};
+
+/**
+ * ARIA attribute map for attribute characteristics.
+ * @note ARIA attributes that don't have any flags are not included here.
+ */
+
+struct AttrCharacteristics {
+  const nsStaticAtom* const attributeName;
+  const uint8_t characteristics;
+};
+
+static const AttrCharacteristics gWAIUnivAttrMap[] = {
+    // clang-format off
+  {nsGkAtoms::aria_activedescendant,  ATTR_BYPASSOBJ                               },
+  {nsGkAtoms::aria_atomic,   ATTR_BYPASSOBJ_IF_FALSE | ATTR_VALTOKEN | ATTR_GLOBAL },
+  {nsGkAtoms::aria_busy,                               ATTR_VALTOKEN | ATTR_GLOBAL },
+  {nsGkAtoms::aria_checked,           ATTR_BYPASSOBJ | ATTR_VALTOKEN               }, /* exposes checkable obj attr */
+  {nsGkAtoms::aria_colcount,          ATTR_VALINT                                  },
+  {nsGkAtoms::aria_colindex,          ATTR_VALINT                                  },
+  {nsGkAtoms::aria_controls,          ATTR_BYPASSOBJ                 | ATTR_GLOBAL },
+  {nsGkAtoms::aria_current,  ATTR_BYPASSOBJ_IF_FALSE | ATTR_VALTOKEN | ATTR_GLOBAL },
+  {nsGkAtoms::aria_describedby,       ATTR_BYPASSOBJ                 | ATTR_GLOBAL },
+  // XXX Ideally, aria-description shouldn't expose a description object
+  // attribute (i.e. it should have ATTR_BYPASSOBJ). However, until the
+  // description-from attribute is implemented (bug 1726087), clients such as
+  // NVDA depend on the description object attribute to work out whether the
+  // accDescription originated from aria-description.
+  {nsGkAtoms::aria_description,                                        ATTR_GLOBAL },
+  {nsGkAtoms::aria_details,           ATTR_BYPASSOBJ                 | ATTR_GLOBAL },
+  {nsGkAtoms::aria_disabled,          ATTR_BYPASSOBJ | ATTR_VALTOKEN | ATTR_GLOBAL },
+  {nsGkAtoms::aria_dropeffect,                         ATTR_VALTOKEN | ATTR_GLOBAL },
+  {nsGkAtoms::aria_errormessage,      ATTR_BYPASSOBJ                 | ATTR_GLOBAL },
+  {nsGkAtoms::aria_expanded,          ATTR_BYPASSOBJ | ATTR_VALTOKEN               },
+  {nsGkAtoms::aria_flowto,            ATTR_BYPASSOBJ                 | ATTR_GLOBAL },
+  {nsGkAtoms::aria_grabbed,                            ATTR_VALTOKEN | ATTR_GLOBAL },
+  {nsGkAtoms::aria_haspopup,          ATTR_BYPASSOBJ_IF_FALSE | ATTR_VALTOKEN | ATTR_GLOBAL },
+  {nsGkAtoms::aria_hidden,            ATTR_BYPASSOBJ | ATTR_VALTOKEN | ATTR_GLOBAL }, /* handled special way */
+  {nsGkAtoms::aria_invalid,           ATTR_BYPASSOBJ | ATTR_VALTOKEN | ATTR_GLOBAL },
+  {nsGkAtoms::aria_label,             ATTR_BYPASSOBJ                 | ATTR_GLOBAL },
+  {nsGkAtoms::aria_labelledby,        ATTR_BYPASSOBJ                 | ATTR_GLOBAL },
+  {nsGkAtoms::aria_level,             ATTR_BYPASSOBJ                               }, /* handled via groupPosition */
+  {nsGkAtoms::aria_live,                               ATTR_VALTOKEN | ATTR_GLOBAL },
+  {nsGkAtoms::aria_modal,             ATTR_BYPASSOBJ | ATTR_VALTOKEN | ATTR_GLOBAL },
+  {nsGkAtoms::aria_multiline,         ATTR_BYPASSOBJ | ATTR_VALTOKEN               },
+  {nsGkAtoms::aria_multiselectable,   ATTR_BYPASSOBJ | ATTR_VALTOKEN               },
+  {nsGkAtoms::aria_owns,              ATTR_BYPASSOBJ                 | ATTR_GLOBAL },
+  {nsGkAtoms::aria_orientation,                        ATTR_VALTOKEN               },
+  {nsGkAtoms::aria_posinset,          ATTR_BYPASSOBJ                               }, /* handled via groupPosition */
+  {nsGkAtoms::aria_pressed,           ATTR_BYPASSOBJ | ATTR_VALTOKEN               },
+  {nsGkAtoms::aria_readonly,          ATTR_BYPASSOBJ | ATTR_VALTOKEN               },
+  {nsGkAtoms::aria_relevant,          ATTR_GLOBAL                                  },
+  {nsGkAtoms::aria_required,          ATTR_BYPASSOBJ | ATTR_VALTOKEN               },
+  {nsGkAtoms::aria_rowcount,          ATTR_VALINT                                  },
+  {nsGkAtoms::aria_rowindex,          ATTR_VALINT                                  },
+  {nsGkAtoms::aria_selected,          ATTR_BYPASSOBJ | ATTR_VALTOKEN               },
+  {nsGkAtoms::aria_setsize,           ATTR_BYPASSOBJ                               }, /* handled via groupPosition */
+  {nsGkAtoms::aria_sort,                               ATTR_VALTOKEN               },
+  {nsGkAtoms::aria_valuenow,          ATTR_BYPASSOBJ                               },
+  {nsGkAtoms::aria_valuemin,          ATTR_BYPASSOBJ                               },
+  {nsGkAtoms::aria_valuemax,          ATTR_BYPASSOBJ                               },
+  {nsGkAtoms::aria_valuetext,         ATTR_BYPASSOBJ                               }
+    // clang-format on
+};
+
+const nsRoleMapEntry* aria::GetRoleMap(dom::Element* aEl) {
+  return GetRoleMapFromIndex(GetRoleMapIndex(aEl));
+}
+
+uint8_t aria::GetRoleMapIndex(dom::Element* aEl) {
+  nsAutoString roles;
+  if (!aEl || !nsAccUtils::GetARIAAttr(aEl, nsGkAtoms::role, roles) ||
+      roles.IsEmpty()) {
+    // We treat role="" as if the role attribute is absent (per aria spec:8.1.1)
+    return NO_ROLE_MAP_ENTRY_INDEX;
+  }
+
+  nsWhitespaceTokenizer tokenizer(roles);
+  while (tokenizer.hasMoreTokens()) {
+    // Do a binary search through table for the next role in role list
+    const nsDependentSubstring role = tokenizer.nextToken();
+    size_t idx;
+    auto comparator = [&role](const nsRoleMapEntry& aEntry) {
+      return Compare(role, aEntry.ARIARoleString(),
+                     nsCaseInsensitiveStringComparator);
+    };
+    if (BinarySearchIf(sWAIRoleMaps, 0, ArrayLength(sWAIRoleMaps), comparator,
+                       &idx)) {
+      return idx;
+    }
+  }
+
+  // Always use some entry index if there is a non-empty role string
+  // To ensure an accessible object is created
+  return LANDMARK_ROLE_MAP_ENTRY_INDEX;
+}
+
+const nsRoleMapEntry* aria::GetRoleMapFromIndex(uint8_t aRoleMapIndex) {
+  switch (aRoleMapIndex) {
+    case NO_ROLE_MAP_ENTRY_INDEX:
+      return nullptr;
+    case EMPTY_ROLE_MAP_ENTRY_INDEX:
+      return &gEmptyRoleMap;
+    case LANDMARK_ROLE_MAP_ENTRY_INDEX:
+      return &sLandmarkRoleMap;
+    default:
+      return sWAIRoleMaps + aRoleMapIndex;
+  }
+}
+
+uint8_t aria::GetIndexFromRoleMap(const nsRoleMapEntry* aRoleMapEntry) {
+  if (aRoleMapEntry == nullptr) {
+    return NO_ROLE_MAP_ENTRY_INDEX;
+  } else if (aRoleMapEntry == &gEmptyRoleMap) {
+    return EMPTY_ROLE_MAP_ENTRY_INDEX;
+  } else if (aRoleMapEntry == &sLandmarkRoleMap) {
+    return LANDMARK_ROLE_MAP_ENTRY_INDEX;
+  } else {
+    uint8_t index = aRoleMapEntry - sWAIRoleMaps;
+    MOZ_ASSERT(aria::IsRoleMapIndexValid(index));
+    return index;
+  }
+}
+
+bool aria::IsRoleMapIndexValid(uint8_t aRoleMapIndex) {
+  switch (aRoleMapIndex) {
+    case NO_ROLE_MAP_ENTRY_INDEX:
+    case EMPTY_ROLE_MAP_ENTRY_INDEX:
+    case LANDMARK_ROLE_MAP_ENTRY_INDEX:
+      return true;
+  }
+  return aRoleMapIndex < ArrayLength(sWAIRoleMaps);
+}
+
+uint64_t aria::UniversalStatesFor(mozilla::dom::Element* aElement) {
+  uint64_t state = 0;
+  uint32_t index = 0;
+  while (MapToState(sWAIUnivStateMap[index], aElement, &state)) index++;
+
+  return state;
+}
+
+uint8_t aria::AttrCharacteristicsFor(nsAtom* aAtom) {
+  for (uint32_t i = 0; i < ArrayLength(gWAIUnivAttrMap); i++) {
+    if (gWAIUnivAttrMap[i].attributeName == aAtom) {
+      return gWAIUnivAttrMap[i].characteristics;
+    }
+  }
+
+  return 0;
+}
+
+bool aria::HasDefinedARIAHidden(nsIContent* aContent) {
+  return aContent && aContent->IsElement() &&
+         nsAccUtils::ARIAAttrValueIs(aContent->AsElement(),
+                                     nsGkAtoms::aria_hidden, nsGkAtoms::_true,
+                                     eCaseMatters);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// AttrIterator class
+
+AttrIterator::AttrIterator(nsIContent* aContent)
+    : mElement(dom::Element::FromNode(aContent)),
+      mIteratingDefaults(false),
+      mAttrIdx(0),
+      mAttrCharacteristics(0) {
+  mAttrs = mElement ? &mElement->GetAttrs() : nullptr;
+  mAttrCount = mAttrs ? mAttrs->AttrCount() : 0;
+}
+
+bool AttrIterator::Next() {
+  while (mAttrIdx < mAttrCount) {
+    const nsAttrName* attr = mAttrs->GetSafeAttrNameAt(mAttrIdx);
+    mAttrIdx++;
+    if (attr->NamespaceEquals(kNameSpaceID_None)) {
+      mAttrAtom = attr->Atom();
+      nsDependentAtomString attrStr(mAttrAtom);
+      if (!StringBeginsWith(attrStr, u"aria-"_ns)) continue;  // Not ARIA
+
+      if (mIteratingDefaults) {
+        if (mOverriddenAttrs.Contains(mAttrAtom)) {
+          continue;
+        }
+      } else {
+        mOverriddenAttrs.Insert(mAttrAtom);
+      }
+
+      // AttrCharacteristicsFor has to search for the entry, so cache it here
+      // rather than having to search again later.
+      mAttrCharacteristics = aria::AttrCharacteristicsFor(mAttrAtom);
+      if (mAttrCharacteristics & ATTR_BYPASSOBJ) {
+        continue;  // No need to handle exposing as obj attribute here
+      }
+
+      if ((mAttrCharacteristics & ATTR_VALTOKEN) &&
+          !nsAccUtils::HasDefinedARIAToken(mAttrs, mAttrAtom)) {
+        continue;  // only expose token based attributes if they are defined
+      }
+
+      if ((mAttrCharacteristics & ATTR_BYPASSOBJ_IF_FALSE) &&
+          mAttrs->AttrValueIs(kNameSpaceID_None, mAttrAtom, nsGkAtoms::_false,
+                              eCaseMatters)) {
+        continue;  // only expose token based attribute if value is not 'false'.
+      }
+
+      return true;
+    }
+  }
+
+  mAttrCharacteristics = 0;
+  mAttrAtom = nullptr;
+
+  if (const auto* defaults = nsAccUtils::GetARIADefaults(mElement);
+      !mIteratingDefaults && defaults) {
+    mIteratingDefaults = true;
+    mAttrs = defaults;
+    mAttrCount = mAttrs->AttrCount();
+    mAttrIdx = 0;
+    return Next();
+  }
+
+  return false;
+}
+
+nsAtom* AttrIterator::AttrName() const { return mAttrAtom; }
+
+void AttrIterator::AttrValue(nsAString& aAttrValue) const {
+  nsAutoString value;
+  if (mAttrs->GetAttr(mAttrAtom, value)) {
+    if (mAttrCharacteristics & ATTR_VALTOKEN) {
+      nsAtom* normalizedValue =
+          nsAccUtils::NormalizeARIAToken(mAttrs, mAttrAtom);
+      if (normalizedValue) {
+        nsDependentAtomString normalizedValueStr(normalizedValue);
+        aAttrValue.Assign(normalizedValueStr);
+        return;
+      }
+    }
+    aAttrValue.Assign(value);
+  }
+}
+
+bool AttrIterator::ExposeAttr(AccAttributes* aTargetAttrs) const {
+  if (mAttrCharacteristics & ATTR_VALTOKEN) {
+    nsAtom* normalizedValue = nsAccUtils::NormalizeARIAToken(mAttrs, mAttrAtom);
+    if (normalizedValue) {
+      aTargetAttrs->SetAttribute(mAttrAtom, normalizedValue);
+      return true;
+    }
+  } else if (mAttrCharacteristics & ATTR_VALINT) {
+    int32_t intVal;
+    if (nsCoreUtils::GetUIntAttrValue(mAttrs->GetAttr(mAttrAtom), &intVal)) {
+      aTargetAttrs->SetAttribute(mAttrAtom, intVal);
+      return true;
+    }
+    if (mAttrAtom == nsGkAtoms::aria_colcount ||
+        mAttrAtom == nsGkAtoms::aria_rowcount) {
+      // These attributes allow a value of -1.
+      if (mAttrs->AttrValueIs(kNameSpaceID_None, mAttrAtom, u"-1"_ns,
+                              eCaseMatters)) {
+        aTargetAttrs->SetAttribute(mAttrAtom, -1);
+        return true;
+      }
+    }
+    return false;  // Invalid value.
+  }
+  nsAutoString value;
+  if (mAttrs->GetAttr(mAttrAtom, value)) {
+    aTargetAttrs->SetAttribute(mAttrAtom, std::move(value));
+    return true;
+  }
+  return false;
+}
diff --git a/accessible/base/ARIAMap.h b/accessible/base/ARIAMap.h
new file mode 100644
index 0000000000..30cc1f0814
--- /dev/null
+++ b/accessible/base/ARIAMap.h
@@ -0,0 +1,335 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=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_aria_ARIAMap_h_
+#define mozilla_a11y_aria_ARIAMap_h_
+
+#include "ARIAStateMap.h"
+#include "mozilla/a11y/AccTypes.h"
+#include "mozilla/a11y/Role.h"
+
+#include "nsAtom.h"
+#include "nsIContent.h"
+#include "nsTHashSet.h"
+
+class nsINode;
+
+namespace mozilla::dom {
+class Element;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Value constants
+
+/**
+ * Used to define if role requires to expose Value interface.
+ */
+enum EValueRule {
+  /**
+   * Value interface isn't exposed.
+   */
+  eNoValue,
+
+  /**
+   * Value interface is implemented, supports value, min and max from
+   * aria-valuenow, aria-valuemin and aria-valuemax.
+   */
+  eHasValueMinMax,
+
+  /**
+   * Value interface is implemented, but only if the element is focusable.
+   * For instance, in ARIA 1.1 the ability for authors to create adjustable
+   * splitters was provided by supporting the value interface on separators
+   * that are focusable. Non-focusable separators expose no value information.
+   */
+  eHasValueMinMaxIfFocusable
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Action constants
+
+/**
+ * Used to define if the role requires to expose action.
+ */
+enum EActionRule {
+  eNoAction,
+  eActivateAction,
+  eClickAction,
+  ePressAction,
+  eCheckUncheckAction,
+  eExpandAction,
+  eJumpAction,
+  eOpenCloseAction,
+  eSelectAction,
+  eSortAction,
+  eSwitchAction
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Live region constants
+
+/**
+ * Used to define if role exposes default value of aria-live attribute.
+ */
+enum ELiveAttrRule {
+  eNoLiveAttr,
+  eOffLiveAttr,
+  ePoliteLiveAttr,
+  eAssertiveLiveAttr
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Role constants
+
+/**
+ * ARIA role overrides role from native markup.
+ */
+const bool kUseMapRole = true;
+
+/**
+ * ARIA role doesn't override the role from native markup.
+ */
+const bool kUseNativeRole = false;
+
+////////////////////////////////////////////////////////////////////////////////
+// ARIA attribute characteristic masks
+
+/**
+ * This mask indicates the attribute should not be exposed as an object
+ * attribute via the catch-all logic in Accessible::Attributes().
+ * This means it either isn't mean't to be exposed as an object attribute, or
+ * that it should, but is already handled in other code.
+ */
+const uint8_t ATTR_BYPASSOBJ = 0x1 << 0;
+const uint8_t ATTR_BYPASSOBJ_IF_FALSE = 0x1 << 1;
+
+/**
+ * This mask indicates the attribute is expected to have an NMTOKEN or bool
+ * value. (See for example usage in Accessible::Attributes())
+ */
+const uint8_t ATTR_VALTOKEN = 0x1 << 2;
+
+/**
+ * Indicate the attribute is global state or property (refer to
+ * http://www.w3.org/TR/wai-aria/states_and_properties#global_states).
+ */
+const uint8_t ATTR_GLOBAL = 0x1 << 3;
+
+/**
+ * Indicates that the attribute should have an integer value.
+ */
+const uint8_t ATTR_VALINT = 0x1 << 4;
+
+////////////////////////////////////////////////////////////////////////////////
+// State map entry
+
+/**
+ * Used in nsRoleMapEntry.state if no nsIAccessibleStates are automatic for
+ * a given role.
+ */
+#define kNoReqStates 0
+
+////////////////////////////////////////////////////////////////////////////////
+// Role map entry
+
+/**
+ * For each ARIA role, this maps the nsIAccessible information.
+ */
+struct nsRoleMapEntry {
+  /**
+   * Return true if matches to the given ARIA role.
+   */
+  bool Is(nsAtom* aARIARole) const { return roleAtom == aARIARole; }
+
+  /**
+   * Return true if ARIA role has the given accessible type.
+   */
+  bool IsOfType(mozilla::a11y::AccGenericType aType) const {
+    return accTypes & aType;
+  }
+
+  /**
+   * Return ARIA role.
+   */
+  const nsDependentAtomString ARIARoleString() const {
+    return nsDependentAtomString(roleAtom);
+  }
+
+  // ARIA role: string representation such as "button"
+  nsStaticAtom* const roleAtom;
+
+  // Role mapping rule: maps to enum Role
+  mozilla::a11y::role role;
+
+  // Role rule: whether to use mapped role or native semantics
+  bool roleRule;
+
+  // Value mapping rule: how to compute accessible value
+  EValueRule valueRule;
+
+  // Action mapping rule, how to expose accessible action
+  EActionRule actionRule;
+
+  // 'live' and 'container-live' object attributes mapping rule: how to expose
+  // these object attributes if ARIA 'live' attribute is missed.
+  ELiveAttrRule liveAttRule;
+
+  // LocalAccessible types this role belongs to.
+  uint32_t accTypes;
+
+  // Automatic state mapping rule: always include in states
+  uint64_t state;  // or kNoReqStates if no default state for this role
+
+  // ARIA properties supported for this role (in other words, the aria-foo
+  // attribute to accessible states mapping rules).
+  // Currently you cannot have unlimited mappings, because
+  // a variable sized array would not allow the use of
+  // C++'s struct initialization feature.
+  mozilla::a11y::aria::EStateRule attributeMap1;
+  mozilla::a11y::aria::EStateRule attributeMap2;
+  mozilla::a11y::aria::EStateRule attributeMap3;
+  mozilla::a11y::aria::EStateRule attributeMap4;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// ARIA map
+
+/**
+ *  These provide the mappings for WAI-ARIA roles, states and properties using
+ *  the structs defined in this file and ARIAStateMap files.
+ */
+namespace mozilla {
+namespace a11y {
+class AccAttributes;
+
+namespace aria {
+
+/**
+ * Empty role map entry. Used by accessibility service to create an accessible
+ * if the accessible can't use role of used accessible class. For example,
+ * it is used for table cells that aren't contained by table.
+ */
+extern nsRoleMapEntry gEmptyRoleMap;
+
+/**
+ * Constants for the role map entry index to indicate that the role map entry
+ * isn't in sWAIRoleMaps, but rather is a special entry: nullptr,
+ * gEmptyRoleMap, and sLandmarkRoleMap
+ */
+const uint8_t NO_ROLE_MAP_ENTRY_INDEX = UINT8_MAX - 2;
+const uint8_t EMPTY_ROLE_MAP_ENTRY_INDEX = UINT8_MAX - 1;
+const uint8_t LANDMARK_ROLE_MAP_ENTRY_INDEX = UINT8_MAX;
+
+/**
+ * Get the role map entry for a given DOM node. This will use the first
+ * ARIA role if the role attribute provides a space delimited list of roles.
+ *
+ * @param aEl     [in] the DOM node to get the role map entry for
+ * @return        a pointer to the role map entry for the ARIA role, or nullptr
+ *                if none
+ */
+const nsRoleMapEntry* GetRoleMap(dom::Element* aEl);
+
+/**
+ * Get the role map entry pointer's index for a given DOM node. This will use
+ * the first ARIA role if the role attribute provides a space delimited list of
+ * roles.
+ *
+ * @param aEl     [in] the DOM node to get the role map entry for
+ * @return        the index of the pointer to the role map entry for the ARIA
+ *                role, or NO_ROLE_MAP_ENTRY_INDEX if none
+ */
+uint8_t GetRoleMapIndex(dom::Element* aEl);
+
+/**
+ * Get the role map entry pointer for a given role map entry index.
+ *
+ * @param aRoleMapIndex  [in] the role map index to get the role map entry
+ *                       pointer for
+ * @return               a pointer to the role map entry for the ARIA role,
+ *                       or nullptr, if none
+ */
+const nsRoleMapEntry* GetRoleMapFromIndex(uint8_t aRoleMapIndex);
+
+/**
+ * Get the role map entry index for a given role map entry pointer. If the role
+ * map entry is within sWAIRoleMaps, return the index within that array,
+ * otherwise return one of the special index constants listed above.
+ *
+ * @param aRoleMap  [in] the role map entry pointer to get the index for
+ * @return          the index of the pointer to the role map entry, or
+ *                  NO_ROLE_MAP_ENTRY_INDEX if none
+ */
+uint8_t GetIndexFromRoleMap(const nsRoleMapEntry* aRoleMap);
+
+/**
+ * Determine whether a role map entry index is valid.
+ */
+bool IsRoleMapIndexValid(uint8_t aRoleMapIndex);
+
+/**
+ * Return accessible state from ARIA universal states applied to the given
+ * element.
+ */
+uint64_t UniversalStatesFor(dom::Element* aElement);
+
+/**
+ * Get the ARIA attribute characteristics for a given ARIA attribute.
+ *
+ * @param aAtom  ARIA attribute
+ * @return       A bitflag representing the attribute characteristics
+ *               (see above for possible bit masks, prefixed "ATTR_")
+ */
+uint8_t AttrCharacteristicsFor(nsAtom* aAtom);
+
+/**
+ * Return true if the element has defined aria-hidden.
+ */
+bool HasDefinedARIAHidden(nsIContent* aContent);
+
+/**
+ * Represents a simple enumerator for iterating through ARIA attributes
+ * exposed as object attributes on a given accessible.
+ */
+class AttrIterator {
+ public:
+  explicit AttrIterator(nsIContent* aContent);
+
+  bool Next();
+
+  nsAtom* AttrName() const;
+
+  void AttrValue(nsAString& aAttrValue) const;
+
+  /**
+   * Expose this ARIA attribute in a specified AccAttributes. The appropriate
+   * type will be used for the attribute; e.g. an atom for a token value.
+   */
+  bool ExposeAttr(AccAttributes* aTargetAttrs) const;
+
+ private:
+  AttrIterator() = delete;
+  AttrIterator(const AttrIterator&) = delete;
+  AttrIterator& operator=(const AttrIterator&) = delete;
+
+  dom::Element* mElement;
+
+  bool mIteratingDefaults;
+  nsTHashSet<RefPtr<nsAtom>> mOverriddenAttrs;
+
+  const AttrArray* mAttrs;
+  uint32_t mAttrIdx;
+  uint32_t mAttrCount;
+  RefPtr<nsAtom> mAttrAtom;
+  uint8_t mAttrCharacteristics;
+};
+
+}  // namespace aria
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/ARIAStateMap.cpp b/accessible/base/ARIAStateMap.cpp
new file mode 100644
index 0000000000..6bf20cf1cc
--- /dev/null
+++ b/accessible/base/ARIAStateMap.cpp
@@ -0,0 +1,334 @@
+/* -*- 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 "ARIAMap.h"
+#include "nsAccUtils.h"
+#include "States.h"
+
+#include "mozilla/dom/Element.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+using namespace mozilla::a11y::aria;
+
+/**
+ * Used to store state map rule data for ARIA attribute of enum type.
+ */
+struct EnumTypeData {
+  // ARIA attribute name.
+  nsStaticAtom* const mAttrName;
+
+  // States if the attribute value is matched to the enum value. Used as
+  // Element::AttrValuesArray, last item must be nullptr.
+  nsStaticAtom* const mValues[4];
+
+  // States applied if corresponding enum values are matched.
+  const uint64_t mStates[3];
+
+  // States to clear in case of match.
+  const uint64_t mClearState;
+};
+
+enum ETokenType {
+  eBoolType = 0,
+  eMixedType = 1,       // can take 'mixed' value
+  eDefinedIfAbsent = 2  // permanent and false state are applied if absent
+};
+
+/**
+ * Used to store state map rule data for ARIA attribute of token type (including
+ * mixed value).
+ */
+struct TokenTypeData {
+  TokenTypeData(nsAtom* aAttrName, uint32_t aType, uint64_t aPermanentState,
+                uint64_t aTrueState, uint64_t aFalseState = 0)
+      : mAttrName(aAttrName),
+        mType(aType),
+        mPermanentState(aPermanentState),
+        mTrueState(aTrueState),
+        mFalseState(aFalseState) {}
+
+  // ARIA attribute name.
+  nsAtom* const mAttrName;
+
+  // Type.
+  const uint32_t mType;
+
+  // State applied if the attribute is defined or mType doesn't have
+  // eDefinedIfAbsent flag set.
+  const uint64_t mPermanentState;
+
+  // States applied if the attribute value is true/false.
+  const uint64_t mTrueState;
+  const uint64_t mFalseState;
+};
+
+/**
+ * Map enum type attribute value to accessible state.
+ */
+static void MapEnumType(dom::Element* aElement, uint64_t* aState,
+                        const EnumTypeData& aData);
+
+/**
+ * Map token type attribute value to states.
+ */
+static void MapTokenType(dom::Element* aContent, uint64_t* aState,
+                         const TokenTypeData& aData);
+
+bool aria::MapToState(EStateRule aRule, dom::Element* aElement,
+                      uint64_t* aState) {
+  switch (aRule) {
+    case eARIAAutoComplete: {
+      static const EnumTypeData data = {
+          nsGkAtoms::aria_autocomplete,
+          {nsGkAtoms::inlinevalue, nsGkAtoms::list_, nsGkAtoms::both, nullptr},
+          {states::SUPPORTS_AUTOCOMPLETION,
+           states::HASPOPUP | states::SUPPORTS_AUTOCOMPLETION,
+           states::HASPOPUP | states::SUPPORTS_AUTOCOMPLETION},
+          0};
+
+      MapEnumType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIABusy: {
+      static const EnumTypeData data = {
+          nsGkAtoms::aria_busy,
+          {nsGkAtoms::_true, nsGkAtoms::error, nullptr},
+          {states::BUSY, states::INVALID},
+          0};
+
+      MapEnumType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIACheckableBool: {
+      static const TokenTypeData data(nsGkAtoms::aria_checked,
+                                      eBoolType | eDefinedIfAbsent,
+                                      states::CHECKABLE, states::CHECKED);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIACheckableMixed: {
+      static const TokenTypeData data(nsGkAtoms::aria_checked,
+                                      eMixedType | eDefinedIfAbsent,
+                                      states::CHECKABLE, states::CHECKED);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIACheckedMixed: {
+      static const TokenTypeData data(nsGkAtoms::aria_checked, eMixedType,
+                                      states::CHECKABLE, states::CHECKED);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIACurrent: {
+      static const TokenTypeData data(nsGkAtoms::aria_current, eBoolType, 0,
+                                      states::CURRENT);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIADisabled: {
+      static const TokenTypeData data(nsGkAtoms::aria_disabled, eBoolType, 0,
+                                      states::UNAVAILABLE);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIAExpanded: {
+      static const TokenTypeData data(nsGkAtoms::aria_expanded, eBoolType, 0,
+                                      states::EXPANDED, states::COLLAPSED);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIAHasPopup: {
+      static const TokenTypeData data(nsGkAtoms::aria_haspopup, eBoolType, 0,
+                                      states::HASPOPUP);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIAInvalid: {
+      static const TokenTypeData data(nsGkAtoms::aria_invalid, eBoolType, 0,
+                                      states::INVALID);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIAModal: {
+      static const TokenTypeData data(nsGkAtoms::aria_modal, eBoolType, 0,
+                                      states::MODAL);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIAMultiline: {
+      static const TokenTypeData data(nsGkAtoms::aria_multiline,
+                                      eBoolType | eDefinedIfAbsent, 0,
+                                      states::MULTI_LINE, states::SINGLE_LINE);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIAMultiSelectable: {
+      static const TokenTypeData data(
+          nsGkAtoms::aria_multiselectable, eBoolType, 0,
+          states::MULTISELECTABLE | states::EXTSELECTABLE);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIAOrientation: {
+      static const EnumTypeData data = {
+          nsGkAtoms::aria_orientation,
+          {nsGkAtoms::horizontal, nsGkAtoms::vertical, nullptr},
+          {states::HORIZONTAL, states::VERTICAL},
+          states::HORIZONTAL | states::VERTICAL};
+
+      MapEnumType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIAPressed: {
+      static const TokenTypeData data(nsGkAtoms::aria_pressed, eMixedType, 0,
+                                      states::PRESSED);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIAReadonly: {
+      static const TokenTypeData data(nsGkAtoms::aria_readonly, eBoolType, 0,
+                                      states::READONLY);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIAReadonlyOrEditable: {
+      static const TokenTypeData data(nsGkAtoms::aria_readonly,
+                                      eBoolType | eDefinedIfAbsent, 0,
+                                      states::READONLY, states::EDITABLE);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIARequired: {
+      static const TokenTypeData data(nsGkAtoms::aria_required, eBoolType, 0,
+                                      states::REQUIRED);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIASelectable: {
+      static const TokenTypeData data(nsGkAtoms::aria_selected,
+                                      eBoolType | eDefinedIfAbsent,
+                                      states::SELECTABLE, states::SELECTED);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eARIASelectableIfDefined: {
+      static const TokenTypeData data(nsGkAtoms::aria_selected, eBoolType,
+                                      states::SELECTABLE, states::SELECTED);
+
+      MapTokenType(aElement, aState, data);
+      return true;
+    }
+
+    case eReadonlyUntilEditable: {
+      if (!(*aState & states::EDITABLE)) *aState |= states::READONLY;
+
+      return true;
+    }
+
+    case eIndeterminateIfNoValue: {
+      if (!nsAccUtils::HasARIAAttr(aElement, nsGkAtoms::aria_valuenow) &&
+          !nsAccUtils::HasARIAAttr(aElement, nsGkAtoms::aria_valuetext)) {
+        *aState |= states::MIXED;
+      }
+
+      return true;
+    }
+
+    case eFocusableUntilDisabled: {
+      if (!nsAccUtils::HasDefinedARIAToken(aElement,
+                                           nsGkAtoms::aria_disabled) ||
+          nsAccUtils::ARIAAttrValueIs(aElement, nsGkAtoms::aria_disabled,
+                                      nsGkAtoms::_false, eCaseMatters)) {
+        *aState |= states::FOCUSABLE;
+      }
+
+      return true;
+    }
+
+    default:
+      return false;
+  }
+}
+
+static void MapEnumType(dom::Element* aElement, uint64_t* aState,
+                        const EnumTypeData& aData) {
+  switch (nsAccUtils::FindARIAAttrValueIn(aElement, aData.mAttrName,
+                                          aData.mValues, eCaseMatters)) {
+    case 0:
+      *aState = (*aState & ~aData.mClearState) | aData.mStates[0];
+      return;
+    case 1:
+      *aState = (*aState & ~aData.mClearState) | aData.mStates[1];
+      return;
+    case 2:
+      *aState = (*aState & ~aData.mClearState) | aData.mStates[2];
+      return;
+  }
+}
+
+static void MapTokenType(dom::Element* aElement, uint64_t* aState,
+                         const TokenTypeData& aData) {
+  if (nsAccUtils::HasDefinedARIAToken(aElement, aData.mAttrName)) {
+    if (nsAccUtils::ARIAAttrValueIs(aElement, aData.mAttrName, nsGkAtoms::mixed,
+                                    eCaseMatters)) {
+      if (aData.mType & eMixedType) {
+        *aState |= aData.mPermanentState | states::MIXED;
+      } else {  // unsupported use of 'mixed' is an authoring error
+        *aState |= aData.mPermanentState | aData.mFalseState;
+      }
+      return;
+    }
+
+    if (nsAccUtils::ARIAAttrValueIs(aElement, aData.mAttrName,
+                                    nsGkAtoms::_false, eCaseMatters)) {
+      *aState |= aData.mPermanentState | aData.mFalseState;
+      return;
+    }
+
+    *aState |= aData.mPermanentState | aData.mTrueState;
+    return;
+  }
+
+  if (aData.mType & eDefinedIfAbsent) {
+    *aState |= aData.mPermanentState | aData.mFalseState;
+  }
+}
diff --git a/accessible/base/ARIAStateMap.h b/accessible/base/ARIAStateMap.h
new file mode 100644
index 0000000000..20490aa901
--- /dev/null
+++ b/accessible/base/ARIAStateMap.h
@@ -0,0 +1,66 @@
+/* -*- 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_aria_ARIAStateMap_h_
+#define _mozilla_a11y_aria_ARIAStateMap_h_
+
+#include <stdint.h>
+
+namespace mozilla {
+
+namespace dom {
+class Element;
+}
+
+namespace a11y {
+namespace aria {
+
+/**
+ * List of the ARIA state mapping rules.
+ */
+enum EStateRule {
+  eARIANone,
+  eARIAAutoComplete,
+  eARIABusy,
+  eARIACheckableBool,
+  eARIACheckableMixed,
+  eARIACheckedMixed,
+  eARIACurrent,
+  eARIADisabled,
+  eARIAExpanded,
+  eARIAHasPopup,
+  eARIAInvalid,
+  eARIAModal,
+  eARIAMultiline,
+  eARIAMultiSelectable,
+  eARIAOrientation,
+  eARIAPressed,
+  eARIAReadonly,
+  eARIAReadonlyOrEditable,
+  eARIARequired,
+  eARIASelectable,
+  eARIASelectableIfDefined,
+  eReadonlyUntilEditable,
+  eIndeterminateIfNoValue,
+  eFocusableUntilDisabled
+};
+
+/**
+ * Expose the accessible states for the given element accordingly to state
+ * mapping rule.
+ *
+ * @param  aRule     [in] state mapping rule ID
+ * @param  aElement  [in] node of the accessible
+ * @param  aState    [in/out] accessible states
+ * @return            true if state map rule ID is valid
+ */
+bool MapToState(EStateRule aRule, dom::Element* aElement, uint64_t* aState);
+
+}  // namespace aria
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/AccAttributes.cpp b/accessible/base/AccAttributes.cpp
new file mode 100644
index 0000000000..4018f09074
--- /dev/null
+++ b/accessible/base/AccAttributes.cpp
@@ -0,0 +1,270 @@
+/* -*- 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 "AccAttributes.h"
+#include "StyleInfo.h"
+#include "mozilla/ToString.h"
+#include "nsAtom.h"
+
+using namespace mozilla::a11y;
+
+bool AccAttributes::GetAttribute(nsAtom* aAttrName,
+                                 nsAString& aAttrValue) const {
+  if (auto value = mData.Lookup(aAttrName)) {
+    StringFromValueAndName(aAttrName, *value, aAttrValue);
+    return true;
+  }
+
+  return false;
+}
+
+void AccAttributes::StringFromValueAndName(nsAtom* aAttrName,
+                                           const AttrValueType& aValue,
+                                           nsAString& aValueString) {
+  aValueString.Truncate();
+
+  aValue.match(
+      [&aValueString](const bool& val) {
+        aValueString.Assign(val ? u"true" : u"false");
+      },
+      [&aValueString](const float& val) {
+        aValueString.AppendFloat(val * 100);
+        aValueString.Append(u"%");
+      },
+      [&aValueString](const double& val) { aValueString.AppendFloat(val); },
+      [&aValueString](const int32_t& val) { aValueString.AppendInt(val); },
+      [&aValueString](const RefPtr<nsAtom>& val) {
+        val->ToString(aValueString);
+      },
+      [&aValueString](const nsTArray<int32_t>& val) {
+        if (const size_t len = val.Length()) {
+          for (size_t i = 0; i < len - 1; i++) {
+            aValueString.AppendInt(val[i]);
+            aValueString.Append(u", ");
+          }
+          aValueString.AppendInt(val[len - 1]);
+        } else {
+          // The array is empty
+          NS_WARNING(
+              "Hmm, should we have used a DeleteEntry() for this instead?");
+          aValueString.Append(u"[ ]");
+        }
+      },
+      [&aValueString](const CSSCoord& val) {
+        aValueString.AppendFloat(val);
+        aValueString.Append(u"px");
+      },
+      [&aValueString](const FontSize& val) {
+        aValueString.AppendInt(val.mValue);
+        aValueString.Append(u"pt");
+      },
+      [&aValueString](const Color& val) {
+        StyleInfo::FormatColor(val.mValue, aValueString);
+      },
+      [&aValueString](const DeleteEntry& val) {
+        aValueString.Append(u"-delete-entry-");
+      },
+      [&aValueString](const UniquePtr<nsString>& val) {
+        aValueString.Assign(*val);
+      },
+      [&aValueString](const RefPtr<AccAttributes>& val) {
+        aValueString.Assign(u"AccAttributes{...}");
+      },
+      [&aValueString](const uint64_t& val) { aValueString.AppendInt(val); },
+      [&aValueString](const UniquePtr<AccGroupInfo>& val) {
+        aValueString.Assign(u"AccGroupInfo{...}");
+      },
+      [&aValueString](const UniquePtr<gfx::Matrix4x4>& val) {
+        aValueString.AppendPrintf("Matrix4x4=%s", ToString(*val).c_str());
+      },
+      [&aValueString](const nsTArray<uint64_t>& val) {
+        if (const size_t len = val.Length()) {
+          for (size_t i = 0; i < len - 1; i++) {
+            aValueString.AppendInt(val[i]);
+            aValueString.Append(u", ");
+          }
+          aValueString.AppendInt(val[len - 1]);
+        } else {
+          // The array is empty
+          NS_WARNING(
+              "Hmm, should we have used a DeleteEntry() for this instead?");
+          aValueString.Append(u"[ ]");
+        }
+      });
+}
+
+void AccAttributes::Update(AccAttributes* aOther) {
+  for (auto iter = aOther->mData.Iter(); !iter.Done(); iter.Next()) {
+    if (iter.Data().is<DeleteEntry>()) {
+      mData.Remove(iter.Key());
+    } else {
+      mData.InsertOrUpdate(iter.Key(), std::move(iter.Data()));
+    }
+    iter.Remove();
+  }
+}
+
+bool AccAttributes::Equal(const AccAttributes* aOther) const {
+  if (Count() != aOther->Count()) {
+    return false;
+  }
+  for (auto iter = mData.ConstIter(); !iter.Done(); iter.Next()) {
+    const auto otherEntry = aOther->mData.Lookup(iter.Key());
+    if (!otherEntry) {
+      return false;
+    }
+    if (iter.Data().is<UniquePtr<nsString>>()) {
+      // Because we store nsString in a UniquePtr, we must handle it specially
+      // so we compare the string and not the pointer.
+      if (!otherEntry->is<UniquePtr<nsString>>()) {
+        return false;
+      }
+      const auto& thisStr = iter.Data().as<UniquePtr<nsString>>();
+      const auto& otherStr = otherEntry->as<UniquePtr<nsString>>();
+      if (*thisStr != *otherStr) {
+        return false;
+      }
+    } else if (iter.Data() != otherEntry.Data()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void AccAttributes::CopyTo(AccAttributes* aDest) const {
+  for (auto iter = mData.ConstIter(); !iter.Done(); iter.Next()) {
+    iter.Data().match(
+        [&iter, &aDest](const bool& val) {
+          aDest->mData.InsertOrUpdate(iter.Key(), AsVariant(val));
+        },
+        [&iter, &aDest](const float& val) {
+          aDest->mData.InsertOrUpdate(iter.Key(), AsVariant(val));
+        },
+        [&iter, &aDest](const double& val) {
+          aDest->mData.InsertOrUpdate(iter.Key(), AsVariant(val));
+        },
+        [&iter, &aDest](const int32_t& val) {
+          aDest->mData.InsertOrUpdate(iter.Key(), AsVariant(val));
+        },
+        [&iter, &aDest](const RefPtr<nsAtom>& val) {
+          aDest->mData.InsertOrUpdate(iter.Key(), AsVariant(val));
+        },
+        [](const nsTArray<int32_t>& val) {
+          // We don't copy arrays.
+          MOZ_ASSERT_UNREACHABLE(
+              "Trying to copy an AccAttributes containing an array");
+        },
+        [&iter, &aDest](const CSSCoord& val) {
+          aDest->mData.InsertOrUpdate(iter.Key(), AsVariant(val));
+        },
+        [&iter, &aDest](const FontSize& val) {
+          aDest->mData.InsertOrUpdate(iter.Key(), AsVariant(val));
+        },
+        [&iter, &aDest](const Color& val) {
+          aDest->mData.InsertOrUpdate(iter.Key(), AsVariant(val));
+        },
+        [](const DeleteEntry& val) {
+          // We don't copy DeleteEntry.
+          MOZ_ASSERT_UNREACHABLE(
+              "Trying to copy an AccAttributes containing a DeleteEntry");
+        },
+        [&iter, &aDest](const UniquePtr<nsString>& val) {
+          aDest->SetAttributeStringCopy(iter.Key(), *val);
+        },
+        [](const RefPtr<AccAttributes>& val) {
+          // We don't copy nested AccAttributes.
+          MOZ_ASSERT_UNREACHABLE(
+              "Trying to copy an AccAttributes containing an AccAttributes");
+        },
+        [&iter, &aDest](const uint64_t& val) {
+          aDest->mData.InsertOrUpdate(iter.Key(), AsVariant(val));
+        },
+        [](const UniquePtr<AccGroupInfo>& val) {
+          MOZ_ASSERT_UNREACHABLE(
+              "Trying to copy an AccAttributes containing an AccGroupInfo");
+        },
+        [](const UniquePtr<gfx::Matrix4x4>& val) {
+          MOZ_ASSERT_UNREACHABLE(
+              "Trying to copy an AccAttributes containing a matrix");
+        },
+        [](const nsTArray<uint64_t>& val) {
+          // We don't copy arrays.
+          MOZ_ASSERT_UNREACHABLE(
+              "Trying to copy an AccAttributes containing an array");
+        });
+  }
+}
+
+#ifdef A11Y_LOG
+void AccAttributes::DebugPrint(const char* aPrefix,
+                               const AccAttributes& aAttributes) {
+  nsAutoString prettyString;
+  prettyString.AssignLiteral("{\n");
+  for (const auto& iter : aAttributes) {
+    nsAutoString name;
+    iter.NameAsString(name);
+
+    nsAutoString value;
+    iter.ValueAsString(value);
+    prettyString.AppendLiteral("  ");
+    prettyString.Append(name);
+    prettyString.AppendLiteral(": ");
+    prettyString.Append(value);
+    prettyString.AppendLiteral("\n");
+  }
+
+  prettyString.AppendLiteral("}");
+  printf("%s %s\n", aPrefix, NS_ConvertUTF16toUTF8(prettyString).get());
+}
+#endif
+
+size_t AccAttributes::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+  size_t size =
+      aMallocSizeOf(this) + mData.ShallowSizeOfExcludingThis(aMallocSizeOf);
+
+  for (auto iter : *this) {
+    size += iter.SizeOfExcludingThis(aMallocSizeOf);
+  }
+
+  return size;
+}
+
+size_t AccAttributes::Entry::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) {
+  size_t size = 0;
+
+  // We don't count the size of Name() since it's counted by the atoms table
+  // memory reporter.
+
+  if (mValue->is<nsTArray<int32_t>>()) {
+    size += mValue->as<nsTArray<int32_t>>().ShallowSizeOfExcludingThis(
+        aMallocSizeOf);
+  } else if (mValue->is<UniquePtr<nsString>>()) {
+    // String data will never be shared.
+    size += mValue->as<UniquePtr<nsString>>()->SizeOfIncludingThisIfUnshared(
+        aMallocSizeOf);
+  } else if (mValue->is<RefPtr<AccAttributes>>()) {
+    size +=
+        mValue->as<RefPtr<AccAttributes>>()->SizeOfIncludingThis(aMallocSizeOf);
+  } else if (mValue->is<UniquePtr<AccGroupInfo>>()) {
+    size += mValue->as<UniquePtr<AccGroupInfo>>()->SizeOfIncludingThis(
+        aMallocSizeOf);
+  } else if (mValue->is<UniquePtr<gfx::Matrix4x4>>()) {
+    size += aMallocSizeOf(mValue->as<UniquePtr<gfx::Matrix4x4>>().get());
+  } else if (mValue->is<nsTArray<uint64_t>>()) {
+    size += mValue->as<nsTArray<uint64_t>>().ShallowSizeOfExcludingThis(
+        aMallocSizeOf);
+  } else {
+    // This type is stored directly and already counted or is an atom and
+    // stored and counted in the atoms table.
+    // Assert that we have exhausted all the remaining variant types.
+    MOZ_ASSERT(mValue->is<RefPtr<nsAtom>>() || mValue->is<bool>() ||
+               mValue->is<float>() || mValue->is<double>() ||
+               mValue->is<int32_t>() || mValue->is<uint64_t>() ||
+               mValue->is<CSSCoord>() || mValue->is<FontSize>() ||
+               mValue->is<Color>() || mValue->is<DeleteEntry>());
+  }
+
+  return size;
+}
diff --git a/accessible/base/AccAttributes.h b/accessible/base/AccAttributes.h
new file mode 100644
index 0000000000..0d7610b358
--- /dev/null
+++ b/accessible/base/AccAttributes.h
@@ -0,0 +1,293 @@
+/* -*- 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 AccAttributes_h_
+#define AccAttributes_h_
+
+#include "mozilla/ServoStyleConsts.h"
+#include "mozilla/a11y/AccGroupInfo.h"
+#include "mozilla/Variant.h"
+#include "nsTHashMap.h"
+#include "nsStringFwd.h"
+#include "mozilla/gfx/Matrix.h"
+
+class nsVariant;
+
+namespace IPC {
+template <typename T>
+struct ParamTraits;
+}  // namespace IPC
+
+namespace mozilla {
+
+namespace dom {
+class Element;
+}
+
+namespace a11y {
+
+struct FontSize {
+  int32_t mValue;
+
+  bool operator==(const FontSize& aOther) const {
+    return mValue == aOther.mValue;
+  }
+
+  bool operator!=(const FontSize& aOther) const {
+    return mValue != aOther.mValue;
+  }
+};
+
+struct Color {
+  nscolor mValue;
+
+  bool operator==(const Color& aOther) const { return mValue == aOther.mValue; }
+
+  bool operator!=(const Color& aOther) const { return mValue != aOther.mValue; }
+};
+
+// A special type. If an entry has a value of this type, it instructs the
+// target instance of an Update to remove the entry with the same key value.
+struct DeleteEntry {
+  DeleteEntry() : mValue(true) {}
+  bool mValue;
+
+  bool operator==(const DeleteEntry& aOther) const { return true; }
+
+  bool operator!=(const DeleteEntry& aOther) const { return false; }
+};
+
+class AccAttributes {
+  // Warning! An AccAttributes can contain another AccAttributes. This is
+  // intended for object and text attributes. However, the nested
+  // AccAttributes should never itself contain another AccAttributes, nor
+  // should it create a cycle. We don't do cycle collection here for
+  // performance reasons, so violating this rule will cause leaks!
+  using AttrValueType =
+      Variant<bool, float, double, int32_t, RefPtr<nsAtom>, nsTArray<int32_t>,
+              CSSCoord, FontSize, Color, DeleteEntry, UniquePtr<nsString>,
+              RefPtr<AccAttributes>, uint64_t, UniquePtr<AccGroupInfo>,
+              UniquePtr<gfx::Matrix4x4>, nsTArray<uint64_t>>;
+  static_assert(sizeof(AttrValueType) <= 16);
+  using AtomVariantMap = nsTHashMap<RefPtr<nsAtom>, AttrValueType>;
+
+ protected:
+  ~AccAttributes() = default;
+
+ public:
+  AccAttributes() = default;
+  AccAttributes(const AccAttributes&) = delete;
+  AccAttributes& operator=(const AccAttributes&) = delete;
+
+  NS_INLINE_DECL_REFCOUNTING(mozilla::a11y::AccAttributes)
+
+  template <typename T>
+  void SetAttribute(nsAtom* aAttrName, T&& aAttrValue) {
+    using ValType =
+        std::remove_const_t<std::remove_reference_t<decltype(aAttrValue)>>;
+    if constexpr (std::is_convertible_v<ValType, nsString>) {
+      static_assert(std::is_rvalue_reference_v<decltype(aAttrValue)>,
+                    "Please only move strings into this function. To make a "
+                    "copy, use SetAttributeStringCopy.");
+      UniquePtr<nsString> value = MakeUnique<nsString>(std::move(aAttrValue));
+      mData.InsertOrUpdate(aAttrName, AsVariant(std::move(value)));
+    } else if constexpr (std::is_same_v<ValType, gfx::Matrix4x4>) {
+      UniquePtr<gfx::Matrix4x4> value = MakeUnique<gfx::Matrix4x4>(aAttrValue);
+      mData.InsertOrUpdate(aAttrName, AsVariant(std::move(value)));
+    } else if constexpr (std::is_same_v<ValType, AccGroupInfo*>) {
+      UniquePtr<AccGroupInfo> value(aAttrValue);
+      mData.InsertOrUpdate(aAttrName, AsVariant(std::move(value)));
+    } else if constexpr (std::is_convertible_v<ValType, nsAtom*>) {
+      mData.InsertOrUpdate(aAttrName, AsVariant(RefPtr<nsAtom>(aAttrValue)));
+    } else {
+      mData.InsertOrUpdate(aAttrName, AsVariant(std::forward<T>(aAttrValue)));
+    }
+  }
+
+  void SetAttributeStringCopy(nsAtom* aAttrName, nsString aAttrValue) {
+    SetAttribute(aAttrName, std::move(aAttrValue));
+  }
+
+  template <typename T>
+  Maybe<const T&> GetAttribute(nsAtom* aAttrName) const {
+    if (auto value = mData.Lookup(aAttrName)) {
+      if constexpr (std::is_same_v<nsString, T>) {
+        if (value->is<UniquePtr<nsString>>()) {
+          const T& val = *(value->as<UniquePtr<nsString>>().get());
+          return SomeRef(val);
+        }
+      } else if constexpr (std::is_same_v<gfx::Matrix4x4, T>) {
+        if (value->is<UniquePtr<gfx::Matrix4x4>>()) {
+          const T& val = *(value->as<UniquePtr<gfx::Matrix4x4>>());
+          return SomeRef(val);
+        }
+      } else {
+        if (value->is<T>()) {
+          const T& val = value->as<T>();
+          return SomeRef(val);
+        }
+      }
+    }
+    return Nothing();
+  }
+
+  template <typename T>
+  RefPtr<const T> GetAttributeRefPtr(nsAtom* aAttrName) const {
+    if (auto value = mData.Lookup(aAttrName)) {
+      if (value->is<RefPtr<T>>()) {
+        RefPtr<const T> ref = value->as<RefPtr<T>>();
+        return ref;
+      }
+    }
+    return nullptr;
+  }
+
+  template <typename T>
+  Maybe<T&> GetMutableAttribute(nsAtom* aAttrName) const {
+    static_assert(std::is_same_v<nsTArray<int32_t>, T> ||
+                      std::is_same_v<nsTArray<uint64_t>, T>,
+                  "Only arrays should be mutable attributes");
+    if (auto value = mData.Lookup(aAttrName)) {
+      if (value->is<T>()) {
+        T& val = value->as<T>();
+        return SomeRef(val);
+      }
+    }
+    return Nothing();
+  }
+
+  // Get stringified value
+  bool GetAttribute(nsAtom* aAttrName, nsAString& aAttrValue) const;
+
+  bool HasAttribute(nsAtom* aAttrName) const {
+    return mData.Contains(aAttrName);
+  }
+
+  bool Remove(nsAtom* aAttrName) { return mData.Remove(aAttrName); }
+
+  uint32_t Count() const { return mData.Count(); }
+
+  // Update one instance with the entries in another. The supplied AccAttributes
+  // will be emptied.
+  void Update(AccAttributes* aOther);
+
+  /**
+   * Return true if all the attributes in this instance are equal to all the
+   * attributes in another instance.
+   */
+  bool Equal(const AccAttributes* aOther) const;
+
+  /**
+   * Copy attributes from this instance to another instance.
+   * This should only be used in very specific cases; e.g. merging two sets of
+   * cached attributes without modifying the cache. It can only copy simple
+   * value types; e.g. it can't copy array values. Attempting to copy an
+   * AccAttributes with uncopyable values will cause an assertion.
+   */
+  void CopyTo(AccAttributes* aDest) const;
+
+  // An entry class for our iterator.
+  class Entry {
+   public:
+    Entry(nsAtom* aAttrName, const AttrValueType* aAttrValue)
+        : mName(aAttrName), mValue(aAttrValue) {}
+
+    nsAtom* Name() const { return mName; }
+
+    template <typename T>
+    Maybe<const T&> Value() const {
+      if constexpr (std::is_same_v<nsString, T>) {
+        if (mValue->is<UniquePtr<nsString>>()) {
+          const T& val = *(mValue->as<UniquePtr<nsString>>().get());
+          return SomeRef(val);
+        }
+      } else if constexpr (std::is_same_v<gfx::Matrix4x4, T>) {
+        if (mValue->is<UniquePtr<gfx::Matrix4x4>>()) {
+          const T& val = *(mValue->as<UniquePtr<gfx::Matrix4x4>>());
+          return SomeRef(val);
+        }
+      } else {
+        if (mValue->is<T>()) {
+          const T& val = mValue->as<T>();
+          return SomeRef(val);
+        }
+      }
+      return Nothing();
+    }
+
+    void NameAsString(nsString& aName) const {
+      mName->ToString(aName);
+      if (StringBeginsWith(aName, u"aria-"_ns)) {
+        // Found 'aria-'
+        aName.ReplaceLiteral(0, 5, u"");
+      }
+    }
+
+    void ValueAsString(nsAString& aValueString) const {
+      StringFromValueAndName(mName, *mValue, aValueString);
+    }
+
+    // Size of the pair in the hash table.
+    size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf);
+
+   private:
+    nsAtom* mName;
+    const AttrValueType* mValue;
+
+    friend class AccAttributes;
+  };
+
+  class Iterator {
+   public:
+    explicit Iterator(AtomVariantMap::const_iterator aIter)
+        : mHashIterator(aIter) {}
+
+    Iterator() = delete;
+    Iterator(const Iterator&) = delete;
+    Iterator& operator=(const Iterator&) = delete;
+
+    bool operator!=(const Iterator& aOther) const {
+      return mHashIterator != aOther.mHashIterator;
+    }
+
+    Iterator& operator++() {
+      mHashIterator++;
+      return *this;
+    }
+
+    Entry operator*() const {
+      auto& entry = *mHashIterator;
+      return Entry(entry.GetKey(), &entry.GetData());
+    }
+
+   private:
+    AtomVariantMap::const_iterator mHashIterator;
+  };
+
+  friend class Iterator;
+
+  Iterator begin() const { return Iterator(mData.begin()); }
+  Iterator end() const { return Iterator(mData.end()); }
+
+#ifdef A11Y_LOG
+  static void DebugPrint(const char* aPrefix, const AccAttributes& aAttributes);
+#endif
+
+  size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf);
+
+ private:
+  static void StringFromValueAndName(nsAtom* aAttrName,
+                                     const AttrValueType& aValue,
+                                     nsAString& aValueString);
+
+  AtomVariantMap mData;
+
+  friend struct IPC::ParamTraits<AccAttributes*>;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/AccEvent.cpp b/accessible/base/AccEvent.cpp
new file mode 100644
index 0000000000..1d1b4386f8
--- /dev/null
+++ b/accessible/base/AccEvent.cpp
@@ -0,0 +1,256 @@
+/* -*- 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 "AccEvent.h"
+
+#include "nsAccUtils.h"
+#include "xpcAccEvents.h"
+#include "States.h"
+#include "TextRange.h"
+#include "xpcAccessibleDocument.h"
+#include "xpcAccessibleTextRange.h"
+
+#include "mozilla/dom/Selection.h"
+#include "mozilla/dom/UserActivation.h"
+
+#include "nsComponentManagerUtils.h"
+#include "nsIMutableArray.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+static_assert(static_cast<bool>(eNoUserInput) == false &&
+                  static_cast<bool>(eFromUserInput) == true,
+              "EIsFromUserInput cannot be casted to bool");
+
+////////////////////////////////////////////////////////////////////////////////
+// AccEvent
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+// AccEvent constructors
+
+AccEvent::AccEvent(uint32_t aEventType, LocalAccessible* aAccessible,
+                   EIsFromUserInput aIsFromUserInput, EEventRule aEventRule)
+    : mEventType(aEventType), mEventRule(aEventRule), mAccessible(aAccessible) {
+  if (aIsFromUserInput == eAutoDetect) {
+    mIsFromUserInput = dom::UserActivation::IsHandlingUserInput();
+  } else {
+    mIsFromUserInput = aIsFromUserInput == eFromUserInput ? true : false;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// AccEvent cycle collection
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(AccEvent)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(AccEvent)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mAccessible)
+  if (AccTreeMutationEvent* tmEvent = downcast_accEvent(tmp)) {
+    tmEvent->SetNextEvent(nullptr);
+    tmEvent->SetPrevEvent(nullptr);
+  }
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(AccEvent)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAccessible)
+  if (AccTreeMutationEvent* tmEvent = downcast_accEvent(tmp)) {
+    CycleCollectionNoteChild(cb, tmEvent->NextEvent(), "mNext");
+    CycleCollectionNoteChild(cb, tmEvent->PrevEvent(), "mPrevEvent");
+  }
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// AccTextChangeEvent
+////////////////////////////////////////////////////////////////////////////////
+
+// Note: we pass in eAllowDupes to the base class because we don't support text
+// events coalescence. We fire delayed text change events in DocAccessible but
+// we continue to base the event off the accessible object rather than just the
+// node. This means we won't try to create an accessible based on the node when
+// we are ready to fire the event and so we will no longer assert at that point
+// if the node was removed from the document. Either way, the AT won't work with
+// a defunct accessible so the behaviour should be equivalent.
+AccTextChangeEvent::AccTextChangeEvent(LocalAccessible* aAccessible,
+                                       int32_t aStart,
+                                       const nsAString& aModifiedText,
+                                       bool aIsInserted,
+                                       EIsFromUserInput aIsFromUserInput)
+    : AccEvent(
+          aIsInserted
+              ? static_cast<uint32_t>(nsIAccessibleEvent::EVENT_TEXT_INSERTED)
+              : static_cast<uint32_t>(nsIAccessibleEvent::EVENT_TEXT_REMOVED),
+          aAccessible, aIsFromUserInput, eAllowDupes),
+      mStart(aStart),
+      mIsInserted(aIsInserted),
+      mModifiedText(aModifiedText) {
+  // XXX We should use IsFromUserInput here, but that isn't always correct
+  // when the text change isn't related to content insertion or removal.
+  mIsFromUserInput =
+      mAccessible->State() & (states::FOCUSED | states::EDITABLE);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// AccHideEvent
+////////////////////////////////////////////////////////////////////////////////
+
+AccHideEvent::AccHideEvent(LocalAccessible* aTarget, bool aNeedsShutdown)
+    : AccMutationEvent(::nsIAccessibleEvent::EVENT_HIDE, aTarget),
+      mNeedsShutdown(aNeedsShutdown) {
+  mNextSibling = mAccessible->LocalNextSibling();
+  mPrevSibling = mAccessible->LocalPrevSibling();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// AccShowEvent
+////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////
+// AccTextSelChangeEvent
+////////////////////////////////////////////////////////////////////////////////
+
+AccTextSelChangeEvent::AccTextSelChangeEvent(HyperTextAccessible* aTarget,
+                                             dom::Selection* aSelection,
+                                             int32_t aReason,
+                                             int32_t aGranularity)
+    : AccEvent(nsIAccessibleEvent::EVENT_TEXT_SELECTION_CHANGED, aTarget,
+               eAutoDetect, eCoalesceTextSelChange),
+      mSel(aSelection),
+      mReason(aReason),
+      mGranularity(aGranularity) {}
+
+AccTextSelChangeEvent::~AccTextSelChangeEvent() {}
+
+bool AccTextSelChangeEvent::IsCaretMoveOnly() const {
+  return mSel->RangeCount() == 1 && mSel->IsCollapsed() &&
+         ((mReason & (nsISelectionListener::COLLAPSETOSTART_REASON |
+                      nsISelectionListener::COLLAPSETOEND_REASON)) == 0);
+}
+
+void AccTextSelChangeEvent::SelectionRanges(
+    nsTArray<TextRange>* aRanges) const {
+  TextRange::TextRangesFromSelection(mSel, aRanges);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// AccSelChangeEvent
+////////////////////////////////////////////////////////////////////////////////
+
+AccSelChangeEvent::AccSelChangeEvent(LocalAccessible* aWidget,
+                                     LocalAccessible* aItem,
+                                     SelChangeType aSelChangeType)
+    : AccEvent(0, aItem, eAutoDetect, eCoalesceSelectionChange),
+      mWidget(aWidget),
+      mItem(aItem),
+      mSelChangeType(aSelChangeType),
+      mPreceedingCount(0),
+      mPackedEvent(nullptr) {
+  if (aSelChangeType == eSelectionAdd) {
+    if (mWidget->GetSelectedItem(1)) {
+      mEventType = nsIAccessibleEvent::EVENT_SELECTION_ADD;
+    } else {
+      mEventType = nsIAccessibleEvent::EVENT_SELECTION;
+    }
+  } else {
+    mEventType = nsIAccessibleEvent::EVENT_SELECTION_REMOVE;
+  }
+}
+
+already_AddRefed<nsIAccessibleEvent> a11y::MakeXPCEvent(AccEvent* aEvent) {
+  DocAccessible* doc = aEvent->Document();
+  LocalAccessible* acc = aEvent->GetAccessible();
+  nsINode* node = acc->GetNode();
+  bool fromUser = aEvent->IsFromUserInput();
+  uint32_t type = aEvent->GetEventType();
+  uint32_t eventGroup = aEvent->GetEventGroups();
+  nsCOMPtr<nsIAccessibleEvent> xpEvent;
+
+  if (eventGroup & (1 << AccEvent::eStateChangeEvent)) {
+    AccStateChangeEvent* sc = downcast_accEvent(aEvent);
+    bool extra = false;
+    uint32_t state = nsAccUtils::To32States(sc->GetState(), &extra);
+    xpEvent = new xpcAccStateChangeEvent(type, ToXPC(acc), ToXPCDocument(doc),
+                                         node, fromUser, state, extra,
+                                         sc->IsStateEnabled());
+    return xpEvent.forget();
+  }
+
+  if (eventGroup & (1 << AccEvent::eTextChangeEvent)) {
+    AccTextChangeEvent* tc = downcast_accEvent(aEvent);
+    nsString text;
+    tc->GetModifiedText(text);
+    xpEvent = new xpcAccTextChangeEvent(
+        type, ToXPC(acc), ToXPCDocument(doc), node, fromUser,
+        tc->GetStartOffset(), tc->GetLength(), tc->IsTextInserted(), text);
+    return xpEvent.forget();
+  }
+
+  if (eventGroup & (1 << AccEvent::eHideEvent)) {
+    AccHideEvent* hideEvent = downcast_accEvent(aEvent);
+    xpEvent = new xpcAccHideEvent(type, ToXPC(acc), ToXPCDocument(doc), node,
+                                  fromUser, ToXPC(hideEvent->TargetParent()),
+                                  ToXPC(hideEvent->TargetNextSibling()),
+                                  ToXPC(hideEvent->TargetPrevSibling()));
+    return xpEvent.forget();
+  }
+
+  if (eventGroup & (1 << AccEvent::eCaretMoveEvent)) {
+    AccCaretMoveEvent* cm = downcast_accEvent(aEvent);
+    xpEvent = new xpcAccCaretMoveEvent(
+        type, ToXPC(acc), ToXPCDocument(doc), node, fromUser,
+        cm->GetCaretOffset(), cm->IsSelectionCollapsed(), cm->IsAtEndOfLine(),
+        cm->GetGranularity());
+    return xpEvent.forget();
+  }
+
+  if (eventGroup & (1 << AccEvent::eTextSelChangeEvent)) {
+    AccTextSelChangeEvent* tsc = downcast_accEvent(aEvent);
+    AutoTArray<TextRange, 1> ranges;
+    tsc->SelectionRanges(&ranges);
+
+    nsCOMPtr<nsIMutableArray> xpcRanges =
+        do_CreateInstance(NS_ARRAY_CONTRACTID);
+    uint32_t len = ranges.Length();
+    for (uint32_t idx = 0; idx < len; idx++) {
+      xpcRanges->AppendElement(new xpcAccessibleTextRange(ranges[idx]));
+    }
+
+    xpEvent = new xpcAccTextSelectionChangeEvent(
+        type, ToXPC(acc), ToXPCDocument(doc), node, fromUser, xpcRanges);
+    return xpEvent.forget();
+  }
+
+  if (eventGroup & (1 << AccEvent::eObjectAttrChangedEvent)) {
+    AccObjectAttrChangedEvent* oac = downcast_accEvent(aEvent);
+    nsString attribute;
+    oac->GetAttribute()->ToString(attribute);
+    xpEvent = new xpcAccObjectAttributeChangedEvent(
+        type, ToXPC(acc), ToXPCDocument(doc), node, fromUser, attribute);
+    return xpEvent.forget();
+  }
+
+  if (eventGroup & (1 << AccEvent::eScrollingEvent)) {
+    AccScrollingEvent* sa = downcast_accEvent(aEvent);
+    xpEvent = new xpcAccScrollingEvent(
+        type, ToXPC(acc), ToXPCDocument(doc), node, fromUser, sa->ScrollX(),
+        sa->ScrollY(), sa->MaxScrollX(), sa->MaxScrollY());
+    return xpEvent.forget();
+  }
+
+  if (eventGroup & (1 << AccEvent::eAnnouncementEvent)) {
+    AccAnnouncementEvent* aa = downcast_accEvent(aEvent);
+    xpEvent = new xpcAccAnnouncementEvent(type, ToXPC(acc), ToXPCDocument(doc),
+                                          node, fromUser, aa->Announcement(),
+                                          aa->Priority());
+    return xpEvent.forget();
+  }
+
+  xpEvent =
+      new xpcAccEvent(type, ToXPC(acc), ToXPCDocument(doc), node, fromUser);
+  return xpEvent.forget();
+}
diff --git a/accessible/base/AccEvent.h b/accessible/base/AccEvent.h
new file mode 100644
index 0000000000..a4ff82916a
--- /dev/null
+++ b/accessible/base/AccEvent.h
@@ -0,0 +1,562 @@
+/* -*- 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 _AccEvent_H_
+#define _AccEvent_H_
+
+#include "nsIAccessibleEvent.h"
+
+#include "mozilla/a11y/LocalAccessible.h"
+
+class nsEventShell;
+namespace mozilla {
+
+namespace dom {
+class Selection;
+}
+
+namespace a11y {
+
+class DocAccessible;
+class EventQueue;
+class TextRange;
+
+// Constants used to point whether the event is from user input.
+enum EIsFromUserInput {
+  // eNoUserInput: event is not from user input
+  eNoUserInput = 0,
+  // eFromUserInput: event is from user input
+  eFromUserInput = 1,
+  // eAutoDetect: the value should be obtained from event state manager
+  eAutoDetect = -1
+};
+
+/**
+ * Generic accessible event.
+ */
+class AccEvent {
+ public:
+  // Rule for accessible events.
+  // The rule will be applied when flushing pending events.
+  enum EEventRule {
+    // eAllowDupes : More than one event of the same type is allowed.
+    //    This event will always be emitted. This flag is used for events that
+    //    don't support coalescence.
+    eAllowDupes,
+
+    // eCoalesceReorder : For reorder events from the same subtree or the same
+    //    node, only the umbrella event on the ancestor will be emitted.
+    eCoalesceReorder,
+
+    // eCoalesceOfSameType : For events of the same type, only the newest event
+    // will be processed.
+    eCoalesceOfSameType,
+
+    // eCoalesceSelectionChange: coalescence of selection change events.
+    eCoalesceSelectionChange,
+
+    // eCoalesceStateChange: coalesce state change events.
+    eCoalesceStateChange,
+
+    // eCoalesceTextSelChange: coalescence of text selection change events.
+    eCoalesceTextSelChange,
+
+    // eRemoveDupes : For repeat events, only the newest event in queue
+    //    will be emitted.
+    eRemoveDupes,
+
+    // eDoNotEmit : This event is confirmed as a duplicate, do not emit it.
+    eDoNotEmit
+  };
+
+  // Initialize with an accessible.
+  AccEvent(uint32_t aEventType, LocalAccessible* aAccessible,
+           EIsFromUserInput aIsFromUserInput = eAutoDetect,
+           EEventRule aEventRule = eRemoveDupes);
+
+  // AccEvent
+  uint32_t GetEventType() const { return mEventType; }
+  EEventRule GetEventRule() const { return mEventRule; }
+  bool IsFromUserInput() const { return mIsFromUserInput; }
+  EIsFromUserInput FromUserInput() const {
+    return static_cast<EIsFromUserInput>(mIsFromUserInput);
+  }
+
+  LocalAccessible* GetAccessible() const { return mAccessible; }
+  DocAccessible* Document() const { return mAccessible->Document(); }
+
+  /**
+   * Down casting.
+   */
+  enum EventGroup {
+    eGenericEvent,
+    eStateChangeEvent,
+    eTextChangeEvent,
+    eTreeMutationEvent,
+    eMutationEvent,
+    eReorderEvent,
+    eHideEvent,
+    eShowEvent,
+    eCaretMoveEvent,
+    eTextSelChangeEvent,
+    eSelectionChangeEvent,
+    eObjectAttrChangedEvent,
+    eScrollingEvent,
+    eAnnouncementEvent,
+  };
+
+  static const EventGroup kEventGroup = eGenericEvent;
+  virtual unsigned int GetEventGroups() const { return 1U << eGenericEvent; }
+
+  /**
+   * Reference counting and cycle collection.
+   */
+  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(AccEvent)
+  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(AccEvent)
+
+ protected:
+  virtual ~AccEvent() {}
+
+  bool mIsFromUserInput;
+  uint32_t mEventType;
+  EEventRule mEventRule;
+  RefPtr<LocalAccessible> mAccessible;
+
+  friend class EventQueue;
+  friend class EventTree;
+  friend class ::nsEventShell;
+  friend class NotificationController;
+};
+
+/**
+ * Accessible state change event.
+ */
+class AccStateChangeEvent : public AccEvent {
+ public:
+  AccStateChangeEvent(LocalAccessible* aAccessible, uint64_t aState,
+                      bool aIsEnabled,
+                      EIsFromUserInput aIsFromUserInput = eAutoDetect)
+      : AccEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE, aAccessible,
+                 aIsFromUserInput, eCoalesceStateChange),
+        mState(aState),
+        mIsEnabled(aIsEnabled) {}
+
+  AccStateChangeEvent(LocalAccessible* aAccessible, uint64_t aState)
+      : AccEvent(::nsIAccessibleEvent::EVENT_STATE_CHANGE, aAccessible,
+                 eAutoDetect, eCoalesceStateChange),
+        mState(aState) {
+    mIsEnabled = (mAccessible->State() & mState) != 0;
+  }
+
+  // AccEvent
+  static const EventGroup kEventGroup = eStateChangeEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccEvent::GetEventGroups() | (1U << eStateChangeEvent);
+  }
+
+  // AccStateChangeEvent
+  uint64_t GetState() const { return mState; }
+  bool IsStateEnabled() const { return mIsEnabled; }
+
+ private:
+  uint64_t mState;
+  bool mIsEnabled;
+
+  friend class EventQueue;
+};
+
+/**
+ * Accessible text change event.
+ */
+class AccTextChangeEvent : public AccEvent {
+ public:
+  AccTextChangeEvent(LocalAccessible* aAccessible, int32_t aStart,
+                     const nsAString& aModifiedText, bool aIsInserted,
+                     EIsFromUserInput aIsFromUserInput = eAutoDetect);
+
+  // AccEvent
+  static const EventGroup kEventGroup = eTextChangeEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccEvent::GetEventGroups() | (1U << eTextChangeEvent);
+  }
+
+  // AccTextChangeEvent
+  int32_t GetStartOffset() const { return mStart; }
+  uint32_t GetLength() const { return mModifiedText.Length(); }
+  bool IsTextInserted() const { return mIsInserted; }
+  void GetModifiedText(nsAString& aModifiedText) {
+    aModifiedText = mModifiedText;
+  }
+  const nsString& ModifiedText() const { return mModifiedText; }
+
+ private:
+  int32_t mStart;
+  bool mIsInserted;
+  nsString mModifiedText;
+
+  friend class EventTree;
+  friend class NotificationController;
+};
+
+/**
+ * A base class for events related to tree mutation, either an AccMutation
+ * event, or an AccReorderEvent.
+ */
+class AccTreeMutationEvent : public AccEvent {
+ public:
+  AccTreeMutationEvent(uint32_t aEventType, LocalAccessible* aTarget)
+      : AccEvent(aEventType, aTarget, eAutoDetect, eCoalesceReorder),
+        mGeneration(0) {}
+
+  // Event
+  static const EventGroup kEventGroup = eTreeMutationEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccEvent::GetEventGroups() | (1U << eTreeMutationEvent);
+  }
+
+  void SetNextEvent(AccTreeMutationEvent* aNext) { mNextEvent = aNext; }
+  void SetPrevEvent(AccTreeMutationEvent* aPrev) { mPrevEvent = aPrev; }
+  AccTreeMutationEvent* NextEvent() const { return mNextEvent; }
+  AccTreeMutationEvent* PrevEvent() const { return mPrevEvent; }
+
+  /**
+   * A sequence number to know when this event was fired.
+   */
+  uint32_t EventGeneration() const { return mGeneration; }
+  void SetEventGeneration(uint32_t aGeneration) { mGeneration = aGeneration; }
+
+ private:
+  RefPtr<AccTreeMutationEvent> mNextEvent;
+  RefPtr<AccTreeMutationEvent> mPrevEvent;
+  uint32_t mGeneration;
+};
+
+/**
+ * Base class for show and hide accessible events.
+ */
+class AccMutationEvent : public AccTreeMutationEvent {
+ public:
+  AccMutationEvent(uint32_t aEventType, LocalAccessible* aTarget)
+      : AccTreeMutationEvent(aEventType, aTarget) {
+    // Don't coalesce these since they are coalesced by reorder event. Coalesce
+    // contained text change events.
+    mParent = mAccessible->LocalParent();
+  }
+  virtual ~AccMutationEvent() {}
+
+  // Event
+  static const EventGroup kEventGroup = eMutationEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccTreeMutationEvent::GetEventGroups() | (1U << eMutationEvent);
+  }
+
+  // MutationEvent
+  bool IsShow() const { return mEventType == nsIAccessibleEvent::EVENT_SHOW; }
+  bool IsHide() const { return mEventType == nsIAccessibleEvent::EVENT_HIDE; }
+
+  LocalAccessible* LocalParent() const { return mParent; }
+
+ protected:
+  RefPtr<LocalAccessible> mParent;
+  RefPtr<AccTextChangeEvent> mTextChangeEvent;
+
+  friend class EventTree;
+  friend class NotificationController;
+};
+
+/**
+ * Accessible hide event.
+ */
+class AccHideEvent : public AccMutationEvent {
+ public:
+  explicit AccHideEvent(LocalAccessible* aTarget, bool aNeedsShutdown = true);
+
+  // Event
+  static const EventGroup kEventGroup = eHideEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccMutationEvent::GetEventGroups() | (1U << eHideEvent);
+  }
+
+  // AccHideEvent
+  LocalAccessible* TargetParent() const { return mParent; }
+  LocalAccessible* TargetNextSibling() const { return mNextSibling; }
+  LocalAccessible* TargetPrevSibling() const { return mPrevSibling; }
+  bool NeedsShutdown() const { return mNeedsShutdown; }
+
+ protected:
+  bool mNeedsShutdown;
+  RefPtr<LocalAccessible> mNextSibling;
+  RefPtr<LocalAccessible> mPrevSibling;
+
+  friend class EventTree;
+  friend class NotificationController;
+};
+
+/**
+ * Accessible show event.
+ */
+class AccShowEvent : public AccMutationEvent {
+ public:
+  explicit AccShowEvent(LocalAccessible* aTarget)
+      : AccMutationEvent(::nsIAccessibleEvent::EVENT_SHOW, aTarget) {}
+
+  // Event
+  static const EventGroup kEventGroup = eShowEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccMutationEvent::GetEventGroups() | (1U << eShowEvent);
+  }
+};
+
+/**
+ * Class for reorder accessible event. Takes care about
+ */
+class AccReorderEvent : public AccTreeMutationEvent {
+ public:
+  explicit AccReorderEvent(LocalAccessible* aTarget)
+      : AccTreeMutationEvent(::nsIAccessibleEvent::EVENT_REORDER, aTarget) {}
+  virtual ~AccReorderEvent() {}
+
+  // Event
+  static const EventGroup kEventGroup = eReorderEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccTreeMutationEvent::GetEventGroups() | (1U << eReorderEvent);
+  }
+
+  /*
+   * Make this an inner reorder event that is coalesced into
+   * a reorder event of an ancestor.
+   */
+  void SetInner() { mEventType = ::nsIAccessibleEvent::EVENT_INNER_REORDER; }
+};
+
+/**
+ * Accessible caret move event.
+ */
+class AccCaretMoveEvent : public AccEvent {
+ public:
+  AccCaretMoveEvent(LocalAccessible* aAccessible, int32_t aCaretOffset,
+                    bool aIsSelectionCollapsed, bool aIsAtEndOfLine,
+                    int32_t aGranularity,
+                    EIsFromUserInput aIsFromUserInput = eAutoDetect)
+      : AccEvent(::nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED, aAccessible,
+                 aIsFromUserInput),
+        mCaretOffset(aCaretOffset),
+        mIsSelectionCollapsed(aIsSelectionCollapsed),
+        mIsAtEndOfLine(aIsAtEndOfLine),
+        mGranularity(aGranularity) {}
+  virtual ~AccCaretMoveEvent() {}
+
+  // AccEvent
+  static const EventGroup kEventGroup = eCaretMoveEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccEvent::GetEventGroups() | (1U << eCaretMoveEvent);
+  }
+
+  // AccCaretMoveEvent
+  int32_t GetCaretOffset() const { return mCaretOffset; }
+
+  bool IsSelectionCollapsed() const { return mIsSelectionCollapsed; }
+  bool IsAtEndOfLine() { return mIsAtEndOfLine; }
+
+  int32_t GetGranularity() const { return mGranularity; }
+
+ private:
+  int32_t mCaretOffset;
+
+  bool mIsSelectionCollapsed;
+  bool mIsAtEndOfLine;
+  int32_t mGranularity;
+};
+
+/**
+ * Accessible text selection change event.
+ */
+class AccTextSelChangeEvent : public AccEvent {
+ public:
+  AccTextSelChangeEvent(HyperTextAccessible* aTarget,
+                        dom::Selection* aSelection, int32_t aReason,
+                        int32_t aGranularity);
+  virtual ~AccTextSelChangeEvent();
+
+  // AccEvent
+  static const EventGroup kEventGroup = eTextSelChangeEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccEvent::GetEventGroups() | (1U << eTextSelChangeEvent);
+  }
+
+  // AccTextSelChangeEvent
+
+  /**
+   * Return true if the text selection change wasn't caused by pure caret move.
+   */
+  bool IsCaretMoveOnly() const;
+
+  int32_t GetGranularity() const { return mGranularity; }
+
+  /**
+   * Return selection ranges in document/control.
+   */
+  void SelectionRanges(nsTArray<a11y::TextRange>* aRanges) const;
+
+ private:
+  RefPtr<dom::Selection> mSel;
+  int32_t mReason;
+  int32_t mGranularity;
+
+  friend class EventQueue;
+  friend class SelectionManager;
+};
+
+/**
+ * Accessible widget selection change event.
+ */
+class AccSelChangeEvent : public AccEvent {
+ public:
+  enum SelChangeType { eSelectionAdd, eSelectionRemove };
+
+  AccSelChangeEvent(LocalAccessible* aWidget, LocalAccessible* aItem,
+                    SelChangeType aSelChangeType);
+
+  virtual ~AccSelChangeEvent() {}
+
+  // AccEvent
+  static const EventGroup kEventGroup = eSelectionChangeEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccEvent::GetEventGroups() | (1U << eSelectionChangeEvent);
+  }
+
+  // AccSelChangeEvent
+  LocalAccessible* Widget() const { return mWidget; }
+
+ private:
+  RefPtr<LocalAccessible> mWidget;
+  RefPtr<LocalAccessible> mItem;
+  SelChangeType mSelChangeType;
+  uint32_t mPreceedingCount;
+  AccSelChangeEvent* mPackedEvent;
+
+  friend class EventQueue;
+};
+
+/**
+ * Accessible object attribute changed event.
+ */
+class AccObjectAttrChangedEvent : public AccEvent {
+ public:
+  AccObjectAttrChangedEvent(LocalAccessible* aAccessible, nsAtom* aAttribute)
+      : AccEvent(::nsIAccessibleEvent::EVENT_OBJECT_ATTRIBUTE_CHANGED,
+                 aAccessible),
+        mAttribute(aAttribute) {}
+
+  // AccEvent
+  static const EventGroup kEventGroup = eObjectAttrChangedEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccEvent::GetEventGroups() | (1U << eObjectAttrChangedEvent);
+  }
+
+  // AccObjectAttrChangedEvent
+  nsAtom* GetAttribute() const { return mAttribute; }
+
+ private:
+  RefPtr<nsAtom> mAttribute;
+
+  virtual ~AccObjectAttrChangedEvent() {}
+};
+
+/**
+ * Accessible scroll event.
+ */
+class AccScrollingEvent : public AccEvent {
+ public:
+  AccScrollingEvent(uint32_t aEventType, LocalAccessible* aAccessible,
+                    uint32_t aScrollX, uint32_t aScrollY, uint32_t aMaxScrollX,
+                    uint32_t aMaxScrollY)
+      : AccEvent(aEventType, aAccessible),
+        mScrollX(aScrollX),
+        mScrollY(aScrollY),
+        mMaxScrollX(aMaxScrollX),
+        mMaxScrollY(aMaxScrollY) {}
+
+  virtual ~AccScrollingEvent() {}
+
+  // AccEvent
+  static const EventGroup kEventGroup = eScrollingEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccEvent::GetEventGroups() | (1U << eScrollingEvent);
+  }
+
+  // The X scrolling offset of the container when the event was fired.
+  uint32_t ScrollX() { return mScrollX; }
+  // The Y scrolling offset of the container when the event was fired.
+  uint32_t ScrollY() { return mScrollY; }
+  // The max X offset of the container.
+  uint32_t MaxScrollX() { return mMaxScrollX; }
+  // The max Y offset of the container.
+  uint32_t MaxScrollY() { return mMaxScrollY; }
+
+ private:
+  uint32_t mScrollX;
+  uint32_t mScrollY;
+  uint32_t mMaxScrollX;
+  uint32_t mMaxScrollY;
+};
+
+/**
+ * Accessible announcement event.
+ */
+class AccAnnouncementEvent : public AccEvent {
+ public:
+  AccAnnouncementEvent(LocalAccessible* aAccessible,
+                       const nsAString& aAnnouncement, uint16_t aPriority)
+      : AccEvent(nsIAccessibleEvent::EVENT_ANNOUNCEMENT, aAccessible),
+        mAnnouncement(aAnnouncement),
+        mPriority(aPriority) {}
+
+  virtual ~AccAnnouncementEvent() {}
+
+  // AccEvent
+  static const EventGroup kEventGroup = eAnnouncementEvent;
+  virtual unsigned int GetEventGroups() const override {
+    return AccEvent::GetEventGroups() | (1U << eAnnouncementEvent);
+  }
+
+  const nsString& Announcement() const { return mAnnouncement; }
+
+  uint16_t Priority() { return mPriority; }
+
+ private:
+  nsString mAnnouncement;
+  uint16_t mPriority;
+};
+
+/**
+ * Downcast the generic accessible event object to derived type.
+ */
+class downcast_accEvent {
+ public:
+  explicit downcast_accEvent(AccEvent* e) : mRawPtr(e) {}
+
+  template <class Destination>
+  operator Destination*() {
+    if (!mRawPtr) return nullptr;
+
+    return mRawPtr->GetEventGroups() & (1U << Destination::kEventGroup)
+               ? static_cast<Destination*>(mRawPtr)
+               : nullptr;
+  }
+
+ private:
+  AccEvent* mRawPtr;
+};
+
+/**
+ * Return a new xpcom accessible event for the given internal one.
+ */
+already_AddRefed<nsIAccessibleEvent> MakeXPCEvent(AccEvent* aEvent);
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/AccGroupInfo.cpp b/accessible/base/AccGroupInfo.cpp
new file mode 100644
index 0000000000..3b536b1aa4
--- /dev/null
+++ b/accessible/base/AccGroupInfo.cpp
@@ -0,0 +1,397 @@
+/* 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 "AccGroupInfo.h"
+#include "mozilla/a11y/Accessible.h"
+#include "mozilla/a11y/TableAccessible.h"
+
+#include "nsAccUtils.h"
+#include "nsIAccessiblePivot.h"
+
+#include "Pivot.h"
+#include "States.h"
+
+using namespace mozilla::a11y;
+
+static role BaseRole(role aRole);
+
+// This rule finds candidate siblings for compound widget children.
+class CompoundWidgetSiblingRule : public PivotRule {
+ public:
+  CompoundWidgetSiblingRule() = delete;
+  explicit CompoundWidgetSiblingRule(role aRole) : mRole(aRole) {}
+
+  uint16_t Match(Accessible* aAcc) override {
+    // If the acc has a matching role, that's a valid sibling. If the acc is
+    // separator then the group is ended. Return a match for separators with
+    // the assumption that the caller will check for the role of the returned
+    // accessible.
+    const role accRole = aAcc->Role();
+    if (BaseRole(accRole) == mRole || accRole == role::SEPARATOR) {
+      return nsIAccessibleTraversalRule::FILTER_MATCH |
+             nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+    }
+
+    // Ignore generic accessibles, but keep searching through the subtree for
+    // siblings.
+    if (aAcc->IsGeneric()) {
+      return nsIAccessibleTraversalRule::FILTER_IGNORE;
+    }
+
+    return nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+
+ private:
+  role mRole = role::NOTHING;
+};
+
+AccGroupInfo::AccGroupInfo(const Accessible* aItem, role aRole)
+    : mPosInSet(0), mSetSize(0), mParentId(0), mItem(aItem), mRole(aRole) {
+  MOZ_COUNT_CTOR(AccGroupInfo);
+  Update();
+}
+
+void AccGroupInfo::Update() {
+  mParentId = 0;
+
+  Accessible* parent = mItem->GetNonGenericParent();
+  if (!parent) {
+    return;
+  }
+
+  const int32_t level = GetARIAOrDefaultLevel(mItem);
+
+  // Compute position in set.
+  mPosInSet = 1;
+
+  // Search backwards through the tree for candidate siblings.
+  Accessible* candidateSibling = const_cast<Accessible*>(mItem);
+  Pivot pivot{parent};
+  CompoundWidgetSiblingRule widgetSiblingRule{mRole};
+  while ((candidateSibling = pivot.Prev(candidateSibling, widgetSiblingRule)) &&
+         candidateSibling != parent) {
+    // If the sibling is separator then the group is ended.
+    if (candidateSibling->Role() == roles::SEPARATOR) {
+      break;
+    }
+
+    const AccGroupInfo* siblingGroupInfo = candidateSibling->GetGroupInfo();
+    // Skip invisible siblings.
+    // If the sibling has calculated group info, that means it's visible.
+    if (!siblingGroupInfo && candidateSibling->State() & states::INVISIBLE) {
+      continue;
+    }
+
+    // Check if it's hierarchical flatten structure, i.e. if the sibling
+    // level is lesser than this one then group is ended, if the sibling level
+    // is greater than this one then the group is split by some child elements
+    // (group will be continued).
+    const int32_t siblingLevel = GetARIAOrDefaultLevel(candidateSibling);
+    if (siblingLevel < level) {
+      mParentId = candidateSibling->ID();
+      break;
+    }
+
+    // Skip subset.
+    if (siblingLevel > level) {
+      continue;
+    }
+
+    // If the previous item in the group has calculated group information then
+    // build group information for this item based on found one.
+    if (siblingGroupInfo) {
+      mPosInSet += siblingGroupInfo->mPosInSet;
+      mParentId = siblingGroupInfo->mParentId;
+      mSetSize = siblingGroupInfo->mSetSize;
+      return;
+    }
+
+    mPosInSet++;
+  }
+
+  // Compute set size.
+  mSetSize = mPosInSet;
+
+  candidateSibling = const_cast<Accessible*>(mItem);
+  while ((candidateSibling = pivot.Next(candidateSibling, widgetSiblingRule)) &&
+         candidateSibling != parent) {
+    // If the sibling is separator then the group is ended.
+    if (candidateSibling->Role() == roles::SEPARATOR) {
+      break;
+    }
+
+    const AccGroupInfo* siblingGroupInfo = candidateSibling->GetGroupInfo();
+    // Skip invisible siblings.
+    // If the sibling has calculated group info, that means it's visible.
+    if (!siblingGroupInfo && candidateSibling->State() & states::INVISIBLE) {
+      continue;
+    }
+
+    // and check if it's hierarchical flatten structure.
+    const int32_t siblingLevel = GetARIAOrDefaultLevel(candidateSibling);
+    if (siblingLevel < level) {
+      break;
+    }
+
+    // Skip subset.
+    if (siblingLevel > level) {
+      continue;
+    }
+
+    // If the next item in the group has calculated group information then
+    // build group information for this item based on found one.
+    if (siblingGroupInfo) {
+      mParentId = siblingGroupInfo->mParentId;
+      mSetSize = siblingGroupInfo->mSetSize;
+      return;
+    }
+
+    mSetSize++;
+  }
+
+  if (mParentId) {
+    return;
+  }
+
+  roles::Role parentRole = parent->Role();
+  if (ShouldReportRelations(mRole, parentRole)) {
+    mParentId = parent->ID();
+  }
+
+  // ARIA tree and list can be arranged by using ARIA groups to organize levels.
+  if (parentRole != roles::GROUPING) {
+    return;
+  }
+
+  // Way #1 for ARIA tree (not ARIA treegrid): previous sibling of a group is a
+  // parent. In other words the parent of the tree item will be a group and
+  // the previous tree item of the group is a conceptual parent of the tree
+  // item.
+  if (mRole == roles::OUTLINEITEM) {
+    // Find the relevant grandparent of the item. Use that parent as the root
+    // and find the previous outline item sibling within that root.
+    Accessible* grandParent = parent->GetNonGenericParent();
+    MOZ_ASSERT(grandParent);
+    Pivot pivot{grandParent};
+    CompoundWidgetSiblingRule parentSiblingRule{mRole};
+    Accessible* parentPrevSibling = pivot.Prev(parent, widgetSiblingRule);
+    if (parentPrevSibling && parentPrevSibling->Role() == mRole) {
+      mParentId = parentPrevSibling->ID();
+      return;
+    }
+  }
+
+  // Way #2 for ARIA list and tree: group is a child of an item. In other words
+  // the parent of the item will be a group and containing item of the group is
+  // a conceptual parent of the item.
+  if (mRole == roles::LISTITEM || mRole == roles::OUTLINEITEM) {
+    Accessible* grandParent = parent->GetNonGenericParent();
+    if (grandParent && grandParent->Role() == mRole) {
+      mParentId = grandParent->ID();
+    }
+  }
+}
+
+AccGroupInfo* AccGroupInfo::CreateGroupInfo(const Accessible* aAccessible) {
+  mozilla::a11y::role role = aAccessible->Role();
+  if (role != mozilla::a11y::roles::ROW &&
+      role != mozilla::a11y::roles::OUTLINEITEM &&
+      role != mozilla::a11y::roles::OPTION &&
+      role != mozilla::a11y::roles::LISTITEM &&
+      role != mozilla::a11y::roles::MENUITEM &&
+      role != mozilla::a11y::roles::COMBOBOX_OPTION &&
+      role != mozilla::a11y::roles::RICH_OPTION &&
+      role != mozilla::a11y::roles::CHECK_RICH_OPTION &&
+      role != mozilla::a11y::roles::PARENT_MENUITEM &&
+      role != mozilla::a11y::roles::CHECK_MENU_ITEM &&
+      role != mozilla::a11y::roles::RADIO_MENU_ITEM &&
+      role != mozilla::a11y::roles::RADIOBUTTON &&
+      role != mozilla::a11y::roles::PAGETAB &&
+      role != mozilla::a11y::roles::COMMENT) {
+    return nullptr;
+  }
+
+  AccGroupInfo* info = new AccGroupInfo(aAccessible, BaseRole(role));
+  return info;
+}
+
+Accessible* AccGroupInfo::FirstItemOf(const Accessible* aContainer) {
+  // ARIA tree can be arranged by ARIA groups case #1 (previous sibling of a
+  // group is a parent) or by aria-level.
+  a11y::role containerRole = aContainer->Role();
+  Accessible* item = aContainer->NextSibling();
+  if (item) {
+    if (containerRole == roles::OUTLINEITEM &&
+        item->Role() == roles::GROUPING) {
+      item = item->FirstChild();
+    }
+
+    if (item) {
+      AccGroupInfo* itemGroupInfo = item->GetOrCreateGroupInfo();
+      if (itemGroupInfo && itemGroupInfo->ConceptualParent() == aContainer) {
+        return item;
+      }
+    }
+  }
+
+  // ARIA list and tree can be arranged by ARIA groups case #2 (group is
+  // a child of an item).
+  item = aContainer->LastChild();
+  if (!item) return nullptr;
+
+  if (item->Role() == roles::GROUPING &&
+      (containerRole == roles::LISTITEM ||
+       containerRole == roles::OUTLINEITEM)) {
+    item = item->FirstChild();
+    if (item) {
+      AccGroupInfo* itemGroupInfo = item->GetOrCreateGroupInfo();
+      if (itemGroupInfo && itemGroupInfo->ConceptualParent() == aContainer) {
+        return item;
+      }
+    }
+  }
+
+  // Otherwise, it can be a direct child if the container is a list or tree.
+  item = aContainer->FirstChild();
+  if (ShouldReportRelations(item->Role(), containerRole)) return item;
+
+  return nullptr;
+}
+
+uint32_t AccGroupInfo::TotalItemCount(Accessible* aContainer,
+                                      bool* aIsHierarchical) {
+  uint32_t itemCount = 0;
+  switch (aContainer->Role()) {
+    case roles::TABLE:
+      if (auto val = aContainer->GetIntARIAAttr(nsGkAtoms::aria_rowcount)) {
+        if (*val >= 0) {
+          return *val;
+        }
+      }
+      if (TableAccessible* tableAcc = aContainer->AsTable()) {
+        return tableAcc->RowCount();
+      }
+      break;
+    case roles::ROW:
+      if (Accessible* table = nsAccUtils::TableFor(aContainer)) {
+        if (auto val = table->GetIntARIAAttr(nsGkAtoms::aria_colcount)) {
+          if (*val >= 0) {
+            return *val;
+          }
+        }
+        if (TableAccessible* tableAcc = table->AsTable()) {
+          return tableAcc->ColCount();
+        }
+      }
+      break;
+    case roles::OUTLINE:
+    case roles::LIST:
+    case roles::MENUBAR:
+    case roles::MENUPOPUP:
+    case roles::COMBOBOX:
+    case roles::GROUPING:
+    case roles::TREE_TABLE:
+    case roles::COMBOBOX_LIST:
+    case roles::LISTBOX:
+    case roles::DEFINITION_LIST:
+    case roles::EDITCOMBOBOX:
+    case roles::RADIO_GROUP:
+    case roles::PAGETABLIST: {
+      Accessible* childItem = AccGroupInfo::FirstItemOf(aContainer);
+      if (!childItem) {
+        childItem = aContainer->FirstChild();
+        if (childItem && childItem->IsTextLeaf()) {
+          // First child can be a text leaf, check its sibling for an item.
+          childItem = childItem->NextSibling();
+        }
+      }
+
+      if (childItem) {
+        GroupPos groupPos = childItem->GroupPosition();
+        itemCount = groupPos.setSize;
+        if (groupPos.level && aIsHierarchical) {
+          *aIsHierarchical = true;
+        }
+      }
+      break;
+    }
+    default:
+      break;
+  }
+
+  return itemCount;
+}
+
+Accessible* AccGroupInfo::NextItemTo(Accessible* aItem) {
+  AccGroupInfo* groupInfo = aItem->GetOrCreateGroupInfo();
+  if (!groupInfo) return nullptr;
+
+  // If the item in middle of the group then search next item in siblings.
+  if (groupInfo->PosInSet() >= groupInfo->SetSize()) return nullptr;
+
+  Accessible* parent = aItem->Parent();
+  uint32_t childCount = parent->ChildCount();
+  for (uint32_t idx = aItem->IndexInParent() + 1; idx < childCount; idx++) {
+    Accessible* nextItem = parent->ChildAt(idx);
+    AccGroupInfo* nextGroupInfo = nextItem->GetOrCreateGroupInfo();
+    if (nextGroupInfo &&
+        nextGroupInfo->ConceptualParent() == groupInfo->ConceptualParent()) {
+      return nextItem;
+    }
+  }
+
+  MOZ_ASSERT_UNREACHABLE(
+      "Item in the middle of the group but there's no next item!");
+  return nullptr;
+}
+
+size_t AccGroupInfo::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+  // We don't count mParentId or mItem since they (should be) counted
+  // as part of the document.
+  return aMallocSizeOf(this);
+}
+
+bool AccGroupInfo::ShouldReportRelations(role aRole, role aParentRole) {
+  // We only want to report hierarchy-based node relations for items in tree or
+  // list form.  ARIA level/owns relations are always reported.
+  if (aParentRole == roles::OUTLINE && aRole == roles::OUTLINEITEM) return true;
+  if (aParentRole == roles::TREE_TABLE && aRole == roles::ROW) return true;
+  if (aParentRole == roles::LIST && aRole == roles::LISTITEM) return true;
+
+  return false;
+}
+
+int32_t AccGroupInfo::GetARIAOrDefaultLevel(const Accessible* aAccessible) {
+  int32_t level = 0;
+  aAccessible->ARIAGroupPosition(&level, nullptr, nullptr);
+
+  if (level != 0) return level;
+
+  return aAccessible->GetLevel(true);
+}
+
+Accessible* AccGroupInfo::ConceptualParent() const {
+  if (!mParentId) {
+    // The conceptual parent can never be the document, so id 0 means none.
+    return nullptr;
+  }
+  if (Accessible* doc =
+          nsAccUtils::DocumentFor(const_cast<Accessible*>(mItem))) {
+    return nsAccUtils::GetAccessibleByID(doc, mParentId);
+  }
+  return nullptr;
+}
+
+static role BaseRole(role aRole) {
+  if (aRole == roles::CHECK_MENU_ITEM || aRole == roles::PARENT_MENUITEM ||
+      aRole == roles::RADIO_MENU_ITEM) {
+    return roles::MENUITEM;
+  }
+
+  if (aRole == roles::CHECK_RICH_OPTION) {
+    return roles::RICH_OPTION;
+  }
+
+  return aRole;
+}
diff --git a/accessible/base/AccGroupInfo.h b/accessible/base/AccGroupInfo.h
new file mode 100644
index 0000000000..a9afa14b8e
--- /dev/null
+++ b/accessible/base/AccGroupInfo.h
@@ -0,0 +1,101 @@
+/* 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 AccGroupInfo_h_
+#define AccGroupInfo_h_
+
+#include "nsISupportsImpl.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/a11y/Role.h"
+
+namespace mozilla {
+namespace a11y {
+
+class Accessible;
+
+/**
+ * Calculate and store group information.
+ */
+class AccGroupInfo {
+ public:
+  MOZ_COUNTED_DTOR(AccGroupInfo)
+
+  AccGroupInfo() = default;
+  AccGroupInfo(AccGroupInfo&&) = default;
+  AccGroupInfo& operator=(AccGroupInfo&&) = default;
+
+  /**
+   * Return 1-based position in the group.
+   */
+  uint32_t PosInSet() const { return mPosInSet; }
+
+  /**
+   * Return a number of items in the group.
+   */
+  uint32_t SetSize() const { return mSetSize; }
+
+  /**
+   * Return a direct or logical parent of the accessible that this group info is
+   * created for.
+   */
+  Accessible* ConceptualParent() const;
+
+  /**
+   * Update group information.
+   */
+  void Update();
+
+  /**
+   * Create group info.
+   */
+  static AccGroupInfo* CreateGroupInfo(const Accessible* aAccessible);
+
+  /**
+   * Return a first item for the given container.
+   */
+  static Accessible* FirstItemOf(const Accessible* aContainer);
+
+  /**
+   * Return total number of items in container, and if it is has nested
+   * collections.
+   */
+  static uint32_t TotalItemCount(Accessible* aContainer, bool* aIsHierarchical);
+
+  /**
+   * Return next item of the same group to the given item.
+   */
+  static Accessible* NextItemTo(Accessible* aItem);
+
+  size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf);
+
+ protected:
+  AccGroupInfo(const Accessible* aItem, a11y::role aRole);
+
+ private:
+  AccGroupInfo(const AccGroupInfo&) = delete;
+  AccGroupInfo& operator=(const AccGroupInfo&) = delete;
+
+  /**
+   * Return true if the given parent and child roles should have their node
+   * relations reported.
+   */
+  static bool ShouldReportRelations(a11y::role aRole, a11y::role aParentRole);
+
+  /**
+   * Return ARIA level value or the default one if ARIA is missed for the
+   * given accessible.
+   */
+  static int32_t GetARIAOrDefaultLevel(const Accessible* aAccessible);
+
+  uint32_t mPosInSet;
+  uint32_t mSetSize;
+  uint64_t mParentId;
+  const Accessible* mItem;
+  a11y::role mRole;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/AccIterator.cpp b/accessible/base/AccIterator.cpp
new file mode 100644
index 0000000000..badd34c0d5
--- /dev/null
+++ b/accessible/base/AccIterator.cpp
@@ -0,0 +1,360 @@
+/* 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 "AccIterator.h"
+
+#include "AccGroupInfo.h"
+#include "DocAccessible-inl.h"
+#include "LocalAccessible-inl.h"
+#include "XULTreeAccessible.h"
+
+#include "mozilla/a11y/DocAccessibleParent.h"
+#include "mozilla/dom/DocumentOrShadowRoot.h"
+#include "mozilla/dom/HTMLLabelElement.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// AccIterator
+////////////////////////////////////////////////////////////////////////////////
+
+AccIterator::AccIterator(const LocalAccessible* aAccessible,
+                         filters::FilterFuncPtr aFilterFunc)
+    : mFilterFunc(aFilterFunc) {
+  mState = new IteratorState(aAccessible);
+}
+
+AccIterator::~AccIterator() {
+  while (mState) {
+    IteratorState* tmp = mState;
+    mState = tmp->mParentState;
+    delete tmp;
+  }
+}
+
+LocalAccessible* AccIterator::Next() {
+  while (mState) {
+    LocalAccessible* child = mState->mParent->LocalChildAt(mState->mIndex++);
+    if (!child) {
+      IteratorState* tmp = mState;
+      mState = mState->mParentState;
+      delete tmp;
+
+      continue;
+    }
+
+    uint32_t result = mFilterFunc(child);
+    if (result & filters::eMatch) return child;
+
+    if (!(result & filters::eSkipSubtree)) {
+      IteratorState* childState = new IteratorState(child, mState);
+      mState = childState;
+    }
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsAccIterator::IteratorState
+
+AccIterator::IteratorState::IteratorState(const LocalAccessible* aParent,
+                                          IteratorState* mParentState)
+    : mParent(aParent), mIndex(0), mParentState(mParentState) {}
+
+////////////////////////////////////////////////////////////////////////////////
+// RelatedAccIterator
+////////////////////////////////////////////////////////////////////////////////
+
+RelatedAccIterator::RelatedAccIterator(DocAccessible* aDocument,
+                                       nsIContent* aDependentContent,
+                                       nsAtom* aRelAttr)
+    : mDocument(aDocument), mRelAttr(aRelAttr), mProviders(nullptr), mIndex(0) {
+  nsAutoString id;
+  if (aDependentContent->IsElement() &&
+      aDependentContent->AsElement()->GetAttr(nsGkAtoms::id, id)) {
+    mProviders = mDocument->GetRelProviders(aDependentContent->AsElement(), id);
+  }
+}
+
+LocalAccessible* RelatedAccIterator::Next() {
+  if (!mProviders) return nullptr;
+
+  while (mIndex < mProviders->Length()) {
+    const auto& provider = (*mProviders)[mIndex++];
+
+    // Return related accessible for the given attribute.
+    if (provider->mRelAttr == mRelAttr) {
+      LocalAccessible* related = mDocument->GetAccessible(provider->mContent);
+      if (related) {
+        return related;
+      }
+
+      // If the document content is pointed by relation then return the
+      // document itself.
+      if (provider->mContent == mDocument->GetContent()) {
+        return mDocument;
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLLabelIterator
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLLabelIterator::HTMLLabelIterator(DocAccessible* aDocument,
+                                     const LocalAccessible* aAccessible,
+                                     LabelFilter aFilter)
+    : mRelIter(aDocument, aAccessible->GetContent(), nsGkAtoms::_for),
+      mAcc(aAccessible),
+      mLabelFilter(aFilter) {}
+
+bool HTMLLabelIterator::IsLabel(LocalAccessible* aLabel) {
+  dom::HTMLLabelElement* labelEl =
+      dom::HTMLLabelElement::FromNode(aLabel->GetContent());
+  return labelEl && labelEl->GetControl() == mAcc->GetContent();
+}
+
+LocalAccessible* HTMLLabelIterator::Next() {
+  // Get either <label for="[id]"> element which explicitly points to given
+  // element, or <label> ancestor which implicitly point to it.
+  LocalAccessible* label = nullptr;
+  while ((label = mRelIter.Next())) {
+    if (IsLabel(label)) {
+      return label;
+    }
+  }
+
+  // Ignore ancestor label on not widget accessible.
+  if (mLabelFilter == eSkipAncestorLabel || !mAcc->IsWidget()) return nullptr;
+
+  // Go up tree to get a name of ancestor label if there is one (an ancestor
+  // <label> implicitly points to us). Don't go up farther than form or
+  // document.
+  LocalAccessible* walkUp = mAcc->LocalParent();
+  while (walkUp && !walkUp->IsDoc()) {
+    nsIContent* walkUpEl = walkUp->GetContent();
+    if (IsLabel(walkUp) && !walkUpEl->AsElement()->HasAttr(nsGkAtoms::_for)) {
+      mLabelFilter = eSkipAncestorLabel;  // prevent infinite loop
+      return walkUp;
+    }
+
+    if (walkUpEl->IsHTMLElement(nsGkAtoms::form)) break;
+
+    walkUp = walkUp->LocalParent();
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HTMLOutputIterator
+////////////////////////////////////////////////////////////////////////////////
+
+HTMLOutputIterator::HTMLOutputIterator(DocAccessible* aDocument,
+                                       nsIContent* aElement)
+    : mRelIter(aDocument, aElement, nsGkAtoms::_for) {}
+
+LocalAccessible* HTMLOutputIterator::Next() {
+  LocalAccessible* output = nullptr;
+  while ((output = mRelIter.Next())) {
+    if (output->GetContent()->IsHTMLElement(nsGkAtoms::output)) return output;
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// XULLabelIterator
+////////////////////////////////////////////////////////////////////////////////
+
+XULLabelIterator::XULLabelIterator(DocAccessible* aDocument,
+                                   nsIContent* aElement)
+    : mRelIter(aDocument, aElement, nsGkAtoms::control) {}
+
+LocalAccessible* XULLabelIterator::Next() {
+  LocalAccessible* label = nullptr;
+  while ((label = mRelIter.Next())) {
+    if (label->GetContent()->IsXULElement(nsGkAtoms::label)) return label;
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// XULDescriptionIterator
+////////////////////////////////////////////////////////////////////////////////
+
+XULDescriptionIterator::XULDescriptionIterator(DocAccessible* aDocument,
+                                               nsIContent* aElement)
+    : mRelIter(aDocument, aElement, nsGkAtoms::control) {}
+
+LocalAccessible* XULDescriptionIterator::Next() {
+  LocalAccessible* descr = nullptr;
+  while ((descr = mRelIter.Next())) {
+    if (descr->GetContent()->IsXULElement(nsGkAtoms::description)) return descr;
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// IDRefsIterator
+////////////////////////////////////////////////////////////////////////////////
+
+IDRefsIterator::IDRefsIterator(DocAccessible* aDoc, nsIContent* aContent,
+                               nsAtom* aIDRefsAttr)
+    : mContent(aContent), mDoc(aDoc), mCurrIdx(0) {
+  if (mContent->IsElement()) {
+    mContent->AsElement()->GetAttr(aIDRefsAttr, mIDs);
+  }
+}
+
+const nsDependentSubstring IDRefsIterator::NextID() {
+  for (; mCurrIdx < mIDs.Length(); mCurrIdx++) {
+    if (!NS_IsAsciiWhitespace(mIDs[mCurrIdx])) break;
+  }
+
+  if (mCurrIdx >= mIDs.Length()) return nsDependentSubstring();
+
+  nsAString::index_type idStartIdx = mCurrIdx;
+  while (++mCurrIdx < mIDs.Length()) {
+    if (NS_IsAsciiWhitespace(mIDs[mCurrIdx])) break;
+  }
+
+  return Substring(mIDs, idStartIdx, mCurrIdx++ - idStartIdx);
+}
+
+nsIContent* IDRefsIterator::NextElem() {
+  while (true) {
+    const nsDependentSubstring id = NextID();
+    if (id.IsEmpty()) break;
+
+    nsIContent* refContent = GetElem(id);
+    if (refContent) return refContent;
+  }
+
+  return nullptr;
+}
+
+dom::Element* IDRefsIterator::GetElem(nsIContent* aContent,
+                                      const nsAString& aID) {
+  // Get elements in DOM tree by ID attribute if this is an explicit content.
+  // In case of bound element check its anonymous subtree.
+  if (!aContent->IsInNativeAnonymousSubtree()) {
+    dom::DocumentOrShadowRoot* docOrShadowRoot =
+        aContent->GetUncomposedDocOrConnectedShadowRoot();
+    if (docOrShadowRoot) {
+      dom::Element* refElm = docOrShadowRoot->GetElementById(aID);
+      if (refElm) {
+        return refElm;
+      }
+    }
+  }
+  return nullptr;
+}
+
+dom::Element* IDRefsIterator::GetElem(const nsDependentSubstring& aID) {
+  return GetElem(mContent, aID);
+}
+
+LocalAccessible* IDRefsIterator::Next() {
+  nsIContent* nextEl = nullptr;
+  while ((nextEl = NextElem())) {
+    LocalAccessible* acc = mDoc->GetAccessible(nextEl);
+    if (acc) {
+      return acc;
+    }
+  }
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// SingleAccIterator
+////////////////////////////////////////////////////////////////////////////////
+
+Accessible* SingleAccIterator::Next() {
+  Accessible* nextAcc = mAcc;
+  mAcc = nullptr;
+  if (!nextAcc) {
+    return nullptr;
+  }
+
+  MOZ_ASSERT(!nextAcc->IsLocal() || !nextAcc->AsLocal()->IsDefunct(),
+             "Iterator references defunct accessible?");
+  return nextAcc;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ItemIterator
+////////////////////////////////////////////////////////////////////////////////
+
+Accessible* ItemIterator::Next() {
+  if (mContainer) {
+    mAnchor = AccGroupInfo::FirstItemOf(mContainer);
+    mContainer = nullptr;
+    return mAnchor;
+  }
+
+  if (mAnchor) {
+    mAnchor = AccGroupInfo::NextItemTo(mAnchor);
+  }
+
+  return mAnchor;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// XULTreeItemIterator
+////////////////////////////////////////////////////////////////////////////////
+
+XULTreeItemIterator::XULTreeItemIterator(const XULTreeAccessible* aXULTree,
+                                         nsITreeView* aTreeView,
+                                         int32_t aRowIdx)
+    : mXULTree(aXULTree),
+      mTreeView(aTreeView),
+      mRowCount(-1),
+      mContainerLevel(-1),
+      mCurrRowIdx(aRowIdx + 1) {
+  mTreeView->GetRowCount(&mRowCount);
+  if (aRowIdx != -1) mTreeView->GetLevel(aRowIdx, &mContainerLevel);
+}
+
+LocalAccessible* XULTreeItemIterator::Next() {
+  while (mCurrRowIdx < mRowCount) {
+    int32_t level = 0;
+    mTreeView->GetLevel(mCurrRowIdx, &level);
+
+    if (level == mContainerLevel + 1) {
+      return mXULTree->GetTreeItemAccessible(mCurrRowIdx++);
+    }
+
+    if (level <= mContainerLevel) {  // got level up
+      mCurrRowIdx = mRowCount;
+      break;
+    }
+
+    mCurrRowIdx++;
+  }
+
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// RemoteAccIterator
+////////////////////////////////////////////////////////////////////////////////
+
+Accessible* RemoteAccIterator::Next() {
+  while (mIndex < mIds.Length()) {
+    uint64_t id = mIds[mIndex++];
+    Accessible* acc = mDoc->GetAccessible(id);
+    if (acc) {
+      return acc;
+    }
+  }
+  return nullptr;
+}
diff --git a/accessible/base/AccIterator.h b/accessible/base/AccIterator.h
new file mode 100644
index 0000000000..463e3e9d3e
--- /dev/null
+++ b/accessible/base/AccIterator.h
@@ -0,0 +1,328 @@
+/* -*- 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_AccIterator_h__
+#define mozilla_a11y_AccIterator_h__
+
+#include "Filters.h"
+#include "mozilla/a11y/DocAccessible.h"
+#include "nsTArray.h"
+
+#include <memory>
+
+class nsITreeView;
+
+namespace mozilla {
+namespace a11y {
+class DocAccessibleParent;
+
+/**
+ * AccIterable is a basic interface for iterators over accessibles.
+ */
+class AccIterable {
+ public:
+  virtual ~AccIterable() {}
+  virtual Accessible* Next() = 0;
+
+ private:
+  friend class Relation;
+  std::unique_ptr<AccIterable> mNextIter;
+};
+
+/**
+ * Allows to iterate through accessible children or subtree complying with
+ * filter function.
+ */
+class AccIterator : public AccIterable {
+ public:
+  AccIterator(const LocalAccessible* aRoot, filters::FilterFuncPtr aFilterFunc);
+  virtual ~AccIterator();
+
+  /**
+   * Return next accessible complying with filter function. Return the first
+   * accessible for the first time.
+   */
+  virtual LocalAccessible* Next() override;
+
+ private:
+  AccIterator();
+  AccIterator(const AccIterator&);
+  AccIterator& operator=(const AccIterator&);
+
+  struct IteratorState {
+    explicit IteratorState(const LocalAccessible* aParent,
+                           IteratorState* mParentState = nullptr);
+
+    const LocalAccessible* mParent;
+    int32_t mIndex;
+    IteratorState* mParentState;
+  };
+
+  filters::FilterFuncPtr mFilterFunc;
+  IteratorState* mState;
+};
+
+/**
+ * Allows to traverse through related accessibles that are pointing to the given
+ * dependent accessible by relation attribute.
+ */
+class RelatedAccIterator : public AccIterable {
+ public:
+  /**
+   * Constructor.
+   *
+   * @param aDocument         [in] the document accessible the related
+   * &                         accessibles belong to.
+   * @param aDependentContent [in] the content of dependent accessible that
+   *                           relations were requested for
+   * @param aRelAttr          [in] relation attribute that relations are
+   *                           pointed by
+   */
+  RelatedAccIterator(DocAccessible* aDocument, nsIContent* aDependentContent,
+                     nsAtom* aRelAttr);
+
+  virtual ~RelatedAccIterator() {}
+
+  /**
+   * Return next related accessible for the given dependent accessible.
+   */
+  virtual LocalAccessible* Next() override;
+
+ private:
+  RelatedAccIterator();
+  RelatedAccIterator(const RelatedAccIterator&);
+  RelatedAccIterator& operator=(const RelatedAccIterator&);
+
+  DocAccessible* mDocument;
+  nsAtom* mRelAttr;
+  DocAccessible::AttrRelProviders* mProviders;
+  uint32_t mIndex;
+};
+
+/**
+ * Used to iterate through HTML labels associated with the given accessible.
+ */
+class HTMLLabelIterator : public AccIterable {
+ public:
+  enum LabelFilter { eAllLabels, eSkipAncestorLabel };
+
+  HTMLLabelIterator(DocAccessible* aDocument,
+                    const LocalAccessible* aAccessible,
+                    LabelFilter aFilter = eAllLabels);
+
+  virtual ~HTMLLabelIterator() {}
+
+  /**
+   * Return next label accessible associated with the given element.
+   */
+  virtual LocalAccessible* Next() override;
+
+ private:
+  HTMLLabelIterator();
+  HTMLLabelIterator(const HTMLLabelIterator&);
+  HTMLLabelIterator& operator=(const HTMLLabelIterator&);
+
+  bool IsLabel(LocalAccessible* aLabel);
+
+  RelatedAccIterator mRelIter;
+  // XXX: replace it on weak reference (bug 678429), it's safe to use raw
+  // pointer now because iterators life cycle is short.
+  const LocalAccessible* mAcc;
+  LabelFilter mLabelFilter;
+};
+
+/**
+ * Used to iterate through HTML outputs associated with the given element.
+ */
+class HTMLOutputIterator : public AccIterable {
+ public:
+  HTMLOutputIterator(DocAccessible* aDocument, nsIContent* aElement);
+  virtual ~HTMLOutputIterator() {}
+
+  /**
+   * Return next output accessible associated with the given element.
+   */
+  virtual LocalAccessible* Next() override;
+
+ private:
+  HTMLOutputIterator();
+  HTMLOutputIterator(const HTMLOutputIterator&);
+  HTMLOutputIterator& operator=(const HTMLOutputIterator&);
+
+  RelatedAccIterator mRelIter;
+};
+
+/**
+ * Used to iterate through XUL labels associated with the given element.
+ */
+class XULLabelIterator : public AccIterable {
+ public:
+  XULLabelIterator(DocAccessible* aDocument, nsIContent* aElement);
+  virtual ~XULLabelIterator() {}
+
+  /**
+   * Return next label accessible associated with the given element.
+   */
+  virtual LocalAccessible* Next() override;
+
+ private:
+  XULLabelIterator();
+  XULLabelIterator(const XULLabelIterator&);
+  XULLabelIterator& operator=(const XULLabelIterator&);
+
+  RelatedAccIterator mRelIter;
+};
+
+/**
+ * Used to iterate through XUL descriptions associated with the given element.
+ */
+class XULDescriptionIterator : public AccIterable {
+ public:
+  XULDescriptionIterator(DocAccessible* aDocument, nsIContent* aElement);
+  virtual ~XULDescriptionIterator() {}
+
+  /**
+   * Return next description accessible associated with the given element.
+   */
+  virtual LocalAccessible* Next() override;
+
+ private:
+  XULDescriptionIterator();
+  XULDescriptionIterator(const XULDescriptionIterator&);
+  XULDescriptionIterator& operator=(const XULDescriptionIterator&);
+
+  RelatedAccIterator mRelIter;
+};
+
+/**
+ * Used to iterate through IDs, elements or accessibles pointed by IDRefs
+ * attribute. Note, any method used to iterate through IDs, elements, or
+ * accessibles moves iterator to next position.
+ */
+class IDRefsIterator : public AccIterable {
+ public:
+  IDRefsIterator(DocAccessible* aDoc, nsIContent* aContent,
+                 nsAtom* aIDRefsAttr);
+  virtual ~IDRefsIterator() {}
+
+  /**
+   * Return next ID.
+   */
+  const nsDependentSubstring NextID();
+
+  /**
+   * Return next element.
+   */
+  nsIContent* NextElem();
+
+  /**
+   * Return the element with the given ID.
+   */
+  static dom::Element* GetElem(nsIContent* aContent, const nsAString& aID);
+  dom::Element* GetElem(const nsDependentSubstring& aID);
+
+  // AccIterable
+  virtual LocalAccessible* Next() override;
+
+ private:
+  IDRefsIterator();
+  IDRefsIterator(const IDRefsIterator&);
+  IDRefsIterator operator=(const IDRefsIterator&);
+
+  nsString mIDs;
+  nsIContent* mContent;
+  DocAccessible* mDoc;
+  nsAString::index_type mCurrIdx;
+};
+
+/**
+ * Iterator that points to a single accessible returning it on the first call
+ * to Next().
+ */
+class SingleAccIterator : public AccIterable {
+ public:
+  explicit SingleAccIterator(Accessible* aTarget) : mAcc(aTarget) {}
+  virtual ~SingleAccIterator() {}
+
+  virtual Accessible* Next() override;
+
+ private:
+  SingleAccIterator();
+  SingleAccIterator(const SingleAccIterator&);
+  SingleAccIterator& operator=(const SingleAccIterator&);
+
+  Accessible* mAcc;
+};
+
+/**
+ * Used to iterate items of the given item container.
+ */
+class ItemIterator : public AccIterable {
+ public:
+  explicit ItemIterator(const Accessible* aItemContainer)
+      : mContainer(aItemContainer), mAnchor(nullptr) {}
+
+  virtual Accessible* Next() override;
+
+ private:
+  ItemIterator() = delete;
+  ItemIterator(const ItemIterator&) = delete;
+  ItemIterator& operator=(const ItemIterator&) = delete;
+
+  const Accessible* mContainer;
+  Accessible* mAnchor;
+};
+
+/**
+ * Used to iterate through XUL tree items of the same level.
+ */
+class XULTreeItemIterator : public AccIterable {
+ public:
+  XULTreeItemIterator(const XULTreeAccessible* aXULTree, nsITreeView* aTreeView,
+                      int32_t aRowIdx);
+  virtual ~XULTreeItemIterator() {}
+
+  virtual LocalAccessible* Next() override;
+
+ private:
+  XULTreeItemIterator() = delete;
+  XULTreeItemIterator(const XULTreeItemIterator&) = delete;
+  XULTreeItemIterator& operator=(const XULTreeItemIterator&) = delete;
+
+  const XULTreeAccessible* mXULTree;
+  nsITreeView* mTreeView;
+  int32_t mRowCount;
+  int32_t mContainerLevel;
+  int32_t mCurrRowIdx;
+};
+
+/**
+ * Used to iterate through a sequence of RemoteAccessibles supplied as an array
+ * of ids. Such id arrays are included in the RemoteAccessible cache.
+ */
+class RemoteAccIterator : public AccIterable {
+ public:
+  /**
+   * Construct with a reference to an array owned somewhere else; e.g. a
+   * RemoteAccessible cache.
+   */
+  RemoteAccIterator(const nsTArray<uint64_t>& aIds, DocAccessibleParent* aDoc)
+      : mIds(aIds), mDoc(aDoc), mIndex(0) {}
+
+  virtual ~RemoteAccIterator() = default;
+
+  virtual Accessible* Next() override;
+
+ private:
+  const nsTArray<uint64_t>& mIds;
+  DocAccessibleParent* mDoc;
+  uint32_t mIndex;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/AccTypes.h b/accessible/base/AccTypes.h
new file mode 100644
index 0000000000..3e9d88e486
--- /dev/null
+++ b/accessible/base/AccTypes.h
@@ -0,0 +1,98 @@
+/* -*- 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_AccTypes_h
+#define mozilla_a11y_AccTypes_h
+
+namespace mozilla {
+namespace a11y {
+
+/**
+ * Accessible object types. Each accessible class can have own type.
+ */
+enum AccType {
+  /**
+   * This set of types is used for accessible creation, keep them together in
+   * alphabetical order since they are used in switch statement.
+   */
+  eNoType,
+  eHTMLBRType,
+  eHTMLButtonType,
+  eHTMLCanvasType,
+  eHTMLCaptionType,
+  eHTMLCheckboxType,
+  eHTMLComboboxType,
+  eHTMLDateTimeFieldType,
+  eHTMLFileInputType,
+  eHTMLGroupboxType,
+  eHTMLHRType,
+  eHTMLImageMapType,
+  eHTMLLiType,
+  eHTMLSelectListType,
+  eHTMLMediaType,
+  eHTMLRadioButtonType,
+  eHTMLRangeType,
+  eHTMLSpinnerType,
+  eHTMLTableType,
+  eHTMLTableCellType,
+  eHTMLTableRowType,
+  eHTMLTextFieldType,
+  eHTMLTextPasswordFieldType,
+  eHyperTextType,
+  eImageType,
+  eOuterDocType,
+  eTextLeafType,
+
+  /**
+   * Other accessible types.
+   */
+  eApplicationType,
+  eHTMLLinkType,
+  eHTMLOptGroupType,
+  eImageMapType,
+  eMenuPopupType,
+  eProgressType,
+  eRootType,
+  eXULLabelType,
+  eXULListItemType,
+  eXULTabpanelsType,
+  eXULTooltipType,
+  eXULTreeType,
+
+  eLastAccType = eXULTreeType
+};
+
+/**
+ * Generic accessible type, different accessible classes can share the same
+ * type, the same accessible class can have several types.
+ */
+enum AccGenericType {
+  eAlert = 1 << 0,
+  eAutoCompletePopup = 1 << 1,
+  eButton = 1 << 2,
+  eCombobox = 1 << 3,
+  eDocument = 1 << 4,
+  eHyperText = 1 << 5,
+  eLandmark = 1 << 6,
+  eList = 1 << 7,
+  eListControl = 1 << 8,
+  eMenuButton = 1 << 9,
+  eSelect = 1 << 10,
+  eTable = 1 << 11,
+  eTableCell = 1 << 12,
+  eTableRow = 1 << 13,
+  eText = 1 << 14,
+  eNumericValue = 1 << 15,
+  eActionable = 1 << 16,  // This is for remote accessibles
+
+  eLastAccGenericType = eActionable,
+  eAllGenericTypes = (eLastAccGenericType << 1) - 1
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif  // mozilla_a11y_AccTypes_h
diff --git a/accessible/base/Asserts.cpp b/accessible/base/Asserts.cpp
new file mode 100644
index 0000000000..efdd733d9b
--- /dev/null
+++ b/accessible/base/Asserts.cpp
@@ -0,0 +1,29 @@
+/* -*- 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 "nsIAccessibleRelation.h"
+#include "nsIAccessibleRole.h"
+#include "mozilla/a11y/RelationType.h"
+#include "mozilla/a11y/Role.h"
+
+using namespace mozilla::a11y;
+
+#define ROLE(geckoRole, stringRole, ariaRole, atkRole, macRole, macSubrole, \
+             msaaRole, ia2Role, androidClass, nameRule)                     \
+  static_assert(                                                            \
+      static_cast<uint32_t>(roles::geckoRole) ==                            \
+          static_cast<uint32_t>(nsIAccessibleRole::ROLE_##geckoRole),       \
+      "internal and xpcom roles differ!");
+#include "RoleMap.h"
+#undef ROLE
+
+#define RELATIONTYPE(geckoType, stringType, atkType, msaaType, ia2Type)       \
+  static_assert(                                                              \
+      static_cast<uint32_t>(RelationType::geckoType) ==                       \
+          static_cast<uint32_t>(nsIAccessibleRelation::RELATION_##geckoType), \
+      "internal and xpcom relations differ!");
+#include "RelationTypeMap.h"
+#undef RELATIONTYPE
diff --git a/accessible/base/CacheConstants.h b/accessible/base/CacheConstants.h
new file mode 100644
index 0000000000..eb5cc79f5e
--- /dev/null
+++ b/accessible/base/CacheConstants.h
@@ -0,0 +1,255 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set expandtab shiftwidth=2 tabstop=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 _CacheConstants_h_
+#define _CacheConstants_h_
+
+#include "nsGkAtoms.h"
+#include "mozilla/a11y/RelationType.h"
+
+namespace mozilla {
+namespace a11y {
+
+class CacheDomain {
+ public:
+  static constexpr uint64_t NameAndDescription = ((uint64_t)0x1) << 0;
+  static constexpr uint64_t Value = ((uint64_t)0x1) << 1;
+  static constexpr uint64_t Bounds = ((uint64_t)0x1) << 2;
+  static constexpr uint64_t Resolution = ((uint64_t)0x1) << 3;
+  static constexpr uint64_t Text = ((uint64_t)0x1) << 4;
+  static constexpr uint64_t DOMNodeIDAndClass = ((uint64_t)0x1) << 5;
+  static constexpr uint64_t State = ((uint64_t)0x1) << 6;
+  static constexpr uint64_t GroupInfo = ((uint64_t)0x1) << 7;
+  static constexpr uint64_t Actions = ((uint64_t)0x1) << 8;
+  static constexpr uint64_t Style = ((uint64_t)0x1) << 9;
+  static constexpr uint64_t TransformMatrix = ((uint64_t)0x1) << 10;
+  static constexpr uint64_t ScrollPosition = ((uint64_t)0x1) << 11;
+  static constexpr uint64_t Table = ((uint64_t)0x1) << 12;
+  static constexpr uint64_t Spelling = ((uint64_t)0x1) << 13;
+  static constexpr uint64_t Viewport = ((uint64_t)0x1) << 14;
+  static constexpr uint64_t ARIA = ((uint64_t)0x1) << 15;
+  static constexpr uint64_t Relations = ((uint64_t)0x1) << 16;
+#ifdef XP_WIN
+  // Used for MathML.
+  static constexpr uint64_t InnerHTML = ((uint64_t)0x1) << 17;
+#endif
+  static constexpr uint64_t All = ~((uint64_t)0x0);
+};
+
+enum class CacheUpdateType {
+  /*
+   * An initial cache push of a loaded document or inserted subtree.
+   */
+  Initial,
+
+  /*
+   * An incremental cache push of one or more fields that have changed.
+   */
+  Update,
+};
+
+struct RelationData {
+  nsStaticAtom* const mAtom;
+  nsStaticAtom* const mValidTag;
+  RelationType mType;
+  RelationType mReverseType;
+};
+
+/**
+ * This array of RelationData lists our relation types (explicit and reverse)
+ * and the cache attribute atoms that store their targets. Attributes may
+ * describe different kinds of relations, depending on the element they
+ * originate on. For example, an <output> element's `for` attribute describes a
+ * CONTROLLER_FOR relation, while the `for` attribute of a <label> describes a
+ * LABEL_FOR relation. To ensure we process these attributes appropriately,
+ * RelationData.mValidTag contains the atom for the tag this attribute/relation
+ * type pairing is valid on. If the pairing is valid for all tag types, this
+ * field is null.
+ */
+static constexpr RelationData kRelationTypeAtoms[] = {
+    {nsGkAtoms::aria_labelledby, nullptr, RelationType::LABELLED_BY,
+     RelationType::LABEL_FOR},
+    {nsGkAtoms::_for, nsGkAtoms::label, RelationType::LABEL_FOR,
+     RelationType::LABELLED_BY},
+    {nsGkAtoms::aria_controls, nullptr, RelationType::CONTROLLER_FOR,
+     RelationType::CONTROLLED_BY},
+    {nsGkAtoms::_for, nsGkAtoms::output, RelationType::CONTROLLED_BY,
+     RelationType::CONTROLLER_FOR},
+    {nsGkAtoms::aria_describedby, nullptr, RelationType::DESCRIBED_BY,
+     RelationType::DESCRIPTION_FOR},
+    {nsGkAtoms::aria_flowto, nullptr, RelationType::FLOWS_TO,
+     RelationType::FLOWS_FROM},
+    {nsGkAtoms::aria_details, nullptr, RelationType::DETAILS,
+     RelationType::DETAILS_FOR},
+    {nsGkAtoms::aria_errormessage, nullptr, RelationType::ERRORMSG,
+     RelationType::ERRORMSG_FOR},
+};
+
+// The count of numbers needed to serialize an nsRect. This is used when
+// flattening character rects into an array of ints.
+constexpr int32_t kNumbersInRect = 4;
+
+/**
+ * RemoteAccessible cache keys.
+ * Cache keys are nsAtoms, but this is mostly an implementation detail. Rather
+ * than creating new atoms specific to the RemoteAccessible cache, we often
+ * reuse existing atoms which are a reasonably close match for the value we're
+ * caching, though the choices aren't always clear or intuitive. For clarity, we
+ * alias the cache keys to atoms below. Code dealing with the RemoteAccessible
+ * cache should generally use these aliases rather than using nsAtoms directly.
+ * There are two exceptions:
+ * 1. Some ARIA attributes are copied directly from the DOM node, so these
+ * aren't aliased. Specifically,   aria-level, aria-posinset and aria-setsize
+ * are copied as separate cache keys as part of CacheDomain::GroupInfo.
+ * 2. Keys for relations are defined in kRelationTypeAtoms above.
+ */
+class CacheKey {
+ public:
+  // uint64_t, CacheDomain::Actions
+  // As returned by Accessible::AccessKey.
+  static constexpr nsStaticAtom* AccessKey = nsGkAtoms::accesskey;
+  // int32_t, no domain
+  static constexpr nsStaticAtom* AppUnitsPerDevPixel =
+      nsGkAtoms::_moz_device_pixel_ratio;
+  // AccAttributes, CacheDomain::ARIA
+  // ARIA attributes that are exposed as object attributes; i.e. returned in
+  // Accessible::Attributes.
+  static constexpr nsStaticAtom* ARIAAttributes = nsGkAtoms::aria;
+  // nsString, CacheUpdateType::Initial
+  // The ARIA role attribute if the role is unknown or if there are multiple
+  // roles.
+  static constexpr nsStaticAtom* ARIARole = nsGkAtoms::role;
+  // bool, CacheDomain::State
+  // The aria-selected attribute.
+  static constexpr nsStaticAtom* ARIASelected = nsGkAtoms::aria_selected;
+  // nsTArray<uint64_t>, CacheDomain::Table
+  // The explicit headers of an HTML table cell.
+  static constexpr nsStaticAtom* CellHeaders = nsGkAtoms::headers;
+  // int32_t, CacheDomain::Table
+  // The colspan of an HTML table cell.
+  static constexpr nsStaticAtom* ColSpan = nsGkAtoms::colspan;
+  // nsTArray<int32_t, 2>, CacheDomain::Bounds
+  // The offset from an OuterDocAccessible (iframe) to its embedded document.
+  static constexpr nsStaticAtom* CrossDocOffset = nsGkAtoms::crossorigin;
+  // nsAtom, CacheDomain::Style
+  // CSS display; block, inline, etc.
+  static constexpr nsStaticAtom* CSSDisplay = nsGkAtoms::display;
+  // nsAtom, CacheDomain::Style
+  // CSS overflow; e.g. hidden.
+  static constexpr nsStaticAtom* CSSOverflow = nsGkAtoms::overflow;
+  // nsAtom, CacheDomain::Style
+  // CSS position; e.g. fixed.
+  static constexpr nsStaticAtom* CssPosition = nsGkAtoms::position;
+  // nsString, CacheDomain::NameAndDescription
+  static constexpr nsStaticAtom* Description = nsGkAtoms::description;
+  // nsString, CacheDomain::Relations
+  // The "name" DOM attribute.
+  static constexpr nsStaticAtom* DOMName = nsGkAtoms::attributeName;
+  // nsAtom, CacheDomain::DOMNodeIDAndClass
+  // The "class" DOM attribute.
+  static constexpr nsStaticAtom* DOMNodeClass = nsGkAtoms::_class;
+  // nsAtom, CacheDomain::DOMNodeIDAndClass
+  static constexpr nsStaticAtom* DOMNodeID = nsGkAtoms::id;
+  // AccGroupInfo, no domain
+  static constexpr nsStaticAtom* GroupInfo = nsGkAtoms::group;
+  // nsTArray<int32_t>, no domain
+  // As returned by HyperTextAccessibleBase::CachedHyperTextOffsets.
+  static constexpr nsStaticAtom* HyperTextOffsets = nsGkAtoms::offset;
+  // bool, CacheDomain::Actions
+  // Whether this image has a longdesc.
+  static constexpr nsStaticAtom* HasLongdesc = nsGkAtoms::longdesc;
+  // nsString, CacheDomain::NameAndDescription
+  static constexpr nsStaticAtom* HTMLPlaceholder = nsGkAtoms::placeholder;
+#ifdef XP_WIN
+  // nsString, CacheDomain::InnerHTML
+  static constexpr nsStaticAtom* InnerHTML = nsGkAtoms::html;
+#endif
+  // nsAtom, CacheUpdateType::Initial
+  // The type of an <input> element; tel, email, etc.
+  static constexpr nsStaticAtom* InputType = nsGkAtoms::textInputType;
+  // bool, CacheDomain::Bounds
+  // Whether the Accessible is fully clipped.
+  static constexpr nsStaticAtom* IsClipped = nsGkAtoms::clip_rule;
+  // nsString, CacheUpdateType::Initial
+  static constexpr nsStaticAtom* MimeType = nsGkAtoms::headerContentType;
+  // double, CacheDomain::Value
+  static constexpr nsStaticAtom* MaxValue = nsGkAtoms::max;
+  // double, CacheDomain::Value
+  static constexpr nsStaticAtom* MinValue = nsGkAtoms::min;
+  // nsString, CacheDomain::NameAndDescription
+  static constexpr nsStaticAtom* Name = nsGkAtoms::name;
+  // ENameValueFlag, CacheDomain::NameAndDescription
+  // Returned by Accessible::Name.
+  static constexpr nsStaticAtom* NameValueFlag = nsGkAtoms::explicit_name;
+  // double, CacheDomain::Value
+  // The numeric value returned by Accessible::CurValue.
+  static constexpr nsStaticAtom* NumericValue = nsGkAtoms::value;
+  // float, CacheDomain::Style
+  static constexpr nsStaticAtom* Opacity = nsGkAtoms::opacity;
+  // nsTArray<int32_t, 4>, CacheDomain::Bounds
+  // The screen bounds relative  to the parent Accessible
+  // as returned by LocalAccessible::ParentRelativeBounds.
+  static constexpr nsStaticAtom* ParentRelativeBounds =
+      nsGkAtoms::relativeBounds;
+  // nsAtom, CacheUpdateType::Initial
+  // The type of a popup (used for HTML popover).
+  static constexpr nsStaticAtom* PopupType = nsGkAtoms::ispopup;
+  // nsAtom, CacheDomain::Actions
+  static constexpr nsStaticAtom* PrimaryAction = nsGkAtoms::action;
+  // float, no domain
+  // Document resolution.
+  static constexpr nsStaticAtom* Resolution = nsGkAtoms::resolution;
+  // int32_t, CacheDomain::Table
+  // The rowspan of an HTML table cell.
+  static constexpr nsStaticAtom* RowSpan = nsGkAtoms::rowspan;
+  // nsTArray<int32_t, 2>, CacheDomain::ScrollPosition
+  static constexpr nsStaticAtom* ScrollPosition = nsGkAtoms::scrollPosition;
+  // nsTArray<int32_t>, CacheDomain::Spelling | CacheDomain::Text
+  // The offsets of spelling errors.
+  static constexpr nsStaticAtom* SpellingErrors = nsGkAtoms::spelling;
+  // nsString, CacheDomain::Value
+  // The src URL of images.
+  static constexpr nsStaticAtom* SrcURL = nsGkAtoms::src;
+  // uint64_t, CacheDomain::State
+  // As returned by Accessible::State.
+  static constexpr nsStaticAtom* State = nsGkAtoms::state;
+  // double, CacheDomain::Value
+  // The value step returned by Accessible::Step.
+  static constexpr nsStaticAtom* Step = nsGkAtoms::step;
+  // nsAtom, CacheUpdateType::Initial
+  // The tag name of the element.
+  static constexpr nsStaticAtom* TagName = nsGkAtoms::tag;
+  // bool, CacheDomain::Table
+  // Whether this is a layout table.
+  static constexpr nsStaticAtom* TableLayoutGuess = nsGkAtoms::layout_guess;
+  // nsString, CacheDomain::Text
+  // The text of TextLeafAccessibles.
+  static constexpr nsStaticAtom* Text = nsGkAtoms::text;
+  // AccAttributes, CacheDomain::Text
+  // Text attributes; font, etc.
+  static constexpr nsStaticAtom* TextAttributes = nsGkAtoms::style;
+  // nsTArray<int32_t, 4 * n>, CacheDomain::Text | CacheDomain::Bounds
+  // The bounds of each character in a text leaf.
+  static constexpr nsStaticAtom* TextBounds = nsGkAtoms::characterData;
+  // nsTArray<int32_t>, CacheDomain::Text | CacheDomain::Bounds
+  // The text offsets where new lines start.
+  static constexpr nsStaticAtom* TextLineStarts = nsGkAtoms::line;
+  // nsString, CacheDomain::Value
+  // The textual value returned by Accessible::Value (as opposed to
+  // the numeric value returned by Accessible::CurValue).
+  static constexpr nsStaticAtom* TextValue = nsGkAtoms::aria_valuetext;
+  // gfx::Matrix4x4, CacheDomain::TransformMatrix
+  static constexpr nsStaticAtom* TransformMatrix = nsGkAtoms::transform;
+  // nsTArray<uint64_t>, CacheDomain::Viewport
+  // The list of Accessibles in the viewport used for hit testing and on-screen
+  // determination.
+  static constexpr nsStaticAtom* Viewport = nsGkAtoms::viewport;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/CachedTableAccessible.cpp b/accessible/base/CachedTableAccessible.cpp
new file mode 100644
index 0000000000..e780bd2a89
--- /dev/null
+++ b/accessible/base/CachedTableAccessible.cpp
@@ -0,0 +1,429 @@
+/* -*- 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 "CachedTableAccessible.h"
+
+#include "AccIterator.h"
+#include "HTMLTableAccessible.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "nsAccUtils.h"
+#include "nsIAccessiblePivot.h"
+#include "Pivot.h"
+#include "RemoteAccessible.h"
+
+namespace mozilla::a11y {
+
+// Used to search for table descendants relevant to table structure.
+class TablePartRule : public PivotRule {
+ public:
+  virtual uint16_t Match(Accessible* aAcc) override {
+    role accRole = aAcc->Role();
+    if (accRole == roles::CAPTION || aAcc->IsTableCell()) {
+      return nsIAccessibleTraversalRule::FILTER_MATCH |
+             nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+    }
+    if (aAcc->IsTableRow()) {
+      return nsIAccessibleTraversalRule::FILTER_MATCH;
+    }
+    if (aAcc->IsTable() ||
+        // Generic containers.
+        accRole == roles::TEXT || accRole == roles::TEXT_CONTAINER ||
+        accRole == roles::SECTION ||
+        // Row groups.
+        accRole == roles::GROUPING) {
+      // Walk inside these, but don't match them.
+      return nsIAccessibleTraversalRule::FILTER_IGNORE;
+    }
+    return nsIAccessibleTraversalRule::FILTER_IGNORE |
+           nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+};
+
+// The Accessible* keys should only be used for lookup. They should not be
+// dereferenced.
+using CachedTablesMap = nsTHashMap<Accessible*, CachedTableAccessible>;
+// We use a global map rather than a map in each document for three reasons:
+// 1. We don't have a common base class for local and remote documents.
+// 2. It avoids wasting memory in a document that doesn't have any tables.
+// 3. It allows the cache management to be encapsulated here in
+// CachedTableAccessible.
+static StaticAutoPtr<CachedTablesMap> sCachedTables;
+
+/* static */
+CachedTableAccessible* CachedTableAccessible::GetFrom(Accessible* aAcc) {
+  MOZ_ASSERT(aAcc->IsTable());
+  if (!sCachedTables) {
+    sCachedTables = new CachedTablesMap();
+    ClearOnShutdown(&sCachedTables);
+  }
+  return &sCachedTables->LookupOrInsertWith(
+      aAcc, [&] { return CachedTableAccessible(aAcc); });
+}
+
+/* static */
+void CachedTableAccessible::Invalidate(Accessible* aAcc) {
+  if (!sCachedTables) {
+    return;
+  }
+
+  if (Accessible* table = nsAccUtils::TableFor(aAcc)) {
+    // Destroy the instance (if any). We'll create a new one the next time it
+    // is requested.
+    sCachedTables->Remove(table);
+  }
+}
+
+CachedTableAccessible::CachedTableAccessible(Accessible* aAcc) : mAcc(aAcc) {
+  MOZ_ASSERT(mAcc);
+  // Build the cache. The cache can only be built once per instance. When it's
+  // invalidated, we just throw away the instance and create a new one when
+  // the cache is next needed.
+  int32_t rowIdx = -1;
+  uint32_t colIdx = 0;
+  // Maps a column index to the cell index of its previous implicit column
+  // header.
+  nsTHashMap<uint32_t, uint32_t> prevColHeaders;
+  Pivot pivot(mAcc);
+  TablePartRule rule;
+  for (Accessible* part = pivot.Next(mAcc, rule); part;
+       part = pivot.Next(part, rule)) {
+    role partRole = part->Role();
+    if (partRole == roles::CAPTION) {
+      // If there are multiple captions, use the first.
+      if (!mCaptionAccID) {
+        mCaptionAccID = part->ID();
+      }
+      continue;
+    }
+    if (part->IsTableRow()) {
+      ++rowIdx;
+      colIdx = 0;
+      // This might be an empty row, so ensure a row here, as our row count is
+      // based on the length of mRowColToCellIdx.
+      EnsureRow(rowIdx);
+      continue;
+    }
+    MOZ_ASSERT(part->IsTableCell());
+    if (rowIdx == -1) {
+      // We haven't created a row yet, so this cell must be outside a row.
+      continue;
+    }
+    // Check for a cell spanning multiple rows which already occupies this
+    // position. Keep incrementing until we find a vacant position.
+    for (;;) {
+      EnsureRowCol(rowIdx, colIdx);
+      if (mRowColToCellIdx[rowIdx][colIdx] == kNoCellIdx) {
+        // This position is not occupied.
+        break;
+      }
+      // This position is occupied.
+      ++colIdx;
+    }
+    // Create the cell.
+    uint32_t cellIdx = mCells.Length();
+    auto prevColHeader = prevColHeaders.MaybeGet(colIdx);
+    auto cell = mCells.AppendElement(
+        CachedTableCellAccessible(part->ID(), part, rowIdx, colIdx,
+                                  prevColHeader ? *prevColHeader : kNoCellIdx));
+    mAccToCellIdx.InsertOrUpdate(part, cellIdx);
+    // Update our row/col map.
+    // This cell might span multiple rows and/or columns. In that case, we need
+    // to occupy multiple coordinates in the row/col map.
+    uint32_t lastRowForCell =
+        static_cast<uint32_t>(rowIdx) + cell->RowExtent() - 1;
+    MOZ_ASSERT(lastRowForCell >= static_cast<uint32_t>(rowIdx));
+    uint32_t lastColForCell = colIdx + cell->ColExtent() - 1;
+    MOZ_ASSERT(lastColForCell >= colIdx);
+    for (uint32_t spannedRow = static_cast<uint32_t>(rowIdx);
+         spannedRow <= lastRowForCell; ++spannedRow) {
+      for (uint32_t spannedCol = colIdx; spannedCol <= lastColForCell;
+           ++spannedCol) {
+        EnsureRowCol(spannedRow, spannedCol);
+        auto& rowCol = mRowColToCellIdx[spannedRow][spannedCol];
+        // If a cell already occupies this position, it overlaps with this one;
+        // e.g. r1..2c2 and r2c1..2. In that case, we want to prefer the first
+        // cell.
+        if (rowCol == kNoCellIdx) {
+          rowCol = cellIdx;
+        }
+      }
+    }
+    if (partRole == roles::COLUMNHEADER) {
+      for (uint32_t spannedCol = colIdx; spannedCol <= lastColForCell;
+           ++spannedCol) {
+        prevColHeaders.InsertOrUpdate(spannedCol, cellIdx);
+      }
+    }
+    // Increment for the next cell.
+    colIdx = lastColForCell + 1;
+  }
+}
+
+void CachedTableAccessible::EnsureRow(uint32_t aRowIdx) {
+  if (mRowColToCellIdx.Length() <= aRowIdx) {
+    mRowColToCellIdx.AppendElements(aRowIdx - mRowColToCellIdx.Length() + 1);
+  }
+  MOZ_ASSERT(mRowColToCellIdx.Length() > aRowIdx);
+}
+
+void CachedTableAccessible::EnsureRowCol(uint32_t aRowIdx, uint32_t aColIdx) {
+  EnsureRow(aRowIdx);
+  auto& row = mRowColToCellIdx[aRowIdx];
+  if (mColCount <= aColIdx) {
+    mColCount = aColIdx + 1;
+  }
+  row.SetCapacity(mColCount);
+  for (uint32_t newCol = row.Length(); newCol <= aColIdx; ++newCol) {
+    // An entry doesn't yet exist for this column in this row.
+    row.AppendElement(kNoCellIdx);
+  }
+  MOZ_ASSERT(row.Length() > aColIdx);
+}
+
+Accessible* CachedTableAccessible::Caption() const {
+  if (mCaptionAccID) {
+    Accessible* caption = nsAccUtils::GetAccessibleByID(
+        nsAccUtils::DocumentFor(mAcc), mCaptionAccID);
+    MOZ_ASSERT(caption, "Dead caption Accessible!");
+    MOZ_ASSERT(caption->Role() == roles::CAPTION, "Caption has wrong role");
+    return caption;
+  }
+  return nullptr;
+}
+
+void CachedTableAccessible::Summary(nsString& aSummary) {
+  if (Caption()) {
+    // If there's a caption, we map caption to Name and summary to Description.
+    mAcc->Description(aSummary);
+  } else {
+    // If there's no caption, we map summary to Name.
+    mAcc->Name(aSummary);
+  }
+}
+
+Accessible* CachedTableAccessible::CellAt(uint32_t aRowIdx, uint32_t aColIdx) {
+  int32_t cellIdx = CellIndexAt(aRowIdx, aColIdx);
+  if (cellIdx == -1) {
+    return nullptr;
+  }
+  return mCells[cellIdx].Acc(mAcc);
+}
+
+bool CachedTableAccessible::IsProbablyLayoutTable() {
+  if (RemoteAccessible* remoteAcc = mAcc->AsRemote()) {
+    return remoteAcc->TableIsProbablyForLayout();
+  }
+  if (auto* localTable = HTMLTableAccessible::GetFrom(mAcc->AsLocal())) {
+    return localTable->IsProbablyLayoutTable();
+  }
+  return false;
+}
+
+/* static */
+CachedTableCellAccessible* CachedTableCellAccessible::GetFrom(
+    Accessible* aAcc) {
+  MOZ_ASSERT(aAcc->IsTableCell());
+  for (Accessible* parent = aAcc; parent; parent = parent->Parent()) {
+    if (parent->IsDoc()) {
+      break;  // Never cross document boundaries.
+    }
+    TableAccessible* table = parent->AsTable();
+    if (!table) {
+      continue;
+    }
+    if (LocalAccessible* local = parent->AsLocal()) {
+      nsIContent* content = local->GetContent();
+      if (content && content->IsXULElement()) {
+        // XUL tables don't use CachedTableAccessible.
+        break;
+      }
+    }
+    // Non-XUL tables only use CachedTableAccessible.
+    auto* cachedTable = static_cast<CachedTableAccessible*>(table);
+    if (auto cellIdx = cachedTable->mAccToCellIdx.Lookup(aAcc)) {
+      return &cachedTable->mCells[*cellIdx];
+    }
+    // We found a table, but it doesn't know about this cell. This can happen
+    // if a cell is outside of a row due to authoring error. We must not search
+    // ancestor tables, since this cell's data is not valid there and vice
+    // versa.
+    break;
+  }
+  return nullptr;
+}
+
+Accessible* CachedTableCellAccessible::Acc(Accessible* aTableAcc) const {
+  Accessible* acc =
+      nsAccUtils::GetAccessibleByID(nsAccUtils::DocumentFor(aTableAcc), mAccID);
+  MOZ_DIAGNOSTIC_ASSERT(acc == mAcc, "Cell's cached mAcc is dead!");
+  return acc;
+}
+
+TableAccessible* CachedTableCellAccessible::Table() const {
+  for (const Accessible* acc = mAcc; acc; acc = acc->Parent()) {
+    // Since the caller has this cell, the table is already created, so it's
+    // okay to ignore the const restriction here.
+    if (TableAccessible* table = const_cast<Accessible*>(acc)->AsTable()) {
+      return table;
+    }
+  }
+  return nullptr;
+}
+
+uint32_t CachedTableCellAccessible::ColExtent() const {
+  if (RemoteAccessible* remoteAcc = mAcc->AsRemote()) {
+    if (remoteAcc->mCachedFields) {
+      if (auto colSpan = remoteAcc->mCachedFields->GetAttribute<int32_t>(
+              CacheKey::ColSpan)) {
+        MOZ_ASSERT(*colSpan > 0);
+        return *colSpan;
+      }
+    }
+  } else if (auto* cell = HTMLTableCellAccessible::GetFrom(mAcc->AsLocal())) {
+    // For HTML table cells, we must use the HTMLTableCellAccessible
+    // GetColExtent method rather than using the DOM attributes directly.
+    // This is because of things like rowspan="0" which depend on knowing
+    // about thead, tbody, etc., which is info we don't have in the a11y tree.
+    uint32_t colExtent = cell->ColExtent();
+    MOZ_ASSERT(colExtent > 0);
+    if (colExtent > 0) {
+      return colExtent;
+    }
+  }
+  return 1;
+}
+
+uint32_t CachedTableCellAccessible::RowExtent() const {
+  if (RemoteAccessible* remoteAcc = mAcc->AsRemote()) {
+    if (remoteAcc->mCachedFields) {
+      if (auto rowSpan = remoteAcc->mCachedFields->GetAttribute<int32_t>(
+              CacheKey::RowSpan)) {
+        MOZ_ASSERT(*rowSpan > 0);
+        return *rowSpan;
+      }
+    }
+  } else if (auto* cell = HTMLTableCellAccessible::GetFrom(mAcc->AsLocal())) {
+    // For HTML table cells, we must use the HTMLTableCellAccessible
+    // GetRowExtent method rather than using the DOM attributes directly.
+    // This is because of things like rowspan="0" which depend on knowing
+    // about thead, tbody, etc., which is info we don't have in the a11y tree.
+    uint32_t rowExtent = cell->RowExtent();
+    MOZ_ASSERT(rowExtent > 0);
+    if (rowExtent > 0) {
+      return rowExtent;
+    }
+  }
+  return 1;
+}
+
+UniquePtr<AccIterable> CachedTableCellAccessible::GetExplicitHeadersIterator() {
+  if (RemoteAccessible* remoteAcc = mAcc->AsRemote()) {
+    if (remoteAcc->mCachedFields) {
+      if (auto headers =
+              remoteAcc->mCachedFields->GetAttribute<nsTArray<uint64_t>>(
+                  CacheKey::CellHeaders)) {
+        return MakeUnique<RemoteAccIterator>(*headers, remoteAcc->Document());
+      }
+    }
+  } else if (LocalAccessible* localAcc = mAcc->AsLocal()) {
+    return MakeUnique<IDRefsIterator>(
+        localAcc->Document(), localAcc->GetContent(), nsGkAtoms::headers);
+  }
+  return nullptr;
+}
+
+void CachedTableCellAccessible::ColHeaderCells(nsTArray<Accessible*>* aCells) {
+  auto* table = static_cast<CachedTableAccessible*>(Table());
+  if (!table) {
+    return;
+  }
+  if (auto iter = GetExplicitHeadersIterator()) {
+    while (Accessible* header = iter->Next()) {
+      role headerRole = header->Role();
+      if (headerRole == roles::COLUMNHEADER) {
+        aCells->AppendElement(header);
+      } else if (headerRole != roles::ROWHEADER) {
+        // Treat this cell as a column header only if it's in the same column.
+        if (auto cellIdx = table->mAccToCellIdx.Lookup(header)) {
+          CachedTableCellAccessible& cell = table->mCells[*cellIdx];
+          if (cell.ColIdx() == ColIdx()) {
+            aCells->AppendElement(header);
+          }
+        }
+      }
+    }
+    if (!aCells->IsEmpty()) {
+      return;
+    }
+  }
+  Accessible* doc = nsAccUtils::DocumentFor(table->AsAccessible());
+  // Each cell stores its previous implicit column header, effectively forming a
+  // linked list. We traverse that to get all the headers.
+  CachedTableCellAccessible* cell = this;
+  for (;;) {
+    if (cell->mPrevColHeaderCellIdx == kNoCellIdx) {
+      break;  // No more headers.
+    }
+    cell = &table->mCells[cell->mPrevColHeaderCellIdx];
+    Accessible* cellAcc = nsAccUtils::GetAccessibleByID(doc, cell->mAccID);
+    aCells->AppendElement(cellAcc);
+  }
+}
+
+void CachedTableCellAccessible::RowHeaderCells(nsTArray<Accessible*>* aCells) {
+  auto* table = static_cast<CachedTableAccessible*>(Table());
+  if (!table) {
+    return;
+  }
+  if (auto iter = GetExplicitHeadersIterator()) {
+    while (Accessible* header = iter->Next()) {
+      role headerRole = header->Role();
+      if (headerRole == roles::ROWHEADER) {
+        aCells->AppendElement(header);
+      } else if (headerRole != roles::COLUMNHEADER) {
+        // Treat this cell as a row header only if it's in the same row.
+        if (auto cellIdx = table->mAccToCellIdx.Lookup(header)) {
+          CachedTableCellAccessible& cell = table->mCells[*cellIdx];
+          if (cell.RowIdx() == RowIdx()) {
+            aCells->AppendElement(header);
+          }
+        }
+      }
+    }
+    if (!aCells->IsEmpty()) {
+      return;
+    }
+  }
+  Accessible* doc = nsAccUtils::DocumentFor(table->AsAccessible());
+  // We don't cache implicit row headers because there are usually not that many
+  // cells per row. Get all the row headers on the row before this cell.
+  uint32_t row = RowIdx();
+  uint32_t thisCol = ColIdx();
+  for (uint32_t col = thisCol - 1; col < thisCol; --col) {
+    int32_t cellIdx = table->CellIndexAt(row, col);
+    if (cellIdx == -1) {
+      continue;
+    }
+    CachedTableCellAccessible& cell = table->mCells[cellIdx];
+    Accessible* cellAcc = nsAccUtils::GetAccessibleByID(doc, cell.mAccID);
+    MOZ_ASSERT(cellAcc);
+    // cell might span multiple columns. We don't want to visit it multiple
+    // times, so ensure col is set to cell's starting column.
+    col = cell.ColIdx();
+    if (cellAcc->Role() != roles::ROWHEADER) {
+      continue;
+    }
+    aCells->AppendElement(cellAcc);
+  }
+}
+
+bool CachedTableCellAccessible::Selected() {
+  return mAcc->State() & states::SELECTED;
+}
+
+}  // namespace mozilla::a11y
diff --git a/accessible/base/CachedTableAccessible.h b/accessible/base/CachedTableAccessible.h
new file mode 100644
index 0000000000..7803343070
--- /dev/null
+++ b/accessible/base/CachedTableAccessible.h
@@ -0,0 +1,294 @@
+/* -*- 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 CACHED_TABLE_ACCESSIBLE_H
+#define CACHED_TABLE_ACCESSIBLE_H
+
+#include "mozilla/a11y/TableAccessible.h"
+#include "mozilla/a11y/TableCellAccessible.h"
+#include "mozilla/UniquePtr.h"
+#include "nsTHashMap.h"
+
+namespace mozilla::a11y {
+
+const uint32_t kNoCellIdx = UINT32_MAX;
+
+class AccIterable;
+
+class CachedTableAccessible;
+
+class CachedTableCellAccessible final : public TableCellAccessible {
+ public:
+  static CachedTableCellAccessible* GetFrom(Accessible* aAcc);
+
+  virtual TableAccessible* Table() const override;
+
+  virtual uint32_t ColIdx() const override {
+    return static_cast<int32_t>(mColIdx);
+  }
+
+  virtual uint32_t RowIdx() const override {
+    return static_cast<int32_t>(mRowIdx);
+  }
+
+  virtual uint32_t ColExtent() const override;
+
+  virtual uint32_t RowExtent() const override;
+
+  virtual void ColHeaderCells(nsTArray<Accessible*>* aCells) override;
+
+  virtual void RowHeaderCells(nsTArray<Accessible*>* aCells) override;
+
+  virtual bool Selected() override;
+
+ private:
+  CachedTableCellAccessible(uint64_t aAccID, Accessible* aAcc, uint32_t aRowIdx,
+                            uint32_t aColIdx, uint32_t aPrevColHeaderCellIdx)
+      : mAccID(aAccID),
+        mAcc(aAcc),
+        mRowIdx(aRowIdx),
+        mColIdx(aColIdx),
+        mPrevColHeaderCellIdx(aPrevColHeaderCellIdx) {}
+
+  // Get the Accessible for this table cell given its ancestor table Accessible,
+  // verifying that the Accessible is valid.
+  Accessible* Acc(Accessible* aTableAcc) const;
+
+  UniquePtr<AccIterable> GetExplicitHeadersIterator();
+
+  uint64_t mAccID;
+  // CachedTableAccessible methods which fetch a cell should retrieve the
+  // Accessible using Acc() rather than using mAcc. We need mAcc for some
+  // methods because we can't fetch a document by id. It's okay to use mAcc in
+  // these methods because the caller has to hold the Accessible in order to
+  // call them.
+  Accessible* mAcc;
+  uint32_t mRowIdx;
+  uint32_t mColIdx;
+  // The cell index of the previous implicit column header.
+  uint32_t mPrevColHeaderCellIdx;
+  friend class CachedTableAccessible;
+};
+
+/**
+ * TableAccessible implementation which builds and queries a cache.
+ */
+class CachedTableAccessible final : public TableAccessible {
+ public:
+  static CachedTableAccessible* GetFrom(Accessible* aAcc);
+
+  /**
+   * This must be called whenever a table is destroyed or the structure of a
+   * table changes; e.g. cells wer added or removed. It can be called with
+   * either a table or a cell.
+   */
+  static void Invalidate(Accessible* aAcc);
+
+  virtual Accessible* Caption() const override;
+  virtual void Summary(nsString& aSummary) override;
+
+  virtual uint32_t ColCount() const override { return mColCount; }
+
+  virtual uint32_t RowCount() override { return mRowColToCellIdx.Length(); }
+
+  virtual int32_t ColIndexAt(uint32_t aCellIdx) override {
+    if (aCellIdx < mCells.Length()) {
+      return static_cast<int32_t>(mCells[aCellIdx].mColIdx);
+    }
+    return -1;
+  }
+
+  virtual int32_t RowIndexAt(uint32_t aCellIdx) override {
+    if (aCellIdx < mCells.Length()) {
+      return static_cast<int32_t>(mCells[aCellIdx].mRowIdx);
+    }
+    return -1;
+  }
+
+  virtual void RowAndColIndicesAt(uint32_t aCellIdx, int32_t* aRowIdx,
+                                  int32_t* aColIdx) override {
+    if (aCellIdx < mCells.Length()) {
+      CachedTableCellAccessible& cell = mCells[aCellIdx];
+      *aRowIdx = static_cast<int32_t>(cell.mRowIdx);
+      *aColIdx = static_cast<int32_t>(cell.mColIdx);
+      return;
+    }
+    *aRowIdx = -1;
+    *aColIdx = -1;
+  }
+
+  virtual uint32_t ColExtentAt(uint32_t aRowIdx, uint32_t aColIdx) override {
+    int32_t cellIdx = CellIndexAt(aRowIdx, aColIdx);
+    if (cellIdx == -1) {
+      return 0;
+    }
+    // Verify that the cell's Accessible is valid.
+    mCells[cellIdx].Acc(mAcc);
+    return mCells[cellIdx].ColExtent();
+  }
+
+  virtual uint32_t RowExtentAt(uint32_t aRowIdx, uint32_t aColIdx) override {
+    int32_t cellIdx = CellIndexAt(aRowIdx, aColIdx);
+    if (cellIdx == -1) {
+      return 0;
+    }
+    // Verify that the cell's Accessible is valid.
+    mCells[cellIdx].Acc(mAcc);
+    return mCells[cellIdx].RowExtent();
+  }
+
+  virtual int32_t CellIndexAt(uint32_t aRowIdx, uint32_t aColIdx) override {
+    if (aRowIdx < mRowColToCellIdx.Length()) {
+      auto& row = mRowColToCellIdx[aRowIdx];
+      if (aColIdx < row.Length()) {
+        uint32_t cellIdx = row[aColIdx];
+        if (cellIdx != kNoCellIdx) {
+          return static_cast<int32_t>(cellIdx);
+        }
+      }
+    }
+    return -1;
+  }
+
+  virtual Accessible* CellAt(uint32_t aRowIdx, uint32_t aColIdx) override;
+
+  virtual bool IsColSelected(uint32_t aColIdx) override {
+    bool selected = false;
+    for (uint32_t row = 0; row < RowCount(); ++row) {
+      selected = IsCellSelected(row, aColIdx);
+      if (!selected) {
+        break;
+      }
+    }
+    return selected;
+  }
+
+  virtual bool IsRowSelected(uint32_t aRowIdx) override {
+    bool selected = false;
+    for (uint32_t col = 0; col < mColCount; ++col) {
+      selected = IsCellSelected(aRowIdx, col);
+      if (!selected) {
+        break;
+      }
+    }
+    return selected;
+  }
+
+  virtual bool IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx) override {
+    int32_t cellIdx = CellIndexAt(aRowIdx, aColIdx);
+    if (cellIdx == -1) {
+      return false;
+    }
+    // Verify that the cell's Accessible is valid.
+    mCells[cellIdx].Acc(mAcc);
+    return mCells[cellIdx].Selected();
+  }
+
+  virtual uint32_t SelectedCellCount() override {
+    uint32_t count = 0;
+    for (auto& cell : mCells) {
+      // Verify that the cell's Accessible is valid.
+      cell.Acc(mAcc);
+      if (cell.Selected()) {
+        ++count;
+      }
+    }
+    return count;
+  }
+
+  virtual uint32_t SelectedColCount() override {
+    uint32_t count = 0;
+    for (uint32_t col = 0; col < mColCount; ++col) {
+      if (IsColSelected(col)) {
+        ++count;
+      }
+    }
+    return count;
+  }
+
+  virtual uint32_t SelectedRowCount() override {
+    uint32_t count = 0;
+    for (uint32_t row = 0; row < RowCount(); ++row) {
+      if (IsRowSelected(row)) {
+        ++count;
+      }
+    }
+    return count;
+  }
+
+  virtual void SelectedCells(nsTArray<Accessible*>* aCells) override {
+    for (auto& cell : mCells) {
+      // Verify that the cell's Accessible is valid.
+      Accessible* acc = cell.Acc(mAcc);
+      if (cell.Selected()) {
+        aCells->AppendElement(acc);
+      }
+    }
+  }
+
+  virtual void SelectedCellIndices(nsTArray<uint32_t>* aCells) override {
+    for (uint32_t idx = 0; idx < mCells.Length(); ++idx) {
+      CachedTableCellAccessible& cell = mCells[idx];
+      // Verify that the cell's Accessible is valid.
+      cell.Acc(mAcc);
+      if (cell.Selected()) {
+        aCells->AppendElement(idx);
+      }
+    }
+  }
+
+  virtual void SelectedColIndices(nsTArray<uint32_t>* aCols) override {
+    for (uint32_t col = 0; col < mColCount; ++col) {
+      if (IsColSelected(col)) {
+        aCols->AppendElement(col);
+      }
+    }
+  }
+
+  virtual void SelectedRowIndices(nsTArray<uint32_t>* aRows) override {
+    for (uint32_t row = 0; row < RowCount(); ++row) {
+      if (IsRowSelected(row)) {
+        aRows->AppendElement(row);
+      }
+    }
+  }
+
+  virtual Accessible* AsAccessible() override { return mAcc; }
+
+  virtual bool IsProbablyLayoutTable() override;
+
+ private:
+  explicit CachedTableAccessible(Accessible* aAcc);
+
+  // Ensure that the given row exists in our data structure, creating array
+  // elements as needed.
+  void EnsureRow(uint32_t aRowIdx);
+
+  // Ensure that the given row and column coordinate exists in our data
+  // structure, creating array elements as needed. A newly created coordinate
+  // will be set to kNoCellIdx.
+  void EnsureRowCol(uint32_t aRowIdx, uint32_t aColIdx);
+
+  Accessible* mAcc;  // The table Accessible.
+  // We track the column count because it might not be uniform across rows in
+  // malformed tables.
+  uint32_t mColCount = 0;
+  // An array of cell instances. A cell index is an index into this array.
+  nsTArray<CachedTableCellAccessible> mCells;
+  // Maps row and column coordinates to cell indices.
+  nsTArray<nsTArray<uint32_t>> mRowColToCellIdx;
+  // Maps Accessibles to cell indexes to facilitate retrieval of a cell
+  // instance from a cell Accessible. The Accessible* keys should only be used
+  // for lookup. They should not be dereferenced.
+  nsTHashMap<Accessible*, uint32_t> mAccToCellIdx;
+  uint64_t mCaptionAccID = 0;
+
+  friend class CachedTableCellAccessible;
+};
+
+}  // namespace mozilla::a11y
+
+#endif
diff --git a/accessible/base/DocManager.cpp b/accessible/base/DocManager.cpp
new file mode 100644
index 0000000000..b7a5203e40
--- /dev/null
+++ b/accessible/base/DocManager.cpp
@@ -0,0 +1,562 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "DocManager.h"
+
+#include "ApplicationAccessible.h"
+#include "DocAccessible-inl.h"
+#include "DocAccessibleParent.h"
+#include "nsAccessibilityService.h"
+#include "Platform.h"
+#include "RootAccessibleWrap.h"
+
+#ifdef A11Y_LOG
+#  include "Logging.h"
+#endif
+
+#include "mozilla/Components.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/dom/Event.h"  // for Event
+#include "nsContentUtils.h"
+#include "nsDocShellLoadTypes.h"
+#include "nsIChannel.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIWebNavigation.h"
+#include "nsIWebProgress.h"
+#include "nsCoreUtils.h"
+#include "xpcAccessibleDocument.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+using namespace mozilla::dom;
+
+StaticAutoPtr<nsTArray<DocAccessibleParent*>> DocManager::sRemoteDocuments;
+StaticAutoPtr<nsRefPtrHashtable<nsPtrHashKey<const DocAccessibleParent>,
+                                xpcAccessibleDocument>>
+    DocManager::sRemoteXPCDocumentCache;
+
+////////////////////////////////////////////////////////////////////////////////
+// DocManager
+////////////////////////////////////////////////////////////////////////////////
+
+DocManager::DocManager() : mDocAccessibleCache(2), mXPCDocumentCache(0) {}
+
+////////////////////////////////////////////////////////////////////////////////
+// DocManager public
+
+DocAccessible* DocManager::GetDocAccessible(Document* aDocument) {
+  if (!aDocument) return nullptr;
+
+  DocAccessible* docAcc = GetExistingDocAccessible(aDocument);
+  if (docAcc) return docAcc;
+
+  return CreateDocOrRootAccessible(aDocument);
+}
+
+DocAccessible* DocManager::GetDocAccessible(const PresShell* aPresShell) {
+  if (!aPresShell) {
+    return nullptr;
+  }
+
+  DocAccessible* doc = aPresShell->GetDocAccessible();
+  if (doc) {
+    return doc;
+  }
+
+  return GetDocAccessible(aPresShell->GetDocument());
+}
+
+LocalAccessible* DocManager::FindAccessibleInCache(nsINode* aNode) const {
+  for (const auto& docAccessible : mDocAccessibleCache.Values()) {
+    NS_ASSERTION(docAccessible,
+                 "No doc accessible for the object in doc accessible cache!");
+
+    if (docAccessible) {
+      LocalAccessible* accessible = docAccessible->GetAccessible(aNode);
+      if (accessible) {
+        return accessible;
+      }
+    }
+  }
+  return nullptr;
+}
+
+void DocManager::RemoveFromXPCDocumentCache(DocAccessible* aDocument,
+                                            bool aAllowServiceShutdown) {
+  xpcAccessibleDocument* xpcDoc = mXPCDocumentCache.GetWeak(aDocument);
+  if (xpcDoc) {
+    xpcDoc->Shutdown();
+    mXPCDocumentCache.Remove(aDocument);
+
+    if (aAllowServiceShutdown && !HasXPCDocuments()) {
+      MaybeShutdownAccService(nsAccessibilityService::eXPCOM);
+    }
+  }
+}
+
+void DocManager::NotifyOfDocumentShutdown(DocAccessible* aDocument,
+                                          Document* aDOMDocument,
+                                          bool aAllowServiceShutdown) {
+  // We need to remove listeners in both cases, when document is being shutdown
+  // or when accessibility service is being shut down as well.
+  RemoveListeners(aDOMDocument);
+
+  // Document will already be removed when accessibility service is shutting
+  // down so we do not need to remove it twice.
+  if (nsAccessibilityService::IsShutdown()) {
+    return;
+  }
+
+  RemoveFromXPCDocumentCache(aDocument, aAllowServiceShutdown);
+  mDocAccessibleCache.Remove(aDOMDocument);
+}
+
+void DocManager::RemoveFromRemoteXPCDocumentCache(DocAccessibleParent* aDoc) {
+  xpcAccessibleDocument* doc = GetCachedXPCDocument(aDoc);
+  if (doc) {
+    doc->Shutdown();
+    sRemoteXPCDocumentCache->Remove(aDoc);
+  }
+
+  if (sRemoteXPCDocumentCache && sRemoteXPCDocumentCache->Count() == 0) {
+    MaybeShutdownAccService(nsAccessibilityService::eXPCOM);
+  }
+}
+
+void DocManager::NotifyOfRemoteDocShutdown(DocAccessibleParent* aDoc) {
+  RemoveFromRemoteXPCDocumentCache(aDoc);
+}
+
+xpcAccessibleDocument* DocManager::GetXPCDocument(DocAccessible* aDocument) {
+  if (!aDocument) return nullptr;
+
+  return mXPCDocumentCache.GetOrInsertNew(aDocument, aDocument);
+}
+
+xpcAccessibleDocument* DocManager::GetXPCDocument(DocAccessibleParent* aDoc) {
+  xpcAccessibleDocument* doc = GetCachedXPCDocument(aDoc);
+  if (doc) {
+    return doc;
+  }
+
+  if (!sRemoteXPCDocumentCache) {
+    sRemoteXPCDocumentCache =
+        new nsRefPtrHashtable<nsPtrHashKey<const DocAccessibleParent>,
+                              xpcAccessibleDocument>;
+    ClearOnShutdown(&sRemoteXPCDocumentCache);
+  }
+
+  MOZ_ASSERT(!aDoc->IsShutdown(), "Adding a shutdown doc to remote XPC cache");
+  doc = new xpcAccessibleDocument(aDoc);
+  sRemoteXPCDocumentCache->InsertOrUpdate(aDoc, RefPtr{doc});
+
+  return doc;
+}
+
+#ifdef DEBUG
+bool DocManager::IsProcessingRefreshDriverNotification() const {
+  for (const auto& entry : mDocAccessibleCache) {
+    DocAccessible* docAccessible = entry.GetWeak();
+    NS_ASSERTION(docAccessible,
+                 "No doc accessible for the object in doc accessible cache!");
+
+    if (docAccessible && docAccessible->mNotificationController &&
+        docAccessible->mNotificationController->IsUpdating()) {
+      return true;
+    }
+  }
+  return false;
+}
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// DocManager protected
+
+bool DocManager::Init() {
+  nsCOMPtr<nsIWebProgress> progress = components::DocLoader::Service();
+
+  if (!progress) return false;
+
+  progress->AddProgressListener(static_cast<nsIWebProgressListener*>(this),
+                                nsIWebProgress::NOTIFY_STATE_DOCUMENT);
+
+  return true;
+}
+
+void DocManager::Shutdown() {
+  nsCOMPtr<nsIWebProgress> progress = components::DocLoader::Service();
+
+  if (progress) {
+    progress->RemoveProgressListener(
+        static_cast<nsIWebProgressListener*>(this));
+  }
+
+  ClearDocCache();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsISupports
+
+NS_IMPL_ISUPPORTS(DocManager, nsIWebProgressListener, nsIDOMEventListener,
+                  nsISupportsWeakReference)
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIWebProgressListener
+
+NS_IMETHODIMP
+DocManager::OnStateChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest,
+                          uint32_t aStateFlags, nsresult aStatus) {
+  NS_ASSERTION(aStateFlags & STATE_IS_DOCUMENT, "Other notifications excluded");
+
+  if (nsAccessibilityService::IsShutdown() || !aWebProgress ||
+      (aStateFlags & (STATE_START | STATE_STOP)) == 0) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<mozIDOMWindowProxy> DOMWindow;
+  aWebProgress->GetDOMWindow(getter_AddRefs(DOMWindow));
+  NS_ENSURE_STATE(DOMWindow);
+
+  nsPIDOMWindowOuter* piWindow = nsPIDOMWindowOuter::From(DOMWindow);
+  MOZ_ASSERT(piWindow);
+
+  nsCOMPtr<Document> document = piWindow->GetDoc();
+  NS_ENSURE_STATE(document);
+
+  // Document was loaded.
+  if (aStateFlags & STATE_STOP) {
+#ifdef A11Y_LOG
+    if (logging::IsEnabled(logging::eDocLoad)) {
+      logging::DocLoad("document loaded", aWebProgress, aRequest, aStateFlags);
+    }
+#endif
+
+    // Figure out an event type to notify the document has been loaded.
+    uint32_t eventType = nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_STOPPED;
+
+    // Some XUL documents get start state and then stop state with failure
+    // status when everything is ok. Fire document load complete event in this
+    // case.
+    if (NS_SUCCEEDED(aStatus) || !document->IsContentDocument()) {
+      eventType = nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE;
+    }
+
+    // If end consumer has been retargeted for loaded content then do not fire
+    // any event because it means no new document has been loaded, for example,
+    // it happens when user clicks on file link.
+    if (aRequest) {
+      uint32_t loadFlags = 0;
+      aRequest->GetLoadFlags(&loadFlags);
+      if (loadFlags & nsIChannel::LOAD_RETARGETED_DOCUMENT_URI) eventType = 0;
+    }
+
+    HandleDOMDocumentLoad(document, eventType);
+    return NS_OK;
+  }
+
+  // Document loading was started.
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eDocLoad)) {
+    logging::DocLoad("start document loading", aWebProgress, aRequest,
+                     aStateFlags);
+  }
+#endif
+
+  DocAccessible* docAcc = GetExistingDocAccessible(document);
+  if (!docAcc) return NS_OK;
+
+  nsCOMPtr<nsIWebNavigation> webNav(do_GetInterface(DOMWindow));
+  nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(webNav));
+  NS_ENSURE_STATE(docShell);
+
+  bool isReloading = false;
+  uint32_t loadType;
+  docShell->GetLoadType(&loadType);
+  if (loadType == LOAD_RELOAD_NORMAL || loadType == LOAD_RELOAD_BYPASS_CACHE ||
+      loadType == LOAD_RELOAD_BYPASS_PROXY ||
+      loadType == LOAD_RELOAD_BYPASS_PROXY_AND_CACHE) {
+    isReloading = true;
+  }
+
+  docAcc->NotifyOfLoading(isReloading);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DocManager::OnProgressChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest,
+                             int32_t aCurSelfProgress, int32_t aMaxSelfProgress,
+                             int32_t aCurTotalProgress,
+                             int32_t aMaxTotalProgress) {
+  MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DocManager::OnLocationChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest,
+                             nsIURI* aLocation, uint32_t aFlags) {
+  MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DocManager::OnStatusChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest,
+                           nsresult aStatus, const char16_t* aMessage) {
+  MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DocManager::OnSecurityChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest,
+                             uint32_t aState) {
+  MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DocManager::OnContentBlockingEvent(nsIWebProgress* aWebProgress,
+                                   nsIRequest* aRequest, uint32_t aEvent) {
+  MOZ_ASSERT_UNREACHABLE("notification excluded in AddProgressListener(...)");
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIDOMEventListener
+
+NS_IMETHODIMP
+DocManager::HandleEvent(Event* aEvent) {
+  nsAutoString type;
+  aEvent->GetType(type);
+
+  nsCOMPtr<Document> document = do_QueryInterface(aEvent->GetTarget());
+  NS_ASSERTION(document, "pagehide or DOMContentLoaded for non document!");
+  if (!document) return NS_OK;
+
+  if (type.EqualsLiteral("pagehide")) {
+    // 'pagehide' event is registered on every DOM document we create an
+    // accessible for, process the event for the target. This document
+    // accessible and all its sub document accessible are shutdown as result of
+    // processing.
+
+#ifdef A11Y_LOG
+    if (logging::IsEnabled(logging::eDocDestroy)) {
+      logging::DocDestroy("received 'pagehide' event", document);
+    }
+#endif
+
+    // Shutdown this one and sub document accessibles.
+
+    // We're allowed to not remove listeners when accessible document is
+    // shutdown since we don't keep strong reference on chrome event target and
+    // listeners are removed automatically when chrome event target goes away.
+    DocAccessible* docAccessible = GetExistingDocAccessible(document);
+    if (docAccessible) docAccessible->Shutdown();
+
+    return NS_OK;
+  }
+
+  // XXX: handle error pages loading separately since they get neither
+  // webprogress notifications nor 'pageshow' event.
+  if (type.EqualsLiteral("DOMContentLoaded") &&
+      nsCoreUtils::IsErrorPage(document)) {
+#ifdef A11Y_LOG
+    if (logging::IsEnabled(logging::eDocLoad)) {
+      logging::DocLoad("handled 'DOMContentLoaded' event", document);
+    }
+#endif
+
+    HandleDOMDocumentLoad(document,
+                          nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE);
+  }
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DocManager private
+
+void DocManager::HandleDOMDocumentLoad(Document* aDocument,
+                                       uint32_t aLoadEventType) {
+  // Document accessible can be created before we were notified the DOM document
+  // was loaded completely. However if it's not created yet then create it.
+  DocAccessible* docAcc = GetExistingDocAccessible(aDocument);
+  if (!docAcc) {
+    docAcc = CreateDocOrRootAccessible(aDocument);
+    if (!docAcc) return;
+  }
+
+  docAcc->NotifyOfLoad(aLoadEventType);
+}
+
+void DocManager::AddListeners(Document* aDocument,
+                              bool aAddDOMContentLoadedListener) {
+  nsPIDOMWindowOuter* window = aDocument->GetWindow();
+  EventTarget* target = window->GetChromeEventHandler();
+  EventListenerManager* elm = target->GetOrCreateListenerManager();
+  elm->AddEventListenerByType(this, u"pagehide"_ns, TrustedEventsAtCapture());
+
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eDocCreate)) {
+    logging::Text("added 'pagehide' listener");
+  }
+#endif
+
+  if (aAddDOMContentLoadedListener) {
+    elm->AddEventListenerByType(this, u"DOMContentLoaded"_ns,
+                                TrustedEventsAtCapture());
+#ifdef A11Y_LOG
+    if (logging::IsEnabled(logging::eDocCreate)) {
+      logging::Text("added 'DOMContentLoaded' listener");
+    }
+#endif
+  }
+}
+
+void DocManager::RemoveListeners(Document* aDocument) {
+  nsPIDOMWindowOuter* window = aDocument->GetWindow();
+  if (!window) return;
+
+  EventTarget* target = window->GetChromeEventHandler();
+  if (!target) return;
+
+  EventListenerManager* elm = target->GetOrCreateListenerManager();
+  elm->RemoveEventListenerByType(this, u"pagehide"_ns,
+                                 TrustedEventsAtCapture());
+
+  elm->RemoveEventListenerByType(this, u"DOMContentLoaded"_ns,
+                                 TrustedEventsAtCapture());
+}
+
+DocAccessible* DocManager::CreateDocOrRootAccessible(Document* aDocument) {
+  // Ignore hidden documents, resource documents, static clone
+  // (printing) documents and documents without a docshell.
+  if (!nsCoreUtils::IsDocumentVisibleConsideringInProcessAncestors(aDocument) ||
+      aDocument->IsResourceDoc() || aDocument->IsStaticDocument() ||
+      !aDocument->IsActive()) {
+    return nullptr;
+  }
+
+  nsIDocShell* docShell = aDocument->GetDocShell();
+  if (!docShell || docShell->IsInvisible()) {
+    return nullptr;
+  }
+
+  nsIWidget* widget = nsContentUtils::WidgetForDocument(aDocument);
+  if (!widget || widget->GetWindowType() == widget::WindowType::Invisible) {
+    return nullptr;
+  }
+
+  // Ignore documents without presshell. We must not ignore documents with no
+  // root frame because DOM focus can hit such documents and ignoring them would
+  // prevent a11y focus.
+  PresShell* presShell = aDocument->GetPresShell();
+  if (!presShell || presShell->IsDestroying()) {
+    return nullptr;
+  }
+
+  bool isRootDoc = nsCoreUtils::IsRootDocument(aDocument);
+
+  DocAccessible* parentDocAcc = nullptr;
+  if (!isRootDoc) {
+    // XXXaaronl: ideally we would traverse the presshell chain. Since there's
+    // no easy way to do that, we cheat and use the document hierarchy.
+    parentDocAcc = GetDocAccessible(aDocument->GetInProcessParentDocument());
+    NS_ASSERTION(parentDocAcc, "Can't create an accessible for the document!");
+    if (!parentDocAcc) return nullptr;
+  }
+
+  // We only create root accessibles for the true root, otherwise create a
+  // doc accessible.
+  RefPtr<DocAccessible> docAcc =
+      isRootDoc ? new RootAccessibleWrap(aDocument, presShell)
+                : new DocAccessibleWrap(aDocument, presShell);
+
+  // Cache the document accessible into document cache.
+  mDocAccessibleCache.InsertOrUpdate(aDocument, RefPtr{docAcc});
+
+  // Initialize the document accessible.
+  docAcc->Init();
+
+  // Bind the document to the tree.
+  if (isRootDoc) {
+    if (!ApplicationAcc()->AppendChild(docAcc)) {
+      docAcc->Shutdown();
+      return nullptr;
+    }
+
+    // Fire reorder event to notify new accessible document has been attached to
+    // the tree. The reorder event is delivered after the document tree is
+    // constructed because event processing and tree construction are done by
+    // the same document.
+    // Note: don't use AccReorderEvent to avoid coalsecense and special reorder
+    // events processing.
+    docAcc->FireDelayedEvent(nsIAccessibleEvent::EVENT_REORDER,
+                             ApplicationAcc());
+
+  } else {
+    parentDocAcc->BindChildDocument(docAcc);
+  }
+
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eDocCreate)) {
+    logging::DocCreate("document creation finished", aDocument);
+    logging::Stack();
+  }
+#endif
+
+  AddListeners(aDocument, isRootDoc);
+  return docAcc;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DocManager static
+
+void DocManager::ClearDocCache() {
+  while (mDocAccessibleCache.Count() > 0) {
+    auto iter = mDocAccessibleCache.Iter();
+    MOZ_ASSERT(!iter.Done());
+    DocAccessible* docAcc = iter.UserData();
+    NS_ASSERTION(docAcc,
+                 "No doc accessible for the object in doc accessible cache!");
+    if (docAcc) {
+      docAcc->Shutdown();
+    }
+
+    iter.Remove();
+  }
+
+  // Ensure that all xpcom accessible documents are shut down as well.
+  while (mXPCDocumentCache.Count() > 0) {
+    auto iter = mXPCDocumentCache.Iter();
+    MOZ_ASSERT(!iter.Done());
+    xpcAccessibleDocument* xpcDoc = iter.UserData();
+    NS_ASSERTION(xpcDoc, "No xpc doc for the object in xpc doc cache!");
+
+    if (xpcDoc) {
+      xpcDoc->Shutdown();
+    }
+
+    iter.Remove();
+  }
+}
+
+void DocManager::RemoteDocAdded(DocAccessibleParent* aDoc) {
+  if (!sRemoteDocuments) {
+    sRemoteDocuments = new nsTArray<DocAccessibleParent*>;
+    ClearOnShutdown(&sRemoteDocuments);
+  }
+
+  MOZ_ASSERT(!sRemoteDocuments->Contains(aDoc),
+             "How did we already have the doc!");
+  sRemoteDocuments->AppendElement(aDoc);
+  ProxyCreated(aDoc);
+}
+
+DocAccessible* mozilla::a11y::GetExistingDocAccessible(
+    const dom::Document* aDocument) {
+  PresShell* presShell = aDocument->GetPresShell();
+  return presShell ? presShell->GetDocAccessible() : nullptr;
+}
diff --git a/accessible/base/DocManager.h b/accessible/base/DocManager.h
new file mode 100644
index 0000000000..94da5d0a24
--- /dev/null
+++ b/accessible/base/DocManager.h
@@ -0,0 +1,193 @@
+/* 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_a11_DocManager_h_
+#define mozilla_a11_DocManager_h_
+
+#include "mozilla/ClearOnShutdown.h"
+#include "nsIDOMEventListener.h"
+#include "nsRefPtrHashtable.h"
+#include "nsIWebProgressListener.h"
+#include "nsWeakReference.h"
+#include "mozilla/StaticPtr.h"
+#include "nsINode.h"
+
+namespace mozilla::dom {
+class Document;
+}
+
+namespace mozilla {
+class PresShell;
+
+namespace a11y {
+
+class LocalAccessible;
+class DocAccessible;
+class xpcAccessibleDocument;
+class DocAccessibleParent;
+
+/**
+ * Manage the document accessible life cycle.
+ */
+class DocManager : public nsIWebProgressListener,
+                   public nsIDOMEventListener,
+                   public nsSupportsWeakReference {
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIWEBPROGRESSLISTENER
+  NS_DECL_NSIDOMEVENTLISTENER
+
+  /**
+   * Return document accessible for the given DOM node.
+   */
+  DocAccessible* GetDocAccessible(dom::Document* aDocument);
+
+  /**
+   * Return document accessible for the given presshell.
+   */
+  DocAccessible* GetDocAccessible(const PresShell* aPresShell);
+
+  /**
+   * Search through all document accessibles for an accessible with the given
+   * unique id.
+   */
+  LocalAccessible* FindAccessibleInCache(nsINode* aNode) const;
+
+  /**
+   * Called by document accessible when it gets shutdown.
+   * @param aAllowServiceShutdown true to shut down nsAccessibilityService
+   *        if it is no longer required, false to prevent it.
+   */
+  void NotifyOfDocumentShutdown(DocAccessible* aDocument,
+                                dom::Document* aDOMDocument,
+                                bool aAllowServiceShutdown = true);
+
+  void RemoveFromXPCDocumentCache(DocAccessible* aDocument,
+                                  bool aAllowServiceShutdown = true);
+
+  /**
+   * Return XPCOM accessible document.
+   */
+  xpcAccessibleDocument* GetXPCDocument(DocAccessible* aDocument);
+  xpcAccessibleDocument* GetCachedXPCDocument(DocAccessible* aDocument) const {
+    return mXPCDocumentCache.GetWeak(aDocument);
+  }
+
+  /*
+   * Notification that a top level document in a content process has gone away.
+   */
+  static void RemoteDocShutdown(DocAccessibleParent* aDoc) {
+    DebugOnly<bool> result = sRemoteDocuments->RemoveElement(aDoc);
+    MOZ_ASSERT(result, "Why didn't we find the document!");
+  }
+
+  /*
+   * Notify of a new top level document in a content process.
+   */
+  static void RemoteDocAdded(DocAccessibleParent* aDoc);
+
+  static const nsTArray<DocAccessibleParent*>* TopLevelRemoteDocs() {
+    return sRemoteDocuments;
+  }
+
+  /**
+   * Remove the xpc document for a remote document if there is one.
+   */
+  static void NotifyOfRemoteDocShutdown(DocAccessibleParent* adoc);
+
+  static void RemoveFromRemoteXPCDocumentCache(DocAccessibleParent* aDoc);
+
+  /**
+   * Get a XPC document for a remote document.
+   */
+  static xpcAccessibleDocument* GetXPCDocument(DocAccessibleParent* aDoc);
+  static xpcAccessibleDocument* GetCachedXPCDocument(
+      const DocAccessibleParent* aDoc) {
+    return sRemoteXPCDocumentCache ? sRemoteXPCDocumentCache->GetWeak(aDoc)
+                                   : nullptr;
+  }
+
+#ifdef DEBUG
+  bool IsProcessingRefreshDriverNotification() const;
+#endif
+
+ protected:
+  DocManager();
+  virtual ~DocManager() = default;
+
+  /**
+   * Initialize the manager.
+   */
+  bool Init();
+
+  /**
+   * Shutdown the manager.
+   */
+  void Shutdown();
+
+  bool HasXPCDocuments() {
+    return mXPCDocumentCache.Count() > 0 ||
+           (sRemoteXPCDocumentCache && sRemoteXPCDocumentCache->Count() > 0);
+  }
+
+ private:
+  DocManager(const DocManager&);
+  DocManager& operator=(const DocManager&);
+
+ private:
+  /**
+   * Create an accessible document if it was't created and fire accessibility
+   * events if needed.
+   *
+   * @param  aDocument       [in] loaded DOM document
+   * @param  aLoadEventType  [in] specifies the event type to fire load event,
+   *                           if 0 then no event is fired
+   */
+  void HandleDOMDocumentLoad(dom::Document* aDocument, uint32_t aLoadEventType);
+
+  /**
+   * Add/remove 'pagehide' and 'DOMContentLoaded' event listeners.
+   */
+  void AddListeners(dom::Document* aDocument, bool aAddPageShowListener);
+  void RemoveListeners(dom::Document* aDocument);
+
+  /**
+   * Create document or root accessible.
+   */
+  DocAccessible* CreateDocOrRootAccessible(dom::Document* aDocument);
+
+  /**
+   * Clear the cache and shutdown the document accessibles.
+   */
+  void ClearDocCache();
+
+  typedef nsRefPtrHashtable<nsPtrHashKey<const dom::Document>, DocAccessible>
+      DocAccessibleHashtable;
+  DocAccessibleHashtable mDocAccessibleCache;
+
+  typedef nsRefPtrHashtable<nsPtrHashKey<const DocAccessible>,
+                            xpcAccessibleDocument>
+      XPCDocumentHashtable;
+  XPCDocumentHashtable mXPCDocumentCache;
+  static StaticAutoPtr<nsRefPtrHashtable<
+      nsPtrHashKey<const DocAccessibleParent>, xpcAccessibleDocument>>
+      sRemoteXPCDocumentCache;
+
+  /*
+   * The list of remote top level documents.
+   */
+  static StaticAutoPtr<nsTArray<DocAccessibleParent*>> sRemoteDocuments;
+};
+
+/**
+ * Return the existing document accessible for the document if any.
+ * Note this returns the doc accessible for the primary pres shell if there is
+ * more than one.
+ */
+DocAccessible* GetExistingDocAccessible(const dom::Document* aDocument);
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif  // mozilla_a11_DocManager_h_
diff --git a/accessible/base/EmbeddedObjCollector.cpp b/accessible/base/EmbeddedObjCollector.cpp
new file mode 100644
index 0000000000..cba5f2d9ba
--- /dev/null
+++ b/accessible/base/EmbeddedObjCollector.cpp
@@ -0,0 +1,62 @@
+/* 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 "EmbeddedObjCollector.h"
+
+#include "LocalAccessible.h"
+
+using namespace mozilla::a11y;
+
+uint32_t EmbeddedObjCollector::Count() {
+  EnsureNGetIndex(nullptr);
+  return mObjects.Length();
+}
+
+LocalAccessible* EmbeddedObjCollector::GetAccessibleAt(uint32_t aIndex) {
+  LocalAccessible* accessible = mObjects.SafeElementAt(aIndex, nullptr);
+  if (accessible) return accessible;
+
+  return EnsureNGetObject(aIndex);
+}
+
+LocalAccessible* EmbeddedObjCollector::EnsureNGetObject(uint32_t aIndex) {
+  uint32_t childCount = mRoot->ChildCount();
+  while (mRootChildIdx < childCount) {
+    LocalAccessible* child = mRoot->LocalChildAt(mRootChildIdx++);
+    if (child->IsText()) continue;
+
+    AppendObject(child);
+    if (mObjects.Length() - 1 == aIndex) return mObjects[aIndex];
+  }
+
+  return nullptr;
+}
+
+int32_t EmbeddedObjCollector::EnsureNGetIndex(LocalAccessible* aAccessible) {
+  uint32_t childCount = mRoot->ChildCount();
+  while (mRootChildIdx < childCount) {
+    LocalAccessible* child = mRoot->LocalChildAt(mRootChildIdx++);
+    if (child->IsText()) continue;
+
+    AppendObject(child);
+    if (child == aAccessible) return mObjects.Length() - 1;
+  }
+
+  return -1;
+}
+
+int32_t EmbeddedObjCollector::GetIndexAt(LocalAccessible* aAccessible) {
+  if (aAccessible->mParent != mRoot) return -1;
+
+  if (aAccessible->mIndexOfEmbeddedChild != -1) {
+    return aAccessible->mIndexOfEmbeddedChild;
+  }
+
+  return !aAccessible->IsText() ? EnsureNGetIndex(aAccessible) : -1;
+}
+
+void EmbeddedObjCollector::AppendObject(LocalAccessible* aAccessible) {
+  aAccessible->mIndexOfEmbeddedChild = mObjects.Length();
+  mObjects.AppendElement(aAccessible);
+}
diff --git a/accessible/base/EmbeddedObjCollector.h b/accessible/base/EmbeddedObjCollector.h
new file mode 100644
index 0000000000..a1d29e458f
--- /dev/null
+++ b/accessible/base/EmbeddedObjCollector.h
@@ -0,0 +1,68 @@
+/* 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_EmbeddedObjCollector_h__
+#define mozilla_a11y_EmbeddedObjCollector_h__
+
+#include "nsTArray.h"
+
+namespace mozilla {
+namespace a11y {
+
+class LocalAccessible;
+
+/**
+ * Collect embedded objects. Provide quick access to accessible by index and
+ * vice versa.
+ */
+class EmbeddedObjCollector final {
+ public:
+  ~EmbeddedObjCollector() {}
+
+  /**
+   * Return index of the given accessible within the collection.
+   */
+  int32_t GetIndexAt(LocalAccessible* aAccessible);
+
+  /**
+   * Return accessible count within the collection.
+   */
+  uint32_t Count();
+
+  /**
+   * Return an accessible from the collection at the given index.
+   */
+  LocalAccessible* GetAccessibleAt(uint32_t aIndex);
+
+ protected:
+  /**
+   * Ensure accessible at the given index is stored and return it.
+   */
+  LocalAccessible* EnsureNGetObject(uint32_t aIndex);
+
+  /**
+   * Ensure index for the given accessible is stored and return it.
+   */
+  int32_t EnsureNGetIndex(LocalAccessible* aAccessible);
+
+  // Make sure it's used by LocalAccessible class only.
+  explicit EmbeddedObjCollector(LocalAccessible* aRoot)
+      : mRoot(aRoot), mRootChildIdx(0) {}
+
+  /**
+   * Append the object to collection.
+   */
+  void AppendObject(LocalAccessible* aAccessible);
+
+  friend class LocalAccessible;
+
+  LocalAccessible* mRoot;
+  uint32_t mRootChildIdx;
+  nsTArray<LocalAccessible*> mObjects;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/EventQueue.cpp b/accessible/base/EventQueue.cpp
new file mode 100644
index 0000000000..8a5e22cd48
--- /dev/null
+++ b/accessible/base/EventQueue.cpp
@@ -0,0 +1,436 @@
+/* -*- 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 "EventQueue.h"
+
+#include "LocalAccessible-inl.h"
+#include "nsEventShell.h"
+#include "DocAccessibleChild.h"
+#include "nsTextEquivUtils.h"
+#ifdef A11Y_LOG
+#  include "Logging.h"
+#endif
+#include "Relation.h"
+
+namespace mozilla {
+namespace a11y {
+
+// Defines the number of selection add/remove events in the queue when they
+// aren't packed into single selection within event.
+const unsigned int kSelChangeCountToPack = 5;
+
+////////////////////////////////////////////////////////////////////////////////
+// EventQueue
+////////////////////////////////////////////////////////////////////////////////
+
+bool EventQueue::PushEvent(AccEvent* aEvent) {
+  NS_ASSERTION((aEvent->mAccessible && aEvent->mAccessible->IsApplication()) ||
+                   aEvent->Document() == mDocument,
+               "Queued event belongs to another document!");
+
+  if (aEvent->mEventType == nsIAccessibleEvent::EVENT_FOCUS) {
+    mFocusEvent = aEvent;
+    return true;
+  }
+
+  // XXX(Bug 1631371) Check if this should use a fallible operation as it
+  // pretended earlier, or change the return type to void.
+  mEvents.AppendElement(aEvent);
+
+  // Filter events.
+  CoalesceEvents();
+
+  if (aEvent->mEventRule != AccEvent::eDoNotEmit &&
+      (aEvent->mEventType == nsIAccessibleEvent::EVENT_NAME_CHANGE ||
+       aEvent->mEventType == nsIAccessibleEvent::EVENT_TEXT_REMOVED ||
+       aEvent->mEventType == nsIAccessibleEvent::EVENT_TEXT_INSERTED)) {
+    PushNameOrDescriptionChange(aEvent);
+  }
+  return true;
+}
+
+bool EventQueue::PushNameOrDescriptionChange(AccEvent* aOrigEvent) {
+  // Fire name/description change event on parent or related LocalAccessible
+  // being labelled/described given that this event hasn't been coalesced, the
+  // dependent's name/description was calculated from this subtree, and the
+  // subtree was changed.
+  LocalAccessible* target = aOrigEvent->mAccessible;
+  // If the text of a text leaf changed without replacing the leaf, the only
+  // event we get is text inserted on the container. In this case, we might
+  // need to fire a name change event on the target itself.
+  const bool maybeTargetNameChanged =
+      (aOrigEvent->mEventType == nsIAccessibleEvent::EVENT_TEXT_REMOVED ||
+       aOrigEvent->mEventType == nsIAccessibleEvent::EVENT_TEXT_INSERTED) &&
+      nsTextEquivUtils::HasNameRule(target, eNameFromSubtreeRule);
+  const bool doName = target->HasNameDependent() || maybeTargetNameChanged;
+  const bool doDesc = target->HasDescriptionDependent();
+  if (!doName && !doDesc) {
+    return false;
+  }
+  bool pushed = false;
+  bool nameCheckAncestor = true;
+  // Only continue traversing up the tree if it's possible that the parent
+  // LocalAccessible's name (or a LocalAccessible being labelled by this
+  // LocalAccessible or an ancestor) can depend on this LocalAccessible's name.
+  LocalAccessible* parent = target;
+  do {
+    // Test possible name dependent parent.
+    if (doName) {
+      if (nameCheckAncestor && (maybeTargetNameChanged || parent != target) &&
+          nsTextEquivUtils::HasNameRule(parent, eNameFromSubtreeRule)) {
+        nsAutoString name;
+        ENameValueFlag nameFlag = parent->Name(name);
+        // If name is obtained from subtree, fire name change event.
+        // HTML file inputs always get part of their name from the subtree, even
+        // if the author provided a name.
+        if (nameFlag == eNameFromSubtree || parent->IsHTMLFileInput()) {
+          RefPtr<AccEvent> nameChangeEvent =
+              new AccEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, parent);
+          pushed |= PushEvent(nameChangeEvent);
+        }
+        nameCheckAncestor = false;
+      }
+
+      Relation rel = parent->RelationByType(RelationType::LABEL_FOR);
+      while (LocalAccessible* relTarget = rel.LocalNext()) {
+        RefPtr<AccEvent> nameChangeEvent =
+            new AccEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, relTarget);
+        pushed |= PushEvent(nameChangeEvent);
+      }
+    }
+
+    if (doDesc) {
+      Relation rel = parent->RelationByType(RelationType::DESCRIPTION_FOR);
+      while (LocalAccessible* relTarget = rel.LocalNext()) {
+        RefPtr<AccEvent> descChangeEvent = new AccEvent(
+            nsIAccessibleEvent::EVENT_DESCRIPTION_CHANGE, relTarget);
+        pushed |= PushEvent(descChangeEvent);
+      }
+    }
+
+    if (parent->IsDoc()) {
+      // Never cross document boundaries.
+      break;
+    }
+    parent = parent->LocalParent();
+  } while (parent &&
+           nsTextEquivUtils::HasNameRule(parent, eNameFromSubtreeIfReqRule));
+
+  return pushed;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// EventQueue: private
+
+void EventQueue::CoalesceEvents() {
+  NS_ASSERTION(mEvents.Length(), "There should be at least one pending event!");
+  uint32_t tail = mEvents.Length() - 1;
+  AccEvent* tailEvent = mEvents[tail];
+
+  switch (tailEvent->mEventRule) {
+    case AccEvent::eCoalesceReorder: {
+      DebugOnly<LocalAccessible*> target = tailEvent->mAccessible.get();
+      MOZ_ASSERT(
+          target->IsApplication() || target->IsOuterDoc() ||
+              target->IsXULTree(),
+          "Only app or outerdoc accessible reorder events are in the queue");
+      MOZ_ASSERT(tailEvent->GetEventType() == nsIAccessibleEvent::EVENT_REORDER,
+                 "only reorder events should be queued");
+      break;  // case eCoalesceReorder
+    }
+
+    case AccEvent::eCoalesceOfSameType: {
+      // Coalesce old events by newer event.
+      for (uint32_t index = tail - 1; index < tail; index--) {
+        AccEvent* accEvent = mEvents[index];
+        if (accEvent->mEventType == tailEvent->mEventType &&
+            accEvent->mEventRule == tailEvent->mEventRule) {
+          accEvent->mEventRule = AccEvent::eDoNotEmit;
+          return;
+        }
+      }
+      break;  // case eCoalesceOfSameType
+    }
+
+    case AccEvent::eCoalesceSelectionChange: {
+      AccSelChangeEvent* tailSelChangeEvent = downcast_accEvent(tailEvent);
+      for (uint32_t index = tail - 1; index < tail; index--) {
+        AccEvent* thisEvent = mEvents[index];
+        if (thisEvent->mEventRule == tailEvent->mEventRule) {
+          AccSelChangeEvent* thisSelChangeEvent = downcast_accEvent(thisEvent);
+
+          // Coalesce selection change events within same control.
+          if (tailSelChangeEvent->mWidget == thisSelChangeEvent->mWidget) {
+            CoalesceSelChangeEvents(tailSelChangeEvent, thisSelChangeEvent,
+                                    index);
+            return;
+          }
+        }
+      }
+      break;  // eCoalesceSelectionChange
+    }
+
+    case AccEvent::eCoalesceStateChange: {
+      // If state change event is duped then ignore previous event. If state
+      // change event is opposite to previous event then no event is emitted
+      // (accessible state wasn't changed).
+      for (uint32_t index = tail - 1; index < tail; index--) {
+        AccEvent* thisEvent = mEvents[index];
+        if (thisEvent->mEventRule != AccEvent::eDoNotEmit &&
+            thisEvent->mEventType == tailEvent->mEventType &&
+            thisEvent->mAccessible == tailEvent->mAccessible) {
+          AccStateChangeEvent* thisSCEvent = downcast_accEvent(thisEvent);
+          AccStateChangeEvent* tailSCEvent = downcast_accEvent(tailEvent);
+          if (thisSCEvent->mState == tailSCEvent->mState) {
+            thisEvent->mEventRule = AccEvent::eDoNotEmit;
+            if (thisSCEvent->mIsEnabled != tailSCEvent->mIsEnabled) {
+              tailEvent->mEventRule = AccEvent::eDoNotEmit;
+            }
+          }
+        }
+      }
+      break;  // eCoalesceStateChange
+    }
+
+    case AccEvent::eCoalesceTextSelChange: {
+      // Coalesce older event by newer event for the same selection or target.
+      // Events for same selection may have different targets and vice versa one
+      // target may be pointed by different selections (for latter see
+      // bug 927159).
+      for (uint32_t index = tail - 1; index < tail; index--) {
+        AccEvent* thisEvent = mEvents[index];
+        if (thisEvent->mEventRule != AccEvent::eDoNotEmit &&
+            thisEvent->mEventType == tailEvent->mEventType) {
+          AccTextSelChangeEvent* thisTSCEvent = downcast_accEvent(thisEvent);
+          AccTextSelChangeEvent* tailTSCEvent = downcast_accEvent(tailEvent);
+          if (thisTSCEvent->mSel == tailTSCEvent->mSel ||
+              thisEvent->mAccessible == tailEvent->mAccessible) {
+            thisEvent->mEventRule = AccEvent::eDoNotEmit;
+          }
+        }
+      }
+      break;  // eCoalesceTextSelChange
+    }
+
+    case AccEvent::eRemoveDupes: {
+      // Check for repeat events, coalesce newly appended event by more older
+      // event.
+      for (uint32_t index = tail - 1; index < tail; index--) {
+        AccEvent* accEvent = mEvents[index];
+        if (accEvent->mEventType == tailEvent->mEventType &&
+            accEvent->mEventRule == tailEvent->mEventRule &&
+            accEvent->mAccessible == tailEvent->mAccessible) {
+          tailEvent->mEventRule = AccEvent::eDoNotEmit;
+          return;
+        }
+      }
+      break;  // case eRemoveDupes
+    }
+
+    default:
+      break;  // case eAllowDupes, eDoNotEmit
+  }           // switch
+}
+
+void EventQueue::CoalesceSelChangeEvents(AccSelChangeEvent* aTailEvent,
+                                         AccSelChangeEvent* aThisEvent,
+                                         uint32_t aThisIndex) {
+  aTailEvent->mPreceedingCount = aThisEvent->mPreceedingCount + 1;
+
+  // Pack all preceding events into single selection within event
+  // when we receive too much selection add/remove events.
+  if (aTailEvent->mPreceedingCount >= kSelChangeCountToPack) {
+    aTailEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION_WITHIN;
+    aTailEvent->mAccessible = aTailEvent->mWidget;
+    aThisEvent->mEventRule = AccEvent::eDoNotEmit;
+
+    // Do not emit any preceding selection events for same widget if they
+    // weren't coalesced yet.
+    if (aThisEvent->mEventType != nsIAccessibleEvent::EVENT_SELECTION_WITHIN) {
+      for (uint32_t jdx = aThisIndex - 1; jdx < aThisIndex; jdx--) {
+        AccEvent* prevEvent = mEvents[jdx];
+        if (prevEvent->mEventRule == aTailEvent->mEventRule) {
+          AccSelChangeEvent* prevSelChangeEvent = downcast_accEvent(prevEvent);
+          if (prevSelChangeEvent->mWidget == aTailEvent->mWidget) {
+            prevSelChangeEvent->mEventRule = AccEvent::eDoNotEmit;
+          }
+        }
+      }
+    }
+    return;
+  }
+
+  // Pack sequential selection remove and selection add events into
+  // single selection change event.
+  if (aTailEvent->mPreceedingCount == 1 &&
+      aTailEvent->mItem != aThisEvent->mItem) {
+    if (aTailEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd &&
+        aThisEvent->mSelChangeType == AccSelChangeEvent::eSelectionRemove) {
+      aThisEvent->mEventRule = AccEvent::eDoNotEmit;
+      aTailEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION;
+      aTailEvent->mPackedEvent = aThisEvent;
+      return;
+    }
+
+    if (aThisEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd &&
+        aTailEvent->mSelChangeType == AccSelChangeEvent::eSelectionRemove) {
+      aTailEvent->mEventRule = AccEvent::eDoNotEmit;
+      aThisEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION;
+      aThisEvent->mPackedEvent = aTailEvent;
+      return;
+    }
+  }
+
+  // Unpack the packed selection change event because we've got one
+  // more selection add/remove.
+  if (aThisEvent->mEventType == nsIAccessibleEvent::EVENT_SELECTION) {
+    if (aThisEvent->mPackedEvent) {
+      aThisEvent->mPackedEvent->mEventType =
+          aThisEvent->mPackedEvent->mSelChangeType ==
+                  AccSelChangeEvent::eSelectionAdd
+              ? nsIAccessibleEvent::EVENT_SELECTION_ADD
+              : nsIAccessibleEvent::EVENT_SELECTION_REMOVE;
+
+      aThisEvent->mPackedEvent->mEventRule = AccEvent::eCoalesceSelectionChange;
+
+      aThisEvent->mPackedEvent = nullptr;
+    }
+
+    aThisEvent->mEventType =
+        aThisEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd
+            ? nsIAccessibleEvent::EVENT_SELECTION_ADD
+            : nsIAccessibleEvent::EVENT_SELECTION_REMOVE;
+
+    return;
+  }
+
+  // Convert into selection add since control has single selection but other
+  // selection events for this control are queued.
+  if (aTailEvent->mEventType == nsIAccessibleEvent::EVENT_SELECTION) {
+    aTailEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION_ADD;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// EventQueue: event queue
+
+void EventQueue::ProcessEventQueue() {
+  // Process only currently queued events.
+  const nsTArray<RefPtr<AccEvent> > events = std::move(mEvents);
+  nsTArray<uint64_t> selectedIDs;
+  nsTArray<uint64_t> unselectedIDs;
+
+  uint32_t eventCount = events.Length();
+#ifdef A11Y_LOG
+  if ((eventCount > 0 || mFocusEvent) && logging::IsEnabled(logging::eEvents)) {
+    logging::MsgBegin("EVENTS", "events processing");
+    logging::Address("document", mDocument);
+    logging::MsgEnd();
+  }
+#endif
+
+  if (mFocusEvent) {
+    // Always fire a pending focus event before all other events. We do this for
+    // two reasons:
+    // 1. It prevents extraneous screen reader speech if the name, states, etc.
+    // of the currently focused item change at the same time as another item is
+    // focused. If aria-activedescendant is used, even setting
+    // aria-activedescendant before changing other properties results in the
+    // property change events being queued before the focus event because we
+    // process  aria-activedescendant async.
+    // 2. It improves perceived performance. Focus changes should be reported as
+    // soon as possible, so clients should handle focus events before they spend
+    // time on anything else.
+    RefPtr<AccEvent> event = std::move(mFocusEvent);
+    if (!event->mAccessible->IsDefunct()) {
+      FocusMgr()->ProcessFocusEvent(event);
+    }
+  }
+
+  for (uint32_t idx = 0; idx < eventCount; idx++) {
+    AccEvent* event = events[idx];
+    uint32_t eventType = event->mEventType;
+    LocalAccessible* target = event->GetAccessible();
+    if (!target || target->IsDefunct()) {
+      continue;
+    }
+
+    // Collect select changes
+    if (IPCAccessibilityActive()) {
+      if ((event->mEventRule == AccEvent::eDoNotEmit &&
+           (eventType == nsIAccessibleEvent::EVENT_SELECTION_ADD ||
+            eventType == nsIAccessibleEvent::EVENT_SELECTION_REMOVE ||
+            eventType == nsIAccessibleEvent::EVENT_SELECTION)) ||
+          eventType == nsIAccessibleEvent::EVENT_SELECTION_WITHIN) {
+        // The selection even was either dropped or morphed to a
+        // selection-within. We need to collect the items from all these events
+        // and manually push their new state to the parent process.
+        AccSelChangeEvent* selChangeEvent = downcast_accEvent(event);
+        LocalAccessible* item = selChangeEvent->mItem;
+        if (!item->IsDefunct()) {
+          uint64_t itemID =
+              item->IsDoc() ? 0 : reinterpret_cast<uint64_t>(item->UniqueID());
+          bool selected = selChangeEvent->mSelChangeType ==
+                          AccSelChangeEvent::eSelectionAdd;
+          if (selected) {
+            selectedIDs.AppendElement(itemID);
+          } else {
+            unselectedIDs.AppendElement(itemID);
+          }
+        }
+      }
+    }
+
+    if (event->mEventRule == AccEvent::eDoNotEmit) {
+      continue;
+    }
+
+    // Dispatch caret moved and text selection change events.
+    if (eventType == nsIAccessibleEvent::EVENT_TEXT_SELECTION_CHANGED) {
+      SelectionMgr()->ProcessTextSelChangeEvent(event);
+      continue;
+    }
+
+    // Fire selected state change events in support to selection events.
+    if (eventType == nsIAccessibleEvent::EVENT_SELECTION_ADD) {
+      nsEventShell::FireEvent(event->mAccessible, states::SELECTED, true,
+                              event->mIsFromUserInput);
+
+    } else if (eventType == nsIAccessibleEvent::EVENT_SELECTION_REMOVE) {
+      nsEventShell::FireEvent(event->mAccessible, states::SELECTED, false,
+                              event->mIsFromUserInput);
+
+    } else if (eventType == nsIAccessibleEvent::EVENT_SELECTION) {
+      AccSelChangeEvent* selChangeEvent = downcast_accEvent(event);
+      nsEventShell::FireEvent(
+          event->mAccessible, states::SELECTED,
+          (selChangeEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd),
+          event->mIsFromUserInput);
+
+      if (selChangeEvent->mPackedEvent) {
+        nsEventShell::FireEvent(selChangeEvent->mPackedEvent->mAccessible,
+                                states::SELECTED,
+                                (selChangeEvent->mPackedEvent->mSelChangeType ==
+                                 AccSelChangeEvent::eSelectionAdd),
+                                selChangeEvent->mPackedEvent->mIsFromUserInput);
+      }
+    }
+
+    nsEventShell::FireEvent(event);
+
+    if (!mDocument) {
+      return;
+    }
+  }
+
+  if (mDocument && IPCAccessibilityActive() &&
+      (!selectedIDs.IsEmpty() || !unselectedIDs.IsEmpty())) {
+    DocAccessibleChild* ipcDoc = mDocument->IPCDoc();
+    ipcDoc->SendSelectedAccessiblesChanged(selectedIDs, unselectedIDs);
+  }
+}
+
+}  // namespace a11y
+}  // namespace mozilla
diff --git a/accessible/base/EventQueue.h b/accessible/base/EventQueue.h
new file mode 100644
index 0000000000..87bcf89340
--- /dev/null
+++ b/accessible/base/EventQueue.h
@@ -0,0 +1,83 @@
+/* -*- 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_EventQueue_h_
+#define mozilla_a11y_EventQueue_h_
+
+#include "AccEvent.h"
+#include "mozilla/Assertions.h"
+
+namespace mozilla {
+namespace a11y {
+
+class DocAccessible;
+
+/**
+ * Used to organize and coalesce pending events.
+ */
+class EventQueue {
+ protected:
+  explicit EventQueue(DocAccessible* aDocument) : mDocument(aDocument) {
+    MOZ_ASSERT(mDocument,
+               "There's no point creating an event queue for a null document");
+  }
+
+  /**
+   * Put an accessible event into the queue to process it later.
+   */
+  bool PushEvent(AccEvent* aEvent);
+
+  /**
+   * Puts name and/or description change events into the queue, if needed.
+   */
+  bool PushNameOrDescriptionChange(AccEvent* aOrigEvent);
+
+  /**
+   * Process events from the queue and fires events.
+   */
+  void ProcessEventQueue();
+
+ private:
+  EventQueue(const EventQueue&) = delete;
+  EventQueue& operator=(const EventQueue&) = delete;
+
+  // Event queue processing
+  /**
+   * Coalesce redundant events from the queue.
+   */
+  void CoalesceEvents();
+
+  /**
+   * Coalesce events from the same subtree.
+   */
+  void CoalesceReorderEvents(AccEvent* aTailEvent);
+
+  /**
+   * Coalesce two selection change events within the same select control.
+   */
+  void CoalesceSelChangeEvents(AccSelChangeEvent* aTailEvent,
+                               AccSelChangeEvent* aThisEvent,
+                               uint32_t aThisIndex);
+
+ protected:
+  /**
+   * The document accessible reference owning this queue.
+   */
+  DocAccessible* mDocument;
+
+  /**
+   * Pending events array. Don't make this an AutoTArray; we use
+   * SwapElements() on it.
+   */
+  nsTArray<RefPtr<AccEvent>> mEvents;
+
+  // Pending focus event.
+  RefPtr<AccEvent> mFocusEvent;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif  // mozilla_a11y_EventQueue_h_
diff --git a/accessible/base/EventTree.cpp b/accessible/base/EventTree.cpp
new file mode 100644
index 0000000000..29cf66e493
--- /dev/null
+++ b/accessible/base/EventTree.cpp
@@ -0,0 +1,99 @@
+/* -*- 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 "EventTree.h"
+
+#include "EmbeddedObjCollector.h"
+#include "NotificationController.h"
+#ifdef A11Y_LOG
+#  include "Logging.h"
+#endif
+
+#include "mozilla/UniquePtr.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// TreeMutation class
+
+TreeMutation::TreeMutation(LocalAccessible* aParent, bool aNoEvents)
+    : mParent(aParent),
+      mStartIdx(UINT32_MAX),
+      mStateFlagsCopy(mParent->mStateFlags),
+      mQueueEvents(!aNoEvents) {
+#ifdef DEBUG
+  mIsDone = false;
+#endif
+
+  mParent->mStateFlags |= LocalAccessible::eKidsMutating;
+}
+
+TreeMutation::~TreeMutation() {
+  MOZ_ASSERT(mIsDone, "Done() must be called explicitly");
+}
+
+void TreeMutation::AfterInsertion(LocalAccessible* aChild) {
+  MOZ_ASSERT(aChild->LocalParent() == mParent);
+
+  if (static_cast<uint32_t>(aChild->mIndexInParent) < mStartIdx) {
+    mStartIdx = aChild->mIndexInParent + 1;
+  }
+
+  if (!mQueueEvents) {
+    return;
+  }
+
+  RefPtr<AccShowEvent> ev = new AccShowEvent(aChild);
+  DebugOnly<bool> added = Controller()->QueueMutationEvent(ev);
+  MOZ_ASSERT(added);
+  aChild->SetShowEventTarget(true);
+}
+
+void TreeMutation::BeforeRemoval(LocalAccessible* aChild, bool aNoShutdown) {
+  MOZ_ASSERT(aChild->LocalParent() == mParent);
+
+  if (static_cast<uint32_t>(aChild->mIndexInParent) < mStartIdx) {
+    mStartIdx = aChild->mIndexInParent;
+  }
+
+  if (!mQueueEvents) {
+    return;
+  }
+
+  RefPtr<AccHideEvent> ev = new AccHideEvent(aChild, !aNoShutdown);
+  if (Controller()->QueueMutationEvent(ev)) {
+    aChild->SetHideEventTarget(true);
+  }
+}
+
+void TreeMutation::Done() {
+  MOZ_ASSERT(mParent->mStateFlags & LocalAccessible::eKidsMutating);
+  mParent->mStateFlags &= ~LocalAccessible::eKidsMutating;
+
+  uint32_t length = mParent->mChildren.Length();
+#ifdef DEBUG
+  for (uint32_t idx = 0; idx < mStartIdx && idx < length; idx++) {
+    MOZ_ASSERT(
+        mParent->mChildren[idx]->mIndexInParent == static_cast<int32_t>(idx),
+        "Wrong index detected");
+  }
+#endif
+
+  for (uint32_t idx = mStartIdx; idx < length; idx++) {
+    mParent->mChildren[idx]->mIndexOfEmbeddedChild = -1;
+  }
+
+  for (uint32_t idx = 0; idx < length; idx++) {
+    mParent->mChildren[idx]->mStateFlags |= LocalAccessible::eGroupInfoDirty;
+  }
+
+  mParent->mEmbeddedObjCollector = nullptr;
+  mParent->mStateFlags |= mStateFlagsCopy & LocalAccessible::eKidsMutating;
+
+#ifdef DEBUG
+  mIsDone = true;
+#endif
+}
diff --git a/accessible/base/EventTree.h b/accessible/base/EventTree.h
new file mode 100644
index 0000000000..bd9976b4fb
--- /dev/null
+++ b/accessible/base/EventTree.h
@@ -0,0 +1,61 @@
+/* -*- 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_EventTree_h_
+#define mozilla_a11y_EventTree_h_
+
+#include "AccEvent.h"
+#include "LocalAccessible.h"
+
+#include "mozilla/a11y/DocAccessible.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+
+namespace mozilla {
+namespace a11y {
+
+class NotificationController;
+
+/**
+ * This class makes sure required tasks are done before and after tree
+ * mutations. Currently this only includes group info invalidation. You must
+ * have an object of this class on the stack when calling methods that mutate
+ * the accessible tree.
+ */
+class TreeMutation final {
+ public:
+  static const bool kNoEvents = true;
+  static const bool kNoShutdown = true;
+
+  explicit TreeMutation(LocalAccessible* aParent, bool aNoEvents = false);
+  ~TreeMutation();
+
+  void AfterInsertion(LocalAccessible* aChild);
+  void BeforeRemoval(LocalAccessible* aChild, bool aNoShutdown = false);
+  void Done();
+
+ private:
+  NotificationController* Controller() const {
+    return mParent->Document()->Controller();
+  }
+
+  LocalAccessible* mParent;
+  uint32_t mStartIdx;
+  uint32_t mStateFlagsCopy;
+
+  /*
+   * True if mutation events should be queued.
+   */
+  bool mQueueEvents;
+
+#ifdef DEBUG
+  bool mIsDone;
+#endif
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif  // mozilla_a11y_EventQueue_h_
diff --git a/accessible/base/Filters.cpp b/accessible/base/Filters.cpp
new file mode 100644
index 0000000000..3ef58dc4fe
--- /dev/null
+++ b/accessible/base/Filters.cpp
@@ -0,0 +1,25 @@
+/* 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 "Filters.h"
+
+#include "LocalAccessible-inl.h"
+#include "States.h"
+
+using namespace mozilla::a11y;
+using namespace mozilla::a11y::filters;
+
+uint32_t filters::GetSelected(LocalAccessible* aAccessible) {
+  if (aAccessible->State() & states::SELECTED) return eMatch | eSkipSubtree;
+
+  return eSkip;
+}
+
+uint32_t filters::GetSelectable(LocalAccessible* aAccessible) {
+  if (aAccessible->InteractiveState() & states::SELECTABLE) {
+    return eMatch | eSkipSubtree;
+  }
+
+  return eSkip;
+}
diff --git a/accessible/base/Filters.h b/accessible/base/Filters.h
new file mode 100644
index 0000000000..486beb5c83
--- /dev/null
+++ b/accessible/base/Filters.h
@@ -0,0 +1,36 @@
+/* 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_Filters_h__
+#define mozilla_a11y_Filters_h__
+
+#include <stdint.h>
+
+/**
+ * Predefined filters used for nsAccIterator and nsAccCollector.
+ */
+namespace mozilla {
+namespace a11y {
+
+class LocalAccessible;
+
+namespace filters {
+
+enum EResult { eSkip = 0, eMatch = 1, eSkipSubtree = 2 };
+
+/**
+ * Return true if the traversed accessible complies with filter.
+ */
+typedef uint32_t (*FilterFuncPtr)(LocalAccessible*);
+
+/**
+ * Matches selected/selectable accessibles in subtree.
+ */
+uint32_t GetSelected(LocalAccessible* aAccessible);
+uint32_t GetSelectable(LocalAccessible* aAccessible);
+}  // namespace filters
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/FocusManager.cpp b/accessible/base/FocusManager.cpp
new file mode 100644
index 0000000000..57cfd7034e
--- /dev/null
+++ b/accessible/base/FocusManager.cpp
@@ -0,0 +1,462 @@
+/* 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 "FocusManager.h"
+
+#include "LocalAccessible-inl.h"
+#include "DocAccessible-inl.h"
+#include "nsAccessibilityService.h"
+#include "nsEventShell.h"
+
+#include "nsFocusManager.h"
+#include "mozilla/a11y/DocAccessibleParent.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/BrowserParent.h"
+
+namespace mozilla {
+namespace a11y {
+
+FocusManager::FocusManager() {}
+
+FocusManager::~FocusManager() {}
+
+LocalAccessible* FocusManager::FocusedLocalAccessible() const {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (mActiveItem) {
+    if (mActiveItem->IsDefunct()) {
+      MOZ_ASSERT_UNREACHABLE("Stored active item is unbound from document");
+      return nullptr;
+    }
+
+    return mActiveItem;
+  }
+
+  if (nsAccessibilityService::IsShutdown()) {
+    // We might try to get or create a DocAccessible below, which isn't safe (or
+    // useful) if the accessibility service is shutting down.
+    return nullptr;
+  }
+
+  nsINode* focusedNode = FocusedDOMNode();
+  if (focusedNode) {
+    DocAccessible* doc =
+        GetAccService()->GetDocAccessible(focusedNode->OwnerDoc());
+    return doc ? doc->GetAccessibleEvenIfNotInMapOrContainer(focusedNode)
+               : nullptr;
+  }
+
+  return nullptr;
+}
+
+Accessible* FocusManager::FocusedAccessible() const {
+#if defined(ANDROID)
+  // It's not safe to call FocusedLocalAccessible() except on the main thread.
+  // Android might query RemoteAccessibles on the UI thread, which might call
+  // FocusedAccessible(). Never try to get the focused LocalAccessible in this
+  // case.
+  if (NS_IsMainThread()) {
+    if (Accessible* focusedAcc = FocusedLocalAccessible()) {
+      return focusedAcc;
+    }
+  } else {
+    nsAccessibilityService::GetAndroidMonitor().AssertCurrentThreadOwns();
+  }
+  return mFocusedRemoteDoc ? mFocusedRemoteDoc->GetFocusedAcc() : nullptr;
+#else
+  if (Accessible* focusedAcc = FocusedLocalAccessible()) {
+    return focusedAcc;
+  }
+
+  if (!XRE_IsParentProcess()) {
+    // DocAccessibleParent's don't exist in the content
+    // process, so we can't return anything useful if this
+    // is the case.
+    return nullptr;
+  }
+
+  nsFocusManager* focusManagerDOM = nsFocusManager::GetFocusManager();
+  if (!focusManagerDOM) {
+    return nullptr;
+  }
+
+  // If we call GetFocusedBrowsingContext from the chrome process
+  // it returns the BrowsingContext for the focused _window_, which
+  // is not helpful here. Instead use GetFocusedBrowsingContextInChrome
+  // which returns the content BrowsingContext that has focus.
+  dom::BrowsingContext* focusedContext =
+      focusManagerDOM->GetFocusedBrowsingContextInChrome();
+
+  DocAccessibleParent* focusedDoc =
+      DocAccessibleParent::GetFrom(focusedContext);
+  return focusedDoc ? focusedDoc->GetFocusedAcc() : nullptr;
+#endif  // defined(ANDROID)
+}
+
+bool FocusManager::IsFocusWithin(const Accessible* aContainer) const {
+  Accessible* child = FocusedAccessible();
+  while (child) {
+    if (child == aContainer) return true;
+
+    child = child->Parent();
+  }
+  return false;
+}
+
+FocusManager::FocusDisposition FocusManager::IsInOrContainsFocus(
+    const LocalAccessible* aAccessible) const {
+  LocalAccessible* focus = FocusedLocalAccessible();
+  if (!focus) return eNone;
+
+  // If focused.
+  if (focus == aAccessible) return eFocused;
+
+  // If contains the focus.
+  LocalAccessible* child = focus->LocalParent();
+  while (child) {
+    if (child == aAccessible) return eContainsFocus;
+
+    child = child->LocalParent();
+  }
+
+  // If contained by focus.
+  child = aAccessible->LocalParent();
+  while (child) {
+    if (child == focus) return eContainedByFocus;
+
+    child = child->LocalParent();
+  }
+
+  return eNone;
+}
+
+bool FocusManager::WasLastFocused(const LocalAccessible* aAccessible) const {
+  return mLastFocus == aAccessible;
+}
+
+void FocusManager::NotifyOfDOMFocus(nsISupports* aTarget) {
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eFocus)) {
+    logging::FocusNotificationTarget("DOM focus", "Target", aTarget);
+  }
+#endif
+
+  mActiveItem = nullptr;
+
+  nsCOMPtr<nsINode> targetNode(do_QueryInterface(aTarget));
+  if (targetNode) {
+    DocAccessible* document =
+        GetAccService()->GetDocAccessible(targetNode->OwnerDoc());
+    if (document) {
+      // Set selection listener for focused element.
+      if (targetNode->IsElement()) {
+        SelectionMgr()->SetControlSelectionListener(targetNode->AsElement());
+      }
+
+      document->HandleNotification<FocusManager, nsINode>(
+          this, &FocusManager::ProcessDOMFocus, targetNode);
+    }
+  }
+}
+
+void FocusManager::NotifyOfDOMBlur(nsISupports* aTarget) {
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eFocus)) {
+    logging::FocusNotificationTarget("DOM blur", "Target", aTarget);
+  }
+#endif
+
+  mActiveItem = nullptr;
+
+  // If DOM document stays focused then fire accessible focus event to process
+  // the case when no element within this DOM document will be focused.
+  nsCOMPtr<nsINode> targetNode(do_QueryInterface(aTarget));
+  if (targetNode && targetNode->OwnerDoc() == FocusedDOMDocument()) {
+    dom::Document* DOMDoc = targetNode->OwnerDoc();
+    DocAccessible* document = GetAccService()->GetDocAccessible(DOMDoc);
+    if (document) {
+      // Clear selection listener for previously focused element.
+      if (targetNode->IsElement()) {
+        SelectionMgr()->ClearControlSelectionListener();
+      }
+
+      document->HandleNotification<FocusManager, nsINode>(
+          this, &FocusManager::ProcessDOMFocus, DOMDoc);
+    }
+  }
+}
+
+void FocusManager::ActiveItemChanged(LocalAccessible* aItem,
+                                     bool aCheckIfActive) {
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eFocus)) {
+    logging::FocusNotificationTarget("active item changed", "Item", aItem);
+  }
+#endif
+
+  // Nothing changed, happens for XUL trees and HTML selects.
+  if (aItem && aItem == mActiveItem) {
+    return;
+  }
+
+  mActiveItem = nullptr;
+
+  if (aItem && aCheckIfActive) {
+    LocalAccessible* widget = aItem->ContainerWidget();
+#ifdef A11Y_LOG
+    if (logging::IsEnabled(logging::eFocus)) logging::ActiveWidget(widget);
+#endif
+    if (!widget || !widget->IsActiveWidget() || !widget->AreItemsOperable()) {
+      return;
+    }
+  }
+  mActiveItem = aItem;
+
+  // If mActiveItem is null we may need to shift a11y focus back to a remote
+  // document. For example, when combobox popup is closed, then
+  // the focus should be moved back to the combobox.
+  if (!mActiveItem && XRE_IsParentProcess()) {
+    dom::BrowserParent* browser = dom::BrowserParent::GetFocused();
+    if (browser) {
+      a11y::DocAccessibleParent* dap = browser->GetTopLevelDocAccessible();
+      if (dap) {
+        Unused << dap->SendRestoreFocus();
+      }
+    }
+  }
+
+  // If active item is changed then fire accessible focus event on it, otherwise
+  // if there's no an active item then fire focus event to accessible having
+  // DOM focus.
+  LocalAccessible* target = FocusedLocalAccessible();
+  if (target) {
+    DispatchFocusEvent(target->Document(), target);
+  }
+}
+
+void FocusManager::ForceFocusEvent() {
+  nsINode* focusedNode = FocusedDOMNode();
+  if (focusedNode) {
+    DocAccessible* document =
+        GetAccService()->GetDocAccessible(focusedNode->OwnerDoc());
+    if (document) {
+      document->HandleNotification<FocusManager, nsINode>(
+          this, &FocusManager::ProcessDOMFocus, focusedNode);
+    }
+  }
+}
+
+void FocusManager::DispatchFocusEvent(DocAccessible* aDocument,
+                                      LocalAccessible* aTarget) {
+  MOZ_ASSERT(aDocument, "No document for focused accessible!");
+  if (aDocument) {
+    RefPtr<AccEvent> event =
+        new AccEvent(nsIAccessibleEvent::EVENT_FOCUS, aTarget, eAutoDetect,
+                     AccEvent::eCoalesceOfSameType);
+    aDocument->FireDelayedEvent(event);
+    mLastFocus = aTarget;
+    if (mActiveItem != aTarget) {
+      // This new focus overrides the stored active item, so clear the active
+      // item. Among other things, the old active item might die.
+      mActiveItem = nullptr;
+    }
+
+#ifdef A11Y_LOG
+    if (logging::IsEnabled(logging::eFocus)) logging::FocusDispatched(aTarget);
+#endif
+  }
+}
+
+void FocusManager::ProcessDOMFocus(nsINode* aTarget) {
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eFocus)) {
+    logging::FocusNotificationTarget("process DOM focus", "Target", aTarget);
+  }
+#endif
+
+  DocAccessible* document =
+      GetAccService()->GetDocAccessible(aTarget->OwnerDoc());
+  if (!document) return;
+
+  LocalAccessible* target =
+      document->GetAccessibleEvenIfNotInMapOrContainer(aTarget);
+  if (target) {
+    // Check if still focused. Otherwise we can end up with storing the active
+    // item for control that isn't focused anymore.
+    nsINode* focusedNode = FocusedDOMNode();
+    if (!focusedNode) return;
+
+    LocalAccessible* DOMFocus =
+        document->GetAccessibleEvenIfNotInMapOrContainer(focusedNode);
+    if (target != DOMFocus) return;
+
+    LocalAccessible* activeItem = target->CurrentItem();
+    if (activeItem) {
+      mActiveItem = activeItem;
+      target = activeItem;
+    }
+
+    DispatchFocusEvent(document, target);
+  }
+}
+
+void FocusManager::ProcessFocusEvent(AccEvent* aEvent) {
+  MOZ_ASSERT(aEvent->GetEventType() == nsIAccessibleEvent::EVENT_FOCUS,
+             "Focus event is expected!");
+
+  // Emit focus event if event target is the active item. Otherwise then check
+  // if it's still focused and then update active item and emit focus event.
+  LocalAccessible* target = aEvent->GetAccessible();
+  MOZ_ASSERT(!target->IsDefunct());
+  if (target != mActiveItem) {
+    // Check if still focused. Otherwise we can end up with storing the active
+    // item for control that isn't focused anymore.
+    DocAccessible* document = aEvent->Document();
+    nsINode* focusedNode = FocusedDOMNode();
+    if (!focusedNode) return;
+
+    LocalAccessible* DOMFocus =
+        document->GetAccessibleEvenIfNotInMapOrContainer(focusedNode);
+    if (target != DOMFocus) return;
+
+    LocalAccessible* activeItem = target->CurrentItem();
+    if (activeItem) {
+      mActiveItem = activeItem;
+      target = activeItem;
+      MOZ_ASSERT(!target->IsDefunct());
+    }
+  }
+
+  // Fire menu start/end events for ARIA menus.
+  if (target->IsARIARole(nsGkAtoms::menuitem)) {
+    // The focus was moved into menu.
+    LocalAccessible* ARIAMenubar = nullptr;
+    for (LocalAccessible* parent = target->LocalParent(); parent;
+         parent = parent->LocalParent()) {
+      if (parent->IsARIARole(nsGkAtoms::menubar)) {
+        ARIAMenubar = parent;
+        break;
+      }
+
+      // Go up in the parent chain of the menu hierarchy.
+      if (!parent->IsARIARole(nsGkAtoms::menuitem) &&
+          !parent->IsARIARole(nsGkAtoms::menu)) {
+        break;
+      }
+    }
+
+    if (ARIAMenubar != mActiveARIAMenubar) {
+      // Leaving ARIA menu. Fire menu_end event on current menubar.
+      if (mActiveARIAMenubar) {
+        RefPtr<AccEvent> menuEndEvent =
+            new AccEvent(nsIAccessibleEvent::EVENT_MENU_END, mActiveARIAMenubar,
+                         aEvent->FromUserInput());
+        nsEventShell::FireEvent(menuEndEvent);
+      }
+
+      mActiveARIAMenubar = ARIAMenubar;
+
+      // Entering ARIA menu. Fire menu_start event.
+      if (mActiveARIAMenubar) {
+        RefPtr<AccEvent> menuStartEvent =
+            new AccEvent(nsIAccessibleEvent::EVENT_MENU_START,
+                         mActiveARIAMenubar, aEvent->FromUserInput());
+        nsEventShell::FireEvent(menuStartEvent);
+      }
+    }
+  } else if (mActiveARIAMenubar) {
+    // Focus left a menu. Fire menu_end event.
+    RefPtr<AccEvent> menuEndEvent =
+        new AccEvent(nsIAccessibleEvent::EVENT_MENU_END, mActiveARIAMenubar,
+                     aEvent->FromUserInput());
+    nsEventShell::FireEvent(menuEndEvent);
+
+    mActiveARIAMenubar = nullptr;
+  }
+
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eFocus)) {
+    logging::FocusNotificationTarget("fire focus event", "Target", target);
+  }
+#endif
+
+  // Reset cached caret value. The cache will be updated upon processing the
+  // next caret move event. This ensures that we will return the correct caret
+  // offset before the caret move event is handled.
+  SelectionMgr()->ResetCaretOffset();
+
+  RefPtr<AccEvent> focusEvent = new AccEvent(nsIAccessibleEvent::EVENT_FOCUS,
+                                             target, aEvent->FromUserInput());
+  nsEventShell::FireEvent(focusEvent);
+
+  if (NS_WARN_IF(target->IsDefunct())) {
+    // target died during nsEventShell::FireEvent.
+    return;
+  }
+
+  // Fire scrolling_start event when the document receives the focus if it has
+  // an anchor jump. If an accessible within the document receive the focus
+  // then null out the anchor jump because it no longer applies.
+  DocAccessible* targetDocument = target->Document();
+  MOZ_ASSERT(targetDocument);
+  LocalAccessible* anchorJump = targetDocument->AnchorJump();
+  if (anchorJump) {
+    if (target == targetDocument || target->IsNonInteractive()) {
+      // XXX: bug 625699, note in some cases the node could go away before we
+      // we receive focus event, for example if the node is removed from DOM.
+      nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_SCROLLING_START,
+                              anchorJump, aEvent->FromUserInput());
+    }
+    targetDocument->SetAnchorJump(nullptr);
+  }
+}
+
+nsINode* FocusManager::FocusedDOMNode() const {
+  nsFocusManager* DOMFocusManager = nsFocusManager::GetFocusManager();
+  nsIContent* focusedElm = DOMFocusManager->GetFocusedElement();
+  nsIFrame* focusedFrame = focusedElm ? focusedElm->GetPrimaryFrame() : nullptr;
+  // DOM elements retain their focused state when they get styled as display:
+  // none/content or visibility: hidden. We should treat those cases as if those
+  // elements were removed, and focus on doc.
+  if (focusedFrame && focusedFrame->StyleVisibility()->IsVisible()) {
+    // Print preview documents don't get DocAccessibles, but we still want a11y
+    // focus to go somewhere useful. Therefore, we allow a11y focus to land on
+    // the OuterDocAccessible in this case.
+    // Note that this code only handles remote print preview documents.
+    if (EventStateManager::IsTopLevelRemoteTarget(focusedElm) &&
+        focusedElm->AsElement()->HasAttribute(u"printpreview"_ns)) {
+      return focusedElm;
+    }
+    // No focus on remote target elements like xul:browser having DOM focus and
+    // residing in chrome process because it means an element in content process
+    // keeps the focus. Similarly, suppress focus on OOP iframes because an
+    // element in another content process should now have the focus.
+    if (EventStateManager::IsRemoteTarget(focusedElm)) {
+      return nullptr;
+    }
+    return focusedElm;
+  }
+
+  // Otherwise the focus can be on DOM document.
+  dom::BrowsingContext* context = DOMFocusManager->GetFocusedBrowsingContext();
+  if (context) {
+    // GetDocShell will return null if the document isn't in our process.
+    nsIDocShell* shell = context->GetDocShell();
+    if (shell) {
+      return shell->GetDocument();
+    }
+  }
+
+  // Focus isn't in this process.
+  return nullptr;
+}
+
+dom::Document* FocusManager::FocusedDOMDocument() const {
+  nsINode* focusedNode = FocusedDOMNode();
+  return focusedNode ? focusedNode->OwnerDoc() : nullptr;
+}
+
+}  // namespace a11y
+}  // namespace mozilla
diff --git a/accessible/base/FocusManager.h b/accessible/base/FocusManager.h
new file mode 100644
index 0000000000..7460a21f9a
--- /dev/null
+++ b/accessible/base/FocusManager.h
@@ -0,0 +1,169 @@
+/* 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_FocusManager_h_
+#define mozilla_a11y_FocusManager_h_
+
+#include "mozilla/RefPtr.h"
+
+class nsINode;
+class nsISupports;
+
+namespace mozilla {
+namespace dom {
+class Document;
+}
+
+namespace a11y {
+
+class Accessible;
+class AccEvent;
+class LocalAccessible;
+class DocAccessible;
+class DocAccessibleParent;
+
+/**
+ * Manage the accessible focus. Used to fire and process accessible events.
+ */
+class FocusManager {
+ public:
+  virtual ~FocusManager();
+
+  /**
+   * Return the currently focused LocalAccessible. If a remote document has
+   * focus, this will return null.
+   */
+  LocalAccessible* FocusedLocalAccessible() const;
+
+  /**
+   * Return the currently focused Accessible, local or remote.
+   */
+  Accessible* FocusedAccessible() const;
+
+  /**
+   * Return true if given accessible is focused.
+   */
+  bool IsFocused(const Accessible* aAccessible) const {
+    return FocusedAccessible() == aAccessible;
+  }
+
+  /**
+   * Return true if the given accessible is an active item, i.e. an item that
+   * is current within the active widget.
+   */
+  inline bool IsActiveItem(const LocalAccessible* aAccessible) {
+    return aAccessible == mActiveItem;
+  }
+
+  /**
+   * Return DOM node having DOM focus.
+   */
+  nsINode* FocusedDOMNode() const;
+
+  /**
+   * Return true if given DOM node has DOM focus.
+   */
+  inline bool HasDOMFocus(const nsINode* aNode) const {
+    return aNode == FocusedDOMNode();
+  }
+
+  /**
+   * Return true if focused accessible is within the given container.
+   */
+  bool IsFocusWithin(const Accessible* aContainer) const;
+
+  /**
+   * Return whether the given accessible is focused or contains the focus or
+   * contained by focused accessible.
+   */
+  enum FocusDisposition { eNone, eFocused, eContainsFocus, eContainedByFocus };
+  FocusDisposition IsInOrContainsFocus(
+      const LocalAccessible* aAccessible) const;
+
+  /**
+   * Return true if the given accessible was the last accessible focused.
+   * This is useful to detect the case where the last focused accessible was
+   * removed before something else was focused. This can happen in one of two
+   * ways:
+   * 1. The DOM focus was removed. DOM doesn't fire a blur event when this
+   *    happens; see bug 559561.
+   * 2. The accessibility focus was an active item (e.g. aria-activedescendant)
+   *    and that item was removed.
+   */
+  bool WasLastFocused(const LocalAccessible* aAccessible) const;
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Focus notifications and processing (don't use until you know what you do).
+
+  /**
+   * Called when DOM focus event is fired.
+   */
+  void NotifyOfDOMFocus(nsISupports* aTarget);
+
+  /**
+   * Called when DOM blur event is fired.
+   */
+  void NotifyOfDOMBlur(nsISupports* aTarget);
+
+  /**
+   * Called when active item is changed. Note: must be called when accessible
+   * tree is up to date.
+   */
+  void ActiveItemChanged(LocalAccessible* aItem, bool aCheckIfActive = true);
+
+  /**
+   * Dispatch delayed focus event for the current focus accessible.
+   */
+  void ForceFocusEvent();
+
+  /**
+   * Dispatch delayed focus event for the given target.
+   */
+  void DispatchFocusEvent(DocAccessible* aDocument, LocalAccessible* aTarget);
+
+  /**
+   * Process DOM focus notification.
+   */
+  void ProcessDOMFocus(nsINode* aTarget);
+
+  /**
+   * Process the delayed accessible event.
+   * do.
+   */
+  void ProcessFocusEvent(AccEvent* aEvent);
+
+#ifdef ANDROID
+  void SetFocusedRemoteDoc(DocAccessibleParent* aDoc) {
+    mFocusedRemoteDoc = aDoc;
+  }
+  bool IsFocusedRemoteDoc(DocAccessibleParent* aDoc) {
+    return mFocusedRemoteDoc == aDoc;
+  }
+#endif
+
+ protected:
+  FocusManager();
+
+ private:
+  FocusManager(const FocusManager&);
+  FocusManager& operator=(const FocusManager&);
+
+  /**
+   * Return DOM document having DOM focus.
+   */
+  dom::Document* FocusedDOMDocument() const;
+
+ private:
+  RefPtr<LocalAccessible> mActiveItem;
+  RefPtr<LocalAccessible> mLastFocus;
+  RefPtr<LocalAccessible> mActiveARIAMenubar;
+#ifdef ANDROID
+  DocAccessibleParent* mFocusedRemoteDoc = nullptr;
+#endif
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/HTMLMarkupMap.h b/accessible/base/HTMLMarkupMap.h
new file mode 100644
index 0000000000..b903097ea0
--- /dev/null
+++ b/accessible/base/HTMLMarkupMap.h
@@ -0,0 +1,444 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=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/. */
+
+MARKUPMAP(
+    a,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      // An anchor element without an href attribute and without a click
+      // listener should be a generic.
+      if (!aElement->HasAttr(nsGkAtoms::href) &&
+          !nsCoreUtils::HasClickListener(aElement)) {
+        return new HyperTextAccessible(aElement, aContext->Document());
+      }
+      // Only some roles truly enjoy life as HTMLLinkAccessibles, for
+      // details see closed bug 494807.
+      const nsRoleMapEntry* roleMapEntry = aria::GetRoleMap(aElement);
+      if (roleMapEntry && roleMapEntry->role != roles::NOTHING &&
+          roleMapEntry->role != roles::LINK) {
+        return new HyperTextAccessible(aElement, aContext->Document());
+      }
+
+      return new HTMLLinkAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(abbr, New_HyperText, 0)
+
+MARKUPMAP(acronym, New_HyperText, 0)
+
+MARKUPMAP(address, New_HyperText, roles::GROUPING)
+
+MARKUPMAP(article, New_HyperText, roles::ARTICLE, Attr(xmlroles, article))
+
+MARKUPMAP(aside, New_HyperText, roles::LANDMARK)
+
+MARKUPMAP(blockquote, New_HyperText, roles::BLOCKQUOTE)
+
+MARKUPMAP(
+    button,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLButtonAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(
+    caption,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      if (aContext->IsTable()) {
+        dom::HTMLTableElement* tableEl =
+            dom::HTMLTableElement::FromNode(aContext->GetContent());
+        if (tableEl && tableEl == aElement->GetParent() &&
+            tableEl->GetCaption() == aElement) {
+          return new HTMLCaptionAccessible(aElement, aContext->Document());
+        }
+      }
+      return nullptr;
+    },
+    0)
+
+MARKUPMAP(code, New_HyperText, roles::CODE)
+
+MARKUPMAP(dd, New_HTMLDtOrDd<HyperTextAccessible>, roles::DEFINITION)
+
+MARKUPMAP(del, New_HyperText, roles::CONTENT_DELETION)
+
+MARKUPMAP(details, New_HyperText, roles::DETAILS)
+
+MARKUPMAP(dfn, New_HyperText, roles::TERM)
+
+MARKUPMAP(dialog, New_HyperText, roles::DIALOG)
+
+MARKUPMAP(
+    div,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      // Never create an accessible if we're part of an anonymous
+      // subtree.
+      if (aElement->IsInNativeAnonymousSubtree()) {
+        return nullptr;
+      }
+      // Always create an accessible if the div has an id.
+      if (aElement->HasAttr(nsGkAtoms::id)) {
+        return new HyperTextAccessible(aElement, aContext->Document());
+      }
+      // Never create an accessible if the div is not display:block; or
+      // display:inline-block or the like.
+      nsIFrame* f = aElement->GetPrimaryFrame();
+      if (!f || !f->IsBlockFrameOrSubclass()) {
+        return nullptr;
+      }
+      // Check for various conditions to determine if this is a block
+      // break and needs to be rendered.
+      // If its previous sibling is an inline element, we probably want
+      // to break, so render.
+      // FIXME: This looks extremely incorrect in presence of shadow DOM,
+      // display: contents, and what not.
+      nsIContent* prevSibling = aElement->GetPreviousSibling();
+      if (prevSibling) {
+        nsIFrame* prevSiblingFrame = prevSibling->GetPrimaryFrame();
+        if (prevSiblingFrame && prevSiblingFrame->IsInlineOutside()) {
+          return new HyperTextAccessible(aElement, aContext->Document());
+        }
+      }
+      // Now, check the children.
+      nsIContent* firstChild = aElement->GetFirstChild();
+      if (firstChild) {
+        nsIFrame* firstChildFrame = firstChild->GetPrimaryFrame();
+        if (!firstChildFrame) {
+          // The first child is invisible, but this might be due to an
+          // invisible text node. Try the next.
+          firstChild = firstChild->GetNextSibling();
+          if (!firstChild) {
+            // If there's no next sibling, there's only one child, so there's
+            // nothing more we can do.
+            return nullptr;
+          }
+          firstChildFrame = firstChild->GetPrimaryFrame();
+        }
+        // Check to see if first child has an inline frame.
+        if (firstChildFrame && firstChildFrame->IsInlineOutside()) {
+          return new HyperTextAccessible(aElement, aContext->Document());
+        }
+        nsIContent* lastChild = aElement->GetLastChild();
+        MOZ_ASSERT(lastChild);
+        if (lastChild != firstChild) {
+          nsIFrame* lastChildFrame = lastChild->GetPrimaryFrame();
+          if (!lastChildFrame) {
+            // The last child is invisible, but this might be due to an
+            // invisible text node. Try the next.
+            lastChild = lastChild->GetPreviousSibling();
+            MOZ_ASSERT(lastChild);
+            if (lastChild == firstChild) {
+              return nullptr;
+            }
+            lastChildFrame = lastChild->GetPrimaryFrame();
+          }
+          // Check to see if last child has an inline frame.
+          if (lastChildFrame && lastChildFrame->IsInlineOutside()) {
+            return new HyperTextAccessible(aElement, aContext->Document());
+          }
+        }
+      }
+      return nullptr;
+    },
+    roles::SECTION)
+
+MARKUPMAP(
+    dl,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLListAccessible(aElement, aContext->Document());
+    },
+    roles::DEFINITION_LIST)
+
+MARKUPMAP(dt, New_HTMLDtOrDd<HTMLLIAccessible>, roles::TERM)
+
+MARKUPMAP(em, New_HyperText, roles::EMPHASIS)
+
+MARKUPMAP(
+    figcaption,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLFigcaptionAccessible(aElement, aContext->Document());
+    },
+    roles::CAPTION)
+
+MARKUPMAP(
+    figure,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLFigureAccessible(aElement, aContext->Document());
+    },
+    roles::FIGURE, Attr(xmlroles, figure))
+
+MARKUPMAP(
+    fieldset,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLGroupboxAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(
+    form,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLFormAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(
+    footer,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLHeaderOrFooterAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(
+    header,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLHeaderOrFooterAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(h1, New_HyperText, roles::HEADING)
+
+MARKUPMAP(h2, New_HyperText, roles::HEADING)
+
+MARKUPMAP(h3, New_HyperText, roles::HEADING)
+
+MARKUPMAP(h4, New_HyperText, roles::HEADING)
+
+MARKUPMAP(h5, New_HyperText, roles::HEADING)
+
+MARKUPMAP(h6, New_HyperText, roles::HEADING)
+
+MARKUPMAP(hgroup, New_HyperText, roles::GROUPING)
+
+MARKUPMAP(
+    hr,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLHRAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(
+    input,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      // TODO(emilio): This would be faster if it used
+      // HTMLInputElement's already-parsed representation.
+      if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::checkbox, eIgnoreCase)) {
+        return new CheckboxAccessible(aElement, aContext->Document());
+      }
+      if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::image, eIgnoreCase)) {
+        return new HTMLButtonAccessible(aElement, aContext->Document());
+      }
+      if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::radio, eIgnoreCase)) {
+        return new HTMLRadioButtonAccessible(aElement, aContext->Document());
+      }
+      if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::time, eIgnoreCase)) {
+        return new HTMLDateTimeAccessible<roles::TIME_EDITOR>(
+            aElement, aContext->Document());
+      }
+      if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::date, eIgnoreCase) ||
+          aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::datetime_local, eIgnoreCase)) {
+        return new HTMLDateTimeAccessible<roles::DATE_EDITOR>(
+            aElement, aContext->Document());
+      }
+      return nullptr;
+    },
+    0)
+
+MARKUPMAP(ins, New_HyperText, roles::CONTENT_INSERTION)
+
+MARKUPMAP(
+    label,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLLabelAccessible(aElement, aContext->Document());
+    },
+    roles::LABEL)
+
+MARKUPMAP(
+    legend,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLLegendAccessible(aElement, aContext->Document());
+    },
+    roles::LABEL)
+
+MARKUPMAP(
+    li,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      // If list item is a child of accessible list then create an
+      // accessible for it unconditionally by tag name. nsBlockFrame
+      // creates the list item accessible for other elements styled as
+      // list items.
+      if (aContext->IsList() &&
+          aContext->GetContent() == aElement->GetParent()) {
+        return new HTMLLIAccessible(aElement, aContext->Document());
+      }
+
+      return nullptr;
+    },
+    0)
+
+MARKUPMAP(main, New_HyperText, roles::LANDMARK)
+
+MARKUPMAP(map, nullptr, roles::TEXT_CONTAINER)
+
+MARKUPMAP(mark, New_HyperText, roles::MARK, Attr(xmlroles, mark))
+
+MARKUPMAP(
+    menu,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLListAccessible(aElement, aContext->Document());
+    },
+    roles::LIST)
+
+MARKUPMAP(nav, New_HyperText, roles::LANDMARK)
+
+MARKUPMAP(
+    ol,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLListAccessible(aElement, aContext->Document());
+    },
+    roles::LIST)
+
+MARKUPMAP(
+    option,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLSelectOptionAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(
+    optgroup,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLSelectOptGroupAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(
+    output,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLOutputAccessible(aElement, aContext->Document());
+    },
+    roles::STATUSBAR, Attr(aria_live, polite))
+
+MARKUPMAP(p, nullptr, roles::PARAGRAPH)
+
+MARKUPMAP(
+    progress,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLProgressAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(q, New_HyperText, 0)
+
+MARKUPMAP(s, New_HyperText, roles::CONTENT_DELETION)
+
+MARKUPMAP(
+    section,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLSectionAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(strong, New_HyperText, roles::STRONG)
+
+MARKUPMAP(sub, New_HyperText, roles::SUBSCRIPT)
+
+MARKUPMAP(
+    summary,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLSummaryAccessible(aElement, aContext->Document());
+    },
+    roles::SUMMARY)
+
+MARKUPMAP(sup, New_HyperText, roles::SUPERSCRIPT)
+
+MARKUPMAP(
+    table,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLTableAccessible(aElement, aContext->Document());
+    },
+    roles::TABLE)
+
+MARKUPMAP(time, New_HyperText, roles::TIME, Attr(xmlroles, time),
+          AttrFromDOM(datetime, datetime))
+
+MARKUPMAP(tbody, nullptr, roles::GROUPING)
+
+MARKUPMAP(
+    td,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      if (!aContext->IsHTMLTableRow()) {
+        return nullptr;
+      }
+      if (aElement->HasAttr(nsGkAtoms::scope)) {
+        return new HTMLTableHeaderCellAccessible(aElement,
+                                                 aContext->Document());
+      }
+      return new HTMLTableCellAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(tfoot, nullptr, roles::GROUPING)
+
+MARKUPMAP(
+    th,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      if (!aContext->IsHTMLTableRow()) {
+        return nullptr;
+      }
+      return new HTMLTableHeaderCellAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(thead, nullptr, roles::GROUPING)
+
+MARKUPMAP(
+    tr,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      if (aContext->IsTableRow()) {
+        // A <tr> within a row isn't valid.
+        return nullptr;
+      }
+      const nsRoleMapEntry* roleMapEntry = aria::GetRoleMap(aElement);
+      if (roleMapEntry && roleMapEntry->role != roles::NOTHING &&
+          roleMapEntry->role != roles::ROW) {
+        // There is a valid ARIA role which isn't "row". Don't treat this as an
+        // HTML table row.
+        return nullptr;
+      }
+      // Check if this <tr> is within a table. We check the grandparent because
+      // it might be inside a rowgroup. We don't specifically check for an HTML
+      // table because there are cases where there is a <tr> inside a
+      // <div role="table"> such as Monorail.
+      if (aContext->IsTable() ||
+          (aContext->LocalParent() && aContext->LocalParent()->IsTable())) {
+        return new HTMLTableRowAccessible(aElement, aContext->Document());
+      }
+      return nullptr;
+    },
+    roles::ROW)
+
+MARKUPMAP(
+    ul,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLListAccessible(aElement, aContext->Document());
+    },
+    roles::LIST)
+
+MARKUPMAP(
+    meter,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLMeterAccessible(aElement, aContext->Document());
+    },
+    roles::METER)
+
+MARKUPMAP(search, New_HyperText, roles::LANDMARK)
diff --git a/accessible/base/IDSet.h b/accessible/base/IDSet.h
new file mode 100644
index 0000000000..a149bf95a3
--- /dev/null
+++ b/accessible/base/IDSet.h
@@ -0,0 +1,129 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * A class to generate unique IDs in the range [ - 2^31, 0 )
+ */
+
+#ifndef MOZILLA_A11Y_IDSet_h_
+#define MOZILLA_A11Y_IDSet_h_
+
+#include "mozilla/Attributes.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/SplayTree.h"
+
+namespace mozilla {
+namespace a11y {
+
+/**
+ * On windows an accessible's id must be a negative 32 bit integer. It is
+ * important to support recycling arbitrary IDs because accessibles can be
+ * created and destroyed at any time in the life of a page.  IDSet provides 2
+ * operations: generate an ID in the range (0, mMaxId], and release an ID so
+ * it can be allocated again.  Allocated ID are tracked by a sparse bitmap
+ * implemented with a splay tree.  Nodes in the tree are keyed by the upper N
+ * bits of the ID, and the node contains a bitmap tracking the allocation of
+ * 2^(ceil(log2(mMaxId)) - N) IDs.
+ *
+ * Note that negation is handled by MsaaIdGenerator as it performs additional
+ * decoration on the ID generated by IDSet.
+ * @see mozilla::a11y::MsaaIdGenerator
+ */
+class IDSet {
+ public:
+  constexpr explicit IDSet(const uint32_t aMaxIdBits)
+      : mBitSet(),
+        mIdx(0),
+        mMaxId((1UL << aMaxIdBits) - 1UL),
+        mMaxIdx(mMaxId / bitsPerElt) {}
+
+  /**
+   * Return a new unique id.
+   */
+  uint32_t GetID() {
+    uint32_t idx = mIdx;
+    while (true) {
+      BitSetElt* elt = mBitSet.findOrInsert(BitSetElt(idx));
+      if (elt->mBitvec[0] != UINT64_MAX) {
+        uint32_t i = CountTrailingZeroes64(~elt->mBitvec[0]);
+
+        elt->mBitvec[0] |= (1ull << i);
+        mIdx = idx;
+        return (elt->mIdx * bitsPerElt + i);
+      }
+
+      if (elt->mBitvec[1] != UINT64_MAX) {
+        uint32_t i = CountTrailingZeroes64(~elt->mBitvec[1]);
+
+        elt->mBitvec[1] |= (1ull << i);
+        mIdx = idx;
+        return (elt->mIdx * bitsPerElt + bitsPerWord + i);
+      }
+
+      idx++;
+      if (idx > mMaxIdx) {
+        idx = 0;
+      }
+
+      if (idx == mIdx) {
+        MOZ_CRASH("used up all the available ids");
+      }
+    }
+  }
+
+  /**
+   * Free a no longer required id so it may be allocated again.
+   */
+  void ReleaseID(uint32_t aID) {
+    MOZ_ASSERT(aID < mMaxId);
+
+    uint32_t idx = aID / bitsPerElt;
+    mIdx = idx;
+    BitSetElt* elt = mBitSet.find(BitSetElt(idx));
+    MOZ_ASSERT(elt);
+
+    uint32_t vecIdx = (aID % bitsPerElt) / bitsPerWord;
+    elt->mBitvec[vecIdx] &= ~(1ull << (aID % bitsPerWord));
+    if (elt->mBitvec[0] == 0 && elt->mBitvec[1] == 0) {
+      delete mBitSet.remove(*elt);
+    }
+  }
+
+ private:
+  static const unsigned int wordsPerElt = 2;
+  static const unsigned int bitsPerWord = 64;
+  static const unsigned int bitsPerElt = wordsPerElt * bitsPerWord;
+
+  struct BitSetElt : mozilla::SplayTreeNode<BitSetElt> {
+    explicit BitSetElt(uint32_t aIdx) : mIdx(aIdx) {
+      mBitvec[0] = mBitvec[1] = 0;
+    }
+
+    uint64_t mBitvec[wordsPerElt];
+    uint32_t mIdx;
+
+    static int compare(const BitSetElt& a, const BitSetElt& b) {
+      if (a.mIdx == b.mIdx) {
+        return 0;
+      }
+
+      if (a.mIdx < b.mIdx) {
+        return -1;
+      }
+      return 1;
+    }
+  };
+
+  SplayTree<BitSetElt, BitSetElt> mBitSet;
+  uint32_t mIdx;
+  const uint32_t mMaxId;
+  const uint32_t mMaxIdx;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/Logging.cpp b/accessible/base/Logging.cpp
new file mode 100644
index 0000000000..67bf76ee5b
--- /dev/null
+++ b/accessible/base/Logging.cpp
@@ -0,0 +1,992 @@
+/* -*- 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 "Logging.h"
+
+#include "LocalAccessible-inl.h"
+#include "AccEvent.h"
+#include "DocAccessible.h"
+#include "DocAccessible-inl.h"
+#include "nsAccessibilityService.h"
+#include "nsCoreUtils.h"
+#include "OuterDocAccessible.h"
+
+#include "nsDocShellLoadTypes.h"
+#include "nsIChannel.h"
+#include "nsIWebProgress.h"
+#include "prenv.h"
+#include "nsIDocShellTreeItem.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StackWalk.h"
+#include "mozilla/ToString.h"
+#include "mozilla/dom/BorrowedAttrInfo.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/HTMLBodyElement.h"
+#include "mozilla/dom/Selection.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+using mozilla::dom::BorrowedAttrInfo;
+
+MOZ_DEFINE_MALLOC_SIZE_OF(AccessibleLoggingMallocSizeOf)
+
+////////////////////////////////////////////////////////////////////////////////
+// Logging helpers
+
+static uint32_t sModules = 0;
+
+struct ModuleRep {
+  const char* mStr;
+  logging::EModules mModule;
+};
+
+static ModuleRep sModuleMap[] = {{"docload", logging::eDocLoad},
+                                 {"doccreate", logging::eDocCreate},
+                                 {"docdestroy", logging::eDocDestroy},
+                                 {"doclifecycle", logging::eDocLifeCycle},
+
+                                 {"events", logging::eEvents},
+                                 {"platforms", logging::ePlatforms},
+                                 {"text", logging::eText},
+                                 {"tree", logging::eTree},
+                                 {"treeSize", logging::eTreeSize},
+
+                                 {"DOMEvents", logging::eDOMEvents},
+                                 {"focus", logging::eFocus},
+                                 {"selection", logging::eSelection},
+                                 {"notifications", logging::eNotifications},
+
+                                 {"stack", logging::eStack},
+                                 {"verbose", logging::eVerbose},
+                                 {"cache", logging::eCache}};
+
+static void EnableLogging(const char* aModulesStr) {
+  sModules = 0;
+  if (!aModulesStr) return;
+
+  const char* token = aModulesStr;
+  while (*token != '\0') {
+    size_t tokenLen = strcspn(token, ",");
+    for (unsigned int idx = 0; idx < ArrayLength(sModuleMap); idx++) {
+      if (strncmp(token, sModuleMap[idx].mStr, tokenLen) == 0) {
+#if !defined(MOZ_PROFILING) && (!defined(DEBUG) || defined(MOZ_OPTIMIZE))
+        // Stack tracing on profiling enabled or debug not optimized builds.
+        if (strncmp(token, "stack", tokenLen) == 0) break;
+#endif
+        sModules |= sModuleMap[idx].mModule;
+        printf("\n\nmodule enabled: %s\n", sModuleMap[idx].mStr);
+        break;
+      }
+    }
+    token += tokenLen;
+
+    if (*token == ',') token++;  // skip ',' char
+  }
+}
+
+static void LogDocURI(dom::Document* aDocumentNode) {
+  nsIURI* uri = aDocumentNode->GetDocumentURI();
+  if (uri) {
+    printf("uri: %s", uri->GetSpecOrDefault().get());
+  } else {
+    printf("uri: null");
+  }
+}
+
+static void LogDocShellState(dom::Document* aDocumentNode) {
+  printf("docshell busy: ");
+  nsCOMPtr<nsIDocShell> docShell = aDocumentNode->GetDocShell();
+  if (!docShell) {
+    printf("null docshell");
+    return;
+  }
+
+  nsAutoCString docShellBusy;
+  nsIDocShell::BusyFlags busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
+  docShell->GetBusyFlags(&busyFlags);
+  if (busyFlags == nsIDocShell::BUSY_FLAGS_NONE) {
+    printf("'none'");
+  }
+  if (busyFlags & nsIDocShell::BUSY_FLAGS_BUSY) {
+    printf("'busy'");
+  }
+  if (busyFlags & nsIDocShell::BUSY_FLAGS_BEFORE_PAGE_LOAD) {
+    printf(", 'before page load'");
+  }
+  if (busyFlags & nsIDocShell::BUSY_FLAGS_PAGE_LOADING) {
+    printf(", 'page loading'");
+  }
+}
+
+static void LogDocType(dom::Document* aDocumentNode) {
+  if (aDocumentNode->IsActive()) {
+    bool isContent = aDocumentNode->IsContentDocument();
+    printf("%s document", (isContent ? "content" : "chrome"));
+  } else {
+    printf("document type: [failed]");
+  }
+}
+
+static void LogDocShellTree(dom::Document* aDocumentNode) {
+  if (aDocumentNode->IsActive()) {
+    nsCOMPtr<nsIDocShellTreeItem> treeItem(aDocumentNode->GetDocShell());
+    if (!treeItem) {
+      printf("in-process docshell hierarchy, null docshell;");
+      return;
+    }
+    nsCOMPtr<nsIDocShellTreeItem> parentTreeItem;
+    treeItem->GetInProcessParent(getter_AddRefs(parentTreeItem));
+    nsCOMPtr<nsIDocShellTreeItem> rootTreeItem;
+    treeItem->GetInProcessRootTreeItem(getter_AddRefs(rootTreeItem));
+    printf(
+        "in-process docshell hierarchy, parent: %p, root: %p, "
+        "is top level: %s;",
+        static_cast<void*>(parentTreeItem), static_cast<void*>(rootTreeItem),
+        (nsCoreUtils::IsTopLevelContentDocInProcess(aDocumentNode) ? "yes"
+                                                                   : "no"));
+  }
+}
+
+static void LogDocState(dom::Document* aDocumentNode) {
+  const char* docState = nullptr;
+  dom::Document::ReadyState docStateFlag = aDocumentNode->GetReadyStateEnum();
+  switch (docStateFlag) {
+    case dom::Document::READYSTATE_UNINITIALIZED:
+      docState = "uninitialized";
+      break;
+    case dom::Document::READYSTATE_LOADING:
+      docState = "loading";
+      break;
+    case dom::Document::READYSTATE_INTERACTIVE:
+      docState = "interactive";
+      break;
+    case dom::Document::READYSTATE_COMPLETE:
+      docState = "complete";
+      break;
+  }
+
+  printf("doc state: %s", docState);
+  printf(", %sinitial", aDocumentNode->IsInitialDocument() ? "" : "not ");
+  printf(", %sshowing", aDocumentNode->IsShowing() ? "" : "not ");
+  printf(", %svisible", aDocumentNode->IsVisible() ? "" : "not ");
+  printf(
+      ", %svisible considering ancestors",
+      nsCoreUtils::IsDocumentVisibleConsideringInProcessAncestors(aDocumentNode)
+          ? ""
+          : "not ");
+  printf(", %sactive", aDocumentNode->IsActive() ? "" : "not ");
+  printf(", %sresource", aDocumentNode->IsResourceDoc() ? "" : "not ");
+
+  dom::Element* rootEl = aDocumentNode->GetBodyElement();
+  if (!rootEl) {
+    rootEl = aDocumentNode->GetRootElement();
+  }
+  printf(", has %srole content", rootEl ? "" : "no ");
+}
+
+static void LogPresShell(dom::Document* aDocumentNode) {
+  PresShell* presShell = aDocumentNode->GetPresShell();
+  printf("presshell: %p", static_cast<void*>(presShell));
+
+  nsIScrollableFrame* sf = nullptr;
+  if (presShell) {
+    printf(", is %s destroying", (presShell->IsDestroying() ? "" : "not"));
+    sf = presShell->GetRootScrollFrameAsScrollable();
+  }
+  printf(", root scroll frame: %p", static_cast<void*>(sf));
+}
+
+static void LogDocLoadGroup(dom::Document* aDocumentNode) {
+  nsCOMPtr<nsILoadGroup> loadGroup = aDocumentNode->GetDocumentLoadGroup();
+  printf("load group: %p", static_cast<void*>(loadGroup));
+}
+
+static void LogDocParent(dom::Document* aDocumentNode) {
+  dom::Document* parentDoc = aDocumentNode->GetInProcessParentDocument();
+  printf("parent DOM document: %p", static_cast<void*>(parentDoc));
+  if (parentDoc) {
+    printf(", parent acc document: %p",
+           static_cast<void*>(GetExistingDocAccessible(parentDoc)));
+    printf("\n    parent ");
+    LogDocURI(parentDoc);
+    printf("\n");
+  }
+}
+
+static void LogDocInfo(dom::Document* aDocumentNode, DocAccessible* aDocument) {
+  printf("    DOM document: %p, acc document: %p\n    ",
+         static_cast<void*>(aDocumentNode), static_cast<void*>(aDocument));
+
+  // log document info
+  if (aDocumentNode) {
+    LogDocURI(aDocumentNode);
+    printf("\n    ");
+    LogDocShellState(aDocumentNode);
+    printf("; ");
+    LogDocType(aDocumentNode);
+    printf("\n    ");
+    LogDocShellTree(aDocumentNode);
+    printf("\n    ");
+    LogDocState(aDocumentNode);
+    printf("\n    ");
+    LogPresShell(aDocumentNode);
+    printf("\n    ");
+    LogDocLoadGroup(aDocumentNode);
+    printf(", ");
+    LogDocParent(aDocumentNode);
+    printf("\n");
+  }
+}
+
+static void LogShellLoadType(nsIDocShell* aDocShell) {
+  printf("load type: ");
+
+  uint32_t loadType = 0;
+  aDocShell->GetLoadType(&loadType);
+  switch (loadType) {
+    case LOAD_NORMAL:
+      printf("normal; ");
+      break;
+    case LOAD_NORMAL_REPLACE:
+      printf("normal replace; ");
+      break;
+    case LOAD_HISTORY:
+      printf("history; ");
+      break;
+    case LOAD_NORMAL_BYPASS_CACHE:
+      printf("normal bypass cache; ");
+      break;
+    case LOAD_NORMAL_BYPASS_PROXY:
+      printf("normal bypass proxy; ");
+      break;
+    case LOAD_NORMAL_BYPASS_PROXY_AND_CACHE:
+      printf("normal bypass proxy and cache; ");
+      break;
+    case LOAD_RELOAD_NORMAL:
+      printf("reload normal; ");
+      break;
+    case LOAD_RELOAD_BYPASS_CACHE:
+      printf("reload bypass cache; ");
+      break;
+    case LOAD_RELOAD_BYPASS_PROXY:
+      printf("reload bypass proxy; ");
+      break;
+    case LOAD_RELOAD_BYPASS_PROXY_AND_CACHE:
+      printf("reload bypass proxy and cache; ");
+      break;
+    case LOAD_LINK:
+      printf("link; ");
+      break;
+    case LOAD_REFRESH:
+      printf("refresh; ");
+      break;
+    case LOAD_REFRESH_REPLACE:
+      printf("refresh replace; ");
+      break;
+    case LOAD_RELOAD_CHARSET_CHANGE:
+      printf("reload charset change; ");
+      break;
+    case LOAD_BYPASS_HISTORY:
+      printf("bypass history; ");
+      break;
+    case LOAD_STOP_CONTENT:
+      printf("stop content; ");
+      break;
+    case LOAD_STOP_CONTENT_AND_REPLACE:
+      printf("stop content and replace; ");
+      break;
+    case LOAD_PUSHSTATE:
+      printf("load pushstate; ");
+      break;
+    case LOAD_REPLACE_BYPASS_CACHE:
+      printf("replace bypass cache; ");
+      break;
+    case LOAD_ERROR_PAGE:
+      printf("error page;");
+      break;
+    default:
+      printf("unknown");
+  }
+}
+
+static void LogRequest(nsIRequest* aRequest) {
+  if (aRequest) {
+    nsAutoCString name;
+    aRequest->GetName(name);
+    printf("    request spec: %s\n", name.get());
+    uint32_t loadFlags = 0;
+    aRequest->GetLoadFlags(&loadFlags);
+    printf("    request load flags: %x; ", loadFlags);
+    if (loadFlags & nsIChannel::LOAD_DOCUMENT_URI) printf("document uri; ");
+    if (loadFlags & nsIChannel::LOAD_RETARGETED_DOCUMENT_URI) {
+      printf("retargeted document uri; ");
+    }
+    if (loadFlags & nsIChannel::LOAD_REPLACE) printf("replace; ");
+    if (loadFlags & nsIChannel::LOAD_INITIAL_DOCUMENT_URI) {
+      printf("initial document uri; ");
+    }
+    if (loadFlags & nsIChannel::LOAD_TARGETED) printf("targeted; ");
+    if (loadFlags & nsIChannel::LOAD_CALL_CONTENT_SNIFFERS) {
+      printf("call content sniffers; ");
+    }
+    if (loadFlags & nsIChannel::LOAD_BYPASS_URL_CLASSIFIER) {
+      printf("bypass classify uri; ");
+    }
+  } else {
+    printf("    no request");
+  }
+}
+
+static void LogDocAccState(DocAccessible* aDocument) {
+  printf("document acc state: ");
+  if (aDocument->HasLoadState(DocAccessible::eCompletelyLoaded)) {
+    printf("completely loaded;");
+  } else if (aDocument->HasLoadState(DocAccessible::eReady)) {
+    printf("ready;");
+  } else if (aDocument->HasLoadState(DocAccessible::eDOMLoaded)) {
+    printf("DOM loaded;");
+  } else if (aDocument->HasLoadState(DocAccessible::eTreeConstructed)) {
+    printf("tree constructed;");
+  }
+}
+
+static void GetDocLoadEventType(AccEvent* aEvent, nsACString& aEventType) {
+  uint32_t type = aEvent->GetEventType();
+  if (type == nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_STOPPED) {
+    aEventType.AssignLiteral("load stopped");
+  } else if (type == nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE) {
+    aEventType.AssignLiteral("load complete");
+  } else if (type == nsIAccessibleEvent::EVENT_DOCUMENT_RELOAD) {
+    aEventType.AssignLiteral("reload");
+  } else if (type == nsIAccessibleEvent::EVENT_STATE_CHANGE) {
+    AccStateChangeEvent* event = downcast_accEvent(aEvent);
+    if (event->GetState() == states::BUSY) {
+      aEventType.AssignLiteral("busy ");
+      if (event->IsStateEnabled()) {
+        aEventType.AppendLiteral("true");
+      } else {
+        aEventType.AppendLiteral("false");
+      }
+    }
+  }
+}
+
+static void DescribeNode(nsINode* aNode, nsAString& aOutDescription) {
+  if (!aNode) {
+    aOutDescription.AppendLiteral("null");
+    return;
+  }
+
+  aOutDescription.AppendPrintf("0x%p, ", (void*)aNode);
+  aOutDescription.Append(aNode->NodeInfo()->QualifiedName());
+
+  if (!aNode->IsElement()) {
+    return;
+  }
+
+  dom::Element* elm = aNode->AsElement();
+
+  nsAtom* idAtom = elm->GetID();
+  if (idAtom) {
+    nsAutoCString id;
+    idAtom->ToUTF8String(id);
+    aOutDescription.AppendPrintf("@id=\"%s\" ", id.get());
+  } else {
+    aOutDescription.Append(' ');
+  }
+
+  uint32_t attrCount = elm->GetAttrCount();
+  if (!attrCount || (idAtom && attrCount == 1)) {
+    return;
+  }
+
+  aOutDescription.AppendLiteral("[ ");
+
+  for (uint32_t index = 0; index < attrCount; index++) {
+    BorrowedAttrInfo info = elm->GetAttrInfoAt(index);
+
+    // Skip redundant display of id attribute.
+    if (info.mName->Equals(nsGkAtoms::id)) {
+      continue;
+    }
+
+    // name
+    nsAutoString name;
+    info.mName->GetQualifiedName(name);
+    aOutDescription.Append(name);
+
+    aOutDescription.AppendLiteral("=\"");
+
+    // value
+    nsAutoString value;
+    info.mValue->ToString(value);
+    for (uint32_t i = value.Length(); i > 0; --i) {
+      if (value[i - 1] == char16_t('"')) value.Insert(char16_t('\\'), i - 1);
+    }
+    aOutDescription.Append(value);
+    aOutDescription.AppendLiteral("\" ");
+  }
+
+  aOutDescription.Append(']');
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// namespace logging:: document life cycle logging methods
+
+static const char* sDocLoadTitle = "DOCLOAD";
+static const char* sDocCreateTitle = "DOCCREATE";
+static const char* sDocDestroyTitle = "DOCDESTROY";
+static const char* sDocEventTitle = "DOCEVENT";
+static const char* sFocusTitle = "FOCUS";
+
+void logging::DocLoad(const char* aMsg, nsIWebProgress* aWebProgress,
+                      nsIRequest* aRequest, uint32_t aStateFlags) {
+  MsgBegin(sDocLoadTitle, "%s", aMsg);
+
+  nsCOMPtr<mozIDOMWindowProxy> DOMWindow;
+  aWebProgress->GetDOMWindow(getter_AddRefs(DOMWindow));
+  nsPIDOMWindowOuter* window = nsPIDOMWindowOuter::From(DOMWindow);
+  if (!window) {
+    MsgEnd();
+    return;
+  }
+
+  nsCOMPtr<dom::Document> documentNode = window->GetDoc();
+  if (!documentNode) {
+    MsgEnd();
+    return;
+  }
+
+  DocAccessible* document = GetExistingDocAccessible(documentNode);
+
+  LogDocInfo(documentNode, document);
+
+  nsCOMPtr<nsIDocShell> docShell = window->GetDocShell();
+  printf("\n    ");
+  LogShellLoadType(docShell);
+  printf("\n");
+  LogRequest(aRequest);
+  printf("\n");
+  printf("    state flags: %x", aStateFlags);
+  bool isDocLoading;
+  aWebProgress->GetIsLoadingDocument(&isDocLoading);
+  printf(", document is %sloading\n", (isDocLoading ? "" : "not "));
+
+  MsgEnd();
+}
+
+void logging::DocLoad(const char* aMsg, dom::Document* aDocumentNode) {
+  MsgBegin(sDocLoadTitle, "%s", aMsg);
+
+  DocAccessible* document = GetExistingDocAccessible(aDocumentNode);
+  LogDocInfo(aDocumentNode, document);
+
+  MsgEnd();
+}
+
+void logging::DocCompleteLoad(DocAccessible* aDocument,
+                              bool aIsLoadEventTarget) {
+  MsgBegin(sDocLoadTitle, "document loaded *completely*");
+
+  printf("    DOM document: %p, acc document: %p\n",
+         static_cast<void*>(aDocument->DocumentNode()),
+         static_cast<void*>(aDocument));
+
+  printf("    ");
+  LogDocURI(aDocument->DocumentNode());
+  printf("\n");
+
+  printf("    ");
+  LogDocAccState(aDocument);
+  printf("\n");
+
+  printf("    document is load event target: %s\n",
+         (aIsLoadEventTarget ? "true" : "false"));
+
+  MsgEnd();
+}
+
+void logging::DocLoadEventFired(AccEvent* aEvent) {
+  nsAutoCString strEventType;
+  GetDocLoadEventType(aEvent, strEventType);
+  if (!strEventType.IsEmpty()) printf("  fire: %s\n", strEventType.get());
+}
+
+void logging::DocLoadEventHandled(AccEvent* aEvent) {
+  nsAutoCString strEventType;
+  GetDocLoadEventType(aEvent, strEventType);
+  if (strEventType.IsEmpty()) return;
+
+  MsgBegin(sDocEventTitle, "handled '%s' event", strEventType.get());
+
+  DocAccessible* document = aEvent->GetAccessible()->AsDoc();
+  if (document) LogDocInfo(document->DocumentNode(), document);
+
+  MsgEnd();
+}
+
+void logging::DocCreate(const char* aMsg, dom::Document* aDocumentNode,
+                        DocAccessible* aDocument) {
+  DocAccessible* document =
+      aDocument ? aDocument : GetExistingDocAccessible(aDocumentNode);
+
+  MsgBegin(sDocCreateTitle, "%s", aMsg);
+  LogDocInfo(aDocumentNode, document);
+  MsgEnd();
+}
+
+void logging::DocDestroy(const char* aMsg, dom::Document* aDocumentNode,
+                         DocAccessible* aDocument) {
+  DocAccessible* document =
+      aDocument ? aDocument : GetExistingDocAccessible(aDocumentNode);
+
+  MsgBegin(sDocDestroyTitle, "%s", aMsg);
+  LogDocInfo(aDocumentNode, document);
+  MsgEnd();
+}
+
+void logging::OuterDocDestroy(OuterDocAccessible* aOuterDoc) {
+  MsgBegin(sDocDestroyTitle, "outerdoc shutdown");
+  logging::Address("outerdoc", aOuterDoc);
+  MsgEnd();
+}
+
+void logging::FocusNotificationTarget(const char* aMsg,
+                                      const char* aTargetDescr,
+                                      LocalAccessible* aTarget) {
+  MsgBegin(sFocusTitle, "%s", aMsg);
+  AccessibleNNode(aTargetDescr, aTarget);
+  MsgEnd();
+}
+
+void logging::FocusNotificationTarget(const char* aMsg,
+                                      const char* aTargetDescr,
+                                      nsINode* aTargetNode) {
+  MsgBegin(sFocusTitle, "%s", aMsg);
+  Node(aTargetDescr, aTargetNode);
+  MsgEnd();
+}
+
+void logging::FocusNotificationTarget(const char* aMsg,
+                                      const char* aTargetDescr,
+                                      nsISupports* aTargetThing) {
+  MsgBegin(sFocusTitle, "%s", aMsg);
+
+  if (aTargetThing) {
+    nsCOMPtr<nsINode> targetNode(do_QueryInterface(aTargetThing));
+    if (targetNode) {
+      AccessibleNNode(aTargetDescr, targetNode);
+    } else {
+      printf("    %s: %p, window\n", aTargetDescr,
+             static_cast<void*>(aTargetThing));
+    }
+  }
+
+  MsgEnd();
+}
+
+void logging::ActiveItemChangeCausedBy(const char* aCause,
+                                       LocalAccessible* aTarget) {
+  SubMsgBegin();
+  printf("    Caused by: %s\n", aCause);
+  AccessibleNNode("Item", aTarget);
+  SubMsgEnd();
+}
+
+void logging::ActiveWidget(LocalAccessible* aWidget) {
+  SubMsgBegin();
+
+  AccessibleNNode("Widget", aWidget);
+  printf("    Widget is active: %s, has operable items: %s\n",
+         (aWidget && aWidget->IsActiveWidget() ? "true" : "false"),
+         (aWidget && aWidget->AreItemsOperable() ? "true" : "false"));
+
+  SubMsgEnd();
+}
+
+void logging::FocusDispatched(LocalAccessible* aTarget) {
+  SubMsgBegin();
+  AccessibleNNode("A11y target", aTarget);
+  SubMsgEnd();
+}
+
+void logging::SelChange(dom::Selection* aSelection, DocAccessible* aDocument,
+                        int16_t aReason) {
+  SelectionType type = aSelection->GetType();
+
+  const char* strType = 0;
+  if (type == SelectionType::eNormal) {
+    strType = "normal";
+  } else if (type == SelectionType::eSpellCheck) {
+    strType = "spellcheck";
+  } else {
+    strType = "unknown";
+  }
+
+  bool isIgnored = !aDocument || !aDocument->IsContentLoaded();
+  printf(
+      "\nSelection changed, selection type: %s, notification %s, reason: %d\n",
+      strType, (isIgnored ? "ignored" : "pending"), aReason);
+
+  Stack();
+}
+
+void logging::TreeInfo(const char* aMsg, uint32_t aExtraFlags, ...) {
+  if (IsEnabledAll(logging::eTree | aExtraFlags)) {
+    va_list vl;
+    va_start(vl, aExtraFlags);
+    const char* descr = va_arg(vl, const char*);
+    if (descr) {
+      LocalAccessible* acc = va_arg(vl, LocalAccessible*);
+      MsgBegin("TREE", "%s; doc: %p", aMsg, acc ? acc->Document() : nullptr);
+      AccessibleInfo(descr, acc);
+      while ((descr = va_arg(vl, const char*))) {
+        AccessibleInfo(descr, va_arg(vl, LocalAccessible*));
+      }
+    } else {
+      MsgBegin("TREE", "%s", aMsg);
+    }
+    va_end(vl);
+    MsgEnd();
+
+    if (aExtraFlags & eStack) {
+      Stack();
+    }
+  }
+}
+
+void logging::TreeInfo(const char* aMsg, uint32_t aExtraFlags,
+                       const char* aMsg1, LocalAccessible* aAcc,
+                       const char* aMsg2, nsINode* aNode) {
+  if (IsEnabledAll(logging::eTree | aExtraFlags)) {
+    MsgBegin("TREE", "%s; doc: %p", aMsg, aAcc ? aAcc->Document() : nullptr);
+    AccessibleInfo(aMsg1, aAcc);
+    LocalAccessible* acc =
+        aAcc ? aAcc->Document()->GetAccessible(aNode) : nullptr;
+    if (acc) {
+      AccessibleInfo(aMsg2, acc);
+    } else {
+      Node(aMsg2, aNode);
+    }
+    MsgEnd();
+  }
+}
+
+void logging::TreeInfo(const char* aMsg, uint32_t aExtraFlags,
+                       LocalAccessible* aParent) {
+  if (IsEnabledAll(logging::eTree | aExtraFlags)) {
+    MsgBegin("TREE", "%s; doc: %p", aMsg, aParent->Document());
+    AccessibleInfo("container", aParent);
+    for (uint32_t idx = 0; idx < aParent->ChildCount(); idx++) {
+      AccessibleInfo("child", aParent->LocalChildAt(idx));
+    }
+    MsgEnd();
+  }
+}
+
+void logging::Tree(const char* aTitle, const char* aMsgText,
+                   LocalAccessible* aRoot, GetTreePrefix aPrefixFunc,
+                   void* aGetTreePrefixData) {
+  logging::MsgBegin(aTitle, "%s", aMsgText);
+
+  nsAutoString level;
+  LocalAccessible* root = aRoot;
+  do {
+    const char* prefix =
+        aPrefixFunc ? aPrefixFunc(aGetTreePrefixData, root) : "";
+    printf("%s", NS_ConvertUTF16toUTF8(level).get());
+    logging::AccessibleInfo(prefix, root);
+    if (root->LocalFirstChild() && !root->LocalFirstChild()->IsDoc()) {
+      level.AppendLiteral(u"  ");
+      root = root->LocalFirstChild();
+      continue;
+    }
+    int32_t idxInParent = root != aRoot && root->mParent
+                              ? root->mParent->mChildren.IndexOf(root)
+                              : -1;
+    if (idxInParent != -1 &&
+        idxInParent <
+            static_cast<int32_t>(root->mParent->mChildren.Length() - 1)) {
+      root = root->mParent->mChildren.ElementAt(idxInParent + 1);
+      continue;
+    }
+    while (root != aRoot && (root = root->LocalParent())) {
+      level.Cut(0, 2);
+      int32_t idxInParent = !root->IsDoc() && root->mParent
+                                ? root->mParent->mChildren.IndexOf(root)
+                                : -1;
+      if (idxInParent != -1 &&
+          idxInParent <
+              static_cast<int32_t>(root->mParent->mChildren.Length() - 1)) {
+        root = root->mParent->mChildren.ElementAt(idxInParent + 1);
+        break;
+      }
+    }
+  } while (root && root != aRoot);
+
+  logging::MsgEnd();
+}
+
+void logging::DOMTree(const char* aTitle, const char* aMsgText,
+                      DocAccessible* aDocument) {
+  logging::MsgBegin(aTitle, "%s", aMsgText);
+  nsAutoString level;
+  nsINode* root = aDocument->DocumentNode();
+  do {
+    printf("%s", NS_ConvertUTF16toUTF8(level).get());
+    logging::Node("", root);
+    if (root->GetFirstChild()) {
+      level.AppendLiteral(u"  ");
+      root = root->GetFirstChild();
+      continue;
+    }
+    if (root->GetNextSibling()) {
+      root = root->GetNextSibling();
+      continue;
+    }
+    while ((root = root->GetParentNode())) {
+      level.Cut(0, 2);
+      if (root->GetNextSibling()) {
+        root = root->GetNextSibling();
+        break;
+      }
+    }
+  } while (root);
+  logging::MsgEnd();
+}
+
+void logging::TreeSize(const char* aTitle, const char* aMsgText,
+                       LocalAccessible* aRoot) {
+  logging::MsgBegin(aTitle, "%s", aMsgText);
+  logging::AccessibleInfo("Logging tree size from: ", aRoot);
+  size_t b = 0;
+  size_t n = 0;
+  LocalAccessible* root = aRoot;
+  do {
+    // Process the current acc
+    b += AccessibleLoggingMallocSizeOf(root);
+    n++;
+
+    // Get next acc
+    if (root->LocalFirstChild() && !root->LocalFirstChild()->IsDoc()) {
+      root = root->LocalFirstChild();
+      continue;
+    }
+    int32_t idxInParent = root != aRoot && root->mParent
+                              ? root->mParent->mChildren.IndexOf(root)
+                              : -1;
+    if (idxInParent != -1 &&
+        idxInParent <
+            static_cast<int32_t>(root->mParent->mChildren.Length() - 1)) {
+      root = root->mParent->mChildren.ElementAt(idxInParent + 1);
+      continue;
+    }
+    while (root != aRoot && (root = root->LocalParent())) {
+      int32_t idxInParent = !root->IsDoc() && root->mParent
+                                ? root->mParent->mChildren.IndexOf(root)
+                                : -1;
+      if (idxInParent != -1 &&
+          idxInParent <
+              static_cast<int32_t>(root->mParent->mChildren.Length() - 1)) {
+        root = root->mParent->mChildren.ElementAt(idxInParent + 1);
+        break;
+      }
+    }
+  } while (root && root != aRoot);
+
+  printf("\nTree contains %zu accessibles and is %zu bytes\n", n, b);
+  logging::MsgEnd();
+}
+
+void logging::MsgBegin(const char* aTitle, const char* aMsgText, ...) {
+  printf("\nA11Y %s: ", aTitle);
+
+  va_list argptr;
+  va_start(argptr, aMsgText);
+  vprintf(aMsgText, argptr);
+  va_end(argptr);
+
+  PRIntervalTime time = PR_IntervalNow();
+  uint32_t mins = (PR_IntervalToSeconds(time) / 60) % 60;
+  uint32_t secs = PR_IntervalToSeconds(time) % 60;
+  uint32_t msecs = PR_IntervalToMilliseconds(time) % 1000;
+  printf("; %02u:%02u.%03u", mins, secs, msecs);
+
+  printf("\n  {\n");
+}
+
+void logging::MsgEnd() { printf("  }\n"); }
+
+void logging::SubMsgBegin() { printf("  {\n"); }
+
+void logging::SubMsgEnd() { printf("  }\n"); }
+
+void logging::MsgEntry(const char* aEntryText, ...) {
+  printf("    ");
+
+  va_list argptr;
+  va_start(argptr, aEntryText);
+  vprintf(aEntryText, argptr);
+  va_end(argptr);
+
+  printf("\n");
+}
+
+void logging::Text(const char* aText) { printf("  %s\n", aText); }
+
+void logging::Address(const char* aDescr, LocalAccessible* aAcc) {
+  if (!aAcc->IsDoc()) {
+    printf("    %s accessible: %p, node: %p\n", aDescr,
+           static_cast<void*>(aAcc), static_cast<void*>(aAcc->GetNode()));
+  }
+
+  DocAccessible* doc = aAcc->Document();
+  dom::Document* docNode = doc->DocumentNode();
+  printf("    document: %p, node: %p\n", static_cast<void*>(doc),
+         static_cast<void*>(docNode));
+
+  printf("    ");
+  LogDocURI(docNode);
+  printf("\n");
+}
+
+void logging::Node(const char* aDescr, nsINode* aNode) {
+  Maybe<uint32_t> idxInParent = aNode->ComputeIndexInParentNode();
+  nsAutoString nodeDesc;
+  DescribeNode(aNode, nodeDesc);
+  printf("    %s: %s, idx in parent %s\n", aDescr,
+         NS_ConvertUTF16toUTF8(nodeDesc).get(), ToString(idxInParent).c_str());
+}
+
+void logging::Document(DocAccessible* aDocument) {
+  printf("    Document: %p, document node: %p\n", static_cast<void*>(aDocument),
+         static_cast<void*>(aDocument->DocumentNode()));
+
+  printf("    Document ");
+  LogDocURI(aDocument->DocumentNode());
+  printf("\n");
+}
+
+void logging::AccessibleInfo(const char* aDescr, LocalAccessible* aAccessible) {
+  printf("    %s: %p; ", aDescr, static_cast<void*>(aAccessible));
+  if (!aAccessible) {
+    printf("\n");
+    return;
+  }
+  if (aAccessible->IsDefunct()) {
+    printf("defunct\n");
+    return;
+  }
+  if (!aAccessible->Document() || aAccessible->Document()->IsDefunct()) {
+    printf("document is shutting down, no info\n");
+    return;
+  }
+
+  nsAutoString role;
+  GetAccService()->GetStringRole(aAccessible->Role(), role);
+  printf("role: %s", NS_ConvertUTF16toUTF8(role).get());
+
+  nsAutoString name;
+  aAccessible->Name(name);
+  if (!name.IsEmpty()) {
+    printf(", name: '%s'", NS_ConvertUTF16toUTF8(name).get());
+  }
+
+  printf(", idx: %d", aAccessible->IndexInParent());
+
+  nsAutoString nodeDesc;
+  DescribeNode(aAccessible->GetNode(), nodeDesc);
+  printf(", node: %s\n", NS_ConvertUTF16toUTF8(nodeDesc).get());
+}
+
+void logging::AccessibleNNode(const char* aDescr,
+                              LocalAccessible* aAccessible) {
+  printf("    %s: %p; ", aDescr, static_cast<void*>(aAccessible));
+  if (!aAccessible) return;
+
+  nsAutoString role;
+  GetAccService()->GetStringRole(aAccessible->Role(), role);
+  nsAutoString name;
+  aAccessible->Name(name);
+
+  printf("role: %s, name: '%s';\n", NS_ConvertUTF16toUTF8(role).get(),
+         NS_ConvertUTF16toUTF8(name).get());
+
+  nsAutoCString nodeDescr(aDescr);
+  nodeDescr.AppendLiteral(" node");
+  Node(nodeDescr.get(), aAccessible->GetNode());
+
+  Document(aAccessible->Document());
+}
+
+void logging::AccessibleNNode(const char* aDescr, nsINode* aNode) {
+  DocAccessible* document =
+      GetAccService()->GetDocAccessible(aNode->OwnerDoc());
+
+  if (document) {
+    LocalAccessible* accessible = document->GetAccessible(aNode);
+    if (accessible) {
+      AccessibleNNode(aDescr, accessible);
+      return;
+    }
+  }
+
+  nsAutoCString nodeDescr("[not accessible] ");
+  nodeDescr.Append(aDescr);
+  Node(nodeDescr.get(), aNode);
+
+  if (document) {
+    Document(document);
+    return;
+  }
+
+  printf("    [contained by not accessible document]:\n");
+  LogDocInfo(aNode->OwnerDoc(), document);
+  printf("\n");
+}
+
+void logging::DOMEvent(const char* aDescr, nsINode* aOrigTarget,
+                       const nsAString& aEventType) {
+  logging::MsgBegin("DOMEvents", "event '%s' %s",
+                    NS_ConvertUTF16toUTF8(aEventType).get(), aDescr);
+  logging::AccessibleNNode("Target", aOrigTarget);
+  logging::MsgEnd();
+}
+
+void logging::Stack() {
+  if (IsEnabled(eStack)) {
+    printf("  stack: \n");
+    MozWalkTheStack(stdout);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// namespace logging:: initialization
+
+bool logging::IsEnabled(uint32_t aModules) { return sModules & aModules; }
+
+bool logging::IsEnabledAll(uint32_t aModules) {
+  return (sModules & aModules) == aModules;
+}
+
+bool logging::IsEnabled(const nsAString& aModuleStr) {
+  for (unsigned int idx = 0; idx < ArrayLength(sModuleMap); idx++) {
+    if (aModuleStr.EqualsASCII(sModuleMap[idx].mStr)) {
+      return sModules & sModuleMap[idx].mModule;
+    }
+  }
+
+  return false;
+}
+
+void logging::Enable(const nsCString& aModules) {
+  EnableLogging(aModules.get());
+}
+
+void logging::CheckEnv() { EnableLogging(PR_GetEnv("A11YLOG")); }
diff --git a/accessible/base/Logging.h b/accessible/base/Logging.h
new file mode 100644
index 0000000000..2a6a93faa9
--- /dev/null
+++ b/accessible/base/Logging.h
@@ -0,0 +1,236 @@
+/* -*- 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_logs_h__
+#define mozilla_a11y_logs_h__
+
+#include "nscore.h"
+#include "nsStringFwd.h"
+#include "mozilla/Attributes.h"
+
+class nsINode;
+class nsIRequest;
+class nsISupports;
+class nsIWebProgress;
+
+namespace mozilla {
+
+namespace dom {
+class Document;
+class Selection;
+}  // namespace dom
+
+namespace a11y {
+
+class AccEvent;
+class LocalAccessible;
+class DocAccessible;
+class OuterDocAccessible;
+
+namespace logging {
+
+enum EModules {
+  eDocLoad = 1 << 0,
+  eDocCreate = 1 << 1,
+  eDocDestroy = 1 << 2,
+  eDocLifeCycle = eDocLoad | eDocCreate | eDocDestroy,
+
+  eEvents = 1 << 3,
+  ePlatforms = 1 << 4,
+  eText = 1 << 5,
+  eTree = 1 << 6,
+  eTreeSize = 1 << 7,
+
+  eDOMEvents = 1 << 8,
+  eFocus = 1 << 9,
+  eSelection = 1 << 10,
+  eNotifications = eDOMEvents | eSelection | eFocus,
+
+  // extras
+  eStack = 1 << 11,
+  eVerbose = 1 << 12,
+  eCache = 1 << 13,
+};
+
+/**
+ * Return true if any of the given modules is logged.
+ */
+bool IsEnabled(uint32_t aModules);
+
+/**
+ * Return true if all of the given modules are logged.
+ */
+bool IsEnabledAll(uint32_t aModules);
+
+/**
+ * Return true if the given module is logged.
+ */
+bool IsEnabled(const nsAString& aModules);
+
+/**
+ * Log the document loading progress.
+ */
+void DocLoad(const char* aMsg, nsIWebProgress* aWebProgress,
+             nsIRequest* aRequest, uint32_t aStateFlags);
+void DocLoad(const char* aMsg, dom::Document* aDocumentNode);
+void DocCompleteLoad(DocAccessible* aDocument, bool aIsLoadEventTarget);
+
+/**
+ * Log that document load event was fired.
+ */
+void DocLoadEventFired(AccEvent* aEvent);
+
+/**
+ * Log that document laod event was handled.
+ */
+void DocLoadEventHandled(AccEvent* aEvent);
+
+/**
+ * Log the document was created.
+ */
+void DocCreate(const char* aMsg, dom::Document* aDocumentNode,
+               DocAccessible* aDocument = nullptr);
+
+/**
+ * Log the document was destroyed.
+ */
+void DocDestroy(const char* aMsg, dom::Document* aDocumentNode,
+                DocAccessible* aDocument = nullptr);
+
+/**
+ * Log the outer document was destroyed.
+ */
+void OuterDocDestroy(OuterDocAccessible* OuterDoc);
+
+/**
+ * Log the focus notification target.
+ */
+void FocusNotificationTarget(const char* aMsg, const char* aTargetDescr,
+                             LocalAccessible* aTarget);
+void FocusNotificationTarget(const char* aMsg, const char* aTargetDescr,
+                             nsINode* aTargetNode);
+void FocusNotificationTarget(const char* aMsg, const char* aTargetDescr,
+                             nsISupports* aTargetThing);
+
+/**
+ * Log a cause of active item descendant change (submessage).
+ */
+void ActiveItemChangeCausedBy(const char* aMsg, LocalAccessible* aTarget);
+
+/**
+ * Log the active widget (submessage).
+ */
+void ActiveWidget(LocalAccessible* aWidget);
+
+/**
+ * Log the focus event was dispatched (submessage).
+ */
+void FocusDispatched(LocalAccessible* aTarget);
+
+/**
+ * Log the selection change.
+ */
+void SelChange(dom::Selection* aSelection, DocAccessible* aDocument,
+               int16_t aReason);
+
+/**
+ * Log the given accessible elements info.
+ */
+void TreeInfo(const char* aMsg, uint32_t aExtraFlags, ...);
+void TreeInfo(const char* aMsg, uint32_t aExtraFlags, const char* aMsg1,
+              LocalAccessible* aAcc, const char* aMsg2, nsINode* aNode);
+void TreeInfo(const char* aMsg, uint32_t aExtraFlags, LocalAccessible* aParent);
+
+/**
+ * Log the accessible/DOM tree.
+ */
+typedef const char* (*GetTreePrefix)(void* aData, LocalAccessible*);
+void Tree(const char* aTitle, const char* aMsgText, LocalAccessible* aRoot,
+          GetTreePrefix aPrefixFunc = nullptr,
+          void* aGetTreePrefixData = nullptr);
+void DOMTree(const char* aTitle, const char* aMsgText, DocAccessible* aDoc);
+
+/**
+ * Log the tree size in bytes.
+ */
+void TreeSize(const char* aTitle, const char* aMsgText, LocalAccessible* aRoot);
+
+/**
+ * Log the message ('title: text' format) on new line. Print the start and end
+ * boundaries of the message body designated by '{' and '}' (2 spaces indent for
+ * body).
+ */
+void MsgBegin(const char* aTitle, const char* aMsgText, ...)
+    MOZ_FORMAT_PRINTF(2, 3);
+void MsgEnd();
+
+/**
+ * Print start and end boundaries of the message body designated by '{' and '}'
+ * (2 spaces indent for body).
+ */
+void SubMsgBegin();
+void SubMsgEnd();
+
+/**
+ * Log the entry into message body (4 spaces indent).
+ */
+void MsgEntry(const char* aEntryText, ...) MOZ_FORMAT_PRINTF(1, 2);
+
+/**
+ * Log the text, two spaces offset is used.
+ */
+void Text(const char* aText);
+
+/**
+ * Log the accessible object address as message entry (4 spaces indent).
+ */
+void Address(const char* aDescr, LocalAccessible* aAcc);
+
+/**
+ * Log the DOM node info as message entry.
+ */
+void Node(const char* aDescr, nsINode* aNode);
+
+/**
+ * Log the document accessible info as message entry.
+ */
+void Document(DocAccessible* aDocument);
+
+/**
+ * Log the accessible and its DOM node as a message entry.
+ */
+void AccessibleInfo(const char* aDescr, LocalAccessible* aAccessible);
+void AccessibleNNode(const char* aDescr, LocalAccessible* aAccessible);
+void AccessibleNNode(const char* aDescr, nsINode* aNode);
+
+/**
+ * Log the DOM event.
+ */
+void DOMEvent(const char* aDescr, nsINode* aOrigTarget,
+              const nsAString& aEventType);
+
+/**
+ * Log the call stack, two spaces offset is used.
+ */
+void Stack();
+
+/**
+ * Enable logging of the specified modules, all other modules aren't logged.
+ */
+void Enable(const nsCString& aModules);
+
+/**
+ * Enable logging of modules specified by A11YLOG environment variable,
+ * all other modules aren't logged.
+ */
+void CheckEnv();
+
+}  // namespace logging
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/MathMLMarkupMap.h b/accessible/base/MathMLMarkupMap.h
new file mode 100644
index 0000000000..a03dccb358
--- /dev/null
+++ b/accessible/base/MathMLMarkupMap.h
@@ -0,0 +1,113 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=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/. */
+
+MARKUPMAP(math, New_HyperText, roles::MATHML_MATH)
+
+MARKUPMAP(mi_, New_HyperText, roles::MATHML_IDENTIFIER)
+
+MARKUPMAP(mn_, New_HyperText, roles::MATHML_NUMBER)
+
+MARKUPMAP(mo_, New_HyperText, roles::MATHML_OPERATOR,
+          AttrFromDOM(accent_, accent_), AttrFromDOM(fence_, fence_),
+          AttrFromDOM(separator_, separator_), AttrFromDOM(largeop_, largeop_))
+
+MARKUPMAP(mtext_, New_HyperText, roles::MATHML_TEXT)
+
+MARKUPMAP(ms_, New_HyperText, roles::MATHML_STRING_LITERAL)
+
+MARKUPMAP(mglyph_, New_HyperText, roles::MATHML_GLYPH)
+
+MARKUPMAP(mrow_, New_HyperText, roles::MATHML_ROW)
+
+MARKUPMAP(mfrac_, New_HyperText, roles::MATHML_FRACTION,
+          AttrFromDOM(bevelled_, bevelled_),
+          AttrFromDOM(linethickness_, linethickness_))
+
+MARKUPMAP(msqrt_, New_HyperText, roles::MATHML_SQUARE_ROOT)
+
+MARKUPMAP(mroot_, New_HyperText, roles::MATHML_ROOT)
+
+MARKUPMAP(mfenced_, New_HyperText, roles::MATHML_ROW)
+
+MARKUPMAP(menclose_, New_HyperText, roles::MATHML_ENCLOSED,
+          AttrFromDOM(notation_, notation_))
+
+MARKUPMAP(mstyle_, New_HyperText, roles::MATHML_STYLE)
+
+MARKUPMAP(msub_, New_HyperText, roles::MATHML_SUB)
+
+MARKUPMAP(msup_, New_HyperText, roles::MATHML_SUP)
+
+MARKUPMAP(msubsup_, New_HyperText, roles::MATHML_SUB_SUP)
+
+MARKUPMAP(munder_, New_HyperText, roles::MATHML_UNDER,
+          AttrFromDOM(accentunder_, accentunder_), AttrFromDOM(align, align))
+
+MARKUPMAP(mover_, New_HyperText, roles::MATHML_OVER,
+          AttrFromDOM(accent_, accent_), AttrFromDOM(align, align))
+
+MARKUPMAP(munderover_, New_HyperText, roles::MATHML_UNDER_OVER,
+          AttrFromDOM(accent_, accent_),
+          AttrFromDOM(accentunder_, accentunder_), AttrFromDOM(align, align))
+
+MARKUPMAP(mmultiscripts_, New_HyperText, roles::MATHML_MULTISCRIPTS)
+
+MARKUPMAP(
+    mtable_,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLTableAccessible(aElement, aContext->Document());
+    },
+    roles::MATHML_TABLE, AttrFromDOM(align, align),
+    AttrFromDOM(columnlines_, columnlines_), AttrFromDOM(rowlines_, rowlines_))
+
+MARKUPMAP(
+    mlabeledtr_,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLTableRowAccessible(aElement, aContext->Document());
+    },
+    roles::MATHML_LABELED_ROW)
+
+MARKUPMAP(
+    mtr_,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLTableRowAccessible(aElement, aContext->Document());
+    },
+    roles::MATHML_TABLE_ROW)
+
+MARKUPMAP(
+    mtd_,
+    [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+      return new HTMLTableCellAccessible(aElement, aContext->Document());
+    },
+    0)
+
+MARKUPMAP(maction_, New_HyperText, roles::MATHML_ACTION,
+          AttrFromDOM(actiontype_, actiontype_),
+          AttrFromDOM(selection_, selection_))
+
+MARKUPMAP(merror_, New_HyperText, roles::MATHML_ERROR)
+
+MARKUPMAP(mstack_, New_HyperText, roles::MATHML_STACK,
+          AttrFromDOM(align, align), AttrFromDOM(position, position))
+
+MARKUPMAP(mlongdiv_, New_HyperText, roles::MATHML_LONG_DIVISION,
+          AttrFromDOM(longdivstyle_, longdivstyle_))
+
+MARKUPMAP(msgroup_, New_HyperText, roles::MATHML_STACK_GROUP,
+          AttrFromDOM(position, position), AttrFromDOM(shift_, shift_))
+
+MARKUPMAP(msrow_, New_HyperText, roles::MATHML_STACK_ROW,
+          AttrFromDOM(position, position))
+
+MARKUPMAP(mscarries_, New_HyperText, roles::MATHML_STACK_CARRIES,
+          AttrFromDOM(location_, location_), AttrFromDOM(position, position))
+
+MARKUPMAP(mscarry_, New_HyperText, roles::MATHML_STACK_CARRY,
+          AttrFromDOM(crossout_, crossout_))
+
+MARKUPMAP(msline_, New_HyperText, roles::MATHML_STACK_LINE,
+          AttrFromDOM(position, position))
diff --git a/accessible/base/NotificationController.cpp b/accessible/base/NotificationController.cpp
new file mode 100644
index 0000000000..63786861f1
--- /dev/null
+++ b/accessible/base/NotificationController.cpp
@@ -0,0 +1,1107 @@
+/* -*- 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 "NotificationController.h"
+
+#include "DocAccessible-inl.h"
+#include "DocAccessibleChild.h"
+#include "LocalAccessible-inl.h"
+#include "nsEventShell.h"
+#include "TextLeafAccessible.h"
+#include "TextUpdater.h"
+
+#include "nsIContentInlines.h"
+
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/ipc/ProcessChild.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "nsAccessibilityService.h"
+#include "mozilla/Telemetry.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+using namespace mozilla::dom;
+
+////////////////////////////////////////////////////////////////////////////////
+// NotificationCollector
+////////////////////////////////////////////////////////////////////////////////
+
+NotificationController::NotificationController(DocAccessible* aDocument,
+                                               PresShell* aPresShell)
+    : EventQueue(aDocument),
+      mObservingState(eNotObservingRefresh),
+      mPresShell(aPresShell),
+      mEventGeneration(0) {
+  // Schedule initial accessible tree construction.
+  ScheduleProcessing();
+}
+
+NotificationController::~NotificationController() {
+  NS_ASSERTION(!mDocument, "Controller wasn't shutdown properly!");
+  if (mDocument) {
+    Shutdown();
+  }
+  MOZ_RELEASE_ASSERT(mObservingState == eNotObservingRefresh,
+                     "Must unregister before being destroyed");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NotificationCollector: AddRef/Release and cycle collection
+
+NS_IMPL_CYCLE_COLLECTING_NATIVE_ADDREF(NotificationController)
+NS_IMPL_CYCLE_COLLECTING_NATIVE_RELEASE(NotificationController)
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(NotificationController)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(NotificationController)
+  if (tmp->mDocument) {
+    tmp->Shutdown();
+  }
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(NotificationController)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHangingChildDocuments)
+  for (const auto& entry : tmp->mContentInsertions) {
+    NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mContentInsertions key");
+    cb.NoteXPCOMChild(entry.GetKey());
+    nsTArray<nsCOMPtr<nsIContent>>* list = entry.GetData().get();
+    for (uint32_t i = 0; i < list->Length(); i++) {
+      NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mContentInsertions value item");
+      cb.NoteXPCOMChild(list->ElementAt(i));
+    }
+  }
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFocusEvent)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEvents)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRelocations)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+////////////////////////////////////////////////////////////////////////////////
+// NotificationCollector: public
+
+void NotificationController::Shutdown() {
+  if (mObservingState != eNotObservingRefresh &&
+      mPresShell->RemoveRefreshObserver(this, FlushType::Display)) {
+    // Note, this was our last chance to unregister, since we're about to
+    // clear mPresShell further down in this function.
+    mObservingState = eNotObservingRefresh;
+  }
+  MOZ_RELEASE_ASSERT(mObservingState == eNotObservingRefresh,
+                     "Must unregister before being destroyed (and we just "
+                     "passed our last change to unregister)");
+  // Immediately null out mPresShell, to prevent us from being registered as a
+  // refresh observer again.
+  mPresShell = nullptr;
+
+  // Shutdown handling child documents.
+  int32_t childDocCount = mHangingChildDocuments.Length();
+  for (int32_t idx = childDocCount - 1; idx >= 0; idx--) {
+    if (!mHangingChildDocuments[idx]->IsDefunct()) {
+      mHangingChildDocuments[idx]->Shutdown();
+    }
+  }
+
+  mHangingChildDocuments.Clear();
+
+  mDocument = nullptr;
+
+  mTextArray.Clear();
+  mContentInsertions.Clear();
+  mNotifications.Clear();
+  mFocusEvent = nullptr;
+  mEvents.Clear();
+  mRelocations.Clear();
+}
+
+void NotificationController::CoalesceHideEvent(AccHideEvent* aHideEvent) {
+  LocalAccessible* parent = aHideEvent->LocalParent();
+  while (parent) {
+    if (parent->IsDoc()) {
+      break;
+    }
+
+    if (parent->HideEventTarget()) {
+      DropMutationEvent(aHideEvent);
+      break;
+    }
+
+    if (parent->ShowEventTarget()) {
+      AccShowEvent* showEvent =
+          downcast_accEvent(mMutationMap.GetEvent(parent, EventMap::ShowEvent));
+      if (showEvent->EventGeneration() < aHideEvent->EventGeneration()) {
+        DropMutationEvent(aHideEvent);
+        break;
+      }
+    }
+
+    parent = parent->LocalParent();
+  }
+}
+
+bool NotificationController::QueueMutationEvent(AccTreeMutationEvent* aEvent) {
+  if (aEvent->GetEventType() == nsIAccessibleEvent::EVENT_HIDE) {
+    // We have to allow there to be a hide and then a show event for a target
+    // because of targets getting moved.  However we need to coalesce a show and
+    // then a hide for a target which means we need to check for that here.
+    if (aEvent->GetAccessible()->ShowEventTarget()) {
+      AccTreeMutationEvent* showEvent =
+          mMutationMap.GetEvent(aEvent->GetAccessible(), EventMap::ShowEvent);
+      DropMutationEvent(showEvent);
+      return false;
+    }
+
+    // Don't queue a hide event on an accessible that's already being moved. It
+    // or an ancestor should already have a hide event queued.
+    if (mDocument &&
+        mDocument->IsAccessibleBeingMoved(aEvent->GetAccessible())) {
+      return false;
+    }
+
+    // If this is an additional hide event, the accessible may be hidden, or
+    // moved again after a move. Preserve the original hide event since
+    // its properties are consistent with the tree that existed before
+    // the next batch of mutation events is processed.
+    if (aEvent->GetAccessible()->HideEventTarget()) {
+      return false;
+    }
+  }
+
+  AccMutationEvent* mutEvent = downcast_accEvent(aEvent);
+  mEventGeneration++;
+  mutEvent->SetEventGeneration(mEventGeneration);
+
+  if (!mFirstMutationEvent) {
+    mFirstMutationEvent = aEvent;
+    ScheduleProcessing();
+  }
+
+  if (mLastMutationEvent) {
+    NS_ASSERTION(!mLastMutationEvent->NextEvent(),
+                 "why isn't the last event the end?");
+    mLastMutationEvent->SetNextEvent(aEvent);
+  }
+
+  aEvent->SetPrevEvent(mLastMutationEvent);
+  mLastMutationEvent = aEvent;
+  mMutationMap.PutEvent(aEvent);
+
+  // Because we could be hiding the target of a show event we need to get rid
+  // of any such events.
+  if (aEvent->GetEventType() == nsIAccessibleEvent::EVENT_HIDE) {
+    CoalesceHideEvent(downcast_accEvent(aEvent));
+
+    // mLastMutationEvent will point to something other than aEvent if and only
+    // if aEvent was just coalesced away.  In that case a parent accessible
+    // must already have the required reorder and text change events so we are
+    // done here.
+    if (mLastMutationEvent != aEvent) {
+      return false;
+    }
+  }
+
+  // We need to fire a reorder event after all of the events targeted at shown
+  // or hidden children of a container.  So either queue a new one, or move an
+  // existing one to the end of the queue if the container already has a
+  // reorder event.
+  LocalAccessible* container = aEvent->GetAccessible()->LocalParent();
+  RefPtr<AccReorderEvent> reorder;
+  if (!container->ReorderEventTarget()) {
+    reorder = new AccReorderEvent(container);
+    container->SetReorderEventTarget(true);
+    mMutationMap.PutEvent(reorder);
+
+    // Since this is the first child of container that is changing, the name
+    // and/or description of dependent Accessibles may be changing.
+    if (PushNameOrDescriptionChange(aEvent)) {
+      ScheduleProcessing();
+    }
+  } else {
+    AccReorderEvent* event = downcast_accEvent(
+        mMutationMap.GetEvent(container, EventMap::ReorderEvent));
+    reorder = event;
+    if (mFirstMutationEvent == event) {
+      mFirstMutationEvent = event->NextEvent();
+    } else {
+      event->PrevEvent()->SetNextEvent(event->NextEvent());
+    }
+
+    event->NextEvent()->SetPrevEvent(event->PrevEvent());
+    event->SetNextEvent(nullptr);
+  }
+
+  reorder->SetEventGeneration(mEventGeneration);
+  reorder->SetPrevEvent(mLastMutationEvent);
+  mLastMutationEvent->SetNextEvent(reorder);
+  mLastMutationEvent = reorder;
+
+  // It is not possible to have a text change event for something other than a
+  // hyper text accessible.
+  if (!container->IsHyperText()) {
+    return true;
+  }
+
+  MOZ_ASSERT(mutEvent);
+
+  nsString text;
+  aEvent->GetAccessible()->AppendTextTo(text);
+  if (text.IsEmpty()) {
+    return true;
+  }
+
+  LocalAccessible* target = aEvent->GetAccessible();
+  int32_t offset = container->AsHyperText()->GetChildOffset(target);
+  AccTreeMutationEvent* prevEvent = aEvent->PrevEvent();
+  while (prevEvent &&
+         prevEvent->GetEventType() == nsIAccessibleEvent::EVENT_REORDER) {
+    prevEvent = prevEvent->PrevEvent();
+  }
+
+  if (prevEvent &&
+      prevEvent->GetEventType() == nsIAccessibleEvent::EVENT_HIDE &&
+      mutEvent->IsHide()) {
+    AccHideEvent* prevHide = downcast_accEvent(prevEvent);
+    AccTextChangeEvent* prevTextChange = prevHide->mTextChangeEvent;
+    if (prevTextChange && prevHide->LocalParent() == mutEvent->LocalParent()) {
+      if (prevHide->mNextSibling == target) {
+        target->AppendTextTo(prevTextChange->mModifiedText);
+        prevHide->mTextChangeEvent.swap(mutEvent->mTextChangeEvent);
+      } else if (prevHide->mPrevSibling == target) {
+        nsString temp;
+        target->AppendTextTo(temp);
+
+        uint32_t extraLen = temp.Length();
+        temp += prevTextChange->mModifiedText;
+        ;
+        prevTextChange->mModifiedText = temp;
+        prevTextChange->mStart -= extraLen;
+        prevHide->mTextChangeEvent.swap(mutEvent->mTextChangeEvent);
+      }
+    }
+  } else if (prevEvent && mutEvent->IsShow() &&
+             prevEvent->GetEventType() == nsIAccessibleEvent::EVENT_SHOW) {
+    AccShowEvent* prevShow = downcast_accEvent(prevEvent);
+    AccTextChangeEvent* prevTextChange = prevShow->mTextChangeEvent;
+    if (prevTextChange && prevShow->LocalParent() == target->LocalParent()) {
+      int32_t index = target->IndexInParent();
+      int32_t prevIndex = prevShow->GetAccessible()->IndexInParent();
+      if (prevIndex + 1 == index) {
+        target->AppendTextTo(prevTextChange->mModifiedText);
+        prevShow->mTextChangeEvent.swap(mutEvent->mTextChangeEvent);
+      } else if (index + 1 == prevIndex) {
+        nsString temp;
+        target->AppendTextTo(temp);
+        prevTextChange->mStart -= temp.Length();
+        temp += prevTextChange->mModifiedText;
+        prevTextChange->mModifiedText = temp;
+        prevShow->mTextChangeEvent.swap(mutEvent->mTextChangeEvent);
+      }
+    }
+  }
+
+  if (!mutEvent->mTextChangeEvent) {
+    mutEvent->mTextChangeEvent = new AccTextChangeEvent(
+        container, offset, text, mutEvent->IsShow(),
+        aEvent->mIsFromUserInput ? eFromUserInput : eNoUserInput);
+  }
+
+  return true;
+}
+
+void NotificationController::DropMutationEvent(AccTreeMutationEvent* aEvent) {
+  const uint32_t eventType = aEvent->GetEventType();
+  MOZ_ASSERT(eventType != nsIAccessibleEvent::EVENT_INNER_REORDER,
+             "Inner reorder has already been dropped, cannot drop again");
+  if (eventType == nsIAccessibleEvent::EVENT_REORDER) {
+    // We don't fully drop reorder events, we just change them to inner reorder
+    // events.
+    AccReorderEvent* reorderEvent = downcast_accEvent(aEvent);
+
+    MOZ_ASSERT(reorderEvent);
+    reorderEvent->SetInner();
+    return;
+  }
+  if (eventType == nsIAccessibleEvent::EVENT_SHOW) {
+    // unset the event bits since the event isn't being fired any more.
+    aEvent->GetAccessible()->SetShowEventTarget(false);
+  } else if (eventType == nsIAccessibleEvent::EVENT_HIDE) {
+    // unset the event bits since the event isn't being fired any more.
+    aEvent->GetAccessible()->SetHideEventTarget(false);
+
+    AccHideEvent* hideEvent = downcast_accEvent(aEvent);
+    MOZ_ASSERT(hideEvent);
+
+    if (hideEvent->NeedsShutdown()) {
+      mDocument->ShutdownChildrenInSubtree(aEvent->GetAccessible());
+    }
+  } else {
+    MOZ_ASSERT_UNREACHABLE("Mutation event has non-mutation event type");
+  }
+
+  // Do the work to splice the event out of the list.
+  if (mFirstMutationEvent == aEvent) {
+    mFirstMutationEvent = aEvent->NextEvent();
+  } else {
+    aEvent->PrevEvent()->SetNextEvent(aEvent->NextEvent());
+  }
+
+  if (mLastMutationEvent == aEvent) {
+    mLastMutationEvent = aEvent->PrevEvent();
+  } else {
+    aEvent->NextEvent()->SetPrevEvent(aEvent->PrevEvent());
+  }
+
+  aEvent->SetPrevEvent(nullptr);
+  aEvent->SetNextEvent(nullptr);
+  mMutationMap.RemoveEvent(aEvent);
+}
+
+void NotificationController::CoalesceMutationEvents() {
+  AccTreeMutationEvent* event = mFirstMutationEvent;
+  while (event) {
+    AccTreeMutationEvent* nextEvent = event->NextEvent();
+    uint32_t eventType = event->GetEventType();
+    if (event->GetEventType() == nsIAccessibleEvent::EVENT_REORDER) {
+      LocalAccessible* acc = event->GetAccessible();
+      while (acc) {
+        if (acc->IsDoc()) {
+          break;
+        }
+
+        // if a parent of the reorder event's target is being hidden that
+        // hide event's target must have a parent that is also a reorder event
+        // target.  That means we don't need this reorder event.
+        if (acc->HideEventTarget()) {
+          DropMutationEvent(event);
+          break;
+        }
+
+        LocalAccessible* parent = acc->LocalParent();
+        if (parent && parent->ReorderEventTarget()) {
+          AccReorderEvent* reorder = downcast_accEvent(
+              mMutationMap.GetEvent(parent, EventMap::ReorderEvent));
+
+          // We want to make sure that a reorder event comes after any show or
+          // hide events targeted at the children of its target.  We keep the
+          // invariant that event generation goes up as you are farther in the
+          // queue, so we want to use the spot of the event with the higher
+          // generation number, and keep that generation number.
+          if (reorder &&
+              reorder->EventGeneration() < event->EventGeneration()) {
+            reorder->SetEventGeneration(event->EventGeneration());
+
+            // It may be true that reorder was before event, and we coalesced
+            // away all the show / hide events between them.  In that case
+            // event is already immediately after reorder in the queue and we
+            // do not need to rearrange the list of events.
+            if (event != reorder->NextEvent()) {
+              // There really should be a show or hide event before the first
+              // reorder event.
+              if (reorder->PrevEvent()) {
+                reorder->PrevEvent()->SetNextEvent(reorder->NextEvent());
+              } else {
+                mFirstMutationEvent = reorder->NextEvent();
+              }
+
+              reorder->NextEvent()->SetPrevEvent(reorder->PrevEvent());
+              event->PrevEvent()->SetNextEvent(reorder);
+              reorder->SetPrevEvent(event->PrevEvent());
+              event->SetPrevEvent(reorder);
+              reorder->SetNextEvent(event);
+            }
+          }
+          DropMutationEvent(event);
+          break;
+        }
+
+        acc = parent;
+      }
+    } else if (eventType == nsIAccessibleEvent::EVENT_SHOW) {
+      LocalAccessible* parent = event->GetAccessible()->LocalParent();
+      while (parent) {
+        if (parent->IsDoc()) {
+          break;
+        }
+
+        // if the parent of a show event is being either shown or hidden then
+        // we don't need to fire a show event for a subtree of that change.
+        if (parent->ShowEventTarget() || parent->HideEventTarget()) {
+          DropMutationEvent(event);
+          break;
+        }
+
+        parent = parent->LocalParent();
+      }
+    } else if (eventType == nsIAccessibleEvent::EVENT_HIDE) {
+      MOZ_ASSERT(eventType == nsIAccessibleEvent::EVENT_HIDE,
+                 "mutation event list has an invalid event");
+
+      AccHideEvent* hideEvent = downcast_accEvent(event);
+      CoalesceHideEvent(hideEvent);
+    }
+
+    event = nextEvent;
+  }
+}
+
+void NotificationController::ScheduleChildDocBinding(DocAccessible* aDocument) {
+  // Schedule child document binding to the tree.
+  mHangingChildDocuments.AppendElement(aDocument);
+  ScheduleProcessing();
+}
+
+void NotificationController::ScheduleContentInsertion(
+    LocalAccessible* aContainer, nsTArray<nsCOMPtr<nsIContent>>& aInsertions) {
+  if (!aInsertions.IsEmpty()) {
+    mContentInsertions.GetOrInsertNew(aContainer)->AppendElements(aInsertions);
+    ScheduleProcessing();
+  }
+}
+
+void NotificationController::ScheduleProcessing() {
+  // If notification flush isn't planned yet, start notification flush
+  // asynchronously (after style and layout).
+  // Note: the mPresShell null-check might be unnecessary; it's just to prevent
+  // a null-deref here, if we somehow get called after we've been shut down.
+  if (mObservingState == eNotObservingRefresh && mPresShell) {
+    if (mPresShell->AddRefreshObserver(this, FlushType::Display,
+                                       "Accessibility notifications")) {
+      mObservingState = eRefreshObserving;
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NotificationCollector: protected
+
+bool NotificationController::IsUpdatePending() {
+  return mPresShell->IsLayoutFlushObserver() ||
+         mObservingState == eRefreshProcessingForUpdate || WaitingForParent() ||
+         mContentInsertions.Count() != 0 || mNotifications.Length() != 0 ||
+         !mTextArray.IsEmpty() ||
+         !mDocument->HasLoadState(DocAccessible::eTreeConstructed);
+}
+
+bool NotificationController::WaitingForParent() {
+  DocAccessible* parentdoc = mDocument->ParentDocument();
+  if (!parentdoc) {
+    return false;
+  }
+
+  NotificationController* parent = parentdoc->mNotificationController;
+  if (!parent || parent == this) {
+    // Do not wait for nothing or ourselves
+    return false;
+  }
+
+  // Wait for parent's notifications processing
+  return parent->mContentInsertions.Count() != 0 ||
+         parent->mNotifications.Length() != 0;
+}
+
+void NotificationController::ProcessMutationEvents() {
+  // Firing an event can indirectly run script; e.g. an XPCOM event observer
+  // or querying a XUL interface. Further mutations might be queued as a result.
+  // It's important that the mutation queue and state bits from one tick don't
+  // interfere with the next tick. Otherwise, we can end up dropping events.
+  // Therefore:
+  // 1. Clear the state bits, which we only need for coalescence.
+  for (AccTreeMutationEvent* event = mFirstMutationEvent; event;
+       event = event->NextEvent()) {
+    LocalAccessible* acc = event->GetAccessible();
+    acc->SetShowEventTarget(false);
+    acc->SetHideEventTarget(false);
+    acc->SetReorderEventTarget(false);
+  }
+  // 2. Keep the current queue locally, but clear the queue on the instance.
+  RefPtr<AccTreeMutationEvent> firstEvent = mFirstMutationEvent;
+  mFirstMutationEvent = mLastMutationEvent = nullptr;
+  mMutationMap.Clear();
+  mEventGeneration = 0;
+
+  // Group the show events by the parent of their target.
+  nsTHashMap<nsPtrHashKey<LocalAccessible>, nsTArray<AccTreeMutationEvent*>>
+      showEvents;
+  for (AccTreeMutationEvent* event = firstEvent; event;
+       event = event->NextEvent()) {
+    if (event->GetEventType() != nsIAccessibleEvent::EVENT_SHOW) {
+      continue;
+    }
+
+    LocalAccessible* parent = event->GetAccessible()->LocalParent();
+    showEvents.LookupOrInsert(parent).AppendElement(event);
+  }
+
+  // We need to fire show events for the children of an accessible in the order
+  // of their indices at this point.  So sort each set of events for the same
+  // container by the index of their target. We do this before firing any events
+  // because firing an event might indirectly run script which might alter the
+  // tree, breaking our sort. However, we don't actually fire the events yet.
+  for (auto iter = showEvents.Iter(); !iter.Done(); iter.Next()) {
+    struct AccIdxComparator {
+      bool LessThan(const AccTreeMutationEvent* a,
+                    const AccTreeMutationEvent* b) const {
+        int32_t aIdx = a->GetAccessible()->IndexInParent();
+        int32_t bIdx = b->GetAccessible()->IndexInParent();
+        MOZ_ASSERT(aIdx >= 0 && bIdx >= 0 && (a == b || aIdx != bIdx));
+        return aIdx < bIdx;
+      }
+      bool Equals(const AccTreeMutationEvent* a,
+                  const AccTreeMutationEvent* b) const {
+        DebugOnly<int32_t> aIdx = a->GetAccessible()->IndexInParent();
+        DebugOnly<int32_t> bIdx = b->GetAccessible()->IndexInParent();
+        MOZ_ASSERT(aIdx >= 0 && bIdx >= 0 && (a == b || aIdx != bIdx));
+        return a == b;
+      }
+    };
+
+    nsTArray<AccTreeMutationEvent*>& events = iter.Data();
+    events.Sort(AccIdxComparator());
+  }
+
+  // there is no reason to fire a hide event for a child of a show event
+  // target.  That can happen if something is inserted into the tree and
+  // removed before the next refresh driver tick, but it should not be
+  // observable outside gecko so it should be safe to coalesce away any such
+  // events.  This means that it should be fine to fire all of the hide events
+  // first, and then deal with any shown subtrees.
+  for (AccTreeMutationEvent* event = firstEvent; event;
+       event = event->NextEvent()) {
+    if (event->GetEventType() != nsIAccessibleEvent::EVENT_HIDE) {
+      continue;
+    }
+
+    nsEventShell::FireEvent(event);
+    if (!mDocument) {
+      return;
+    }
+
+    AccMutationEvent* mutEvent = downcast_accEvent(event);
+    if (mutEvent->mTextChangeEvent) {
+      nsEventShell::FireEvent(mutEvent->mTextChangeEvent);
+      if (!mDocument) {
+        return;
+      }
+    }
+
+    // Fire menupopup end event before a hide event if a menu goes away.
+
+    // XXX: We don't look into children of hidden subtree to find hiding
+    // menupopup (as we did prior bug 570275) because we don't do that when
+    // menu is showing (and that's impossible until bug 606924 is fixed).
+    // Nevertheless we should do this at least because layout coalesces
+    // the changes before our processing and we may miss some menupopup
+    // events. Now we just want to be consistent in content insertion/removal
+    // handling.
+    if (event->mAccessible->ARIARole() == roles::MENUPOPUP) {
+      nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_MENUPOPUP_END,
+                              event->mAccessible);
+      if (!mDocument) {
+        return;
+      }
+    }
+
+    AccHideEvent* hideEvent = downcast_accEvent(event);
+    if (hideEvent->NeedsShutdown()) {
+      mDocument->ShutdownChildrenInSubtree(event->mAccessible);
+    }
+  }
+
+  // Fire the show events we sorted earlier.
+  for (auto iter = showEvents.Iter(); !iter.Done(); iter.Next()) {
+    nsTArray<AccTreeMutationEvent*>& events = iter.Data();
+    for (AccTreeMutationEvent* event : events) {
+      nsEventShell::FireEvent(event);
+      if (!mDocument) {
+        return;
+      }
+
+      AccMutationEvent* mutEvent = downcast_accEvent(event);
+      if (mutEvent->mTextChangeEvent) {
+        nsEventShell::FireEvent(mutEvent->mTextChangeEvent);
+        if (!mDocument) {
+          return;
+        }
+      }
+    }
+  }
+
+  // Now we can fire the reorder events after all the show and hide events.
+  for (const uint32_t reorderType : {nsIAccessibleEvent::EVENT_INNER_REORDER,
+                                     nsIAccessibleEvent::EVENT_REORDER}) {
+    for (AccTreeMutationEvent* event = firstEvent; event;
+         event = event->NextEvent()) {
+      if (event->GetEventType() != reorderType) {
+        continue;
+      }
+
+      if (event->GetAccessible()->IsDefunct()) {
+        // An inner reorder target may have been hidden itself and no
+        // longer bound to the document.
+        MOZ_ASSERT(reorderType == nsIAccessibleEvent::EVENT_INNER_REORDER,
+                   "An 'outer' reorder target should not be defunct");
+        continue;
+      }
+
+      nsEventShell::FireEvent(event);
+      if (!mDocument) {
+        return;
+      }
+
+      LocalAccessible* target = event->GetAccessible();
+      target->Document()->MaybeNotifyOfValueChange(target);
+      if (!mDocument) {
+        return;
+      }
+    }
+  }
+
+  // Our events are in a doubly linked list. Clear the pointers to reduce
+  // pressure on the cycle collector. Even though clearing the previous pointers
+  // removes cycles, this isn't enough. The cycle collector still gets bogged
+  // down when there are lots of mutation events if the next pointers aren't
+  // cleared. Even without the cycle collector, not clearing the next pointers
+  // potentially results in deep recursion because releasing each event releases
+  // its next event.
+  RefPtr<AccTreeMutationEvent> event = firstEvent;
+  while (event) {
+    RefPtr<AccTreeMutationEvent> next = event->NextEvent();
+    event->SetNextEvent(nullptr);
+    event->SetPrevEvent(nullptr);
+    event = next;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NotificationCollector: private
+
+void NotificationController::WillRefresh(mozilla::TimeStamp aTime) {
+  AUTO_PROFILER_MARKER_TEXT("NotificationController::WillRefresh", A11Y, {},
+                            ""_ns);
+  Telemetry::AutoTimer<Telemetry::A11Y_TREE_UPDATE_TIMING_MS> timer;
+  // DO NOT ADD CODE ABOVE THIS BLOCK: THIS CODE IS MEASURING TIMINGS.
+
+  AUTO_PROFILER_LABEL("NotificationController::WillRefresh", A11Y);
+
+  // If mDocument is null, the document accessible that this notification
+  // controller was created for is now shut down. This means we've lost our
+  // ability to unregister ourselves, which is bad. (However, it also shouldn't
+  // be logically possible for us to get here with a null mDocument; the only
+  // thing that clears that pointer is our Shutdown() method, which first
+  // unregisters and fatally asserts if that fails).
+  MOZ_RELEASE_ASSERT(
+      mDocument,
+      "The document was shut down while refresh observer is attached!");
+
+  if (ipc::ProcessChild::ExpectingShutdown()) {
+    return;
+  }
+
+  // Wait until an update, we have started, or an interruptible reflow is
+  // finished. We also check the existance of our pres context and root pres
+  // context, since if we can't reach either of these the frame tree is being
+  // destroyed.
+  nsPresContext* pc = mPresShell->GetPresContext();
+  if (mObservingState == eRefreshProcessing ||
+      mObservingState == eRefreshProcessingForUpdate ||
+      mPresShell->IsReflowInterrupted() || !pc || !pc->GetRootPresContext()) {
+    return;
+  }
+
+  // Process parent's notifications before ours, to get proper ordering between
+  // e.g. tab event and content event.
+  if (WaitingForParent()) {
+    mDocument->ParentDocument()->mNotificationController->WillRefresh(aTime);
+    if (!mDocument || ipc::ProcessChild::ExpectingShutdown()) {
+      return;
+    }
+  }
+
+  // Any generic notifications should be queued if we're processing content
+  // insertions or generic notifications.
+  mObservingState = eRefreshProcessingForUpdate;
+
+  // Initial accessible tree construction.
+  if (!mDocument->HasLoadState(DocAccessible::eTreeConstructed)) {
+    // (1) If document is not bound to parent at this point, or
+    // (2) the PresShell is not initialized (and it isn't about:blank),
+    // then the document is not ready yet (process notifications later).
+    if (!mDocument->IsBoundToParent() ||
+        (!mPresShell->DidInitialize() &&
+         !mDocument->DocumentNode()->IsInitialDocument())) {
+      mObservingState = eRefreshObserving;
+      return;
+    }
+
+#ifdef A11Y_LOG
+    if (logging::IsEnabled(logging::eTree)) {
+      logging::MsgBegin("TREE", "initial tree created");
+      logging::Address("document", mDocument);
+      logging::MsgEnd();
+    }
+#endif
+
+    mDocument->DoInitialUpdate();
+    if (ipc::ProcessChild::ExpectingShutdown()) {
+      return;
+    }
+
+    NS_ASSERTION(mContentInsertions.Count() == 0,
+                 "Pending content insertions while initial accessible tree "
+                 "isn't created!");
+  }
+
+  mDocument->ProcessPendingUpdates();
+
+  // Process rendered text change notifications. Even though we want to process
+  // them in the order in which they were queued, we still want to avoid
+  // duplicates.
+  nsTHashSet<nsIContent*> textHash;
+  for (nsIContent* textNode : mTextArray) {
+    if (!textHash.EnsureInserted(textNode)) {
+      continue;  // Already processed.
+    }
+    LocalAccessible* textAcc = mDocument->GetAccessible(textNode);
+
+    // If the text node is not in tree or doesn't have a frame, or placed in
+    // another document, then this case should have been handled already by
+    // content removal notifications.
+    nsINode* containerNode = textNode->GetFlattenedTreeParentNode();
+    if (!containerNode || textNode->OwnerDoc() != mDocument->DocumentNode()) {
+      MOZ_ASSERT(!textAcc,
+                 "Text node was removed but accessible is kept alive!");
+      continue;
+    }
+
+    nsIFrame* textFrame = textNode->GetPrimaryFrame();
+    if (!textFrame) {
+      MOZ_ASSERT(!textAcc,
+                 "Text node isn't rendered but accessible is kept alive!");
+      continue;
+    }
+
+#ifdef A11Y_LOG
+    nsIContent* containerElm =
+        containerNode->IsElement() ? containerNode->AsElement() : nullptr;
+#endif
+
+    nsIFrame::RenderedText text = textFrame->GetRenderedText(
+        0, UINT32_MAX, nsIFrame::TextOffsetType::OffsetsInContentText,
+        nsIFrame::TrailingWhitespace::DontTrim);
+
+    // Remove text accessible if rendered text is empty.
+    if (textAcc) {
+      if (text.mString.IsEmpty()) {
+#ifdef A11Y_LOG
+        if (logging::IsEnabled(logging::eTree | logging::eText)) {
+          logging::MsgBegin("TREE", "text node lost its content; doc: %p",
+                            mDocument);
+          logging::Node("container", containerElm);
+          logging::Node("content", textNode);
+          logging::MsgEnd();
+        }
+#endif
+
+        mDocument->ContentRemoved(textAcc);
+        continue;
+      }
+
+      // Update text of the accessible and fire text change events.
+#ifdef A11Y_LOG
+      if (logging::IsEnabled(logging::eText)) {
+        logging::MsgBegin("TEXT", "text may be changed; doc: %p", mDocument);
+        logging::Node("container", containerElm);
+        logging::Node("content", textNode);
+        logging::MsgEntry(
+            "old text '%s'",
+            NS_ConvertUTF16toUTF8(textAcc->AsTextLeaf()->Text()).get());
+        logging::MsgEntry("new text: '%s'",
+                          NS_ConvertUTF16toUTF8(text.mString).get());
+        logging::MsgEnd();
+      }
+#endif
+
+      TextUpdater::Run(mDocument, textAcc->AsTextLeaf(), text.mString);
+      continue;
+    }
+
+    // Append an accessible if rendered text is not empty.
+    if (!text.mString.IsEmpty()) {
+#ifdef A11Y_LOG
+      if (logging::IsEnabled(logging::eTree | logging::eText)) {
+        logging::MsgBegin("TREE", "text node gains new content; doc: %p",
+                          mDocument);
+        logging::Node("container", containerElm);
+        logging::Node("content", textNode);
+        logging::MsgEnd();
+      }
+#endif
+
+      MOZ_ASSERT(mDocument->AccessibleOrTrueContainer(containerNode),
+                 "Text node having rendered text hasn't accessible document!");
+
+      LocalAccessible* container =
+          mDocument->AccessibleOrTrueContainer(containerNode, true);
+      if (container) {
+        nsTArray<nsCOMPtr<nsIContent>>* list =
+            mContentInsertions.GetOrInsertNew(container);
+        list->AppendElement(textNode);
+      }
+    }
+  }
+  textHash.Clear();
+  mTextArray.Clear();
+
+  // Process content inserted notifications to update the tree.
+  // Processing an insertion can indirectly run script (e.g. querying a XUL
+  // interface), which might result in another insertion being queued.
+  // We don't want to lose any queued insertions if this happens. Therefore, we
+  // move the current insertions into a temporary data structure and process
+  // them from there. Any insertions queued during processing will get handled
+  // in subsequent refresh driver ticks.
+  const auto contentInsertions = std::move(mContentInsertions);
+  for (const auto& entry : contentInsertions) {
+    mDocument->ProcessContentInserted(entry.GetKey(), entry.GetData().get());
+    if (!mDocument) {
+      return;
+    }
+  }
+
+  // Bind hanging child documents unless we are using IPC and the
+  // document has no IPC actor.  If we fail to bind the child doc then
+  // shut it down.
+  uint32_t hangingDocCnt = mHangingChildDocuments.Length();
+  nsTArray<RefPtr<DocAccessible>> newChildDocs;
+  for (uint32_t idx = 0; idx < hangingDocCnt; idx++) {
+    DocAccessible* childDoc = mHangingChildDocuments[idx];
+    if (childDoc->IsDefunct()) {
+      continue;
+    }
+
+    if (IPCAccessibilityActive() && !mDocument->IPCDoc()) {
+      childDoc->Shutdown();
+      continue;
+    }
+
+    nsIContent* ownerContent = childDoc->DocumentNode()->GetEmbedderElement();
+    if (ownerContent) {
+      LocalAccessible* outerDocAcc = mDocument->GetAccessible(ownerContent);
+      if (outerDocAcc && outerDocAcc->AppendChild(childDoc)) {
+        if (mDocument->AppendChildDocument(childDoc)) {
+          newChildDocs.AppendElement(std::move(mHangingChildDocuments[idx]));
+          continue;
+        }
+
+        outerDocAcc->RemoveChild(childDoc);
+      }
+
+      // Failed to bind the child document, destroy it.
+      childDoc->Shutdown();
+    }
+  }
+
+  // Clear the hanging documents list, even if we didn't bind them.
+  mHangingChildDocuments.Clear();
+  MOZ_ASSERT(mDocument, "Illicit document shutdown");
+  if (!mDocument) {
+    return;
+  }
+
+  // If the document is ready and all its subdocuments are completely loaded
+  // then process the document load.
+  if (mDocument->HasLoadState(DocAccessible::eReady) &&
+      !mDocument->HasLoadState(DocAccessible::eCompletelyLoaded) &&
+      hangingDocCnt == 0) {
+    uint32_t childDocCnt = mDocument->ChildDocumentCount(), childDocIdx = 0;
+    for (; childDocIdx < childDocCnt; childDocIdx++) {
+      DocAccessible* childDoc = mDocument->GetChildDocumentAt(childDocIdx);
+      if (!childDoc->HasLoadState(DocAccessible::eCompletelyLoaded)) {
+        break;
+      }
+    }
+
+    if (childDocIdx == childDocCnt) {
+      mDocument->ProcessLoad();
+      if (!mDocument) {
+        return;
+      }
+    }
+  }
+
+  // Process invalidation list of the document after all accessible tree
+  // mutation is done.
+  mDocument->ProcessInvalidationList();
+
+  // Process relocation list.
+  for (uint32_t idx = 0; idx < mRelocations.Length(); idx++) {
+    // owner should be in a document and have na associated DOM node (docs
+    // sometimes don't)
+    if (mRelocations[idx]->IsInDocument() &&
+        mRelocations[idx]->HasOwnContent()) {
+      mDocument->DoARIAOwnsRelocation(mRelocations[idx]);
+    }
+  }
+  mRelocations.Clear();
+
+  // Process only currently queued generic notifications.
+  // These are used for processing aria-activedescendant, DOMMenuItemActive,
+  // etc. Therefore, they must be processed after relocations, since relocated
+  // subtrees might not have been created before relocation processing and the
+  // target might be inside a relocated subtree.
+  const nsTArray<RefPtr<Notification>> notifications =
+      std::move(mNotifications);
+
+  uint32_t notificationCount = notifications.Length();
+  for (uint32_t idx = 0; idx < notificationCount; idx++) {
+    notifications[idx]->Process();
+    if (!mDocument) {
+      return;
+    }
+  }
+
+  if (ipc::ProcessChild::ExpectingShutdown()) {
+    return;
+  }
+
+  // If a generic notification occurs after this point then we may be allowed to
+  // process it synchronously.  However we do not want to reenter if fireing
+  // events causes script to run.
+  mObservingState = eRefreshProcessing;
+
+  mDocument->SendAccessiblesWillMove();
+
+  // Send any queued cache updates before we fire any mutation events so the
+  // cache is up to date when mutation events are fired. We do this after
+  // insertions (but not their events) so that cache updates dependent on the
+  // tree work correctly; e.g. line start calculation.
+  if (IPCAccessibilityActive() && mDocument) {
+    mDocument->ProcessQueuedCacheUpdates();
+  }
+
+  CoalesceMutationEvents();
+  ProcessMutationEvents();
+
+  // When firing mutation events, mObservingState is set to
+  // eRefreshProcessing. Any calls to ScheduleProcessing() that
+  // occur before mObservingState is reset will be dropped because we only
+  // schedule a tick if mObservingState == eNotObservingRefresh.
+  // This sometimes results in our viewport cache being out-of-date after
+  // processing mutation events. Call ProcessQueuedCacheUpdates again to
+  // ensure it is updated.
+  if (IPCAccessibilityActive() && mDocument) {
+    mDocument->ProcessQueuedCacheUpdates();
+  }
+
+  if (mDocument) {
+    mDocument->ClearMutationData();
+  }
+
+  if (ipc::ProcessChild::ExpectingShutdown()) {
+    return;
+  }
+
+  ProcessEventQueue();
+
+  if (IPCAccessibilityActive()) {
+    size_t newDocCount = newChildDocs.Length();
+    for (size_t i = 0; i < newDocCount; i++) {
+      DocAccessible* childDoc = newChildDocs[i];
+      if (childDoc->IsDefunct()) {
+        continue;
+      }
+
+      LocalAccessible* parent = childDoc->LocalParent();
+      DocAccessibleChild* parentIPCDoc = mDocument->IPCDoc();
+      MOZ_DIAGNOSTIC_ASSERT(parentIPCDoc);
+      uint64_t id = reinterpret_cast<uintptr_t>(parent->UniqueID());
+      MOZ_DIAGNOSTIC_ASSERT(id);
+      DocAccessibleChild* ipcDoc = childDoc->IPCDoc();
+      if (ipcDoc) {
+        parentIPCDoc->SendBindChildDoc(WrapNotNull(ipcDoc), id);
+        continue;
+      }
+
+      ipcDoc = new DocAccessibleChild(childDoc, parentIPCDoc->Manager());
+      childDoc->SetIPCDoc(ipcDoc);
+
+      nsCOMPtr<nsIBrowserChild> browserChild =
+          do_GetInterface(mDocument->DocumentNode()->GetDocShell());
+      if (browserChild) {
+        static_cast<BrowserChild*>(browserChild.get())
+            ->SendPDocAccessibleConstructor(
+                ipcDoc, parentIPCDoc, id,
+                childDoc->DocumentNode()->GetBrowsingContext());
+      }
+    }
+  }
+
+  if (!mDocument) {
+    // A null mDocument means we've gotten a Shutdown() call (presumably via
+    // some script that we triggered above), and that means we're done here.
+    // Note: in this case, it's important that don't modify mObservingState;
+    // Shutdown() will have *unregistered* us as a refresh observer, and we
+    // don't want to mistakenly overwrite mObservingState and fool ourselves
+    // into thinking we've re-registered when we really haven't!
+    MOZ_ASSERT(mObservingState == eNotObservingRefresh,
+               "We've been shutdown, which means we should've been "
+               "unregistered as a refresh observer");
+    return;
+  }
+  mObservingState = eRefreshObserving;
+
+  // Stop further processing if there are no new notifications of any kind or
+  // events and document load is processed.
+  if (mContentInsertions.Count() == 0 && mNotifications.IsEmpty() &&
+      !mFocusEvent && mEvents.IsEmpty() && mTextArray.IsEmpty() &&
+      mHangingChildDocuments.IsEmpty() &&
+      mDocument->HasLoadState(DocAccessible::eCompletelyLoaded) &&
+      mPresShell->RemoveRefreshObserver(this, FlushType::Display)) {
+    mObservingState = eNotObservingRefresh;
+  }
+}
+
+void NotificationController::EventMap::PutEvent(AccTreeMutationEvent* aEvent) {
+  EventType type = GetEventType(aEvent);
+  uint64_t addr = reinterpret_cast<uintptr_t>(aEvent->GetAccessible());
+  MOZ_ASSERT((addr & 0x3) == 0, "accessible is not 4 byte aligned");
+  addr |= type;
+  mTable.InsertOrUpdate(addr, RefPtr{aEvent});
+}
+
+AccTreeMutationEvent* NotificationController::EventMap::GetEvent(
+    LocalAccessible* aTarget, EventType aType) {
+  uint64_t addr = reinterpret_cast<uintptr_t>(aTarget);
+  MOZ_ASSERT((addr & 0x3) == 0, "target is not 4 byte aligned");
+
+  addr |= aType;
+  return mTable.GetWeak(addr);
+}
+
+void NotificationController::EventMap::RemoveEvent(
+    AccTreeMutationEvent* aEvent) {
+  EventType type = GetEventType(aEvent);
+  uint64_t addr = reinterpret_cast<uintptr_t>(aEvent->GetAccessible());
+  MOZ_ASSERT((addr & 0x3) == 0, "accessible is not 4 byte aligned");
+  addr |= type;
+
+  MOZ_ASSERT(mTable.GetWeak(addr) == aEvent, "mTable has the wrong event");
+  mTable.Remove(addr);
+}
+
+NotificationController::EventMap::EventType
+NotificationController::EventMap::GetEventType(AccTreeMutationEvent* aEvent) {
+  switch (aEvent->GetEventType()) {
+    case nsIAccessibleEvent::EVENT_SHOW:
+      return ShowEvent;
+    case nsIAccessibleEvent::EVENT_HIDE:
+      return HideEvent;
+    case nsIAccessibleEvent::EVENT_REORDER:
+    case nsIAccessibleEvent::EVENT_INNER_REORDER:
+      return ReorderEvent;
+    default:
+      MOZ_ASSERT_UNREACHABLE("event has invalid type");
+      return ShowEvent;
+  }
+}
diff --git a/accessible/base/NotificationController.h b/accessible/base/NotificationController.h
new file mode 100644
index 0000000000..137963f117
--- /dev/null
+++ b/accessible/base/NotificationController.h
@@ -0,0 +1,396 @@
+/* -*- 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_NotificationController_h_
+#define mozilla_a11y_NotificationController_h_
+
+#include "EventQueue.h"
+
+#include "nsClassHashtable.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIFrame.h"
+#include "nsRefreshObservers.h"
+#include "nsTHashSet.h"
+
+#include <utility>
+
+#ifdef A11Y_LOG
+#  include "Logging.h"
+#endif
+
+namespace mozilla {
+
+class PresShell;
+
+namespace a11y {
+
+class DocAccessible;
+
+/**
+ * Notification interface.
+ */
+class Notification {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(mozilla::a11y::Notification)
+
+  /**
+   * Process notification.
+   */
+  virtual void Process() = 0;
+
+ protected:
+  Notification() {}
+
+  /**
+   * Protected destructor, to discourage deletion outside of Release():
+   */
+  virtual ~Notification() {}
+
+ private:
+  Notification(const Notification&);
+  Notification& operator=(const Notification&);
+};
+
+/**
+ * Template class for generic notification.
+ *
+ * @note  Instance is kept as a weak ref, the caller must guarantee it exists
+ *        longer than the document accessible owning the notification controller
+ *        that this notification is processed by.
+ */
+template <class Class, class... Args>
+class TNotification : public Notification {
+ public:
+  typedef void (Class::*Callback)(Args*...);
+
+  TNotification(Class* aInstance, Callback aCallback, Args*... aArgs)
+      : mInstance(aInstance), mCallback(aCallback), mArgs(aArgs...) {}
+  virtual ~TNotification() { mInstance = nullptr; }
+
+  virtual void Process() override {
+    ProcessHelper(std::index_sequence_for<Args...>{});
+  }
+
+ private:
+  TNotification(const TNotification&);
+  TNotification& operator=(const TNotification&);
+
+  template <size_t... Indices>
+  void ProcessHelper(std::index_sequence<Indices...>) {
+    (mInstance->*mCallback)(std::get<Indices>(mArgs)...);
+  }
+
+  Class* mInstance;
+  Callback mCallback;
+  std::tuple<RefPtr<Args>...> mArgs;
+};
+
+/**
+ * Used to process notifications from core for the document accessible.
+ */
+class NotificationController final : public EventQueue,
+                                     public nsARefreshObserver {
+ public:
+  NotificationController(DocAccessible* aDocument, PresShell* aPresShell);
+
+  NS_IMETHOD_(MozExternalRefCountType) AddRef(void) override;
+  NS_IMETHOD_(MozExternalRefCountType) Release(void) override;
+
+  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(NotificationController)
+
+  /**
+   * Shutdown the notification controller.
+   */
+  void Shutdown();
+
+  /**
+   * Add an accessible event into the queue to process it later.
+   */
+  void QueueEvent(AccEvent* aEvent) {
+    if (PushEvent(aEvent)) {
+      ScheduleProcessing();
+    }
+  }
+
+  /**
+   * Queue a mutation event to emit if not coalesced away.  Returns true if the
+   * event was queued and has not yet been coalesced.
+   */
+  bool QueueMutationEvent(AccTreeMutationEvent* aEvent);
+
+  /**
+   * Coalesce all queued mutation events.
+   */
+  void CoalesceMutationEvents();
+
+  /**
+   * Schedule binding the child document to the tree of this document.
+   */
+  void ScheduleChildDocBinding(DocAccessible* aDocument);
+
+  /**
+   * Schedule the accessible tree update because of rendered text changes.
+   */
+  inline void ScheduleTextUpdate(nsIContent* aTextNode) {
+    // Make sure we are not called with a node that is not in the DOM tree or
+    // not visible.
+    MOZ_ASSERT(aTextNode->GetParentNode(), "A text node is not in DOM");
+    MOZ_ASSERT(aTextNode->GetPrimaryFrame(),
+               "A text node doesn't have a frame");
+    MOZ_ASSERT(aTextNode->GetPrimaryFrame()->StyleVisibility()->IsVisible(),
+               "A text node is not visible");
+
+    mTextArray.AppendElement(aTextNode);
+
+    ScheduleProcessing();
+  }
+
+  /**
+   * Pend accessible tree update for content insertion.
+   */
+  void ScheduleContentInsertion(LocalAccessible* aContainer,
+                                nsTArray<nsCOMPtr<nsIContent>>& aInsertions);
+
+  /**
+   * Pend an accessible subtree relocation.
+   */
+  void ScheduleRelocation(LocalAccessible* aOwner) {
+    if (!mRelocations.Contains(aOwner)) {
+      // XXX(Bug 1631371) Check if this should use a fallible operation as it
+      // pretended earlier, or change the return type to void.
+      mRelocations.AppendElement(aOwner);
+      ScheduleProcessing();
+    }
+  }
+
+  /**
+   * Start to observe refresh to make notifications and events processing after
+   * layout.
+   */
+  void ScheduleProcessing();
+
+  /**
+   * Process the generic notification synchronously if there are no pending
+   * layout changes and no notifications are pending or being processed right
+   * now. Otherwise, queue it up to process asynchronously.
+   *
+   * @note  The caller must guarantee that the given instance still exists when
+   *        the notification is processed.
+   */
+  template <class Class, class... Args>
+  inline void HandleNotification(
+      Class* aInstance,
+      typename TNotification<Class, Args...>::Callback aMethod,
+      Args*... aArgs) {
+    if (!IsUpdatePending()) {
+#ifdef A11Y_LOG
+      if (mozilla::a11y::logging::IsEnabled(
+              mozilla::a11y::logging::eNotifications)) {
+        mozilla::a11y::logging::Text("sync notification processing");
+      }
+#endif
+      (aInstance->*aMethod)(aArgs...);
+      return;
+    }
+
+    RefPtr<Notification> notification =
+        new TNotification<Class, Args...>(aInstance, aMethod, aArgs...);
+    if (notification) {
+      // XXX(Bug 1631371) Check if this should use a fallible operation as it
+      // pretended earlier.
+      mNotifications.AppendElement(notification);
+      ScheduleProcessing();
+    }
+  }
+
+  /**
+   * Schedule the generic notification to process asynchronously.
+   *
+   * @note  The caller must guarantee that the given instance still exists when
+   *        the notification is processed.
+   */
+  template <class Class>
+  inline void ScheduleNotification(
+      Class* aInstance, typename TNotification<Class>::Callback aMethod) {
+    RefPtr<Notification> notification =
+        new TNotification<Class>(aInstance, aMethod);
+    if (notification) {
+      // XXX(Bug 1631371) Check if this should use a fallible operation as it
+      // pretended earlier.
+      mNotifications.AppendElement(notification);
+      ScheduleProcessing();
+    }
+  }
+
+  template <class Class, class Arg>
+  inline void ScheduleNotification(
+      Class* aInstance, typename TNotification<Class, Arg>::Callback aMethod,
+      Arg* aArg) {
+    RefPtr<Notification> notification =
+        new TNotification<Class, Arg>(aInstance, aMethod, aArg);
+    if (notification) {
+      // XXX(Bug 1631371) Check if this should use a fallible operation as it
+      // pretended earlier.
+      mNotifications.AppendElement(notification);
+      ScheduleProcessing();
+    }
+  }
+
+#ifdef DEBUG
+  bool IsUpdating() const {
+    return mObservingState == eRefreshProcessingForUpdate;
+  }
+#endif
+
+ protected:
+  virtual ~NotificationController();
+
+  nsCycleCollectingAutoRefCnt mRefCnt;
+  NS_DECL_OWNINGTHREAD
+
+  /**
+   * Return true if the accessible tree state update is pending.
+   */
+  bool IsUpdatePending();
+
+  /**
+   * Return true if we should wait for processing from the parent before we can
+   * process our own queue.
+   */
+  bool WaitingForParent();
+
+ private:
+  NotificationController(const NotificationController&);
+  NotificationController& operator=(const NotificationController&);
+
+  // nsARefreshObserver
+  virtual void WillRefresh(mozilla::TimeStamp aTime) override;
+
+ private:
+  /**
+   * Remove a specific hide event if it should not be propagated.
+   */
+  void CoalesceHideEvent(AccHideEvent* aHideEvent);
+
+  /**
+   * get rid of a mutation event that is no longer necessary.
+   */
+  void DropMutationEvent(AccTreeMutationEvent* aEvent);
+
+  /**
+   * Fire all necessary mutation events.
+   */
+  void ProcessMutationEvents();
+
+  /**
+   * Indicates whether we're waiting on an event queue processing from our
+   * notification controller to flush events.
+   */
+  enum eObservingState {
+    eNotObservingRefresh,
+    eRefreshObserving,
+    eRefreshProcessing,
+    eRefreshProcessingForUpdate
+  };
+  eObservingState mObservingState;
+
+  /**
+   * The presshell of the document accessible.
+   */
+  PresShell* mPresShell;
+
+  /**
+   * Child documents that needs to be bound to the tree.
+   */
+  nsTArray<RefPtr<DocAccessible>> mHangingChildDocuments;
+
+  /**
+   * Pending accessible tree update notifications for content insertions.
+   */
+  nsClassHashtable<nsRefPtrHashKey<LocalAccessible>,
+                   nsTArray<nsCOMPtr<nsIContent>>>
+      mContentInsertions;
+
+  template <class T>
+  class nsCOMPtrHashKey : public PLDHashEntryHdr {
+   public:
+    typedef T* KeyType;
+    typedef const T* KeyTypePointer;
+
+    explicit nsCOMPtrHashKey(const T* aKey) : mKey(const_cast<T*>(aKey)) {}
+    nsCOMPtrHashKey(nsCOMPtrHashKey<T>&& aOther)
+        : PLDHashEntryHdr(std::move(aOther)), mKey(std::move(aOther.mKey)) {}
+    ~nsCOMPtrHashKey() {}
+
+    KeyType GetKey() const { return mKey; }
+    bool KeyEquals(KeyTypePointer aKey) const { return aKey == mKey; }
+
+    static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
+    static PLDHashNumber HashKey(KeyTypePointer aKey) {
+      return NS_PTR_TO_INT32(aKey) >> 2;
+    }
+
+    enum { ALLOW_MEMMOVE = true };
+
+   protected:
+    nsCOMPtr<T> mKey;
+  };
+
+  /**
+   * Pending accessible tree update notifications for rendered text changes.
+   * When there are a lot of nearby text insertions (e.g. during a reflow), it
+   * is much more performant to process them in order because we then benefit
+   * from the layout line cursor. Therefore, we use an array here.
+   */
+  nsTArray<nsCOMPtr<nsIContent>> mTextArray;
+
+  /**
+   * Other notifications like DOM events. Don't make this an AutoTArray; we
+   * use SwapElements() on it.
+   */
+  nsTArray<RefPtr<Notification>> mNotifications;
+
+  /**
+   * Holds all scheduled relocations.
+   */
+  nsTArray<RefPtr<LocalAccessible>> mRelocations;
+
+  /**
+   * A list of all mutation events we may want to emit.  Ordered from the first
+   * event that should be emitted to the last one to emit.
+   */
+  RefPtr<AccTreeMutationEvent> mFirstMutationEvent;
+  RefPtr<AccTreeMutationEvent> mLastMutationEvent;
+
+  /**
+   * A class to map an accessible and event type to an event.
+   */
+  class EventMap {
+   public:
+    enum EventType {
+      ShowEvent = 0x0,
+      HideEvent = 0x1,
+      ReorderEvent = 0x2,
+    };
+
+    void PutEvent(AccTreeMutationEvent* aEvent);
+    AccTreeMutationEvent* GetEvent(LocalAccessible* aTarget, EventType aType);
+    void RemoveEvent(AccTreeMutationEvent* aEvent);
+    void Clear() { mTable.Clear(); }
+
+   private:
+    EventType GetEventType(AccTreeMutationEvent* aEvent);
+
+    nsRefPtrHashtable<nsUint64HashKey, AccTreeMutationEvent> mTable;
+  };
+
+  EventMap mMutationMap;
+  uint32_t mEventGeneration;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif  // mozilla_a11y_NotificationController_h_
diff --git a/accessible/base/Pivot.cpp b/accessible/base/Pivot.cpp
new file mode 100644
index 0000000000..146d9207cf
--- /dev/null
+++ b/accessible/base/Pivot.cpp
@@ -0,0 +1,331 @@
+/* -*- 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 "Pivot.h"
+
+#include "AccIterator.h"
+#include "LocalAccessible.h"
+#include "RemoteAccessible.h"
+#include "nsAccUtils.h"
+#include "nsIAccessiblePivot.h"
+
+#include "mozilla/a11y/Accessible.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// Pivot
+////////////////////////////////////////////////////////////////////////////////
+
+Pivot::Pivot(Accessible* aRoot) : mRoot(aRoot) { MOZ_COUNT_CTOR(Pivot); }
+
+Pivot::~Pivot() { MOZ_COUNT_DTOR(Pivot); }
+
+Accessible* Pivot::AdjustStartPosition(Accessible* aAnchor, PivotRule& aRule,
+                                       uint16_t* aFilterResult) {
+  Accessible* matched = aAnchor;
+  *aFilterResult = aRule.Match(aAnchor);
+
+  if (aAnchor && aAnchor != mRoot) {
+    for (Accessible* temp = aAnchor->Parent(); temp && temp != mRoot;
+         temp = temp->Parent()) {
+      uint16_t filtered = aRule.Match(temp);
+      if (filtered & nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE) {
+        *aFilterResult = filtered;
+        matched = temp;
+      }
+    }
+  }
+
+  return matched;
+}
+
+Accessible* Pivot::SearchBackward(Accessible* aAnchor, PivotRule& aRule,
+                                  bool aSearchCurrent) {
+  // Initial position could be unset, in that case return null.
+  if (!aAnchor) {
+    return nullptr;
+  }
+
+  uint16_t filtered = nsIAccessibleTraversalRule::FILTER_IGNORE;
+
+  Accessible* acc = AdjustStartPosition(aAnchor, aRule, &filtered);
+
+  if (aSearchCurrent && (filtered & nsIAccessibleTraversalRule::FILTER_MATCH)) {
+    return acc;
+  }
+
+  while (acc && acc != mRoot) {
+    Accessible* parent = acc->Parent();
+#if defined(ANDROID)
+    MOZ_ASSERT(
+        acc->IsLocal() || (acc->IsRemote() && parent->IsRemote()),
+        "Pivot::SearchBackward climbed out of remote subtree in Android!");
+#endif
+    int32_t idxInParent = acc->IndexInParent();
+    while (idxInParent > 0 && parent) {
+      acc = parent->ChildAt(--idxInParent);
+      if (!acc) {
+        continue;
+      }
+
+      filtered = aRule.Match(acc);
+
+      Accessible* lastChild = acc->LastChild();
+      while (!(filtered & nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE) &&
+             lastChild) {
+        parent = acc;
+        acc = lastChild;
+        idxInParent = acc->IndexInParent();
+        filtered = aRule.Match(acc);
+        lastChild = acc->LastChild();
+      }
+
+      if (filtered & nsIAccessibleTraversalRule::FILTER_MATCH) {
+        return acc;
+      }
+    }
+
+    acc = parent;
+    if (!acc) {
+      break;
+    }
+
+    filtered = aRule.Match(acc);
+
+    if (filtered & nsIAccessibleTraversalRule::FILTER_MATCH) {
+      return acc;
+    }
+  }
+
+  return nullptr;
+}
+
+Accessible* Pivot::SearchForward(Accessible* aAnchor, PivotRule& aRule,
+                                 bool aSearchCurrent) {
+  // Initial position could be not set, in that case begin search from root.
+  Accessible* acc = aAnchor ? aAnchor : mRoot;
+
+  uint16_t filtered = nsIAccessibleTraversalRule::FILTER_IGNORE;
+  acc = AdjustStartPosition(acc, aRule, &filtered);
+  if (aSearchCurrent && (filtered & nsIAccessibleTraversalRule::FILTER_MATCH)) {
+    return acc;
+  }
+
+  while (acc) {
+    Accessible* firstChild = acc->FirstChild();
+    while (!(filtered & nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE) &&
+           firstChild) {
+      acc = firstChild;
+      filtered = aRule.Match(acc);
+
+      if (filtered & nsIAccessibleTraversalRule::FILTER_MATCH) {
+        return acc;
+      }
+      firstChild = acc->FirstChild();
+    }
+
+    Accessible* sibling = nullptr;
+    Accessible* temp = acc;
+    do {
+      if (temp == mRoot) {
+        break;
+      }
+
+      sibling = temp->NextSibling();
+
+      if (sibling) {
+        break;
+      }
+      temp = temp->Parent();
+#if defined(ANDROID)
+      MOZ_ASSERT(
+          acc->IsLocal() || (acc->IsRemote() && temp->IsRemote()),
+          "Pivot::SearchForward climbed out of remote subtree in Android!");
+#endif
+
+    } while (temp);
+
+    if (!sibling) {
+      break;
+    }
+
+    acc = sibling;
+    filtered = aRule.Match(acc);
+    if (filtered & nsIAccessibleTraversalRule::FILTER_MATCH) {
+      return acc;
+    }
+  }
+
+  return nullptr;
+}
+
+Accessible* Pivot::Next(Accessible* aAnchor, PivotRule& aRule,
+                        bool aIncludeStart) {
+  return SearchForward(aAnchor, aRule, aIncludeStart);
+}
+
+Accessible* Pivot::Prev(Accessible* aAnchor, PivotRule& aRule,
+                        bool aIncludeStart) {
+  return SearchBackward(aAnchor, aRule, aIncludeStart);
+}
+
+Accessible* Pivot::First(PivotRule& aRule) {
+  return SearchForward(mRoot, aRule, true);
+}
+
+Accessible* Pivot::Last(PivotRule& aRule) {
+  Accessible* lastAcc = mRoot;
+
+  // First go to the last accessible in pre-order
+  while (lastAcc && lastAcc->HasChildren()) {
+    lastAcc = lastAcc->LastChild();
+  }
+
+  // Search backwards from last accessible and find the last occurrence in the
+  // doc
+  return SearchBackward(lastAcc, aRule, true);
+}
+
+Accessible* Pivot::AtPoint(int32_t aX, int32_t aY, PivotRule& aRule) {
+  Accessible* match = nullptr;
+  Accessible* child =
+      mRoot ? mRoot->ChildAtPoint(aX, aY,
+                                  Accessible::EWhichChildAtPoint::DeepestChild)
+            : nullptr;
+  while (child && (mRoot != child)) {
+    uint16_t filtered = aRule.Match(child);
+
+    // Ignore any matching nodes that were below this one
+    if (filtered & nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE) {
+      match = nullptr;
+    }
+
+    // Match if no node below this is a match
+    if ((filtered & nsIAccessibleTraversalRule::FILTER_MATCH) && !match) {
+      LayoutDeviceIntRect childRect = child->IsLocal()
+                                          ? child->AsLocal()->Bounds()
+                                          : child->AsRemote()->Bounds();
+      // Double-check child's bounds since the deepest child may have been out
+      // of bounds. This assures we don't return a false positive.
+      if (childRect.Contains(aX, aY)) {
+        match = child;
+      }
+    }
+
+    child = child->Parent();
+  }
+
+  return match;
+}
+
+// Role Rule
+
+PivotRoleRule::PivotRoleRule(mozilla::a11y::role aRole)
+    : mRole(aRole), mDirectDescendantsFrom(nullptr) {}
+
+PivotRoleRule::PivotRoleRule(mozilla::a11y::role aRole,
+                             Accessible* aDirectDescendantsFrom)
+    : mRole(aRole), mDirectDescendantsFrom(aDirectDescendantsFrom) {}
+
+uint16_t PivotRoleRule::Match(Accessible* aAcc) {
+  uint16_t result = nsIAccessibleTraversalRule::FILTER_IGNORE;
+
+  if (nsAccUtils::MustPrune(aAcc)) {
+    result |= nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+
+  if (mDirectDescendantsFrom && (aAcc != mDirectDescendantsFrom)) {
+    // If we've specified mDirectDescendantsFrom, we should ignore
+    // non-direct descendants of from the specified AoP. Because
+    // pivot performs a preorder traversal, the first aAcc
+    // object(s) that don't equal mDirectDescendantsFrom will be
+    // mDirectDescendantsFrom's children. We'll process them, but ignore
+    // their subtrees thereby processing direct descendants of
+    // mDirectDescendantsFrom only.
+    result |= nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+
+  if (aAcc && aAcc->Role() == mRole) {
+    result |= nsIAccessibleTraversalRule::FILTER_MATCH;
+  }
+
+  return result;
+}
+
+// State Rule
+
+PivotStateRule::PivotStateRule(uint64_t aState) : mState(aState) {}
+
+uint16_t PivotStateRule::Match(Accessible* aAcc) {
+  uint16_t result = nsIAccessibleTraversalRule::FILTER_IGNORE;
+
+  if (nsAccUtils::MustPrune(aAcc)) {
+    result |= nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+
+  if (aAcc && (aAcc->State() & mState)) {
+    result = nsIAccessibleTraversalRule::FILTER_MATCH |
+             nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+
+  return result;
+}
+
+// LocalAccInSameDocRule
+
+uint16_t LocalAccInSameDocRule::Match(Accessible* aAcc) {
+  LocalAccessible* acc = aAcc ? aAcc->AsLocal() : nullptr;
+  if (!acc) {
+    return nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+  if (acc->IsOuterDoc()) {
+    return nsIAccessibleTraversalRule::FILTER_MATCH |
+           nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+  return nsIAccessibleTraversalRule::FILTER_MATCH;
+}
+
+// Radio Button Name Rule
+
+PivotRadioNameRule::PivotRadioNameRule(const nsString& aName) : mName(aName) {}
+
+uint16_t PivotRadioNameRule::Match(Accessible* aAcc) {
+  uint16_t result = nsIAccessibleTraversalRule::FILTER_IGNORE;
+  RemoteAccessible* remote = aAcc->AsRemote();
+  if (!remote) {
+    // We need the cache to be able to fetch the name attribute below.
+    return result;
+  }
+
+  if (nsAccUtils::MustPrune(aAcc) || aAcc->IsOuterDoc()) {
+    result |= nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+
+  if (remote->IsHTMLRadioButton()) {
+    nsString currName = remote->GetCachedHTMLNameAttribute();
+    if (!currName.IsEmpty() && mName.Equals(currName)) {
+      result |= nsIAccessibleTraversalRule::FILTER_MATCH;
+    }
+  }
+
+  return result;
+}
+
+// MustPruneSameDocRule
+
+uint16_t MustPruneSameDocRule::Match(Accessible* aAcc) {
+  if (!aAcc) {
+    return nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+
+  if (nsAccUtils::MustPrune(aAcc) || aAcc->IsOuterDoc()) {
+    return nsIAccessibleTraversalRule::FILTER_MATCH |
+           nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+  }
+
+  return nsIAccessibleTraversalRule::FILTER_MATCH;
+}
diff --git a/accessible/base/Pivot.h b/accessible/base/Pivot.h
new file mode 100644
index 0000000000..bd2814f48e
--- /dev/null
+++ b/accessible/base/Pivot.h
@@ -0,0 +1,141 @@
+/* -*- 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_Pivot_h_
+#define mozilla_a11y_Pivot_h_
+
+#include <stdint.h>
+#include "mozilla/a11y/Role.h"
+#include "mozilla/dom/ChildIterator.h"
+
+namespace mozilla {
+namespace a11y {
+
+class DocAccessible;
+class Accessible;
+
+class PivotRule {
+ public:
+  // A filtering function that returns a bitmask from
+  // nsIAccessibleTraversalRule: FILTER_IGNORE (0x0): Don't match this
+  // accessible. FILTER_MATCH (0x1): Match this accessible FILTER_IGNORE_SUBTREE
+  // (0x2): Ignore accessible's subtree.
+  virtual uint16_t Match(Accessible* aAcc) = 0;
+};
+
+// The Pivot class is used for searching for accessible nodes in a given subtree
+// with a given criteria. Since it only holds a weak reference to the root,
+// this class is meant to be used primarily on the stack.
+class Pivot final {
+ public:
+  explicit Pivot(Accessible* aRoot);
+  Pivot() = delete;
+  Pivot(const Pivot&) = delete;
+  Pivot& operator=(const Pivot&) = delete;
+
+  ~Pivot();
+
+  // Return the next accessible after aAnchor in pre-order that matches the
+  // given rule. If aIncludeStart, return aAnchor if it matches the rule.
+  Accessible* Next(Accessible* aAnchor, PivotRule& aRule,
+                   bool aIncludeStart = false);
+
+  // Return the previous accessible before aAnchor in pre-order that matches the
+  // given rule. If aIncludeStart, return aAnchor if it matches the rule.
+  Accessible* Prev(Accessible* aAnchor, PivotRule& aRule,
+                   bool aIncludeStart = false);
+
+  // Return the first accessible within the root that matches the pivot rule.
+  Accessible* First(PivotRule& aRule);
+
+  // Return the last accessible within the root that matches the pivot rule.
+  Accessible* Last(PivotRule& aRule);
+
+  // Return the accessible at the given screen coordinate if it matches the
+  // pivot rule.
+  Accessible* AtPoint(int32_t aX, int32_t aY, PivotRule& aRule);
+
+ private:
+  Accessible* AdjustStartPosition(Accessible* aAnchor, PivotRule& aRule,
+                                  uint16_t* aFilterResult);
+
+  // Search in preorder for the first accessible to match the rule.
+  Accessible* SearchForward(Accessible* aAnchor, PivotRule& aRule,
+                            bool aSearchCurrent);
+
+  // Reverse search in preorder for the first accessible to match the rule.
+  Accessible* SearchBackward(Accessible* aAnchor, PivotRule& aRule,
+                             bool aSearchCurrent);
+
+  Accessible* mRoot;
+};
+
+/**
+ * This rule matches accessibles on a given role, filtering out non-direct
+ * descendants if necessary.
+ */
+class PivotRoleRule : public PivotRule {
+ public:
+  explicit PivotRoleRule(role aRole);
+  explicit PivotRoleRule(role aRole, Accessible* aDirectDescendantsFrom);
+
+  virtual uint16_t Match(Accessible* aAcc) override;
+
+ protected:
+  role mRole;
+  Accessible* mDirectDescendantsFrom;
+};
+
+/**
+ * This rule matches accessibles with a given state.
+ */
+class PivotStateRule : public PivotRule {
+ public:
+  explicit PivotStateRule(uint64_t aState);
+
+  virtual uint16_t Match(Accessible* aAcc) override;
+
+ protected:
+  uint64_t mState;
+};
+
+/**
+ * This rule matches any local LocalAccessible (i.e. not RemoteAccessible) in
+ * the same document as the anchor. That is, it includes any descendant
+ * OuterDocAccessible, but not its descendants.
+ */
+class LocalAccInSameDocRule : public PivotRule {
+ public:
+  virtual uint16_t Match(Accessible* aAcc) override;
+};
+
+/**
+ * This rule matches remote radio button accessibles with the given name
+ * attribute. It assumes the cache is enabled.
+ */
+class PivotRadioNameRule : public PivotRule {
+ public:
+  explicit PivotRadioNameRule(const nsString& aName);
+
+  virtual uint16_t Match(Accessible* aAcc) override;
+
+ protected:
+  const nsString& mName;
+};
+
+/**
+ * This rule doesn't search iframes. Subtrees that should be
+ * pruned by way of nsAccUtils::MustPrune are also not searched.
+ */
+
+class MustPruneSameDocRule : public PivotRule {
+ public:
+  virtual uint16_t Match(Accessible* aAcc) override;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif  // mozilla_a11y_Pivot_h_
diff --git a/accessible/base/Platform.h b/accessible/base/Platform.h
new file mode 100644
index 0000000000..23f214246f
--- /dev/null
+++ b/accessible/base/Platform.h
@@ -0,0 +1,136 @@
+/* -*- 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_Platform_h
+#define mozilla_a11y_Platform_h
+
+#include <stdint.h>
+#include "nsStringFwd.h"
+#include "Units.h"
+
+#if defined(ANDROID)
+#  include "nsTArray.h"
+#  include "nsRect.h"
+#endif
+
+#ifdef MOZ_WIDGET_COCOA
+#  include "mozilla/a11y/Role.h"
+#  include "nsTArray.h"
+#endif
+
+namespace mozilla {
+namespace a11y {
+
+class Accessible;
+class RemoteAccessible;
+
+enum EPlatformDisabledState {
+  ePlatformIsForceEnabled = -1,
+  ePlatformIsEnabled = 0,
+  ePlatformIsDisabled = 1
+};
+
+/**
+ * Return the platform disabled state.
+ */
+EPlatformDisabledState PlatformDisabledState();
+
+#ifdef MOZ_ACCESSIBILITY_ATK
+/**
+ * Perform initialization that should be done as soon as possible, in order
+ * to minimize startup time.
+ * XXX: this function and the next defined in ApplicationAccessibleWrap.cpp
+ */
+void PreInit();
+#endif
+
+#if defined(MOZ_ACCESSIBILITY_ATK) || defined(XP_MACOSX)
+/**
+ * Is platform accessibility enabled.
+ * Only used on linux with atk and MacOS for now.
+ */
+bool ShouldA11yBeEnabled();
+#endif
+
+#if defined(XP_WIN)
+/*
+ * Name of platform service that instantiated accessibility
+ */
+void SetInstantiator(const uint32_t aInstantiatorPid);
+bool GetInstantiator(nsIFile** aOutInstantiator);
+#endif
+
+/**
+ * Called to initialize platform specific accessibility support.
+ * Note this is called after internal accessibility support is initialized.
+ */
+void PlatformInit();
+
+/**
+ * Shutdown platform accessibility.
+ * Note this is called before internal accessibility support is shutdown.
+ */
+void PlatformShutdown();
+
+/**
+ * called when a new RemoteAccessible is created, so the platform may setup a
+ * wrapper for it, or take other action.
+ */
+void ProxyCreated(RemoteAccessible* aProxy);
+
+/**
+ * Called just before a RemoteAccessible is destroyed so its wrapper can be
+ * disposed of and other action taken.
+ */
+void ProxyDestroyed(RemoteAccessible*);
+
+/**
+ * Called when an event is fired on an Accessible so that platforms may fire
+ * events if appropriate.
+ */
+void PlatformEvent(Accessible* aTarget, uint32_t aEventType);
+void PlatformStateChangeEvent(Accessible* aTarget, uint64_t aState,
+                              bool aEnabled);
+
+void PlatformFocusEvent(Accessible* aTarget,
+                        const LayoutDeviceIntRect& aCaretRect);
+void PlatformCaretMoveEvent(Accessible* aTarget, int32_t aOffset,
+                            bool aIsSelectionCollapsed, int32_t aGranularity,
+                            const LayoutDeviceIntRect& aCaretRect,
+                            bool aFromUser);
+void PlatformTextChangeEvent(Accessible* aTarget, const nsAString& aStr,
+                             int32_t aStart, uint32_t aLen, bool aIsInsert,
+                             bool aFromUser);
+void PlatformShowHideEvent(Accessible* aTarget, Accessible* aParent,
+                           bool aInsert, bool aFromUser);
+void PlatformSelectionEvent(Accessible* aTarget, Accessible* aWidget,
+                            uint32_t aType);
+
+#if defined(ANDROID)
+void PlatformScrollingEvent(Accessible* aTarget, uint32_t aEventType,
+                            uint32_t aScrollX, uint32_t aScrollY,
+                            uint32_t aMaxScrollX, uint32_t aMaxScrollY);
+
+void PlatformAnnouncementEvent(Accessible* aTarget,
+                               const nsAString& aAnnouncement,
+                               uint16_t aPriority);
+
+bool LocalizeString(const nsAString& aToken, nsAString& aLocalized);
+#endif
+
+#ifdef MOZ_WIDGET_COCOA
+class TextRange;
+void PlatformTextSelectionChangeEvent(Accessible* aTarget,
+                                      const nsTArray<TextRange>& aSelection);
+
+void PlatformRoleChangedEvent(Accessible* aTarget, const a11y::role& aRole,
+                              uint8_t aRoleMapEntryIndex);
+#endif
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif  // mozilla_a11y_Platform_h
diff --git a/accessible/base/Relation.h b/accessible/base/Relation.h
new file mode 100644
index 0000000000..24fceeab02
--- /dev/null
+++ b/accessible/base/Relation.h
@@ -0,0 +1,105 @@
+/* -*- 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_relation_h_
+#define mozilla_a11y_relation_h_
+
+#include "AccIterator.h"
+
+#include <memory>
+
+namespace mozilla {
+namespace a11y {
+
+/**
+ * A collection of relation targets of a certain type.  Targets are computed
+ * lazily while enumerating.
+ */
+class Relation {
+ public:
+  Relation() : mFirstIter(nullptr), mLastIter(nullptr) {}
+
+  explicit Relation(AccIterable* aIter) : mFirstIter(aIter), mLastIter(aIter) {}
+
+  explicit Relation(Accessible* aAcc)
+      : mFirstIter(nullptr), mLastIter(nullptr) {
+    AppendTarget(aAcc);
+  }
+
+  Relation(DocAccessible* aDocument, nsIContent* aContent)
+      : mFirstIter(nullptr), mLastIter(nullptr) {
+    AppendTarget(aDocument, aContent);
+  }
+
+  Relation(Relation&& aOther)
+      : mFirstIter(std::move(aOther.mFirstIter)), mLastIter(aOther.mLastIter) {
+    aOther.mLastIter = nullptr;
+  }
+
+  Relation& operator=(Relation&& aRH) {
+    mFirstIter = std::move(aRH.mFirstIter);
+    mLastIter = aRH.mLastIter;
+    aRH.mLastIter = nullptr;
+    return *this;
+  }
+
+  inline void AppendIter(AccIterable* aIter) {
+    if (mLastIter) {
+      mLastIter->mNextIter.reset(aIter);
+    } else {
+      mFirstIter.reset(aIter);
+    }
+
+    mLastIter = aIter;
+  }
+
+  /**
+   * Append the given accessible to the set of related accessibles.
+   */
+  inline void AppendTarget(Accessible* aAcc) {
+    if (aAcc) AppendIter(new SingleAccIterator(aAcc));
+  }
+
+  /**
+   * Append the one accessible for this content node to the set of related
+   * accessibles.
+   */
+  void AppendTarget(DocAccessible* aDocument, nsIContent* aContent) {
+    if (aContent) AppendTarget(aDocument->GetAccessible(aContent));
+  }
+
+  /**
+   * compute and return the next related accessible.
+   */
+  inline Accessible* Next() {
+    Accessible* target = nullptr;
+
+    while (mFirstIter && !(target = mFirstIter->Next())) {
+      mFirstIter = std::move(mFirstIter->mNextIter);
+    }
+
+    if (!mFirstIter) mLastIter = nullptr;
+
+    return target;
+  }
+
+  inline LocalAccessible* LocalNext() {
+    Accessible* next = Next();
+    return next ? next->AsLocal() : nullptr;
+  }
+
+ private:
+  Relation& operator=(const Relation&) = delete;
+  Relation(const Relation&) = delete;
+
+  std::unique_ptr<AccIterable> mFirstIter;
+  AccIterable* mLastIter;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/RelationTypeGen.py b/accessible/base/RelationTypeGen.py
new file mode 100644
index 0000000000..8d9a0f91bf
--- /dev/null
+++ b/accessible/base/RelationTypeGen.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env 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/.
+
+import re
+
+
+def generate(relH, relIdl):
+    input = open(relIdl, "rt").read()
+    relations = re.findall(
+        r"const unsigned long RELATION_([A-Z_]+) = ([x0-9a-f]+);", input
+    )
+
+    relH.write(
+        "/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */\n"
+        "/* Relations are defined in accessible/interfaces/nsIAccessibleRelation.idl */\n\n"
+        "#ifndef mozilla_a11y_relationtype_h_\n"
+        "#define mozilla_a11y_relationtype_h_\n\n"
+        "namespace mozilla {\n"
+        "namespace a11y {\n\n"
+        "enum class RelationType {\n"
+    )
+    for name, num in relations:
+        relH.write(f"  {name} = {num},\n")
+    lastName = relations[-1][0]
+    relH.write(
+        f"  LAST = {lastName}\n"
+        "};\n\n"
+        "}  // namespace a11y\n"
+        "}  // namespace mozilla\n\n"
+        "#endif\n"
+    )
+
+
+# For debugging
+if __name__ == "__main__":
+    import sys
+
+    generate(sys.stdout, "accessible/interfaces/nsIAccessibleRelation.idl")
diff --git a/accessible/base/RelationTypeMap.h b/accessible/base/RelationTypeMap.h
new file mode 100644
index 0000000000..e819682368
--- /dev/null
+++ b/accessible/base/RelationTypeMap.h
@@ -0,0 +1,90 @@
+/* -*- 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/. */
+
+/**
+ * Usage: declare the macro RELATIONTYPE()with the following arguments:
+ * RELATIONTYPE(geckoType, geckoTypeName, atkType, msaaType, ia2Type)
+ */
+
+RELATIONTYPE(LABELLED_BY, "labelled by", ATK_RELATION_LABELLED_BY,
+             NAVRELATION_LABELLED_BY, IA2_RELATION_LABELLED_BY)
+
+RELATIONTYPE(LABEL_FOR, "label for", ATK_RELATION_LABEL_FOR,
+             NAVRELATION_LABEL_FOR, IA2_RELATION_LABEL_FOR)
+
+RELATIONTYPE(DESCRIBED_BY, "described by", ATK_RELATION_DESCRIBED_BY,
+             NAVRELATION_DESCRIBED_BY, IA2_RELATION_DESCRIBED_BY)
+
+RELATIONTYPE(DESCRIPTION_FOR, "description for", ATK_RELATION_DESCRIPTION_FOR,
+             NAVRELATION_DESCRIPTION_FOR, IA2_RELATION_DESCRIPTION_FOR)
+
+RELATIONTYPE(NODE_CHILD_OF, "node child of", ATK_RELATION_NODE_CHILD_OF,
+             NAVRELATION_NODE_CHILD_OF, IA2_RELATION_NODE_CHILD_OF)
+
+RELATIONTYPE(NODE_PARENT_OF, "node parent of", ATK_RELATION_NODE_PARENT_OF,
+             NAVRELATION_NODE_PARENT_OF, IA2_RELATION_NODE_PARENT_OF)
+
+RELATIONTYPE(CONTROLLED_BY, "controlled by", ATK_RELATION_CONTROLLED_BY,
+             NAVRELATION_CONTROLLED_BY, IA2_RELATION_CONTROLLED_BY)
+
+RELATIONTYPE(CONTROLLER_FOR, "controller for", ATK_RELATION_CONTROLLER_FOR,
+             NAVRELATION_CONTROLLER_FOR, IA2_RELATION_CONTROLLER_FOR)
+
+RELATIONTYPE(FLOWS_TO, "flows to", ATK_RELATION_FLOWS_TO, NAVRELATION_FLOWS_TO,
+             IA2_RELATION_FLOWS_TO)
+
+RELATIONTYPE(FLOWS_FROM, "flows from", ATK_RELATION_FLOWS_FROM,
+             NAVRELATION_FLOWS_FROM, IA2_RELATION_FLOWS_FROM)
+
+RELATIONTYPE(MEMBER_OF, "member of", ATK_RELATION_MEMBER_OF,
+             NAVRELATION_MEMBER_OF, IA2_RELATION_MEMBER_OF)
+
+RELATIONTYPE(SUBWINDOW_OF, "subwindow of", ATK_RELATION_SUBWINDOW_OF,
+             NAVRELATION_SUBWINDOW_OF, IA2_RELATION_SUBWINDOW_OF)
+
+RELATIONTYPE(EMBEDS, "embeds", ATK_RELATION_EMBEDS, NAVRELATION_EMBEDS,
+             IA2_RELATION_EMBEDS)
+
+RELATIONTYPE(EMBEDDED_BY, "embedded by", ATK_RELATION_EMBEDDED_BY,
+             NAVRELATION_EMBEDDED_BY, IA2_RELATION_EMBEDDED_BY)
+
+RELATIONTYPE(POPUP_FOR, "popup for", ATK_RELATION_POPUP_FOR,
+             NAVRELATION_POPUP_FOR, IA2_RELATION_POPUP_FOR)
+
+RELATIONTYPE(PARENT_WINDOW_OF, "parent window of",
+             ATK_RELATION_PARENT_WINDOW_OF, NAVRELATION_PARENT_WINDOW_OF,
+             IA2_RELATION_PARENT_WINDOW_OF)
+
+RELATIONTYPE(DEFAULT_BUTTON, "default button", ATK_RELATION_NULL,
+             NAVRELATION_DEFAULT_BUTTON, IA2_RELATION_NULL)
+
+RELATIONTYPE(CONTAINING_DOCUMENT, "containing document", ATK_RELATION_NULL,
+             NAVRELATION_CONTAINING_DOCUMENT, IA2_RELATION_CONTAINING_DOCUMENT)
+
+RELATIONTYPE(CONTAINING_TAB_PANE, "containing tab pane", ATK_RELATION_NULL,
+             NAVRELATION_CONTAINING_TAB_PANE, IA2_RELATION_CONTAINING_TAB_PANE)
+
+RELATIONTYPE(CONTAINING_WINDOW, "containing window", ATK_RELATION_NULL,
+             NAVRELATION_CONTAINING_WINDOW, IA2_RELATION_CONTAINING_WINDOW)
+
+RELATIONTYPE(CONTAINING_APPLICATION, "containing application",
+             ATK_RELATION_NULL, NAVRELATION_CONTAINING_APPLICATION,
+             IA2_RELATION_CONTAINING_APPLICATION)
+
+RELATIONTYPE(DETAILS, "details", ATK_RELATION_DETAILS, NAVRELATION_DETAILS,
+             IA2_RELATION_DETAILS)
+
+RELATIONTYPE(DETAILS_FOR, "details for", ATK_RELATION_DETAILS_FOR,
+             NAVRELATION_DETAILS_FOR, IA2_RELATION_DETAILS_FOR)
+
+RELATIONTYPE(ERRORMSG, "error", ATK_RELATION_ERROR_MESSAGE, NAVRELATION_ERROR,
+             IA2_RELATION_ERROR)
+
+RELATIONTYPE(ERRORMSG_FOR, "error for", ATK_RELATION_ERROR_FOR,
+             NAVRELATION_ERROR_FOR, IA2_RELATION_ERROR_FOR)
+
+RELATIONTYPE(LINKS_TO, "links to", ATK_RELATION_NULL, NAVRELATION_LINKS_TO,
+             IA2_RELATION_NULL)
diff --git a/accessible/base/RoleHGen.py b/accessible/base/RoleHGen.py
new file mode 100644
index 0000000000..374d2f66a9
--- /dev/null
+++ b/accessible/base/RoleHGen.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env 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/.
+
+import re
+
+
+def generate(roleH, roleIdl):
+    input = open(roleIdl, "rt").read()
+    roles = re.findall(r"const unsigned long ROLE_([A-Z_]+) = (\d+);", input)
+
+    roleH.write(
+        "/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */\n"
+        "/* Roles are defined in accessible/interfaces/nsIAccessibleRole.idl */\n\n"
+        "#ifndef _role_h_\n"
+        "#define _role_h_\n\n"
+        "namespace mozilla {\n"
+        "namespace a11y {\n"
+        "namespace roles {\n\n"
+        "enum Role {\n"
+    )
+    for name, num in roles:
+        roleH.write(f"  {name} = {num},\n")
+    lastName = roles[-1][0]
+    roleH.write(
+        f"  LAST_ROLE = {lastName}\n"
+        "};\n\n"
+        "}  // namespace roles\n\n"
+        "typedef enum mozilla::a11y::roles::Role role;\n\n"
+        "}  // namespace a11y\n"
+        "}  // namespace mozilla\n\n"
+        "#endif\n"
+    )
+
+
+# For debugging
+if __name__ == "__main__":
+    import sys
+
+    generate(sys.stdout, "accessible/interfaces/nsIAccessibleRole.idl")
diff --git a/accessible/base/RoleMap.h b/accessible/base/RoleMap.h
new file mode 100644
index 0000000000..ce82000188
--- /dev/null
+++ b/accessible/base/RoleMap.h
@@ -0,0 +1,1546 @@
+/* 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/. */
+
+// clang-format off
+/**
+ * Usage: declare the macro ROLE()with the following arguments:
+ * ROLE(geckoRole, stringRole, ariaRole, atkRole, macRole, macSubrole, msaaRole, ia2Role, nameRule)
+ */
+
+ROLE(NOTHING,
+     "nothing",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityUnknownRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_CLIENT,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(MENUBAR,
+     "menubar",
+     nsGkAtoms::menubar,
+     ATK_ROLE_MENU_BAR,
+     NSAccessibilityMenuBarRole,  //Irrelevant on OS X; the menubar will always be native and on the top of the screen.
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_MENUBAR,
+     ROLE_SYSTEM_MENUBAR,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(SCROLLBAR,
+     "scrollbar",
+     nsGkAtoms::scrollbar,
+     ATK_ROLE_SCROLL_BAR,
+     NSAccessibilityScrollBarRole,  //We might need to make this its own mozAccessible, to support the children objects (valueindicator, down/up buttons).
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_SCROLLBAR,
+     ROLE_SYSTEM_SCROLLBAR,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromValueRule)
+
+ROLE(ALERT,
+     "alert",
+     nsGkAtoms::alert,
+     ATK_ROLE_ALERT,
+     NSAccessibilityGroupRole,
+     @"AXApplicationAlert",
+     ROLE_SYSTEM_ALERT,
+     ROLE_SYSTEM_ALERT,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(INTERNAL_FRAME,
+     "internal frame",
+     nullptr,
+     ATK_ROLE_INTERNAL_FRAME,
+     NSAccessibilityScrollAreaRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_INTERNAL_FRAME,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MENUPOPUP,
+     "menupopup",
+     nsGkAtoms::menu,
+     ATK_ROLE_MENU,
+     NSAccessibilityMenuRole,  //The parent of menuitems.
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_MENUPOPUP,
+     ROLE_SYSTEM_MENUPOPUP,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MENUITEM,
+     "menuitem",
+     nsGkAtoms::menuitem,
+     ATK_ROLE_MENU_ITEM,
+     NSAccessibilityMenuItemRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_MENUITEM,
+     ROLE_SYSTEM_MENUITEM,
+     java::SessionAccessibility::CLASSNAME_MENUITEM,
+     eNameFromSubtreeRule)
+
+ROLE(TOOLTIP,
+     "tooltip",
+     nsGkAtoms::tooltip,
+     ATK_ROLE_TOOL_TIP,
+     NSAccessibilityGroupRole,
+     @"AXUserInterfaceTooltip",
+     ROLE_SYSTEM_TOOLTIP,
+     ROLE_SYSTEM_TOOLTIP,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(APPLICATION,
+     "application",
+     nsGkAtoms::application,
+     ATK_ROLE_EMBEDDED,
+     NSAccessibilityGroupRole,  //Unused on OS X. the system will take care of this.
+     @"AXLandmarkApplication",
+     ROLE_SYSTEM_APPLICATION,
+     ROLE_SYSTEM_APPLICATION,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(DOCUMENT,
+     "document",
+     nsGkAtoms::document,
+     ATK_ROLE_DOCUMENT_WEB,
+     @"AXWebArea",
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_DOCUMENT,
+     ROLE_SYSTEM_DOCUMENT,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+/**
+ *  msaa comment:
+ *   We used to map to ROLE_SYSTEM_PANE, but JAWS would
+ *   not read the accessible name for the contaning pane.
+ *   However, JAWS will read the accessible name for a groupbox.
+ *   By mapping a PANE to a GROUPING, we get no undesirable effects,
+ *   but fortunately JAWS will then read the group's label,
+ *   when an inner control gets focused.
+ */
+ROLE(PANE,
+     "pane",
+     nullptr,
+     ATK_ROLE_PANEL,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     ROLE_SYSTEM_GROUPING,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(DIALOG,
+     "dialog",
+     nsGkAtoms::dialog,
+     ATK_ROLE_DIALOG,
+     NSAccessibilityGroupRole,  //There's a dialog subrole.
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_DIALOG,
+     ROLE_SYSTEM_DIALOG,
+     java::SessionAccessibility::CLASSNAME_DIALOG,
+     eNoNameRule)
+
+ROLE(GROUPING,
+     "grouping",
+     nsGkAtoms::group,
+     ATK_ROLE_PANEL,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     ROLE_SYSTEM_GROUPING,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(SEPARATOR,
+     "separator",
+     nsGkAtoms::separator_,
+     ATK_ROLE_SEPARATOR,
+     NSAccessibilitySplitterRole,
+     @"AXContentSeparator",
+     ROLE_SYSTEM_SEPARATOR,
+     ROLE_SYSTEM_SEPARATOR,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(TOOLBAR,
+     "toolbar",
+     nsGkAtoms::toolbar,
+     ATK_ROLE_TOOL_BAR,
+     NSAccessibilityToolbarRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_TOOLBAR,
+     ROLE_SYSTEM_TOOLBAR,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(STATUSBAR,
+     "statusbar",
+     nsGkAtoms::status,
+     ATK_ROLE_STATUSBAR,
+     NSAccessibilityGroupRole,
+     @"AXApplicationStatus",
+     ROLE_SYSTEM_STATUSBAR,
+     ROLE_SYSTEM_STATUSBAR,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(TABLE,
+     "table",
+     nsGkAtoms::table,
+     ATK_ROLE_TABLE,
+     NSAccessibilityTableRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_TABLE,
+     ROLE_SYSTEM_TABLE,
+     java::SessionAccessibility::CLASSNAME_GRIDVIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(COLUMNHEADER,
+     "columnheader",
+     nsGkAtoms::columnheader,
+     ATK_ROLE_COLUMN_HEADER,
+     NSAccessibilityCellRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_COLUMNHEADER,
+     ROLE_SYSTEM_COLUMNHEADER,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(ROWHEADER,
+     "rowheader",
+     nsGkAtoms::rowheader,
+     ATK_ROLE_ROW_HEADER,
+     NSAccessibilityCellRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_ROWHEADER,
+     ROLE_SYSTEM_ROWHEADER,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(ROW,
+     "row",
+     nsGkAtoms::row,
+     ATK_ROLE_TABLE_ROW,
+     NSAccessibilityRowRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_ROW,
+     ROLE_SYSTEM_ROW,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(CELL,
+     "cell",
+     nsGkAtoms::cell,
+     ATK_ROLE_TABLE_CELL,
+     NSAccessibilityCellRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_CELL,
+     ROLE_SYSTEM_CELL,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(LINK,
+     "link",
+     nsGkAtoms::link,
+     ATK_ROLE_LINK,
+     NSAccessibilityLinkRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_LINK,
+     ROLE_SYSTEM_LINK,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(LIST,
+     "list",
+     nsGkAtoms::list_,
+     ATK_ROLE_LIST,
+     NSAccessibilityListRole,
+     NSAccessibilityContentListSubrole,
+     ROLE_SYSTEM_LIST,
+     ROLE_SYSTEM_LIST,
+     java::SessionAccessibility::CLASSNAME_LISTVIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(LISTITEM,
+     "listitem",
+     nsGkAtoms::listitem,
+     ATK_ROLE_LIST_ITEM,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_LISTITEM,
+     ROLE_SYSTEM_LISTITEM,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(OUTLINE,
+     "outline",
+     nsGkAtoms::tree,
+     ATK_ROLE_TREE,
+     NSAccessibilityOutlineRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_OUTLINE,
+     ROLE_SYSTEM_OUTLINE,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(OUTLINEITEM,
+     "outlineitem",
+     nsGkAtoms::treeitem,
+     ATK_ROLE_TREE_ITEM,
+     NSAccessibilityRowRole,
+     NSAccessibilityOutlineRowSubrole,
+     ROLE_SYSTEM_OUTLINEITEM,
+     ROLE_SYSTEM_OUTLINEITEM,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(PAGETAB,
+     "pagetab",
+     nsGkAtoms::tab,
+     ATK_ROLE_PAGE_TAB,
+     NSAccessibilityRadioButtonRole,
+     @"AXTabButton", // Can be upgraded to NSAccessibilityTabButtonSubrole in 10.13
+     ROLE_SYSTEM_PAGETAB,
+     ROLE_SYSTEM_PAGETAB,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(PROPERTYPAGE,
+     "propertypage",
+     nsGkAtoms::tabpanel,
+     ATK_ROLE_SCROLL_PANE,
+     NSAccessibilityGroupRole,
+     @"AXTabPanel",
+     ROLE_SYSTEM_PROPERTYPAGE,
+     ROLE_SYSTEM_PROPERTYPAGE,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(GRAPHIC,
+     "graphic",
+     nsGkAtoms::image,
+     ATK_ROLE_IMAGE,
+     NSAccessibilityImageRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GRAPHIC,
+     ROLE_SYSTEM_GRAPHIC,
+     java::SessionAccessibility::CLASSNAME_IMAGE,
+     eNoNameRule)
+
+ROLE(STATICTEXT,
+     "statictext",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityStaticTextRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_STATICTEXT,
+     ROLE_SYSTEM_STATICTEXT,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(TEXT_LEAF,
+     "text leaf",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityStaticTextRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_TEXT,
+     ROLE_SYSTEM_TEXT,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(PUSHBUTTON,
+     "pushbutton",
+     nsGkAtoms::button,
+     ATK_ROLE_PUSH_BUTTON,
+     NSAccessibilityButtonRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_PUSHBUTTON,
+     ROLE_SYSTEM_PUSHBUTTON,
+     java::SessionAccessibility::CLASSNAME_BUTTON,
+     eNameFromSubtreeRule)
+
+ROLE(CHECKBUTTON,
+     "checkbutton",
+     nsGkAtoms::checkbox,
+     ATK_ROLE_CHECK_BOX,
+     NSAccessibilityCheckBoxRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_CHECKBUTTON,
+     ROLE_SYSTEM_CHECKBUTTON,
+     java::SessionAccessibility::CLASSNAME_CHECKBOX,
+     eNameFromSubtreeRule)
+
+ROLE(RADIOBUTTON,
+     "radiobutton",
+     nsGkAtoms::radio,
+     ATK_ROLE_RADIO_BUTTON,
+     NSAccessibilityRadioButtonRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_RADIOBUTTON,
+     ROLE_SYSTEM_RADIOBUTTON,
+     java::SessionAccessibility::CLASSNAME_RADIOBUTTON,
+     eNameFromSubtreeRule)
+
+// Equivalent of HTML select element with size="1". See also EDITCOMBOBOX.
+ROLE(COMBOBOX,
+     "combobox",
+     nsGkAtoms::combobox,
+     ATK_ROLE_COMBO_BOX,
+     NSAccessibilityPopUpButtonRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_COMBOBOX,
+     ROLE_SYSTEM_COMBOBOX,
+     java::SessionAccessibility::CLASSNAME_SPINNER,
+     eNameFromValueRule)
+
+ROLE(PROGRESSBAR,
+     "progressbar",
+     nsGkAtoms::progressbar,
+     ATK_ROLE_PROGRESS_BAR,
+     NSAccessibilityProgressIndicatorRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_PROGRESSBAR,
+     ROLE_SYSTEM_PROGRESSBAR,
+     java::SessionAccessibility::CLASSNAME_PROGRESSBAR,
+     eNameFromValueRule)
+
+ROLE(SLIDER,
+     "slider",
+     nsGkAtoms::slider,
+     ATK_ROLE_SLIDER,
+     NSAccessibilitySliderRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_SLIDER,
+     ROLE_SYSTEM_SLIDER,
+     java::SessionAccessibility::CLASSNAME_SEEKBAR,
+     eNameFromValueRule)
+
+ROLE(SPINBUTTON,
+     "spinbutton",
+     nsGkAtoms::spinbutton,
+     ATK_ROLE_SPIN_BUTTON,
+     NSAccessibilityIncrementorRole,  //Subroles: Increment/Decrement.
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_SPINBUTTON,
+     ROLE_SYSTEM_SPINBUTTON,
+     java::SessionAccessibility::CLASSNAME_EDITTEXT,
+     eNameFromValueRule)
+
+ROLE(DIAGRAM,
+     "diagram",
+     nsGkAtoms::graphicsDocument,
+     ATK_ROLE_IMAGE,
+     NSAccessibilityImageRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_DIAGRAM,
+     ROLE_SYSTEM_DIAGRAM,
+     java::SessionAccessibility::CLASSNAME_IMAGE,
+     eNoNameRule)
+
+ROLE(ANIMATION,
+     "animation",
+     nsGkAtoms::marquee,
+     ATK_ROLE_ANIMATION,
+     NSAccessibilityUnknownRole,
+     @"AXApplicationMarquee",
+     ROLE_SYSTEM_ANIMATION,
+     ROLE_SYSTEM_ANIMATION,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(BUTTONDROPDOWN,
+     "buttondropdown",
+     nullptr,
+     ATK_ROLE_PUSH_BUTTON,
+     NSAccessibilityPopUpButtonRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_BUTTONDROPDOWN,
+     ROLE_SYSTEM_BUTTONDROPDOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(BUTTONMENU,
+     "buttonmenu",
+     nsGkAtoms::button,
+     ATK_ROLE_PUSH_BUTTON,
+     NSAccessibilityMenuButtonRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_BUTTONMENU,
+     ROLE_SYSTEM_BUTTONMENU,
+     java::SessionAccessibility::CLASSNAME_SPINNER,
+     eNameFromSubtreeRule)
+
+ROLE(WHITESPACE,
+     "whitespace",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityUnknownRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_WHITESPACE,
+     ROLE_SYSTEM_WHITESPACE,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(PAGETABLIST,
+     "pagetablist",
+     nsGkAtoms::tablist,
+     ATK_ROLE_PAGE_TAB_LIST,
+     NSAccessibilityTabGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_PAGETABLIST,
+     ROLE_SYSTEM_PAGETABLIST,
+     java::SessionAccessibility::CLASSNAME_TABWIDGET,
+     eNoNameRule)
+
+ROLE(CANVAS,
+     "canvas",
+     nullptr,
+     ATK_ROLE_CANVAS,
+     NSAccessibilityImageRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GRAPHIC,
+     IA2_ROLE_CANVAS,
+     java::SessionAccessibility::CLASSNAME_IMAGE,
+     eNoNameRule)
+
+ROLE(CHECK_MENU_ITEM,
+     "check menu item",
+     nsGkAtoms::menuitemcheckbox,
+     ATK_ROLE_CHECK_MENU_ITEM,
+     NSAccessibilityMenuItemRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_MENUITEM,
+     IA2_ROLE_CHECK_MENU_ITEM,
+     java::SessionAccessibility::CLASSNAME_MENUITEM,
+     eNameFromSubtreeRule)
+
+ROLE(DATE_EDITOR,
+     "date editor",
+     nullptr,
+     ATK_ROLE_DATE_EDITOR,
+     @"AXGroup",
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_DATE_EDITOR,
+     java::SessionAccessibility::CLASSNAME_SPINNER,
+     eNoNameRule)
+
+ROLE(CHROME_WINDOW,
+     "chrome window",
+     nullptr,
+     ATK_ROLE_FRAME,
+     NSAccessibilityGroupRole,  //Contains the main Firefox UI
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_APPLICATION,
+     IA2_ROLE_FRAME,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(LABEL,
+     "label",
+     nullptr,
+     ATK_ROLE_LABEL,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_STATICTEXT,
+     IA2_ROLE_LABEL,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(PASSWORD_TEXT,
+     "password text",
+     nullptr,
+     ATK_ROLE_PASSWORD_TEXT,
+     NSAccessibilityTextFieldRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_TEXT,
+     ROLE_SYSTEM_TEXT,
+     java::SessionAccessibility::CLASSNAME_EDITTEXT,
+     eNoNameRule)
+
+ROLE(RADIO_MENU_ITEM,
+     "radio menu item",
+     nsGkAtoms::menuitemradio,
+     ATK_ROLE_RADIO_MENU_ITEM,
+     NSAccessibilityMenuItemRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_MENUITEM,
+     IA2_ROLE_RADIO_MENU_ITEM,
+     java::SessionAccessibility::CLASSNAME_MENUITEM,
+     eNameFromSubtreeRule)
+
+ROLE(TEXT_CONTAINER,
+     "text container",
+     nsGkAtoms::generic,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_TEXT_FRAME,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(TOGGLE_BUTTON,
+     "toggle button",
+     nsGkAtoms::button,
+     ATK_ROLE_TOGGLE_BUTTON,
+     NSAccessibilityCheckBoxRole,
+     NSAccessibilityToggleSubrole,
+     ROLE_SYSTEM_PUSHBUTTON,
+     IA2_ROLE_TOGGLE_BUTTON,
+     java::SessionAccessibility::CLASSNAME_TOGGLEBUTTON,
+     eNameFromSubtreeRule)
+
+ROLE(TREE_TABLE,
+     "tree table",
+     nsGkAtoms::treegrid,
+     ATK_ROLE_TREE_TABLE,
+     NSAccessibilityTableRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_OUTLINE,
+     ROLE_SYSTEM_OUTLINE,
+     java::SessionAccessibility::CLASSNAME_GRIDVIEW,
+     eNoNameRule)
+
+ROLE(PARAGRAPH,
+     "paragraph",
+     nsGkAtoms::paragraph,
+     ATK_ROLE_PARAGRAPH,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_PARAGRAPH,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(ENTRY,
+     "entry",
+     nsGkAtoms::textbox,
+     ATK_ROLE_ENTRY,
+     NSAccessibilityTextFieldRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_TEXT,
+     ROLE_SYSTEM_TEXT,
+     java::SessionAccessibility::CLASSNAME_EDITTEXT,
+     eNameFromValueRule)
+
+ROLE(CAPTION,
+     "caption",
+     nsGkAtoms::caption,
+     ATK_ROLE_CAPTION,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_CAPTION,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(NON_NATIVE_DOCUMENT,
+     "non-native document",
+     nsGkAtoms::document,
+     ATK_ROLE_DOCUMENT_FRAME,
+     NSAccessibilityGroupRole,
+     @"AXDocument",
+     ROLE_SYSTEM_DOCUMENT,
+     ROLE_SYSTEM_DOCUMENT,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(HEADING,
+     "heading",
+     nsGkAtoms::heading,
+     ATK_ROLE_HEADING,
+     @"AXHeading",
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_HEADING,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(SECTION,
+     "section",
+     nsGkAtoms::generic,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_SECTION,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(FORM,
+     "form",
+     nsGkAtoms::form,
+     ATK_ROLE_FORM,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_FORM,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(APP_ROOT,
+     "app root",
+     nullptr,
+     ATK_ROLE_APPLICATION,
+     NSAccessibilityUnknownRole,  //Unused on OS X
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_APPLICATION,
+     ROLE_SYSTEM_APPLICATION,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(PARENT_MENUITEM,
+     "parent menuitem",
+     nsGkAtoms::menuitem,
+     ATK_ROLE_MENU,
+     NSAccessibilityMenuItemRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_MENUITEM,
+     ROLE_SYSTEM_MENUITEM,
+     java::SessionAccessibility::CLASSNAME_MENUITEM,
+     eNameFromSubtreeRule)
+
+ROLE(COMBOBOX_LIST,
+     "combobox list",
+     nsGkAtoms::listbox,
+     ATK_ROLE_MENU,
+     NSAccessibilityMenuRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_LIST,
+     ROLE_SYSTEM_LIST,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(COMBOBOX_OPTION,
+     "combobox option",
+     nsGkAtoms::option,
+     ATK_ROLE_MENU_ITEM,
+     NSAccessibilityMenuItemRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_LISTITEM,
+     ROLE_SYSTEM_LISTITEM,
+     java::SessionAccessibility::CLASSNAME_MENUITEM,
+     eNameFromSubtreeRule)
+
+ROLE(IMAGE_MAP,
+     "image map",
+     nsGkAtoms::img,
+     ATK_ROLE_IMAGE,
+     @"AXImageMap",
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GRAPHIC,
+     ROLE_SYSTEM_GRAPHIC,
+     java::SessionAccessibility::CLASSNAME_IMAGE,
+     eNoNameRule)
+
+ROLE(OPTION,
+     "listbox option",
+     nsGkAtoms::option,
+     ATK_ROLE_LIST_ITEM,
+     NSAccessibilityStaticTextRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_LISTITEM,
+     ROLE_SYSTEM_LISTITEM,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(RICH_OPTION,
+     "listbox rich option",
+     nullptr,
+     ATK_ROLE_LIST_ITEM,
+     NSAccessibilityRowRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_LISTITEM,
+     ROLE_SYSTEM_LISTITEM,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(LISTBOX,
+     "listbox",
+     nsGkAtoms::listbox,
+     ATK_ROLE_LIST_BOX,
+     NSAccessibilityListRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_LIST,
+     ROLE_SYSTEM_LIST,
+     java::SessionAccessibility::CLASSNAME_LISTVIEW,
+     eNoNameRule)
+
+ROLE(FLAT_EQUATION,
+     "flat equation",
+     nsGkAtoms::math,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityUnknownRole,
+     @"AXDocumentMath",
+     ROLE_SYSTEM_EQUATION,
+     ROLE_SYSTEM_EQUATION,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(GRID_CELL,
+     "gridcell",
+     nsGkAtoms::gridcell,
+     ATK_ROLE_TABLE_CELL,
+     NSAccessibilityCellRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_CELL,
+     ROLE_SYSTEM_CELL,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(NOTE,
+     "note",
+     nsGkAtoms::note_,
+     ATK_ROLE_COMMENT,
+     NSAccessibilityGroupRole,
+     @"AXDocumentNote",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_NOTE,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(FIGURE,
+     "figure",
+     nsGkAtoms::figure,
+     ATK_ROLE_PANEL,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     ROLE_SYSTEM_GROUPING,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(CHECK_RICH_OPTION,
+     "check rich option",
+     nullptr,
+     ATK_ROLE_CHECK_BOX,
+     NSAccessibilityCheckBoxRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_CHECKBUTTON,
+     ROLE_SYSTEM_CHECKBUTTON,
+     java::SessionAccessibility::CLASSNAME_CHECKBOX,
+     eNameFromSubtreeRule)
+
+ROLE(DEFINITION_LIST,
+     "definitionlist",
+     nullptr,
+     ATK_ROLE_LIST,
+     NSAccessibilityListRole,
+     @"AXDescriptionList",
+     ROLE_SYSTEM_LIST,
+     ROLE_SYSTEM_LIST,
+     java::SessionAccessibility::CLASSNAME_LISTVIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(TERM,
+     "term",
+     nsGkAtoms::term,
+     ATK_ROLE_DESCRIPTION_TERM,
+     NSAccessibilityGroupRole,
+     @"AXTerm",
+     ROLE_SYSTEM_LISTITEM,
+     ROLE_SYSTEM_LISTITEM,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(DEFINITION,
+     "definition",
+     nsGkAtoms::definition,
+     ATK_ROLE_PARAGRAPH,
+     NSAccessibilityGroupRole,
+     @"AXDescription",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_PARAGRAPH,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(KEY,
+     "key",
+     nullptr,
+     ATK_ROLE_PUSH_BUTTON,
+     NSAccessibilityButtonRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_PUSHBUTTON,
+     ROLE_SYSTEM_PUSHBUTTON,
+     java::SessionAccessibility::CLASSNAME_BUTTON,
+     eNameFromSubtreeRule)
+
+ROLE(SWITCH,
+     "switch",
+     nsGkAtoms::svgSwitch,
+     ATK_ROLE_TOGGLE_BUTTON,
+     NSAccessibilityCheckBoxRole,
+     NSAccessibilitySwitchSubrole,
+     ROLE_SYSTEM_CHECKBUTTON,
+     IA2_ROLE_TOGGLE_BUTTON,
+     java::SessionAccessibility::CLASSNAME_CHECKBOX,
+     eNameFromSubtreeRule)
+
+ROLE(MATHML_MATH,
+     "math",
+     nsGkAtoms::math,
+     ATK_ROLE_MATH,
+     NSAccessibilityGroupRole,
+     @"AXDocumentMath",
+     ROLE_SYSTEM_EQUATION,
+     ROLE_SYSTEM_EQUATION,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_IDENTIFIER,
+     "mathml identifier",
+     nullptr,
+     ATK_ROLE_STATIC,
+     NSAccessibilityGroupRole,
+     @"AXMathIdentifier",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(MATHML_NUMBER,
+     "mathml number",
+     nullptr,
+     ATK_ROLE_STATIC,
+     NSAccessibilityGroupRole,
+     @"AXMathNumber",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(MATHML_OPERATOR,
+     "mathml operator",
+     nullptr,
+     ATK_ROLE_STATIC,
+     NSAccessibilityGroupRole,
+     @"AXMathOperator",
+     // XXX: NSAccessibility also uses subroles AXMathSeparatorOperator and
+    // AXMathFenceOperator. We should use the NS_MATHML_OPERATOR_FENCE and
+    // NS_MATHML_OPERATOR_SEPARATOR bits of nsOperatorFlags, but currently they
+    // are only available from the MathML layout code. Hence we just fallback
+    // to subrole AXMathOperator for now.
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(MATHML_TEXT,
+     "mathml text",
+     nullptr,
+     ATK_ROLE_STATIC,
+     NSAccessibilityGroupRole,
+     @"AXMathRoot",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(MATHML_STRING_LITERAL,
+     "mathml string literal",
+     nullptr,
+     ATK_ROLE_STATIC,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeRule)
+
+ROLE(MATHML_GLYPH,
+     "mathml glyph",
+     nullptr,
+     ATK_ROLE_IMAGE,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_IMAGE,
+     eNameFromSubtreeRule)
+
+ROLE(MATHML_ROW,
+     "mathml row",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     @"AXMathRow",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_FRACTION,
+     "mathml fraction",
+     nullptr,
+     ATK_ROLE_MATH_FRACTION,
+     NSAccessibilityGroupRole,
+     @"AXMathFraction",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_SQUARE_ROOT,
+     "mathml square root",
+     nullptr,
+     ATK_ROLE_MATH_ROOT,
+     NSAccessibilityGroupRole,
+     @"AXMathSquareRoot",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_ROOT,
+     "mathml root",
+     nullptr,
+     ATK_ROLE_MATH_ROOT,
+     NSAccessibilityGroupRole,
+     @"AXMathRoot",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_ENCLOSED,
+     "mathml enclosed",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_STYLE,
+     "mathml style",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     @"AXMathRow",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_SUB,
+     "mathml sub",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     @"AXMathSubscriptSuperscript",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_SUP,
+     "mathml sup",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     @"AXMathSubscriptSuperscript",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_SUB_SUP,
+     "mathml sub sup",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     @"AXMathSubscriptSuperscript",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_UNDER,
+     "mathml under",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     @"AXMathUnderOver",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_OVER,
+     "mathml over",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     @"AXMathUnderOver",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_UNDER_OVER,
+     "mathml under over",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     @"AXMathUnderOver",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_MULTISCRIPTS,
+     "mathml multiscripts",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     @"AXMathMultiscript",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_TABLE,
+     "mathml table",
+     nullptr,
+     ATK_ROLE_TABLE,
+     NSAccessibilityGroupRole,
+     @"AXMathTable",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_GRIDVIEW,
+     eNoNameRule)
+
+ROLE(MATHML_LABELED_ROW,
+     "mathml labeled row",
+     nullptr,
+     ATK_ROLE_TABLE_ROW,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_TABLE_ROW,
+     "mathml table row",
+     nullptr,
+     ATK_ROLE_TABLE_ROW,
+     NSAccessibilityGroupRole,
+     @"AXMathTableRow",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_CELL,
+     "mathml cell",
+     nullptr,
+     ATK_ROLE_TABLE_CELL,
+     NSAccessibilityGroupRole,
+     @"AXMathTableCell",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_ACTION,
+     "mathml action",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_ERROR,
+     "mathml error",
+     nullptr,
+     ATK_ROLE_SECTION,
+     NSAccessibilityGroupRole,
+     @"AXMathRow",
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_STACK,
+     "mathml stack",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_LONG_DIVISION,
+     "mathml long division",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_STACK_GROUP,
+     "mathml stack group",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_STACK_ROW,
+     "mathml stack row",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_STACK_CARRIES,
+     "mathml stack carries",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_STACK_CARRY,
+     "mathml stack carry",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MATHML_STACK_LINE,
+     "mathml stack line",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     0,
+     IA2_ROLE_UNKNOWN,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(RADIO_GROUP,
+     "grouping",
+     nsGkAtoms::radiogroup,
+     ATK_ROLE_PANEL,
+     NSAccessibilityRadioGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     ROLE_SYSTEM_GROUPING,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(TEXT,
+     "text",
+     nsGkAtoms::generic,
+     ATK_ROLE_STATIC,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_TEXT_FRAME,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(DETAILS,
+     "details",
+     nsGkAtoms::group,
+     ATK_ROLE_PANEL,
+     NSAccessibilityGroupRole,
+     @"AXDetails",
+     ROLE_SYSTEM_GROUPING,
+     ROLE_SYSTEM_GROUPING,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(SUMMARY,
+     "summary",
+     nullptr,
+     ATK_ROLE_PUSH_BUTTON,
+     NSAccessibilityButtonRole,
+     @"AXSummary",
+     ROLE_SYSTEM_PUSHBUTTON,
+     ROLE_SYSTEM_PUSHBUTTON,
+     java::SessionAccessibility::CLASSNAME_BUTTON,
+     eNameFromSubtreeRule)
+
+ROLE(LANDMARK,
+     "landmark",
+     nullptr,
+     ATK_ROLE_LANDMARK,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_LANDMARK,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(NAVIGATION,
+     "navigation",
+     nullptr,
+     ATK_ROLE_LANDMARK,
+     NSAccessibilityGroupRole,
+     @"AXLandmarkNavigation",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_LANDMARK,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(FOOTNOTE,
+     "footnote",
+     nullptr,
+     ATK_ROLE_FOOTNOTE,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_FOOTNOTE,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(ARTICLE,
+     "article",
+     nsGkAtoms::article,
+     ATK_ROLE_ARTICLE,
+     NSAccessibilityGroupRole,
+     @"AXDocumentArticle",
+     ROLE_SYSTEM_DOCUMENT,
+     ROLE_SYSTEM_DOCUMENT,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(REGION,
+     "region",
+     nsGkAtoms::region,
+     ATK_ROLE_LANDMARK,
+     NSAccessibilityGroupRole,
+     @"AXLandmarkRegion",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_LANDMARK,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+// A composite widget with a text input and popup. Used for ARIA role combobox.
+// See also COMBOBOX.
+ROLE(EDITCOMBOBOX,
+     "editcombobox",
+     nsGkAtoms::combobox,
+     ATK_ROLE_COMBO_BOX,
+     NSAccessibilityComboBoxRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_COMBOBOX,
+     ROLE_SYSTEM_COMBOBOX,
+     java::SessionAccessibility::CLASSNAME_EDITTEXT,
+     eNameFromValueRule)
+
+ROLE(BLOCKQUOTE,
+     "blockquote",
+     nsGkAtoms::blockquote,
+     ATK_ROLE_BLOCK_QUOTE,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_BLOCK_QUOTE,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(CONTENT_DELETION,
+     "content deletion",
+     nsGkAtoms::deletion,
+     ATK_ROLE_CONTENT_DELETION,
+     NSAccessibilityGroupRole,
+     @"AXDeleteStyleGroup",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_CONTENT_DELETION,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(CONTENT_INSERTION,
+     "content insertion",
+     nsGkAtoms::insertion,
+     ATK_ROLE_CONTENT_INSERTION,
+     NSAccessibilityGroupRole,
+     @"AXInsertStyleGroup",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_CONTENT_INSERTION,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(FORM_LANDMARK,
+     "form",
+     nsGkAtoms::form,
+     ATK_ROLE_LANDMARK,
+     NSAccessibilityGroupRole,
+     @"AXLandmarkForm",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_FORM,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(MARK,
+     "mark",
+     nsGkAtoms::mark,
+     ATK_ROLE_MARK,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_MARK,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(SUGGESTION,
+     "suggestion",
+     nsGkAtoms::suggestion,
+     ATK_ROLE_SUGGESTION,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_SUGGESTION,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(COMMENT,
+     "comment",
+     nsGkAtoms::comment,
+     ATK_ROLE_COMMENT,
+     NSAccessibilityGroupRole,
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_COMMENT,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(CODE,
+     "code",
+     nsGkAtoms::code,
+     ATK_ROLE_STATIC,
+     NSAccessibilityGroupRole,
+     @"AXCodeStyleGroup",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_TEXT_FRAME,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(TIME_EDITOR,
+     "time editor",
+     nullptr,
+     ATK_ROLE_PANEL,
+     @"AXTimeField",
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_GROUPING,
+     ROLE_SYSTEM_GROUPING,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(LISTITEM_MARKER,
+     "list item marker",
+     nullptr,
+     ATK_ROLE_UNKNOWN,
+     @"AXListMarker",
+     NSAccessibilityUnknownSubrole,
+     ROLE_SYSTEM_STATICTEXT,
+     ROLE_SYSTEM_STATICTEXT,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNoNameRule)
+
+ROLE(METER,
+     "meter",
+     nsGkAtoms::meter,
+     ATK_ROLE_LEVEL_BAR,
+     NSAccessibilityLevelIndicatorRole,
+     @"AXMeter",
+     ROLE_SYSTEM_PROGRESSBAR,
+     ROLE_SYSTEM_PROGRESSBAR,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromValueRule)
+
+ROLE(SUBSCRIPT,
+     "subscript",
+     nsGkAtoms::subscript,
+     ATK_ROLE_SUBSCRIPT,
+     NSAccessibilityGroupRole,
+     @"AXSubscriptStyleGroup",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_TEXT_FRAME,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(SUPERSCRIPT,
+     "superscript",
+     nsGkAtoms::superscript,
+     ATK_ROLE_SUPERSCRIPT,
+     NSAccessibilityGroupRole,
+     @"AXSuperscriptStyleGroup",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_TEXT_FRAME,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(EMPHASIS,
+     "emphasis",
+     nsGkAtoms::emphasis,
+     ATK_ROLE_STATIC,
+     NSAccessibilityGroupRole,
+     @"AXEmphasisStyleGroup",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_TEXT_FRAME,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(STRONG,
+     "strong",
+     nsGkAtoms::strong,
+     ATK_ROLE_STATIC,
+     NSAccessibilityGroupRole,
+     @"AXStrongStyleGroup",
+     ROLE_SYSTEM_GROUPING,
+     IA2_ROLE_TEXT_FRAME,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+ROLE(TIME,
+     "time",
+     nsGkAtoms::time,
+     ATK_ROLE_STATIC,
+     NSAccessibilityGroupRole,
+     @"AXTimeGroup",
+     ROLE_SYSTEM_GROUPING,
+     ROLE_SYSTEM_GROUPING,
+     java::SessionAccessibility::CLASSNAME_VIEW,
+     eNameFromSubtreeIfReqRule)
+
+// clang-format on
diff --git a/accessible/base/SelectionManager.cpp b/accessible/base/SelectionManager.cpp
new file mode 100644
index 0000000000..97721bb439
--- /dev/null
+++ b/accessible/base/SelectionManager.cpp
@@ -0,0 +1,246 @@
+/* -*- 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 "mozilla/a11y/SelectionManager.h"
+
+#include "DocAccessible-inl.h"
+#include "HyperTextAccessible.h"
+#include "HyperTextAccessible-inl.h"
+#include "nsAccUtils.h"
+#include "nsCoreUtils.h"
+#include "nsEventShell.h"
+#include "nsFrameSelection.h"
+#include "TextLeafRange.h"
+
+#include "mozilla/PresShell.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/dom/Element.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+using mozilla::dom::Selection;
+
+struct mozilla::a11y::SelData final {
+  SelData(Selection* aSel, int32_t aReason, int32_t aGranularity)
+      : mSel(aSel), mReason(aReason), mGranularity(aGranularity) {}
+
+  RefPtr<Selection> mSel;
+  int16_t mReason;
+  int32_t mGranularity;
+
+  NS_INLINE_DECL_REFCOUNTING(SelData)
+
+ private:
+  // Private destructor, to discourage deletion outside of Release():
+  ~SelData() {}
+};
+
+SelectionManager::SelectionManager()
+    : mCaretOffset(-1), mAccWithCaret(nullptr) {}
+
+void SelectionManager::ClearControlSelectionListener() {
+  // Remove 'this' registered as selection listener for the normal selection.
+  if (mCurrCtrlNormalSel) {
+    mCurrCtrlNormalSel->RemoveSelectionListener(this);
+    mCurrCtrlNormalSel = nullptr;
+  }
+
+  // Remove 'this' registered as selection listener for the spellcheck
+  // selection.
+  if (mCurrCtrlSpellSel) {
+    mCurrCtrlSpellSel->RemoveSelectionListener(this);
+    mCurrCtrlSpellSel = nullptr;
+  }
+}
+
+void SelectionManager::SetControlSelectionListener(dom::Element* aFocusedElm) {
+  // When focus moves such that the caret is part of a new frame selection
+  // this removes the old selection listener and attaches a new one for
+  // the current focus.
+  ClearControlSelectionListener();
+
+  nsIFrame* controlFrame = aFocusedElm->GetPrimaryFrame();
+  if (!controlFrame) return;
+
+  const nsFrameSelection* frameSel = controlFrame->GetConstFrameSelection();
+  NS_ASSERTION(frameSel, "No frame selection for focused element!");
+  if (!frameSel) return;
+
+  // Register 'this' as selection listener for the normal selection.
+  Selection* normalSel = frameSel->GetSelection(SelectionType::eNormal);
+  normalSel->AddSelectionListener(this);
+  mCurrCtrlNormalSel = normalSel;
+
+  // Register 'this' as selection listener for the spell check selection.
+  Selection* spellSel = frameSel->GetSelection(SelectionType::eSpellCheck);
+  spellSel->AddSelectionListener(this);
+  mCurrCtrlSpellSel = spellSel;
+}
+
+void SelectionManager::AddDocSelectionListener(PresShell* aPresShell) {
+  const nsFrameSelection* frameSel = aPresShell->ConstFrameSelection();
+
+  // Register 'this' as selection listener for the normal selection.
+  Selection* normalSel = frameSel->GetSelection(SelectionType::eNormal);
+  normalSel->AddSelectionListener(this);
+
+  // Register 'this' as selection listener for the spell check selection.
+  Selection* spellSel = frameSel->GetSelection(SelectionType::eSpellCheck);
+  spellSel->AddSelectionListener(this);
+}
+
+void SelectionManager::RemoveDocSelectionListener(PresShell* aPresShell) {
+  const nsFrameSelection* frameSel = aPresShell->ConstFrameSelection();
+
+  // Remove 'this' registered as selection listener for the normal selection.
+  Selection* normalSel = frameSel->GetSelection(SelectionType::eNormal);
+  normalSel->RemoveSelectionListener(this);
+
+  // Remove 'this' registered as selection listener for the spellcheck
+  // selection.
+  Selection* spellSel = frameSel->GetSelection(SelectionType::eSpellCheck);
+  spellSel->RemoveSelectionListener(this);
+
+  if (mCurrCtrlNormalSel) {
+    if (mCurrCtrlNormalSel->GetPresShell() == aPresShell) {
+      // Remove 'this' registered as selection listener for the normal selection
+      // if we are removing listeners for its PresShell.
+      mCurrCtrlNormalSel->RemoveSelectionListener(this);
+      mCurrCtrlNormalSel = nullptr;
+    }
+  }
+
+  if (mCurrCtrlSpellSel) {
+    if (mCurrCtrlSpellSel->GetPresShell() == aPresShell) {
+      // Remove 'this' registered as selection listener for the spellcheck
+      // selection if we are removing listeners for its PresShell.
+      mCurrCtrlSpellSel->RemoveSelectionListener(this);
+      mCurrCtrlSpellSel = nullptr;
+    }
+  }
+}
+
+void SelectionManager::ProcessTextSelChangeEvent(AccEvent* aEvent) {
+  // Fire selection change event if it's not pure caret-move selection change,
+  // i.e. the accessible has or had not collapsed selection. Also, it must not
+  // be a collapsed selection on the container of a focused text field, since
+  // the text field has an independent selection and will thus fire its own
+  // selection events.
+  AccTextSelChangeEvent* event = downcast_accEvent(aEvent);
+  if (!event->IsCaretMoveOnly() &&
+      !(event->mSel->IsCollapsed() && event->mSel != mCurrCtrlNormalSel &&
+        FocusMgr() && FocusMgr()->FocusedLocalAccessible() &&
+        FocusMgr()->FocusedLocalAccessible()->IsTextField())) {
+    nsEventShell::FireEvent(aEvent);
+  }
+
+  // Fire caret move event if there's a caret in the selection.
+  nsINode* caretCntrNode = nsCoreUtils::GetDOMNodeFromDOMPoint(
+      event->mSel->GetFocusNode(), event->mSel->FocusOffset());
+  if (!caretCntrNode) return;
+
+  HyperTextAccessible* caretCntr = nsAccUtils::GetTextContainer(caretCntrNode);
+  NS_ASSERTION(
+      caretCntr,
+      "No text container for focus while there's one for common ancestor?!");
+  if (!caretCntr) return;
+
+  Selection* selection = caretCntr->DOMSelection();
+
+  // XXX Sometimes we can't get a selection for caretCntr, in that case assume
+  // event->mSel is correct.
+  if (!selection) selection = event->mSel;
+
+  mCaretOffset = caretCntr->DOMPointToOffset(selection->GetFocusNode(),
+                                             selection->FocusOffset());
+  mAccWithCaret = caretCntr;
+  if (mCaretOffset != -1) {
+    RefPtr<AccCaretMoveEvent> caretMoveEvent =
+        new AccCaretMoveEvent(caretCntr, mCaretOffset, selection->IsCollapsed(),
+                              caretCntr->IsCaretAtEndOfLine(),
+                              event->GetGranularity(), aEvent->FromUserInput());
+    nsEventShell::FireEvent(caretMoveEvent);
+  }
+}
+
+NS_IMETHODIMP
+SelectionManager::NotifySelectionChanged(dom::Document* aDocument,
+                                         Selection* aSelection, int16_t aReason,
+                                         int32_t aAmount) {
+  if (NS_WARN_IF(!aDocument) || NS_WARN_IF(!aSelection)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  DocAccessible* document = GetAccService()->GetDocAccessible(aDocument);
+
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eSelection)) {
+    logging::SelChange(aSelection, document, aReason);
+  }
+#endif
+
+  if (document) {
+    // Selection manager has longer lifetime than any document accessible,
+    // so that we are guaranteed that the notification is processed before
+    // the selection manager is destroyed.
+    RefPtr<SelData> selData = new SelData(aSelection, aReason, aAmount);
+    document->HandleNotification<SelectionManager, SelData>(
+        this, &SelectionManager::ProcessSelectionChanged, selData);
+  }
+
+  return NS_OK;
+}
+
+void SelectionManager::ProcessSelectionChanged(SelData* aSelData) {
+  Selection* selection = aSelData->mSel;
+  if (!selection->GetPresShell()) return;
+
+  const nsRange* range = selection->GetAnchorFocusRange();
+  nsINode* cntrNode = nullptr;
+  if (range) {
+    cntrNode = range->GetClosestCommonInclusiveAncestor();
+  }
+
+  if (!cntrNode) {
+    cntrNode = selection->GetFrameSelection()->GetAncestorLimiter();
+    if (!cntrNode) {
+      cntrNode = selection->GetPresShell()->GetDocument();
+      NS_ASSERTION(aSelData->mSel->GetPresShell()->ConstFrameSelection() ==
+                       selection->GetFrameSelection(),
+                   "Wrong selection container was used!");
+    }
+  }
+
+  HyperTextAccessible* text = nsAccUtils::GetTextContainer(cntrNode);
+  if (!text) {
+    // FIXME bug 1126649
+    NS_ERROR("We must reach document accessible implementing text interface!");
+    return;
+  }
+
+  if (selection->GetType() == SelectionType::eNormal) {
+    RefPtr<AccEvent> event = new AccTextSelChangeEvent(
+        text, selection, aSelData->mReason, aSelData->mGranularity);
+    text->Document()->FireDelayedEvent(event);
+
+  } else if (selection->GetType() == SelectionType::eSpellCheck) {
+    // XXX: fire an event for container accessible of the focus/anchor range
+    // of the spelcheck selection.
+    text->Document()->FireDelayedEvent(
+        nsIAccessibleEvent::EVENT_TEXT_ATTRIBUTE_CHANGED, text);
+  }
+}
+
+void SelectionManager::SpellCheckRangeChanged(const nsRange& aRange) {
+  // Events are fired in SelectionManager::NotifySelectionChanged. This is only
+  // used to push cache updates.
+  if (IPCAccessibilityActive()) {
+    dom::Document* doc = aRange.GetStartContainer()->OwnerDoc();
+    MOZ_ASSERT(doc);
+    TextLeafPoint::UpdateCachedSpellingError(doc, aRange);
+  }
+}
+
+SelectionManager::~SelectionManager() = default;
diff --git a/accessible/base/SelectionManager.h b/accessible/base/SelectionManager.h
new file mode 100644
index 0000000000..1dba086036
--- /dev/null
+++ b/accessible/base/SelectionManager.h
@@ -0,0 +1,141 @@
+/* -*- 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_SelectionManager_h__
+#define mozilla_a11y_SelectionManager_h__
+
+#include "nsISelectionListener.h"
+#include "mozilla/WeakPtr.h"
+
+class nsRange;
+
+namespace mozilla {
+
+class PresShell;
+
+namespace dom {
+class Element;
+class Selection;
+}  // namespace dom
+
+namespace a11y {
+
+class AccEvent;
+class HyperTextAccessible;
+
+/**
+ * This special accessibility class is for the caret and selection management.
+ * There is only 1 visible caret per top level window. However, there may be
+ * several visible selections.
+ *
+ * The important selections are the one owned by each document, and the one in
+ * the currently focused control.
+ *
+ * On Windows this class is used to move an invisible system caret that
+ * shadows the Mozilla caret. Windows will also automatically map this to
+ * the MSAA caret accessible object (via OBJID_CARET) (as opposed to the root
+ * accessible tree for a window which is retrieved with OBJID_CLIENT).
+ *
+ * For ATK and IAccessible2, this class is used to fire caret move and
+ * selection change events.
+ */
+
+struct SelData;
+
+class SelectionManager : public nsISelectionListener {
+ public:
+  // nsISupports
+  // implemented by derived nsAccessibilityService
+
+  // nsISelectionListener
+  NS_DECL_NSISELECTIONLISTENER
+
+  // SelectionManager
+  void Shutdown() { ClearControlSelectionListener(); }
+
+  /**
+   * Listen to selection events on the focused control.
+   *
+   * Note: only one control's selection events are listened to at a time. This
+   * will remove the previous control's selection listener.
+   */
+  void SetControlSelectionListener(dom::Element* aFocusedElm);
+
+  /**
+   * Stop listening to selection events on the control.
+   */
+  void ClearControlSelectionListener();
+
+  /**
+   * Listen to selection events on the document.
+   */
+  void AddDocSelectionListener(PresShell* aPresShell);
+
+  /**
+   * Stop listening to selection events for a given document
+   */
+  void RemoveDocSelectionListener(PresShell* aPresShell);
+
+  /**
+   * Process delayed event, results in caret move and text selection change
+   * events.
+   */
+  void ProcessTextSelChangeEvent(AccEvent* aEvent);
+
+  /**
+   * Gets the current caret offset/hypertext accessible pair. If there is no
+   * current pair, then returns -1 for the offset and a nullptr for the
+   * accessible.
+   */
+  inline HyperTextAccessible* AccessibleWithCaret(int32_t* aCaret) {
+    if (aCaret) *aCaret = mCaretOffset;
+
+    return mAccWithCaret;
+  }
+
+  /**
+   * Update caret offset when it doesn't go through a caret move event.
+   */
+  inline void UpdateCaretOffset(HyperTextAccessible* aItem, int32_t aOffset) {
+    mAccWithCaret = aItem;
+    mCaretOffset = aOffset;
+  }
+
+  inline void ResetCaretOffset() {
+    mCaretOffset = -1;
+    mAccWithCaret = nullptr;
+  }
+
+  /**
+   * Called by mozInlineSpellChecker when a spell check range is added/removed.
+   * nsISelectionListener isn't sufficient for spelling errors, since it only
+   * tells us that there was a change, not which range changed. We don't want
+   * to unnecessarily push a cache update for all Accessibles in the entire
+   * selection.
+   */
+  void SpellCheckRangeChanged(const nsRange& aRange);
+
+  ~SelectionManager();
+
+ protected:
+  SelectionManager();
+
+  /**
+   * Process DOM selection change. Fire selection and caret move events.
+   */
+  void ProcessSelectionChanged(SelData* aSelData);
+
+ private:
+  // Currently focused control.
+  int32_t mCaretOffset;
+  HyperTextAccessible* mAccWithCaret;
+  WeakPtr<dom::Selection> mCurrCtrlNormalSel;
+  WeakPtr<dom::Selection> mCurrCtrlSpellSel;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/States.h b/accessible/base/States.h
new file mode 100644
index 0000000000..5588568d89
--- /dev/null
+++ b/accessible/base/States.h
@@ -0,0 +1,305 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set expandtab shiftwidth=2 tabstop=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 _states_h_
+#define _states_h_
+
+#include <stdint.h>
+
+namespace mozilla {
+namespace a11y {
+namespace states {
+
+/**
+ * The object is disabled, opposite to enabled and sensitive.
+ */
+const uint64_t UNAVAILABLE = ((uint64_t)0x1) << 0;
+
+/**
+ * The object is selected.
+ */
+const uint64_t SELECTED = ((uint64_t)0x1) << 1;
+
+/**
+ * The object has the keyboard focus.
+ */
+const uint64_t FOCUSED = ((uint64_t)0x1) << 2;
+
+/**
+ * The object is pressed.
+ */
+const uint64_t PRESSED = ((uint64_t)0x1) << 3;
+
+/**
+ * The checkable object is checked, applied to check box controls,
+ * @see CHECKABLE and MIXED states.
+ */
+const uint64_t CHECKED = ((uint64_t)0x1) << 4;
+
+/**
+ * Indicates that the state of a three-state check box or tool bar button is
+ * undetermined.  The check box is neither checked or unchecked, and is
+ * in the third or mixed state.
+ */
+const uint64_t MIXED = ((uint64_t)0x1) << 5;
+
+/**
+ * The object is designated read-only, so it can't be edited.
+ */
+const uint64_t READONLY = ((uint64_t)0x1) << 6;
+
+/**
+ * The object is hot-tracked by the mouse, which means that its appearance
+ * has changed to indicate that the mouse pointer is located over it.
+ *
+ * This is currently unused.
+ */
+const uint64_t HOTTRACKED = ((uint64_t)0x1) << 7;
+
+/**
+ * This object is the default button in a window.
+ */
+const uint64_t DEFAULT = ((uint64_t)0x1) << 8;
+
+/**
+ * The expandable object's children are displayed, the opposite of collapsed,
+ * applied to trees, list and other controls.
+ * @see COLLAPSED state
+ */
+const uint64_t EXPANDED = ((uint64_t)0x1) << 9;
+
+/**
+ * The expandable object's children are not displayed, the opposite of
+ * expanded, applied to tree lists and other controls,
+ * @see EXPANDED state.
+ */
+const uint64_t COLLAPSED = ((uint64_t)0x1) << 10;
+
+/**
+ * The control or document can not accept input at this time.
+ */
+const uint64_t BUSY = ((uint64_t)0x1) << 11;
+
+/**
+ * The object is out of normal flow, may be outside of boundaries of its
+ * parent.
+ */
+const uint64_t FLOATING = ((uint64_t)0x1) << 12;
+
+/**
+ * The object can be checked.
+ */
+const uint64_t CHECKABLE = ((uint64_t)0x1) << 13;
+
+/**
+ * This object is a graphic which is rapidly changing appearance.
+ */
+const uint64_t ANIMATED = ((uint64_t)0x1) << 14;
+
+/**
+ * The object is programmatically hidden.
+ * So user action like scrolling or switching tabs won't make this visible.
+ */
+const uint64_t INVISIBLE = ((uint64_t)0x1) << 15;
+
+/**
+ * The object is scrolled off screen.
+ * User action such as scrolling or changing tab may make the object
+ * visible.
+ */
+const uint64_t OFFSCREEN = ((uint64_t)0x1) << 16;
+
+/**
+ * The object can be resized.
+ */
+const uint64_t SIZEABLE = ((uint64_t)0x1) << 17;
+
+/**
+ * The object can be moved to a different position.
+ */
+const uint64_t MOVEABLE = ((uint64_t)0x1) << 18;
+
+/**
+ * The object describes itself with speech.
+ * Other speech related assistive technology may want to avoid speaking
+ * information about this object, because the object is already doing this.
+ */
+const uint64_t SELFVOICING = ((uint64_t)0x1) << 19;
+
+/**
+ * The object can have the focus and become focused.
+ */
+const uint64_t FOCUSABLE = ((uint64_t)0x1) << 20;
+
+/**
+ * The object can be selected.
+ */
+const uint64_t SELECTABLE = ((uint64_t)0x1) << 21;
+
+/**
+ * This object is a link.
+ */
+const uint64_t LINKED = ((uint64_t)0x1) << 22;
+
+/**
+ * This is used for links that have been traversed
+ * i.e. the linked page has been visited.
+ */
+const uint64_t TRAVERSED = ((uint64_t)0x1) << 23;
+
+/**
+ * Supports multiple selection.
+ */
+const uint64_t MULTISELECTABLE = ((uint64_t)0x1) << 24;
+
+/**
+ * Supports extended selection.
+ * All objects supporting this are also multipselectable.
+ * This only makes sense for msaa see bug 635690.
+ */
+const uint64_t EXTSELECTABLE = ((uint64_t)0x1) << 25;
+
+/**
+ * The user is required to interact with this object.
+ */
+const uint64_t REQUIRED = ((uint64_t)0x1) << 26;
+
+/**
+ * The object is an alert, notifying the user of something important.
+ */
+const uint64_t ALERT = ((uint64_t)0x1) << 27;
+
+/**
+ * Used for text fields containing invalid values.
+ */
+const uint64_t INVALID = ((uint64_t)0x1) << 28;
+
+/**
+ * The controls value can not be obtained, and is returned as a set of "*"s.
+ */
+const uint64_t PROTECTED = ((uint64_t)0x1) << 29;
+
+/**
+ * The object can be invoked to show a pop up menu or window.
+ */
+const uint64_t HASPOPUP = ((uint64_t)0x1) << 30;
+
+/**
+ * The editable area has some kind of autocompletion.
+ */
+const uint64_t SUPPORTS_AUTOCOMPLETION = ((uint64_t)0x1) << 31;
+
+/**
+ * The object is no longer available to be queried.
+ */
+const uint64_t DEFUNCT = ((uint64_t)0x1) << 32;
+
+/**
+ * The text is selectable, the object must implement the text interface.
+ */
+const uint64_t SELECTABLE_TEXT = ((uint64_t)0x1) << 33;
+
+/**
+ * The text in this object can be edited.
+ */
+const uint64_t EDITABLE = ((uint64_t)0x1) << 34;
+
+/**
+ * This window is currently the active window.
+ */
+const uint64_t ACTIVE = ((uint64_t)0x1) << 35;
+
+/**
+ * Indicates that the object is modal. Modal objects have the behavior
+ * that something must be done with the object before the user can
+ * interact with an object in a different window.
+ */
+const uint64_t MODAL = ((uint64_t)0x1) << 36;
+
+/**
+ * Edit control that can take multiple lines.
+ */
+const uint64_t MULTI_LINE = ((uint64_t)0x1) << 37;
+
+/**
+ * Uses horizontal layout.
+ */
+const uint64_t HORIZONTAL = ((uint64_t)0x1) << 38;
+
+/**
+ * Indicates this object paints every pixel within its rectangular region.
+ */
+const uint64_t OPAQUE1 = ((uint64_t)0x1) << 39;
+
+/**
+ * This text object can only contain 1 line of text.
+ */
+const uint64_t SINGLE_LINE = ((uint64_t)0x1) << 40;
+
+/**
+ * The parent object manages descendants, and this object may only exist
+ * while it is visible or has focus.
+ * For example the focused cell of a table or the current element of a list box
+ * may have this state.
+ */
+const uint64_t TRANSIENT = ((uint64_t)0x1) << 41;
+
+/**
+ * Uses vertical layout.
+ * Especially used for sliders and scrollbars.
+ */
+const uint64_t VERTICAL = ((uint64_t)0x1) << 42;
+
+/**
+ * Object not dead, but not up-to-date either.
+ */
+const uint64_t STALE = ((uint64_t)0x1) << 43;
+
+/**
+ * A widget that is not unavailable.
+ */
+const uint64_t ENABLED = ((uint64_t)0x1) << 44;
+
+/**
+ * Same as ENABLED state for now see bug 636158
+ */
+const uint64_t SENSITIVE = ((uint64_t)0x1) << 45;
+
+/**
+ * The object is expandable, provides a UI to expand/collapse its children
+ * @see EXPANDED and COLLAPSED states.
+ */
+const uint64_t EXPANDABLE = ((uint64_t)0x1) << 46;
+
+/**
+ * The object is pinned, usually indicating it is fixed in place and has
+ * permanence.
+ */
+const uint64_t PINNED = ((uint64_t)0x1) << 47;
+
+/**
+ * The object is the current item within a container or set of related elements.
+ */
+const uint64_t CURRENT = ((uint64_t)0x1) << 48;
+
+/**
+ * Not a real state, used for static assertions.
+ */
+const uint64_t LAST_ENTRY = CURRENT;
+
+}  // namespace states
+
+/**
+ * States that must be calculated by RemoteAccessible and are thus not cached.
+ */
+const uint64_t kRemoteCalculatedStates =
+    states::FOCUSED | states::INVISIBLE | states::OFFSCREEN | states::ENABLED |
+    states::SENSITIVE | states::COLLAPSED | states::OPAQUE1;
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/Statistics.h b/accessible/base/Statistics.h
new file mode 100644
index 0000000000..19f7166317
--- /dev/null
+++ b/accessible/base/Statistics.h
@@ -0,0 +1,42 @@
+/* -*- 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 A11Y_STATISTICS_H_
+#define A11Y_STATISTICS_H_
+
+#include "mozilla/Telemetry.h"
+
+namespace mozilla {
+namespace a11y {
+namespace statistics {
+
+inline void A11yInitialized() {
+  Telemetry::Accumulate(Telemetry::A11Y_INSTANTIATED_FLAG, true);
+}
+
+inline void A11yConsumers(uint32_t aConsumer) {
+  Telemetry::Accumulate(Telemetry::A11Y_CONSUMERS, aConsumer);
+}
+
+/**
+ * Report that ISimpleDOM* has been used.
+ */
+inline void ISimpleDOMUsed() {
+  Telemetry::Accumulate(Telemetry::A11Y_ISIMPLEDOM_USAGE_FLAG, true);
+}
+
+/**
+ * Report that IAccessibleTable has been used.
+ */
+inline void IAccessibleTableUsed() {
+  Telemetry::Accumulate(Telemetry::A11Y_IATABLE_USAGE_FLAG, true);
+}
+
+}  // namespace statistics
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/StyleInfo.cpp b/accessible/base/StyleInfo.cpp
new file mode 100644
index 0000000000..2673e9684d
--- /dev/null
+++ b/accessible/base/StyleInfo.cpp
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set expandtab shiftwidth=2 tabstop=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 "StyleInfo.h"
+
+#include "nsStyleConsts.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+void StyleInfo::FormatColor(const nscolor& aValue, nsAString& aFormattedValue) {
+  // Combine the string like rgb(R, G, B) from nscolor.
+  // FIXME: What about the alpha channel?
+  aFormattedValue.AppendLiteral("rgb(");
+  aFormattedValue.AppendInt(NS_GET_R(aValue));
+  aFormattedValue.AppendLiteral(", ");
+  aFormattedValue.AppendInt(NS_GET_G(aValue));
+  aFormattedValue.AppendLiteral(", ");
+  aFormattedValue.AppendInt(NS_GET_B(aValue));
+  aFormattedValue.Append(')');
+}
+
+already_AddRefed<nsAtom> StyleInfo::TextDecorationStyleToAtom(
+    StyleTextDecorationStyle aValue) {
+  // TODO: When these are enum classes that rust also understands we should just
+  // make an FFI call here.
+  // TODO: These should probably be static atoms.
+  switch (aValue) {
+    case StyleTextDecorationStyle::None:
+      return NS_Atomize("-moz-none");
+    case StyleTextDecorationStyle::Solid:
+      return NS_Atomize("solid");
+    case StyleTextDecorationStyle::Double:
+      return NS_Atomize("double");
+    case StyleTextDecorationStyle::Dotted:
+      return NS_Atomize("dotted");
+    case StyleTextDecorationStyle::Dashed:
+      return NS_Atomize("dashed");
+    case StyleTextDecorationStyle::Wavy:
+      return NS_Atomize("wavy");
+    default:
+      MOZ_ASSERT_UNREACHABLE("Unknown decoration style");
+      break;
+  }
+
+  return nullptr;
+}
diff --git a/accessible/base/StyleInfo.h b/accessible/base/StyleInfo.h
new file mode 100644
index 0000000000..e078a86834
--- /dev/null
+++ b/accessible/base/StyleInfo.h
@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set expandtab shiftwidth=2 tabstop=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_style_h_
+#define _mozilla_a11y_style_h_
+
+#include "mozilla/gfx/Types.h"
+#include "mozilla/AlreadyAddRefed.h"
+#include "nsStringFwd.h"
+#include "nsColor.h"
+
+class nsAtom;
+
+namespace mozilla {
+
+enum class StyleTextDecorationStyle : uint8_t;
+
+namespace dom {
+class Element;
+}  // namespace dom
+namespace a11y {
+
+class StyleInfo {
+ public:
+  static void FormatColor(const nscolor& aValue, nsAString& aFormattedValue);
+  static already_AddRefed<nsAtom> TextDecorationStyleToAtom(
+      StyleTextDecorationStyle aValue);
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/TextAttrs.cpp b/accessible/base/TextAttrs.cpp
new file mode 100644
index 0000000000..e1ca62e549
--- /dev/null
+++ b/accessible/base/TextAttrs.cpp
@@ -0,0 +1,816 @@
+/* -*- 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 "TextAttrs.h"
+
+#include "AccAttributes.h"
+#include "nsAccUtils.h"
+#include "nsCoreUtils.h"
+#include "StyleInfo.h"
+
+#include "gfxTextRun.h"
+#include "nsFontMetrics.h"
+#include "nsLayoutUtils.h"
+#include "nsContainerFrame.h"
+#include "HyperTextAccessible.h"
+#include "mozilla/AppUnits.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// TextAttrsMgr
+////////////////////////////////////////////////////////////////////////////////
+
+void TextAttrsMgr::GetAttributes(AccAttributes* aAttributes,
+                                 uint32_t* aStartOffset, uint32_t* aEndOffset) {
+  // 1. Hyper text accessible must be specified always.
+  // 2. Offset accessible must be specified in
+  // the case of text attributes. Result hyper text offsets are optional if you
+  // just want the attributes for a single text Accessible.
+  // 3. Offset accessible and result hyper text offsets must not be specified
+  // but include default text attributes flag and attributes list must be
+  // specified in the case of default text attributes.
+  MOZ_ASSERT(
+      mHyperTextAcc && ((mOffsetAcc && mOffsetAccIdx != -1) ||
+                        (!mOffsetAcc && mOffsetAccIdx == -1 && !aStartOffset &&
+                         !aEndOffset && mIncludeDefAttrs && aAttributes)),
+      "Wrong usage of TextAttrsMgr!");
+
+  // Embedded objects are combined into own range with empty attributes set.
+  if (mOffsetAcc && !mOffsetAcc->IsText()) {
+    if (!aStartOffset) {
+      return;
+    }
+    for (int32_t childIdx = mOffsetAccIdx - 1; childIdx >= 0; childIdx--) {
+      LocalAccessible* currAcc = mHyperTextAcc->LocalChildAt(childIdx);
+      if (currAcc->IsText()) break;
+
+      (*aStartOffset)--;
+    }
+
+    uint32_t childCount = mHyperTextAcc->ChildCount();
+    for (uint32_t childIdx = mOffsetAccIdx + 1; childIdx < childCount;
+         childIdx++) {
+      LocalAccessible* currAcc = mHyperTextAcc->LocalChildAt(childIdx);
+      if (currAcc->IsText()) break;
+
+      (*aEndOffset)++;
+    }
+
+    return;
+  }
+
+  // Get the content and frame of the accessible. In the case of document
+  // accessible it's role content and root frame.
+  nsIContent* hyperTextElm = mHyperTextAcc->GetContent();
+  if (!hyperTextElm) {
+    return;  // XXX: we don't support text attrs on document with no body
+  }
+
+  nsIFrame* rootFrame = mHyperTextAcc->GetFrame();
+  if (!rootFrame) {
+    return;
+  }
+
+  nsIContent *offsetNode = nullptr, *offsetElm = nullptr;
+  nsIFrame* frame = nullptr;
+  if (mOffsetAcc) {
+    offsetNode = mOffsetAcc->GetContent();
+    offsetElm = nsCoreUtils::GetDOMElementFor(offsetNode);
+    MOZ_ASSERT(offsetElm, "No element for offset accessible!");
+    if (!offsetElm) return;
+
+    frame = offsetElm->GetPrimaryFrame();
+  }
+
+  // "language" text attribute
+  LangTextAttr langTextAttr(mHyperTextAcc, hyperTextElm, offsetNode);
+
+  // "aria-invalid" text attribute
+  InvalidTextAttr invalidTextAttr(hyperTextElm, offsetNode);
+
+  // "background-color" text attribute
+  BGColorTextAttr bgColorTextAttr(rootFrame, frame);
+
+  // "color" text attribute
+  ColorTextAttr colorTextAttr(rootFrame, frame);
+
+  // "font-family" text attribute
+  FontFamilyTextAttr fontFamilyTextAttr(rootFrame, frame);
+
+  // "font-size" text attribute
+  FontSizeTextAttr fontSizeTextAttr(rootFrame, frame);
+
+  // "font-style" text attribute
+  FontStyleTextAttr fontStyleTextAttr(rootFrame, frame);
+
+  // "font-weight" text attribute
+  FontWeightTextAttr fontWeightTextAttr(rootFrame, frame);
+
+  // "auto-generated" text attribute
+  AutoGeneratedTextAttr autoGenTextAttr(mHyperTextAcc, mOffsetAcc);
+
+  // "text-underline(line-through)-style(color)" text attributes
+  TextDecorTextAttr textDecorTextAttr(rootFrame, frame);
+
+  // "text-position" text attribute
+  TextPosTextAttr textPosTextAttr(rootFrame, frame, hyperTextElm, offsetNode);
+
+  TextAttr* attrArray[] = {
+      &langTextAttr,      &invalidTextAttr,    &bgColorTextAttr,
+      &colorTextAttr,     &fontFamilyTextAttr, &fontSizeTextAttr,
+      &fontStyleTextAttr, &fontWeightTextAttr, &autoGenTextAttr,
+      &textDecorTextAttr, &textPosTextAttr};
+
+  // Expose text attributes if applicable.
+  if (aAttributes) {
+    for (uint32_t idx = 0; idx < ArrayLength(attrArray); idx++) {
+      attrArray[idx]->Expose(aAttributes, mIncludeDefAttrs);
+    }
+  }
+
+  // Expose text attributes range where they are applied if applicable.
+  if (aStartOffset) {
+    GetRange(attrArray, ArrayLength(attrArray), aStartOffset, aEndOffset);
+  }
+}
+
+void TextAttrsMgr::GetRange(TextAttr* aAttrArray[], uint32_t aAttrArrayLen,
+                            uint32_t* aStartOffset, uint32_t* aEndOffset) {
+  // Navigate backward from anchor accessible to find start offset.
+  for (int32_t childIdx = mOffsetAccIdx - 1; childIdx >= 0; childIdx--) {
+    LocalAccessible* currAcc = mHyperTextAcc->LocalChildAt(childIdx);
+
+    // Stop on embedded accessible since embedded accessibles are combined into
+    // own range.
+    if (!currAcc->IsText()) break;
+
+    MOZ_ASSERT(nsCoreUtils::GetDOMElementFor(currAcc->GetContent()),
+               "Text accessible has to have an associated DOM element");
+
+    bool offsetFound = false;
+    for (uint32_t attrIdx = 0; attrIdx < aAttrArrayLen; attrIdx++) {
+      TextAttr* textAttr = aAttrArray[attrIdx];
+      if (!textAttr->Equal(currAcc)) {
+        offsetFound = true;
+        break;
+      }
+    }
+
+    if (offsetFound) break;
+
+    *(aStartOffset) -= nsAccUtils::TextLength(currAcc);
+  }
+
+  // Navigate forward from anchor accessible to find end offset.
+  uint32_t childLen = mHyperTextAcc->ChildCount();
+  for (uint32_t childIdx = mOffsetAccIdx + 1; childIdx < childLen; childIdx++) {
+    LocalAccessible* currAcc = mHyperTextAcc->LocalChildAt(childIdx);
+    if (!currAcc->IsText()) break;
+
+    MOZ_ASSERT(nsCoreUtils::GetDOMElementFor(currAcc->GetContent()),
+               "Text accessible has to have an associated DOM element");
+
+    bool offsetFound = false;
+    for (uint32_t attrIdx = 0; attrIdx < aAttrArrayLen; attrIdx++) {
+      TextAttr* textAttr = aAttrArray[attrIdx];
+
+      // Alter the end offset when text attribute changes its value and stop
+      // the search.
+      if (!textAttr->Equal(currAcc)) {
+        offsetFound = true;
+        break;
+      }
+    }
+
+    if (offsetFound) break;
+
+    (*aEndOffset) += nsAccUtils::TextLength(currAcc);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// LangTextAttr
+////////////////////////////////////////////////////////////////////////////////
+
+TextAttrsMgr::LangTextAttr::LangTextAttr(HyperTextAccessible* aRoot,
+                                         nsIContent* aRootElm, nsIContent* aElm)
+    : TTextAttr<nsString>(!aElm), mRootContent(aRootElm) {
+  aRoot->Language(mRootNativeValue);
+  mIsRootDefined = !mRootNativeValue.IsEmpty();
+
+  if (aElm) {
+    nsCoreUtils::GetLanguageFor(aElm, mRootContent, mNativeValue);
+    mIsDefined = !mNativeValue.IsEmpty();
+  }
+}
+
+TextAttrsMgr::LangTextAttr::~LangTextAttr() {}
+
+bool TextAttrsMgr::LangTextAttr::GetValueFor(LocalAccessible* aAccessible,
+                                             nsString* aValue) {
+  nsCoreUtils::GetLanguageFor(aAccessible->GetContent(), mRootContent, *aValue);
+  return !aValue->IsEmpty();
+}
+
+void TextAttrsMgr::LangTextAttr::ExposeValue(AccAttributes* aAttributes,
+                                             const nsString& aValue) {
+  RefPtr<nsAtom> lang = NS_Atomize(aValue);
+  aAttributes->SetAttribute(nsGkAtoms::language, lang);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// InvalidTextAttr
+////////////////////////////////////////////////////////////////////////////////
+
+TextAttrsMgr::InvalidTextAttr::InvalidTextAttr(nsIContent* aRootElm,
+                                               nsIContent* aElm)
+    : TTextAttr<uint32_t>(!aElm), mRootElm(aRootElm) {
+  mIsRootDefined = GetValue(mRootElm, &mRootNativeValue);
+  if (aElm) mIsDefined = GetValue(aElm, &mNativeValue);
+}
+
+bool TextAttrsMgr::InvalidTextAttr::GetValueFor(LocalAccessible* aAccessible,
+                                                uint32_t* aValue) {
+  nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent());
+  return elm ? GetValue(elm, aValue) : false;
+}
+
+void TextAttrsMgr::InvalidTextAttr::ExposeValue(AccAttributes* aAttributes,
+                                                const uint32_t& aValue) {
+  switch (aValue) {
+    case eFalse:
+      aAttributes->SetAttribute(nsGkAtoms::invalid, nsGkAtoms::_false);
+      break;
+
+    case eGrammar:
+      aAttributes->SetAttribute(nsGkAtoms::invalid, nsGkAtoms::grammar);
+      break;
+
+    case eSpelling:
+      aAttributes->SetAttribute(nsGkAtoms::invalid, nsGkAtoms::spelling);
+      break;
+
+    case eTrue:
+      aAttributes->SetAttribute(nsGkAtoms::invalid, nsGkAtoms::_true);
+      break;
+  }
+}
+
+bool TextAttrsMgr::InvalidTextAttr::GetValue(nsIContent* aElm,
+                                             uint32_t* aValue) {
+  nsIContent* elm = aElm;
+  do {
+    if (nsAccUtils::HasDefinedARIAToken(elm, nsGkAtoms::aria_invalid)) {
+      static dom::Element::AttrValuesArray tokens[] = {
+          nsGkAtoms::_false, nsGkAtoms::grammar, nsGkAtoms::spelling, nullptr};
+
+      int32_t idx = nsAccUtils::FindARIAAttrValueIn(
+          elm->AsElement(), nsGkAtoms::aria_invalid, tokens, eCaseMatters);
+      switch (idx) {
+        case 0:
+          *aValue = eFalse;
+          return true;
+        case 1:
+          *aValue = eGrammar;
+          return true;
+        case 2:
+          *aValue = eSpelling;
+          return true;
+        default:
+          *aValue = eTrue;
+          return true;
+      }
+    }
+  } while ((elm = elm->GetParent()) && elm != mRootElm);
+
+  return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// BGColorTextAttr
+////////////////////////////////////////////////////////////////////////////////
+
+TextAttrsMgr::BGColorTextAttr::BGColorTextAttr(nsIFrame* aRootFrame,
+                                               nsIFrame* aFrame)
+    : TTextAttr<nscolor>(!aFrame), mRootFrame(aRootFrame) {
+  mIsRootDefined = GetColor(mRootFrame, &mRootNativeValue);
+  if (aFrame) mIsDefined = GetColor(aFrame, &mNativeValue);
+}
+
+bool TextAttrsMgr::BGColorTextAttr::GetValueFor(LocalAccessible* aAccessible,
+                                                nscolor* aValue) {
+  nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent());
+  if (elm) {
+    nsIFrame* frame = elm->GetPrimaryFrame();
+    if (frame) {
+      return GetColor(frame, aValue);
+    }
+  }
+  return false;
+}
+
+void TextAttrsMgr::BGColorTextAttr::ExposeValue(AccAttributes* aAttributes,
+                                                const nscolor& aValue) {
+  aAttributes->SetAttribute(nsGkAtoms::backgroundColor, Color{aValue});
+}
+
+bool TextAttrsMgr::BGColorTextAttr::GetColor(nsIFrame* aFrame,
+                                             nscolor* aColor) {
+  nscolor backgroundColor = aFrame->StyleBackground()->BackgroundColor(aFrame);
+  if (NS_GET_A(backgroundColor) > 0) {
+    *aColor = backgroundColor;
+    return true;
+  }
+
+  nsContainerFrame* parentFrame = aFrame->GetParent();
+  if (!parentFrame) {
+    *aColor = aFrame->PresContext()->DefaultBackgroundColor();
+    return true;
+  }
+
+  // Each frame of parents chain for the initially passed 'aFrame' has
+  // transparent background color. So background color isn't changed from
+  // 'mRootFrame' to initially passed 'aFrame'.
+  if (parentFrame == mRootFrame) return false;
+
+  return GetColor(parentFrame, aColor);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ColorTextAttr
+////////////////////////////////////////////////////////////////////////////////
+
+TextAttrsMgr::ColorTextAttr::ColorTextAttr(nsIFrame* aRootFrame,
+                                           nsIFrame* aFrame)
+    : TTextAttr<nscolor>(!aFrame) {
+  mRootNativeValue = aRootFrame->StyleText()->mColor.ToColor();
+  mIsRootDefined = true;
+
+  if (aFrame) {
+    mNativeValue = aFrame->StyleText()->mColor.ToColor();
+    mIsDefined = true;
+  }
+}
+
+bool TextAttrsMgr::ColorTextAttr::GetValueFor(LocalAccessible* aAccessible,
+                                              nscolor* aValue) {
+  nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent());
+  if (elm) {
+    if (nsIFrame* frame = elm->GetPrimaryFrame()) {
+      *aValue = frame->StyleText()->mColor.ToColor();
+      return true;
+    }
+  }
+  return false;
+}
+
+void TextAttrsMgr::ColorTextAttr::ExposeValue(AccAttributes* aAttributes,
+                                              const nscolor& aValue) {
+  aAttributes->SetAttribute(nsGkAtoms::color, Color{aValue});
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// FontFamilyTextAttr
+////////////////////////////////////////////////////////////////////////////////
+
+TextAttrsMgr::FontFamilyTextAttr::FontFamilyTextAttr(nsIFrame* aRootFrame,
+                                                     nsIFrame* aFrame)
+    : TTextAttr<nsString>(!aFrame) {
+  mIsRootDefined = GetFontFamily(aRootFrame, mRootNativeValue);
+
+  if (aFrame) mIsDefined = GetFontFamily(aFrame, mNativeValue);
+}
+
+bool TextAttrsMgr::FontFamilyTextAttr::GetValueFor(LocalAccessible* aAccessible,
+                                                   nsString* aValue) {
+  nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent());
+  if (elm) {
+    nsIFrame* frame = elm->GetPrimaryFrame();
+    if (frame) {
+      return GetFontFamily(frame, *aValue);
+    }
+  }
+  return false;
+}
+
+void TextAttrsMgr::FontFamilyTextAttr::ExposeValue(AccAttributes* aAttributes,
+                                                   const nsString& aValue) {
+  RefPtr<nsAtom> family = NS_Atomize(aValue);
+  aAttributes->SetAttribute(nsGkAtoms::font_family, family);
+}
+
+bool TextAttrsMgr::FontFamilyTextAttr::GetFontFamily(nsIFrame* aFrame,
+                                                     nsString& aFamily) {
+  RefPtr<nsFontMetrics> fm =
+      nsLayoutUtils::GetFontMetricsForFrame(aFrame, 1.0f);
+
+  gfxFontGroup* fontGroup = fm->GetThebesFontGroup();
+  RefPtr<gfxFont> font = fontGroup->GetFirstValidFont();
+  gfxFontEntry* fontEntry = font->GetFontEntry();
+  aFamily.Append(NS_ConvertUTF8toUTF16(fontEntry->FamilyName()));
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// FontSizeTextAttr
+////////////////////////////////////////////////////////////////////////////////
+
+TextAttrsMgr::FontSizeTextAttr::FontSizeTextAttr(nsIFrame* aRootFrame,
+                                                 nsIFrame* aFrame)
+    : TTextAttr<nscoord>(!aFrame) {
+  mDC = aRootFrame->PresContext()->DeviceContext();
+
+  mRootNativeValue = aRootFrame->StyleFont()->mSize.ToAppUnits();
+  mIsRootDefined = true;
+
+  if (aFrame) {
+    mNativeValue = aFrame->StyleFont()->mSize.ToAppUnits();
+    mIsDefined = true;
+  }
+}
+
+bool TextAttrsMgr::FontSizeTextAttr::GetValueFor(LocalAccessible* aAccessible,
+                                                 nscoord* aValue) {
+  nsIContent* el = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent());
+  if (el) {
+    nsIFrame* frame = el->GetPrimaryFrame();
+    if (frame) {
+      *aValue = frame->StyleFont()->mSize.ToAppUnits();
+      return true;
+    }
+  }
+  return false;
+}
+
+void TextAttrsMgr::FontSizeTextAttr::ExposeValue(AccAttributes* aAttributes,
+                                                 const nscoord& aValue) {
+  // Convert from nscoord to pt.
+  //
+  // Note: according to IA2, "The conversion doesn't have to be exact.
+  // The intent is to give the user a feel for the size of the text."
+  //
+  // ATK does not specify a unit and will likely follow IA2 here.
+  //
+  // XXX todo: consider sharing this code with layout module? (bug 474621)
+  float px = NSAppUnitsToFloatPixels(aValue, mozilla::AppUnitsPerCSSPixel());
+  // Each pt is 4/3 of a CSS pixel.
+  FontSize fontSize{NS_lround(px * 3 / 4)};
+
+  aAttributes->SetAttribute(nsGkAtoms::font_size, fontSize);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// FontStyleTextAttr
+////////////////////////////////////////////////////////////////////////////////
+
+TextAttrsMgr::FontStyleTextAttr::FontStyleTextAttr(nsIFrame* aRootFrame,
+                                                   nsIFrame* aFrame)
+    : TTextAttr<FontSlantStyle>(!aFrame) {
+  mRootNativeValue = aRootFrame->StyleFont()->mFont.style;
+  mIsRootDefined = true;
+
+  if (aFrame) {
+    mNativeValue = aFrame->StyleFont()->mFont.style;
+    mIsDefined = true;
+  }
+}
+
+bool TextAttrsMgr::FontStyleTextAttr::GetValueFor(LocalAccessible* aAccessible,
+                                                  FontSlantStyle* aValue) {
+  nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent());
+  if (elm) {
+    nsIFrame* frame = elm->GetPrimaryFrame();
+    if (frame) {
+      *aValue = frame->StyleFont()->mFont.style;
+      return true;
+    }
+  }
+  return false;
+}
+
+void TextAttrsMgr::FontStyleTextAttr::ExposeValue(
+    AccAttributes* aAttributes, const FontSlantStyle& aValue) {
+  if (aValue.IsNormal()) {
+    aAttributes->SetAttribute(nsGkAtoms::font_style, nsGkAtoms::normal);
+  } else if (aValue.IsItalic()) {
+    RefPtr<nsAtom> atom = NS_Atomize("italic");
+    aAttributes->SetAttribute(nsGkAtoms::font_style, atom);
+  } else {
+    nsAutoCString s;
+    aValue.ToString(s);
+    nsString wide;
+    CopyUTF8toUTF16(s, wide);
+    aAttributes->SetAttribute(nsGkAtoms::font_style, std::move(wide));
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// FontWeightTextAttr
+////////////////////////////////////////////////////////////////////////////////
+
+TextAttrsMgr::FontWeightTextAttr::FontWeightTextAttr(nsIFrame* aRootFrame,
+                                                     nsIFrame* aFrame)
+    : TTextAttr<FontWeight>(!aFrame) {
+  mRootNativeValue = GetFontWeight(aRootFrame);
+  mIsRootDefined = true;
+
+  if (aFrame) {
+    mNativeValue = GetFontWeight(aFrame);
+    mIsDefined = true;
+  }
+}
+
+bool TextAttrsMgr::FontWeightTextAttr::GetValueFor(LocalAccessible* aAccessible,
+                                                   FontWeight* aValue) {
+  nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent());
+  if (elm) {
+    nsIFrame* frame = elm->GetPrimaryFrame();
+    if (frame) {
+      *aValue = GetFontWeight(frame);
+      return true;
+    }
+  }
+  return false;
+}
+
+void TextAttrsMgr::FontWeightTextAttr::ExposeValue(AccAttributes* aAttributes,
+                                                   const FontWeight& aValue) {
+  int value = aValue.ToIntRounded();
+  aAttributes->SetAttribute(nsGkAtoms::fontWeight, value);
+}
+
+FontWeight TextAttrsMgr::FontWeightTextAttr::GetFontWeight(nsIFrame* aFrame) {
+  // nsFont::width isn't suitable here because it's necessary to expose real
+  // value of font weight (used font might not have some font weight values).
+  RefPtr<nsFontMetrics> fm =
+      nsLayoutUtils::GetFontMetricsForFrame(aFrame, 1.0f);
+
+  gfxFontGroup* fontGroup = fm->GetThebesFontGroup();
+  RefPtr<gfxFont> font = fontGroup->GetFirstValidFont();
+
+  // When there doesn't exist a bold font in the family and so the rendering of
+  // a non-bold font face is changed so that the user sees what looks like a
+  // bold font, i.e. synthetic bolding is used. (Simply returns false on any
+  // platforms that don't use the multi-strike synthetic bolding.)
+  if (font->ApplySyntheticBold()) {
+    return FontWeight::BOLD;
+  }
+
+  // On Windows, font->GetStyle()->weight will give the same weight as
+  // fontEntry->Weight(), the weight of the first font in the font group,
+  // which may not be the weight of the font face used to render the
+  // characters. On Mac, font->GetStyle()->weight will just give the same
+  // number as getComputedStyle(). fontEntry->Weight() will give the weight
+  // range supported by the font face used, so we clamp the weight that was
+  // requested by style to what is actually supported by the font.
+  gfxFontEntry* fontEntry = font->GetFontEntry();
+  return fontEntry->Weight().Clamp(font->GetStyle()->weight);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// AutoGeneratedTextAttr
+////////////////////////////////////////////////////////////////////////////////
+TextAttrsMgr::AutoGeneratedTextAttr::AutoGeneratedTextAttr(
+    HyperTextAccessible* aHyperTextAcc, LocalAccessible* aAccessible)
+    : TTextAttr<bool>(!aAccessible) {
+  mRootNativeValue = false;
+  mIsRootDefined = false;
+
+  if (aAccessible) {
+    mIsDefined = mNativeValue =
+        ((aAccessible->NativeRole() == roles::STATICTEXT) ||
+         (aAccessible->NativeRole() == roles::LISTITEM_MARKER));
+  }
+}
+
+bool TextAttrsMgr::AutoGeneratedTextAttr::GetValueFor(
+    LocalAccessible* aAccessible, bool* aValue) {
+  return *aValue = (aAccessible->NativeRole() == roles::STATICTEXT);
+}
+
+void TextAttrsMgr::AutoGeneratedTextAttr::ExposeValue(
+    AccAttributes* aAttributes, const bool& aValue) {
+  aAttributes->SetAttribute(nsGkAtoms::auto_generated, aValue);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TextDecorTextAttr
+////////////////////////////////////////////////////////////////////////////////
+
+TextAttrsMgr::TextDecorValue::TextDecorValue(nsIFrame* aFrame) {
+  const nsStyleTextReset* textReset = aFrame->StyleTextReset();
+  mStyle = textReset->mTextDecorationStyle;
+  mColor = textReset->mTextDecorationColor.CalcColor(aFrame);
+  mLine =
+      textReset->mTextDecorationLine & (StyleTextDecorationLine::UNDERLINE |
+                                        StyleTextDecorationLine::LINE_THROUGH);
+}
+
+TextAttrsMgr::TextDecorTextAttr::TextDecorTextAttr(nsIFrame* aRootFrame,
+                                                   nsIFrame* aFrame)
+    : TTextAttr<TextDecorValue>(!aFrame) {
+  mRootNativeValue = TextDecorValue(aRootFrame);
+  mIsRootDefined = mRootNativeValue.IsDefined();
+
+  if (aFrame) {
+    mNativeValue = TextDecorValue(aFrame);
+    mIsDefined = mNativeValue.IsDefined();
+  }
+}
+
+bool TextAttrsMgr::TextDecorTextAttr::GetValueFor(LocalAccessible* aAccessible,
+                                                  TextDecorValue* aValue) {
+  nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent());
+  if (elm) {
+    nsIFrame* frame = elm->GetPrimaryFrame();
+    if (frame) {
+      *aValue = TextDecorValue(frame);
+      return aValue->IsDefined();
+    }
+  }
+  return false;
+}
+
+void TextAttrsMgr::TextDecorTextAttr::ExposeValue(
+    AccAttributes* aAttributes, const TextDecorValue& aValue) {
+  if (aValue.IsUnderline()) {
+    RefPtr<nsAtom> underlineStyle =
+        StyleInfo::TextDecorationStyleToAtom(aValue.Style());
+    aAttributes->SetAttribute(nsGkAtoms::textUnderlineStyle, underlineStyle);
+
+    aAttributes->SetAttribute(nsGkAtoms::textUnderlineColor,
+                              Color{aValue.Color()});
+    return;
+  }
+
+  if (aValue.IsLineThrough()) {
+    RefPtr<nsAtom> lineThroughStyle =
+        StyleInfo::TextDecorationStyleToAtom(aValue.Style());
+    aAttributes->SetAttribute(nsGkAtoms::textLineThroughStyle,
+                              lineThroughStyle);
+
+    aAttributes->SetAttribute(nsGkAtoms::textLineThroughColor,
+                              Color{aValue.Color()});
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TextPosTextAttr
+////////////////////////////////////////////////////////////////////////////////
+
+TextAttrsMgr::TextPosTextAttr::TextPosTextAttr(nsIFrame* aRootFrame,
+                                               nsIFrame* aFrame,
+                                               nsIContent* aRootElm,
+                                               nsIContent* aElm)
+    : TTextAttr<Maybe<TextPosValue>>(!aFrame && !aElm), mRootElm(aRootElm) {
+  // Get the text-position values for the roots and children.
+  // If we find an ARIA text-position value on a DOM element - searching up
+  // from the supplied root DOM element - use the associated frame as the root
+  // frame. This ensures that we're using the proper root frame for comparison.
+  nsIFrame* ariaFrame = nullptr;
+  Maybe<TextPosValue> rootAria = GetAriaTextPosValue(aRootElm, ariaFrame);
+  if (rootAria && ariaFrame) {
+    aRootFrame = ariaFrame;
+  }
+  Maybe<TextPosValue> rootLayout = GetLayoutTextPosValue(aRootFrame);
+  Maybe<TextPosValue> childLayout;
+  Maybe<TextPosValue> childAria;
+  if (aFrame) {
+    childLayout = GetLayoutTextPosValue(aFrame);
+  }
+  if (aElm) {
+    childAria = GetAriaTextPosValue(aElm);
+  }
+
+  // Aria values take precedence over layout values.
+  mIsRootDefined = rootAria || rootLayout;
+  mRootNativeValue = rootAria ? rootAria : rootLayout;
+  mIsDefined = childAria || childLayout;
+  mNativeValue = childAria ? childAria : childLayout;
+
+  // If there's no child text-position information from ARIA, and the child
+  // layout info is equivalent to the root layout info (i.e., it's inherited),
+  // then we should prefer the root information.
+  if (!childAria && childLayout == rootLayout) {
+    mIsDefined = false;
+  }
+}
+
+bool TextAttrsMgr::TextPosTextAttr::GetValueFor(LocalAccessible* aAccessible,
+                                                Maybe<TextPosValue>* aValue) {
+  nsIContent* elm = nsCoreUtils::GetDOMElementFor(aAccessible->GetContent());
+  if (elm) {
+    nsIFrame* frame = elm->GetPrimaryFrame();
+    if (frame) {
+      Maybe<TextPosValue> layoutValue = GetLayoutTextPosValue(frame);
+      Maybe<TextPosValue> ariaValue = GetAriaTextPosValue(elm);
+
+      *aValue = ariaValue ? ariaValue : layoutValue;
+      return aValue->isSome();
+    }
+  }
+  return false;
+}
+
+void TextAttrsMgr::TextPosTextAttr::ExposeValue(
+    AccAttributes* aAttributes, const Maybe<TextPosValue>& aValue) {
+  if (aValue.isNothing()) {
+    return;
+  }
+
+  RefPtr<nsAtom> atom = nullptr;
+  switch (*aValue) {
+    case eTextPosBaseline:
+      atom = nsGkAtoms::baseline;
+      break;
+
+    case eTextPosSub:
+      atom = nsGkAtoms::sub;
+      break;
+
+    case eTextPosSuper:
+      atom = NS_Atomize("super");
+      break;
+  }
+
+  if (atom) {
+    aAttributes->SetAttribute(nsGkAtoms::textPosition, atom);
+  }
+}
+
+Maybe<TextAttrsMgr::TextPosValue>
+TextAttrsMgr::TextPosTextAttr::GetAriaTextPosValue(nsIContent* aElm) const {
+  nsIFrame* ariaFrame = nullptr;
+  return GetAriaTextPosValue(aElm, ariaFrame);
+}
+
+Maybe<TextAttrsMgr::TextPosValue>
+TextAttrsMgr::TextPosTextAttr::GetAriaTextPosValue(nsIContent* aElm,
+                                                   nsIFrame*& ariaFrame) const {
+  // Search for the superscript and subscript roles that imply text-position.
+  const nsIContent* elm = aElm;
+  do {
+    if (elm->IsElement()) {
+      const mozilla::dom::Element* domElm = elm->AsElement();
+      static const dom::Element::AttrValuesArray tokens[] = {
+          nsGkAtoms::subscript, nsGkAtoms::superscript, nullptr};
+      const int32_t valueIdx = domElm->FindAttrValueIn(
+          kNameSpaceID_None, nsGkAtoms::role, tokens, eCaseMatters);
+      ariaFrame = domElm->GetPrimaryFrame();
+      if (valueIdx == 0) {
+        return Some(eTextPosSub);
+      }
+      if (valueIdx == 1) {
+        return Some(eTextPosSuper);
+      }
+    }
+  } while ((elm = elm->GetParent()) && elm != mRootElm);
+
+  ariaFrame = nullptr;
+  return Nothing{};
+}
+
+Maybe<TextAttrsMgr::TextPosValue>
+TextAttrsMgr::TextPosTextAttr::GetLayoutTextPosValue(nsIFrame* aFrame) const {
+  const auto& verticalAlign = aFrame->StyleDisplay()->mVerticalAlign;
+  if (verticalAlign.IsKeyword()) {
+    switch (verticalAlign.AsKeyword()) {
+      case StyleVerticalAlignKeyword::Baseline:
+        return Some(eTextPosBaseline);
+      case StyleVerticalAlignKeyword::Sub:
+        return Some(eTextPosSub);
+      case StyleVerticalAlignKeyword::Super:
+        return Some(eTextPosSuper);
+      // No good guess for the rest, so do not expose value of text-position
+      // attribute.
+      default:
+        return Nothing{};
+    }
+  }
+
+  const auto& length = verticalAlign.AsLength();
+  if (length.ConvertsToPercentage()) {
+    const float percentValue = length.ToPercentage();
+    return percentValue > 0 ? Some(eTextPosSuper)
+                            : (percentValue < 0 ? Some(eTextPosSub)
+                                                : Some(eTextPosBaseline));
+  }
+
+  if (length.ConvertsToLength()) {
+    const nscoord coordValue = length.ToLength();
+    return coordValue > 0
+               ? Some(eTextPosSuper)
+               : (coordValue < 0 ? Some(eTextPosSub) : Some(eTextPosBaseline));
+  }
+
+  if (const nsIContent* content = aFrame->GetContent()) {
+    if (content->IsHTMLElement(nsGkAtoms::sup)) return Some(eTextPosSuper);
+    if (content->IsHTMLElement(nsGkAtoms::sub)) return Some(eTextPosSub);
+  }
+
+  return Nothing{};
+}
diff --git a/accessible/base/TextAttrs.h b/accessible/base/TextAttrs.h
new file mode 100644
index 0000000000..031e114273
--- /dev/null
+++ b/accessible/base/TextAttrs.h
@@ -0,0 +1,440 @@
+/* -*- 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 nsTextAttrs_h_
+#define nsTextAttrs_h_
+
+#include "mozilla/FontPropertyTypes.h"
+#include "nsCOMPtr.h"
+#include "nsColor.h"
+#include "nsString.h"
+#include "nsStyleConsts.h"
+
+class nsIFrame;
+class nsIContent;
+class nsDeviceContext;
+
+namespace mozilla {
+namespace a11y {
+
+class AccAttributes;
+class LocalAccessible;
+class HyperTextAccessible;
+
+/**
+ * Used to expose text attributes for the hyper text accessible (see
+ * HyperTextAccessible class).
+ *
+ * @note "invalid: spelling" text attribute is implemented entirely in
+ *       HyperTextAccessible class.
+ */
+class TextAttrsMgr {
+ public:
+  /**
+   * Constructor. Used to expose default text attributes.
+   */
+  explicit TextAttrsMgr(HyperTextAccessible* aHyperTextAcc)
+      : mOffsetAcc(nullptr),
+        mHyperTextAcc(aHyperTextAcc),
+        mOffsetAccIdx(-1),
+        mIncludeDefAttrs(true) {}
+
+  /**
+   * Constructor. Used to expose text attributes at the given offset.
+   *
+   * @param aHyperTextAcc    [in] hyper text accessible text attributes are
+   *                          calculated for
+   * @param aIncludeDefAttrs [optional] indicates whether default text
+   *                          attributes should be included into list of exposed
+   *                          text attributes
+   * @param oOffsetAcc       [optional] offset an accessible the text attributes
+   *                          should be calculated for
+   * @param oOffsetAccIdx    [optional] index in parent of offset accessible
+   */
+  TextAttrsMgr(HyperTextAccessible* aHyperTextAcc, bool aIncludeDefAttrs,
+               LocalAccessible* aOffsetAcc, int32_t aOffsetAccIdx)
+      : mOffsetAcc(aOffsetAcc),
+        mHyperTextAcc(aHyperTextAcc),
+        mOffsetAccIdx(aOffsetAccIdx),
+        mIncludeDefAttrs(aIncludeDefAttrs) {}
+
+  /*
+   * Return text attributes and hyper text offsets where these attributes are
+   * applied. Offsets are calculated in the case of non default attributes.
+   *
+   * @note In the case of default attributes pointers on hyper text offsets
+   *       must be skipped.
+   *
+   * @param aAttributes    [in, out] text attributes list
+   * @param aStartHTOffset [out, optional] start hyper text offset
+   * @param aEndHTOffset   [out, optional] end hyper text offset
+   */
+  void GetAttributes(AccAttributes* aAttributes,
+                     uint32_t* aStartHTOffset = nullptr,
+                     uint32_t* aEndHTOffset = nullptr);
+
+ protected:
+  /**
+   * Calculates range (start and end offsets) of text where the text attributes
+   * are stretched. New offsets may be smaller if one of text attributes changes
+   * its value before or after the given offsets.
+   *
+   * @param aTextAttrArray  [in] text attributes array
+   * @param aAttrArrayLen   [in] text attributes array length
+   * @param aStartHTOffset  [in, out] the start offset
+   * @param aEndHTOffset    [in, out] the end offset
+   */
+  class TextAttr;
+  void GetRange(TextAttr* aAttrArray[], uint32_t aAttrArrayLen,
+                uint32_t* aStartOffset, uint32_t* aEndOffset);
+
+ private:
+  LocalAccessible* mOffsetAcc;
+  HyperTextAccessible* mHyperTextAcc;
+  int32_t mOffsetAccIdx;
+  bool mIncludeDefAttrs;
+
+ protected:
+  /**
+   * Interface class of text attribute class implementations.
+   */
+  class TextAttr {
+   public:
+    /**
+     * Expose the text attribute to the given attribute set.
+     *
+     * @param aAttributes           [in] the given attribute set
+     * @param aIncludeDefAttrValue  [in] if true then attribute is exposed even
+     *                               if its value is the same as default one
+     */
+    virtual void Expose(AccAttributes* aAttributes,
+                        bool aIncludeDefAttrValue) = 0;
+
+    /**
+     * Return true if the text attribute value on the given element equals with
+     * predefined attribute value.
+     */
+    virtual bool Equal(LocalAccessible* aAccessible) = 0;
+  };
+
+  /**
+   * Base class to work with text attributes. See derived classes below.
+   */
+  template <class T>
+  class TTextAttr : public TextAttr {
+   public:
+    explicit TTextAttr(bool aGetRootValue) : mGetRootValue(aGetRootValue) {}
+
+    // TextAttr
+    virtual void Expose(AccAttributes* aAttributes,
+                        bool aIncludeDefAttrValue) override {
+      if (mGetRootValue) {
+        if (mIsRootDefined) ExposeValue(aAttributes, mRootNativeValue);
+        return;
+      }
+
+      if (mIsDefined) {
+        if (aIncludeDefAttrValue || mRootNativeValue != mNativeValue) {
+          ExposeValue(aAttributes, mNativeValue);
+        }
+        return;
+      }
+
+      if (aIncludeDefAttrValue && mIsRootDefined) {
+        ExposeValue(aAttributes, mRootNativeValue);
+      }
+    }
+
+    virtual bool Equal(LocalAccessible* aAccessible) override {
+      T nativeValue;
+      bool isDefined = GetValueFor(aAccessible, &nativeValue);
+
+      if (!mIsDefined && !isDefined) return true;
+
+      if (mIsDefined && isDefined) return nativeValue == mNativeValue;
+
+      if (mIsDefined) return mNativeValue == mRootNativeValue;
+
+      return nativeValue == mRootNativeValue;
+    }
+
+   protected:
+    // Expose the text attribute with the given value to attribute set.
+    virtual void ExposeValue(AccAttributes* aAttributes, const T& aValue) = 0;
+
+    // Return native value for the given DOM element.
+    virtual bool GetValueFor(LocalAccessible* aAccessible, T* aValue) = 0;
+
+    // Indicates if root value should be exposed.
+    bool mGetRootValue;
+
+    // Native value and flag indicating if the value is defined (initialized in
+    // derived classes). Note, undefined native value means it is inherited
+    // from root.
+    MOZ_INIT_OUTSIDE_CTOR T mNativeValue;
+    MOZ_INIT_OUTSIDE_CTOR bool mIsDefined;
+
+    // Native root value and flag indicating if the value is defined
+    // (initialized in derived classes).
+    MOZ_INIT_OUTSIDE_CTOR T mRootNativeValue;
+    MOZ_INIT_OUTSIDE_CTOR bool mIsRootDefined;
+  };
+
+  /**
+   * Class is used for the work with 'language' text attribute.
+   */
+  class LangTextAttr : public TTextAttr<nsString> {
+   public:
+    LangTextAttr(HyperTextAccessible* aRoot, nsIContent* aRootElm,
+                 nsIContent* aElm);
+    virtual ~LangTextAttr();
+
+   protected:
+    // TextAttr
+    virtual bool GetValueFor(LocalAccessible* aAccessible,
+                             nsString* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const nsString& aValue) override;
+
+   private:
+    nsCOMPtr<nsIContent> mRootContent;
+  };
+
+  /**
+   * Class is used for the 'invalid' text attribute. Note, it calculated
+   * the attribute from aria-invalid attribute only; invalid:spelling attribute
+   * calculated from misspelled text in the editor is managed by
+   * HyperTextAccessible and applied on top of the value from aria-invalid.
+   */
+  class InvalidTextAttr : public TTextAttr<uint32_t> {
+   public:
+    InvalidTextAttr(nsIContent* aRootElm, nsIContent* aElm);
+    virtual ~InvalidTextAttr(){};
+
+   protected:
+    enum { eFalse, eGrammar, eSpelling, eTrue };
+
+    // TextAttr
+    virtual bool GetValueFor(LocalAccessible* aAccessible,
+                             uint32_t* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const uint32_t& aValue) override;
+
+   private:
+    bool GetValue(nsIContent* aElm, uint32_t* aValue);
+    nsIContent* mRootElm;
+  };
+
+  /**
+   * Class is used for the work with 'background-color' text attribute.
+   */
+  class BGColorTextAttr : public TTextAttr<nscolor> {
+   public:
+    BGColorTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+    virtual ~BGColorTextAttr() {}
+
+   protected:
+    // TextAttr
+    virtual bool GetValueFor(LocalAccessible* aAccessible,
+                             nscolor* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const nscolor& aValue) override;
+
+   private:
+    bool GetColor(nsIFrame* aFrame, nscolor* aColor);
+    nsIFrame* mRootFrame;
+  };
+
+  /**
+   * Class is used for the work with 'color' text attribute.
+   */
+  class ColorTextAttr : public TTextAttr<nscolor> {
+   public:
+    ColorTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+    virtual ~ColorTextAttr() {}
+
+   protected:
+    // TTextAttr
+    virtual bool GetValueFor(LocalAccessible* aAccessible,
+                             nscolor* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const nscolor& aValue) override;
+  };
+
+  /**
+   * Class is used for the work with "font-family" text attribute.
+   */
+  class FontFamilyTextAttr : public TTextAttr<nsString> {
+   public:
+    FontFamilyTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+    virtual ~FontFamilyTextAttr() {}
+
+   protected:
+    // TTextAttr
+    virtual bool GetValueFor(LocalAccessible* aAccessible,
+                             nsString* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const nsString& aValue) override;
+
+   private:
+    bool GetFontFamily(nsIFrame* aFrame, nsString& aFamily);
+  };
+
+  /**
+   * Class is used for the work with "font-size" text attribute.
+   */
+  class FontSizeTextAttr : public TTextAttr<nscoord> {
+   public:
+    FontSizeTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+    virtual ~FontSizeTextAttr() {}
+
+   protected:
+    // TTextAttr
+    virtual bool GetValueFor(LocalAccessible* aAccessible,
+                             nscoord* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const nscoord& aValue) override;
+
+   private:
+    nsDeviceContext* mDC;
+  };
+
+  /**
+   * Class is used for the work with "font-style" text attribute.
+   */
+  class FontStyleTextAttr : public TTextAttr<mozilla::FontSlantStyle> {
+   public:
+    FontStyleTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+    virtual ~FontStyleTextAttr() {}
+
+   protected:
+    // TTextAttr
+    virtual bool GetValueFor(LocalAccessible* aContent,
+                             mozilla::FontSlantStyle* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const mozilla::FontSlantStyle& aValue) override;
+  };
+
+  /**
+   * Class is used for the work with "font-weight" text attribute.
+   */
+  class FontWeightTextAttr : public TTextAttr<mozilla::FontWeight> {
+   public:
+    FontWeightTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+    virtual ~FontWeightTextAttr() {}
+
+   protected:
+    // TTextAttr
+    virtual bool GetValueFor(LocalAccessible* aAccessible,
+                             mozilla::FontWeight* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const mozilla::FontWeight& aValue) override;
+
+   private:
+    mozilla::FontWeight GetFontWeight(nsIFrame* aFrame);
+  };
+
+  /**
+   * Class is used for the work with 'auto-generated' text attribute.
+   */
+  class AutoGeneratedTextAttr : public TTextAttr<bool> {
+   public:
+    AutoGeneratedTextAttr(HyperTextAccessible* aHyperTextAcc,
+                          LocalAccessible* aAccessible);
+    virtual ~AutoGeneratedTextAttr() {}
+
+   protected:
+    // TextAttr
+    virtual bool GetValueFor(LocalAccessible* aAccessible,
+                             bool* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const bool& aValue) override;
+  };
+
+  /**
+   * TextDecorTextAttr class is used for the work with
+   * "text-line-through-style", "text-line-through-color",
+   * "text-underline-style" and "text-underline-color" text attributes.
+   */
+
+  class TextDecorValue {
+   public:
+    TextDecorValue()
+        : mColor{0},
+          mLine{StyleTextDecorationLine::NONE},
+          mStyle{StyleTextDecorationStyle::None} {}
+    explicit TextDecorValue(nsIFrame* aFrame);
+
+    nscolor Color() const { return mColor; }
+    mozilla::StyleTextDecorationStyle Style() const { return mStyle; }
+
+    bool IsDefined() const { return IsUnderline() || IsLineThrough(); }
+    bool IsUnderline() const {
+      return bool(mLine & mozilla::StyleTextDecorationLine::UNDERLINE);
+    }
+    bool IsLineThrough() const {
+      return bool(mLine & mozilla::StyleTextDecorationLine::LINE_THROUGH);
+    }
+
+    bool operator==(const TextDecorValue& aValue) const {
+      return mColor == aValue.mColor && mLine == aValue.mLine &&
+             mStyle == aValue.mStyle;
+    }
+    bool operator!=(const TextDecorValue& aValue) const {
+      return !(*this == aValue);
+    }
+
+   private:
+    nscolor mColor;
+    mozilla::StyleTextDecorationLine mLine;
+    mozilla::StyleTextDecorationStyle mStyle;
+  };
+
+  class TextDecorTextAttr : public TTextAttr<TextDecorValue> {
+   public:
+    TextDecorTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame);
+    virtual ~TextDecorTextAttr() {}
+
+   protected:
+    // TextAttr
+    virtual bool GetValueFor(LocalAccessible* aAccessible,
+                             TextDecorValue* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const TextDecorValue& aValue) override;
+  };
+
+  /**
+   * Class is used for the work with "text-position" text attribute.
+   */
+
+  enum TextPosValue { eTextPosBaseline, eTextPosSub, eTextPosSuper };
+
+  class TextPosTextAttr : public TTextAttr<Maybe<TextPosValue>> {
+   public:
+    TextPosTextAttr(nsIFrame* aRootFrame, nsIFrame* aFrame,
+                    nsIContent* aRootElm, nsIContent* aElm);
+    virtual ~TextPosTextAttr() {}
+
+   protected:
+    // TextAttr
+    virtual bool GetValueFor(LocalAccessible* aAccessible,
+                             Maybe<TextPosValue>* aValue) override;
+    virtual void ExposeValue(AccAttributes* aAttributes,
+                             const Maybe<TextPosValue>& aValue) override;
+
+   private:
+    Maybe<TextPosValue> GetAriaTextPosValue(nsIContent* aElm) const;
+    Maybe<TextPosValue> GetAriaTextPosValue(nsIContent* aElm,
+                                            nsIFrame*& ariaFrame) const;
+    Maybe<TextPosValue> GetLayoutTextPosValue(nsIFrame* aFrame) const;
+    nsIContent* mRootElm;
+  };
+
+};  // TextAttrMgr
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/TextLeafRange.cpp b/accessible/base/TextLeafRange.cpp
new file mode 100644
index 0000000000..9b658e12af
--- /dev/null
+++ b/accessible/base/TextLeafRange.cpp
@@ -0,0 +1,1990 @@
+/* -*- 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 "TextLeafRange.h"
+
+#include "HyperTextAccessible-inl.h"
+#include "mozilla/a11y/Accessible.h"
+#include "mozilla/a11y/CacheConstants.h"
+#include "mozilla/a11y/DocAccessible.h"
+#include "mozilla/a11y/DocAccessibleParent.h"
+#include "mozilla/a11y/LocalAccessible.h"
+#include "mozilla/BinarySearch.h"
+#include "mozilla/Casting.h"
+#include "mozilla/dom/CharacterData.h"
+#include "mozilla/dom/HTMLInputElement.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/intl/Segmenter.h"
+#include "mozilla/intl/WordBreaker.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/TextEditor.h"
+#include "nsAccUtils.h"
+#include "nsBlockFrame.h"
+#include "nsFrameSelection.h"
+#include "nsIAccessiblePivot.h"
+#include "nsILineIterator.h"
+#include "nsINode.h"
+#include "nsRange.h"
+#include "nsStyleStructInlines.h"
+#include "nsTArray.h"
+#include "nsTextFrame.h"
+#include "nsUnicharUtils.h"
+#include "Pivot.h"
+#include "TextAttrs.h"
+
+using mozilla::intl::WordBreaker;
+using FindWordOptions = mozilla::intl::WordBreaker::FindWordOptions;
+
+namespace mozilla::a11y {
+
+/*** Helpers ***/
+
+/**
+ * These two functions convert between rendered and content text offsets.
+ * When text DOM nodes are rendered, the rendered text often does not contain
+ * all the whitespace from the source. For example, by default, the text
+ * "a   b" will be rendered as "a b"; i.e. multiple spaces are compressed to
+ * one. TextLeafAccessibles contain rendered text, but when we query layout, we
+ * need to provide offsets into the original content text. Similarly, layout
+ * returns content offsets, but we need to convert them to rendered offsets to
+ * map them to TextLeafAccessibles.
+ */
+
+static int32_t RenderedToContentOffset(LocalAccessible* aAcc,
+                                       uint32_t aRenderedOffset) {
+  nsTextFrame* frame = do_QueryFrame(aAcc->GetFrame());
+  if (!frame) {
+    MOZ_ASSERT(!aAcc->HasOwnContent() || aAcc->IsHTMLBr(),
+               "No text frame because this is a XUL label[value] text leaf or "
+               "a BR element.");
+    return static_cast<int32_t>(aRenderedOffset);
+  }
+
+  if (frame->StyleText()->WhiteSpaceIsSignificant() &&
+      frame->StyleText()->NewlineIsSignificant(frame)) {
+    // Spaces and new lines aren't altered, so the content and rendered offsets
+    // are the same. This happens in pre-formatted text and text fields.
+    return static_cast<int32_t>(aRenderedOffset);
+  }
+
+  nsIFrame::RenderedText text =
+      frame->GetRenderedText(aRenderedOffset, aRenderedOffset + 1,
+                             nsIFrame::TextOffsetType::OffsetsInRenderedText,
+                             nsIFrame::TrailingWhitespace::DontTrim);
+  return text.mOffsetWithinNodeText;
+}
+
+static uint32_t ContentToRenderedOffset(LocalAccessible* aAcc,
+                                        int32_t aContentOffset) {
+  nsTextFrame* frame = do_QueryFrame(aAcc->GetFrame());
+  if (!frame) {
+    MOZ_ASSERT(!aAcc->HasOwnContent(),
+               "No text frame because this is a XUL label[value] text leaf.");
+    return aContentOffset;
+  }
+
+  if (frame->StyleText()->WhiteSpaceIsSignificant() &&
+      frame->StyleText()->NewlineIsSignificant(frame)) {
+    // Spaces and new lines aren't altered, so the content and rendered offsets
+    // are the same. This happens in pre-formatted text and text fields.
+    return aContentOffset;
+  }
+
+  nsIFrame::RenderedText text =
+      frame->GetRenderedText(aContentOffset, aContentOffset + 1,
+                             nsIFrame::TextOffsetType::OffsetsInContentText,
+                             nsIFrame::TrailingWhitespace::DontTrim);
+  return text.mOffsetWithinNodeRenderedText;
+}
+
+class LeafRule : public PivotRule {
+ public:
+  explicit LeafRule(bool aIgnoreListItemMarker)
+      : mIgnoreListItemMarker(aIgnoreListItemMarker) {}
+
+  virtual uint16_t Match(Accessible* aAcc) override {
+    if (aAcc->IsOuterDoc()) {
+      // Treat an embedded doc as a single character in this document, but do
+      // not descend inside it.
+      return nsIAccessibleTraversalRule::FILTER_MATCH |
+             nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
+    }
+
+    if (mIgnoreListItemMarker && aAcc->Role() == roles::LISTITEM_MARKER) {
+      // Ignore list item markers if configured to do so.
+      return nsIAccessibleTraversalRule::FILTER_IGNORE;
+    }
+
+    // We deliberately include Accessibles such as empty input elements and
+    // empty containers, as these can be at the start of a line.
+    if (!aAcc->HasChildren()) {
+      return nsIAccessibleTraversalRule::FILTER_MATCH;
+    }
+    return nsIAccessibleTraversalRule::FILTER_IGNORE;
+  }
+
+ private:
+  bool mIgnoreListItemMarker;
+};
+
+static HyperTextAccessible* HyperTextFor(LocalAccessible* aAcc) {
+  for (LocalAccessible* acc = aAcc; acc; acc = acc->LocalParent()) {
+    if (HyperTextAccessible* ht = acc->AsHyperText()) {
+      return ht;
+    }
+  }
+  return nullptr;
+}
+
+static Accessible* NextLeaf(Accessible* aOrigin, bool aIsEditable = false,
+                            bool aIgnoreListItemMarker = false) {
+  MOZ_ASSERT(aOrigin);
+  Accessible* doc = nsAccUtils::DocumentFor(aOrigin);
+  Pivot pivot(doc);
+  auto rule = LeafRule(aIgnoreListItemMarker);
+  Accessible* leaf = pivot.Next(aOrigin, rule);
+  if (aIsEditable && leaf) {
+    return leaf->Parent() && (leaf->Parent()->State() & states::EDITABLE)
+               ? leaf
+               : nullptr;
+  }
+  return leaf;
+}
+
+static Accessible* PrevLeaf(Accessible* aOrigin, bool aIsEditable = false,
+                            bool aIgnoreListItemMarker = false) {
+  MOZ_ASSERT(aOrigin);
+  Accessible* doc = nsAccUtils::DocumentFor(aOrigin);
+  Pivot pivot(doc);
+  auto rule = LeafRule(aIgnoreListItemMarker);
+  Accessible* leaf = pivot.Prev(aOrigin, rule);
+  if (aIsEditable && leaf) {
+    return leaf->Parent() && (leaf->Parent()->State() & states::EDITABLE)
+               ? leaf
+               : nullptr;
+  }
+  return leaf;
+}
+
+static nsIFrame* GetFrameInBlock(const LocalAccessible* aAcc) {
+  dom::HTMLInputElement* input =
+      dom::HTMLInputElement::FromNodeOrNull(aAcc->GetContent());
+  if (!input) {
+    if (LocalAccessible* parent = aAcc->LocalParent()) {
+      input = dom::HTMLInputElement::FromNodeOrNull(parent->GetContent());
+    }
+  }
+
+  if (input) {
+    // If this is a single line input (or a leaf of an input) we want to return
+    // the top frame of the input element and not the text leaf's frame because
+    // the leaf may be inside of an embedded block frame in the input's shadow
+    // DOM that we aren't interested in.
+    return input->GetPrimaryFrame();
+  }
+
+  return aAcc->GetFrame();
+}
+
+static bool IsLocalAccAtLineStart(LocalAccessible* aAcc) {
+  if (aAcc->NativeRole() == roles::LISTITEM_MARKER) {
+    // A bullet always starts a line.
+    return true;
+  }
+  // Splitting of content across lines is handled by layout.
+  // nsIFrame::IsLogicallyAtLineEdge queries whether a frame is the first frame
+  // on its line. However, we can't use that because the first frame on a line
+  // might not be included in the a11y tree; e.g. an empty span, or space
+  // in the DOM after a line break which is stripped when rendered. Instead, we
+  // get the line number for this Accessible's frame and the line number for the
+  // previous leaf Accessible's frame and compare them.
+  Accessible* prev = PrevLeaf(aAcc);
+  LocalAccessible* prevLocal = prev ? prev->AsLocal() : nullptr;
+  if (!prevLocal) {
+    // There's nothing before us, so this is the start of the first line.
+    return true;
+  }
+  if (prevLocal->NativeRole() == roles::LISTITEM_MARKER) {
+    // If there is  a bullet immediately before us and we're inside the same
+    // list item, this is not the start of a line.
+    LocalAccessible* listItem = prevLocal->LocalParent();
+    MOZ_ASSERT(listItem);
+    LocalAccessible* doc = listItem->Document();
+    MOZ_ASSERT(doc);
+    for (LocalAccessible* parent = aAcc->LocalParent(); parent && parent != doc;
+         parent = parent->LocalParent()) {
+      if (parent == listItem) {
+        return false;
+      }
+    }
+  }
+
+  nsIFrame* thisFrame = GetFrameInBlock(aAcc);
+  if (!thisFrame) {
+    return false;
+  }
+
+  nsIFrame* prevFrame = GetFrameInBlock(prevLocal);
+  if (!prevFrame) {
+    return false;
+  }
+
+  auto [thisBlock, thisLineFrame] = thisFrame->GetContainingBlockForLine(
+      /* aLockScroll */ false);
+  if (!thisBlock) {
+    // We couldn't get the containing block for this frame. In that case, we
+    // play it safe and assume this is the beginning of a new line.
+    return true;
+  }
+
+  // The previous leaf might cross lines. We want to compare against the last
+  // line.
+  prevFrame = prevFrame->LastContinuation();
+  auto [prevBlock, prevLineFrame] = prevFrame->GetContainingBlockForLine(
+      /* aLockScroll */ false);
+  if (thisBlock != prevBlock) {
+    // If the blocks are different, that means there's nothing before us on the
+    // same line, so we're at the start.
+    return true;
+  }
+  if (nsBlockFrame* block = do_QueryFrame(thisBlock)) {
+    // If we have a block frame, it's faster for us to use
+    // BlockInFlowLineIterator because it uses the line cursor.
+    bool found = false;
+    block->SetupLineCursorForQuery();
+    nsBlockInFlowLineIterator prevIt(block, prevLineFrame, &found);
+    if (!found) {
+      // Error; play it safe.
+      return true;
+    }
+    found = false;
+    nsBlockInFlowLineIterator thisIt(block, thisLineFrame, &found);
+    // if the lines are different, that means there's nothing before us on the
+    // same line, so we're at the start.
+    return !found || prevIt.GetLine() != thisIt.GetLine();
+  }
+  AutoAssertNoDomMutations guard;
+  nsILineIterator* it = prevBlock->GetLineIterator();
+  MOZ_ASSERT(it, "GetLineIterator impl in line-container blocks is infallible");
+  int32_t prevLineNum = it->FindLineContaining(prevLineFrame);
+  if (prevLineNum < 0) {
+    // Error; play it safe.
+    return true;
+  }
+  int32_t thisLineNum = it->FindLineContaining(thisLineFrame, prevLineNum);
+  // if the blocks and line numbers are different, that means there's nothing
+  // before us on the same line, so we're at the start.
+  return thisLineNum != prevLineNum;
+}
+
+/**
+ * There are many kinds of word break, but we only need to treat punctuation and
+ * space specially.
+ */
+enum WordBreakClass { eWbcSpace = 0, eWbcPunct, eWbcOther };
+
+static WordBreakClass GetWordBreakClass(char16_t aChar) {
+  // Based on IsSelectionInlineWhitespace and IsSelectionNewline in
+  // layout/generic/nsTextFrame.cpp.
+  const char16_t kCharNbsp = 0xA0;
+  switch (aChar) {
+    case ' ':
+    case kCharNbsp:
+    case '\t':
+    case '\f':
+    case '\n':
+    case '\r':
+      return eWbcSpace;
+    default:
+      break;
+  }
+  return mozilla::IsPunctuationForWordSelect(aChar) ? eWbcPunct : eWbcOther;
+}
+
+/**
+ * Words can cross Accessibles. To work out whether we're at the start of a
+ * word, we might have to check the previous leaf. This class handles querying
+ * the previous WordBreakClass, crossing Accessibles if necessary.
+ */
+class PrevWordBreakClassWalker {
+ public:
+  PrevWordBreakClassWalker(Accessible* aAcc, const nsAString& aText,
+                           int32_t aOffset)
+      : mAcc(aAcc), mText(aText), mOffset(aOffset) {
+    mClass = GetWordBreakClass(mText.CharAt(mOffset));
+  }
+
+  WordBreakClass CurClass() { return mClass; }
+
+  Maybe<WordBreakClass> PrevClass() {
+    for (;;) {
+      if (!PrevChar()) {
+        return Nothing();
+      }
+      WordBreakClass curClass = GetWordBreakClass(mText.CharAt(mOffset));
+      if (curClass != mClass) {
+        mClass = curClass;
+        return Some(curClass);
+      }
+    }
+    MOZ_ASSERT_UNREACHABLE();
+    return Nothing();
+  }
+
+  bool IsStartOfGroup() {
+    if (!PrevChar()) {
+      // There are no characters before us.
+      return true;
+    }
+    WordBreakClass curClass = GetWordBreakClass(mText.CharAt(mOffset));
+    // We wanted to peek at the previous character, not really move to it.
+    ++mOffset;
+    return curClass != mClass;
+  }
+
+ private:
+  bool PrevChar() {
+    if (mOffset > 0) {
+      --mOffset;
+      return true;
+    }
+    if (!mAcc) {
+      // PrevChar was called already and failed.
+      return false;
+    }
+    mAcc = PrevLeaf(mAcc);
+    if (!mAcc) {
+      return false;
+    }
+    mText.Truncate();
+    mAcc->AppendTextTo(mText);
+    mOffset = static_cast<int32_t>(mText.Length()) - 1;
+    return true;
+  }
+
+  Accessible* mAcc;
+  nsAutoString mText;
+  int32_t mOffset;
+  WordBreakClass mClass;
+};
+
+/**
+ * WordBreaker breaks at all space, punctuation, etc. We want to emulate
+ * layout, so that's not what we want. This function determines whether this
+ * is acceptable as the start of a word for our purposes.
+ */
+static bool IsAcceptableWordStart(Accessible* aAcc, const nsAutoString& aText,
+                                  int32_t aOffset) {
+  PrevWordBreakClassWalker walker(aAcc, aText, aOffset);
+  if (!walker.IsStartOfGroup()) {
+    // If we're not at the start of a WordBreaker group, this can't be the
+    // start of a word.
+    return false;
+  }
+  WordBreakClass curClass = walker.CurClass();
+  if (curClass == eWbcSpace) {
+    // Space isn't the start of a word.
+    return false;
+  }
+  Maybe<WordBreakClass> prevClass = walker.PrevClass();
+  if (curClass == eWbcPunct && (!prevClass || prevClass.value() != eWbcSpace)) {
+    // Punctuation isn't the start of a word (unless it is after space).
+    return false;
+  }
+  if (!prevClass || prevClass.value() != eWbcPunct) {
+    // If there's nothing before this or the group before this isn't
+    // punctuation, this is the start of a word.
+    return true;
+  }
+  // At this point, we know the group before this is punctuation.
+  if (!StaticPrefs::layout_word_select_stop_at_punctuation()) {
+    // When layout.word_select.stop_at_punctuation is false (defaults to true),
+    // if there is punctuation before this, this is not the start of a word.
+    return false;
+  }
+  Maybe<WordBreakClass> prevPrevClass = walker.PrevClass();
+  if (!prevPrevClass || prevPrevClass.value() == eWbcSpace) {
+    // If there is punctuation before this and space (or nothing) before the
+    // punctuation, this is not the start of a word.
+    return false;
+  }
+  return true;
+}
+
+class BlockRule : public PivotRule {
+ public:
+  virtual uint16_t Match(Accessible* aAcc) override {
+    if (RefPtr<nsAtom>(aAcc->DisplayStyle()) == nsGkAtoms::block ||
+        aAcc->IsHTMLListItem() || aAcc->IsTableRow() || aAcc->IsTableCell()) {
+      return nsIAccessibleTraversalRule::FILTER_MATCH;
+    }
+    return nsIAccessibleTraversalRule::FILTER_IGNORE;
+  }
+};
+
+/**
+ * Find spelling error DOM ranges overlapping the requested LocalAccessible and
+ * offsets. This includes ranges that begin or end outside of the given
+ * LocalAccessible. Note that the offset arguments are rendered offsets, but
+ * because the returned ranges are DOM ranges, those offsets are content
+ * offsets. See the documentation for dom::Selection::GetRangesForIntervalArray
+ * for information about the aAllowAdjacent argument.
+ */
+static nsTArray<nsRange*> FindDOMSpellingErrors(LocalAccessible* aAcc,
+                                                int32_t aRenderedStart,
+                                                int32_t aRenderedEnd,
+                                                bool aAllowAdjacent = false) {
+  if (!aAcc->IsTextLeaf() || !aAcc->HasOwnContent()) {
+    return {};
+  }
+  nsIFrame* frame = aAcc->GetFrame();
+  RefPtr<nsFrameSelection> frameSel =
+      frame ? frame->GetFrameSelection() : nullptr;
+  dom::Selection* domSel =
+      frameSel ? frameSel->GetSelection(SelectionType::eSpellCheck) : nullptr;
+  if (!domSel) {
+    return {};
+  }
+  nsINode* node = aAcc->GetNode();
+  uint32_t contentStart = RenderedToContentOffset(aAcc, aRenderedStart);
+  uint32_t contentEnd =
+      aRenderedEnd == nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT
+          ? dom::CharacterData::FromNode(node)->TextLength()
+          : RenderedToContentOffset(aAcc, aRenderedEnd);
+  nsTArray<nsRange*> domRanges;
+  domSel->GetDynamicRangesForIntervalArray(node, contentStart, node, contentEnd,
+                                           aAllowAdjacent, &domRanges);
+  return domRanges;
+}
+
+/**
+ * Given two DOM nodes get DOM Selection object that is common
+ * to both of them.
+ */
+static dom::Selection* GetDOMSelection(const nsIContent* aStartContent,
+                                       const nsIContent* aEndContent) {
+  nsIFrame* startFrame = aStartContent->GetPrimaryFrame();
+  const nsFrameSelection* startFrameSel =
+      startFrame ? startFrame->GetConstFrameSelection() : nullptr;
+  nsIFrame* endFrame = aEndContent->GetPrimaryFrame();
+  const nsFrameSelection* endFrameSel =
+      endFrame ? endFrame->GetConstFrameSelection() : nullptr;
+
+  if (startFrameSel != endFrameSel) {
+    // Start and end point don't share the same selection state.
+    // This could happen when both points aren't in the same editable.
+    return nullptr;
+  }
+
+  return startFrameSel ? startFrameSel->GetSelection(SelectionType::eNormal)
+                       : nullptr;
+}
+
+std::pair<nsIContent*, int32_t> TextLeafPoint::ToDOMPoint(
+    bool aIncludeGenerated) const {
+  if (!(*this) || !mAcc->IsLocal()) {
+    MOZ_ASSERT_UNREACHABLE("Invalid point");
+    return {nullptr, 0};
+  }
+
+  nsIContent* content = mAcc->AsLocal()->GetContent();
+  nsIFrame* frame = content ? content->GetPrimaryFrame() : nullptr;
+  MOZ_ASSERT(frame);
+
+  if (!aIncludeGenerated && frame && frame->IsGeneratedContentFrame()) {
+    // List markers accessibles represent the generated content element,
+    // before/after text accessibles represent the child text nodes.
+    auto generatedElement = content->IsGeneratedContentContainerForMarker()
+                                ? content
+                                : content->GetParentElement();
+    auto parent = generatedElement ? generatedElement->GetParent() : nullptr;
+    MOZ_ASSERT(parent);
+    if (parent) {
+      if (generatedElement->IsGeneratedContentContainerForAfter()) {
+        // Use the end offset of the parent element for trailing generated
+        // content.
+        return {parent, parent->GetChildCount()};
+      }
+
+      if (generatedElement->IsGeneratedContentContainerForBefore() ||
+          generatedElement->IsGeneratedContentContainerForMarker()) {
+        // Use the start offset of the parent element for leading generated
+        // content.
+        return {parent, 0};
+      }
+
+      MOZ_ASSERT_UNREACHABLE("Unknown generated content type!");
+    }
+  }
+
+  if (!mAcc->IsTextLeaf() && !mAcc->IsHTMLBr() && !mAcc->HasChildren()) {
+    // If this is not a text leaf it can be an empty editable container,
+    // whitespace, or an empty doc. In any case, the offset inside should be 0.
+    MOZ_ASSERT(mOffset == 0);
+
+    if (RefPtr<TextControlElement> textControlElement =
+            TextControlElement::FromNodeOrNull(content)) {
+      // This is an empty input, use the shadow root's element.
+      if (RefPtr<TextEditor> textEditor = textControlElement->GetTextEditor()) {
+        if (textEditor->IsEmpty()) {
+          MOZ_ASSERT(mOffset == 0);
+          return {textEditor->GetRoot(), 0};
+        }
+      }
+    }
+
+    return {content, 0};
+  }
+
+  return {content, RenderedToContentOffset(mAcc->AsLocal(), mOffset)};
+}
+
+/*** TextLeafPoint ***/
+
+TextLeafPoint::TextLeafPoint(Accessible* aAcc, int32_t aOffset) {
+  if (!aAcc) {
+    // Construct an invalid point.
+    mAcc = nullptr;
+    mOffset = 0;
+    return;
+  }
+
+  // Even though an OuterDoc contains a document, we treat it as a leaf because
+  // we don't want to move into another document.
+  if (aOffset != nsIAccessibleText::TEXT_OFFSET_CARET && !aAcc->IsOuterDoc() &&
+      aAcc->HasChildren()) {
+    // Find a leaf. This might not necessarily be a TextLeafAccessible; it
+    // could be an empty container.
+    auto GetChild = [&aOffset](Accessible* acc) -> Accessible* {
+      if (acc->IsOuterDoc()) {
+        return nullptr;
+      }
+      return aOffset != nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT
+                 ? acc->FirstChild()
+                 : acc->LastChild();
+    };
+
+    for (Accessible* acc = GetChild(aAcc); acc; acc = GetChild(acc)) {
+      mAcc = acc;
+    }
+    mOffset = aOffset != nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT
+                  ? 0
+                  : nsAccUtils::TextLength(mAcc);
+    return;
+  }
+  mAcc = aAcc;
+  mOffset = aOffset != nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT
+                ? aOffset
+                : nsAccUtils::TextLength(mAcc);
+}
+
+bool TextLeafPoint::operator<(const TextLeafPoint& aPoint) const {
+  if (mAcc == aPoint.mAcc) {
+    return mOffset < aPoint.mOffset;
+  }
+  return mAcc->IsBefore(aPoint.mAcc);
+}
+
+bool TextLeafPoint::operator<=(const TextLeafPoint& aPoint) const {
+  return *this == aPoint || *this < aPoint;
+}
+
+bool TextLeafPoint::IsDocEdge(nsDirection aDirection) const {
+  if (aDirection == eDirPrevious) {
+    return mOffset == 0 && !PrevLeaf(mAcc);
+  }
+
+  return mOffset == static_cast<int32_t>(nsAccUtils::TextLength(mAcc)) &&
+         !NextLeaf(mAcc);
+}
+
+bool TextLeafPoint::IsLeafAfterListItemMarker() const {
+  Accessible* prev = PrevLeaf(mAcc);
+  return prev && prev->Role() == roles::LISTITEM_MARKER &&
+         prev->Parent()->IsAncestorOf(mAcc);
+}
+
+bool TextLeafPoint::IsEmptyLastLine() const {
+  if (mAcc->IsHTMLBr() && mOffset == 1) {
+    return true;
+  }
+  if (!mAcc->IsTextLeaf()) {
+    return false;
+  }
+  if (mOffset < static_cast<int32_t>(nsAccUtils::TextLength(mAcc))) {
+    return false;
+  }
+  nsAutoString text;
+  mAcc->AppendTextTo(text, mOffset - 1, 1);
+  return text.CharAt(0) == '\n';
+}
+
+char16_t TextLeafPoint::GetChar() const {
+  nsAutoString text;
+  mAcc->AppendTextTo(text, mOffset, 1);
+  return text.CharAt(0);
+}
+
+TextLeafPoint TextLeafPoint::FindPrevLineStartSameLocalAcc(
+    bool aIncludeOrigin) const {
+  LocalAccessible* acc = mAcc->AsLocal();
+  MOZ_ASSERT(acc);
+  if (mOffset == 0) {
+    if (aIncludeOrigin && IsLocalAccAtLineStart(acc)) {
+      return *this;
+    }
+    return TextLeafPoint();
+  }
+  nsIFrame* frame = acc->GetFrame();
+  if (!frame) {
+    // This can happen if this is an empty element with display: contents. In
+    // that case, this Accessible contains no lines.
+    return TextLeafPoint();
+  }
+  if (!frame->IsTextFrame()) {
+    if (IsLocalAccAtLineStart(acc)) {
+      return TextLeafPoint(acc, 0);
+    }
+    return TextLeafPoint();
+  }
+  // Each line of a text node is rendered as a continuation frame. Get the
+  // continuation containing the origin.
+  int32_t origOffset = mOffset;
+  origOffset = RenderedToContentOffset(acc, origOffset);
+  nsTextFrame* continuation = nullptr;
+  int32_t unusedOffsetInContinuation = 0;
+  frame->GetChildFrameContainingOffset(
+      origOffset, true, &unusedOffsetInContinuation, (nsIFrame**)&continuation);
+  MOZ_ASSERT(continuation);
+  int32_t lineStart = continuation->GetContentOffset();
+  if (!aIncludeOrigin && lineStart > 0 && lineStart == origOffset) {
+    // A line starts at the origin, but the caller doesn't want this included.
+    // Go back one more.
+    continuation = continuation->GetPrevContinuation();
+    MOZ_ASSERT(continuation);
+    lineStart = continuation->GetContentOffset();
+  }
+  MOZ_ASSERT(lineStart >= 0);
+  if (lineStart == 0 && !IsLocalAccAtLineStart(acc)) {
+    // This is the first line of this text node, but there is something else
+    // on the same line before this text node, so don't return this as a line
+    // start.
+    return TextLeafPoint();
+  }
+  lineStart = static_cast<int32_t>(ContentToRenderedOffset(acc, lineStart));
+  return TextLeafPoint(acc, lineStart);
+}
+
+TextLeafPoint TextLeafPoint::FindNextLineStartSameLocalAcc(
+    bool aIncludeOrigin) const {
+  LocalAccessible* acc = mAcc->AsLocal();
+  MOZ_ASSERT(acc);
+  if (aIncludeOrigin && mOffset == 0 && IsLocalAccAtLineStart(acc)) {
+    return *this;
+  }
+  nsIFrame* frame = acc->GetFrame();
+  if (!frame) {
+    // This can happen if this is an empty element with display: contents. In
+    // that case, this Accessible contains no lines.
+    return TextLeafPoint();
+  }
+  if (!frame->IsTextFrame()) {
+    // There can't be multiple lines in a non-text leaf.
+    return TextLeafPoint();
+  }
+  // Each line of a text node is rendered as a continuation frame. Get the
+  // continuation containing the origin.
+  int32_t origOffset = mOffset;
+  origOffset = RenderedToContentOffset(acc, origOffset);
+  nsTextFrame* continuation = nullptr;
+  int32_t unusedOffsetInContinuation = 0;
+  frame->GetChildFrameContainingOffset(
+      origOffset, true, &unusedOffsetInContinuation, (nsIFrame**)&continuation);
+  MOZ_ASSERT(continuation);
+  if (
+      // A line starts at the origin and the caller wants this included.
+      aIncludeOrigin && continuation->GetContentOffset() == origOffset &&
+      // If this is the first line of this text node (offset 0), don't treat it
+      // as a line start if there's something else on the line before this text
+      // node.
+      !(origOffset == 0 && !IsLocalAccAtLineStart(acc))) {
+    return *this;
+  }
+  continuation = continuation->GetNextContinuation();
+  if (!continuation) {
+    return TextLeafPoint();
+  }
+  int32_t lineStart = continuation->GetContentOffset();
+  lineStart = static_cast<int32_t>(ContentToRenderedOffset(acc, lineStart));
+  return TextLeafPoint(acc, lineStart);
+}
+
+TextLeafPoint TextLeafPoint::FindLineStartSameRemoteAcc(
+    nsDirection aDirection, bool aIncludeOrigin) const {
+  RemoteAccessible* acc = mAcc->AsRemote();
+  MOZ_ASSERT(acc);
+  auto lines = acc->GetCachedTextLines();
+  if (!lines) {
+    return TextLeafPoint();
+  }
+  size_t index;
+  // If BinarySearch returns true, mOffset is in the array and index points at
+  // it. If BinarySearch returns false, mOffset is not in the array and index
+  // points at the next line start after mOffset.
+  if (BinarySearch(*lines, 0, lines->Length(), mOffset, &index)) {
+    if (aIncludeOrigin) {
+      return *this;
+    }
+    if (aDirection == eDirNext) {
+      // We don't want to include the origin. Get the next line start.
+      ++index;
+    }
+  }
+  MOZ_ASSERT(index <= lines->Length());
+  if ((aDirection == eDirNext && index == lines->Length()) ||
+      (aDirection == eDirPrevious && index == 0)) {
+    return TextLeafPoint();
+  }
+  // index points at the line start after mOffset.
+  if (aDirection == eDirPrevious) {
+    --index;
+  }
+  return TextLeafPoint(mAcc, lines->ElementAt(index));
+}
+
+TextLeafPoint TextLeafPoint::FindLineStartSameAcc(
+    nsDirection aDirection, bool aIncludeOrigin,
+    bool aIgnoreListItemMarker) const {
+  TextLeafPoint boundary;
+  if (aIgnoreListItemMarker && aIncludeOrigin && mOffset == 0 &&
+      IsLeafAfterListItemMarker()) {
+    // If:
+    // (1) we are ignoring list markers
+    // (2) we should include origin
+    // (3) we are at the start of a leaf that follows a list item marker
+    // ...then return this point.
+    return *this;
+  }
+
+  if (mAcc->IsLocal()) {
+    boundary = aDirection == eDirNext
+                   ? FindNextLineStartSameLocalAcc(aIncludeOrigin)
+                   : FindPrevLineStartSameLocalAcc(aIncludeOrigin);
+  } else {
+    boundary = FindLineStartSameRemoteAcc(aDirection, aIncludeOrigin);
+  }
+
+  if (aIgnoreListItemMarker && aDirection == eDirPrevious && !boundary &&
+      mOffset != 0 && IsLeafAfterListItemMarker()) {
+    // If:
+    // (1) we are ignoring list markers
+    // (2) we are searching backwards in accessible
+    // (3) we did not find a line start before this point
+    // (4) we are in a leaf that follows a list item marker
+    // ...then return the first point in this accessible.
+    boundary = TextLeafPoint(mAcc, 0);
+  }
+
+  return boundary;
+}
+
+TextLeafPoint TextLeafPoint::FindPrevWordStartSameAcc(
+    bool aIncludeOrigin) const {
+  if (mOffset == 0 && !aIncludeOrigin) {
+    // We can't go back any further and the caller doesn't want the origin
+    // included, so there's nothing more to do.
+    return TextLeafPoint();
+  }
+  nsAutoString text;
+  mAcc->AppendTextTo(text);
+  TextLeafPoint lineStart = *this;
+  if (!aIncludeOrigin || (lineStart.mOffset == 1 && text.Length() == 1 &&
+                          text.CharAt(0) == '\n')) {
+    // We're not interested in a line that starts here, either because
+    // aIncludeOrigin is false or because we're at the end of a line break
+    // node.
+    --lineStart.mOffset;
+  }
+  // A word never starts with a line feed character. If there are multiple
+  // consecutive line feed characters and we're after the first of them, the
+  // previous line start will be a line feed character. Skip this and any prior
+  // consecutive line feed first.
+  for (; lineStart.mOffset >= 0 && text.CharAt(lineStart.mOffset) == '\n';
+       --lineStart.mOffset) {
+  }
+  if (lineStart.mOffset < 0) {
+    // There's no line start for our purposes.
+    lineStart = TextLeafPoint();
+  } else {
+    lineStart =
+        lineStart.FindLineStartSameAcc(eDirPrevious, /* aIncludeOrigin */ true);
+  }
+  // Keep walking backward until we find an acceptable word start.
+  intl::WordRange word;
+  if (mOffset == 0) {
+    word.mBegin = 0;
+  } else if (mOffset == static_cast<int32_t>(text.Length())) {
+    word = WordBreaker::FindWord(
+        text, mOffset - 1,
+        StaticPrefs::layout_word_select_stop_at_punctuation()
+            ? FindWordOptions::StopAtPunctuation
+            : FindWordOptions::None);
+  } else {
+    word = WordBreaker::FindWord(
+        text, mOffset,
+        StaticPrefs::layout_word_select_stop_at_punctuation()
+            ? FindWordOptions::StopAtPunctuation
+            : FindWordOptions::None);
+  }
+  for (;; word = WordBreaker::FindWord(
+              text, word.mBegin - 1,
+              StaticPrefs::layout_word_select_stop_at_punctuation()
+                  ? FindWordOptions::StopAtPunctuation
+                  : FindWordOptions::None)) {
+    if (!aIncludeOrigin && static_cast<int32_t>(word.mBegin) == mOffset) {
+      // A word possibly starts at the origin, but the caller doesn't want this
+      // included.
+      MOZ_ASSERT(word.mBegin != 0);
+      continue;
+    }
+    if (lineStart && static_cast<int32_t>(word.mBegin) < lineStart.mOffset) {
+      // A line start always starts a new word.
+      return lineStart;
+    }
+    if (IsAcceptableWordStart(mAcc, text, static_cast<int32_t>(word.mBegin))) {
+      break;
+    }
+    if (word.mBegin == 0) {
+      // We can't go back any further.
+      if (lineStart) {
+        // A line start always starts a new word.
+        return lineStart;
+      }
+      return TextLeafPoint();
+    }
+  }
+  return TextLeafPoint(mAcc, static_cast<int32_t>(word.mBegin));
+}
+
+TextLeafPoint TextLeafPoint::FindNextWordStartSameAcc(
+    bool aIncludeOrigin) const {
+  nsAutoString text;
+  mAcc->AppendTextTo(text);
+  int32_t wordStart = mOffset;
+  if (aIncludeOrigin) {
+    if (wordStart == 0) {
+      if (IsAcceptableWordStart(mAcc, text, 0)) {
+        return *this;
+      }
+    } else {
+      // The origin might start a word, so search from just before it.
+      --wordStart;
+    }
+  }
+  TextLeafPoint lineStart = FindLineStartSameAcc(eDirNext, aIncludeOrigin);
+  if (lineStart) {
+    // A word never starts with a line feed character. If there are multiple
+    // consecutive line feed characters, lineStart will point at the second of
+    // them. Skip this and any subsequent consecutive line feed.
+    for (; lineStart.mOffset < static_cast<int32_t>(text.Length()) &&
+           text.CharAt(lineStart.mOffset) == '\n';
+         ++lineStart.mOffset) {
+    }
+    if (lineStart.mOffset == static_cast<int32_t>(text.Length())) {
+      // There's no line start for our purposes.
+      lineStart = TextLeafPoint();
+    }
+  }
+  // Keep walking forward until we find an acceptable word start.
+  intl::WordBreakIteratorUtf16 wordBreakIter(text);
+  int32_t previousPos = wordStart;
+  Maybe<uint32_t> nextBreak = wordBreakIter.Seek(wordStart);
+  for (;;) {
+    if (!nextBreak || *nextBreak == text.Length()) {
+      if (lineStart) {
+        // A line start always starts a new word.
+        return lineStart;
+      }
+      if (StaticPrefs::layout_word_select_stop_at_punctuation()) {
+        // If layout.word_select.stop_at_punctuation is true, we have to look
+        // for punctuation class since it may not break state in UAX#29.
+        for (int32_t i = previousPos + 1;
+             i < static_cast<int32_t>(text.Length()); i++) {
+          if (IsAcceptableWordStart(mAcc, text, i)) {
+            return TextLeafPoint(mAcc, i);
+          }
+        }
+      }
+      return TextLeafPoint();
+    }
+    wordStart = AssertedCast<int32_t>(*nextBreak);
+    if (lineStart && wordStart > lineStart.mOffset) {
+      // A line start always starts a new word.
+      return lineStart;
+    }
+    if (IsAcceptableWordStart(mAcc, text, wordStart)) {
+      break;
+    }
+
+    if (StaticPrefs::layout_word_select_stop_at_punctuation()) {
+      // If layout.word_select.stop_at_punctuation is true, we have to look
+      // for punctuation class since it may not break state in UAX#29.
+      for (int32_t i = previousPos + 1; i < wordStart; i++) {
+        if (IsAcceptableWordStart(mAcc, text, i)) {
+          return TextLeafPoint(mAcc, i);
+        }
+      }
+    }
+    previousPos = wordStart;
+    nextBreak = wordBreakIter.Next();
+  }
+  return TextLeafPoint(mAcc, wordStart);
+}
+
+bool TextLeafPoint::IsCaretAtEndOfLine() const {
+  MOZ_ASSERT(IsCaret());
+  if (LocalAccessible* acc = mAcc->AsLocal()) {
+    HyperTextAccessible* ht = HyperTextFor(acc);
+    if (!ht) {
+      return false;
+    }
+    // Use HyperTextAccessible::IsCaretAtEndOfLine. Eventually, we'll want to
+    // move that code into TextLeafPoint, but existing code depends on it living
+    // in HyperTextAccessible (including caret events).
+    return ht->IsCaretAtEndOfLine();
+  }
+  return mAcc->AsRemote()->Document()->IsCaretAtEndOfLine();
+}
+
+TextLeafPoint TextLeafPoint::ActualizeCaret(bool aAdjustAtEndOfLine) const {
+  MOZ_ASSERT(IsCaret());
+  HyperTextAccessibleBase* ht;
+  int32_t htOffset;
+  if (LocalAccessible* acc = mAcc->AsLocal()) {
+    // Use HyperTextAccessible::CaretOffset. Eventually, we'll want to move
+    // that code into TextLeafPoint, but existing code depends on it living in
+    // HyperTextAccessible (including caret events).
+    ht = HyperTextFor(acc);
+    if (!ht) {
+      return TextLeafPoint();
+    }
+    htOffset = ht->CaretOffset();
+    if (htOffset == -1) {
+      return TextLeafPoint();
+    }
+  } else {
+    // Ideally, we'd cache the caret as a leaf, but our events are based on
+    // HyperText for now.
+    std::tie(ht, htOffset) = mAcc->AsRemote()->Document()->GetCaret();
+    if (!ht) {
+      return TextLeafPoint();
+    }
+  }
+  if (aAdjustAtEndOfLine && htOffset > 0 && IsCaretAtEndOfLine()) {
+    // It is the same character offset when the caret is visually at the very
+    // end of a line or the start of a new line (soft line break). Getting text
+    // at the line should provide the line with the visual caret. Otherwise,
+    // screen readers will announce the wrong line as the user presses up or
+    // down arrow and land at the end of a line.
+    --htOffset;
+  }
+  return ht->ToTextLeafPoint(htOffset);
+}
+
+TextLeafPoint TextLeafPoint::FindBoundary(AccessibleTextBoundary aBoundaryType,
+                                          nsDirection aDirection,
+                                          BoundaryFlags aFlags) const {
+  if (IsCaret()) {
+    if (aBoundaryType == nsIAccessibleText::BOUNDARY_CHAR) {
+      if (IsCaretAtEndOfLine()) {
+        // The caret is at the end of the line. Return no character.
+        return ActualizeCaret(/* aAdjustAtEndOfLine */ false);
+      }
+    }
+    return ActualizeCaret().FindBoundary(
+        aBoundaryType, aDirection, aFlags & BoundaryFlags::eIncludeOrigin);
+  }
+
+  bool inEditableAndStopInIt = (aFlags & BoundaryFlags::eStopInEditable) &&
+                               mAcc->Parent() &&
+                               (mAcc->Parent()->State() & states::EDITABLE);
+  if (aBoundaryType == nsIAccessibleText::BOUNDARY_LINE_END) {
+    return FindLineEnd(aDirection,
+                       inEditableAndStopInIt
+                           ? aFlags
+                           : (aFlags & ~BoundaryFlags::eStopInEditable));
+  }
+  if (aBoundaryType == nsIAccessibleText::BOUNDARY_WORD_END) {
+    return FindWordEnd(aDirection,
+                       inEditableAndStopInIt
+                           ? aFlags
+                           : (aFlags & ~BoundaryFlags::eStopInEditable));
+  }
+  if ((aBoundaryType == nsIAccessibleText::BOUNDARY_LINE_START ||
+       aBoundaryType == nsIAccessibleText::BOUNDARY_PARAGRAPH) &&
+      (aFlags & BoundaryFlags::eIncludeOrigin) && aDirection == eDirPrevious &&
+      IsEmptyLastLine()) {
+    // If we're at an empty line at the end of an Accessible,  we don't want to
+    // walk into the previous line. For example, this can happen if the caret
+    // is positioned on an empty line at the end of a textarea.
+    return *this;
+  }
+  bool includeOrigin = !!(aFlags & BoundaryFlags::eIncludeOrigin);
+  bool ignoreListItemMarker = !!(aFlags & BoundaryFlags::eIgnoreListItemMarker);
+  Accessible* lastAcc = nullptr;
+  for (TextLeafPoint searchFrom = *this; searchFrom;
+       searchFrom = searchFrom.NeighborLeafPoint(
+           aDirection, inEditableAndStopInIt, ignoreListItemMarker)) {
+    lastAcc = searchFrom.mAcc;
+    if (ignoreListItemMarker && searchFrom == *this &&
+        searchFrom.mAcc->Role() == roles::LISTITEM_MARKER) {
+      continue;
+    }
+    TextLeafPoint boundary;
+    // Search for the boundary within the current Accessible.
+    switch (aBoundaryType) {
+      case nsIAccessibleText::BOUNDARY_CHAR:
+        if (includeOrigin) {
+          boundary = searchFrom;
+        } else if (aDirection == eDirPrevious && searchFrom.mOffset > 0) {
+          boundary.mAcc = searchFrom.mAcc;
+          boundary.mOffset = searchFrom.mOffset - 1;
+        } else if (aDirection == eDirNext &&
+                   searchFrom.mOffset + 1 <
+                       static_cast<int32_t>(
+                           nsAccUtils::TextLength(searchFrom.mAcc))) {
+          boundary.mAcc = searchFrom.mAcc;
+          boundary.mOffset = searchFrom.mOffset + 1;
+        }
+        break;
+      case nsIAccessibleText::BOUNDARY_WORD_START:
+        if (aDirection == eDirPrevious) {
+          boundary = searchFrom.FindPrevWordStartSameAcc(includeOrigin);
+        } else {
+          boundary = searchFrom.FindNextWordStartSameAcc(includeOrigin);
+        }
+        break;
+      case nsIAccessibleText::BOUNDARY_LINE_START:
+        boundary = searchFrom.FindLineStartSameAcc(aDirection, includeOrigin,
+                                                   ignoreListItemMarker);
+        break;
+      case nsIAccessibleText::BOUNDARY_PARAGRAPH:
+        boundary = searchFrom.FindParagraphSameAcc(aDirection, includeOrigin,
+                                                   ignoreListItemMarker);
+        break;
+      default:
+        MOZ_ASSERT_UNREACHABLE();
+        break;
+    }
+    if (boundary) {
+      return boundary;
+    }
+
+    // The start/end of the Accessible might be a boundary. If so, we must stop
+    // on it.
+    includeOrigin = true;
+  }
+
+  MOZ_ASSERT(lastAcc);
+  // No further leaf was found. Use the start/end of the first/last leaf.
+  return TextLeafPoint(
+      lastAcc, aDirection == eDirPrevious
+                   ? 0
+                   : static_cast<int32_t>(nsAccUtils::TextLength(lastAcc)));
+}
+
+TextLeafPoint TextLeafPoint::FindLineEnd(nsDirection aDirection,
+                                         BoundaryFlags aFlags) const {
+  if (aDirection == eDirPrevious && IsEmptyLastLine()) {
+    // If we're at an empty line at the end of an Accessible,  we don't want to
+    // walk into the previous line. For example, this can happen if the caret
+    // is positioned on an empty line at the end of a textarea.
+    // Because we want the line end, we must walk back to the line feed
+    // character.
+    return FindBoundary(nsIAccessibleText::BOUNDARY_CHAR, eDirPrevious,
+                        aFlags & ~BoundaryFlags::eIncludeOrigin);
+  }
+  if ((aFlags & BoundaryFlags::eIncludeOrigin) && IsLineFeedChar()) {
+    return *this;
+  }
+  if (aDirection == eDirPrevious && !(aFlags & BoundaryFlags::eIncludeOrigin)) {
+    // If there is a line feed immediately before us, return that.
+    TextLeafPoint prevChar =
+        FindBoundary(nsIAccessibleText::BOUNDARY_CHAR, eDirPrevious,
+                     aFlags & ~BoundaryFlags::eIncludeOrigin);
+    if (prevChar.IsLineFeedChar()) {
+      return prevChar;
+    }
+  }
+  TextLeafPoint searchFrom = *this;
+  if (aDirection == eDirNext && IsLineFeedChar()) {
+    // If we search for the next line start from a line feed, we'll get the
+    // character immediately following the line feed. We actually want the
+    // next line start after that. Skip the line feed.
+    searchFrom = FindBoundary(nsIAccessibleText::BOUNDARY_CHAR, eDirNext,
+                              aFlags & ~BoundaryFlags::eIncludeOrigin);
+  }
+  TextLeafPoint lineStart = searchFrom.FindBoundary(
+      nsIAccessibleText::BOUNDARY_LINE_START, aDirection, aFlags);
+  if (aDirection == eDirNext && IsEmptyLastLine()) {
+    // There is a line feed immediately before us, but that's actually the end
+    // of the previous line, not the end of our empty line. Don't walk back.
+    return lineStart;
+  }
+  // If there is a line feed before this line start (at the end of the previous
+  // line), we must return that.
+  TextLeafPoint prevChar =
+      lineStart.FindBoundary(nsIAccessibleText::BOUNDARY_CHAR, eDirPrevious,
+                             aFlags & ~BoundaryFlags::eIncludeOrigin);
+  if (prevChar && prevChar.IsLineFeedChar()) {
+    return prevChar;
+  }
+  return lineStart;
+}
+
+bool TextLeafPoint::IsSpace() const {
+  return GetWordBreakClass(GetChar()) == eWbcSpace;
+}
+
+TextLeafPoint TextLeafPoint::FindWordEnd(nsDirection aDirection,
+                                         BoundaryFlags aFlags) const {
+  char16_t origChar = GetChar();
+  const bool origIsSpace = GetWordBreakClass(origChar) == eWbcSpace;
+  bool prevIsSpace = false;
+  if (aDirection == eDirPrevious ||
+      ((aFlags & BoundaryFlags::eIncludeOrigin) && origIsSpace) || !origChar) {
+    TextLeafPoint prev =
+        FindBoundary(nsIAccessibleText::BOUNDARY_CHAR, eDirPrevious,
+                     aFlags & ~BoundaryFlags::eIncludeOrigin);
+    if (aDirection == eDirPrevious && prev == *this) {
+      return *this;  // Can't go any further.
+    }
+    prevIsSpace = prev.IsSpace();
+    if ((aFlags & BoundaryFlags::eIncludeOrigin) &&
+        (origIsSpace || IsDocEdge(eDirNext)) && !prevIsSpace) {
+      // The origin is space or end of document, but the previous
+      // character is not. This means we're at the end of a word.
+      return *this;
+    }
+  }
+  TextLeafPoint boundary = *this;
+  if (aDirection == eDirPrevious && !prevIsSpace) {
+    // If there isn't space immediately before us, first find the start of the
+    // previous word.
+    boundary = FindBoundary(nsIAccessibleText::BOUNDARY_WORD_START,
+                            eDirPrevious, aFlags);
+  } else if (aDirection == eDirNext &&
+             (origIsSpace || (!origChar && prevIsSpace))) {
+    // We're within the space at the end of the word. Skip over the space. We
+    // can do that by searching for the next word start.
+    boundary = FindBoundary(nsIAccessibleText::BOUNDARY_WORD_START, eDirNext,
+                            aFlags & ~BoundaryFlags::eIncludeOrigin);
+    if (boundary.IsSpace()) {
+      // The next word starts with a space. This can happen if there is a space
+      // after or at the start of a block element.
+      return boundary;
+    }
+  }
+  if (aDirection == eDirNext) {
+    BoundaryFlags flags = aFlags;
+    if (IsDocEdge(eDirPrevious)) {
+      // If this is the start of the doc don't be inclusive in the word-start
+      // search because there is no preceding block where this could be a
+      // word-end for.
+      flags &= ~BoundaryFlags::eIncludeOrigin;
+    }
+    boundary = boundary.FindBoundary(nsIAccessibleText::BOUNDARY_WORD_START,
+                                     eDirNext, flags);
+  }
+  // At this point, boundary is either the start of a word or at a space. A
+  // word ends at the beginning of consecutive space. Therefore, skip back to
+  // the start of any space before us.
+  TextLeafPoint prev = boundary;
+  for (;;) {
+    prev = prev.FindBoundary(nsIAccessibleText::BOUNDARY_CHAR, eDirPrevious,
+                             aFlags & ~BoundaryFlags::eIncludeOrigin);
+    if (prev == boundary) {
+      break;  // Can't go any further.
+    }
+    if (!prev.IsSpace()) {
+      break;
+    }
+    boundary = prev;
+  }
+  return boundary;
+}
+
+TextLeafPoint TextLeafPoint::FindParagraphSameAcc(
+    nsDirection aDirection, bool aIncludeOrigin,
+    bool aIgnoreListItemMarker) const {
+  if (aIncludeOrigin && IsDocEdge(eDirPrevious)) {
+    // The top of the document is a paragraph boundary.
+    return *this;
+  }
+
+  if (aIgnoreListItemMarker && aIncludeOrigin && mOffset == 0 &&
+      IsLeafAfterListItemMarker()) {
+    // If we are in a list item and the previous sibling is
+    // a bullet, the 0 offset in this leaf is a line start.
+    return *this;
+  }
+
+  if (mAcc->IsTextLeaf() &&
+      // We don't want to copy strings unnecessarily. See below for the context
+      // of these individual conditions.
+      ((aIncludeOrigin && mOffset > 0) || aDirection == eDirNext ||
+       mOffset >= 2)) {
+    // If there is a line feed, a new paragraph begins after it.
+    nsAutoString text;
+    mAcc->AppendTextTo(text);
+    if (aIncludeOrigin && mOffset > 0 && text.CharAt(mOffset - 1) == '\n') {
+      return TextLeafPoint(mAcc, mOffset);
+    }
+    int32_t lfOffset = -1;
+    if (aDirection == eDirNext) {
+      lfOffset = text.FindChar('\n', mOffset);
+    } else if (mOffset >= 2) {
+      // A line feed at mOffset - 1 means the origin begins a new paragraph,
+      // but we already handled aIncludeOrigin above. Therefore, we search from
+      // mOffset - 2.
+      lfOffset = text.RFindChar('\n', mOffset - 2);
+    }
+    if (lfOffset != -1 && lfOffset + 1 < static_cast<int32_t>(text.Length())) {
+      return TextLeafPoint(mAcc, lfOffset + 1);
+    }
+  }
+
+  if (aIgnoreListItemMarker && mOffset > 0 && aDirection == eDirPrevious &&
+      IsLeafAfterListItemMarker()) {
+    // No line breaks were found in the preceding text to this offset.
+    // If we are in a list item and the previous sibling is
+    // a bullet, the 0 offset in this leaf is a line start.
+    return TextLeafPoint(mAcc, 0);
+  }
+
+  // Check whether this Accessible begins a paragraph.
+  if ((!aIncludeOrigin && mOffset == 0) ||
+      (aDirection == eDirNext && mOffset > 0)) {
+    // The caller isn't interested in whether this Accessible begins a
+    // paragraph.
+    return TextLeafPoint();
+  }
+  Accessible* prevLeaf = PrevLeaf(mAcc);
+  BlockRule blockRule;
+  Pivot pivot(nsAccUtils::DocumentFor(mAcc));
+  Accessible* prevBlock = pivot.Prev(mAcc, blockRule);
+  // Check if we're the first leaf after a block element.
+  if (prevBlock) {
+    if (
+        // If there's no previous leaf, we must be the first leaf after the
+        // block.
+        !prevLeaf ||
+        // A block can be a leaf; e.g. an empty div or paragraph.
+        prevBlock == prevLeaf) {
+      return TextLeafPoint(mAcc, 0);
+    }
+    if (prevBlock->IsAncestorOf(mAcc)) {
+      // We're inside the block.
+      if (!prevBlock->IsAncestorOf(prevLeaf)) {
+        // The previous leaf isn't inside the block. That means we're the first
+        // leaf in the block.
+        return TextLeafPoint(mAcc, 0);
+      }
+    } else {
+      // We aren't inside the block, so the block ends before us.
+      if (prevBlock->IsAncestorOf(prevLeaf)) {
+        // The previous leaf is inside the block. That means we're the first
+        // leaf after the block. This case is necessary because a block causes a
+        // paragraph break both before and after it.
+        return TextLeafPoint(mAcc, 0);
+      }
+    }
+  }
+  if (!prevLeaf || prevLeaf->IsHTMLBr()) {
+    // We're the first leaf after a line break or the start of the document.
+    return TextLeafPoint(mAcc, 0);
+  }
+  if (prevLeaf->IsTextLeaf()) {
+    // There's a text leaf before us. Check if it ends with a line feed.
+    nsAutoString text;
+    prevLeaf->AppendTextTo(text, nsAccUtils::TextLength(prevLeaf) - 1, 1);
+    if (text.CharAt(0) == '\n') {
+      return TextLeafPoint(mAcc, 0);
+    }
+  }
+  return TextLeafPoint();
+}
+
+bool TextLeafPoint::IsInSpellingError() const {
+  if (LocalAccessible* acc = mAcc->AsLocal()) {
+    auto domRanges = FindDOMSpellingErrors(acc, mOffset, mOffset + 1);
+    // If there is a spelling error overlapping this character, we're in a
+    // spelling error.
+    return !domRanges.IsEmpty();
+  }
+
+  RemoteAccessible* acc = mAcc->AsRemote();
+  MOZ_ASSERT(acc);
+  if (!acc->mCachedFields) {
+    return false;
+  }
+  auto spellingErrors = acc->mCachedFields->GetAttribute<nsTArray<int32_t>>(
+      CacheKey::SpellingErrors);
+  if (!spellingErrors) {
+    return false;
+  }
+  size_t index;
+  const bool foundOrigin = BinarySearch(
+      *spellingErrors, 0, spellingErrors->Length(), mOffset, &index);
+  // In spellingErrors, even indices are start offsets, odd indices are end
+  // offsets.
+  const bool foundStart = index % 2 == 0;
+  if (foundOrigin) {
+    // mOffset is a spelling error boundary. If it's a start offset, we're in a
+    // spelling error.
+    return foundStart;
+  }
+  // index points at the next spelling error boundary after mOffset.
+  if (index == 0) {
+    return false;  // No spelling errors before mOffset.
+  }
+  if (foundStart) {
+    // We're not in a spelling error because it starts after mOffset.
+    return false;
+  }
+  // A spelling error ends after mOffset.
+  return true;
+}
+
+TextLeafPoint TextLeafPoint::FindSpellingErrorSameAcc(
+    nsDirection aDirection, bool aIncludeOrigin) const {
+  if (!aIncludeOrigin && mOffset == 0 && aDirection == eDirPrevious) {
+    return TextLeafPoint();
+  }
+  if (LocalAccessible* acc = mAcc->AsLocal()) {
+    // We want to find both start and end points, so we pass true for
+    // aAllowAdjacent.
+    auto domRanges =
+        aDirection == eDirNext
+            ? FindDOMSpellingErrors(acc, mOffset,
+                                    nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT,
+                                    /* aAllowAdjacent */ true)
+            : FindDOMSpellingErrors(acc, 0, mOffset,
+                                    /* aAllowAdjacent */ true);
+    nsINode* node = acc->GetNode();
+    if (aDirection == eDirNext) {
+      for (nsRange* domRange : domRanges) {
+        if (domRange->GetStartContainer() == node) {
+          int32_t matchOffset = static_cast<int32_t>(ContentToRenderedOffset(
+              acc, static_cast<int32_t>(domRange->StartOffset())));
+          if ((aIncludeOrigin && matchOffset == mOffset) ||
+              matchOffset > mOffset) {
+            return TextLeafPoint(mAcc, matchOffset);
+          }
+        }
+        if (domRange->GetEndContainer() == node) {
+          int32_t matchOffset = static_cast<int32_t>(ContentToRenderedOffset(
+              acc, static_cast<int32_t>(domRange->EndOffset())));
+          if ((aIncludeOrigin && matchOffset == mOffset) ||
+              matchOffset > mOffset) {
+            return TextLeafPoint(mAcc, matchOffset);
+          }
+        }
+      }
+    } else {
+      for (nsRange* domRange : Reversed(domRanges)) {
+        if (domRange->GetEndContainer() == node) {
+          int32_t matchOffset = static_cast<int32_t>(ContentToRenderedOffset(
+              acc, static_cast<int32_t>(domRange->EndOffset())));
+          if ((aIncludeOrigin && matchOffset == mOffset) ||
+              matchOffset < mOffset) {
+            return TextLeafPoint(mAcc, matchOffset);
+          }
+        }
+        if (domRange->GetStartContainer() == node) {
+          int32_t matchOffset = static_cast<int32_t>(ContentToRenderedOffset(
+              acc, static_cast<int32_t>(domRange->StartOffset())));
+          if ((aIncludeOrigin && matchOffset == mOffset) ||
+              matchOffset < mOffset) {
+            return TextLeafPoint(mAcc, matchOffset);
+          }
+        }
+      }
+    }
+    return TextLeafPoint();
+  }
+
+  RemoteAccessible* acc = mAcc->AsRemote();
+  MOZ_ASSERT(acc);
+  if (!acc->mCachedFields) {
+    return TextLeafPoint();
+  }
+  auto spellingErrors = acc->mCachedFields->GetAttribute<nsTArray<int32_t>>(
+      CacheKey::SpellingErrors);
+  if (!spellingErrors) {
+    return TextLeafPoint();
+  }
+  size_t index;
+  if (BinarySearch(*spellingErrors, 0, spellingErrors->Length(), mOffset,
+                   &index)) {
+    // mOffset is in spellingErrors.
+    if (aIncludeOrigin) {
+      return *this;
+    }
+    if (aDirection == eDirNext) {
+      // We don't want the origin, so move to the next spelling error boundary
+      // after mOffset.
+      ++index;
+    }
+  }
+  // index points at the next spelling error boundary after mOffset.
+  if (aDirection == eDirNext) {
+    if (spellingErrors->Length() == index) {
+      return TextLeafPoint();  // No spelling error boundary after us.
+    }
+    return TextLeafPoint(mAcc, (*spellingErrors)[index]);
+  }
+  if (index == 0) {
+    return TextLeafPoint();  // No spelling error boundary before us.
+  }
+  // Decrement index so it points at a spelling error boundary before mOffset.
+  --index;
+  if ((*spellingErrors)[index] == -1) {
+    MOZ_ASSERT(index == 0);
+    // A spelling error starts before mAcc.
+    return TextLeafPoint();
+  }
+  return TextLeafPoint(mAcc, (*spellingErrors)[index]);
+}
+
+TextLeafPoint TextLeafPoint::NeighborLeafPoint(
+    nsDirection aDirection, bool aIsEditable,
+    bool aIgnoreListItemMarker) const {
+  Accessible* acc = aDirection == eDirPrevious
+                        ? PrevLeaf(mAcc, aIsEditable, aIgnoreListItemMarker)
+                        : NextLeaf(mAcc, aIsEditable, aIgnoreListItemMarker);
+  if (!acc) {
+    return TextLeafPoint();
+  }
+
+  return TextLeafPoint(
+      acc, aDirection == eDirPrevious
+               ? static_cast<int32_t>(nsAccUtils::TextLength(acc)) - 1
+               : 0);
+}
+
+LayoutDeviceIntRect TextLeafPoint::ComputeBoundsFromFrame() const {
+  LocalAccessible* local = mAcc->AsLocal();
+  MOZ_ASSERT(local, "Can't compute bounds in frame from non-local acc");
+  nsIFrame* frame = local->GetFrame();
+  MOZ_ASSERT(frame, "No frame found for acc!");
+
+  if (!frame || !frame->IsTextFrame()) {
+    return local->Bounds();
+  }
+
+  // Substring must be entirely within the same text node.
+  MOZ_ASSERT(frame->IsPrimaryFrame(),
+             "Cannot compute content offset on non-primary frame");
+  nsIFrame::RenderedText text = frame->GetRenderedText(
+      mOffset, mOffset + 1, nsIFrame::TextOffsetType::OffsetsInRenderedText,
+      nsIFrame::TrailingWhitespace::DontTrim);
+  int32_t contentOffset = text.mOffsetWithinNodeText;
+  int32_t contentOffsetInFrame;
+  // Get the right frame continuation -- not really a child, but a sibling of
+  // the primary frame passed in
+  nsresult rv = frame->GetChildFrameContainingOffset(
+      contentOffset, true, &contentOffsetInFrame, &frame);
+  NS_ENSURE_SUCCESS(rv, LayoutDeviceIntRect());
+
+  // Start with this frame's screen rect, which we will shrink based on
+  // the char we care about within it.
+  nsRect frameScreenRect = frame->GetScreenRectInAppUnits();
+
+  // Add the point where the char starts to the frameScreenRect
+  nsPoint frameTextStartPoint;
+  rv = frame->GetPointFromOffset(contentOffset, &frameTextStartPoint);
+  NS_ENSURE_SUCCESS(rv, LayoutDeviceIntRect());
+
+  // Use the next offset to calculate the width
+  // XXX(morgan) does this work for vertical text?
+  nsPoint frameTextEndPoint;
+  rv = frame->GetPointFromOffset(contentOffset + 1, &frameTextEndPoint);
+  NS_ENSURE_SUCCESS(rv, LayoutDeviceIntRect());
+
+  frameScreenRect.SetRectX(
+      frameScreenRect.X() +
+          std::min(frameTextStartPoint.x, frameTextEndPoint.x),
+      mozilla::Abs(frameTextStartPoint.x - frameTextEndPoint.x));
+
+  nsPresContext* presContext = local->Document()->PresContext();
+  return LayoutDeviceIntRect::FromAppUnitsToNearest(
+      frameScreenRect, presContext->AppUnitsPerDevPixel());
+}
+
+/* static */
+nsTArray<int32_t> TextLeafPoint::GetSpellingErrorOffsets(
+    LocalAccessible* aAcc) {
+  nsINode* node = aAcc->GetNode();
+  auto domRanges = FindDOMSpellingErrors(
+      aAcc, 0, nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT);
+  // Our offsets array will contain two offsets for each range: one for the
+  // start, one for the end. That is, the array is of the form:
+  // [r1start, r1end, r2start, r2end, ...]
+  nsTArray<int32_t> offsets(domRanges.Length() * 2);
+  for (nsRange* domRange : domRanges) {
+    if (domRange->GetStartContainer() == node) {
+      offsets.AppendElement(static_cast<int32_t>(ContentToRenderedOffset(
+          aAcc, static_cast<int32_t>(domRange->StartOffset()))));
+    } else {
+      // This range overlaps aAcc, but starts before it.
+      // This can only happen for the first range.
+      MOZ_ASSERT(domRange == *domRanges.begin() && offsets.IsEmpty());
+      // Using -1 here means this won't be treated as the start of a spelling
+      // error range, while still indicating that we're within a spelling error.
+      offsets.AppendElement(-1);
+    }
+    if (domRange->GetEndContainer() == node) {
+      offsets.AppendElement(static_cast<int32_t>(ContentToRenderedOffset(
+          aAcc, static_cast<int32_t>(domRange->EndOffset()))));
+    } else {
+      // This range overlaps aAcc, but ends after it.
+      // This can only happen for the last range.
+      MOZ_ASSERT(domRange == *domRanges.rbegin());
+      // We don't append -1 here because this would just make things harder for
+      // a binary search.
+    }
+  }
+  return offsets;
+}
+
+/* static */
+void TextLeafPoint::UpdateCachedSpellingError(dom::Document* aDocument,
+                                              const nsRange& aRange) {
+  DocAccessible* docAcc = GetExistingDocAccessible(aDocument);
+  if (!docAcc) {
+    return;
+  }
+  LocalAccessible* startAcc = docAcc->GetAccessible(aRange.GetStartContainer());
+  LocalAccessible* endAcc = docAcc->GetAccessible(aRange.GetEndContainer());
+  if (!startAcc || !endAcc) {
+    return;
+  }
+  for (Accessible* acc = startAcc; acc; acc = NextLeaf(acc)) {
+    if (acc->IsTextLeaf()) {
+      docAcc->QueueCacheUpdate(acc->AsLocal(), CacheDomain::Spelling);
+    }
+    if (acc == endAcc) {
+      // Subtle: We check this here rather than in the loop condition because
+      // we want to include endAcc but stop once we reach it. Putting it in the
+      // loop condition would mean we stop at endAcc, but we would also exclude
+      // it; i.e. we wouldn't push the cache for it.
+      break;
+    }
+  }
+}
+
+already_AddRefed<AccAttributes> TextLeafPoint::GetTextAttributesLocalAcc(
+    bool aIncludeDefaults) const {
+  LocalAccessible* acc = mAcc->AsLocal();
+  MOZ_ASSERT(acc);
+  MOZ_ASSERT(acc->IsText());
+  // TextAttrsMgr wants a HyperTextAccessible.
+  LocalAccessible* parent = acc->LocalParent();
+  HyperTextAccessible* hyperAcc = parent->AsHyperText();
+  MOZ_ASSERT(hyperAcc);
+  RefPtr<AccAttributes> attributes = new AccAttributes();
+  if (hyperAcc) {
+    TextAttrsMgr mgr(hyperAcc, aIncludeDefaults, acc,
+                     acc ? acc->IndexInParent() : -1);
+    mgr.GetAttributes(attributes, nullptr, nullptr);
+  }
+  return attributes.forget();
+}
+
+already_AddRefed<AccAttributes> TextLeafPoint::GetTextAttributes(
+    bool aIncludeDefaults) const {
+  if (!mAcc->IsText()) {
+    return nullptr;
+  }
+  RefPtr<AccAttributes> attrs;
+  if (mAcc->IsLocal()) {
+    attrs = GetTextAttributesLocalAcc(aIncludeDefaults);
+  } else {
+    attrs = new AccAttributes();
+    if (aIncludeDefaults) {
+      Accessible* parent = mAcc->Parent();
+      if (parent && parent->IsRemote() && parent->IsHyperText()) {
+        if (auto defAttrs = parent->AsRemote()->GetCachedTextAttributes()) {
+          defAttrs->CopyTo(attrs);
+        }
+      }
+    }
+    if (auto thisAttrs = mAcc->AsRemote()->GetCachedTextAttributes()) {
+      thisAttrs->CopyTo(attrs);
+    }
+  }
+  if (IsInSpellingError()) {
+    attrs->SetAttribute(nsGkAtoms::invalid, nsGkAtoms::spelling);
+  }
+  return attrs.forget();
+}
+
+TextLeafPoint TextLeafPoint::FindTextAttrsStart(nsDirection aDirection,
+                                                bool aIncludeOrigin) const {
+  if (IsCaret()) {
+    return ActualizeCaret().FindTextAttrsStart(aDirection, aIncludeOrigin);
+  }
+  const bool isRemote = mAcc->IsRemote();
+  RefPtr<const AccAttributes> lastAttrs =
+      isRemote ? mAcc->AsRemote()->GetCachedTextAttributes()
+               : GetTextAttributesLocalAcc();
+  if (aIncludeOrigin && aDirection == eDirNext && mOffset == 0) {
+    // Even when searching forward, the only way to know whether the origin is
+    // the start of a text attrs run is to compare with the previous sibling.
+    // Anything other than text breaks an attrs run.
+    TextLeafPoint point;
+    point.mAcc = mAcc->PrevSibling();
+    if (!point.mAcc || !point.mAcc->IsText()) {
+      return *this;
+    }
+    // For RemoteAccessible, we can get attributes from the cache without any
+    // calculation or copying.
+    RefPtr<const AccAttributes> attrs =
+        isRemote ? point.mAcc->AsRemote()->GetCachedTextAttributes()
+                 : point.GetTextAttributesLocalAcc();
+    if (attrs && lastAttrs && !attrs->Equal(lastAttrs)) {
+      return *this;
+    }
+  }
+  TextLeafPoint lastPoint = *this;
+  for (;;) {
+    if (TextLeafPoint spelling = lastPoint.FindSpellingErrorSameAcc(
+            aDirection, aIncludeOrigin && lastPoint.mAcc == mAcc)) {
+      // A spelling error starts or ends somewhere in the Accessible we're
+      // considering. This causes an attribute change, so return that point.
+      return spelling;
+    }
+    TextLeafPoint point;
+    point.mAcc = aDirection == eDirNext ? lastPoint.mAcc->NextSibling()
+                                        : lastPoint.mAcc->PrevSibling();
+    if (!point.mAcc || !point.mAcc->IsText()) {
+      break;
+    }
+    RefPtr<const AccAttributes> attrs =
+        isRemote ? point.mAcc->AsRemote()->GetCachedTextAttributes()
+                 : point.GetTextAttributesLocalAcc();
+    if (attrs && lastAttrs && !attrs->Equal(lastAttrs)) {
+      // The attributes change here. If we're moving forward, we want to
+      // return this point. If we're moving backward, we've now moved before
+      // the start of the attrs run containing the origin, so return that start
+      // point; i.e. the start of the last Accessible we hit.
+      if (aDirection == eDirPrevious) {
+        point = lastPoint;
+        point.mOffset = 0;
+      }
+      if (!aIncludeOrigin && point == *this) {
+        MOZ_ASSERT(aDirection == eDirPrevious);
+        // The origin is the start of an attrs run, but the caller doesn't want
+        // the origin included.
+        continue;
+      }
+      return point;
+    }
+    lastPoint = point;
+    if (aDirection == eDirPrevious) {
+      // On the next iteration, we want to search for spelling errors from the
+      // end of this Accessible.
+      lastPoint.mOffset =
+          static_cast<int32_t>(nsAccUtils::TextLength(point.mAcc));
+    }
+    lastAttrs = attrs;
+  }
+  // We couldn't move any further. Use the start/end.
+  return TextLeafPoint(
+      lastPoint.mAcc,
+      aDirection == eDirPrevious
+          ? 0
+          : static_cast<int32_t>(nsAccUtils::TextLength(lastPoint.mAcc)));
+}
+
+LayoutDeviceIntRect TextLeafPoint::CharBounds() {
+  if (mAcc && !mAcc->IsText()) {
+    // If we're dealing with an empty container, return the
+    // accessible's non-text bounds.
+    return mAcc->Bounds();
+  }
+
+  if (!mAcc || (mAcc->IsRemote() && !mAcc->AsRemote()->mCachedFields)) {
+    return LayoutDeviceIntRect();
+  }
+
+  if (LocalAccessible* local = mAcc->AsLocal()) {
+    if (!local->IsTextLeaf() || nsAccUtils::TextLength(local) == 0) {
+      // Empty content, use our own bounds to at least get x,y coordinates
+      return local->Bounds();
+    }
+
+    if (mOffset >= 0 &&
+        static_cast<uint32_t>(mOffset) >= nsAccUtils::TextLength(local)) {
+      // It's valid for a caller to query the length because the caret might be
+      // at the end of editable text. In that case, we should just silently
+      // return. However, we assert that the offset isn't greater than the
+      // length.
+      NS_ASSERTION(
+          static_cast<uint32_t>(mOffset) <= nsAccUtils::TextLength(local),
+          "Wrong in offset");
+      return LayoutDeviceIntRect();
+    }
+
+    LayoutDeviceIntRect bounds = ComputeBoundsFromFrame();
+
+    // This document may have a resolution set, we will need to multiply
+    // the document-relative coordinates by that value and re-apply the doc's
+    // screen coordinates.
+    nsPresContext* presContext = local->Document()->PresContext();
+    nsIFrame* rootFrame = presContext->PresShell()->GetRootFrame();
+    LayoutDeviceIntRect orgRectPixels =
+        LayoutDeviceIntRect::FromAppUnitsToNearest(
+            rootFrame->GetScreenRectInAppUnits(),
+            presContext->AppUnitsPerDevPixel());
+    bounds.MoveBy(-orgRectPixels.X(), -orgRectPixels.Y());
+    bounds.ScaleRoundOut(presContext->PresShell()->GetResolution());
+    bounds.MoveBy(orgRectPixels.X(), orgRectPixels.Y());
+    return bounds;
+  }
+
+  RemoteAccessible* remote = mAcc->AsRemote();
+  nsRect charBounds = remote->GetCachedCharRect(mOffset);
+  if (!charBounds.IsEmpty()) {
+    return remote->BoundsWithOffset(Some(charBounds));
+  }
+
+  return LayoutDeviceIntRect();
+}
+
+bool TextLeafPoint::ContainsPoint(int32_t aX, int32_t aY) {
+  if (mAcc && !mAcc->IsText()) {
+    // If we're dealing with an empty embedded object, use the
+    // accessible's non-text bounds.
+    return mAcc->Bounds().Contains(aX, aY);
+  }
+
+  return CharBounds().Contains(aX, aY);
+}
+
+bool TextLeafRange::Crop(Accessible* aContainer) {
+  TextLeafPoint containerStart(aContainer, 0);
+  TextLeafPoint containerEnd(aContainer,
+                             nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT);
+
+  if (mEnd < containerStart || containerEnd < mStart) {
+    // The range ends before the container, or starts after it.
+    return false;
+  }
+
+  if (mStart < containerStart) {
+    // If range start is before container start, adjust range start to
+    // start of container.
+    mStart = containerStart;
+  }
+
+  if (containerEnd < mEnd) {
+    // If range end is after container end, adjust range end to end of
+    // container.
+    mEnd = containerEnd;
+  }
+
+  return true;
+}
+
+LayoutDeviceIntRect TextLeafRange::Bounds() const {
+  if (mEnd == mStart || mEnd < mStart) {
+    return LayoutDeviceIntRect();
+  }
+
+  bool locatedFinalLine = false;
+  TextLeafPoint currPoint = mStart;
+  LayoutDeviceIntRect result = currPoint.CharBounds();
+
+  // Union the first and last chars of each line to create a line rect. Then,
+  // union the lines together.
+  while (!locatedFinalLine) {
+    // Fetch the last point in the current line by getting the
+    // start of the next line and going back one char. We don't
+    // use BOUNDARY_LINE_END here because it is equivalent to LINE_START when
+    // the line doesn't end with a line feed character.
+    TextLeafPoint lineStartPoint = currPoint.FindBoundary(
+        nsIAccessibleText::BOUNDARY_LINE_START, eDirNext);
+    TextLeafPoint lastPointInLine = lineStartPoint.FindBoundary(
+        nsIAccessibleText::BOUNDARY_CHAR, eDirPrevious);
+    // If currPoint is the end of the document, lineStartPoint will be equal
+    // to currPoint and we would be in an endless loop.
+    if (lineStartPoint == currPoint || mEnd <= lastPointInLine) {
+      lastPointInLine = mEnd;
+      locatedFinalLine = true;
+    }
+
+    LayoutDeviceIntRect currLine = currPoint.CharBounds();
+    currLine.UnionRect(currLine, lastPointInLine.CharBounds());
+    result.UnionRect(result, currLine);
+
+    currPoint = lineStartPoint;
+  }
+
+  return result;
+}
+
+bool TextLeafRange::SetSelection(int32_t aSelectionNum) const {
+  if (!mStart || !mEnd || mStart.mAcc->IsLocal() != mEnd.mAcc->IsLocal()) {
+    return false;
+  }
+
+  if (mStart.mAcc->IsRemote()) {
+    DocAccessibleParent* doc = mStart.mAcc->AsRemote()->Document();
+    if (doc != mEnd.mAcc->AsRemote()->Document()) {
+      return false;
+    }
+
+    Unused << doc->SendSetTextSelection(mStart.mAcc->ID(), mStart.mOffset,
+                                        mEnd.mAcc->ID(), mEnd.mOffset,
+                                        aSelectionNum);
+    return true;
+  }
+
+  bool reversed = mEnd < mStart;
+  auto [startContent, startContentOffset] =
+      !reversed ? mStart.ToDOMPoint(false) : mEnd.ToDOMPoint(false);
+  auto [endContent, endContentOffset] =
+      !reversed ? mEnd.ToDOMPoint(false) : mStart.ToDOMPoint(false);
+
+  if (!startContent || !endContent) {
+    return false;
+  }
+
+  RefPtr<dom::Selection> domSel = GetDOMSelection(startContent, endContent);
+  if (!domSel) {
+    return false;
+  }
+
+  uint32_t rangeCount = domSel->RangeCount();
+  RefPtr<nsRange> domRange = nullptr;
+  if (aSelectionNum == static_cast<int32_t>(rangeCount) || aSelectionNum < 0) {
+    domRange = nsRange::Create(startContent);
+  } else {
+    domRange = domSel->GetRangeAt(AssertedCast<uint32_t>(aSelectionNum));
+  }
+  if (!domRange) {
+    return false;
+  }
+
+  domRange->SetStart(startContent, startContentOffset);
+  domRange->SetEnd(endContent, endContentOffset);
+
+  // If this is not a new range, notify selection listeners that the existing
+  // selection range has changed. Otherwise, just add the new range.
+  if (aSelectionNum != static_cast<int32_t>(rangeCount)) {
+    domSel->RemoveRangeAndUnselectFramesAndNotifyListeners(*domRange,
+                                                           IgnoreErrors());
+  }
+
+  IgnoredErrorResult err;
+  domSel->AddRangeAndSelectFramesAndNotifyListeners(*domRange, err);
+  if (!err.Failed()) {
+    // Changing the direction of the selection assures that the caret
+    // will be at the logical end of the selection.
+    domSel->SetDirection(reversed ? eDirPrevious : eDirNext);
+    return true;
+  }
+
+  return false;
+}
+
+void TextLeafRange::ScrollIntoView(uint32_t aScrollType) const {
+  if (!mStart || !mEnd || mStart.mAcc->IsLocal() != mEnd.mAcc->IsLocal()) {
+    return;
+  }
+
+  if (mStart.mAcc->IsRemote()) {
+    DocAccessibleParent* doc = mStart.mAcc->AsRemote()->Document();
+    if (doc != mEnd.mAcc->AsRemote()->Document()) {
+      // Can't scroll range that spans docs.
+      return;
+    }
+
+    Unused << doc->SendScrollTextLeafRangeIntoView(
+        mStart.mAcc->ID(), mStart.mOffset, mEnd.mAcc->ID(), mEnd.mOffset,
+        aScrollType);
+    return;
+  }
+
+  auto [startContent, startContentOffset] = mStart.ToDOMPoint();
+  auto [endContent, endContentOffset] = mEnd.ToDOMPoint();
+
+  if (!startContent || !endContent) {
+    return;
+  }
+
+  ErrorResult er;
+  RefPtr<nsRange> domRange = nsRange::Create(startContent, startContentOffset,
+                                             endContent, endContentOffset, er);
+  if (er.Failed()) {
+    return;
+  }
+
+  nsCoreUtils::ScrollSubstringTo(mStart.mAcc->AsLocal()->GetFrame(), domRange,
+                                 aScrollType);
+}
+
+TextLeafRange::Iterator TextLeafRange::Iterator::BeginIterator(
+    const TextLeafRange& aRange) {
+  Iterator result(aRange);
+
+  result.mSegmentStart = aRange.mStart;
+  if (aRange.mStart.mAcc == aRange.mEnd.mAcc) {
+    result.mSegmentEnd = aRange.mEnd;
+  } else {
+    result.mSegmentEnd = TextLeafPoint(
+        aRange.mStart.mAcc, nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT);
+  }
+
+  return result;
+}
+
+TextLeafRange::Iterator TextLeafRange::Iterator::EndIterator(
+    const TextLeafRange& aRange) {
+  Iterator result(aRange);
+
+  result.mSegmentEnd = TextLeafPoint();
+  result.mSegmentStart = TextLeafPoint();
+
+  return result;
+}
+
+TextLeafRange::Iterator& TextLeafRange::Iterator::operator++() {
+  if (mSegmentEnd.mAcc == mRange.mEnd.mAcc) {
+    mSegmentEnd = TextLeafPoint();
+    mSegmentStart = TextLeafPoint();
+    return *this;
+  }
+
+  if (Accessible* nextLeaf = NextLeaf(mSegmentEnd.mAcc)) {
+    mSegmentStart = TextLeafPoint(nextLeaf, 0);
+    if (nextLeaf == mRange.mEnd.mAcc) {
+      mSegmentEnd = TextLeafPoint(nextLeaf, mRange.mEnd.mOffset);
+    } else {
+      mSegmentEnd =
+          TextLeafPoint(nextLeaf, nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT);
+    }
+  } else {
+    mSegmentEnd = TextLeafPoint();
+    mSegmentStart = TextLeafPoint();
+  }
+
+  return *this;
+}
+
+}  // namespace mozilla::a11y
diff --git a/accessible/base/TextLeafRange.h b/accessible/base/TextLeafRange.h
new file mode 100644
index 0000000000..23fea2ecfb
--- /dev/null
+++ b/accessible/base/TextLeafRange.h
@@ -0,0 +1,360 @@
+/* -*- 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_TextLeafRange_h__
+#define mozilla_a11y_TextLeafRange_h__
+
+#include <stdint.h>
+
+#include "AccAttributes.h"
+#include "nsDirection.h"
+#include "nsIAccessibleText.h"
+
+class nsRange;
+
+namespace mozilla {
+namespace dom {
+class Document;
+}
+
+namespace a11y {
+class Accessible;
+class LocalAccessible;
+
+/**
+ * Represents a point within accessible text.
+ * This is stored as a leaf Accessible and an offset into that Accessible.
+ * For an empty Accessible, the offset will always be 0.
+ * This will eventually replace TextPoint. Unlike TextPoint, this does not
+ * use HyperTextAccessible offsets.
+ */
+class TextLeafPoint final {
+ public:
+  TextLeafPoint(Accessible* aAcc, int32_t aOffset);
+
+  /**
+   * Constructs an invalid TextPoint (mAcc is null).
+   * A TextLeafPoint in this state will evaluate to false.
+   * mAcc can be set later. Alternatively, this can be used to indicate an error
+   * (e.g. if a requested point couldn't be found).
+   */
+  TextLeafPoint() : mAcc(nullptr), mOffset(0) {}
+
+  /**
+   * Construct a TextLeafPoint representing the caret.
+   * The actual offset used for the caret differs depending on whether the
+   * caret is at the end of a line and the query being made. Thus, mOffset on
+   * the returned TextLeafPoint is not a valid offset.
+   */
+  static TextLeafPoint GetCaret(Accessible* aAcc) {
+    return TextLeafPoint(aAcc, nsIAccessibleText::TEXT_OFFSET_CARET);
+  }
+
+  Accessible* mAcc;
+  int32_t mOffset;
+
+  bool operator==(const TextLeafPoint& aPoint) const {
+    return mAcc == aPoint.mAcc && mOffset == aPoint.mOffset;
+  }
+
+  bool operator!=(const TextLeafPoint& aPoint) const {
+    return !(*this == aPoint);
+  }
+
+  bool operator<(const TextLeafPoint& aPoint) const;
+
+  bool operator<=(const TextLeafPoint& aPoint) const;
+
+  /**
+   * A valid TextLeafPoint evaluates to true. An invalid TextLeafPoint
+   * evaluates to false.
+   */
+  explicit operator bool() const { return !!mAcc; }
+
+  bool IsCaret() const {
+    return mOffset == nsIAccessibleText::TEXT_OFFSET_CARET;
+  }
+
+  bool IsCaretAtEndOfLine() const;
+
+  /**
+   * Get a TextLeafPoint at the actual caret offset.
+   * This should only be called on a TextLeafPoint created with GetCaret.
+   * If aAdjustAtEndOfLine is true, the point will be adjusted if the caret is
+   * at the end of a line so that word and line boundaries can be calculated
+   * correctly.
+   */
+  TextLeafPoint ActualizeCaret(bool aAdjustAtEndOfLine = true) const;
+
+  enum class BoundaryFlags : uint32_t {
+    eDefaultBoundaryFlags = 0,
+    // Return point unchanged if it is at the given boundary type.
+    eIncludeOrigin = 1 << 0,
+    // If current point is in editable, return point within samme editable.
+    eStopInEditable = 1 << 1,
+    // Skip over list items in searches and don't consider them line or
+    // paragraph starts.
+    eIgnoreListItemMarker = 1 << 2,
+  };
+
+  /**
+   * Find a boundary (word start, line start, etc.) in a specific direction.
+   * If no boundary is found, the start/end of the document is returned
+   * (depending on the direction).
+   */
+  TextLeafPoint FindBoundary(
+      AccessibleTextBoundary aBoundaryType, nsDirection aDirection,
+      BoundaryFlags aFlags = BoundaryFlags::eDefaultBoundaryFlags) const;
+
+  /**
+   * These two functions find a line start boundary within the same
+   * LocalAccessible as this. That is, they do not cross Accessibles. If no
+   * boundary is found, an invalid TextLeafPoint is returned.
+   * These are used by FindBoundary. Most callers will want FindBoundary
+   * instead.
+   */
+  TextLeafPoint FindPrevLineStartSameLocalAcc(bool aIncludeOrigin) const;
+  TextLeafPoint FindNextLineStartSameLocalAcc(bool aIncludeOrigin) const;
+
+  /**
+   * These two functions find a word start boundary within the same
+   * Accessible as this. That is, they do not cross Accessibles. If no
+   * boundary is found, an invalid TextLeafPoint is returned.
+   * These are used by FindBoundary. Most callers will want FindBoundary
+   * instead.
+   */
+  TextLeafPoint FindPrevWordStartSameAcc(bool aIncludeOrigin) const;
+  TextLeafPoint FindNextWordStartSameAcc(bool aIncludeOrigin) const;
+
+  /**
+   * Get the text attributes at this point.
+   * If aIncludeDefaults is true, default attributes on the HyperTextAccessible
+   * will be included.
+   */
+  already_AddRefed<AccAttributes> GetTextAttributes(
+      bool aIncludeDefaults = true) const;
+
+  /**
+   * Get Get the text attributes at this point in a LocalAccessible.
+   * This is used by GetTextAttributes. Most callers will want GetTextAttributes
+   * instead.
+   */
+  already_AddRefed<AccAttributes> GetTextAttributesLocalAcc(
+      bool aIncludeDefaults = true) const;
+
+  /**
+   * Get the offsets of all spelling errors in a given LocalAccessible. This
+   * should only be used when pushing the cache. Most callers will want
+   * FindTextAttrsStart instead.
+   */
+  static nsTArray<int32_t> GetSpellingErrorOffsets(LocalAccessible* aAcc);
+
+  /**
+   * Queue a cache update for a spelling error in a given DOM range.
+   */
+  static void UpdateCachedSpellingError(dom::Document* aDocument,
+                                        const nsRange& aRange);
+
+  /**
+   * Find the start of a run of text attributes in a specific direction.
+   * A text attributes run is a span of text where the attributes are the same.
+   * If no boundary is found, the start/end of the container is returned
+   * (depending on the direction).
+   * If aIncludeorigin is true and this is at a boundary, this will be
+   * returned unchanged.
+   */
+  TextLeafPoint FindTextAttrsStart(nsDirection aDirection,
+                                   bool aIncludeOrigin = false) const;
+
+  /**
+   * Returns a rect (in dev pixels) describing position and size of
+   * the character at mOffset in mAcc. This rect is screen-relative.
+   * This function only works on remote accessibles, and assumes caching
+   * is enabled.
+   */
+  LayoutDeviceIntRect CharBounds();
+
+  /**
+   * Returns true if the given point (in screen coords) is contained
+   * in the char bounds of the current TextLeafPoint. Returns false otherwise.
+   * If the current point is an empty container, we use the acc's bounds instead
+   * of char bounds. Because this depends on CharBounds, this function only
+   * works on remote accessibles, and assumes caching is enabled.
+   */
+  bool ContainsPoint(int32_t aX, int32_t aY);
+
+  bool IsLineFeedChar() const { return GetChar() == '\n'; }
+
+  bool IsSpace() const;
+
+  bool IsParagraphStart(bool aIgnoreListItemMarker = false) const {
+    return mOffset == 0 &&
+           FindParagraphSameAcc(eDirPrevious, true, aIgnoreListItemMarker);
+  }
+
+  /**
+   * Translate given TextLeafPoint into a DOM point.
+   */
+  MOZ_CAN_RUN_SCRIPT std::pair<nsIContent*, int32_t> ToDOMPoint(
+      bool aIncludeGenerated = true) const;
+
+ private:
+  bool IsEmptyLastLine() const;
+
+  bool IsDocEdge(nsDirection aDirection) const;
+
+  bool IsLeafAfterListItemMarker() const;
+
+  char16_t GetChar() const;
+
+  TextLeafPoint FindLineStartSameRemoteAcc(nsDirection aDirection,
+                                           bool aIncludeOrigin) const;
+
+  /**
+   * Helper which just calls the appropriate function based on whether mAcc
+   *is local or remote.
+   */
+  TextLeafPoint FindLineStartSameAcc(nsDirection aDirection,
+                                     bool aIncludeOrigin,
+                                     bool aIgnoreListItemMarker = false) const;
+
+  TextLeafPoint FindLineEnd(nsDirection aDirection, BoundaryFlags aFlags) const;
+  TextLeafPoint FindWordEnd(nsDirection aDirection, BoundaryFlags aFlags) const;
+
+  TextLeafPoint FindParagraphSameAcc(nsDirection aDirection,
+                                     bool aIncludeOrigin,
+                                     bool aIgnoreListItemMarker = false) const;
+
+  bool IsInSpellingError() const;
+
+  /**
+   * Find a spelling error boundary in the same Accessible. This function
+   * searches for either start or end points, since either means a change in
+   * text attributes.
+   */
+  TextLeafPoint FindSpellingErrorSameAcc(nsDirection aDirection,
+                                         bool aIncludeOrigin) const;
+
+  // Return the point immediately succeeding or preceding this leaf depending
+  // on given direction.
+  TextLeafPoint NeighborLeafPoint(nsDirection aDirection, bool aIsEditable,
+                                  bool aIgnoreListItemMarker) const;
+
+  /**
+   * This function assumes mAcc is a LocalAccessible.
+   * It iterates the continuations of mAcc's primary frame until it locates
+   * the continuation containing mOffset (a rendered offset). It then uses
+   * GetScreenRectInAppUnits to compute screen coords for the frame, resizing
+   * such that the resulting rect contains only one character.
+   */
+  LayoutDeviceIntRect ComputeBoundsFromFrame() const;
+};
+
+MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(TextLeafPoint::BoundaryFlags)
+
+/**
+ * Represents a range of accessible text.
+ * This will eventually replace TextRange.
+ */
+class TextLeafRange final {
+ public:
+  TextLeafRange(const TextLeafPoint& aStart, const TextLeafPoint& aEnd)
+      : mStart(aStart), mEnd(aEnd) {}
+  explicit TextLeafRange(const TextLeafPoint& aStart)
+      : mStart(aStart), mEnd(aStart) {}
+  explicit TextLeafRange() {}
+
+  /**
+   * A valid TextLeafRange evaluates to true. An invalid TextLeafRange
+   * evaluates to false.
+   */
+  explicit operator bool() const { return !!mStart && !!mEnd; }
+
+  bool operator!=(const TextLeafRange& aOther) const {
+    return mEnd != aOther.mEnd || mStart != aOther.mStart;
+  }
+
+  bool operator==(const TextLeafRange& aOther) const {
+    return mEnd == aOther.mEnd && mStart == aOther.mStart;
+  }
+
+  TextLeafPoint Start() const { return mStart; }
+  void SetStart(const TextLeafPoint& aStart) { mStart = aStart; }
+  TextLeafPoint End() const { return mEnd; }
+  void SetEnd(const TextLeafPoint& aEnd) { mEnd = aEnd; }
+
+  bool Crop(Accessible* aContainer);
+
+  /**
+   * Returns a union rect (in dev pixels) of all character bounds in this range.
+   * This rect is screen-relative and inclusive of mEnd. This function only
+   * works on remote accessibles, and assumes caching is enabled.
+   */
+  LayoutDeviceIntRect Bounds() const;
+
+  /**
+   * Set range as DOM selection.
+   * aSelectionNum is the selection index to use. If aSelectionNum is
+   * out of bounds for current selection ranges, or is -1, a new selection
+   * range is created.
+   */
+  MOZ_CAN_RUN_SCRIPT bool SetSelection(int32_t aSelectionNum) const;
+
+  MOZ_CAN_RUN_SCRIPT void ScrollIntoView(uint32_t aScrollType) const;
+
+ private:
+  TextLeafPoint mStart;
+  TextLeafPoint mEnd;
+
+ public:
+  /**
+   * A TextLeafRange iterator will iterate through single leaf segments of the
+   * given range.
+   */
+
+  class Iterator {
+   public:
+    Iterator(Iterator&& aOther)
+        : mRange(aOther.mRange),
+          mSegmentStart(aOther.mSegmentStart),
+          mSegmentEnd(aOther.mSegmentEnd) {}
+
+    static Iterator BeginIterator(const TextLeafRange& aRange);
+
+    static Iterator EndIterator(const TextLeafRange& aRange);
+
+    Iterator& operator++();
+
+    bool operator!=(const Iterator& aOther) const {
+      return mRange != aOther.mRange || mSegmentStart != aOther.mSegmentStart ||
+             mSegmentEnd != aOther.mSegmentEnd;
+    }
+
+    TextLeafRange operator*() {
+      return TextLeafRange(mSegmentStart, mSegmentEnd);
+    }
+
+   private:
+    explicit Iterator(const TextLeafRange& aRange) : mRange(aRange) {}
+
+    Iterator() = delete;
+    Iterator(const Iterator&) = delete;
+    Iterator& operator=(const Iterator&) = delete;
+    Iterator& operator=(const Iterator&&) = delete;
+
+    const TextLeafRange& mRange;
+    TextLeafPoint mSegmentStart;
+    TextLeafPoint mSegmentEnd;
+  };
+
+  Iterator begin() const { return Iterator::BeginIterator(*this); }
+  Iterator end() const { return Iterator::EndIterator(*this); }
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/TextRange-inl.h b/accessible/base/TextRange-inl.h
new file mode 100644
index 0000000000..3c53bd5038
--- /dev/null
+++ b/accessible/base/TextRange-inl.h
@@ -0,0 +1,25 @@
+/* -*- 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_TextRange_inl_h__
+#define mozilla_a11y_TextRange_inl_h__
+
+#include "TextRange.h"
+
+namespace mozilla {
+namespace a11y {
+
+inline Accessible* TextRange::Container() const {
+  uint32_t pos1 = 0, pos2 = 0;
+  AutoTArray<Accessible*, 30> parents1, parents2;
+  return CommonParent(mStartContainer, mEndContainer, &parents1, &pos1,
+                      &parents2, &pos2);
+}
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/TextRange.cpp b/accessible/base/TextRange.cpp
new file mode 100644
index 0000000000..15ff8bd05a
--- /dev/null
+++ b/accessible/base/TextRange.cpp
@@ -0,0 +1,376 @@
+/* -*- 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 "TextRange-inl.h"
+
+#include "LocalAccessible-inl.h"
+#include "HyperTextAccessible-inl.h"
+#include "mozilla/IntegerRange.h"
+#include "mozilla/dom/Selection.h"
+#include "nsAccUtils.h"
+
+namespace mozilla {
+namespace a11y {
+
+/**
+ * Returns a text point for aAcc within aContainer.
+ */
+static void ToTextPoint(Accessible* aAcc, Accessible** aContainer,
+                        int32_t* aOffset, bool aIsBefore = true) {
+  if (aAcc->IsHyperText()) {
+    *aContainer = aAcc;
+    *aOffset =
+        aIsBefore
+            ? 0
+            : static_cast<int32_t>(aAcc->AsHyperTextBase()->CharacterCount());
+    return;
+  }
+
+  Accessible* child = nullptr;
+  Accessible* parent = aAcc;
+  do {
+    child = parent;
+    parent = parent->Parent();
+  } while (parent && !parent->IsHyperText());
+
+  if (parent) {
+    *aContainer = parent;
+    *aOffset = parent->AsHyperTextBase()->GetChildOffset(
+        child->IndexInParent() + static_cast<int32_t>(!aIsBefore));
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TextPoint
+
+bool TextPoint::operator<(const TextPoint& aPoint) const {
+  if (mContainer == aPoint.mContainer) return mOffset < aPoint.mOffset;
+
+  // Build the chain of parents
+  Accessible* p1 = mContainer;
+  Accessible* p2 = aPoint.mContainer;
+  AutoTArray<Accessible*, 30> parents1, parents2;
+  do {
+    parents1.AppendElement(p1);
+    p1 = p1->Parent();
+  } while (p1);
+  do {
+    parents2.AppendElement(p2);
+    p2 = p2->Parent();
+  } while (p2);
+
+  // Find where the parent chain differs
+  uint32_t pos1 = parents1.Length(), pos2 = parents2.Length();
+  for (uint32_t len = std::min(pos1, pos2); len > 0; --len) {
+    Accessible* child1 = parents1.ElementAt(--pos1);
+    Accessible* child2 = parents2.ElementAt(--pos2);
+    if (child1 != child2) {
+      return child1->IndexInParent() < child2->IndexInParent();
+    }
+  }
+
+  if (pos1 != 0) {
+    // If parents1 is a superset of parents2 then mContainer is a
+    // descendant of aPoint.mContainer. The next element down in parents1
+    // is mContainer's ancestor that is the child of aPoint.mContainer.
+    // We compare its end offset in aPoint.mContainer with aPoint.mOffset.
+    Accessible* child = parents1.ElementAt(pos1 - 1);
+    MOZ_ASSERT(child->Parent() == aPoint.mContainer);
+    return child->EndOffset() < static_cast<uint32_t>(aPoint.mOffset);
+  }
+
+  if (pos2 != 0) {
+    // If parents2 is a superset of parents1 then aPoint.mContainer is a
+    // descendant of mContainer. The next element down in parents2
+    // is aPoint.mContainer's ancestor that is the child of mContainer.
+    // We compare its start offset in mContainer with mOffset.
+    Accessible* child = parents2.ElementAt(pos2 - 1);
+    MOZ_ASSERT(child->Parent() == mContainer);
+    return static_cast<uint32_t>(mOffset) < child->StartOffset();
+  }
+
+  NS_ERROR("Broken tree?!");
+  return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// TextRange
+
+TextRange::TextRange(Accessible* aRoot, Accessible* aStartContainer,
+                     int32_t aStartOffset, Accessible* aEndContainer,
+                     int32_t aEndOffset)
+    : mRoot(aRoot),
+      mStartContainer(aStartContainer),
+      mEndContainer(aEndContainer),
+      mStartOffset(aStartOffset),
+      mEndOffset(aEndOffset) {}
+
+bool TextRange::Crop(Accessible* aContainer) {
+  uint32_t boundaryPos = 0, containerPos = 0;
+  AutoTArray<Accessible*, 30> boundaryParents, containerParents;
+
+  // Crop the start boundary.
+  Accessible* container = nullptr;
+  HyperTextAccessibleBase* startHyper = mStartContainer->AsHyperTextBase();
+  Accessible* boundary = startHyper->GetChildAtOffset(mStartOffset);
+  if (boundary != aContainer) {
+    CommonParent(boundary, aContainer, &boundaryParents, &boundaryPos,
+                 &containerParents, &containerPos);
+
+    if (boundaryPos == 0) {
+      if (containerPos != 0) {
+        // The container is contained by the start boundary, reduce the range to
+        // the point starting at the container.
+        ToTextPoint(aContainer, &mStartContainer, &mStartOffset);
+      } else {
+        // The start boundary and the container are siblings.
+        container = aContainer;
+      }
+    } else {
+      // The container does not contain the start boundary.
+      boundary = boundaryParents[boundaryPos];
+      container = containerParents[containerPos];
+    }
+
+    if (container) {
+      // If the range start is after the container, then make the range invalid.
+      if (boundary->IndexInParent() > container->IndexInParent()) {
+        return !!(mRoot = nullptr);
+      }
+
+      // If the range starts before the container, then reduce the range to
+      // the point starting at the container.
+      if (boundary->IndexInParent() < container->IndexInParent()) {
+        ToTextPoint(container, &mStartContainer, &mStartOffset);
+      }
+    }
+
+    boundaryParents.SetLengthAndRetainStorage(0);
+    containerParents.SetLengthAndRetainStorage(0);
+  }
+
+  HyperTextAccessibleBase* endHyper = mEndContainer->AsHyperTextBase();
+  boundary = endHyper->GetChildAtOffset(mEndOffset);
+  if (boundary == aContainer) {
+    return true;
+  }
+
+  // Crop the end boundary.
+  container = nullptr;
+  CommonParent(boundary, aContainer, &boundaryParents, &boundaryPos,
+               &containerParents, &containerPos);
+
+  if (boundaryPos == 0) {
+    if (containerPos != 0) {
+      ToTextPoint(aContainer, &mEndContainer, &mEndOffset, false);
+    } else {
+      container = aContainer;
+    }
+  } else {
+    boundary = boundaryParents[boundaryPos];
+    container = containerParents[containerPos];
+  }
+
+  if (!container) {
+    return true;
+  }
+
+  if (boundary->IndexInParent() < container->IndexInParent()) {
+    return !!(mRoot = nullptr);
+  }
+
+  if (boundary->IndexInParent() > container->IndexInParent()) {
+    ToTextPoint(container, &mEndContainer, &mEndOffset, false);
+  }
+
+  return true;
+}
+
+/**
+ * Convert the given DOM point to a DOM point in non-generated contents.
+ *
+ * If aDOMPoint is in ::before, the result is immediately after it.
+ * If aDOMPoint is in ::after, the result is immediately before it.
+ */
+static DOMPoint ClosestNotGeneratedDOMPoint(const DOMPoint& aDOMPoint,
+                                            nsIContent* aElementContent) {
+  MOZ_ASSERT(aDOMPoint.node, "The node must not be null");
+
+  // ::before pseudo element
+  if (aElementContent &&
+      aElementContent->IsGeneratedContentContainerForBefore()) {
+    MOZ_ASSERT(aElementContent->GetParent(),
+               "::before must have parent element");
+    // The first child of its parent (i.e., immediately after the ::before) is
+    // good point for a DOM range.
+    return DOMPoint(aElementContent->GetParent(), 0);
+  }
+
+  // ::after pseudo element
+  if (aElementContent &&
+      aElementContent->IsGeneratedContentContainerForAfter()) {
+    MOZ_ASSERT(aElementContent->GetParent(),
+               "::after must have parent element");
+    // The end of its parent (i.e., immediately before the ::after) is good
+    // point for a DOM range.
+    return DOMPoint(aElementContent->GetParent(),
+                    aElementContent->GetParent()->GetChildCount());
+  }
+
+  return aDOMPoint;
+}
+
+/**
+ * GetElementAsContentOf() returns a content representing an element which is
+ * or includes aNode.
+ *
+ * XXX This method is enough to retrieve ::before or ::after pseudo element.
+ *     So, if you want to use this for other purpose, you might need to check
+ *     ancestors too.
+ */
+static nsIContent* GetElementAsContentOf(nsINode* aNode) {
+  if (auto* element = dom::Element::FromNode(aNode)) {
+    return element;
+  }
+  return aNode->GetParentElement();
+}
+
+bool TextRange::AssignDOMRange(nsRange* aRange, bool* aReversed) const {
+  MOZ_ASSERT(mRoot->IsLocal(), "Not supported for RemoteAccessible");
+  bool reversed = EndPoint() < StartPoint();
+  if (aReversed) {
+    *aReversed = reversed;
+  }
+
+  HyperTextAccessible* startHyper = mStartContainer->AsLocal()->AsHyperText();
+  HyperTextAccessible* endHyper = mEndContainer->AsLocal()->AsHyperText();
+  DOMPoint startPoint = reversed ? endHyper->OffsetToDOMPoint(mEndOffset)
+                                 : startHyper->OffsetToDOMPoint(mStartOffset);
+  if (!startPoint.node) {
+    return false;
+  }
+
+  // HyperTextAccessible manages pseudo elements generated by ::before or
+  // ::after.  However, contents of them are not in the DOM tree normally.
+  // Therefore, they are not selectable and editable.  So, when this creates
+  // a DOM range, it should not start from nor end in any pseudo contents.
+
+  nsIContent* container = GetElementAsContentOf(startPoint.node);
+  DOMPoint startPointForDOMRange =
+      ClosestNotGeneratedDOMPoint(startPoint, container);
+  aRange->SetStart(startPointForDOMRange.node, startPointForDOMRange.idx);
+
+  // If the caller wants collapsed range, let's collapse the range to its start.
+  if (mEndContainer == mStartContainer && mEndOffset == mStartOffset) {
+    aRange->Collapse(true);
+    return true;
+  }
+
+  DOMPoint endPoint = reversed ? startHyper->OffsetToDOMPoint(mStartOffset)
+                               : endHyper->OffsetToDOMPoint(mEndOffset);
+  if (!endPoint.node) {
+    return false;
+  }
+
+  if (startPoint.node != endPoint.node) {
+    container = GetElementAsContentOf(endPoint.node);
+  }
+
+  DOMPoint endPointForDOMRange =
+      ClosestNotGeneratedDOMPoint(endPoint, container);
+  aRange->SetEnd(endPointForDOMRange.node, endPointForDOMRange.idx);
+  return true;
+}
+
+void TextRange::TextRangesFromSelection(dom::Selection* aSelection,
+                                        nsTArray<TextRange>* aRanges) {
+  MOZ_ASSERT(aRanges->Length() == 0, "TextRange array supposed to be empty");
+
+  aRanges->SetCapacity(aSelection->RangeCount());
+
+  const uint32_t rangeCount = aSelection->RangeCount();
+  for (const uint32_t idx : IntegerRange(rangeCount)) {
+    MOZ_ASSERT(aSelection->RangeCount() == rangeCount);
+    const nsRange* DOMRange = aSelection->GetRangeAt(idx);
+    MOZ_ASSERT(DOMRange);
+    HyperTextAccessible* startContainer =
+        nsAccUtils::GetTextContainer(DOMRange->GetStartContainer());
+    HyperTextAccessible* endContainer =
+        nsAccUtils::GetTextContainer(DOMRange->GetEndContainer());
+    HyperTextAccessible* commonAncestor = nsAccUtils::GetTextContainer(
+        DOMRange->GetClosestCommonInclusiveAncestor());
+    if (!startContainer || !endContainer) {
+      continue;
+    }
+
+    int32_t startOffset = startContainer->DOMPointToOffset(
+        DOMRange->GetStartContainer(), DOMRange->StartOffset(), false);
+    int32_t endOffset = endContainer->DOMPointToOffset(
+        DOMRange->GetEndContainer(), DOMRange->EndOffset(), true);
+
+    TextRange tr(commonAncestor && commonAncestor->IsTextField()
+                     ? commonAncestor
+                     : startContainer->Document(),
+                 startContainer, startOffset, endContainer, endOffset);
+    *(aRanges->AppendElement()) = std::move(tr);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// pivate
+
+void TextRange::Set(Accessible* aRoot, Accessible* aStartContainer,
+                    int32_t aStartOffset, Accessible* aEndContainer,
+                    int32_t aEndOffset) {
+  mRoot = aRoot;
+  mStartContainer = aStartContainer;
+  mEndContainer = aEndContainer;
+  mStartOffset = aStartOffset;
+  mEndOffset = aEndOffset;
+}
+
+Accessible* TextRange::CommonParent(Accessible* aAcc1, Accessible* aAcc2,
+                                    nsTArray<Accessible*>* aParents1,
+                                    uint32_t* aPos1,
+                                    nsTArray<Accessible*>* aParents2,
+                                    uint32_t* aPos2) const {
+  if (aAcc1 == aAcc2) {
+    return aAcc1;
+  }
+
+  MOZ_ASSERT(aParents1->Length() == 0 || aParents2->Length() == 0,
+             "Wrong arguments");
+
+  // Build the chain of parents.
+  Accessible* p1 = aAcc1;
+  Accessible* p2 = aAcc2;
+  do {
+    aParents1->AppendElement(p1);
+    p1 = p1->Parent();
+  } while (p1);
+  do {
+    aParents2->AppendElement(p2);
+    p2 = p2->Parent();
+  } while (p2);
+
+  // Find where the parent chain differs
+  *aPos1 = aParents1->Length();
+  *aPos2 = aParents2->Length();
+  Accessible* parent = nullptr;
+  uint32_t len = 0;
+  for (len = std::min(*aPos1, *aPos2); len > 0; --len) {
+    Accessible* child1 = aParents1->ElementAt(--(*aPos1));
+    Accessible* child2 = aParents2->ElementAt(--(*aPos2));
+    if (child1 != child2) break;
+
+    parent = child1;
+  }
+
+  return parent;
+}
+
+}  // namespace a11y
+}  // namespace mozilla
diff --git a/accessible/base/TextRange.h b/accessible/base/TextRange.h
new file mode 100644
index 0000000000..121dbe8399
--- /dev/null
+++ b/accessible/base/TextRange.h
@@ -0,0 +1,164 @@
+/* -*- 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_TextRange_h__
+#define mozilla_a11y_TextRange_h__
+
+#include <utility>
+
+#include "nsTArray.h"
+
+class nsRange;
+
+namespace mozilla {
+namespace dom {
+class Selection;
+}  // namespace dom
+namespace a11y {
+
+class Accessible;
+class LocalAccessible;
+
+/**
+ * A text point (HyperText + offset), represents a boundary of text range.
+ * In new code, This should only be used when you explicitly need to deal with
+ * HyperText containers and offsets, including embedded objects; e.g. for
+ * IAccessible2 and ATK. Otherwise, use TextLeafPoint instead.
+ */
+struct TextPoint final {
+  TextPoint(Accessible* aContainer, int32_t aOffset)
+      : mContainer(aContainer), mOffset(aOffset) {}
+  TextPoint(const TextPoint& aPoint)
+      : mContainer(aPoint.mContainer), mOffset(aPoint.mOffset) {}
+
+  Accessible* mContainer;
+  int32_t mOffset;
+
+  bool operator==(const TextPoint& aPoint) const {
+    return mContainer == aPoint.mContainer && mOffset == aPoint.mOffset;
+  }
+  bool operator<(const TextPoint& aPoint) const;
+};
+
+/**
+ * Represents a HyperText range within the text control or document.
+ * In new code, This should only be used when you explicitly need to deal with
+ * HyperText containers and offsets, including embedded objects; e.g. for
+ * IAccessible2 and ATK. Otherwise, use TextLeafRange instead.
+ */
+class TextRange final {
+ public:
+  TextRange(Accessible* aRoot, Accessible* aStartContainer,
+            int32_t aStartOffset, Accessible* aEndContainer,
+            int32_t aEndOffset);
+  TextRange() : mStartOffset{0}, mEndOffset{0} {}
+  TextRange(TextRange&& aRange)
+      : mRoot(std::move(aRange.mRoot)),
+        mStartContainer(std::move(aRange.mStartContainer)),
+        mEndContainer(std::move(aRange.mEndContainer)),
+        mStartOffset(aRange.mStartOffset),
+        mEndOffset(aRange.mEndOffset) {}
+
+  TextRange& operator=(TextRange&& aRange) {
+    mRoot = std::move(aRange.mRoot);
+    mStartContainer = std::move(aRange.mStartContainer);
+    mEndContainer = std::move(aRange.mEndContainer);
+    mStartOffset = aRange.mStartOffset;
+    mEndOffset = aRange.mEndOffset;
+    return *this;
+  }
+
+  Accessible* Root() { return mRoot; }
+  Accessible* StartContainer() const { return mStartContainer; }
+  int32_t StartOffset() const { return mStartOffset; }
+  Accessible* EndContainer() const { return mEndContainer; }
+  int32_t EndOffset() const { return mEndOffset; }
+
+  bool operator==(const TextRange& aRange) const {
+    return mStartContainer == aRange.mStartContainer &&
+           mStartOffset == aRange.mStartOffset &&
+           mEndContainer == aRange.mEndContainer &&
+           mEndOffset == aRange.mEndOffset;
+  }
+
+  TextPoint StartPoint() const {
+    return TextPoint(mStartContainer, mStartOffset);
+  }
+  TextPoint EndPoint() const { return TextPoint(mEndContainer, mEndOffset); }
+
+  /**
+   * Return a container containing both start and end points.
+   */
+  Accessible* Container() const;
+
+  /**
+   * Crops the range if it overlaps the given accessible element boundaries,
+   * returns true if the range was cropped successfully.
+   */
+  bool Crop(Accessible* aContainer);
+
+  /**
+   * Convert stored hypertext offsets into DOM offsets and assign it to DOM
+   * range.
+   *
+   * Note that if start and/or end accessible offsets are in generated content
+   * such as ::before or
+   * ::after, the result range excludes the generated content.  See also
+   * ClosestNotGeneratedDOMPoint() for more information.
+   *
+   * @param  aRange        [in, out] the range whose bounds to set
+   * @param  aReversed     [out] whether the start/end offsets were reversed.
+   * @return true   if conversion was successful
+   */
+  bool AssignDOMRange(nsRange* aRange, bool* aReversed = nullptr) const;
+
+  /**
+   * Return true if this TextRange object represents an actual range of text.
+   */
+  bool IsValid() const { return mRoot; }
+
+  void SetStartPoint(Accessible* aContainer, int32_t aOffset) {
+    mStartContainer = aContainer;
+    mStartOffset = aOffset;
+  }
+  void SetEndPoint(Accessible* aContainer, int32_t aOffset) {
+    mStartContainer = aContainer;
+    mStartOffset = aOffset;
+  }
+
+  static void TextRangesFromSelection(dom::Selection* aSelection,
+                                      nsTArray<TextRange>* aRanges);
+
+ private:
+  TextRange(const TextRange& aRange) = delete;
+  TextRange& operator=(const TextRange& aRange) = delete;
+
+  friend class HyperTextAccessible;
+  friend class xpcAccessibleTextRange;
+
+  void Set(Accessible* aRoot, Accessible* aStartContainer, int32_t aStartOffset,
+           Accessible* aEndContainer, int32_t aEndOffset);
+
+  /**
+   * A helper method returning a common parent for two given accessible
+   * elements.
+   */
+  Accessible* CommonParent(Accessible* aAcc1, Accessible* aAcc2,
+                           nsTArray<Accessible*>* aParents1, uint32_t* aPos1,
+                           nsTArray<Accessible*>* aParents2,
+                           uint32_t* aPos2) const;
+
+  Accessible* mRoot;
+  Accessible* mStartContainer;
+  Accessible* mEndContainer;
+  int32_t mStartOffset;
+  int32_t mEndOffset;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/TextUpdater.cpp b/accessible/base/TextUpdater.cpp
new file mode 100644
index 0000000000..29f8ac11f3
--- /dev/null
+++ b/accessible/base/TextUpdater.cpp
@@ -0,0 +1,215 @@
+/* -*- 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 "TextUpdater.h"
+
+#include "CacheConstants.h"
+#include "DocAccessible-inl.h"
+#include "TextLeafAccessible.h"
+#include <algorithm>
+
+using namespace mozilla::a11y;
+
+void TextUpdater::Run(DocAccessible* aDocument, TextLeafAccessible* aTextLeaf,
+                      const nsAString& aNewText) {
+  NS_ASSERTION(aTextLeaf, "No text leaf accessible?");
+
+  const nsString& oldText = aTextLeaf->Text();
+  uint32_t oldLen = oldText.Length(), newLen = aNewText.Length();
+  uint32_t minLen = std::min(oldLen, newLen);
+
+  // Skip coinciding begin substrings.
+  uint32_t skipStart = 0;
+  for (; skipStart < minLen; skipStart++) {
+    if (aNewText[skipStart] != oldText[skipStart]) break;
+  }
+
+  // The text was changed. Do update.
+  if (skipStart != minLen || oldLen != newLen) {
+    TextUpdater updater(aDocument, aTextLeaf);
+    updater.DoUpdate(aNewText, oldText, skipStart);
+    aDocument->QueueCacheUpdate(aTextLeaf, CacheDomain::Text);
+  }
+}
+
+void TextUpdater::DoUpdate(const nsAString& aNewText, const nsAString& aOldText,
+                           uint32_t aSkipStart) {
+  LocalAccessible* parent = mTextLeaf->LocalParent();
+  if (!parent) return;
+
+  mHyperText = parent->AsHyperText();
+  if (!mHyperText) {
+    MOZ_ASSERT_UNREACHABLE("Text leaf parent is not hypertext!");
+    return;
+  }
+
+  // Get the text leaf accessible offset and invalidate cached offsets after it.
+  mTextOffset = mHyperText->GetChildOffset(mTextLeaf, true);
+  NS_ASSERTION(mTextOffset != -1, "Text leaf hasn't offset within hyper text!");
+
+  // Don't bother diffing if the hypertext isn't editable. Diffing non-editable
+  // text can lead to weird screen reader results with live regions, e.g.,
+  // changing "text" to "testing" might read the diff "s ing" when we'd really
+  // just like to hear "testing."
+  if (!mHyperText->IsEditable()) {
+    // Fire text change event for removal.
+    RefPtr<AccEvent> textRemoveEvent =
+        new AccTextChangeEvent(mHyperText, mTextOffset, aOldText, false);
+    mDocument->FireDelayedEvent(textRemoveEvent);
+
+    // Fire text change event for insertion if there's text to insert.
+    if (!aNewText.IsEmpty()) {
+      RefPtr<AccEvent> textInsertEvent =
+          new AccTextChangeEvent(mHyperText, mTextOffset, aNewText, true);
+      mDocument->FireDelayedEvent(textInsertEvent);
+    }
+
+    mDocument->MaybeNotifyOfValueChange(mHyperText);
+
+    // Update the text.
+    mTextLeaf->SetText(aNewText);
+    return;
+  }
+
+  uint32_t oldLen = aOldText.Length(), newLen = aNewText.Length();
+  uint32_t minLen = std::min(oldLen, newLen);
+
+  // Trim coinciding substrings from the end.
+  uint32_t skipEnd = 0;
+  while (minLen - skipEnd > aSkipStart &&
+         aNewText[newLen - skipEnd - 1] == aOldText[oldLen - skipEnd - 1]) {
+    skipEnd++;
+  }
+
+  uint32_t strLen1 = oldLen - aSkipStart - skipEnd;
+  uint32_t strLen2 = newLen - aSkipStart - skipEnd;
+
+  const nsAString& str1 = Substring(aOldText, aSkipStart, strLen1);
+  const nsAString& str2 = Substring(aNewText, aSkipStart, strLen2);
+
+  // Increase offset of the text leaf on skipped characters amount.
+  mTextOffset += aSkipStart;
+
+  // It could be single insertion or removal or the case of long strings. Do not
+  // calculate the difference between long strings and prefer to fire pair of
+  // insert/remove events as the old string was replaced on the new one.
+  if (strLen1 == 0 || strLen2 == 0 || strLen1 > kMaxStrLen ||
+      strLen2 > kMaxStrLen) {
+    if (strLen1 > 0) {
+      // Fire text change event for removal.
+      RefPtr<AccEvent> textRemoveEvent =
+          new AccTextChangeEvent(mHyperText, mTextOffset, str1, false);
+      mDocument->FireDelayedEvent(textRemoveEvent);
+    }
+
+    if (strLen2 > 0) {
+      // Fire text change event for insertion.
+      RefPtr<AccEvent> textInsertEvent =
+          new AccTextChangeEvent(mHyperText, mTextOffset, str2, true);
+      mDocument->FireDelayedEvent(textInsertEvent);
+    }
+
+    mDocument->MaybeNotifyOfValueChange(mHyperText);
+
+    // Update the text.
+    mTextLeaf->SetText(aNewText);
+    return;
+  }
+
+  // Otherwise find the difference between strings and fire events.
+  // Note: we can skip initial and final coinciding characters since they don't
+  // affect the Levenshtein distance.
+
+  // Compute the flat structured matrix need to compute the difference.
+  uint32_t len1 = strLen1 + 1, len2 = strLen2 + 1;
+  uint32_t* entries = new uint32_t[len1 * len2];
+
+  for (uint32_t colIdx = 0; colIdx < len1; colIdx++) entries[colIdx] = colIdx;
+
+  uint32_t* row = entries;
+  for (uint32_t rowIdx = 1; rowIdx < len2; rowIdx++) {
+    uint32_t* prevRow = row;
+    row += len1;
+    row[0] = rowIdx;
+    for (uint32_t colIdx = 1; colIdx < len1; colIdx++) {
+      if (str1[colIdx - 1] != str2[rowIdx - 1]) {
+        uint32_t left = row[colIdx - 1];
+        uint32_t up = prevRow[colIdx];
+        uint32_t upleft = prevRow[colIdx - 1];
+        row[colIdx] = std::min(upleft, std::min(left, up)) + 1;
+      } else {
+        row[colIdx] = prevRow[colIdx - 1];
+      }
+    }
+  }
+
+  // Compute events based on the difference.
+  nsTArray<RefPtr<AccEvent> > events;
+  ComputeTextChangeEvents(str1, str2, entries, events);
+
+  delete[] entries;
+
+  // Fire events.
+  for (int32_t idx = events.Length() - 1; idx >= 0; idx--) {
+    mDocument->FireDelayedEvent(events[idx]);
+  }
+
+  mDocument->MaybeNotifyOfValueChange(mHyperText);
+
+  // Update the text.
+  mTextLeaf->SetText(aNewText);
+}
+
+void TextUpdater::ComputeTextChangeEvents(
+    const nsAString& aStr1, const nsAString& aStr2, uint32_t* aEntries,
+    nsTArray<RefPtr<AccEvent> >& aEvents) {
+  int32_t colIdx = aStr1.Length(), rowIdx = aStr2.Length();
+
+  // Point at which strings last matched.
+  int32_t colEnd = colIdx;
+  int32_t rowEnd = rowIdx;
+
+  int32_t colLen = colEnd + 1;
+  uint32_t* row = aEntries + rowIdx * colLen;
+  uint32_t dist = row[colIdx];  // current Levenshtein distance
+  while (rowIdx && colIdx) {    // stop when we can't move diagonally
+    if (aStr1[colIdx - 1] == aStr2[rowIdx - 1]) {  // match
+      if (rowIdx < rowEnd) {  // deal with any pending insertion
+        FireInsertEvent(Substring(aStr2, rowIdx, rowEnd - rowIdx), rowIdx,
+                        aEvents);
+      }
+      if (colIdx < colEnd) {  // deal with any pending deletion
+        FireDeleteEvent(Substring(aStr1, colIdx, colEnd - colIdx), rowIdx,
+                        aEvents);
+      }
+
+      colEnd = --colIdx;  // reset the match point
+      rowEnd = --rowIdx;
+      row -= colLen;
+      continue;
+    }
+    --dist;
+    if (dist == row[colIdx - 1 - colLen]) {  // substitution
+      --colIdx;
+      --rowIdx;
+      row -= colLen;
+      continue;
+    }
+    if (dist == row[colIdx - colLen]) {  // insertion
+      --rowIdx;
+      row -= colLen;
+      continue;
+    }
+    if (dist == row[colIdx - 1]) {  // deletion
+      --colIdx;
+      continue;
+    }
+    MOZ_ASSERT_UNREACHABLE("huh?");
+    return;
+  }
+
+  if (rowEnd) FireInsertEvent(Substring(aStr2, 0, rowEnd), 0, aEvents);
+  if (colEnd) FireDeleteEvent(Substring(aStr1, 0, colEnd), 0, aEvents);
+}
diff --git a/accessible/base/TextUpdater.h b/accessible/base/TextUpdater.h
new file mode 100644
index 0000000000..87905cf082
--- /dev/null
+++ b/accessible/base/TextUpdater.h
@@ -0,0 +1,95 @@
+/* -*- 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_TextUpdater_h__
+#define mozilla_a11y_TextUpdater_h__
+
+#include "AccEvent.h"
+#include "HyperTextAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+/**
+ * Used to find a difference between old and new text and fire text change
+ * events.
+ */
+class TextUpdater {
+ public:
+  /**
+   * Start text of the text leaf update.
+   */
+  static void Run(DocAccessible* aDocument, TextLeafAccessible* aTextLeaf,
+                  const nsAString& aNewText);
+
+ private:
+  TextUpdater(DocAccessible* aDocument, TextLeafAccessible* aTextLeaf)
+      : mDocument(aDocument),
+        mTextLeaf(aTextLeaf),
+        mHyperText(nullptr),
+        mTextOffset(-1) {}
+
+  ~TextUpdater() {
+    mDocument = nullptr;
+    mTextLeaf = nullptr;
+    mHyperText = nullptr;
+  }
+
+  /**
+   * Update text of the text leaf accessible, fire text change and value change
+   * (if applicable) events for its container hypertext accessible.
+   */
+  void DoUpdate(const nsAString& aNewText, const nsAString& aOldText,
+                uint32_t aSkipStart);
+
+ private:
+  TextUpdater();
+  TextUpdater(const TextUpdater&);
+  TextUpdater& operator=(const TextUpdater&);
+
+  /**
+   * Fire text change events based on difference between strings.
+   */
+  void ComputeTextChangeEvents(const nsAString& aStr1, const nsAString& aStr2,
+                               uint32_t* aEntries,
+                               nsTArray<RefPtr<AccEvent> >& aEvents);
+
+  /**
+   * Helper to create text change events for inserted text.
+   */
+  inline void FireInsertEvent(const nsAString& aText, uint32_t aAddlOffset,
+                              nsTArray<RefPtr<AccEvent> >& aEvents) {
+    RefPtr<AccEvent> event = new AccTextChangeEvent(
+        mHyperText, mTextOffset + aAddlOffset, aText, true);
+    aEvents.AppendElement(event);
+  }
+
+  /**
+   * Helper to create text change events for removed text.
+   */
+  inline void FireDeleteEvent(const nsAString& aText, uint32_t aAddlOffset,
+                              nsTArray<RefPtr<AccEvent> >& aEvents) {
+    RefPtr<AccEvent> event = new AccTextChangeEvent(
+        mHyperText, mTextOffset + aAddlOffset, aText, false);
+    aEvents.AppendElement(event);
+  }
+
+  /**
+   * The constant used to skip string difference calculation in case of long
+   * strings.
+   */
+  const static uint32_t kMaxStrLen = 1 << 6;
+
+ private:
+  DocAccessible* mDocument;
+  TextLeafAccessible* mTextLeaf;
+  HyperTextAccessible* mHyperText;
+  int32_t mTextOffset;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/TreeWalker.cpp b/accessible/base/TreeWalker.cpp
new file mode 100644
index 0000000000..ff314bd83c
--- /dev/null
+++ b/accessible/base/TreeWalker.cpp
@@ -0,0 +1,348 @@
+/* -*- 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 "TreeWalker.h"
+
+#include "nsAccessibilityService.h"
+#include "DocAccessible.h"
+
+#include "mozilla/dom/ChildIterator.h"
+#include "mozilla/dom/Element.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// TreeWalker
+////////////////////////////////////////////////////////////////////////////////
+
+TreeWalker::TreeWalker(LocalAccessible* aContext)
+    : mDoc(aContext->Document()),
+      mContext(aContext),
+      mAnchorNode(nullptr),
+      mARIAOwnsIdx(0),
+      mChildFilter(nsIContent::eSkipPlaceholderContent),
+      mFlags(0),
+      mPhase(eAtStart) {
+  mChildFilter |= nsIContent::eAllChildren;
+
+  mAnchorNode = mContext->IsDoc() ? mDoc->DocumentNode()->GetRootElement()
+                                  : mContext->GetContent();
+
+  MOZ_COUNT_CTOR(TreeWalker);
+}
+
+TreeWalker::TreeWalker(LocalAccessible* aContext, nsIContent* aAnchorNode,
+                       uint32_t aFlags)
+    : mDoc(aContext->Document()),
+      mContext(aContext),
+      mAnchorNode(aAnchorNode),
+      mARIAOwnsIdx(0),
+      mChildFilter(nsIContent::eSkipPlaceholderContent),
+      mFlags(aFlags),
+      mPhase(eAtStart) {
+  MOZ_ASSERT(mFlags & eWalkCache,
+             "This constructor cannot be used for tree creation");
+  MOZ_ASSERT(aAnchorNode, "No anchor node for the accessible tree walker");
+
+  mChildFilter |= nsIContent::eAllChildren;
+
+  MOZ_COUNT_CTOR(TreeWalker);
+}
+
+TreeWalker::TreeWalker(DocAccessible* aDocument, nsIContent* aAnchorNode)
+    : mDoc(aDocument),
+      mContext(nullptr),
+      mAnchorNode(aAnchorNode),
+      mARIAOwnsIdx(0),
+      mChildFilter(nsIContent::eSkipPlaceholderContent |
+                   nsIContent::eAllChildren),
+      mFlags(eWalkCache),
+      mPhase(eAtStart) {
+  MOZ_ASSERT(aAnchorNode, "No anchor node for the accessible tree walker");
+  MOZ_COUNT_CTOR(TreeWalker);
+}
+
+TreeWalker::~TreeWalker() { MOZ_COUNT_DTOR(TreeWalker); }
+
+LocalAccessible* TreeWalker::Scope(nsIContent* aAnchorNode) {
+  Reset();
+
+  mAnchorNode = aAnchorNode;
+
+  mFlags |= eScoped;
+
+  bool skipSubtree = false;
+  LocalAccessible* acc = AccessibleFor(aAnchorNode, 0, &skipSubtree);
+  if (acc) {
+    mPhase = eAtEnd;
+    return acc;
+  }
+
+  return skipSubtree ? nullptr : Next();
+}
+
+bool TreeWalker::Seek(nsIContent* aChildNode) {
+  MOZ_ASSERT(aChildNode, "Child cannot be null");
+
+  Reset();
+
+  if (mAnchorNode == aChildNode) {
+    return true;
+  }
+
+  nsIContent* childNode = nullptr;
+  nsINode* parentNode = aChildNode;
+  do {
+    childNode = parentNode->AsContent();
+    parentNode = childNode->GetFlattenedTreeParent();
+
+    // Handle the special case of XBL binding child under a shadow root.
+    if (parentNode && parentNode->IsShadowRoot()) {
+      parentNode = childNode->GetFlattenedTreeParent();
+      if (parentNode == mAnchorNode) {
+        return true;
+      }
+      continue;
+    }
+
+    if (!parentNode || !parentNode->IsElement()) {
+      return false;
+    }
+
+    // If ARIA owned child.
+    LocalAccessible* child = mDoc->GetAccessible(childNode);
+    if (child && child->IsRelocated()) {
+      MOZ_ASSERT(
+          !(mFlags & eScoped),
+          "Walker should not be scoped when seeking into relocated children");
+      if (child->LocalParent() != mContext) {
+        return false;
+      }
+
+      LocalAccessible* ownedChild = nullptr;
+      while ((ownedChild = mDoc->ARIAOwnedAt(mContext, mARIAOwnsIdx++)) &&
+             ownedChild != child) {
+        ;
+      }
+
+      MOZ_ASSERT(ownedChild, "A child has to be in ARIA owned elements");
+      mPhase = eAtARIAOwns;
+      return true;
+    }
+
+    // Look in DOM.
+    dom::AllChildrenIterator* iter =
+        PrependState(parentNode->AsElement(), true);
+    if (!iter->Seek(childNode)) {
+      return false;
+    }
+
+    if (parentNode == mAnchorNode) {
+      mPhase = eAtDOM;
+      return true;
+    }
+  } while (true);
+
+  MOZ_ASSERT_UNREACHABLE("because the do-while loop never breaks");
+}
+
+LocalAccessible* TreeWalker::Next() {
+  if (mStateStack.IsEmpty()) {
+    if (mPhase == eAtEnd) {
+      return nullptr;
+    }
+
+    if (mPhase == eAtDOM || mPhase == eAtARIAOwns) {
+      if (!(mFlags & eScoped)) {
+        mPhase = eAtARIAOwns;
+        LocalAccessible* child = mDoc->ARIAOwnedAt(mContext, mARIAOwnsIdx);
+        if (child) {
+          mARIAOwnsIdx++;
+          return child;
+        }
+      }
+      MOZ_ASSERT(!(mFlags & eScoped) || mPhase != eAtARIAOwns,
+                 "Don't walk relocated children in scoped mode");
+      mPhase = eAtEnd;
+      return nullptr;
+    }
+
+    if (!mAnchorNode) {
+      mPhase = eAtEnd;
+      return nullptr;
+    }
+
+    mPhase = eAtDOM;
+    PushState(mAnchorNode, true);
+  }
+
+  dom::AllChildrenIterator* top = &mStateStack[mStateStack.Length() - 1];
+  while (top) {
+    while (nsIContent* childNode = top->GetNextChild()) {
+      bool skipSubtree = false;
+      LocalAccessible* child = AccessibleFor(childNode, mFlags, &skipSubtree);
+      if (child) {
+        return child;
+      }
+
+      // Walk down the subtree if allowed.
+      if (!skipSubtree && childNode->IsElement()) {
+        top = PushState(childNode, true);
+      }
+    }
+    top = PopState();
+  }
+
+  // If we traversed the whole subtree of the anchor node. Move to next node
+  // relative anchor node within the context subtree if asked.
+  if (mFlags != eWalkContextTree) {
+    // eWalkCache flag presence indicates that the search is scoped to the
+    // anchor (no ARIA owns stuff).
+    if (mFlags & eWalkCache) {
+      mPhase = eAtEnd;
+      return nullptr;
+    }
+    return Next();
+  }
+
+  nsINode* contextNode = mContext->GetNode();
+  while (mAnchorNode != contextNode) {
+    nsINode* parentNode = mAnchorNode->GetFlattenedTreeParent();
+    if (!parentNode || !parentNode->IsElement()) return nullptr;
+
+    nsIContent* parent = parentNode->AsElement();
+    top = PushState(parent, true);
+    if (top->Seek(mAnchorNode)) {
+      mAnchorNode = parent;
+      return Next();
+    }
+
+    // XXX We really should never get here, it means we're trying to find an
+    // accessible for a dom node where iterating over its parent's children
+    // doesn't return it. However this sometimes happens when we're asked for
+    // the nearest accessible to place holder content which we ignore.
+    mAnchorNode = parent;
+  }
+
+  return Next();
+}
+
+LocalAccessible* TreeWalker::Prev() {
+  if (mStateStack.IsEmpty()) {
+    if (mPhase == eAtStart || mPhase == eAtDOM) {
+      mPhase = eAtStart;
+      return nullptr;
+    }
+
+    if (mPhase == eAtEnd) {
+      if (mFlags & eScoped) {
+        mPhase = eAtDOM;
+      } else {
+        mPhase = eAtARIAOwns;
+        mARIAOwnsIdx = mDoc->ARIAOwnedCount(mContext);
+      }
+    }
+
+    if (mPhase == eAtARIAOwns) {
+      MOZ_ASSERT(!(mFlags & eScoped),
+                 "Should not walk relocated children in scoped mode");
+      if (mARIAOwnsIdx > 0) {
+        return mDoc->ARIAOwnedAt(mContext, --mARIAOwnsIdx);
+      }
+
+      if (!mAnchorNode) {
+        mPhase = eAtStart;
+        return nullptr;
+      }
+
+      mPhase = eAtDOM;
+      PushState(mAnchorNode, false);
+    }
+  }
+
+  dom::AllChildrenIterator* top = &mStateStack[mStateStack.Length() - 1];
+  while (top) {
+    while (nsIContent* childNode = top->GetPreviousChild()) {
+      // No accessible creation on the way back.
+      bool skipSubtree = false;
+      LocalAccessible* child =
+          AccessibleFor(childNode, eWalkCache, &skipSubtree);
+      if (child) {
+        return child;
+      }
+
+      // Walk down into subtree to find accessibles.
+      if (!skipSubtree && childNode->IsElement()) {
+        top = PushState(childNode, false);
+      }
+    }
+    top = PopState();
+  }
+
+  // Move to a previous node relative the anchor node within the context
+  // subtree if asked.
+  if (mFlags != eWalkContextTree) {
+    mPhase = eAtStart;
+    return nullptr;
+  }
+
+  nsINode* contextNode = mContext->GetNode();
+  while (mAnchorNode != contextNode) {
+    nsINode* parentNode = mAnchorNode->GetFlattenedTreeParent();
+    if (!parentNode || !parentNode->IsElement()) {
+      return nullptr;
+    }
+
+    nsIContent* parent = parentNode->AsElement();
+    top = PushState(parent, true);
+    if (top->Seek(mAnchorNode)) {
+      mAnchorNode = parent;
+      return Prev();
+    }
+
+    mAnchorNode = parent;
+  }
+
+  mPhase = eAtStart;
+  return nullptr;
+}
+
+LocalAccessible* TreeWalker::AccessibleFor(nsIContent* aNode, uint32_t aFlags,
+                                           bool* aSkipSubtree) {
+  // Ignore the accessible and its subtree if it was repositioned by means
+  // of aria-owns.
+  LocalAccessible* child = mDoc->GetAccessible(aNode);
+  if (child) {
+    if (child->IsRelocated()) {
+      *aSkipSubtree = true;
+      return nullptr;
+    }
+    return child;
+  }
+
+  // Create an accessible if allowed.
+  if (!(aFlags & eWalkCache) && mContext->IsAcceptableChild(aNode)) {
+    // We may have ARIA owned element in the dependent attributes map, but the
+    // element may be not allowed for this ARIA owns relation, if the relation
+    // crosses out XBL anonymous content boundaries. In this case we won't
+    // create an accessible object for it, when aria-owns is processed, which
+    // may make the element subtree inaccessible. To avoid that let's create
+    // an accessible object now, and later, if allowed, move it in the tree,
+    // when aria-owns relation is processed.
+    if (mDoc->RelocateARIAOwnedIfNeeded(aNode) && !aNode->IsXULElement()) {
+      *aSkipSubtree = true;
+      return nullptr;
+    }
+    return GetAccService()->CreateAccessible(aNode, mContext, aSkipSubtree);
+  }
+
+  return nullptr;
+}
+
+dom::AllChildrenIterator* TreeWalker::PopState() {
+  mStateStack.RemoveLastElement();
+  return mStateStack.IsEmpty() ? nullptr : &mStateStack.LastElement();
+}
diff --git a/accessible/base/TreeWalker.h b/accessible/base/TreeWalker.h
new file mode 100644
index 0000000000..9093d8187f
--- /dev/null
+++ b/accessible/base/TreeWalker.h
@@ -0,0 +1,142 @@
+/* -*- 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_TreeWalker_h_
+#define mozilla_a11y_TreeWalker_h_
+
+#include "mozilla/Attributes.h"
+#include <stdint.h>
+#include "mozilla/dom/ChildIterator.h"
+#include "nsCOMPtr.h"
+
+class nsIContent;
+
+namespace mozilla {
+namespace a11y {
+
+class LocalAccessible;
+class DocAccessible;
+
+/**
+ * This class is used to walk the DOM tree to create accessible tree.
+ */
+class TreeWalker final {
+ public:
+  enum {
+    // used to walk the existing tree of the given node
+    eWalkCache = 1,
+    // used to walk the context tree starting from given node
+    eWalkContextTree = 2 | eWalkCache,
+    eScoped = 4
+  };
+
+  /**
+   * Used to navigate and create if needed the accessible children.
+   */
+  explicit TreeWalker(LocalAccessible* aContext);
+
+  /**
+   * Used to navigate the accessible children relative to the anchor.
+   *
+   * @param aContext [in] container accessible for the given node, used to
+   *                   define accessible context
+   * @param aAnchorNode [in] the node the search will be prepared relative to
+   * @param aFlags   [in] flags (see enum above)
+   */
+  TreeWalker(LocalAccessible* aContext, nsIContent* aAnchorNode,
+             uint32_t aFlags = eWalkCache);
+
+  /**
+   * Navigates the accessible children within the anchor node subtree.
+   */
+  TreeWalker(DocAccessible* aDocument, nsIContent* aAnchorNode);
+
+  ~TreeWalker();
+
+  /**
+   * Resets the walker state, and sets the given node as an anchor. Returns a
+   * first accessible element within the node including the node itself.
+   */
+  LocalAccessible* Scope(nsIContent* aAnchorNode);
+
+  /**
+   * Resets the walker state.
+   */
+  void Reset() {
+    mPhase = eAtStart;
+    mStateStack.Clear();
+    mARIAOwnsIdx = 0;
+  }
+
+  /**
+   * Sets the walker state to the given child node if it's within the anchor.
+   */
+  bool Seek(nsIContent* aChildNode);
+
+  /**
+   * Return the next/prev accessible.
+   *
+   * @note Returned accessible is bound to the document, if the accessible is
+   *       rejected during tree creation then the caller should be unbind it
+   *       from the document.
+   */
+  LocalAccessible* Next();
+  LocalAccessible* Prev();
+
+  LocalAccessible* Context() const { return mContext; }
+  DocAccessible* Document() const { return mDoc; }
+
+ private:
+  TreeWalker();
+  TreeWalker(const TreeWalker&);
+  TreeWalker& operator=(const TreeWalker&);
+
+  /**
+   * Return an accessible for the given node if any.
+   */
+  LocalAccessible* AccessibleFor(nsIContent* aNode, uint32_t aFlags,
+                                 bool* aSkipSubtree);
+
+  /**
+   * Create new state for the given node and push it on top of stack / at bottom
+   * of stack.
+   *
+   * @note State stack is used to navigate up/down the DOM subtree during
+   *        accessible children search.
+   */
+  dom::AllChildrenIterator* PushState(nsIContent* aContent,
+                                      bool aStartAtBeginning) {
+    return mStateStack.AppendElement(
+        dom::AllChildrenIterator(aContent, mChildFilter, aStartAtBeginning));
+  }
+  dom::AllChildrenIterator* PrependState(nsIContent* aContent,
+                                         bool aStartAtBeginning) {
+    return mStateStack.InsertElementAt(
+        0, dom::AllChildrenIterator(aContent, mChildFilter, aStartAtBeginning));
+  }
+
+  /**
+   * Pop state from stack.
+   */
+  dom::AllChildrenIterator* PopState();
+
+  DocAccessible* mDoc;
+  LocalAccessible* mContext;
+  nsIContent* mAnchorNode;
+
+  AutoTArray<dom::AllChildrenIterator, 20> mStateStack;
+  uint32_t mARIAOwnsIdx;
+
+  int32_t mChildFilter;
+  uint32_t mFlags;
+
+  enum Phase { eAtStart, eAtDOM, eAtARIAOwns, eAtEnd };
+  Phase mPhase;
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif  // mozilla_a11y_TreeWalker_h_
diff --git a/accessible/base/XULMap.h b/accessible/base/XULMap.h
new file mode 100644
index 0000000000..4687e85814
--- /dev/null
+++ b/accessible/base/XULMap.h
@@ -0,0 +1,115 @@
+/* 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/. */
+
+XULMAP_TYPE(browser, OuterDocAccessible)
+XULMAP_TYPE(button, XULButtonAccessible)
+XULMAP_TYPE(checkbox, CheckboxAccessible)
+XULMAP_TYPE(dropMarker, XULDropmarkerAccessible)
+XULMAP_TYPE(editor, OuterDocAccessible)
+XULMAP_TYPE(findbar, XULToolbarAccessible)
+XULMAP_TYPE(groupbox, XULGroupboxAccessible)
+XULMAP_TYPE(iframe, OuterDocAccessible)
+XULMAP_TYPE(listheader, XULColumAccessible)
+XULMAP_TYPE(menu, XULMenuitemAccessible)
+XULMAP_TYPE(menubar, XULMenubarAccessible)
+XULMAP_TYPE(menucaption, XULMenuitemAccessible)
+XULMAP_TYPE(menuitem, XULMenuitemAccessible)
+XULMAP_TYPE(menulist, XULComboboxAccessible)
+XULMAP_TYPE(menuseparator, XULMenuSeparatorAccessible)
+XULMAP_TYPE(notification, XULAlertAccessible)
+XULMAP_TYPE(radio, XULRadioButtonAccessible)
+XULMAP_TYPE(radiogroup, XULRadioGroupAccessible)
+XULMAP_TYPE(richlistbox, XULListboxAccessible)
+XULMAP_TYPE(richlistitem, XULListitemAccessible)
+XULMAP_TYPE(statusbar, XULStatusBarAccessible)
+XULMAP_TYPE(tab, XULTabAccessible)
+XULMAP_TYPE(tabpanels, XULTabpanelsAccessible)
+XULMAP_TYPE(tabs, XULTabsAccessible)
+XULMAP_TYPE(toolbarseparator, XULToolbarSeparatorAccessible)
+XULMAP_TYPE(toolbarspacer, XULToolbarSeparatorAccessible)
+XULMAP_TYPE(toolbarspring, XULToolbarSeparatorAccessible)
+XULMAP_TYPE(treecol, XULColumnItemAccessible)
+XULMAP_TYPE(treecols, XULTreeColumAccessible)
+XULMAP_TYPE(toolbar, XULToolbarAccessible)
+XULMAP_TYPE(toolbarbutton, XULToolbarButtonAccessible)
+
+XULMAP(description,
+       [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+         if (aElement->ClassList()->Contains(u"tooltip-label"_ns)) {
+           // FIXME(emilio): Why this special case?
+           return nullptr;
+         }
+
+         return new XULLabelAccessible(aElement, aContext->Document());
+       })
+
+XULMAP(tooltip,
+       [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+         return new XULTooltipAccessible(aElement, aContext->Document());
+       })
+
+XULMAP(label,
+       [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+         if (aElement->ClassList()->Contains(u"text-link"_ns)) {
+           return new XULLinkAccessible(aElement, aContext->Document());
+         }
+         return new XULLabelAccessible(aElement, aContext->Document());
+       })
+
+XULMAP(image,
+       [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+         // Don't include nameless images in accessible tree.
+         if (!aElement->HasAttr(nsGkAtoms::tooltiptext)) {
+           return nullptr;
+         }
+
+         return new ImageAccessible(aElement, aContext->Document());
+       })
+
+XULMAP(menupopup, [](Element* aElement, LocalAccessible* aContext) {
+  return CreateMenupopupAccessible(aElement, aContext);
+})
+
+XULMAP(panel,
+       [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+         static const Element::AttrValuesArray sIgnoreTypeVals[] = {
+             nsGkAtoms::autocomplete_richlistbox, nsGkAtoms::autocomplete,
+             nullptr};
+
+         if (aElement->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::type,
+                                       sIgnoreTypeVals, eIgnoreCase) >= 0) {
+           return nullptr;
+         }
+
+         if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::noautofocus,
+                                   nsGkAtoms::_true, eCaseMatters)) {
+           return new XULAlertAccessible(aElement, aContext->Document());
+         }
+
+         return new EnumRoleAccessible<roles::PANE>(aElement,
+                                                    aContext->Document());
+       })
+
+XULMAP(tree,
+       [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* {
+         nsIContent* child =
+             nsTreeUtils::GetDescendantChild(aElement, nsGkAtoms::treechildren);
+         if (!child) return nullptr;
+
+         nsTreeBodyFrame* treeFrame = do_QueryFrame(child->GetPrimaryFrame());
+         if (!treeFrame) return nullptr;
+
+         RefPtr<nsTreeColumns> treeCols = treeFrame->Columns();
+         uint32_t count = treeCols->Count();
+
+         // Outline of list accessible.
+         if (count == 1) {
+           return new XULTreeAccessible(aElement, aContext->Document(),
+                                        treeFrame);
+         }
+
+         // Table or tree table accessible.
+         return new XULTreeGridAccessible(aElement, aContext->Document(),
+                                          treeFrame);
+       })
diff --git a/accessible/base/moz.build b/accessible/base/moz.build
new file mode 100644
index 0000000000..b65c90ceba
--- /dev/null
+++ b/accessible/base/moz.build
@@ -0,0 +1,122 @@
+# -*- 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/.
+
+GeneratedFile(
+    "RelationType.h",
+    script="/accessible/base/RelationTypeGen.py",
+    entry_point="generate",
+    inputs=["/accessible/interfaces/nsIAccessibleRelation.idl"],
+)
+GeneratedFile(
+    "Role.h",
+    script="/accessible/base/RoleHGen.py",
+    entry_point="generate",
+    inputs=["/accessible/interfaces/nsIAccessibleRole.idl"],
+)
+
+EXPORTS += ["AccEvent.h", "nsAccessibilityService.h"]
+
+EXPORTS.mozilla.a11y += [
+    "!RelationType.h",
+    "!Role.h",
+    "AccAttributes.h",
+    "AccGroupInfo.h",
+    "AccTypes.h",
+    "CacheConstants.h",
+    "DocManager.h",
+    "FocusManager.h",
+    "IDSet.h",
+    "Platform.h",
+    "SelectionManager.h",
+    "States.h",
+]
+
+if CONFIG["MOZ_DEBUG"]:
+    EXPORTS.mozilla.a11y += [
+        "Logging.h",
+    ]
+
+UNIFIED_SOURCES += [
+    "AccAttributes.cpp",
+    "AccEvent.cpp",
+    "AccGroupInfo.cpp",
+    "AccIterator.cpp",
+    "ARIAMap.cpp",
+    "ARIAStateMap.cpp",
+    "Asserts.cpp",
+    "CachedTableAccessible.cpp",
+    "DocManager.cpp",
+    "EmbeddedObjCollector.cpp",
+    "EventQueue.cpp",
+    "EventTree.cpp",
+    "Filters.cpp",
+    "FocusManager.cpp",
+    "NotificationController.cpp",
+    "nsAccessibilityService.cpp",
+    "nsAccUtils.cpp",
+    "nsCoreUtils.cpp",
+    "nsEventShell.cpp",
+    "nsTextEquivUtils.cpp",
+    "Pivot.cpp",
+    "SelectionManager.cpp",
+    "StyleInfo.cpp",
+    "TextAttrs.cpp",
+    "TextLeafRange.cpp",
+    "TextRange.cpp",
+    "TextUpdater.cpp",
+    "TreeWalker.cpp",
+]
+
+if CONFIG["A11Y_LOG"]:
+    UNIFIED_SOURCES += [
+        "Logging.cpp",
+    ]
+
+LOCAL_INCLUDES += [
+    "/accessible/generic",
+    "/accessible/html",
+    "/accessible/ipc",
+    "/dom/base",
+    "/dom/xul",
+]
+
+LOCAL_INCLUDES += [
+    "/accessible/xpcom",
+    "/accessible/xul",
+    "/dom/base",
+    "/ipc/chromium/src",
+    "/layout/generic",
+    "/layout/style",
+    "/layout/xul",
+    "/layout/xul/tree/",
+]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk":
+    LOCAL_INCLUDES += [
+        "/accessible/atk",
+        "/gfx/cairo/cairo/src",
+    ]
+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",
+    ]
+
+FINAL_LIBRARY = "xul"
+
+include("/ipc/chromium/chromium-config.mozbuild")
diff --git a/accessible/base/nsAccCache.h b/accessible/base/nsAccCache.h
new file mode 100644
index 0000000000..db0c877035
--- /dev/null
+++ b/accessible/base/nsAccCache.h
@@ -0,0 +1,24 @@
+/* -*- 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 _nsAccCache_H_
+#define _nsAccCache_H_
+
+////////////////////////////////////////////////////////////////////////////////
+// LocalAccessible cache utils
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+void UnbindCacheEntriesFromDocument(
+    nsRefPtrHashtable<nsPtrHashKey<const void>, T>& aCache) {
+  for (auto iter = aCache.Iter(); !iter.Done(); iter.Next()) {
+    T* accessible = iter.Data();
+    MOZ_ASSERT(accessible && !accessible->IsDefunct());
+    accessible->Document()->UnbindFromDocument(accessible);
+    iter.Remove();
+  }
+}
+
+#endif
diff --git a/accessible/base/nsAccUtils.cpp b/accessible/base/nsAccUtils.cpp
new file mode 100644
index 0000000000..82af56348f
--- /dev/null
+++ b/accessible/base/nsAccUtils.cpp
@@ -0,0 +1,626 @@
+/* -*- 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 "nsAccUtils.h"
+
+#include "AccAttributes.h"
+#include "ARIAMap.h"
+#include "nsCoreUtils.h"
+#include "nsGenericHTMLElement.h"
+#include "DocAccessible.h"
+#include "DocAccessibleParent.h"
+#include "HyperTextAccessible.h"
+#include "nsIAccessibleTypes.h"
+#include "mozilla/a11y/Role.h"
+#include "States.h"
+#include "TextLeafAccessible.h"
+
+#include "nsIBaseWindow.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIDOMXULContainerElement.h"
+#include "mozilla/a11y/RemoteAccessible.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/ElementInternals.h"
+#include "nsAccessibilityService.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+void nsAccUtils::SetAccGroupAttrs(AccAttributes* aAttributes, int32_t aLevel,
+                                  int32_t aSetSize, int32_t aPosInSet) {
+  nsAutoString value;
+
+  if (aLevel) {
+    aAttributes->SetAttribute(nsGkAtoms::level, aLevel);
+  }
+
+  if (aSetSize && aPosInSet) {
+    aAttributes->SetAttribute(nsGkAtoms::posinset, aPosInSet);
+    aAttributes->SetAttribute(nsGkAtoms::setsize, aSetSize);
+  }
+}
+
+int32_t nsAccUtils::GetLevelForXULContainerItem(nsIContent* aContent) {
+  nsCOMPtr<nsIDOMXULContainerItemElement> item =
+      aContent->AsElement()->AsXULContainerItem();
+  if (!item) return 0;
+
+  nsCOMPtr<dom::Element> containerElement;
+  item->GetParentContainer(getter_AddRefs(containerElement));
+  nsCOMPtr<nsIDOMXULContainerElement> container =
+      containerElement ? containerElement->AsXULContainer() : nullptr;
+  if (!container) return 0;
+
+  // Get level of the item.
+  int32_t level = -1;
+  while (container) {
+    level++;
+
+    container->GetParentContainer(getter_AddRefs(containerElement));
+    container = containerElement ? containerElement->AsXULContainer() : nullptr;
+  }
+
+  return level;
+}
+
+void nsAccUtils::SetLiveContainerAttributes(AccAttributes* aAttributes,
+                                            Accessible* aStartAcc) {
+  nsAutoString live, relevant, busy;
+  nsStaticAtom* role = nullptr;
+  Maybe<bool> atomic;
+  for (Accessible* acc = aStartAcc; acc; acc = acc->Parent()) {
+    // We only want the nearest value for each attribute. If we already got a
+    // value, don't bother fetching it from further ancestors.
+    const bool wasLiveEmpty = live.IsEmpty();
+    acc->LiveRegionAttributes(wasLiveEmpty ? &live : nullptr,
+                              relevant.IsEmpty() ? &relevant : nullptr,
+                              atomic ? nullptr : &atomic,
+                              busy.IsEmpty() ? &busy : nullptr);
+    if (wasLiveEmpty) {
+      const nsRoleMapEntry* roleMap = acc->ARIARoleMap();
+      if (live.IsEmpty()) {
+        // aria-live wasn't explicitly set. See if an aria-live value is implied
+        // by an ARIA role or markup element.
+        if (roleMap) {
+          GetLiveAttrValue(roleMap->liveAttRule, live);
+        } else if (nsStaticAtom* value = GetAccService()->MarkupAttribute(
+                       acc, nsGkAtoms::aria_live)) {
+          value->ToString(live);
+        }
+      }
+      if (!live.IsEmpty() && roleMap &&
+          roleMap->roleAtom != nsGkAtoms::_empty) {
+        role = roleMap->roleAtom;
+      }
+    }
+    if (acc->IsDoc()) {
+      break;
+    }
+  }
+  if (!live.IsEmpty()) {
+    aAttributes->SetAttribute(nsGkAtoms::containerLive, std::move(live));
+  }
+  if (role) {
+    aAttributes->SetAttribute(nsGkAtoms::containerLiveRole, std::move(role));
+  }
+  if (!relevant.IsEmpty()) {
+    aAttributes->SetAttribute(nsGkAtoms::containerRelevant,
+                              std::move(relevant));
+  }
+  if (atomic) {
+    aAttributes->SetAttribute(nsGkAtoms::containerAtomic, *atomic);
+  }
+  if (!busy.IsEmpty()) {
+    aAttributes->SetAttribute(nsGkAtoms::containerBusy, std::move(busy));
+  }
+}
+
+bool nsAccUtils::HasDefinedARIAToken(nsIContent* aContent, nsAtom* aAtom) {
+  NS_ASSERTION(aContent, "aContent is null in call to HasDefinedARIAToken!");
+
+  if (!aContent->IsElement()) return false;
+
+  dom::Element* element = aContent->AsElement();
+  if (auto* htmlElement = nsGenericHTMLElement::FromNode(element);
+      htmlElement && !element->HasAttr(aAtom)) {
+    const auto* defaults = GetARIADefaults(htmlElement);
+    if (!defaults) {
+      return false;
+    }
+    return HasDefinedARIAToken(defaults, aAtom);
+  }
+  return HasDefinedARIAToken(&element->GetAttrs(), aAtom);
+}
+
+bool nsAccUtils::HasDefinedARIAToken(const AttrArray* aAttrs, nsAtom* aAtom) {
+  return aAttrs->HasAttr(aAtom) &&
+         !aAttrs->AttrValueIs(kNameSpaceID_None, aAtom, nsGkAtoms::_empty,
+                              eCaseMatters) &&
+         !aAttrs->AttrValueIs(kNameSpaceID_None, aAtom, nsGkAtoms::_undefined,
+                              eCaseMatters);
+}
+
+nsStaticAtom* nsAccUtils::NormalizeARIAToken(const AttrArray* aAttrs,
+                                             nsAtom* aAttr) {
+  if (!HasDefinedARIAToken(aAttrs, aAttr)) {
+    return nsGkAtoms::_empty;
+  }
+
+  if (aAttr == nsGkAtoms::aria_current) {
+    static AttrArray::AttrValuesArray tokens[] = {
+        nsGkAtoms::page, nsGkAtoms::step, nsGkAtoms::location_,
+        nsGkAtoms::date, nsGkAtoms::time, nsGkAtoms::_true,
+        nullptr};
+    int32_t idx =
+        aAttrs->FindAttrValueIn(kNameSpaceID_None, aAttr, tokens, eCaseMatters);
+    // If the token is present, return it, otherwise TRUE as per spec.
+    return (idx >= 0) ? tokens[idx] : nsGkAtoms::_true;
+  }
+
+  static AttrArray::AttrValuesArray tokens[] = {
+      nsGkAtoms::_false, nsGkAtoms::_true, nsGkAtoms::mixed, nullptr};
+  int32_t idx =
+      aAttrs->FindAttrValueIn(kNameSpaceID_None, aAttr, tokens, eCaseMatters);
+  if (idx >= 0) {
+    return tokens[idx];
+  }
+
+  return nullptr;
+}
+
+nsStaticAtom* nsAccUtils::NormalizeARIAToken(dom::Element* aElement,
+                                             nsAtom* aAttr) {
+  if (auto* htmlElement = nsGenericHTMLElement::FromNode(aElement);
+      htmlElement && !aElement->HasAttr(aAttr)) {
+    const auto* defaults = GetARIADefaults(htmlElement);
+    if (!defaults) {
+      return nsGkAtoms::_empty;
+    }
+    return NormalizeARIAToken(defaults, aAttr);
+  }
+  return NormalizeARIAToken(&aElement->GetAttrs(), aAttr);
+}
+
+Accessible* nsAccUtils::GetSelectableContainer(const Accessible* aAccessible,
+                                               uint64_t aState) {
+  if (!aAccessible) return nullptr;
+
+  if (!(aState & states::SELECTABLE)) return nullptr;
+  MOZ_ASSERT(!aAccessible->IsDoc());
+
+  const Accessible* parent = aAccessible;
+  while ((parent = parent->Parent()) && !parent->IsSelect()) {
+    if (parent->IsDoc() || parent->Role() == roles::PANE) {
+      return nullptr;
+    }
+  }
+  return const_cast<Accessible*>(parent);
+}
+
+LocalAccessible* nsAccUtils::GetSelectableContainer(
+    LocalAccessible* aAccessible, uint64_t aState) {
+  Accessible* selectable =
+      GetSelectableContainer(static_cast<Accessible*>(aAccessible), aState);
+  return selectable ? selectable->AsLocal() : nullptr;
+}
+
+bool nsAccUtils::IsDOMAttrTrue(const LocalAccessible* aAccessible,
+                               nsAtom* aAttr) {
+  dom::Element* el = aAccessible->Elm();
+  return el && ARIAAttrValueIs(el, aAttr, nsGkAtoms::_true, eCaseMatters);
+}
+
+Accessible* nsAccUtils::TableFor(Accessible* aAcc) {
+  if (!aAcc ||
+      (!aAcc->IsTable() && !aAcc->IsTableRow() && !aAcc->IsTableCell())) {
+    return nullptr;
+  }
+  Accessible* table = aAcc;
+  for (; table && !table->IsTable(); table = table->Parent()) {
+  }
+  // We don't assert (table && table->IsTable()) here because
+  // it's possible for this tree walk to yield no table at all
+  // ex. because a table part has been moved in the tree
+  // using aria-owns.
+  return table;
+}
+
+LocalAccessible* nsAccUtils::TableFor(LocalAccessible* aRow) {
+  Accessible* table = TableFor(static_cast<Accessible*>(aRow));
+  return table ? table->AsLocal() : nullptr;
+}
+
+HyperTextAccessible* nsAccUtils::GetTextContainer(nsINode* aNode) {
+  // Get text accessible containing the result node.
+  DocAccessible* doc = GetAccService()->GetDocAccessible(aNode->OwnerDoc());
+  LocalAccessible* accessible =
+      doc ? doc->GetAccessibleOrContainer(aNode) : nullptr;
+  if (!accessible) return nullptr;
+
+  do {
+    HyperTextAccessible* textAcc = accessible->AsHyperText();
+    if (textAcc) return textAcc;
+
+    accessible = accessible->LocalParent();
+  } while (accessible);
+
+  return nullptr;
+}
+
+LayoutDeviceIntPoint nsAccUtils::ConvertToScreenCoords(
+    int32_t aX, int32_t aY, uint32_t aCoordinateType, Accessible* aAccessible) {
+  LayoutDeviceIntPoint coords(aX, aY);
+
+  switch (aCoordinateType) {
+    // Regardless of coordinate type, the coords returned
+    // are in dev pixels.
+    case nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE:
+      break;
+
+    case nsIAccessibleCoordinateType::COORDTYPE_WINDOW_RELATIVE: {
+      coords += GetScreenCoordsForWindow(aAccessible);
+      break;
+    }
+
+    case nsIAccessibleCoordinateType::COORDTYPE_PARENT_RELATIVE: {
+      coords += GetScreenCoordsForParent(aAccessible);
+      break;
+    }
+
+    default:
+      MOZ_ASSERT_UNREACHABLE("invalid coord type!");
+  }
+
+  return coords;
+}
+
+void nsAccUtils::ConvertScreenCoordsTo(int32_t* aX, int32_t* aY,
+                                       uint32_t aCoordinateType,
+                                       Accessible* aAccessible) {
+  switch (aCoordinateType) {
+    // Regardless of coordinate type, the values returned for
+    // aX and aY are in dev pixels.
+    case nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE:
+      break;
+
+    case nsIAccessibleCoordinateType::COORDTYPE_WINDOW_RELATIVE: {
+      LayoutDeviceIntPoint coords = GetScreenCoordsForWindow(aAccessible);
+      *aX -= coords.x;
+      *aY -= coords.y;
+      break;
+    }
+
+    case nsIAccessibleCoordinateType::COORDTYPE_PARENT_RELATIVE: {
+      LayoutDeviceIntPoint coords = GetScreenCoordsForParent(aAccessible);
+      *aX -= coords.x;
+      *aY -= coords.y;
+      break;
+    }
+
+    default:
+      MOZ_ASSERT_UNREACHABLE("invalid coord type!");
+  }
+}
+
+LayoutDeviceIntPoint nsAccUtils::GetScreenCoordsForParent(
+    Accessible* aAccessible) {
+  if (!aAccessible) return LayoutDeviceIntPoint();
+
+  if (Accessible* parent = aAccessible->Parent()) {
+    LayoutDeviceIntRect parentBounds = parent->Bounds();
+    // The rect returned from Bounds() is already in dev
+    // pixels, so we don't need to do any conversion here.
+    return parentBounds.TopLeft();
+  }
+
+  return LayoutDeviceIntPoint();
+}
+
+LayoutDeviceIntPoint nsAccUtils::GetScreenCoordsForWindow(
+    Accessible* aAccessible) {
+  LayoutDeviceIntPoint coords(0, 0);
+  a11y::LocalAccessible* localAcc = aAccessible->AsLocal();
+  if (!localAcc) {
+    localAcc = aAccessible->AsRemote()->OuterDocOfRemoteBrowser();
+    if (!localAcc) {
+      // This could be null if the tab is closing but the document is still
+      // being shut down.
+      return coords;
+    }
+  }
+
+  nsCOMPtr<nsIDocShellTreeItem> treeItem(
+      nsCoreUtils::GetDocShellFor(localAcc->GetNode()));
+  if (!treeItem) return coords;
+
+  nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
+  treeItem->GetTreeOwner(getter_AddRefs(treeOwner));
+  if (!treeOwner) return coords;
+
+  nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(treeOwner);
+  if (baseWindow) {
+    baseWindow->GetPosition(&coords.x.value,
+                            &coords.y.value);  // in device pixels
+  }
+
+  return coords;
+}
+
+bool nsAccUtils::GetLiveAttrValue(uint32_t aRule, nsAString& aValue) {
+  switch (aRule) {
+    case eOffLiveAttr:
+      aValue = u"off"_ns;
+      return true;
+    case ePoliteLiveAttr:
+      aValue = u"polite"_ns;
+      return true;
+    case eAssertiveLiveAttr:
+      aValue = u"assertive"_ns;
+      return true;
+  }
+
+  return false;
+}
+
+#ifdef DEBUG
+
+bool nsAccUtils::IsTextInterfaceSupportCorrect(LocalAccessible* aAccessible) {
+  // Don't test for accessible docs, it makes us create accessibles too
+  // early and fire mutation events before we need to
+  if (aAccessible->IsDoc()) return true;
+
+  bool foundText = false;
+  uint32_t childCount = aAccessible->ChildCount();
+  for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
+    LocalAccessible* child = aAccessible->LocalChildAt(childIdx);
+    if (child && child->IsText()) {
+      foundText = true;
+      break;
+    }
+  }
+
+  return !foundText || aAccessible->IsHyperText();
+}
+#endif
+
+uint32_t nsAccUtils::TextLength(Accessible* aAccessible) {
+  if (!aAccessible->IsText()) {
+    return 1;
+  }
+
+  if (LocalAccessible* localAcc = aAccessible->AsLocal()) {
+    TextLeafAccessible* textLeaf = localAcc->AsTextLeaf();
+    if (textLeaf) {
+      return textLeaf->Text().Length();
+    }
+  } else if (aAccessible->IsText()) {
+    RemoteAccessible* remoteAcc = aAccessible->AsRemote();
+    MOZ_ASSERT(remoteAcc);
+    return remoteAcc->GetCachedTextLength();
+  }
+
+  // For list bullets (or anything other accessible which would compute its own
+  // text. They don't have their own frame.
+  // XXX In the future, list bullets may have frame and anon content, so
+  // we should be able to remove this at that point
+  nsAutoString text;
+  aAccessible->AppendTextTo(text);  // Get all the text
+  return text.Length();
+}
+
+bool nsAccUtils::MustPrune(Accessible* aAccessible) {
+  MOZ_ASSERT(aAccessible);
+  roles::Role role = aAccessible->Role();
+
+  if (role == roles::SLIDER || role == roles::PROGRESSBAR) {
+    // Always prune the tree for sliders and progressbars, as it doesn't make
+    // sense for either to have descendants. Per the ARIA spec, children of
+    // these elements are presentational. They also confuse NVDA.
+    return true;
+  }
+
+  if (role != roles::MENUITEM && role != roles::COMBOBOX_OPTION &&
+      role != roles::OPTION && role != roles::ENTRY &&
+      role != roles::FLAT_EQUATION && role != roles::PASSWORD_TEXT &&
+      role != roles::PUSHBUTTON && role != roles::TOGGLE_BUTTON &&
+      role != roles::GRAPHIC && role != roles::SEPARATOR) {
+    // If it doesn't match any of these roles, don't prune its children.
+    return false;
+  }
+
+  if (aAccessible->ChildCount() != 1) {
+    // If the accessible has more than one child, don't prune it.
+    return false;
+  }
+
+  roles::Role childRole = aAccessible->FirstChild()->Role();
+  // If the accessible's child is a text leaf, prune the accessible.
+  return childRole == roles::TEXT_LEAF || childRole == roles::STATICTEXT;
+}
+
+bool nsAccUtils::IsARIALive(const LocalAccessible* aAccessible) {
+  // Get computed aria-live property based on the closest container with the
+  // attribute. Inner nodes override outer nodes within the same
+  // document.
+  // This should be the same as the container-live attribute, but we don't need
+  // the other container-* attributes, so we can't use the same function.
+  nsIContent* ancestor = aAccessible->GetContent();
+  if (!ancestor) {
+    return false;
+  }
+  dom::Document* doc = ancestor->GetComposedDoc();
+  if (!doc) {
+    return false;
+  }
+  dom::Element* topEl = doc->GetRootElement();
+  while (ancestor) {
+    const nsRoleMapEntry* role = nullptr;
+    if (ancestor->IsElement()) {
+      role = aria::GetRoleMap(ancestor->AsElement());
+    }
+    nsAutoString live;
+    if (HasDefinedARIAToken(ancestor, nsGkAtoms::aria_live)) {
+      GetARIAAttr(ancestor->AsElement(), nsGkAtoms::aria_live, live);
+    } else if (role) {
+      GetLiveAttrValue(role->liveAttRule, live);
+    } else if (nsStaticAtom* value = GetAccService()->MarkupAttribute(
+                   ancestor, nsGkAtoms::aria_live)) {
+      value->ToString(live);
+    }
+    if (!live.IsEmpty() && !live.EqualsLiteral("off")) {
+      return true;
+    }
+
+    if (ancestor == topEl) {
+      break;
+    }
+
+    ancestor = ancestor->GetParent();
+    if (!ancestor) {
+      ancestor = topEl;  // Use <body>/<frameset>
+    }
+  }
+
+  return false;
+}
+
+Accessible* nsAccUtils::DocumentFor(Accessible* aAcc) {
+  if (!aAcc) {
+    return nullptr;
+  }
+  if (LocalAccessible* localAcc = aAcc->AsLocal()) {
+    return localAcc->Document();
+  }
+  return aAcc->AsRemote()->Document();
+}
+
+Accessible* nsAccUtils::GetAccessibleByID(Accessible* aDoc, uint64_t aID) {
+  if (!aDoc) {
+    return nullptr;
+  }
+  if (LocalAccessible* localAcc = aDoc->AsLocal()) {
+    if (DocAccessible* doc = localAcc->AsDoc()) {
+      if (!aID) {
+        // GetAccessibleByUniqueID doesn't treat 0 as the document.
+        return aDoc;
+      }
+      return doc->GetAccessibleByUniqueID(
+          reinterpret_cast<void*>(static_cast<uintptr_t>(aID)));
+    }
+  } else if (DocAccessibleParent* doc = aDoc->AsRemote()->AsDoc()) {
+    return doc->GetAccessible(aID);
+  }
+  return nullptr;
+}
+
+void nsAccUtils::DocumentURL(Accessible* aDoc, nsAString& aURL) {
+  MOZ_ASSERT(aDoc && aDoc->IsDoc());
+  if (LocalAccessible* localAcc = aDoc->AsLocal()) {
+    return localAcc->AsDoc()->URL(aURL);
+  }
+  return aDoc->AsRemote()->AsDoc()->URL(aURL);
+}
+
+void nsAccUtils::DocumentMimeType(Accessible* aDoc, nsAString& aMimeType) {
+  MOZ_ASSERT(aDoc && aDoc->IsDoc());
+  if (LocalAccessible* localAcc = aDoc->AsLocal()) {
+    return localAcc->AsDoc()->MimeType(aMimeType);
+  }
+  return aDoc->AsRemote()->AsDoc()->MimeType(aMimeType);
+}
+
+// ARIA Accessibility Default Accessors
+const AttrArray* nsAccUtils::GetARIADefaults(dom::Element* aElement) {
+  auto* element = nsGenericHTMLElement::FromNode(aElement);
+  if (!element) {
+    return nullptr;
+  }
+  auto* internals = element->GetInternals();
+  if (!internals) {
+    return nullptr;
+  }
+  return &internals->GetAttrs();
+}
+
+bool nsAccUtils::HasARIAAttr(dom::Element* aElement, const nsAtom* aName) {
+  if (aElement->HasAttr(aName)) {
+    return true;
+  }
+  const auto* defaults = GetARIADefaults(aElement);
+  if (!defaults) {
+    return false;
+  }
+  return defaults->HasAttr(aName);
+}
+
+bool nsAccUtils::GetARIAAttr(dom::Element* aElement, const nsAtom* aName,
+                             nsAString& aResult) {
+  if (aElement->GetAttr(aName, aResult)) {
+    return true;
+  }
+  const auto* defaults = GetARIADefaults(aElement);
+  if (!defaults) {
+    return false;
+  }
+  return defaults->GetAttr(aName, aResult);
+}
+
+const nsAttrValue* nsAccUtils::GetARIAAttr(dom::Element* aElement,
+                                           const nsAtom* aName) {
+  if (const auto* val = aElement->GetParsedAttr(aName, kNameSpaceID_None)) {
+    return val;
+  }
+  const auto* defaults = GetARIADefaults(aElement);
+  if (!defaults) {
+    return nullptr;
+  }
+  return defaults->GetAttr(aName, kNameSpaceID_None);
+}
+
+bool nsAccUtils::ARIAAttrValueIs(dom::Element* aElement, const nsAtom* aName,
+                                 const nsAString& aValue,
+                                 nsCaseTreatment aCaseSensitive) {
+  if (aElement->AttrValueIs(kNameSpaceID_None, aName, aValue, aCaseSensitive)) {
+    return true;
+  }
+  const auto* defaults = GetARIADefaults(aElement);
+  if (!defaults) {
+    return false;
+  }
+  return defaults->AttrValueIs(kNameSpaceID_None, aName, aValue,
+                               aCaseSensitive);
+}
+
+bool nsAccUtils::ARIAAttrValueIs(dom::Element* aElement, const nsAtom* aName,
+                                 const nsAtom* aValue,
+                                 nsCaseTreatment aCaseSensitive) {
+  if (aElement->AttrValueIs(kNameSpaceID_None, aName, aValue, aCaseSensitive)) {
+    return true;
+  }
+  const auto* defaults = GetARIADefaults(aElement);
+  if (!defaults) {
+    return false;
+  }
+  return defaults->AttrValueIs(kNameSpaceID_None, aName, aValue,
+                               aCaseSensitive);
+}
+
+int32_t nsAccUtils::FindARIAAttrValueIn(dom::Element* aElement,
+                                        const nsAtom* aName,
+                                        AttrArray::AttrValuesArray* aValues,
+                                        nsCaseTreatment aCaseSensitive) {
+  int32_t index = aElement->FindAttrValueIn(kNameSpaceID_None, aName, aValues,
+                                            aCaseSensitive);
+  if (index == AttrArray::ATTR_MISSING) {
+    const auto* defaults = GetARIADefaults(aElement);
+    if (!defaults) {
+      return index;
+    }
+    index = defaults->FindAttrValueIn(kNameSpaceID_None, aName, aValues,
+                                      aCaseSensitive);
+  }
+  return index;
+}
diff --git a/accessible/base/nsAccUtils.h b/accessible/base/nsAccUtils.h
new file mode 100644
index 0000000000..ed51eef709
--- /dev/null
+++ b/accessible/base/nsAccUtils.h
@@ -0,0 +1,299 @@
+/* -*- 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 nsAccUtils_h_
+#define nsAccUtils_h_
+
+#include "mozilla/a11y/LocalAccessible.h"
+#include "mozilla/a11y/DocManager.h"
+
+#include "nsAccessibilityService.h"
+#include "nsCoreUtils.h"
+
+#include "nsIDocShell.h"
+#include "nsPoint.h"
+
+namespace mozilla {
+
+class PresShell;
+
+namespace dom {
+class Element;
+}
+
+namespace a11y {
+
+class HyperTextAccessible;
+class DocAccessible;
+class Attribute;
+
+class nsAccUtils {
+ public:
+  /**
+   * Set group attributes ('level', 'setsize', 'posinset').
+   */
+  static void SetAccGroupAttrs(AccAttributes* aAttributes, int32_t aLevel,
+                               int32_t aSetSize, int32_t aPosInSet);
+
+  /**
+   * Compute group level for nsIDOMXULContainerItemElement node.
+   */
+  static int32_t GetLevelForXULContainerItem(nsIContent* aContent);
+
+  /**
+   * Set container-foo live region attributes for the given node.
+   *
+   * @param aAttributes    where to store the attributes
+   * @param aStartAcc  Accessible to start from
+   */
+  static void SetLiveContainerAttributes(AccAttributes* aAttributes,
+                                         Accessible* aStartAcc);
+
+  /**
+   * Any ARIA property of type boolean or NMTOKEN is undefined if the ARIA
+   * property is not present, or is "" or "undefined". Do not call
+   * this method for properties of type string, decimal, IDREF or IDREFS.
+   *
+   * Return true if the ARIA property is defined, otherwise false
+   */
+  static bool HasDefinedARIAToken(nsIContent* aContent, nsAtom* aAtom);
+  static bool HasDefinedARIAToken(const AttrArray* aAttrs, nsAtom* aAtom);
+
+  /**
+   * If the given ARIA attribute has a specific known token value, return it.
+   * If the specification demands for a fallback value for unknown attribute
+   * values, return that. For all others, return a nullptr.
+   */
+  static nsStaticAtom* NormalizeARIAToken(const AttrArray* aAttrs,
+                                          nsAtom* aAttr);
+  static nsStaticAtom* NormalizeARIAToken(mozilla::dom::Element* aElement,
+                                          nsAtom* aAttr);
+
+  /**
+   * Return document accessible for the given DOM node.
+   */
+  static DocAccessible* GetDocAccessibleFor(nsINode* aNode) {
+    return GetAccService()->GetDocAccessible(
+        nsCoreUtils::GetPresShellFor(aNode));
+  }
+
+  /**
+   * Return document accessible for the given docshell.
+   */
+  static DocAccessible* GetDocAccessibleFor(nsIDocShellTreeItem* aContainer) {
+    nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(aContainer));
+    return GetAccService()->GetDocAccessible(docShell->GetPresShell());
+  }
+
+  /**
+   * Return single or multi selectable container for the given item.
+   *
+   * @param  aAccessible  [in] the item accessible
+   * @param  aState       [in] the state of the item accessible
+   */
+  static Accessible* GetSelectableContainer(const Accessible* aAccessible,
+                                            uint64_t aState);
+  static LocalAccessible* GetSelectableContainer(LocalAccessible* aAccessible,
+                                                 uint64_t aState);
+
+  /**
+   * Return a text container accessible for the given node.
+   */
+  static HyperTextAccessible* GetTextContainer(nsINode* aNode);
+
+  static Accessible* TableFor(Accessible* aRow);
+  static LocalAccessible* TableFor(LocalAccessible* aRow);
+
+  static const LocalAccessible* TableFor(const LocalAccessible* aAcc) {
+    return TableFor(const_cast<LocalAccessible*>(aAcc));
+  }
+
+  /**
+   * Return true if the DOM node of a given accessible has a given attribute
+   * with a value of "true".
+   */
+  static bool IsDOMAttrTrue(const LocalAccessible* aAccessible, nsAtom* aAttr);
+
+  /**
+   * Return true if the DOM node of given accessible has aria-selected="true"
+   * attribute.
+   */
+  static inline bool IsARIASelected(const LocalAccessible* aAccessible) {
+    return IsDOMAttrTrue(aAccessible, nsGkAtoms::aria_selected);
+  }
+
+  /**
+   * Return true if the DOM node of given accessible has
+   * aria-multiselectable="true" attribute.
+   */
+  static inline bool IsARIAMultiSelectable(const LocalAccessible* aAccessible) {
+    return IsDOMAttrTrue(aAccessible, nsGkAtoms::aria_multiselectable);
+  }
+
+  /**
+   * Converts the given coordinates to coordinates relative screen.
+   *
+   * @param aX               [in] the given x coord in dev pixels
+   * @param aY               [in] the given y coord in dev pixels
+   * @param aCoordinateType  [in] specifies coordinates origin (refer to
+   *                         nsIAccessibleCoordinateType)
+   * @param aAccessible      [in] the accessible if coordinates are given
+   *                         relative it.
+   * @return converted coordinates
+   */
+  static LayoutDeviceIntPoint ConvertToScreenCoords(int32_t aX, int32_t aY,
+                                                    uint32_t aCoordinateType,
+                                                    Accessible* aAccessible);
+
+  /**
+   * Converts the given coordinates relative screen to another coordinate
+   * system.
+   *
+   * @param aX               [in, out] the given x coord in dev pixels
+   * @param aY               [in, out] the given y coord in dev pixels
+   * @param aCoordinateType  [in] specifies coordinates origin (refer to
+   *                         nsIAccessibleCoordinateType)
+   * @param aAccessible      [in] the accessible if coordinates are given
+   *                         relative it
+   */
+  static void ConvertScreenCoordsTo(int32_t* aX, int32_t* aY,
+                                    uint32_t aCoordinateType,
+                                    Accessible* aAccessible);
+
+  /**
+   * Returns screen-relative coordinates (in dev pixels) for the parent of the
+   * given accessible.
+   *
+   * @param [in] aAccessible  the accessible
+   */
+  static LayoutDeviceIntPoint GetScreenCoordsForParent(Accessible* aAccessible);
+
+  /**
+   * Returns coordinates in device pixels relative screen for the top level
+   * window.
+   *
+   * @param aAccessible the acc hosted in the window.
+   */
+  static mozilla::LayoutDeviceIntPoint GetScreenCoordsForWindow(
+      mozilla::a11y::Accessible* aAccessible);
+
+  /**
+   * Get the 'live' or 'container-live' object attribute value from the given
+   * ELiveAttrRule constant.
+   *
+   * @param  aRule   [in] rule constant (see ELiveAttrRule in nsAccMap.h)
+   * @param  aValue  [out] object attribute value
+   *
+   * @return         true if object attribute should be exposed
+   */
+  static bool GetLiveAttrValue(uint32_t aRule, nsAString& aValue);
+
+#ifdef DEBUG
+  /**
+   * Detect whether the given accessible object implements nsIAccessibleText,
+   * when it is text or has text child node.
+   */
+  static bool IsTextInterfaceSupportCorrect(LocalAccessible* aAccessible);
+#endif
+
+  /**
+   * Return text length of the given accessible, return 0 on failure.
+   */
+  static uint32_t TextLength(Accessible* aAccessible);
+
+  /**
+   * Transform nsIAccessibleStates constants to internal state constant.
+   */
+  static inline uint64_t To64State(uint32_t aState1, uint32_t aState2) {
+    return static_cast<uint64_t>(aState1) +
+           (static_cast<uint64_t>(aState2) << 31);
+  }
+
+  /**
+   * Transform internal state constant to nsIAccessibleStates constants.
+   */
+  static inline void To32States(uint64_t aState64, uint32_t* aState1,
+                                uint32_t* aState2) {
+    *aState1 = aState64 & 0x7fffffff;
+    if (aState2) *aState2 = static_cast<uint32_t>(aState64 >> 31);
+  }
+
+  static uint32_t To32States(uint64_t aState, bool* aIsExtra) {
+    uint32_t extraState = aState >> 31;
+    *aIsExtra = !!extraState;
+    return extraState ? extraState : aState;
+  }
+
+  /**
+   * Return true if the given accessible can't have children. Used when exposing
+   * to platform accessibility APIs, should the children be pruned off?
+   */
+  static bool MustPrune(Accessible* aAccessible);
+
+  /**
+   * Return true if the given accessible is within an ARIA live region; i.e.
+   * the container-live attribute would be something other than "off" or empty.
+   */
+  static bool IsARIALive(const LocalAccessible* aAccessible);
+
+  /**
+   * Get the document Accessible which owns a given Accessible.
+   * This function is needed because there is no unified base class for local
+   * and remote documents.
+   * If aAcc is null, null will be returned.
+   */
+  static Accessible* DocumentFor(Accessible* aAcc);
+
+  /**
+   * Get an Accessible in a given document by its unique id.
+   * An Accessible's id can be obtained using Accessible::ID.
+   * This function is needed because there is no unified base class for local
+   * and remote documents.
+   * If aDoc is nul, null will be returned.
+   */
+  static Accessible* GetAccessibleByID(Accessible* aDoc, uint64_t aID);
+
+  /**
+   * Get the URL for a given document.
+   * This function is needed because there is no unified base class for local
+   * and remote documents.
+   */
+  static void DocumentURL(Accessible* aDoc, nsAString& aURL);
+
+  /**
+   * Get the mime type for a given document.
+   * This function is needed because there is no unified base class for local
+   * and remote documents.
+   */
+  static void DocumentMimeType(Accessible* aDoc, nsAString& aMimeType);
+
+  /**
+   * Accessors for element attributes that are aware of CustomElement ARIA
+   * accessibility defaults. If the element does not have the provided
+   * attribute defined directly on it, we will then attempt to fetch the
+   * default instead.
+   */
+  static const AttrArray* GetARIADefaults(dom::Element* aElement);
+  static bool HasARIAAttr(dom::Element* aElement, const nsAtom* aName);
+  static bool GetARIAAttr(dom::Element* aElement, const nsAtom* aName,
+                          nsAString& aResult);
+  static const nsAttrValue* GetARIAAttr(dom::Element* aElement,
+                                        const nsAtom* aName);
+  static bool ARIAAttrValueIs(dom::Element* aElement, const nsAtom* aName,
+                              const nsAString& aValue,
+                              nsCaseTreatment aCaseSensitive);
+  static bool ARIAAttrValueIs(dom::Element* aElement, const nsAtom* aName,
+                              const nsAtom* aValue,
+                              nsCaseTreatment aCaseSensitive);
+  static int32_t FindARIAAttrValueIn(dom::Element* aElement,
+                                     const nsAtom* aName,
+                                     AttrArray::AttrValuesArray* aValues,
+                                     nsCaseTreatment aCaseSensitive);
+};
+
+}  // namespace a11y
+}  // namespace mozilla
+
+#endif
diff --git a/accessible/base/nsAccessibilityService.cpp b/accessible/base/nsAccessibilityService.cpp
new file mode 100644
index 0000000000..c31dd666ce
--- /dev/null
+++ b/accessible/base/nsAccessibilityService.cpp
@@ -0,0 +1,1933 @@
+/* -*- 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 "nsAccessibilityService.h"
+
+// NOTE: alphabetically ordered
+#include "ApplicationAccessibleWrap.h"
+#include "ARIAGridAccessible.h"
+#include "ARIAMap.h"
+#include "DocAccessible-inl.h"
+#include "DocAccessibleChild.h"
+#include "FocusManager.h"
+#include "HTMLCanvasAccessible.h"
+#include "HTMLElementAccessibles.h"
+#include "HTMLImageMapAccessible.h"
+#include "HTMLLinkAccessible.h"
+#include "HTMLListAccessible.h"
+#include "HTMLSelectAccessible.h"
+#include "HTMLTableAccessible.h"
+#include "HyperTextAccessible.h"
+#include "RootAccessible.h"
+#include "nsAccUtils.h"
+#include "nsArrayUtils.h"
+#include "nsAttrName.h"
+#include "nsDOMTokenList.h"
+#include "nsCRT.h"
+#include "nsEventShell.h"
+#include "nsGkAtoms.h"
+#include "nsIFrameInlines.h"
+#include "nsServiceManagerUtils.h"
+#include "nsTextFormatter.h"
+#include "OuterDocAccessible.h"
+#include "mozilla/a11y/Role.h"
+#ifdef MOZ_ACCESSIBILITY_ATK
+#  include "RootAccessibleWrap.h"
+#endif
+#include "States.h"
+#include "Statistics.h"
+#include "TextLeafAccessible.h"
+#include "xpcAccessibleApplication.h"
+
+#ifdef XP_WIN
+#  include "mozilla/a11y/Compatibility.h"
+#  include "mozilla/StaticPtr.h"
+#endif
+
+#ifdef A11Y_LOG
+#  include "Logging.h"
+#endif
+
+#include "nsExceptionHandler.h"
+#include "nsImageFrame.h"
+#include "nsIObserverService.h"
+#include "nsMenuPopupFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsTreeBodyFrame.h"
+#include "nsTreeUtils.h"
+#include "mozilla/a11y/AccTypes.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/dom/DOMStringList.h"
+#include "mozilla/dom/EventTarget.h"
+#include "mozilla/dom/HTMLTableElement.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Services.h"
+
+#include "XULAlertAccessible.h"
+#include "XULComboboxAccessible.h"
+#include "XULElementAccessibles.h"
+#include "XULFormControlAccessible.h"
+#include "XULListboxAccessible.h"
+#include "XULMenuAccessible.h"
+#include "XULTabAccessible.h"
+#include "XULTreeGridAccessible.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+using namespace mozilla::dom;
+
+/**
+ * Accessibility service force enable/disable preference.
+ * Supported values:
+ *   Accessibility is force enabled (accessibility should always be enabled): -1
+ *   Accessibility is enabled (will be started upon a request, default value): 0
+ *   Accessibility is force disabled (never enable accessibility):             1
+ */
+#define PREF_ACCESSIBILITY_FORCE_DISABLED "accessibility.force_disabled"
+
+////////////////////////////////////////////////////////////////////////////////
+// Statics
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * If the element has an ARIA attribute that requires a specific Accessible
+ * class, create and return it. Otherwise, return null.
+ */
+static LocalAccessible* MaybeCreateSpecificARIAAccessible(
+    const nsRoleMapEntry* aRoleMapEntry, const LocalAccessible* aContext,
+    nsIContent* aContent, DocAccessible* aDocument) {
+  if (aRoleMapEntry && aRoleMapEntry->accTypes & eTableCell) {
+    if (aContent->IsAnyOfHTMLElements(nsGkAtoms::td, nsGkAtoms::th) &&
+        aContext->IsHTMLTableRow()) {
+      // Don't use ARIAGridCellAccessible for a valid td/th because
+      // HTMLTableCellAccessible can provide additional info; e.g. row/col span
+      // from the layout engine.
+      return nullptr;
+    }
+    // A cell must be in a row.
+    const Accessible* parent = aContext;
+    if (parent->IsGeneric()) {
+      parent = parent->GetNonGenericParent();
+    }
+    if (!parent || parent->Role() != roles::ROW) {
+      return nullptr;
+    }
+    // That row must be in a table, though there may be an intervening rowgroup.
+    parent = parent->GetNonGenericParent();
+    if (!parent) {
+      return nullptr;
+    }
+    if (!parent->IsTable() && parent->Role() == roles::GROUPING) {
+      parent = parent->GetNonGenericParent();
+      if (!parent) {
+        return nullptr;
+      }
+    }
+    if (parent->IsTable()) {
+      return new ARIAGridCellAccessible(aContent, aDocument);
+    }
+  }
+  return nullptr;
+}
+
+/**
+ * Return true if the element has an attribute (ARIA, title, or relation) that
+ * requires the creation of an Accessible for the element.
+ */
+static bool AttributesMustBeAccessible(nsIContent* aContent,
+                                       DocAccessible* aDocument) {
+  if (aContent->IsElement()) {
+    uint32_t attrCount = aContent->AsElement()->GetAttrCount();
+    for (uint32_t attrIdx = 0; attrIdx < attrCount; attrIdx++) {
+      const nsAttrName* attr = aContent->AsElement()->GetAttrNameAt(attrIdx);
+      if (attr->NamespaceEquals(kNameSpaceID_None)) {
+        nsAtom* attrAtom = attr->Atom();
+        if (attrAtom == nsGkAtoms::title && aContent->IsHTMLElement()) {
+          // If the author provided a title on an element that would not
+          // be accessible normally, assume an intent and make it accessible.
+          return true;
+        }
+
+        nsDependentAtomString attrStr(attrAtom);
+        if (!StringBeginsWith(attrStr, u"aria-"_ns)) continue;  // not ARIA
+
+        // A global state or a property and in case of token defined.
+        uint8_t attrFlags = aria::AttrCharacteristicsFor(attrAtom);
+        if ((attrFlags & ATTR_GLOBAL) &&
+            (!(attrFlags & ATTR_VALTOKEN) ||
+             nsAccUtils::HasDefinedARIAToken(aContent, attrAtom))) {
+          return true;
+        }
+      }
+    }
+
+    // If the given ID is referred by relation attribute then create an
+    // Accessible for it.
+    nsAutoString id;
+    if (nsCoreUtils::GetID(aContent, id) && !id.IsEmpty()) {
+      return aDocument->IsDependentID(aContent->AsElement(), id);
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Return true if the element must be a generic Accessible, even if it has been
+ * marked presentational with role="presentation", etc. MustBeAccessible causes
+ * an Accessible to be created as if it weren't marked presentational at all;
+ * e.g. <table role="presentation" tabindex="0"> will expose roles::TABLE and
+ * support TableAccessible. In contrast, this function causes a generic
+ * Accessible to be created; e.g. <table role="presentation" style="position:
+ * fixed;"> will expose roles::TEXT_CONTAINER and will not support
+ * TableAccessible. This is necessary in certain cases for the
+ * RemoteAccessible cache.
+ */
+static bool MustBeGenericAccessible(nsIContent* aContent,
+                                    DocAccessible* aDocument) {
+  if (aContent->IsInNativeAnonymousSubtree() || aContent->IsSVGElement()) {
+    // We should not force create accs for anonymous content.
+    // This is an issue for inputs, which have an intermediate
+    // container with relevant overflow styling between the input
+    // and its internal input content.
+    // We should also avoid this for SVG elements (ie. `<foreignobject>`s
+    // which have default overflow:hidden styling).
+    return false;
+  }
+  nsIFrame* frame = aContent->GetPrimaryFrame();
+  MOZ_ASSERT(frame);
+  nsAutoCString overflow;
+  frame->Style()->GetComputedPropertyValue(eCSSProperty_overflow, overflow);
+  // If the frame has been transformed, and the content has any children, we
+  // should create an Accessible so that we can account for the transform when
+  // calculating the Accessible's bounds using the parent process cache.
+  // Ditto for content which is position: fixed or sticky or has overflow
+  // styling (auto, scroll, hidden).
+  // However, don't do this for XUL widgets, as this breaks XUL a11y code
+  // expectations in some cases. XUL widgets are only used in the parent
+  // process and can't be cached anyway.
+  return !aContent->IsXULElement() &&
+         ((aContent->HasChildren() && frame->IsTransformed()) ||
+          frame->IsStickyPositioned() ||
+          (frame->StyleDisplay()->mPosition == StylePositionProperty::Fixed &&
+           nsLayoutUtils::IsReallyFixedPos(frame)) ||
+          overflow.Equals("auto"_ns) || overflow.Equals("scroll"_ns) ||
+          overflow.Equals("hidden"_ns));
+}
+
+/**
+ * Return true if the element must be accessible.
+ */
+static bool MustBeAccessible(nsIContent* aContent, DocAccessible* aDocument) {
+  nsIFrame* frame = aContent->GetPrimaryFrame();
+  MOZ_ASSERT(frame);
+  // This document might be invisible when it first loads. Therefore, we must
+  // check focusability irrespective of visibility here. Otherwise, we might not
+  // create Accessibles for some focusable elements; e.g. a span with only a
+  // tabindex. Elements that are invisible within this document are excluded
+  // earlier in CreateAccessible.
+  if (frame->IsFocusable(/* aWithMouse */ false,
+                         /* aCheckVisibility */ false)) {
+    return true;
+  }
+
+  return AttributesMustBeAccessible(aContent, aDocument);
+}
+
+bool nsAccessibilityService::ShouldCreateImgAccessible(
+    mozilla::dom::Element* aElement, DocAccessible* aDocument) {
+  // The element must have a layout frame for us to proceed. If there is no
+  // frame, the image is likely hidden.
+  nsIFrame* frame = aElement->GetPrimaryFrame();
+  if (!frame) {
+    return false;
+  }
+
+  // If the element is not an img, and also not an embedded image via embed or
+  // object, then we should not create an accessible.
+  if (!aElement->IsHTMLElement(nsGkAtoms::img) &&
+      ((!aElement->IsHTMLElement(nsGkAtoms::embed) &&
+        !aElement->IsHTMLElement(nsGkAtoms::object)) ||
+       frame->AccessibleType() != AccType::eImageType)) {
+    return false;
+  }
+
+  nsAutoString newAltText;
+  const bool hasAlt = aElement->GetAttr(nsGkAtoms::alt, newAltText);
+  if (!hasAlt || !newAltText.IsEmpty()) {
+    // If there is no alt attribute, we should create an accessible. The
+    // author may have missed the attribute, and the AT may want to provide a
+    // name. If there is alt text, we should create an accessible.
+    return true;
+  }
+
+  if (newAltText.IsEmpty() && (nsCoreUtils::HasClickListener(aElement) ||
+                               MustBeAccessible(aElement, aDocument))) {
+    // If there is empty alt text, but there is a click listener for this img,
+    // or if it otherwise must be an accessible (e.g., if it has an aria-label
+    // attribute), we should create an accessible.
+    return true;
+  }
+
+  // Otherwise, no alt text means we should not create an accessible.
+  return false;
+}
+
+/**
+ * Return true if the SVG element should be accessible
+ */
+static bool MustSVGElementBeAccessible(nsIContent* aContent,
+                                       DocAccessible* aDocument) {
+  // https://w3c.github.io/svg-aam/#include_elements
+  for (nsIContent* childElm = aContent->GetFirstChild(); childElm;
+       childElm = childElm->GetNextSibling()) {
+    if (childElm->IsAnyOfSVGElements(nsGkAtoms::title, nsGkAtoms::desc)) {
+      return true;
+    }
+  }
+  return MustBeAccessible(aContent, aDocument);
+}
+
+/**
+ * Used by XULMap.h to map both menupopup and popup elements
+ */
+LocalAccessible* CreateMenupopupAccessible(Element* aElement,
+                                           LocalAccessible* aContext) {
+#ifdef MOZ_ACCESSIBILITY_ATK
+  // ATK considers this node to be redundant when within menubars, and it makes
+  // menu navigation with assistive technologies more difficult
+  // XXX In the future we will should this for consistency across the
+  // nsIAccessible implementations on each platform for a consistent scripting
+  // environment, but then strip out redundant accessibles in the AccessibleWrap
+  // class for each platform.
+  nsIContent* parent = aElement->GetParent();
+  if (parent && parent->IsXULElement(nsGkAtoms::menu)) return nullptr;
+#endif
+
+  return new XULMenupopupAccessible(aElement, aContext->Document());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// LocalAccessible constructors
+
+static LocalAccessible* New_HyperText(Element* aElement,
+                                      LocalAccessible* aContext) {
+  return new HyperTextAccessible(aElement, aContext->Document());
+}
+
+template <typename AccClass>
+static LocalAccessible* New_HTMLDtOrDd(Element* aElement,
+                                       LocalAccessible* aContext) {
+  nsIContent* parent = aContext->GetContent();
+  if (parent->IsHTMLElement(nsGkAtoms::div)) {
+    // It is conforming in HTML to use a div to group dt/dd elements.
+    parent = parent->GetParent();
+  }
+
+  if (parent && parent->IsHTMLElement(nsGkAtoms::dl)) {
+    return new AccClass(aElement, aContext->Document());
+  }
+
+  return nullptr;
+}
+
+/**
+ * Cached value of the PREF_ACCESSIBILITY_FORCE_DISABLED preference.
+ */
+static int32_t sPlatformDisabledState = 0;
+
+////////////////////////////////////////////////////////////////////////////////
+// Markup maps array.
+
+#define Attr(name, value) \
+  { nsGkAtoms::name, nsGkAtoms::value }
+
+#define AttrFromDOM(name, DOMAttrName) \
+  { nsGkAtoms::name, nullptr, nsGkAtoms::DOMAttrName }
+
+#define AttrFromDOMIf(name, DOMAttrName, DOMAttrValue) \
+  { nsGkAtoms::name, nullptr, nsGkAtoms::DOMAttrName, nsGkAtoms::DOMAttrValue }
+
+#define MARKUPMAP(atom, new_func, r, ...) \
+  {nsGkAtoms::atom, new_func, static_cast<a11y::role>(r), {__VA_ARGS__}},
+
+static const MarkupMapInfo sHTMLMarkupMapList[] = {
+#include "HTMLMarkupMap.h"
+};
+
+static const MarkupMapInfo sMathMLMarkupMapList[] = {
+#include "MathMLMarkupMap.h"
+};
+
+#undef MARKUPMAP
+
+#define XULMAP(atom, ...) {nsGkAtoms::atom, __VA_ARGS__},
+
+#define XULMAP_TYPE(atom, new_type)                                          \
+  XULMAP(                                                                    \
+      atom,                                                                  \
+      [](Element* aElement, LocalAccessible* aContext) -> LocalAccessible* { \
+        return new new_type(aElement, aContext->Document());                 \
+      })
+
+static const XULMarkupMapInfo sXULMarkupMapList[] = {
+#include "XULMap.h"
+};
+
+#undef XULMAP_TYPE
+#undef XULMAP
+
+#undef Attr
+#undef AttrFromDOM
+#undef AttrFromDOMIf
+
+////////////////////////////////////////////////////////////////////////////////
+// nsAccessibilityService
+////////////////////////////////////////////////////////////////////////////////
+
+nsAccessibilityService* nsAccessibilityService::gAccessibilityService = nullptr;
+ApplicationAccessible* nsAccessibilityService::gApplicationAccessible = nullptr;
+xpcAccessibleApplication* nsAccessibilityService::gXPCApplicationAccessible =
+    nullptr;
+uint32_t nsAccessibilityService::gConsumers = 0;
+
+nsAccessibilityService::nsAccessibilityService()
+    : mHTMLMarkupMap(ArrayLength(sHTMLMarkupMapList)),
+      mMathMLMarkupMap(ArrayLength(sMathMLMarkupMapList)),
+      mXULMarkupMap(ArrayLength(sXULMarkupMapList)) {}
+
+nsAccessibilityService::~nsAccessibilityService() {
+  NS_ASSERTION(IsShutdown(), "Accessibility wasn't shutdown!");
+  gAccessibilityService = nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIListenerChangeListener
+
+NS_IMETHODIMP
+nsAccessibilityService::ListenersChanged(nsIArray* aEventChanges) {
+  uint32_t targetCount;
+  nsresult rv = aEventChanges->GetLength(&targetCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (uint32_t i = 0; i < targetCount; i++) {
+    nsCOMPtr<nsIEventListenerChange> change =
+        do_QueryElementAt(aEventChanges, i);
+
+    RefPtr<EventTarget> target;
+    change->GetTarget(getter_AddRefs(target));
+    nsIContent* content(nsIContent::FromEventTargetOrNull(target));
+    if (!content || !content->IsHTMLElement()) {
+      continue;
+    }
+
+    uint32_t changeCount;
+    change->GetCountOfEventListenerChangesAffectingAccessibility(&changeCount);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (changeCount) {
+      Document* ownerDoc = content->OwnerDoc();
+      DocAccessible* document = GetExistingDocAccessible(ownerDoc);
+
+      if (document) {
+        LocalAccessible* acc = document->GetAccessible(content);
+        if (!acc && (content == document->GetContent() ||
+                     content == document->DocumentNode()->GetRootElement())) {
+          acc = document;
+        }
+        if (!acc && content->IsElement() &&
+            content->AsElement()->IsHTMLElement(nsGkAtoms::area)) {
+          // For area accessibles, we have to recreate the entire image map,
+          // since the image map accessible manages the tree itself. The click
+          // listener change may require us to update the role for the
+          // accessible associated with the area element.
+          LocalAccessible* areaAcc =
+              document->GetAccessibleEvenIfNotInMap(content);
+          if (areaAcc && areaAcc->LocalParent()) {
+            document->RecreateAccessible(areaAcc->LocalParent()->GetContent());
+          }
+        }
+        if (!acc && nsCoreUtils::HasClickListener(content)) {
+          // Create an accessible for a inaccessible element having click event
+          // handler.
+          document->ContentInserted(content, content->GetNextSibling());
+        } else if (acc) {
+          if ((acc->IsHTMLLink() && !acc->AsHTMLLink()->IsLinked()) ||
+              (content->IsElement() &&
+               content->AsElement()->IsHTMLElement(nsGkAtoms::a) &&
+               !acc->IsHTMLLink())) {
+            // An HTML link without an href attribute should have a generic
+            // role, unless it has a click listener. Since we might have gained
+            // or lost a click listener here, recreate the accessible so that we
+            // can create the correct type of accessible. If it was a link, it
+            // may no longer be one. If it wasn't, it may become one.
+            document->RecreateAccessible(content);
+          }
+
+          // A click listener change might mean losing or gaining an action.
+          document->QueueCacheUpdate(acc, CacheDomain::Actions);
+        }
+      }
+    }
+  }
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsISupports
+
+NS_IMPL_ISUPPORTS_INHERITED(nsAccessibilityService, DocManager, nsIObserver,
+                            nsIListenerChangeListener,
+                            nsISelectionListener)  // from SelectionManager
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIObserver
+
+NS_IMETHODIMP
+nsAccessibilityService::Observe(nsISupports* aSubject, const char* aTopic,
+                                const char16_t* aData) {
+  if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
+    Shutdown();
+  }
+
+  return NS_OK;
+}
+
+void nsAccessibilityService::NotifyOfAnchorJumpTo(nsIContent* aTargetNode) {
+  Document* documentNode = aTargetNode->GetUncomposedDoc();
+  if (!documentNode) {
+    return;
+  }
+  DocAccessible* document = GetDocAccessible(documentNode);
+  if (!document) {
+    return;
+  }
+  // If the document has focus when we get this notification, ensure that
+  // we fire a start scrolling event.
+  const Accessible* focusedAcc = FocusedAccessible();
+  if (focusedAcc &&
+      (focusedAcc == document || focusedAcc->IsNonInteractive())) {
+    LocalAccessible* targetAcc = document->GetAccessible(aTargetNode);
+    if (targetAcc) {
+      nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_SCROLLING_START,
+                              targetAcc);
+      document->SetAnchorJump(nullptr);
+    } else {
+      // We can't find the target accessible in the document yet. Set the
+      // anchor jump so that we can fire the scrolling start event later.
+      document->SetAnchorJump(aTargetNode);
+    }
+  } else {
+    document->SetAnchorJump(aTargetNode);
+  }
+}
+
+void nsAccessibilityService::FireAccessibleEvent(uint32_t aEvent,
+                                                 LocalAccessible* aTarget) {
+  nsEventShell::FireEvent(aEvent, aTarget);
+}
+
+void nsAccessibilityService::NotifyOfPossibleBoundsChange(
+    mozilla::PresShell* aPresShell, nsIContent* aContent) {
+  if (IPCAccessibilityActive()) {
+    DocAccessible* document = aPresShell->GetDocAccessible();
+    if (document) {
+      // DocAccessible::GetAccessible() won't return the document if a root
+      // element like body is passed.
+      LocalAccessible* accessible = aContent == document->GetContent()
+                                        ? document
+                                        : document->GetAccessible(aContent);
+      if (accessible) {
+        document->QueueCacheUpdate(accessible, CacheDomain::Bounds);
+      }
+    }
+  }
+}
+
+void nsAccessibilityService::NotifyOfComputedStyleChange(
+    mozilla::PresShell* aPresShell, nsIContent* aContent) {
+  DocAccessible* document = aPresShell->GetDocAccessible();
+  if (!document) {
+    return;
+  }
+
+  // DocAccessible::GetAccessible() won't return the document if a root
+  // element like body is passed.
+  LocalAccessible* accessible = aContent == document->GetContent()
+                                    ? document
+                                    : document->GetAccessible(aContent);
+  if (!accessible && aContent && aContent->HasChildren() &&
+      !aContent->IsInNativeAnonymousSubtree()) {
+    // If the content has children and its frame has a transform, create an
+    // Accessible so that we can account for the transform when calculating
+    // the Accessible's bounds using the parent process cache. Ditto for
+    // position: fixed/sticky and content with overflow styling (hidden, auto,
+    // scroll)
+    if (const nsIFrame* frame = aContent->GetPrimaryFrame()) {
+      const auto& disp = *frame->StyleDisplay();
+      if (disp.HasTransform(frame) ||
+          disp.mPosition == StylePositionProperty::Fixed ||
+          disp.mPosition == StylePositionProperty::Sticky ||
+          disp.IsScrollableOverflow()) {
+        document->ContentInserted(aContent, aContent->GetNextSibling());
+      }
+    }
+  } else if (accessible && IPCAccessibilityActive()) {
+    accessible->MaybeQueueCacheUpdateForStyleChanges();
+  }
+}
+
+void nsAccessibilityService::NotifyOfResolutionChange(
+    mozilla::PresShell* aPresShell, float aResolution) {
+  DocAccessible* document = aPresShell->GetDocAccessible();
+  if (document && document->IPCDoc()) {
+    AutoTArray<mozilla::a11y::CacheData, 1> data;
+    RefPtr<AccAttributes> fields = new AccAttributes();
+    fields->SetAttribute(CacheKey::Resolution, aResolution);
+    data.AppendElement(mozilla::a11y::CacheData(0, fields));
+    document->IPCDoc()->SendCache(CacheUpdateType::Update, data);
+  }
+}
+
+void nsAccessibilityService::NotifyOfDevPixelRatioChange(
+    mozilla::PresShell* aPresShell, int32_t aAppUnitsPerDevPixel) {
+  DocAccessible* document = aPresShell->GetDocAccessible();
+  if (document && document->IPCDoc()) {
+    AutoTArray<mozilla::a11y::CacheData, 1> data;
+    RefPtr<AccAttributes> fields = new AccAttributes();
+    fields->SetAttribute(CacheKey::AppUnitsPerDevPixel, aAppUnitsPerDevPixel);
+    data.AppendElement(mozilla::a11y::CacheData(0, fields));
+    document->IPCDoc()->SendCache(CacheUpdateType::Update, data);
+  }
+}
+
+LocalAccessible* nsAccessibilityService::GetRootDocumentAccessible(
+    PresShell* aPresShell, bool aCanCreate) {
+  PresShell* presShell = aPresShell;
+  Document* documentNode = aPresShell->GetDocument();
+  if (documentNode) {
+    nsCOMPtr<nsIDocShellTreeItem> treeItem(documentNode->GetDocShell());
+    if (treeItem) {
+      nsCOMPtr<nsIDocShellTreeItem> rootTreeItem;
+      treeItem->GetInProcessRootTreeItem(getter_AddRefs(rootTreeItem));
+      if (treeItem != rootTreeItem) {
+        nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(rootTreeItem));
+        presShell = docShell->GetPresShell();
+      }
+
+      return aCanCreate ? GetDocAccessible(presShell)
+                        : presShell->GetDocAccessible();
+    }
+  }
+  return nullptr;
+}
+
+void nsAccessibilityService::NotifyOfTabPanelVisibilityChange(
+    PresShell* aPresShell, Element* aPanel, bool aNowVisible) {
+  MOZ_ASSERT(aPanel->GetParent()->IsXULElement(nsGkAtoms::tabpanels));
+
+  DocAccessible* document = GetDocAccessible(aPresShell);
+  if (!document) {
+    return;
+  }
+
+  if (LocalAccessible* acc = document->GetAccessible(aPanel)) {
+    RefPtr<AccEvent> event =
+        new AccStateChangeEvent(acc, states::OFFSCREEN, aNowVisible);
+    document->FireDelayedEvent(event);
+  }
+}
+
+void nsAccessibilityService::ContentRangeInserted(PresShell* aPresShell,
+                                                  nsIContent* aStartChild,
+                                                  nsIContent* aEndChild) {
+  DocAccessible* document = GetDocAccessible(aPresShell);
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eTree)) {
+    logging::MsgBegin("TREE", "content inserted; doc: %p", document);
+    logging::Node("container", aStartChild->GetParentNode());
+    for (nsIContent* child = aStartChild; child != aEndChild;
+         child = child->GetNextSibling()) {
+      logging::Node("content", child);
+    }
+    logging::MsgEnd();
+    logging::Stack();
+  }
+#endif
+
+  if (document) {
+    document->ContentInserted(aStartChild, aEndChild);
+  }
+}
+
+void nsAccessibilityService::ScheduleAccessibilitySubtreeUpdate(
+    PresShell* aPresShell, nsIContent* aContent) {
+  DocAccessible* document = GetDocAccessible(aPresShell);
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eTree)) {
+    logging::MsgBegin("TREE", "schedule update; doc: %p", document);
+    logging::Node("content node", aContent);
+    logging::MsgEnd();
+  }
+#endif
+
+  if (document) {
+    document->ScheduleTreeUpdate(aContent);
+  }
+}
+
+void nsAccessibilityService::ContentRemoved(PresShell* aPresShell,
+                                            nsIContent* aChildNode) {
+  DocAccessible* document = GetDocAccessible(aPresShell);
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eTree)) {
+    logging::MsgBegin("TREE", "content removed; doc: %p", document);
+    logging::Node("container node", aChildNode->GetFlattenedTreeParent());
+    logging::Node("content node", aChildNode);
+    logging::MsgEnd();
+  }
+#endif
+
+  if (document) {
+    document->ContentRemoved(aChildNode);
+  }
+
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eTree)) {
+    logging::MsgEnd();
+    logging::Stack();
+  }
+#endif
+}
+
+void nsAccessibilityService::TableLayoutGuessMaybeChanged(
+    PresShell* aPresShell, nsIContent* aContent) {
+  if (DocAccessible* document = GetDocAccessible(aPresShell)) {
+    if (LocalAccessible* acc = document->GetAccessible(aContent)) {
+      if (LocalAccessible* table = nsAccUtils::TableFor(acc)) {
+        document->QueueCacheUpdate(table, CacheDomain::Table);
+      }
+    }
+  }
+}
+
+void nsAccessibilityService::ComboboxOptionMaybeChanged(
+    PresShell* aPresShell, nsIContent* aMutatingNode) {
+  DocAccessible* document = GetDocAccessible(aPresShell);
+  if (!document) {
+    return;
+  }
+
+  for (nsIContent* cur = aMutatingNode; cur; cur = cur->GetParent()) {
+    if (cur->IsHTMLElement(nsGkAtoms::option)) {
+      if (LocalAccessible* accessible = document->GetAccessible(cur)) {
+        document->FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE,
+                                   accessible);
+        break;
+      }
+      if (cur->IsHTMLElement(nsGkAtoms::select)) {
+        break;
+      }
+    }
+  }
+}
+
+void nsAccessibilityService::UpdateText(PresShell* aPresShell,
+                                        nsIContent* aContent) {
+  DocAccessible* document = GetDocAccessible(aPresShell);
+  if (document) document->UpdateText(aContent);
+}
+
+void nsAccessibilityService::TreeViewChanged(PresShell* aPresShell,
+                                             nsIContent* aContent,
+                                             nsITreeView* aView) {
+  DocAccessible* document = GetDocAccessible(aPresShell);
+  if (document) {
+    LocalAccessible* accessible = document->GetAccessible(aContent);
+    if (accessible) {
+      XULTreeAccessible* treeAcc = accessible->AsXULTree();
+      if (treeAcc) treeAcc->TreeViewChanged(aView);
+    }
+  }
+}
+
+void nsAccessibilityService::RangeValueChanged(PresShell* aPresShell,
+                                               nsIContent* aContent) {
+  DocAccessible* document = GetDocAccessible(aPresShell);
+  if (document) {
+    LocalAccessible* accessible = document->GetAccessible(aContent);
+    if (accessible) {
+      document->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE,
+                                 accessible);
+    }
+  }
+}
+
+void nsAccessibilityService::UpdateImageMap(nsImageFrame* aImageFrame) {
+  PresShell* presShell = aImageFrame->PresShell();
+  DocAccessible* document = GetDocAccessible(presShell);
+  if (document) {
+    LocalAccessible* accessible =
+        document->GetAccessible(aImageFrame->GetContent());
+    if (accessible) {
+      HTMLImageMapAccessible* imageMap = accessible->AsImageMap();
+      if (imageMap) {
+        imageMap->UpdateChildAreas();
+        return;
+      }
+
+      // If image map was initialized after we created an accessible (that'll
+      // be an image accessible) then recreate it.
+      RecreateAccessible(presShell, aImageFrame->GetContent());
+    }
+  }
+}
+
+void nsAccessibilityService::UpdateLabelValue(PresShell* aPresShell,
+                                              nsIContent* aLabelElm,
+                                              const nsString& aNewValue) {
+  DocAccessible* document = GetDocAccessible(aPresShell);
+  if (document) {
+    LocalAccessible* accessible = document->GetAccessible(aLabelElm);
+    if (accessible) {
+      XULLabelAccessible* xulLabel = accessible->AsXULLabel();
+      NS_ASSERTION(xulLabel,
+                   "UpdateLabelValue was called for wrong accessible!");
+      if (xulLabel) xulLabel->UpdateLabelValue(aNewValue);
+    }
+  }
+}
+
+void nsAccessibilityService::PresShellActivated(PresShell* aPresShell) {
+  DocAccessible* document = aPresShell->GetDocAccessible();
+  if (document) {
+    RootAccessible* rootDocument = document->RootAccessible();
+    NS_ASSERTION(rootDocument, "Entirely broken tree: no root document!");
+    if (rootDocument) rootDocument->DocumentActivated(document);
+  }
+}
+
+void nsAccessibilityService::RecreateAccessible(PresShell* aPresShell,
+                                                nsIContent* aContent) {
+  DocAccessible* document = GetDocAccessible(aPresShell);
+  if (document) document->RecreateAccessible(aContent);
+}
+
+void nsAccessibilityService::GetStringRole(uint32_t aRole, nsAString& aString) {
+#define ROLE(geckoRole, stringRole, ariaRole, atkRole, macRole, macSubrole, \
+             msaaRole, ia2Role, androidClass, nameRule)                     \
+  case roles::geckoRole:                                                    \
+    aString.AssignLiteral(stringRole);                                      \
+    return;
+
+  switch (aRole) {
+#include "RoleMap.h"
+    default:
+      aString.AssignLiteral("unknown");
+      return;
+  }
+
+#undef ROLE
+}
+
+void nsAccessibilityService::GetStringStates(uint32_t aState,
+                                             uint32_t aExtraState,
+                                             nsISupports** aStringStates) {
+  RefPtr<DOMStringList> stringStates =
+      GetStringStates(nsAccUtils::To64State(aState, aExtraState));
+
+  // unknown state
+  if (!stringStates->Length()) {
+    stringStates->Add(u"unknown"_ns);
+  }
+
+  stringStates.forget(aStringStates);
+}
+
+already_AddRefed<DOMStringList> nsAccessibilityService::GetStringStates(
+    uint64_t aStates) const {
+  RefPtr<DOMStringList> stringStates = new DOMStringList();
+
+  if (aStates & states::UNAVAILABLE) {
+    stringStates->Add(u"unavailable"_ns);
+  }
+  if (aStates & states::SELECTED) {
+    stringStates->Add(u"selected"_ns);
+  }
+  if (aStates & states::FOCUSED) {
+    stringStates->Add(u"focused"_ns);
+  }
+  if (aStates & states::PRESSED) {
+    stringStates->Add(u"pressed"_ns);
+  }
+  if (aStates & states::CHECKED) {
+    stringStates->Add(u"checked"_ns);
+  }
+  if (aStates & states::MIXED) {
+    stringStates->Add(u"mixed"_ns);
+  }
+  if (aStates & states::READONLY) {
+    stringStates->Add(u"readonly"_ns);
+  }
+  if (aStates & states::HOTTRACKED) {
+    stringStates->Add(u"hottracked"_ns);
+  }
+  if (aStates & states::DEFAULT) {
+    stringStates->Add(u"default"_ns);
+  }
+  if (aStates & states::EXPANDED) {
+    stringStates->Add(u"expanded"_ns);
+  }
+  if (aStates & states::COLLAPSED) {
+    stringStates->Add(u"collapsed"_ns);
+  }
+  if (aStates & states::BUSY) {
+    stringStates->Add(u"busy"_ns);
+  }
+  if (aStates & states::FLOATING) {
+    stringStates->Add(u"floating"_ns);
+  }
+  if (aStates & states::ANIMATED) {
+    stringStates->Add(u"animated"_ns);
+  }
+  if (aStates & states::INVISIBLE) {
+    stringStates->Add(u"invisible"_ns);
+  }
+  if (aStates & states::OFFSCREEN) {
+    stringStates->Add(u"offscreen"_ns);
+  }
+  if (aStates & states::SIZEABLE) {
+    stringStates->Add(u"sizeable"_ns);
+  }
+  if (aStates & states::MOVEABLE) {
+    stringStates->Add(u"moveable"_ns);
+  }
+  if (aStates & states::SELFVOICING) {
+    stringStates->Add(u"selfvoicing"_ns);
+  }
+  if (aStates & states::FOCUSABLE) {
+    stringStates->Add(u"focusable"_ns);
+  }
+  if (aStates & states::SELECTABLE) {
+    stringStates->Add(u"selectable"_ns);
+  }
+  if (aStates & states::LINKED) {
+    stringStates->Add(u"linked"_ns);
+  }
+  if (aStates & states::TRAVERSED) {
+    stringStates->Add(u"traversed"_ns);
+  }
+  if (aStates & states::MULTISELECTABLE) {
+    stringStates->Add(u"multiselectable"_ns);
+  }
+  if (aStates & states::EXTSELECTABLE) {
+    stringStates->Add(u"extselectable"_ns);
+  }
+  if (aStates & states::PROTECTED) {
+    stringStates->Add(u"protected"_ns);
+  }
+  if (aStates & states::HASPOPUP) {
+    stringStates->Add(u"haspopup"_ns);
+  }
+  if (aStates & states::REQUIRED) {
+    stringStates->Add(u"required"_ns);
+  }
+  if (aStates & states::ALERT) {
+    stringStates->Add(u"alert"_ns);
+  }
+  if (aStates & states::INVALID) {
+    stringStates->Add(u"invalid"_ns);
+  }
+  if (aStates & states::CHECKABLE) {
+    stringStates->Add(u"checkable"_ns);
+  }
+  if (aStates & states::SUPPORTS_AUTOCOMPLETION) {
+    stringStates->Add(u"autocompletion"_ns);
+  }
+  if (aStates & states::DEFUNCT) {
+    stringStates->Add(u"defunct"_ns);
+  }
+  if (aStates & states::SELECTABLE_TEXT) {
+    stringStates->Add(u"selectable text"_ns);
+  }
+  if (aStates & states::EDITABLE) {
+    stringStates->Add(u"editable"_ns);
+  }
+  if (aStates & states::ACTIVE) {
+    stringStates->Add(u"active"_ns);
+  }
+  if (aStates & states::MODAL) {
+    stringStates->Add(u"modal"_ns);
+  }
+  if (aStates & states::MULTI_LINE) {
+    stringStates->Add(u"multi line"_ns);
+  }
+  if (aStates & states::HORIZONTAL) {
+    stringStates->Add(u"horizontal"_ns);
+  }
+  if (aStates & states::OPAQUE1) {
+    stringStates->Add(u"opaque"_ns);
+  }
+  if (aStates & states::SINGLE_LINE) {
+    stringStates->Add(u"single line"_ns);
+  }
+  if (aStates & states::TRANSIENT) {
+    stringStates->Add(u"transient"_ns);
+  }
+  if (aStates & states::VERTICAL) {
+    stringStates->Add(u"vertical"_ns);
+  }
+  if (aStates & states::STALE) {
+    stringStates->Add(u"stale"_ns);
+  }
+  if (aStates & states::ENABLED) {
+    stringStates->Add(u"enabled"_ns);
+  }
+  if (aStates & states::SENSITIVE) {
+    stringStates->Add(u"sensitive"_ns);
+  }
+  if (aStates & states::EXPANDABLE) {
+    stringStates->Add(u"expandable"_ns);
+  }
+  if (aStates & states::PINNED) {
+    stringStates->Add(u"pinned"_ns);
+  }
+  if (aStates & states::CURRENT) {
+    stringStates->Add(u"current"_ns);
+  }
+
+  return stringStates.forget();
+}
+
+void nsAccessibilityService::GetStringEventType(uint32_t aEventType,
+                                                nsAString& aString) {
+  static_assert(
+      nsIAccessibleEvent::EVENT_LAST_ENTRY == ArrayLength(kEventTypeNames),
+      "nsIAccessibleEvent constants are out of sync to kEventTypeNames");
+
+  if (aEventType >= ArrayLength(kEventTypeNames)) {
+    aString.AssignLiteral("unknown");
+    return;
+  }
+
+  aString.AssignASCII(kEventTypeNames[aEventType]);
+}
+
+void nsAccessibilityService::GetStringEventType(uint32_t aEventType,
+                                                nsACString& aString) {
+  MOZ_ASSERT(
+      nsIAccessibleEvent::EVENT_LAST_ENTRY == ArrayLength(kEventTypeNames),
+      "nsIAccessibleEvent constants are out of sync to kEventTypeNames");
+
+  if (aEventType >= ArrayLength(kEventTypeNames)) {
+    aString.AssignLiteral("unknown");
+    return;
+  }
+
+  aString = nsDependentCString(kEventTypeNames[aEventType]);
+}
+
+void nsAccessibilityService::GetStringRelationType(uint32_t aRelationType,
+                                                   nsAString& aString) {
+  NS_ENSURE_TRUE_VOID(aRelationType <=
+                      static_cast<uint32_t>(RelationType::LAST));
+
+#define RELATIONTYPE(geckoType, geckoTypeName, atkType, msaaType, ia2Type) \
+  case RelationType::geckoType:                                            \
+    aString.AssignLiteral(geckoTypeName);                                  \
+    return;
+
+  RelationType relationType = static_cast<RelationType>(aRelationType);
+  switch (relationType) {
+#include "RelationTypeMap.h"
+    default:
+      aString.AssignLiteral("unknown");
+      return;
+  }
+
+#undef RELATIONTYPE
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsAccessibilityService public
+
+LocalAccessible* nsAccessibilityService::CreateAccessible(
+    nsINode* aNode, LocalAccessible* aContext, bool* aIsSubtreeHidden) {
+  MOZ_ASSERT(aContext, "No context provided");
+  MOZ_ASSERT(aNode, "No node to create an accessible for");
+  MOZ_ASSERT(gConsumers, "No creation after shutdown");
+
+  if (aIsSubtreeHidden) *aIsSubtreeHidden = false;
+
+  DocAccessible* document = aContext->Document();
+  MOZ_ASSERT(!document->GetAccessible(aNode),
+             "We already have an accessible for this node.");
+
+  if (aNode->IsDocument()) {
+    // If it's document node then ask accessible document loader for
+    // document accessible, otherwise return null.
+    return GetDocAccessible(aNode->AsDocument());
+  }
+
+  // We have a content node.
+  if (!aNode->GetComposedDoc()) {
+    NS_WARNING("Creating accessible for node with no document");
+    return nullptr;
+  }
+
+  if (aNode->OwnerDoc() != document->DocumentNode()) {
+    NS_ERROR("Creating accessible for wrong document");
+    return nullptr;
+  }
+
+  if (!aNode->IsContent()) return nullptr;
+
+  nsIContent* content = aNode->AsContent();
+  if (aria::HasDefinedARIAHidden(content)) {
+    if (aIsSubtreeHidden) {
+      *aIsSubtreeHidden = true;
+    }
+    return nullptr;
+  }
+
+  // Check frame and its visibility.
+  nsIFrame* frame = content->GetPrimaryFrame();
+  if (frame) {
+    // If invisible or inert, we don't create an accessible, but we don't mark
+    // it with aIsSubtreeHidden = true, since visibility: hidden frame allows
+    // visible elements in subtree, and inert elements allow non-inert
+    // elements.
+    if (!frame->StyleVisibility()->IsVisible() || frame->StyleUI()->IsInert()) {
+      return nullptr;
+    }
+  } else if (nsCoreUtils::CanCreateAccessibleWithoutFrame(content)) {
+    // display:contents element doesn't have a frame, but retains the
+    // semantics. All its children are unaffected.
+    const nsRoleMapEntry* roleMapEntry = aria::GetRoleMap(content->AsElement());
+    RefPtr<LocalAccessible> newAcc = MaybeCreateSpecificARIAAccessible(
+        roleMapEntry, aContext, content, document);
+    const MarkupMapInfo* markupMap = nullptr;
+    if (!newAcc) {
+      markupMap = GetMarkupMapInfoFor(content);
+      if (markupMap && markupMap->new_func) {
+        newAcc = markupMap->new_func(content->AsElement(), aContext);
+      }
+    }
+
+    // Check whether this element has an ARIA role or attribute that requires
+    // us to create an Accessible.
+    const bool hasNonPresentationalARIARole =
+        roleMapEntry && !roleMapEntry->Is(nsGkAtoms::presentation) &&
+        !roleMapEntry->Is(nsGkAtoms::none);
+    if (!newAcc && (hasNonPresentationalARIARole ||
+                    AttributesMustBeAccessible(content, document))) {
+      newAcc = new HyperTextAccessible(content, document);
+    }
+
+    // If there's still no Accessible but we do have an entry in the markup
+    // map for this non-presentational element, create a generic
+    // HyperTextAccessible.
+    if (!newAcc && markupMap &&
+        (!roleMapEntry || hasNonPresentationalARIARole)) {
+      newAcc = new HyperTextAccessible(content, document);
+    }
+
+    if (newAcc) {
+      document->BindToDocument(newAcc, roleMapEntry);
+    }
+    return newAcc;
+  } else {
+    if (aIsSubtreeHidden) {
+      *aIsSubtreeHidden = true;
+    }
+    return nullptr;
+  }
+
+  if (frame->IsHiddenByContentVisibilityOnAnyAncestor(
+          nsIFrame::IncludeContentVisibility::Hidden)) {
+    if (aIsSubtreeHidden) {
+      *aIsSubtreeHidden = true;
+    }
+    return nullptr;
+  }
+
+  if (nsMenuPopupFrame* popupFrame = do_QueryFrame(frame)) {
+    // Hidden tooltips and panels don't create accessibles in the whole subtree.
+    // Showing them gets handled by RootAccessible::ProcessDOMEvent.
+    if (content->IsAnyOfXULElements(nsGkAtoms::tooltip, nsGkAtoms::panel)) {
+      nsPopupState popupState = popupFrame->PopupState();
+      if (popupState == ePopupHiding || popupState == ePopupInvisible ||
+          popupState == ePopupClosed) {
+        if (aIsSubtreeHidden) {
+          *aIsSubtreeHidden = true;
+        }
+        return nullptr;
+      }
+    }
+  }
+
+  if (frame->GetContent() != content) {
+    // Not the main content for this frame. This happens because <area>
+    // elements return the image frame as their primary frame. The main content
+    // for the image frame is the image content. If the frame is not an image
+    // frame or the node is not an area element then null is returned.
+    // This setup will change when bug 135040 is fixed. Make sure we don't
+    // create area accessible here. Hopefully assertion below will handle that.
+
+#ifdef DEBUG
+    nsImageFrame* imageFrame = do_QueryFrame(frame);
+    NS_ASSERTION(imageFrame && content->IsHTMLElement(nsGkAtoms::area),
+                 "Unknown case of not main content for the frame!");
+#endif
+    return nullptr;
+  }
+
+#ifdef DEBUG
+  nsImageFrame* imageFrame = do_QueryFrame(frame);
+  NS_ASSERTION(!imageFrame || !content->IsHTMLElement(nsGkAtoms::area),
+               "Image map manages the area accessible creation!");
+#endif
+
+  // Attempt to create an accessible based on what we know.
+  RefPtr<LocalAccessible> newAcc;
+
+  // Create accessible for visible text frames.
+  if (content->IsText()) {
+    nsIFrame::RenderedText text = frame->GetRenderedText(
+        0, UINT32_MAX, nsIFrame::TextOffsetType::OffsetsInContentText,
+        nsIFrame::TrailingWhitespace::DontTrim);
+    // Ignore not rendered text nodes and whitespace text nodes between table
+    // cells.
+    if (text.mString.IsEmpty() ||
+        (aContext->IsTableRow() &&
+         nsCoreUtils::IsWhitespaceString(text.mString))) {
+      if (aIsSubtreeHidden) *aIsSubtreeHidden = true;
+
+      return nullptr;
+    }
+
+    newAcc = CreateAccessibleByFrameType(frame, content, aContext);
+    MOZ_ASSERT(newAcc, "Accessible not created for text node!");
+    document->BindToDocument(newAcc, nullptr);
+    newAcc->AsTextLeaf()->SetText(text.mString);
+    return newAcc;
+  }
+
+  if (content->IsHTMLElement(nsGkAtoms::map)) {
+    // Create hyper text accessible for HTML map if it is used to group links
+    // (see http://www.w3.org/TR/WCAG10-HTML-TECHS/#group-bypass). If the HTML
+    // map rect is empty then it is used for links grouping. Otherwise it should
+    // be used in conjunction with HTML image element and in this case we don't
+    // create any accessible for it and don't walk into it. The accessibles for
+    // HTML area (HTMLAreaAccessible) the map contains are attached as
+    // children of the appropriate accessible for HTML image
+    // (ImageAccessible).
+    if (nsLayoutUtils::GetAllInFlowRectsUnion(frame, frame->GetParent())
+            .IsEmpty()) {
+      if (aIsSubtreeHidden) *aIsSubtreeHidden = true;
+
+      return nullptr;
+    }
+
+    newAcc = new HyperTextAccessible(content, document);
+    document->BindToDocument(newAcc, aria::GetRoleMap(content->AsElement()));
+    return newAcc;
+  }
+
+  const nsRoleMapEntry* roleMapEntry = aria::GetRoleMap(content->AsElement());
+
+  if (roleMapEntry && (roleMapEntry->Is(nsGkAtoms::presentation) ||
+                       roleMapEntry->Is(nsGkAtoms::none))) {
+    if (MustBeAccessible(content, document)) {
+      // If the element is focusable, a global ARIA attribute is applied to it
+      // or it is referenced by an ARIA relationship, then treat
+      // role="presentation" on the element as if the role is not there.
+      roleMapEntry = nullptr;
+    } else if (MustBeGenericAccessible(content, document)) {
+      // Clear roleMapEntry so that we use the generic role specified below.
+      // Otherwise, we'd expose roles::NOTHING as specified for presentation in
+      // ARIAMap.
+      roleMapEntry = nullptr;
+      newAcc = new EnumRoleHyperTextAccessible<roles::TEXT_CONTAINER>(content,
+                                                                      document);
+    } else {
+      return nullptr;
+    }
+  }
+
+  // We should always use OuterDocAccessible for OuterDocs, even if there's a
+  // specific ARIA class we would otherwise use.
+  if (!newAcc && frame->AccessibleType() != eOuterDocType) {
+    newAcc = MaybeCreateSpecificARIAAccessible(roleMapEntry, aContext, content,
+                                               document);
+  }
+
+  if (!newAcc && content->IsHTMLElement()) {  // HTML accessibles
+    // Prefer to use markup to decide if and what kind of accessible to
+    // create,
+    const MarkupMapInfo* markupMap =
+        mHTMLMarkupMap.Get(content->NodeInfo()->NameAtom());
+    if (markupMap && markupMap->new_func) {
+      newAcc = markupMap->new_func(content->AsElement(), aContext);
+    }
+
+    if (!newAcc) {  // try by frame accessible type.
+      newAcc = CreateAccessibleByFrameType(frame, content, aContext);
+    }
+
+    // If table has strong ARIA role then all table descendants shouldn't
+    // expose their native roles.
+    if (!roleMapEntry && newAcc && aContext->HasStrongARIARole()) {
+      if (frame->AccessibleType() == eHTMLTableRowType) {
+        const nsRoleMapEntry* contextRoleMap = aContext->ARIARoleMap();
+        if (!contextRoleMap->IsOfType(eTable)) {
+          roleMapEntry = &aria::gEmptyRoleMap;
+        }
+
+      } else if (frame->AccessibleType() == eHTMLTableCellType &&
+                 aContext->ARIARoleMap() == &aria::gEmptyRoleMap) {
+        roleMapEntry = &aria::gEmptyRoleMap;
+
+      } else if (content->IsAnyOfHTMLElements(nsGkAtoms::dt, nsGkAtoms::li,
+                                              nsGkAtoms::dd) ||
+                 frame->AccessibleType() == eHTMLLiType) {
+        const nsRoleMapEntry* contextRoleMap = aContext->ARIARoleMap();
+        if (!contextRoleMap->IsOfType(eList)) {
+          roleMapEntry = &aria::gEmptyRoleMap;
+        }
+      }
+    }
+  }
+
+  // XUL accessibles.
+  if (!newAcc && content->IsXULElement()) {
+    if (content->IsXULElement(nsGkAtoms::panel)) {
+      // We filter here instead of in the XUL map because
+      // if we filter there and return null, we still end up
+      // creating a generic accessible at the end of this function.
+      // Doing the filtering here ensures we never create accessibles
+      // for panels whose popups aren't visible.
+      nsMenuPopupFrame* popupFrame = do_QueryFrame(frame);
+      if (!popupFrame) {
+        return nullptr;
+      }
+
+      nsPopupState popupState = popupFrame->PopupState();
+      if (popupState == ePopupHiding || popupState == ePopupInvisible ||
+          popupState == ePopupClosed) {
+        return nullptr;
+      }
+    }
+
+    // Prefer to use XUL to decide if and what kind of accessible to create.
+    const XULMarkupMapInfo* xulMap =
+        mXULMarkupMap.Get(content->NodeInfo()->NameAtom());
+    if (xulMap && xulMap->new_func) {
+      newAcc = xulMap->new_func(content->AsElement(), aContext);
+    }
+
+    // Any XUL/flex box can be used as tabpanel, make sure we create a proper
+    // accessible for it.
+    if (!newAcc && aContext->IsXULTabpanels() &&
+        content->GetParent() == aContext->GetContent()) {
+      LayoutFrameType frameType = frame->Type();
+      // FIXME(emilio): Why only these frame types?
+      if (frameType == LayoutFrameType::FlexContainer ||
+          frameType == LayoutFrameType::Scroll) {
+        newAcc = new XULTabpanelAccessible(content, document);
+      }
+    }
+  }
+
+  if (!newAcc) {
+    if (content->IsSVGElement()) {
+      if (content->IsSVGGeometryElement() ||
+          content->IsSVGElement(nsGkAtoms::image)) {
+        // Shape elements: rect, circle, ellipse, line, path, polygon,
+        // and polyline. 'use' and 'text' graphic elements require
+        // special support.
+        if (MustSVGElementBeAccessible(content, document)) {
+          newAcc = new EnumRoleAccessible<roles::GRAPHIC>(content, document);
+        }
+      } else if (content->IsSVGElement(nsGkAtoms::text)) {
+        newAcc = new HyperTextAccessible(content->AsElement(), document);
+      } else if (content->IsSVGElement(nsGkAtoms::svg)) {
+        // An <svg> element could contain <foreignObject>, which contains HTML
+        // but does not normally create its own Accessible. This means that the
+        // <svg> Accessible could have TextLeafAccessible children, so it must
+        // be a HyperTextAccessible.
+        newAcc =
+            new EnumRoleHyperTextAccessible<roles::DIAGRAM>(content, document);
+      } else if (content->IsSVGElement(nsGkAtoms::g) &&
+                 MustSVGElementBeAccessible(content, document)) {
+        // <g> can also contain <foreignObject>.
+        newAcc =
+            new EnumRoleHyperTextAccessible<roles::GROUPING>(content, document);
+      } else if (content->IsSVGElement(nsGkAtoms::a)) {
+        newAcc = new HTMLLinkAccessible(content, document);
+      }
+
+    } else if (content->IsMathMLElement()) {
+      const MarkupMapInfo* markupMap =
+          mMathMLMarkupMap.Get(content->NodeInfo()->NameAtom());
+      if (markupMap && markupMap->new_func) {
+        newAcc = markupMap->new_func(content->AsElement(), aContext);
+      }
+
+      // Fall back to text when encountering Content MathML.
+      if (!newAcc && !content->IsAnyOfMathMLElements(
+                         nsGkAtoms::annotation_, nsGkAtoms::annotation_xml_,
+                         nsGkAtoms::mpadded_, nsGkAtoms::mphantom_,
+                         nsGkAtoms::maligngroup_, nsGkAtoms::malignmark_,
+                         nsGkAtoms::mspace_, nsGkAtoms::semantics_)) {
+        newAcc = new HyperTextAccessible(content, document);
+      }
+    } else if (content->IsGeneratedContentContainerForMarker()) {
+      if (aContext->IsHTMLListItem()) {
+        newAcc = new HTMLListBulletAccessible(content, document);
+      }
+      if (aIsSubtreeHidden) {
+        *aIsSubtreeHidden = true;
+      }
+    }
+  }
+
+  // If no accessible, see if we need to create a generic accessible because
+  // of some property that makes this object interesting
+  // We don't do this for <body>, <html>, <window>, <dialog> etc. which
+  // correspond to the doc accessible and will be created in any case
+  if (!newAcc && !content->IsHTMLElement(nsGkAtoms::body) &&
+      content->GetParent() &&
+      (roleMapEntry || MustBeAccessible(content, document) ||
+       (content->IsHTMLElement() && nsCoreUtils::HasClickListener(content)))) {
+    // This content is focusable or has an interesting dynamic content
+    // accessibility property. If it's interesting we need it in the
+    // accessibility hierarchy so that events or other accessibles can point to
+    // it, or so that it can hold a state, etc.
+    if (content->IsHTMLElement() || content->IsMathMLElement() ||
+        content->IsSVGElement(nsGkAtoms::foreignObject)) {
+      // Interesting container which may have selectable text and/or embedded
+      // objects.
+      newAcc = new HyperTextAccessible(content, document);
+    } else {  // XUL, other SVG, etc.
+      // Interesting generic non-HTML container
+      newAcc = new AccessibleWrap(content, document);
+    }
+  } else if (!newAcc && MustBeGenericAccessible(content, document)) {
+    newAcc = new EnumRoleHyperTextAccessible<roles::TEXT_CONTAINER>(content,
+                                                                    document);
+  }
+
+  if (newAcc) {
+    document->BindToDocument(newAcc, roleMapEntry);
+  }
+  return newAcc;
+}
+
+#if defined(ANDROID)
+#  include "mozilla/Monitor.h"
+#  include "mozilla/Maybe.h"
+
+static Maybe<Monitor> sAndroidMonitor;
+
+mozilla::Monitor& nsAccessibilityService::GetAndroidMonitor() {
+  if (!sAndroidMonitor.isSome()) {
+    sAndroidMonitor.emplace("nsAccessibility::sAndroidMonitor");
+  }
+
+  return *sAndroidMonitor;
+}
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// nsAccessibilityService private
+
+bool nsAccessibilityService::Init() {
+  AUTO_PROFILER_MARKER_TEXT("nsAccessibilityService::Init", A11Y, {}, ""_ns);
+  // DO NOT ADD CODE ABOVE HERE: THIS CODE IS MEASURING TIMINGS.
+
+  // Initialize accessible document manager.
+  if (!DocManager::Init()) return false;
+
+  // Add observers.
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+  if (!observerService) return false;
+
+  observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
+
+#if defined(XP_WIN)
+  // This information needs to be initialized before the observer fires.
+  if (XRE_IsParentProcess()) {
+    Compatibility::Init();
+  }
+#endif  // defined(XP_WIN)
+
+  // Subscribe to EventListenerService.
+  nsCOMPtr<nsIEventListenerService> eventListenerService =
+      do_GetService("@mozilla.org/eventlistenerservice;1");
+  if (!eventListenerService) return false;
+
+  eventListenerService->AddListenerChangeListener(this);
+
+  for (uint32_t i = 0; i < ArrayLength(sHTMLMarkupMapList); i++) {
+    mHTMLMarkupMap.InsertOrUpdate(sHTMLMarkupMapList[i].tag,
+                                  &sHTMLMarkupMapList[i]);
+  }
+  for (const auto& info : sMathMLMarkupMapList) {
+    mMathMLMarkupMap.InsertOrUpdate(info.tag, &info);
+  }
+
+  for (uint32_t i = 0; i < ArrayLength(sXULMarkupMapList); i++) {
+    mXULMarkupMap.InsertOrUpdate(sXULMarkupMapList[i].tag,
+                                 &sXULMarkupMapList[i]);
+  }
+
+#ifdef A11Y_LOG
+  logging::CheckEnv();
+#endif
+
+  gAccessibilityService = this;
+  NS_ADDREF(gAccessibilityService);  // will release in Shutdown()
+
+  if (XRE_IsParentProcess()) {
+    gApplicationAccessible = new ApplicationAccessibleWrap();
+  } else {
+    gApplicationAccessible = new ApplicationAccessible();
+  }
+
+  NS_ADDREF(gApplicationAccessible);  // will release in Shutdown()
+  gApplicationAccessible->Init();
+
+  CrashReporter::AnnotateCrashReport(CrashReporter::Annotation::Accessibility,
+                                     "Active"_ns);
+
+  // Now its safe to start platform accessibility.
+  if (XRE_IsParentProcess()) PlatformInit();
+
+  statistics::A11yInitialized();
+
+  static const char16_t kInitIndicator[] = {'1', 0};
+  observerService->NotifyObservers(nullptr, "a11y-init-or-shutdown",
+                                   kInitIndicator);
+
+  return true;
+}
+
+void nsAccessibilityService::Shutdown() {
+  // Application is going to be closed, shutdown accessibility and mark
+  // accessibility service as shutdown to prevent calls of its methods.
+  // Don't null accessibility service static member at this point to be safe
+  // if someone will try to operate with it.
+
+  MOZ_ASSERT(gConsumers, "Accessibility was shutdown already");
+  UnsetConsumers(eXPCOM | eMainProcess | ePlatformAPI);
+
+  // Remove observers.
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+  if (observerService) {
+    observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+  }
+
+  // Stop accessible document loader.
+  DocManager::Shutdown();
+
+  SelectionManager::Shutdown();
+
+  if (XRE_IsParentProcess()) PlatformShutdown();
+
+  gApplicationAccessible->Shutdown();
+  NS_RELEASE(gApplicationAccessible);
+  gApplicationAccessible = nullptr;
+
+  NS_IF_RELEASE(gXPCApplicationAccessible);
+  gXPCApplicationAccessible = nullptr;
+
+#if defined(ANDROID)
+  // Don't allow the service to shut down while an a11y request is being handled
+  // in the UI thread, as the request may depend on state from the service.
+  MonitorAutoLock mal(GetAndroidMonitor());
+#endif
+  NS_RELEASE(gAccessibilityService);
+  gAccessibilityService = nullptr;
+
+  if (observerService) {
+    static const char16_t kShutdownIndicator[] = {'0', 0};
+    observerService->NotifyObservers(nullptr, "a11y-init-or-shutdown",
+                                     kShutdownIndicator);
+  }
+}
+
+already_AddRefed<LocalAccessible>
+nsAccessibilityService::CreateAccessibleByFrameType(nsIFrame* aFrame,
+                                                    nsIContent* aContent,
+                                                    LocalAccessible* aContext) {
+  DocAccessible* document = aContext->Document();
+
+  RefPtr<LocalAccessible> newAcc;
+  switch (aFrame->AccessibleType()) {
+    case eNoType:
+      return nullptr;
+    case eHTMLBRType:
+      newAcc = new HTMLBRAccessible(aContent, document);
+      break;
+    case eHTMLButtonType:
+      newAcc = new HTMLButtonAccessible(aContent, document);
+      break;
+    case eHTMLCanvasType:
+      newAcc = new HTMLCanvasAccessible(aContent, document);
+      break;
+    case eHTMLCaptionType:
+      if (aContext->IsTable() &&
+          aContext->GetContent() == aContent->GetParent()) {
+        newAcc = new HTMLCaptionAccessible(aContent, document);
+      }
+      break;
+    case eHTMLCheckboxType:
+      newAcc = new CheckboxAccessible(aContent, document);
+      break;
+    case eHTMLComboboxType:
+      newAcc = new HTMLComboboxAccessible(aContent, document);
+      break;
+    case eHTMLFileInputType:
+      newAcc = new HTMLFileInputAccessible(aContent, document);
+      break;
+    case eHTMLGroupboxType:
+      newAcc = new HTMLGroupboxAccessible(aContent, document);
+      break;
+    case eHTMLHRType:
+      newAcc = new HTMLHRAccessible(aContent, document);
+      break;
+    case eHTMLImageMapType:
+      newAcc = new HTMLImageMapAccessible(aContent, document);
+      break;
+    case eHTMLLiType:
+      if (aContext->IsList() &&
+          aContext->GetContent() == aContent->GetParent()) {
+        newAcc = new HTMLLIAccessible(aContent, document);
+      } else {
+        // Otherwise create a generic text accessible to avoid text jamming.
+        newAcc = new HyperTextAccessible(aContent, document);
+      }
+      break;
+    case eHTMLSelectListType:
+      newAcc = new HTMLSelectListAccessible(aContent, document);
+      break;
+    case eHTMLMediaType:
+      newAcc = new EnumRoleAccessible<roles::GROUPING>(aContent, document);
+      break;
+    case eHTMLRadioButtonType:
+      newAcc = new HTMLRadioButtonAccessible(aContent, document);
+      break;
+    case eHTMLRangeType:
+      newAcc = new HTMLRangeAccessible(aContent, document);
+      break;
+    case eHTMLSpinnerType:
+      newAcc = new HTMLSpinnerAccessible(aContent, document);
+      break;
+    case eHTMLTableType:
+    case eHTMLTableCellType:
+      // We handle markup and ARIA tables elsewhere. If we reach here, this is
+      // a CSS table part. Just create a generic text container.
+      newAcc = new HyperTextAccessible(aContent, document);
+      break;
+    case eHTMLTableRowType:
+      // This is a CSS table row. Don't expose it at all.
+      break;
+    case eHTMLTextFieldType:
+      newAcc = new HTMLTextFieldAccessible(aContent, document);
+      break;
+    case eHyperTextType: {
+      if (aContext->IsTable() || aContext->IsTableRow()) {
+        // This is some generic hyperText, for example a block frame element
+        // inserted between a table and table row. Treat it as presentational.
+        return nullptr;
+      }
+
+      if (!aContent->IsAnyOfHTMLElements(nsGkAtoms::dt, nsGkAtoms::dd,
+                                         nsGkAtoms::div, nsGkAtoms::thead,
+                                         nsGkAtoms::tfoot, nsGkAtoms::tbody)) {
+        newAcc = new HyperTextAccessible(aContent, document);
+      }
+      break;
+    }
+    case eImageType:
+      if (aContent->IsElement() &&
+          ShouldCreateImgAccessible(aContent->AsElement(), document)) {
+        newAcc = new ImageAccessible(aContent, document);
+      }
+      break;
+    case eOuterDocType:
+      newAcc = new OuterDocAccessible(aContent, document);
+      break;
+    case eTextLeafType:
+      newAcc = new TextLeafAccessible(aContent, document);
+      break;
+    default:
+      MOZ_ASSERT(false);
+      break;
+  }
+
+  return newAcc.forget();
+}
+
+void nsAccessibilityService::MarkupAttributes(
+    Accessible* aAcc, AccAttributes* aAttributes) const {
+  const mozilla::a11y::MarkupMapInfo* markupMap = GetMarkupMapInfoFor(aAcc);
+  if (!markupMap) return;
+
+  dom::Element* el = aAcc->IsLocal() ? aAcc->AsLocal()->Elm() : nullptr;
+  for (uint32_t i = 0; i < ArrayLength(markupMap->attrs); i++) {
+    const MarkupAttrInfo* info = markupMap->attrs + i;
+    if (!info->name) break;
+
+    if (info->DOMAttrName) {
+      if (!el) {
+        // XXX Expose DOM attributes for cached RemoteAccessibles.
+        continue;
+      }
+      if (info->DOMAttrValue) {
+        if (el->AttrValueIs(kNameSpaceID_None, info->DOMAttrName,
+                            info->DOMAttrValue, eCaseMatters)) {
+          aAttributes->SetAttribute(info->name, info->DOMAttrValue);
+        }
+        continue;
+      }
+
+      nsString value;
+      el->GetAttr(info->DOMAttrName, value);
+
+      if (!value.IsEmpty()) {
+        aAttributes->SetAttribute(info->name, std::move(value));
+      }
+
+      continue;
+    }
+
+    aAttributes->SetAttribute(info->name, info->value);
+  }
+}
+
+LocalAccessible* nsAccessibilityService::AddNativeRootAccessible(
+    void* aAtkAccessible) {
+#ifdef MOZ_ACCESSIBILITY_ATK
+  ApplicationAccessible* applicationAcc = ApplicationAcc();
+  if (!applicationAcc) return nullptr;
+
+  GtkWindowAccessible* nativeWnd =
+      new GtkWindowAccessible(static_cast<AtkObject*>(aAtkAccessible));
+
+  if (applicationAcc->AppendChild(nativeWnd)) return nativeWnd;
+#endif
+
+  return nullptr;
+}
+
+void nsAccessibilityService::RemoveNativeRootAccessible(
+    LocalAccessible* aAccessible) {
+#ifdef MOZ_ACCESSIBILITY_ATK
+  ApplicationAccessible* applicationAcc = ApplicationAcc();
+
+  if (applicationAcc) applicationAcc->RemoveChild(aAccessible);
+#endif
+}
+
+bool nsAccessibilityService::HasAccessible(nsINode* aDOMNode) {
+  if (!aDOMNode) return false;
+
+  Document* document = aDOMNode->OwnerDoc();
+  if (!document) return false;
+
+  DocAccessible* docAcc = GetExistingDocAccessible(aDOMNode->OwnerDoc());
+  if (!docAcc) return false;
+
+  return docAcc->HasAccessible(aDOMNode);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsAccessibilityService private (DON'T put methods here)
+
+void nsAccessibilityService::SetConsumers(uint32_t aConsumers, bool aNotify) {
+  if (gConsumers & aConsumers) {
+    return;
+  }
+
+  gConsumers |= aConsumers;
+  if (aNotify) {
+    NotifyOfConsumersChange();
+  }
+}
+
+void nsAccessibilityService::UnsetConsumers(uint32_t aConsumers) {
+  if (!(gConsumers & aConsumers)) {
+    return;
+  }
+
+  gConsumers &= ~aConsumers;
+  NotifyOfConsumersChange();
+}
+
+void nsAccessibilityService::GetConsumers(nsAString& aString) {
+  const char16_t* kJSONFmt =
+      u"{ \"XPCOM\": %s, \"MainProcess\": %s, \"PlatformAPI\": %s }";
+  nsString json;
+  nsTextFormatter::ssprintf(json, kJSONFmt,
+                            gConsumers & eXPCOM ? "true" : "false",
+                            gConsumers & eMainProcess ? "true" : "false",
+                            gConsumers & ePlatformAPI ? "true" : "false");
+  aString.Assign(json);
+}
+
+void nsAccessibilityService::NotifyOfConsumersChange() {
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+
+  if (!observerService) {
+    return;
+  }
+
+  nsAutoString consumers;
+  GetConsumers(consumers);
+  observerService->NotifyObservers(nullptr, "a11y-consumers-changed",
+                                   consumers.get());
+}
+
+const mozilla::a11y::MarkupMapInfo* nsAccessibilityService::GetMarkupMapInfoFor(
+    Accessible* aAcc) const {
+  if (LocalAccessible* localAcc = aAcc->AsLocal()) {
+    return localAcc->HasOwnContent()
+               ? GetMarkupMapInfoFor(localAcc->GetContent())
+               : nullptr;
+  }
+  // XXX For now, we assume all RemoteAccessibles are HTML elements. This
+  // isn't strictly correct, but as far as current callers are concerned,
+  // this doesn't matter. If that changes in future, we could expose the
+  // element type via AccGenericType.
+  return mHTMLMarkupMap.Get(aAcc->TagName());
+}
+
+nsAccessibilityService* GetOrCreateAccService(uint32_t aNewConsumer) {
+  // Do not initialize accessibility if it is force disabled.
+  if (PlatformDisabledState() == ePlatformIsDisabled) {
+    return nullptr;
+  }
+
+  if (!nsAccessibilityService::gAccessibilityService) {
+    RefPtr<nsAccessibilityService> service = new nsAccessibilityService();
+    if (!service->Init()) {
+      service->Shutdown();
+      return nullptr;
+    }
+  }
+
+  MOZ_ASSERT(nsAccessibilityService::gAccessibilityService,
+             "LocalAccessible service is not initialized.");
+  nsAccessibilityService::gAccessibilityService->SetConsumers(aNewConsumer);
+  return nsAccessibilityService::gAccessibilityService;
+}
+
+void MaybeShutdownAccService(uint32_t aFormerConsumer) {
+  nsAccessibilityService* accService =
+      nsAccessibilityService::gAccessibilityService;
+
+  if (!accService || nsAccessibilityService::IsShutdown()) {
+    return;
+  }
+
+  // Still used by XPCOM
+  if (nsCoreUtils::AccEventObserversExist() ||
+      xpcAccessibilityService::IsInUse() || accService->HasXPCDocuments()) {
+    // In case the XPCOM flag was unset (possibly because of the shutdown
+    // timer in the xpcAccessibilityService) ensure it is still present. Note:
+    // this should be fixed when all the consumer logic is taken out as a
+    // separate class.
+    accService->SetConsumers(nsAccessibilityService::eXPCOM, false);
+
+    if (aFormerConsumer != nsAccessibilityService::eXPCOM) {
+      // Only unset non-XPCOM consumers.
+      accService->UnsetConsumers(aFormerConsumer);
+    }
+    return;
+  }
+
+  if (nsAccessibilityService::gConsumers & ~aFormerConsumer) {
+    accService->UnsetConsumers(aFormerConsumer);
+  } else {
+    accService
+        ->Shutdown();  // Will unset all nsAccessibilityService::gConsumers
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Services
+////////////////////////////////////////////////////////////////////////////////
+
+namespace mozilla {
+namespace a11y {
+
+FocusManager* FocusMgr() {
+  return nsAccessibilityService::gAccessibilityService;
+}
+
+SelectionManager* SelectionMgr() {
+  return nsAccessibilityService::gAccessibilityService;
+}
+
+ApplicationAccessible* ApplicationAcc() {
+  return nsAccessibilityService::gApplicationAccessible;
+}
+
+xpcAccessibleApplication* XPCApplicationAcc() {
+  if (!nsAccessibilityService::gXPCApplicationAccessible &&
+      nsAccessibilityService::gApplicationAccessible) {
+    nsAccessibilityService::gXPCApplicationAccessible =
+        new xpcAccessibleApplication(
+            nsAccessibilityService::gApplicationAccessible);
+    NS_ADDREF(nsAccessibilityService::gXPCApplicationAccessible);
+  }
+
+  return nsAccessibilityService::gXPCApplicationAccessible;
+}
+
+EPlatformDisabledState PlatformDisabledState() {
+  static bool platformDisabledStateCached = false;
+  if (platformDisabledStateCached) {
+    return static_cast<EPlatformDisabledState>(sPlatformDisabledState);
+  }
+
+  platformDisabledStateCached = true;
+  Preferences::RegisterCallback(PrefChanged, PREF_ACCESSIBILITY_FORCE_DISABLED);
+  return ReadPlatformDisabledState();
+}
+
+EPlatformDisabledState ReadPlatformDisabledState() {
+  sPlatformDisabledState =
+      Preferences::GetInt(PREF_ACCESSIBILITY_FORCE_DISABLED, 0);
+  if (sPlatformDisabledState < ePlatformIsForceEnabled) {
+    sPlatformDisabledState = ePlatformIsForceEnabled;
+  } else if (sPlatformDisabledState > ePlatformIsDisabled) {
+    sPlatformDisabledState = ePlatformIsDisabled;
+  }
+
+  return static_cast<EPlatformDisabledState>(sPlatformDisabledState);
+}
+
+void PrefChanged(const char* aPref, void* aClosure) {
+  if (ReadPlatformDisabledState() == ePlatformIsDisabled) {
+    // Force shut down accessibility.
+    nsAccessibilityService* accService =
+        nsAccessibilityService::gAccessibilityService;
+    if (accService && !nsAccessibilityService::IsShutdown()) {
+      accService->Shutdown();
+    }
+  }
+}
+
+}  // namespace a11y
+}  // namespace mozilla
diff --git a/accessible/base/nsAccessibilityService.h b/accessible/base/nsAccessibilityService.h
new file mode 100644
index 0000000000..0b3f172f89
--- /dev/null
+++ b/accessible/base/nsAccessibilityService.h
@@ -0,0 +1,492 @@
+/* -*- 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 __nsAccessibilityService_h__
+#define __nsAccessibilityService_h__
+
+#include "mozilla/a11y/DocManager.h"
+#include "mozilla/a11y/FocusManager.h"
+#include "mozilla/a11y/Platform.h"
+#include "mozilla/a11y/Role.h"
+#include "mozilla/a11y/SelectionManager.h"
+#include "mozilla/Preferences.h"
+
+#include "nsAtomHashKeys.h"
+#include "nsIContent.h"
+#include "nsIObserver.h"
+#include "nsIAccessibleEvent.h"
+#include "nsIEventListenerService.h"
+#include "nsXULAppAPI.h"
+#include "xpcAccessibilityService.h"
+
+class nsImageFrame;
+class nsIArray;
+class nsITreeView;
+
+namespace mozilla {
+
+class PresShell;
+class Monitor;
+namespace dom {
+class DOMStringList;
+class Element;
+}  // namespace dom
+
+namespace a11y {
+
+class AccAttributes;
+class Accessible;
+class ApplicationAccessible;
+class xpcAccessibleApplication;
+
+/**
+ * Return focus manager.
+ */
+FocusManager* FocusMgr();
+
+/**
+ * Return selection manager.
+ */
+SelectionManager* SelectionMgr();
+
+/**
+ * Returns the application accessible.
+ */
+ApplicationAccessible* ApplicationAcc();
+xpcAccessibleApplication* XPCApplicationAcc();
+
+typedef LocalAccessible*(New_Accessible)(mozilla::dom::Element* aElement,
+                                         LocalAccessible* aContext);
+
+// These fields are not `nsStaticAtom* const` because MSVC doesn't like it.
+struct MarkupAttrInfo {
+  nsStaticAtom* name;
+  nsStaticAtom* value;
+
+  nsStaticAtom* DOMAttrName;
+  nsStaticAtom* DOMAttrValue;
+};
+
+struct MarkupMapInfo {
+  nsStaticAtom* const tag;
+  New_Accessible* new_func;
+  a11y::role role;
+  MarkupAttrInfo attrs[4];
+};
+
+struct XULMarkupMapInfo {
+  nsStaticAtom* const tag;
+  New_Accessible* new_func;
+};
+
+/**
+ * PREF_ACCESSIBILITY_FORCE_DISABLED preference change callback.
+ */
+void PrefChanged(const char* aPref, void* aClosure);
+
+/**
+ * Read and normalize PREF_ACCESSIBILITY_FORCE_DISABLED preference.
+ */
+EPlatformDisabledState ReadPlatformDisabledState();
+
+}  // namespace a11y
+}  // namespace mozilla
+
+class nsAccessibilityService final : public mozilla::a11y::DocManager,
+                                     public mozilla::a11y::FocusManager,
+                                     public mozilla::a11y::SelectionManager,
+                                     public nsIListenerChangeListener,
+                                     public nsIObserver {
+ public:
+  typedef mozilla::a11y::LocalAccessible LocalAccessible;
+  typedef mozilla::a11y::DocAccessible DocAccessible;
+
+  // nsIListenerChangeListener
+  NS_IMETHOD ListenersChanged(nsIArray* aEventChanges) override;
+
+ protected:
+  ~nsAccessibilityService();
+
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIOBSERVER
+
+  LocalAccessible* GetRootDocumentAccessible(mozilla::PresShell* aPresShell,
+                                             bool aCanCreate);
+
+  /**
+   * Adds/remove ATK root accessible for gtk+ native window to/from children
+   * of the application accessible.
+   */
+  LocalAccessible* AddNativeRootAccessible(void* aAtkAccessible);
+  void RemoveNativeRootAccessible(LocalAccessible* aRootAccessible);
+
+  bool HasAccessible(nsINode* aDOMNode);
+
+  /**
+   * Get a string equivalent for an accessible role value.
+   */
+  void GetStringRole(uint32_t aRole, nsAString& aString);
+
+  /**
+   * Get a string equivalent for an accessible state/extra state.
+   */
+  already_AddRefed<mozilla::dom::DOMStringList> GetStringStates(
+      uint64_t aStates) const;
+  void GetStringStates(uint32_t aState, uint32_t aExtraState,
+                       nsISupports** aStringStates);
+
+  /**
+   * Get a string equivalent for an accessible event value.
+   */
+  void GetStringEventType(uint32_t aEventType, nsAString& aString);
+
+  /**
+   * Get a string equivalent for an accessible event value.
+   */
+  void GetStringEventType(uint32_t aEventType, nsACString& aString);
+
+  /**
+   * Get a string equivalent for an accessible relation type.
+   */
+  void GetStringRelationType(uint32_t aRelationType, nsAString& aString);
+
+  // nsAccesibilityService
+  /**
+   * Notification used to update the accessible tree when new content is
+   * inserted.
+   */
+  void ContentRangeInserted(mozilla::PresShell* aPresShell,
+                            nsIContent* aStartChild, nsIContent* aEndChild);
+
+  /**
+   * Triggers a re-evaluation of the a11y tree of aContent after the next
+   * refresh. This is important because whether we create accessibles may
+   * depend on the frame tree / style.
+   */
+  void ScheduleAccessibilitySubtreeUpdate(mozilla::PresShell* aPresShell,
+                                          nsIContent* aStartChild);
+
+  /**
+   * Notification used to update the accessible tree when content is removed.
+   */
+  void ContentRemoved(mozilla::PresShell* aPresShell, nsIContent* aChild);
+
+  /**
+   * Notification used to invalidate the isLayoutTable cache.
+   */
+  void TableLayoutGuessMaybeChanged(mozilla::PresShell* aPresShell,
+                                    nsIContent* aContent);
+
+  /**
+   * Notifies when a combobox <option> text or label changes.
+   */
+  void ComboboxOptionMaybeChanged(mozilla::PresShell*,
+                                  nsIContent* aMutatingNode);
+
+  void UpdateText(mozilla::PresShell* aPresShell, nsIContent* aContent);
+
+  /**
+   * Update XUL:tree accessible tree when treeview is changed.
+   */
+  void TreeViewChanged(mozilla::PresShell* aPresShell, nsIContent* aContent,
+                       nsITreeView* aView);
+
+  /**
+   * Notify of input@type="element" value change.
+   */
+  void RangeValueChanged(mozilla::PresShell* aPresShell, nsIContent* aContent);
+
+  /**
+   * Update the image map.
+   */
+  void UpdateImageMap(nsImageFrame* aImageFrame);
+
+  /**
+   * Update the label accessible tree when rendered @value is changed.
+   */
+  void UpdateLabelValue(mozilla::PresShell* aPresShell, nsIContent* aLabelElm,
+                        const nsString& aNewValue);
+
+  /**
+   * Notify accessibility that anchor jump has been accomplished to the given
+   * target. Used by layout.
+   */
+  void NotifyOfAnchorJumpTo(nsIContent* aTarget);
+
+  /**
+   * Notify that presshell is activated.
+   */
+  void PresShellActivated(mozilla::PresShell* aPresShell);
+
+  /**
+   * Recreate an accessible for the given content node in the presshell.
+   */
+  void RecreateAccessible(mozilla::PresShell* aPresShell, nsIContent* aContent);
+
+  void FireAccessibleEvent(uint32_t aEvent, LocalAccessible* aTarget);
+
+  void NotifyOfPossibleBoundsChange(mozilla::PresShell* aPresShell,
+                                    nsIContent* aContent);
+
+  void NotifyOfComputedStyleChange(mozilla::PresShell* aPresShell,
+                                   nsIContent* aContent);
+
+  void NotifyOfTabPanelVisibilityChange(mozilla::PresShell* aPresShell,
+                                        mozilla::dom::Element* aPanel,
+                                        bool aVisible);
+
+  void NotifyOfResolutionChange(mozilla::PresShell* aPresShell,
+                                float aResolution);
+
+  void NotifyOfDevPixelRatioChange(mozilla::PresShell* aPresShell,
+                                   int32_t aAppUnitsPerDevPixel);
+
+  // nsAccessibiltiyService
+
+  /**
+   * Return true if accessibility service has been shutdown.
+   */
+  static bool IsShutdown() { return gConsumers == 0; };
+
+  /**
+   * Return true if there should be an image accessible for the given element.
+   */
+  static bool ShouldCreateImgAccessible(mozilla::dom::Element* aElement,
+                                        DocAccessible* aDocument);
+
+  /**
+   * Creates an accessible for the given DOM node.
+   *
+   * @param  aNode             [in] the given node
+   * @param  aContext          [in] context the accessible is created in
+   * @param  aIsSubtreeHidden  [out, optional] indicates whether the node's
+   *                             frame and its subtree is hidden
+   */
+  LocalAccessible* CreateAccessible(nsINode* aNode, LocalAccessible* aContext,
+                                    bool* aIsSubtreeHidden = nullptr);
+
+  mozilla::a11y::role MarkupRole(const nsIContent* aContent) const {
+    const mozilla::a11y::MarkupMapInfo* markupMap =
+        GetMarkupMapInfoFor(aContent);
+    return markupMap ? markupMap->role : mozilla::a11y::roles::NOTHING;
+  }
+
+  /**
+   * Return the associated value for a given attribute if
+   * it appears in the MarkupMap. Otherwise, it returns null. This can be
+   * called with either an nsIContent or an Accessible.
+   */
+  template <typename T>
+  nsStaticAtom* MarkupAttribute(T aSource, nsStaticAtom* aAtom) const {
+    const mozilla::a11y::MarkupMapInfo* markupMap =
+        GetMarkupMapInfoFor(aSource);
+    if (markupMap) {
+      for (size_t i = 0; i < mozilla::ArrayLength(markupMap->attrs); i++) {
+        const mozilla::a11y::MarkupAttrInfo* info = markupMap->attrs + i;
+        if (info->name == aAtom) {
+          return info->value;
+        }
+      }
+    }
+    return nullptr;
+  }
+
+  /**
+   * Set the object attribute defined by markup for the given element.
+   */
+  void MarkupAttributes(mozilla::a11y::Accessible* aAcc,
+                        mozilla::a11y::AccAttributes* aAttributes) const;
+
+  /**
+   * A list of possible accessibility service consumers. Accessibility service
+   * can only be shut down when there are no remaining consumers.
+   *
+   * eXPCOM       - accessibility service is used by XPCOM.
+   *
+   * eMainProcess - accessibility service was started by main process in the
+   *                content process.
+   *
+   * ePlatformAPI - accessibility service is used by the platform api in the
+   *                main process.
+   */
+  enum ServiceConsumer {
+    eXPCOM = 1 << 0,
+    eMainProcess = 1 << 1,
+    ePlatformAPI = 1 << 2,
+  };
+
+#if defined(ANDROID)
+  static mozilla::Monitor& GetAndroidMonitor();
+#endif
+
+ private:
+  // nsAccessibilityService creation is controlled by friend
+  // GetOrCreateAccService, keep constructors private.
+  nsAccessibilityService();
+  nsAccessibilityService(const nsAccessibilityService&);
+  nsAccessibilityService& operator=(const nsAccessibilityService&);
+
+ private:
+  /**
+   * Initialize accessibility service.
+   */
+  bool Init();
+
+  /**
+   * Shutdowns accessibility service.
+   */
+  void Shutdown();
+
+  /**
+   * Create an accessible whose type depends on the given frame.
+   */
+  already_AddRefed<LocalAccessible> CreateAccessibleByFrameType(
+      nsIFrame* aFrame, nsIContent* aContent, LocalAccessible* aContext);
+
+  /**
+   * Notify observers about change of the accessibility service's consumers.
+   */
+  void NotifyOfConsumersChange();
+
+  /**
+   * Get a JSON string representing the accessibility service consumers.
+   */
+  void GetConsumers(nsAString& aString);
+
+  /**
+   * Set accessibility service consumers.
+   */
+  void SetConsumers(uint32_t aConsumers, bool aNotify = true);
+
+  /**
+   * Unset accessibility service consumers.
+   */
+  void UnsetConsumers(uint32_t aConsumers);
+
+  /**
+   * Reference for accessibility service instance.
+   */
+  static nsAccessibilityService* gAccessibilityService;
+
+  /**
+   * Reference for application accessible instance.
+   */
+  static mozilla::a11y::ApplicationAccessible* gApplicationAccessible;
+  static mozilla::a11y::xpcAccessibleApplication* gXPCApplicationAccessible;
+
+  /**
+   * Contains a set of accessibility service consumers.
+   */
+  static uint32_t gConsumers;
+
+  // Can be weak because all atoms are known static
+  using MarkupMap = nsTHashMap<nsAtom*, const mozilla::a11y::MarkupMapInfo*>;
+  MarkupMap mHTMLMarkupMap;
+  MarkupMap mMathMLMarkupMap;
+
+  const mozilla::a11y::MarkupMapInfo* GetMarkupMapInfoFor(
+      const nsIContent* aContent) const {
+    if (aContent->IsHTMLElement()) {
+      return mHTMLMarkupMap.Get(aContent->NodeInfo()->NameAtom());
+    }
+    if (aContent->IsMathMLElement()) {
+      return mMathMLMarkupMap.Get(aContent->NodeInfo()->NameAtom());
+    }
+    // This function can be called by MarkupAttribute, etc. which might in turn
+    // be called on a XUL, SVG, etc. element. For example, this can happen
+    // with nsAccUtils::SetLiveContainerAttributes.
+    return nullptr;
+  }
+
+  const mozilla::a11y::MarkupMapInfo* GetMarkupMapInfoFor(
+      mozilla::a11y::Accessible* aAcc) const;
+
+  nsTHashMap<nsAtom*, const mozilla::a11y::XULMarkupMapInfo*> mXULMarkupMap;
+
+  friend nsAccessibilityService* GetAccService();
+  friend nsAccessibilityService* GetOrCreateAccService(uint32_t);
+  friend void MaybeShutdownAccService(uint32_t);
+  friend void mozilla::a11y::PrefChanged(const char*, void*);
+  friend mozilla::a11y::FocusManager* mozilla::a11y::FocusMgr();
+  friend mozilla::a11y::SelectionManager* mozilla::a11y::SelectionMgr();
+  friend mozilla::a11y::ApplicationAccessible* mozilla::a11y::ApplicationAcc();
+  friend mozilla::a11y::xpcAccessibleApplication*
+  mozilla::a11y::XPCApplicationAcc();
+  friend class xpcAccessibilityService;
+};
+
+/**
+ * Return the accessibility service instance. (Handy global function)
+ */
+inline nsAccessibilityService* GetAccService() {
+  return nsAccessibilityService::gAccessibilityService;
+}
+
+/**
+ * Return accessibility service instance; creating one if necessary.
+ */
+nsAccessibilityService* GetOrCreateAccService(
+    uint32_t aNewConsumer = nsAccessibilityService::ePlatformAPI);
+
+/**
+ * Shutdown accessibility service if needed.
+ */
+void MaybeShutdownAccService(uint32_t aFormerConsumer);
+
+/**
+ * Return true if we're in a content process and not B2G.
+ */
+inline bool IPCAccessibilityActive() { return XRE_IsContentProcess(); }
+
+/**
+ * Map nsIAccessibleEvents constants to strings. Used by
+ * nsAccessibilityService::GetStringEventType() method.
+ */
+static const char kEventTypeNames[][40] = {
+    "unknown",                   //
+    "show",                      // EVENT_SHOW
+    "hide",                      // EVENT_HIDE
+    "reorder",                   // EVENT_REORDER
+    "focus",                     // EVENT_FOCUS
+    "state change",              // EVENT_STATE_CHANGE
+    "name changed",              // EVENT_NAME_CHANGE
+    "description change",        // EVENT_DESCRIPTION_CHANGE
+    "value change",              // EVENT_VALUE_CHANGE
+    "selection",                 // EVENT_SELECTION
+    "selection add",             // EVENT_SELECTION_ADD
+    "selection remove",          // EVENT_SELECTION_REMOVE
+    "selection within",          // EVENT_SELECTION_WITHIN
+    "alert",                     // EVENT_ALERT
+    "menu start",                // EVENT_MENU_START
+    "menu end",                  // EVENT_MENU_END
+    "menupopup start",           // EVENT_MENUPOPUP_START
+    "menupopup end",             // EVENT_MENUPOPUP_END
+    "dragdrop start",            // EVENT_DRAGDROP_START
+    "scrolling start",           // EVENT_SCROLLING_START
+    "scrolling end",             // EVENT_SCROLLING_END
+    "document load complete",    // EVENT_DOCUMENT_LOAD_COMPLETE
+    "document reload",           // EVENT_DOCUMENT_RELOAD
+    "document load stopped",     // EVENT_DOCUMENT_LOAD_STOPPED
+    "text attribute changed",    // EVENT_TEXT_ATTRIBUTE_CHANGED
+    "text caret moved",          // EVENT_TEXT_CARET_MOVED
+    "text inserted",             // EVENT_TEXT_INSERTED
+    "text removed",              // EVENT_TEXT_REMOVED
+    "text selection changed",    // EVENT_TEXT_SELECTION_CHANGED
+    "window activate",           // EVENT_WINDOW_ACTIVATE
+    "window deactivate",         // EVENT_WINDOW_DEACTIVATE
+    "window maximize",           // EVENT_WINDOW_MAXIMIZE
+    "window minimize",           // EVENT_WINDOW_MINIMIZE
+    "window restore",            // EVENT_WINDOW_RESTORE
+    "object attribute changed",  // EVENT_OBJECT_ATTRIBUTE_CHANGED
+    "text value change",         // EVENT_TEXT_VALUE_CHANGE
+    "scrolling",                 // EVENT_SCROLLING
+    "announcement",              // EVENT_ANNOUNCEMENT
+    "live region added",         // EVENT_LIVE_REGION_ADDED
+    "live region removed",       // EVENT_LIVE_REGION_REMOVED
+    "inner reorder",             // EVENT_INNER_REORDER
+};
+
+#endif
diff --git a/accessible/base/nsCoreUtils.cpp b/accessible/base/nsCoreUtils.cpp
new file mode 100644
index 0000000000..80739bb401
--- /dev/null
+++ b/accessible/base/nsCoreUtils.cpp
@@ -0,0 +1,622 @@
+/* -*- 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 "nsCoreUtils.h"
+
+#include "nsAttrValue.h"
+#include "nsIAccessibleTypes.h"
+
+#include "mozilla/dom/Document.h"
+#include "nsAccUtils.h"
+#include "nsRange.h"
+#include "nsXULElement.h"
+#include "nsIDocShell.h"
+#include "nsIObserverService.h"
+#include "nsPresContext.h"
+#include "nsIScrollableFrame.h"
+#include "nsISelectionController.h"
+#include "nsISimpleEnumerator.h"
+#include "mozilla/dom/TouchEvent.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/TouchEvents.h"
+#include "nsView.h"
+#include "nsGkAtoms.h"
+
+#include "nsComponentManagerUtils.h"
+
+#include "XULTreeElement.h"
+#include "nsIContentInlines.h"
+#include "nsTreeColumns.h"
+#include "mozilla/dom/DocumentInlines.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/HTMLLabelElement.h"
+#include "mozilla/dom/MouseEventBinding.h"
+#include "mozilla/dom/Selection.h"
+
+using namespace mozilla;
+
+using mozilla::dom::DOMRect;
+using mozilla::dom::Element;
+using mozilla::dom::Selection;
+using mozilla::dom::XULTreeElement;
+
+using mozilla::a11y::nsAccUtils;
+
+////////////////////////////////////////////////////////////////////////////////
+// nsCoreUtils
+////////////////////////////////////////////////////////////////////////////////
+
+bool nsCoreUtils::IsLabelWithControl(nsIContent* aContent) {
+  dom::HTMLLabelElement* label = dom::HTMLLabelElement::FromNode(aContent);
+  if (label && label->GetControl()) return true;
+
+  return false;
+}
+
+bool nsCoreUtils::HasClickListener(nsIContent* aContent) {
+  NS_ENSURE_TRUE(aContent, false);
+  EventListenerManager* listenerManager =
+      aContent->GetExistingListenerManager();
+
+  return listenerManager &&
+         (listenerManager->HasListenersFor(nsGkAtoms::onclick) ||
+          listenerManager->HasListenersFor(nsGkAtoms::onmousedown) ||
+          listenerManager->HasListenersFor(nsGkAtoms::onmouseup));
+}
+
+void nsCoreUtils::DispatchClickEvent(XULTreeElement* aTree, int32_t aRowIndex,
+                                     nsTreeColumn* aColumn,
+                                     const nsAString& aPseudoElt) {
+  RefPtr<dom::Element> tcElm = aTree->GetTreeBody();
+  if (!tcElm) return;
+
+  Document* document = tcElm->GetUncomposedDoc();
+  if (!document) return;
+
+  RefPtr<PresShell> presShell = document->GetPresShell();
+  if (!presShell) {
+    return;
+  }
+
+  // Ensure row is visible.
+  aTree->EnsureRowIsVisible(aRowIndex);
+
+  // Calculate x and y coordinates.
+  nsresult rv;
+  nsIntRect rect =
+      aTree->GetCoordsForCellItem(aRowIndex, aColumn, aPseudoElt, rv);
+  if (NS_FAILED(rv)) {
+    return;
+  }
+
+  RefPtr<DOMRect> treeBodyRect = tcElm->GetBoundingClientRect();
+  int32_t tcX = (int32_t)treeBodyRect->X();
+  int32_t tcY = (int32_t)treeBodyRect->Y();
+
+  // Dispatch mouse events.
+  AutoWeakFrame tcFrame = tcElm->GetPrimaryFrame();
+  nsIFrame* rootFrame = presShell->GetRootFrame();
+
+  nsPoint offset;
+  nsCOMPtr<nsIWidget> rootWidget =
+      rootFrame->GetView()->GetNearestWidget(&offset);
+
+  RefPtr<nsPresContext> presContext = presShell->GetPresContext();
+
+  int32_t cnvdX = presContext->CSSPixelsToDevPixels(tcX + int32_t(rect.x) + 1) +
+                  presContext->AppUnitsToDevPixels(offset.x);
+  int32_t cnvdY = presContext->CSSPixelsToDevPixels(tcY + int32_t(rect.y) + 1) +
+                  presContext->AppUnitsToDevPixels(offset.y);
+
+  // XUL is just desktop, so there is no real reason for senfing touch events.
+  DispatchMouseEvent(eMouseDown, cnvdX, cnvdY, tcElm, tcFrame, presShell,
+                     rootWidget);
+
+  DispatchMouseEvent(eMouseUp, cnvdX, cnvdY, tcElm, tcFrame, presShell,
+                     rootWidget);
+}
+
+void nsCoreUtils::DispatchMouseEvent(EventMessage aMessage, int32_t aX,
+                                     int32_t aY, nsIContent* aContent,
+                                     nsIFrame* aFrame, PresShell* aPresShell,
+                                     nsIWidget* aRootWidget) {
+  WidgetMouseEvent event(true, aMessage, aRootWidget, WidgetMouseEvent::eReal,
+                         WidgetMouseEvent::eNormal);
+
+  event.mRefPoint = LayoutDeviceIntPoint(aX, aY);
+
+  event.mClickCount = 1;
+  event.mButton = MouseButton::ePrimary;
+  event.mInputSource = dom::MouseEvent_Binding::MOZ_SOURCE_UNKNOWN;
+
+  nsEventStatus status = nsEventStatus_eIgnore;
+  aPresShell->HandleEventWithTarget(&event, aFrame, aContent, &status);
+}
+
+void nsCoreUtils::DispatchTouchEvent(EventMessage aMessage, int32_t aX,
+                                     int32_t aY, nsIContent* aContent,
+                                     nsIFrame* aFrame, PresShell* aPresShell,
+                                     nsIWidget* aRootWidget) {
+  nsIDocShell* docShell = nullptr;
+  if (aPresShell->GetDocument()) {
+    docShell = aPresShell->GetDocument()->GetDocShell();
+  }
+  if (!dom::TouchEvent::PrefEnabled(docShell)) {
+    return;
+  }
+
+  WidgetTouchEvent event(true, aMessage, aRootWidget);
+
+  // XXX: Touch has an identifier of -1 to hint that it is synthesized.
+  RefPtr<dom::Touch> t = new dom::Touch(-1, LayoutDeviceIntPoint(aX, aY),
+                                        LayoutDeviceIntPoint(1, 1), 0.0f, 1.0f);
+  t->SetTouchTarget(aContent);
+  event.mTouches.AppendElement(t);
+  nsEventStatus status = nsEventStatus_eIgnore;
+  aPresShell->HandleEventWithTarget(&event, aFrame, aContent, &status);
+}
+
+uint32_t nsCoreUtils::GetAccessKeyFor(nsIContent* aContent) {
+  // Accesskeys are registered by @accesskey attribute only. At first check
+  // whether it is presented on the given element to avoid the slow
+  // EventStateManager::GetRegisteredAccessKey() method.
+  if (!aContent->IsElement() || !aContent->AsElement()->HasAttr(
+                                    kNameSpaceID_None, nsGkAtoms::accesskey)) {
+    return 0;
+  }
+
+  nsPresContext* presContext = aContent->OwnerDoc()->GetPresContext();
+  if (!presContext) return 0;
+
+  EventStateManager* esm = presContext->EventStateManager();
+  if (!esm) return 0;
+
+  return esm->GetRegisteredAccessKey(aContent->AsElement());
+}
+
+nsIContent* nsCoreUtils::GetDOMElementFor(nsIContent* aContent) {
+  if (aContent->IsElement()) return aContent;
+
+  if (aContent->IsText()) return aContent->GetFlattenedTreeParent();
+
+  return nullptr;
+}
+
+nsINode* nsCoreUtils::GetDOMNodeFromDOMPoint(nsINode* aNode, uint32_t aOffset) {
+  if (aNode && aNode->IsElement()) {
+    uint32_t childCount = aNode->GetChildCount();
+    NS_ASSERTION(aOffset <= childCount, "Wrong offset of the DOM point!");
+
+    // The offset can be after last child of container node that means DOM point
+    // is placed immediately after the last child. In this case use the DOM node
+    // from the given DOM point is used as result node.
+    if (aOffset != childCount) return aNode->GetChildAt_Deprecated(aOffset);
+  }
+
+  return aNode;
+}
+
+bool nsCoreUtils::IsAncestorOf(nsINode* aPossibleAncestorNode,
+                               nsINode* aPossibleDescendantNode,
+                               nsINode* aRootNode) {
+  NS_ENSURE_TRUE(aPossibleAncestorNode && aPossibleDescendantNode, false);
+
+  nsINode* parentNode = aPossibleDescendantNode;
+  while ((parentNode = parentNode->GetParentNode()) &&
+         parentNode != aRootNode) {
+    if (parentNode == aPossibleAncestorNode) return true;
+  }
+
+  return false;
+}
+
+nsresult nsCoreUtils::ScrollSubstringTo(nsIFrame* aFrame, nsRange* aRange,
+                                        uint32_t aScrollType) {
+  ScrollAxis vertical, horizontal;
+  ConvertScrollTypeToPercents(aScrollType, &vertical, &horizontal);
+
+  return ScrollSubstringTo(aFrame, aRange, vertical, horizontal);
+}
+
+nsresult nsCoreUtils::ScrollSubstringTo(nsIFrame* aFrame, nsRange* aRange,
+                                        ScrollAxis aVertical,
+                                        ScrollAxis aHorizontal) {
+  if (!aFrame || !aRange) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsPresContext* presContext = aFrame->PresContext();
+
+  nsCOMPtr<nsISelectionController> selCon;
+  aFrame->GetSelectionController(presContext, getter_AddRefs(selCon));
+  NS_ENSURE_TRUE(selCon, NS_ERROR_FAILURE);
+
+  RefPtr<dom::Selection> selection =
+      selCon->GetSelection(nsISelectionController::SELECTION_ACCESSIBILITY);
+
+  selection->RemoveAllRanges(IgnoreErrors());
+  selection->AddRangeAndSelectFramesAndNotifyListeners(*aRange, IgnoreErrors());
+
+  selection->ScrollIntoView(nsISelectionController::SELECTION_ANCHOR_REGION,
+                            aVertical, aHorizontal,
+                            Selection::SCROLL_SYNCHRONOUS);
+
+  selection->CollapseToStart(IgnoreErrors());
+
+  return NS_OK;
+}
+
+void nsCoreUtils::ScrollFrameToPoint(nsIFrame* aScrollableFrame,
+                                     nsIFrame* aFrame,
+                                     const LayoutDeviceIntPoint& aPoint) {
+  nsIScrollableFrame* scrollableFrame = do_QueryFrame(aScrollableFrame);
+  if (!scrollableFrame) return;
+
+  nsPoint point = LayoutDeviceIntPoint::ToAppUnits(
+      aPoint, aFrame->PresContext()->AppUnitsPerDevPixel());
+  nsRect frameRect = aFrame->GetScreenRectInAppUnits();
+  nsPoint deltaPoint = point - frameRect.TopLeft();
+
+  nsPoint scrollPoint = scrollableFrame->GetScrollPosition();
+  scrollPoint -= deltaPoint;
+
+  scrollableFrame->ScrollTo(scrollPoint, ScrollMode::Instant);
+}
+
+void nsCoreUtils::ConvertScrollTypeToPercents(uint32_t aScrollType,
+                                              ScrollAxis* aVertical,
+                                              ScrollAxis* aHorizontal) {
+  WhereToScroll whereY, whereX;
+  WhenToScroll whenY, whenX;
+  switch (aScrollType) {
+    case nsIAccessibleScrollType::SCROLL_TYPE_TOP_LEFT:
+      whereY = WhereToScroll::Start;
+      whenY = WhenToScroll::Always;
+      whereX = WhereToScroll::Start;
+      whenX = WhenToScroll::Always;
+      break;
+    case nsIAccessibleScrollType::SCROLL_TYPE_BOTTOM_RIGHT:
+      whereY = WhereToScroll::End;
+      whenY = WhenToScroll::Always;
+      whereX = WhereToScroll::End;
+      whenX = WhenToScroll::Always;
+      break;
+    case nsIAccessibleScrollType::SCROLL_TYPE_TOP_EDGE:
+      whereY = WhereToScroll::Start;
+      whenY = WhenToScroll::Always;
+      whereX = WhereToScroll::Nearest;
+      whenX = WhenToScroll::IfNotFullyVisible;
+      break;
+    case nsIAccessibleScrollType::SCROLL_TYPE_BOTTOM_EDGE:
+      whereY = WhereToScroll::End;
+      whenY = WhenToScroll::Always;
+      whereX = WhereToScroll::Nearest;
+      whenX = WhenToScroll::IfNotFullyVisible;
+      break;
+    case nsIAccessibleScrollType::SCROLL_TYPE_LEFT_EDGE:
+      whereY = WhereToScroll::Nearest;
+      whenY = WhenToScroll::IfNotFullyVisible;
+      whereX = WhereToScroll::Start;
+      whenX = WhenToScroll::Always;
+      break;
+    case nsIAccessibleScrollType::SCROLL_TYPE_RIGHT_EDGE:
+      whereY = WhereToScroll::Nearest;
+      whenY = WhenToScroll::IfNotFullyVisible;
+      whereX = WhereToScroll::End;
+      whenX = WhenToScroll::Always;
+      break;
+    default:
+      whereY = WhereToScroll::Center;
+      whenY = WhenToScroll::IfNotFullyVisible;
+      whereX = WhereToScroll::Center;
+      whenX = WhenToScroll::IfNotFullyVisible;
+  }
+  *aVertical = ScrollAxis(whereY, whenY);
+  *aHorizontal = ScrollAxis(whereX, whenX);
+}
+
+already_AddRefed<nsIDocShell> nsCoreUtils::GetDocShellFor(nsINode* aNode) {
+  if (!aNode) return nullptr;
+
+  nsCOMPtr<nsIDocShell> docShell = aNode->OwnerDoc()->GetDocShell();
+  return docShell.forget();
+}
+
+bool nsCoreUtils::IsRootDocument(Document* aDocument) {
+  nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem = aDocument->GetDocShell();
+  NS_ASSERTION(docShellTreeItem, "No document shell for document!");
+
+  nsCOMPtr<nsIDocShellTreeItem> parentTreeItem;
+  docShellTreeItem->GetInProcessParent(getter_AddRefs(parentTreeItem));
+
+  return !parentTreeItem;
+}
+
+bool nsCoreUtils::IsTopLevelContentDocInProcess(Document* aDocumentNode) {
+  mozilla::dom::BrowsingContext* bc = aDocumentNode->GetBrowsingContext();
+  return bc->IsContent() && (
+                                // Tab document.
+                                bc->IsTop() ||
+                                // Out-of-process iframe.
+                                !bc->GetParent()->IsInProcess());
+}
+
+bool nsCoreUtils::IsErrorPage(Document* aDocument) {
+  nsIURI* uri = aDocument->GetDocumentURI();
+  if (!uri->SchemeIs("about")) {
+    return false;
+  }
+
+  nsAutoCString path;
+  uri->GetPathQueryRef(path);
+
+  constexpr auto neterror = "neterror"_ns;
+  constexpr auto certerror = "certerror"_ns;
+
+  return StringBeginsWith(path, neterror) || StringBeginsWith(path, certerror);
+}
+
+PresShell* nsCoreUtils::GetPresShellFor(nsINode* aNode) {
+  return aNode->OwnerDoc()->GetPresShell();
+}
+
+bool nsCoreUtils::GetID(nsIContent* aContent, nsAString& aID) {
+  return aContent->IsElement() &&
+         aContent->AsElement()->GetAttr(nsGkAtoms::id, aID);
+}
+
+bool nsCoreUtils::GetUIntAttr(nsIContent* aContent, nsAtom* aAttr,
+                              int32_t* aUInt) {
+  if (!aContent->IsElement()) {
+    return false;
+  }
+  return GetUIntAttrValue(nsAccUtils::GetARIAAttr(aContent->AsElement(), aAttr),
+                          aUInt);
+}
+
+bool nsCoreUtils::GetUIntAttrValue(const nsAttrValue* aVal, int32_t* aUInt) {
+  if (!aVal) {
+    return false;
+  }
+  nsAutoString value;
+  aVal->ToString(value);
+  if (!value.IsEmpty()) {
+    nsresult error = NS_OK;
+    int32_t integer = value.ToInteger(&error);
+    if (NS_SUCCEEDED(error) && integer > 0) {
+      *aUInt = integer;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void nsCoreUtils::GetLanguageFor(nsIContent* aContent, nsIContent* aRootContent,
+                                 nsAString& aLanguage) {
+  aLanguage.Truncate();
+
+  nsIContent* walkUp = aContent;
+  while (walkUp && walkUp != aRootContent &&
+         (!walkUp->IsElement() ||
+          !walkUp->AsElement()->GetAttr(nsGkAtoms::lang, aLanguage))) {
+    walkUp = walkUp->GetParent();
+  }
+}
+
+XULTreeElement* nsCoreUtils::GetTree(nsIContent* aContent) {
+  // Find DOMNode's parents recursively until reach the <tree> tag
+  nsIContent* currentContent = aContent;
+  while (currentContent) {
+    if (currentContent->NodeInfo()->Equals(nsGkAtoms::tree, kNameSpaceID_XUL)) {
+      return XULTreeElement::FromNode(currentContent);
+    }
+    currentContent = currentContent->GetFlattenedTreeParent();
+  }
+
+  return nullptr;
+}
+
+already_AddRefed<nsTreeColumn> nsCoreUtils::GetFirstSensibleColumn(
+    XULTreeElement* aTree, FlushType aFlushType) {
+  if (!aTree) {
+    return nullptr;
+  }
+
+  RefPtr<nsTreeColumns> cols = aTree->GetColumns(aFlushType);
+  if (!cols) {
+    return nullptr;
+  }
+
+  RefPtr<nsTreeColumn> column = cols->GetFirstColumn();
+  if (column && IsColumnHidden(column)) return GetNextSensibleColumn(column);
+
+  return column.forget();
+}
+
+uint32_t nsCoreUtils::GetSensibleColumnCount(XULTreeElement* aTree) {
+  uint32_t count = 0;
+  if (!aTree) {
+    return count;
+  }
+
+  RefPtr<nsTreeColumns> cols = aTree->GetColumns();
+  if (!cols) {
+    return count;
+  }
+
+  nsTreeColumn* column = cols->GetFirstColumn();
+
+  while (column) {
+    if (!IsColumnHidden(column)) count++;
+
+    column = column->GetNext();
+  }
+
+  return count;
+}
+
+already_AddRefed<nsTreeColumn> nsCoreUtils::GetSensibleColumnAt(
+    XULTreeElement* aTree, uint32_t aIndex) {
+  if (!aTree) {
+    return nullptr;
+  }
+
+  uint32_t idx = aIndex;
+
+  nsCOMPtr<nsTreeColumn> column = GetFirstSensibleColumn(aTree);
+  while (column) {
+    if (idx == 0) return column.forget();
+
+    idx--;
+    column = GetNextSensibleColumn(column);
+  }
+
+  return nullptr;
+}
+
+already_AddRefed<nsTreeColumn> nsCoreUtils::GetNextSensibleColumn(
+    nsTreeColumn* aColumn) {
+  if (!aColumn) {
+    return nullptr;
+  }
+
+  RefPtr<nsTreeColumn> nextColumn = aColumn->GetNext();
+
+  while (nextColumn && IsColumnHidden(nextColumn)) {
+    nextColumn = nextColumn->GetNext();
+  }
+
+  return nextColumn.forget();
+}
+
+already_AddRefed<nsTreeColumn> nsCoreUtils::GetPreviousSensibleColumn(
+    nsTreeColumn* aColumn) {
+  if (!aColumn) {
+    return nullptr;
+  }
+
+  RefPtr<nsTreeColumn> prevColumn = aColumn->GetPrevious();
+
+  while (prevColumn && IsColumnHidden(prevColumn)) {
+    prevColumn = prevColumn->GetPrevious();
+  }
+
+  return prevColumn.forget();
+}
+
+bool nsCoreUtils::IsColumnHidden(nsTreeColumn* aColumn) {
+  if (!aColumn) {
+    return false;
+  }
+
+  Element* element = aColumn->Element();
+  return element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::hidden,
+                              nsGkAtoms::_true, eCaseMatters);
+}
+
+void nsCoreUtils::ScrollTo(PresShell* aPresShell, nsIContent* aContent,
+                           uint32_t aScrollType) {
+  ScrollAxis vertical, horizontal;
+  ConvertScrollTypeToPercents(aScrollType, &vertical, &horizontal);
+  aPresShell->ScrollContentIntoView(aContent, vertical, horizontal,
+                                    ScrollFlags::ScrollOverflowHidden);
+}
+
+bool nsCoreUtils::IsHTMLTableHeader(nsIContent* aContent) {
+  return aContent->NodeInfo()->Equals(nsGkAtoms::th) ||
+         (aContent->IsElement() &&
+          aContent->AsElement()->HasAttr(nsGkAtoms::scope));
+}
+
+bool nsCoreUtils::IsWhitespaceString(const nsAString& aString) {
+  nsAString::const_char_iterator iterBegin, iterEnd;
+
+  aString.BeginReading(iterBegin);
+  aString.EndReading(iterEnd);
+
+  while (iterBegin != iterEnd && IsWhitespace(*iterBegin)) ++iterBegin;
+
+  return iterBegin == iterEnd;
+}
+
+bool nsCoreUtils::AccEventObserversExist() {
+  nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();
+  NS_ENSURE_TRUE(obsService, false);
+
+  nsCOMPtr<nsISimpleEnumerator> observers;
+  obsService->EnumerateObservers(NS_ACCESSIBLE_EVENT_TOPIC,
+                                 getter_AddRefs(observers));
+  NS_ENSURE_TRUE(observers, false);
+
+  bool hasObservers = false;
+  observers->HasMoreElements(&hasObservers);
+
+  return hasObservers;
+}
+
+void nsCoreUtils::DispatchAccEvent(RefPtr<nsIAccessibleEvent> event) {
+  nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();
+  NS_ENSURE_TRUE_VOID(obsService);
+
+  obsService->NotifyObservers(event, NS_ACCESSIBLE_EVENT_TOPIC, nullptr);
+}
+
+bool nsCoreUtils::IsDisplayContents(nsIContent* aContent) {
+  auto* element = Element::FromNodeOrNull(aContent);
+  return element && element->IsDisplayContents();
+}
+
+bool nsCoreUtils::CanCreateAccessibleWithoutFrame(nsIContent* aContent) {
+  auto* element = Element::FromNodeOrNull(aContent);
+  if (!element) {
+    return false;
+  }
+  if (!element->HasServoData() || Servo_Element_IsDisplayNone(element)) {
+    // Out of the flat tree or in a display: none subtree.
+    return false;
+  }
+
+  // If we aren't display: contents or option/optgroup we can't create an
+  // accessible without frame. Our select combobox code relies on the latter.
+  if (!element->IsDisplayContents() &&
+      !element->IsAnyOfHTMLElements(nsGkAtoms::option, nsGkAtoms::optgroup)) {
+    return false;
+  }
+
+  // Even if we're display: contents or optgroups, we might not be able to
+  // create an accessible if we're in a content-visibility: hidden subtree.
+  //
+  // To check that, find the closest ancestor element with a frame.
+  for (nsINode* ancestor = element->GetFlattenedTreeParentNode();
+       ancestor && ancestor->IsContent();
+       ancestor = ancestor->GetFlattenedTreeParentNode()) {
+    if (nsIFrame* f = ancestor->AsContent()->GetPrimaryFrame()) {
+      if (f->HidesContent(nsIFrame::IncludeContentVisibility::Hidden) ||
+          f->IsHiddenByContentVisibilityOnAnyAncestor(
+              nsIFrame::IncludeContentVisibility::Hidden)) {
+        return false;
+      }
+      break;
+    }
+  }
+
+  return true;
+}
+
+bool nsCoreUtils::IsDocumentVisibleConsideringInProcessAncestors(
+    const Document* aDocument) {
+  const Document* parent = aDocument;
+  do {
+    if (!parent->IsVisible()) {
+      return false;
+    }
+  } while ((parent = parent->GetInProcessParentDocument()));
+  return true;
+}
diff --git a/accessible/base/nsCoreUtils.h b/accessible/base/nsCoreUtils.h
new file mode 100644
index 0000000000..2c3e7330ff
--- /dev/null
+++ b/accessible/base/nsCoreUtils.h
@@ -0,0 +1,329 @@
+/* -*- 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 nsCoreUtils_h_
+#define nsCoreUtils_h_
+
+#include "AttrArray.h"
+#include "mozilla/EventForwards.h"
+#include "nsCaseTreatment.h"
+#include "nsIAccessibleEvent.h"
+#include "nsIContent.h"
+#include "mozilla/FlushType.h"
+#include "mozilla/PresShellForwards.h"
+
+#include "nsPoint.h"
+#include "nsTArray.h"
+#include "Units.h"
+
+class nsAttrValue;
+class nsGenericHTMLElement;
+class nsRange;
+class nsTreeColumn;
+class nsIFrame;
+class nsIDocShell;
+class nsIWidget;
+
+namespace mozilla {
+class PresShell;
+namespace dom {
+class Document;
+class XULTreeElement;
+}  // namespace dom
+}  // namespace mozilla
+
+/**
+ * Core utils.
+ */
+class nsCoreUtils {
+ public:
+  typedef mozilla::PresShell PresShell;
+  typedef mozilla::dom::Document Document;
+
+  /**
+   * Return true if the given node is a label of a control.
+   */
+  static bool IsLabelWithControl(nsIContent* aContent);
+
+  /**
+   * Return true if the given node has registered click, mousedown or mouseup
+   * event listeners.
+   */
+  static bool HasClickListener(nsIContent* aContent);
+
+  /**
+   * Dispatch click event to XUL tree cell.
+   *
+   * @param  aTree        [in] tree
+   * @param  aRowIndex    [in] row index
+   * @param  aColumn      [in] column object
+   * @param  aPseudoElm   [in] pseudo element inside the cell, see
+   *                       XULTreeElement for available values
+   */
+  MOZ_CAN_RUN_SCRIPT
+  static void DispatchClickEvent(mozilla::dom::XULTreeElement* aTree,
+                                 int32_t aRowIndex, nsTreeColumn* aColumn,
+                                 const nsAString& aPseudoElt = u""_ns);
+
+  /**
+   * Send mouse event to the given element.
+   *
+   * @param aMessage     [in] an event message (see EventForwards.h)
+   * @param aX           [in] x coordinate in dev pixels
+   * @param aY           [in] y coordinate in dev pixels
+   * @param aContent     [in] the element
+   * @param aFrame       [in] frame of the element
+   * @param aPresShell   [in] the presshell for the element
+   * @param aRootWidget  [in] the root widget of the element
+   */
+  MOZ_CAN_RUN_SCRIPT
+  static void DispatchMouseEvent(mozilla::EventMessage aMessage, int32_t aX,
+                                 int32_t aY, nsIContent* aContent,
+                                 nsIFrame* aFrame, PresShell* aPresShell,
+                                 nsIWidget* aRootWidget);
+
+  /**
+   * Send a touch event with a single touch point to the given element.
+   *
+   * @param aMessage     [in] an event message (see EventForwards.h)
+   * @param aX           [in] x coordinate in dev pixels
+   * @param aY           [in] y coordinate in dev pixels
+   * @param aContent     [in] the element
+   * @param aFrame       [in] frame of the element
+   * @param aPresShell   [in] the presshell for the element
+   * @param aRootWidget  [in] the root widget of the element
+   */
+  MOZ_CAN_RUN_SCRIPT
+  static void DispatchTouchEvent(mozilla::EventMessage aMessage, int32_t aX,
+                                 int32_t aY, nsIContent* aContent,
+                                 nsIFrame* aFrame, PresShell* aPresShell,
+                                 nsIWidget* aRootWidget);
+
+  /**
+   * Return an accesskey registered on the given element by
+   * EventStateManager or 0 if there is no registered accesskey.
+   *
+   * @param aContent - the given element.
+   */
+  static uint32_t GetAccessKeyFor(nsIContent* aContent);
+
+  /**
+   * Return DOM element related with the given node, i.e.
+   * a) itself if it is DOM element
+   * b) parent element if it is text node
+   * c) otherwise nullptr
+   *
+   * @param aNode  [in] the given DOM node
+   */
+  static nsIContent* GetDOMElementFor(nsIContent* aContent);
+
+  /**
+   * Return DOM node for the given DOM point.
+   */
+  static nsINode* GetDOMNodeFromDOMPoint(nsINode* aNode, uint32_t aOffset);
+
+  /**
+   * Is the first passed in node an ancestor of the second?
+   * Note: A node is not considered to be the ancestor of itself.
+   *
+   * @param  aPossibleAncestorNode   [in] node to test for ancestor-ness of
+   *                                   aPossibleDescendantNode
+   * @param  aPossibleDescendantNode [in] node to test for descendant-ness of
+   *                                   aPossibleAncestorNode
+   * @param  aRootNode               [in, optional] the root node that search
+   *                                   search should be performed within
+   * @return true                     if aPossibleAncestorNode is an ancestor of
+   *                                   aPossibleDescendantNode
+   */
+  static bool IsAncestorOf(nsINode* aPossibleAncestorNode,
+                           nsINode* aPossibleDescendantNode,
+                           nsINode* aRootNode = nullptr);
+
+  /**
+   * Helper method to scroll range into view, used for implementation of
+   * nsIAccessibleText::scrollSubstringTo().
+   *
+   * @param aFrame        the frame for accessible the range belongs to.
+   * @param aRange    the range to scroll to
+   * @param aScrollType   the place a range should be scrolled to
+   */
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY static nsresult ScrollSubstringTo(
+      nsIFrame* aFrame, nsRange* aRange, uint32_t aScrollType);
+
+  /** Helper method to scroll range into view, used for implementation of
+   * nsIAccessibleText::scrollSubstringTo[Point]().
+   *
+   * @param aFrame        the frame for accessible the range belongs to.
+   * @param aRange    the range to scroll to
+   * @param aVertical     how to align vertically, specified in percents, and
+   * when.
+   * @param aHorizontal     how to align horizontally, specified in percents,
+   * and when.
+   */
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY static nsresult ScrollSubstringTo(
+      nsIFrame* aFrame, nsRange* aRange, mozilla::ScrollAxis aVertical,
+      mozilla::ScrollAxis aHorizontal);
+
+  /**
+   * Scrolls the given frame to the point, used for implememntation of
+   * nsIAccessible::scrollToPoint and nsIAccessibleText::scrollSubstringToPoint.
+   *
+   * @param aScrollableFrame  the scrollable frame
+   * @param aFrame            the frame to scroll
+   * @param aPoint            the point scroll to (in dev pixels)
+   */
+  static void ScrollFrameToPoint(nsIFrame* aScrollableFrame, nsIFrame* aFrame,
+                                 const mozilla::LayoutDeviceIntPoint& aPoint);
+
+  /**
+   * Converts scroll type constant defined in nsIAccessibleScrollType to
+   * vertical and horizontal parameters.
+   */
+  static void ConvertScrollTypeToPercents(uint32_t aScrollType,
+                                          mozilla::ScrollAxis* aVertical,
+                                          mozilla::ScrollAxis* aHorizontal);
+
+  /**
+   * Return document shell for the given DOM node.
+   */
+  static already_AddRefed<nsIDocShell> GetDocShellFor(nsINode* aNode);
+
+  /**
+   * Return true if the given document is root document.
+   */
+  static bool IsRootDocument(Document* aDocument);
+
+  /**
+   * Return true if the given document is a top level content document in this
+   * process.
+   * This will be true for tab documents and out-of-process iframe documents.
+   */
+  static bool IsTopLevelContentDocInProcess(Document* aDocumentNode);
+
+  /**
+   * Return true if the given document is an error page.
+   */
+  static bool IsErrorPage(Document* aDocument);
+
+  /**
+   * Return presShell for the document containing the given DOM node.
+   */
+  static PresShell* GetPresShellFor(nsINode* aNode);
+
+  /**
+   * Get the ID for an element, in some types of XML this may not be the ID
+   * attribute
+   * @param aContent  Node to get the ID for
+   * @param aID       Where to put ID string
+   * @return          true if there is an ID set for this node
+   */
+  static bool GetID(nsIContent* aContent, nsAString& aID);
+
+  /**
+   * Convert attribute value of the given node to positive integer. If no
+   * attribute or wrong value then false is returned.
+   */
+  static bool GetUIntAttr(nsIContent* aContent, nsAtom* aAttr, int32_t* aUInt);
+  static bool GetUIntAttrValue(const nsAttrValue* aVal, int32_t* aUInt);
+
+  /**
+   * Returns language for the given node.
+   *
+   * @param aContent     [in] the given node
+   * @param aRootContent [in] container of the given node
+   * @param aLanguage    [out] language
+   */
+  static void GetLanguageFor(nsIContent* aContent, nsIContent* aRootContent,
+                             nsAString& aLanguage);
+
+  /**
+   * Return tree from any levels DOMNode under the XUL tree.
+   */
+  static mozilla::dom::XULTreeElement* GetTree(nsIContent* aContent);
+
+  /**
+   * Return first sensible column for the given tree box object.
+   */
+  static already_AddRefed<nsTreeColumn> GetFirstSensibleColumn(
+      mozilla::dom::XULTreeElement* aTree,
+      mozilla::FlushType = mozilla::FlushType::Frames);
+
+  /**
+   * Return sensible columns count for the given tree box object.
+   */
+  static uint32_t GetSensibleColumnCount(mozilla::dom::XULTreeElement* aTree);
+
+  /**
+   * Return sensible column at the given index for the given tree box object.
+   */
+  static already_AddRefed<nsTreeColumn> GetSensibleColumnAt(
+      mozilla::dom::XULTreeElement* aTree, uint32_t aIndex);
+
+  /**
+   * Return next sensible column for the given column.
+   */
+  static already_AddRefed<nsTreeColumn> GetNextSensibleColumn(
+      nsTreeColumn* aColumn);
+
+  /**
+   * Return previous sensible column for the given column.
+   */
+  static already_AddRefed<nsTreeColumn> GetPreviousSensibleColumn(
+      nsTreeColumn* aColumn);
+
+  /**
+   * Return true if the given column is hidden (i.e. not sensible).
+   */
+  static bool IsColumnHidden(nsTreeColumn* aColumn);
+
+  /**
+   * Scroll content into view.
+   */
+  MOZ_CAN_RUN_SCRIPT
+  static void ScrollTo(PresShell* aPresShell, nsIContent* aContent,
+                       uint32_t aScrollType);
+
+  /**
+   * Return true if the given node is table header element.
+   */
+  static bool IsHTMLTableHeader(nsIContent* aContent);
+
+  /**
+   * Returns true if the given string is empty or contains whitespace symbols
+   * only. In contrast to nsWhitespaceTokenizer class it takes into account
+   * non-breaking space (0xa0).
+   */
+  static bool IsWhitespaceString(const nsAString& aString);
+
+  /**
+   * Returns true if the given character is whitespace symbol.
+   */
+  static bool IsWhitespace(char16_t aChar) {
+    return aChar == ' ' || aChar == '\n' || aChar == '\r' || aChar == '\t' ||
+           aChar == 0xa0;
+  }
+
+  /*
+   * Return true if there are any observers of accessible events.
+   */
+  static bool AccEventObserversExist();
+
+  /**
+   * Notify accessible event observers of an event.
+   */
+  static void DispatchAccEvent(RefPtr<nsIAccessibleEvent> aEvent);
+
+  static bool IsDisplayContents(nsIContent* aContent);
+  static bool CanCreateAccessibleWithoutFrame(nsIContent* aContent);
+
+  /**
+   * Return whether the document and all its in-process ancestors are visible in
+   * the sense of pageshow / hide.
+   */
+  static bool IsDocumentVisibleConsideringInProcessAncestors(
+      const Document* aDocument);
+};
+
+#endif
diff --git a/accessible/base/nsEventShell.cpp b/accessible/base/nsEventShell.cpp
new file mode 100644
index 0000000000..fcdc954919
--- /dev/null
+++ b/accessible/base/nsEventShell.cpp
@@ -0,0 +1,81 @@
+/* -*- 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 "nsEventShell.h"
+
+#include "nsAccUtils.h"
+#include "Logging.h"
+#include "AccAttributes.h"
+
+#include "mozilla/StaticPtr.h"
+#include "mozilla/dom/DOMStringList.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// nsEventShell
+////////////////////////////////////////////////////////////////////////////////
+
+void nsEventShell::FireEvent(AccEvent* aEvent) {
+  if (!aEvent || aEvent->mEventRule == AccEvent::eDoNotEmit) return;
+
+  LocalAccessible* accessible = aEvent->GetAccessible();
+  NS_ENSURE_TRUE_VOID(accessible);
+
+  nsINode* node = accessible->GetNode();
+  if (node) {
+    sEventTargetNode = node;
+    sEventFromUserInput = aEvent->IsFromUserInput();
+  }
+
+#ifdef A11Y_LOG
+  if (logging::IsEnabled(logging::eEvents)) {
+    logging::MsgBegin("EVENTS", "events fired");
+    nsAutoString type;
+    GetAccService()->GetStringEventType(aEvent->GetEventType(), type);
+    logging::MsgEntry("type: %s", NS_ConvertUTF16toUTF8(type).get());
+    if (aEvent->GetEventType() == nsIAccessibleEvent::EVENT_STATE_CHANGE) {
+      AccStateChangeEvent* event = downcast_accEvent(aEvent);
+      RefPtr<dom::DOMStringList> stringStates =
+          GetAccService()->GetStringStates(event->GetState());
+      nsAutoString state;
+      stringStates->Item(0, state);
+      logging::MsgEntry("state: %s = %s", NS_ConvertUTF16toUTF8(state).get(),
+                        event->IsStateEnabled() ? "true" : "false");
+    }
+    logging::AccessibleInfo("target", aEvent->GetAccessible());
+    logging::MsgEnd();
+  }
+#endif
+
+  accessible->HandleAccEvent(aEvent);
+  aEvent->mEventRule = AccEvent::eDoNotEmit;
+
+  sEventTargetNode = nullptr;
+}
+
+void nsEventShell::FireEvent(uint32_t aEventType, LocalAccessible* aAccessible,
+                             EIsFromUserInput aIsFromUserInput) {
+  NS_ENSURE_TRUE_VOID(aAccessible);
+
+  RefPtr<AccEvent> event =
+      new AccEvent(aEventType, aAccessible, aIsFromUserInput);
+
+  FireEvent(event);
+}
+
+void nsEventShell::GetEventAttributes(nsINode* aNode,
+                                      AccAttributes* aAttributes) {
+  if (aNode != sEventTargetNode) return;
+
+  aAttributes->SetAttribute(nsGkAtoms::eventFromInput, sEventFromUserInput);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsEventShell: private
+
+bool nsEventShell::sEventFromUserInput = false;
+StaticRefPtr<nsINode> nsEventShell::sEventTargetNode;
diff --git a/accessible/base/nsEventShell.h b/accessible/base/nsEventShell.h
new file mode 100644
index 0000000000..ff2e062750
--- /dev/null
+++ b/accessible/base/nsEventShell.h
@@ -0,0 +1,66 @@
+/* -*- 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 _nsEventShell_H_
+#define _nsEventShell_H_
+
+#include "AccEvent.h"
+
+namespace mozilla {
+template <typename T>
+class StaticRefPtr;
+}
+
+/**
+ * Used for everything about events.
+ */
+class nsEventShell {
+ public:
+  /**
+   * Fire the accessible event.
+   */
+  static void FireEvent(mozilla::a11y::AccEvent* aEvent);
+
+  /**
+   * Fire accessible event of the given type for the given accessible.
+   *
+   * @param  aEventType   [in] the event type
+   * @param  aAccessible  [in] the event target
+   */
+  static void FireEvent(uint32_t aEventType,
+                        mozilla::a11y::LocalAccessible* aAccessible,
+                        mozilla::a11y::EIsFromUserInput aIsFromUserInput =
+                            mozilla::a11y::eAutoDetect);
+
+  /**
+   * Fire state change event.
+   */
+  static void FireEvent(mozilla::a11y::LocalAccessible* aTarget,
+                        uint64_t aState, bool aIsEnabled,
+                        bool aIsFromUserInput) {
+    RefPtr<mozilla::a11y::AccStateChangeEvent> stateChangeEvent =
+        new mozilla::a11y::AccStateChangeEvent(
+            aTarget, aState, aIsEnabled,
+            (aIsFromUserInput ? mozilla::a11y::eFromUserInput
+                              : mozilla::a11y::eNoUserInput));
+    FireEvent(stateChangeEvent);
+  }
+
+  /**
+   * Append 'event-from-input' object attribute if the accessible event has
+   * been fired just now for the given node.
+   *
+   * @param  aNode        [in] the DOM node
+   * @param  aAttributes  [in, out] the attributes
+   */
+  static void GetEventAttributes(nsINode* aNode,
+                                 mozilla::a11y::AccAttributes* aAttributes);
+
+ private:
+  static mozilla::StaticRefPtr<nsINode> sEventTargetNode;
+  static bool sEventFromUserInput;
+};
+
+#endif
diff --git a/accessible/base/nsTextEquivUtils.cpp b/accessible/base/nsTextEquivUtils.cpp
new file mode 100644
index 0000000000..d95229c1dc
--- /dev/null
+++ b/accessible/base/nsTextEquivUtils.cpp
@@ -0,0 +1,360 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=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 "nsTextEquivUtils.h"
+
+#include "LocalAccessible-inl.h"
+#include "AccIterator.h"
+#include "nsCoreUtils.h"
+#include "mozilla/dom/ChildIterator.h"
+#include "mozilla/dom/Text.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+/**
+ * The accessible for which we are computing a text equivalent. It is useful
+ * for bailing out during recursive text computation, or for special cases
+ * like step f. of the ARIA implementation guide.
+ */
+static const Accessible* sInitiatorAcc = nullptr;
+
+////////////////////////////////////////////////////////////////////////////////
+// nsTextEquivUtils. Public.
+
+nsresult nsTextEquivUtils::GetNameFromSubtree(
+    const LocalAccessible* aAccessible, nsAString& aName) {
+  aName.Truncate();
+
+  if (sInitiatorAcc) return NS_OK;
+
+  sInitiatorAcc = aAccessible;
+  if (GetRoleRule(aAccessible->Role()) == eNameFromSubtreeRule) {
+    // XXX: is it necessary to care the accessible is not a document?
+    if (aAccessible->IsContent()) {
+      nsAutoString name;
+      AppendFromAccessibleChildren(aAccessible, &name);
+      name.CompressWhitespace();
+      if (!nsCoreUtils::IsWhitespaceString(name)) aName = name;
+    }
+  }
+
+  sInitiatorAcc = nullptr;
+
+  return NS_OK;
+}
+
+nsresult nsTextEquivUtils::GetTextEquivFromIDRefs(
+    const LocalAccessible* aAccessible, nsAtom* aIDRefsAttr,
+    nsAString& aTextEquiv) {
+  aTextEquiv.Truncate();
+
+  nsIContent* content = aAccessible->GetContent();
+  if (!content) return NS_OK;
+
+  nsIContent* refContent = nullptr;
+  IDRefsIterator iter(aAccessible->Document(), content, aIDRefsAttr);
+  while ((refContent = iter.NextElem())) {
+    if (!aTextEquiv.IsEmpty()) aTextEquiv += ' ';
+
+    if (refContent->IsHTMLElement(nsGkAtoms::slot)) printf("jtd idref slot\n");
+    nsresult rv =
+        AppendTextEquivFromContent(aAccessible, refContent, &aTextEquiv);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+nsresult nsTextEquivUtils::AppendTextEquivFromContent(
+    const LocalAccessible* aInitiatorAcc, nsIContent* aContent,
+    nsAString* aString) {
+  // Prevent recursion which can cause infinite loops.
+  if (sInitiatorAcc) return NS_OK;
+
+  sInitiatorAcc = aInitiatorAcc;
+
+  nsresult rv = NS_ERROR_FAILURE;
+  if (LocalAccessible* accessible =
+          aInitiatorAcc->Document()->GetAccessible(aContent)) {
+    rv = AppendFromAccessible(accessible, aString);
+  } else {
+    // The given content is invisible or otherwise inaccessible, so use the DOM
+    // subtree.
+    rv = AppendFromDOMNode(aContent, aString);
+  }
+
+  sInitiatorAcc = nullptr;
+  return rv;
+}
+
+nsresult nsTextEquivUtils::AppendTextEquivFromTextContent(nsIContent* aContent,
+                                                          nsAString* aString) {
+  if (aContent->IsText()) {
+    if (aContent->TextLength() > 0) {
+      nsIFrame* frame = aContent->GetPrimaryFrame();
+      if (frame) {
+        nsIFrame::RenderedText text = frame->GetRenderedText(
+            0, UINT32_MAX, nsIFrame::TextOffsetType::OffsetsInContentText,
+            nsIFrame::TrailingWhitespace::DontTrim);
+        aString->Append(text.mString);
+      } else {
+        // If aContent is an object that is display: none, we have no a frame.
+        aContent->GetAsText()->AppendTextTo(*aString);
+      }
+    }
+
+    return NS_OK;
+  }
+
+  if (aContent->IsHTMLElement() &&
+      aContent->NodeInfo()->Equals(nsGkAtoms::br)) {
+    aString->AppendLiteral("\r\n");
+    return NS_OK;
+  }
+
+  return NS_OK_NO_NAME_CLAUSE_HANDLED;
+}
+
+nsresult nsTextEquivUtils::AppendFromDOMChildren(nsIContent* aContent,
+                                                 nsAString* aString) {
+  auto iter =
+      dom::AllChildrenIterator(aContent, nsIContent::eAllChildren, true);
+  while (nsIContent* childContent = iter.GetNextChild()) {
+    nsresult rv = AppendFromDOMNode(childContent, aString);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsTextEquivUtils. Private.
+
+nsresult nsTextEquivUtils::AppendFromAccessibleChildren(
+    const Accessible* aAccessible, nsAString* aString) {
+  nsresult rv = NS_OK_NO_NAME_CLAUSE_HANDLED;
+
+  uint32_t childCount = aAccessible->ChildCount();
+  for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
+    Accessible* child = aAccessible->ChildAt(childIdx);
+    rv = AppendFromAccessible(child, aString);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return rv;
+}
+
+nsresult nsTextEquivUtils::AppendFromAccessible(Accessible* aAccessible,
+                                                nsAString* aString) {
+  // XXX: is it necessary to care the accessible is not a document?
+  bool isHTMLBlock = false;
+  if (aAccessible->IsLocal() && aAccessible->AsLocal()->IsContent()) {
+    nsIContent* content = aAccessible->AsLocal()->GetContent();
+    nsresult rv = AppendTextEquivFromTextContent(content, aString);
+    if (rv != NS_OK_NO_NAME_CLAUSE_HANDLED) return rv;
+    if (!content->IsText()) {
+      nsIFrame* frame = content->GetPrimaryFrame();
+      if (frame) {
+        // If this is a block level frame (as opposed to span level), we need to
+        // add spaces around that block's text, so we don't get words jammed
+        // together in final name.
+        const nsStyleDisplay* display = frame->StyleDisplay();
+        if (display->IsBlockOutsideStyle() ||
+            display->mDisplay == StyleDisplay::TableCell) {
+          isHTMLBlock = true;
+          if (!aString->IsEmpty()) {
+            aString->Append(char16_t(' '));
+          }
+        }
+      }
+    }
+  }
+
+  bool isEmptyTextEquiv = true;
+
+  // If the name is from tooltip then append it to result string in the end
+  // (see h. step of name computation guide).
+  nsAutoString text;
+  if (aAccessible->Name(text) != eNameFromTooltip) {
+    isEmptyTextEquiv = !AppendString(aString, text);
+  }
+
+  // Implementation of f. step.
+  nsresult rv = AppendFromValue(aAccessible, aString);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (rv != NS_OK_NO_NAME_CLAUSE_HANDLED) isEmptyTextEquiv = false;
+
+  // Implementation of g) step of text equivalent computation guide. Go down
+  // into subtree if accessible allows "text equivalent from subtree rule" or
+  // it's not root and not control.
+  if (isEmptyTextEquiv) {
+    if (ShouldIncludeInSubtreeCalculation(aAccessible)) {
+      rv = AppendFromAccessibleChildren(aAccessible, aString);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      if (rv != NS_OK_NO_NAME_CLAUSE_HANDLED) isEmptyTextEquiv = false;
+    }
+  }
+
+  // Implementation of h. step
+  if (isEmptyTextEquiv && !text.IsEmpty()) {
+    AppendString(aString, text);
+    if (isHTMLBlock) {
+      aString->Append(char16_t(' '));
+    }
+    return NS_OK;
+  }
+
+  if (!isEmptyTextEquiv && isHTMLBlock) {
+    aString->Append(char16_t(' '));
+  }
+  return rv;
+}
+
+nsresult nsTextEquivUtils::AppendFromValue(Accessible* aAccessible,
+                                           nsAString* aString) {
+  if (GetRoleRule(aAccessible->Role()) != eNameFromValueRule) {
+    return NS_OK_NO_NAME_CLAUSE_HANDLED;
+  }
+
+  // Implementation of step f. of text equivalent computation. If the given
+  // accessible is not root accessible (the accessible the text equivalent is
+  // computed for in the end) then append accessible value. Otherwise append
+  // value if and only if the given accessible is in the middle of its parent.
+
+  nsAutoString text;
+  if (aAccessible != sInitiatorAcc) {
+    aAccessible->Value(text);
+
+    return AppendString(aString, text) ? NS_OK : NS_OK_NO_NAME_CLAUSE_HANDLED;
+  }
+
+  // XXX: is it necessary to care the accessible is not a document?
+  if (aAccessible->IsDoc()) return NS_ERROR_UNEXPECTED;
+
+  for (Accessible* next = aAccessible->NextSibling(); next;
+       next = next->NextSibling()) {
+    if (!IsWhitespaceLeaf(next)) {
+      for (Accessible* prev = aAccessible->PrevSibling(); prev;
+           prev = prev->PrevSibling()) {
+        if (!IsWhitespaceLeaf(prev)) {
+          aAccessible->Value(text);
+
+          return AppendString(aString, text) ? NS_OK
+                                             : NS_OK_NO_NAME_CLAUSE_HANDLED;
+        }
+      }
+    }
+  }
+
+  return NS_OK_NO_NAME_CLAUSE_HANDLED;
+}
+
+nsresult nsTextEquivUtils::AppendFromDOMNode(nsIContent* aContent,
+                                             nsAString* aString) {
+  nsresult rv = AppendTextEquivFromTextContent(aContent, aString);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (rv != NS_OK_NO_NAME_CLAUSE_HANDLED) return NS_OK;
+
+  if (aContent->IsAnyOfHTMLElements(nsGkAtoms::script, nsGkAtoms::style)) {
+    // The text within these elements is never meant for users.
+    return NS_OK;
+  }
+
+  if (aContent->IsXULElement()) {
+    nsAutoString textEquivalent;
+    if (aContent->NodeInfo()->Equals(nsGkAtoms::label, kNameSpaceID_XUL)) {
+      aContent->AsElement()->GetAttr(nsGkAtoms::value, textEquivalent);
+    } else {
+      aContent->AsElement()->GetAttr(nsGkAtoms::label, textEquivalent);
+    }
+
+    if (textEquivalent.IsEmpty()) {
+      aContent->AsElement()->GetAttr(nsGkAtoms::tooltiptext, textEquivalent);
+    }
+
+    AppendString(aString, textEquivalent);
+  }
+
+  return AppendFromDOMChildren(aContent, aString);
+}
+
+bool nsTextEquivUtils::AppendString(nsAString* aString,
+                                    const nsAString& aTextEquivalent) {
+  if (aTextEquivalent.IsEmpty()) return false;
+
+  // Insert spaces to insure that words from controls aren't jammed together.
+  if (!aString->IsEmpty() && !nsCoreUtils::IsWhitespace(aString->Last())) {
+    aString->Append(char16_t(' '));
+  }
+
+  aString->Append(aTextEquivalent);
+
+  if (!nsCoreUtils::IsWhitespace(aString->Last())) {
+    aString->Append(char16_t(' '));
+  }
+
+  return true;
+}
+
+uint32_t nsTextEquivUtils::GetRoleRule(role aRole) {
+#define ROLE(geckoRole, stringRole, ariaRole, atkRole, macRole, macSubrole, \
+             msaaRole, ia2Role, androidClass, nameRule)                     \
+  case roles::geckoRole:                                                    \
+    return nameRule;
+
+  switch (aRole) {
+#include "RoleMap.h"
+    default:
+      MOZ_CRASH("Unknown role.");
+  }
+
+#undef ROLE
+}
+
+bool nsTextEquivUtils::ShouldIncludeInSubtreeCalculation(
+    Accessible* aAccessible) {
+  uint32_t nameRule = GetRoleRule(aAccessible->Role());
+  if (nameRule == eNameFromSubtreeRule) {
+    return true;
+  }
+  if (!(nameRule & eNameFromSubtreeIfReqRule)) {
+    return false;
+  }
+
+  if (aAccessible == sInitiatorAcc) {
+    // We're calculating the text equivalent for this accessible, but this
+    // accessible should only be included when calculating the text equivalent
+    // for something else.
+    return false;
+  }
+
+  // sInitiatorAcc can be null when, for example, LocalAccessible::Value calls
+  // GetTextEquivFromSubtree.
+  role initiatorRole = sInitiatorAcc ? sInitiatorAcc->Role() : roles::NOTHING;
+  if (initiatorRole == roles::OUTLINEITEM &&
+      aAccessible->Role() == roles::GROUPING) {
+    // Child treeitems are contained in a group. We don't want to include those
+    // in the parent treeitem's text equivalent.
+    return false;
+  }
+
+  return true;
+}
+
+bool nsTextEquivUtils::IsWhitespaceLeaf(Accessible* aAccessible) {
+  if (!aAccessible || !aAccessible->IsTextLeaf()) {
+    return false;
+  }
+
+  nsAutoString name;
+  aAccessible->Name(name);
+  return nsCoreUtils::IsWhitespaceString(name);
+}
diff --git a/accessible/base/nsTextEquivUtils.h b/accessible/base/nsTextEquivUtils.h
new file mode 100644
index 0000000000..525727b102
--- /dev/null
+++ b/accessible/base/nsTextEquivUtils.h
@@ -0,0 +1,182 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=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 _nsTextEquivUtils_H_
+#define _nsTextEquivUtils_H_
+
+#include "mozilla/a11y/Accessible.h"
+#include "mozilla/a11y/Role.h"
+
+class nsIContent;
+
+namespace mozilla {
+namespace a11y {
+class LocalAccessible;
+}
+}  // namespace mozilla
+
+/**
+ * Text equivalent computation rules (see nsTextEquivUtils::gRoleToNameRulesMap)
+ */
+enum ETextEquivRule {
+  // No rule.
+  eNoNameRule = 0x00,
+
+  // Walk into subtree only if the currently navigated accessible is not root
+  // accessible (i.e. if the accessible is part of text equivalent computation).
+  eNameFromSubtreeIfReqRule = 0x01,
+
+  // Text equivalent computation from subtree is allowed.
+  eNameFromSubtreeRule = 0x03,
+
+  // The accessible allows to append its value to text equivalent.
+  // XXX: This is temporary solution. Once we move accessible value of links
+  // and linkable accessibles to MSAA part we can remove this.
+  eNameFromValueRule = 0x04
+};
+
+/**
+ * The class provides utils methods to compute the accessible name and
+ * description.
+ */
+class nsTextEquivUtils {
+ public:
+  typedef mozilla::a11y::LocalAccessible LocalAccessible;
+  typedef mozilla::a11y::Accessible Accessible;
+
+  /**
+   * Determines if the accessible has a given name rule.
+   *
+   * @param aAccessible [in] the given accessible
+   * @param aRule       [in] a given name rule
+   * @return true if the accessible has the rule
+   */
+  static inline bool HasNameRule(Accessible* aAccessible,
+                                 ETextEquivRule aRule) {
+    return (GetRoleRule(aAccessible->Role()) & aRule) == aRule;
+  }
+
+  /**
+   * Calculates the name from accessible subtree if allowed.
+   *
+   * @param aAccessible [in] the given accessible
+   * @param aName       [out] accessible name
+   */
+  static nsresult GetNameFromSubtree(const LocalAccessible* aAccessible,
+                                     nsAString& aName);
+
+  /**
+   * Calculates text equivalent from the subtree. Similar to GetNameFromSubtree.
+   * However it returns not empty result for things like HTML p.
+   */
+  static void GetTextEquivFromSubtree(const Accessible* aAccessible,
+                                      nsString& aTextEquiv) {
+    aTextEquiv.Truncate();
+
+    AppendFromAccessibleChildren(aAccessible, &aTextEquiv);
+    aTextEquiv.CompressWhitespace();
+  }
+
+  /**
+   * Calculates text equivalent for the given accessible from its IDRefs
+   * attribute (like aria-labelledby or aria-describedby).
+   *
+   * @param aAccessible  [in] the accessible text equivalent is computed for
+   * @param aIDRefsAttr  [in] IDRefs attribute on DOM node of the accessible
+   * @param aTextEquiv   [out] result text equivalent
+   */
+  static nsresult GetTextEquivFromIDRefs(const LocalAccessible* aAccessible,
+                                         nsAtom* aIDRefsAttr,
+                                         nsAString& aTextEquiv);
+
+  /**
+   * Calculates the text equivalent from the given content and its subtree if
+   * allowed and appends it to the given string.
+   *
+   * @param aInitiatorAcc  [in] the accessible text equivalent is computed for
+   *                       in the end (root accessible of text equivalent
+   *                       calculation recursion)
+   * @param aContent       [in] the given content the text equivalent is
+   *                       computed from
+   * @param aString        [in, out] the string
+   */
+  static nsresult AppendTextEquivFromContent(
+      const LocalAccessible* aInitiatorAcc, nsIContent* aContent,
+      nsAString* aString);
+
+  /**
+   * Calculates the text equivalent from the given text content (may be text
+   * node or html:br) and appends it to the given string.
+   *
+   * @param aContent       [in] the text content
+   * @param aString        [in, out] the string
+   */
+  static nsresult AppendTextEquivFromTextContent(nsIContent* aContent,
+                                                 nsAString* aString);
+
+  /**
+   * Iterates DOM children and calculates text equivalent from each child node.
+   * Then, appends found text to the given string.
+   *
+   * @param aContent      [in] the node to fetch DOM children from
+   * @param aString       [in, out] the string
+   */
+  static nsresult AppendFromDOMChildren(nsIContent* aContent,
+                                        nsAString* aString);
+
+ private:
+  /**
+   * Iterates accessible children and calculates text equivalent from each
+   * child.
+   */
+  static nsresult AppendFromAccessibleChildren(const Accessible* aAccessible,
+                                               nsAString* aString);
+
+  /**
+   * Calculates text equivalent from the given accessible and its subtree if
+   * allowed.
+   */
+  static nsresult AppendFromAccessible(Accessible* aAccessible,
+                                       nsAString* aString);
+
+  /**
+   * Calculates text equivalent from the value of given accessible.
+   */
+  static nsresult AppendFromValue(Accessible* aAccessible, nsAString* aString);
+
+  /**
+   * Calculates text equivalent from the given DOM node and its subtree if
+   * allowed.
+   */
+  static nsresult AppendFromDOMNode(nsIContent* aContent, nsAString* aString);
+
+  /**
+   * Concatenates strings and appends space between them. Returns true if
+   * text equivalent string was appended.
+   */
+  static bool AppendString(nsAString* aString,
+                           const nsAString& aTextEquivalent);
+
+  /**
+   * Returns the rule (constant of ETextEquivRule) for a given role.
+   */
+  static uint32_t GetRoleRule(mozilla::a11y::roles::Role aRole);
+
+  /**
+   * Returns true if a given accessible should be included when calculating
+   * the text equivalent for the initiator's subtree.
+   */
+  static bool ShouldIncludeInSubtreeCalculation(Accessible* aAccessible);
+
+  /**
+   * Returns true if a given accessible is a text leaf containing only
+   * whitespace.
+   */
+  static bool IsWhitespaceLeaf(Accessible* aAccessible);
+};
+
+#endif