diff -r 000000000000 -r 6474c204b198 accessible/src/generic/Accessible.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/accessible/src/generic/Accessible.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,3337 @@
+/* -*- 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 "Accessible-inl.h"
+
+#include "nsIXBLAccessible.h"
+
+#include "AccCollector.h"
+#include "AccGroupInfo.h"
+#include "AccIterator.h"
+#include "nsAccUtils.h"
+#include "nsAccessibleRelation.h"
+#include "nsAccessibilityService.h"
+#include "ApplicationAccessible.h"
+#include "nsCoreUtils.h"
+#include "nsIAccessibleRelation.h"
+#include "nsIAccessibleRole.h"
+#include "nsEventShell.h"
+#include "nsTextEquivUtils.h"
+#include "Relation.h"
+#include "Role.h"
+#include "RootAccessible.h"
+#include "States.h"
+#include "StyleInfo.h"
+#include "TableAccessible.h"
+#include "TableCellAccessible.h"
+#include "TreeWalker.h"
+
+#include "nsIDOMElement.h"
+#include "nsIDOMNodeFilter.h"
+#include "nsIDOMHTMLElement.h"
+#include "nsIDOMKeyEvent.h"
+#include "nsIDOMTreeWalker.h"
+#include "nsIDOMXULButtonElement.h"
+#include "nsIDOMXULDocument.h"
+#include "nsIDOMXULElement.h"
+#include "nsIDOMXULLabelElement.h"
+#include "nsIDOMXULSelectCntrlEl.h"
+#include "nsIDOMXULSelectCntrlItemEl.h"
+#include "nsPIDOMWindow.h"
+
+#include "nsIDocument.h"
+#include "nsIContent.h"
+#include "nsIForm.h"
+#include "nsIFormControl.h"
+
+#include "nsDeckFrame.h"
+#include "nsLayoutUtils.h"
+#include "nsIPresShell.h"
+#include "nsIStringBundle.h"
+#include "nsPresContext.h"
+#include "nsIFrame.h"
+#include "nsView.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIScrollableFrame.h"
+#include "nsFocusManager.h"
+
+#include "nsXPIDLString.h"
+#include "nsUnicharUtils.h"
+#include "nsReadableUtils.h"
+#include "prdtoa.h"
+#include "nsIAtom.h"
+#include "nsIURI.h"
+#include "nsArrayUtils.h"
+#include "nsIMutableArray.h"
+#include "nsIObserverService.h"
+#include "nsIServiceManager.h"
+#include "nsWhitespaceTokenizer.h"
+#include "nsAttrName.h"
+#include "nsNetUtil.h"
+
+#ifdef DEBUG
+#include "nsIDOMCharacterData.h"
+#endif
+
+#include "mozilla/Assertions.h"
+#include "mozilla/EventStates.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/unused.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/TreeWalker.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Accessible: nsISupports and cycle collection
+
+NS_IMPL_CYCLE_COLLECTION(Accessible,
+                         mContent, mParent, mChildren)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Accessible)
+  NS_INTERFACE_MAP_ENTRY(nsIAccessible)
+  if (aIID.Equals(NS_GET_IID(Accessible)))
+    foundInterface = static_cast<nsIAccessible*>(this);
+  else
+  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleSelectable, IsSelect())
+  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleValue, HasNumericValue())
+  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleHyperLink, IsLink())
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIAccessible)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(Accessible)
+NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_DESTROY(Accessible, LastRelease())
+
+Accessible::Accessible(nsIContent* aContent, DocAccessible* aDoc) :
+  mContent(aContent), mDoc(aDoc),
+  mParent(nullptr), mIndexInParent(-1), mChildrenFlags(eChildrenUninitialized),
+  mStateFlags(0), mContextFlags(0), mType(0), mGenericTypes(0),
+  mIndexOfEmbeddedChild(-1), mRoleMapEntry(nullptr)
+{
+#ifdef NS_DEBUG_X
+   {
+     nsCOMPtr<nsIPresShell> shell(do_QueryReferent(aShell));
+     printf(">>> %p Created Acc - DOM: %p  PS: %p", 
+            (void*)static_cast<nsIAccessible*>(this), (void*)aNode,
+            (void*)shell.get());
+    nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
+    if (content) {
+      printf(" Con: %s@%p",
+             NS_ConvertUTF16toUTF8(content->NodeInfo()->QualifiedName()).get(),
+             (void *)content.get());
+      nsAutoString buf;
+      Name(buf);
+      printf(" Name:[%s]", NS_ConvertUTF16toUTF8(buf).get());
+     }
+     printf("\n");
+   }
+#endif
+}
+
+Accessible::~Accessible()
+{
+  NS_ASSERTION(!mDoc, "LastRelease was never called!?!");
+}
+
+NS_IMETHODIMP
+Accessible::GetDocument(nsIAccessibleDocument** aDocument)
+{
+  NS_ENSURE_ARG_POINTER(aDocument);
+
+  NS_IF_ADDREF(*aDocument = Document());
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::GetDOMNode(nsIDOMNode** aDOMNode)
+{
+  NS_ENSURE_ARG_POINTER(aDOMNode);
+  *aDOMNode = nullptr;
+
+  nsINode *node = GetNode();
+  if (node)
+    CallQueryInterface(node, aDOMNode);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::GetRootDocument(nsIAccessibleDocument** aRootDocument)
+{
+  NS_ENSURE_ARG_POINTER(aRootDocument);
+
+  NS_IF_ADDREF(*aRootDocument = RootAccessible());
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::GetLanguage(nsAString& aLanguage)
+{
+  Language(aLanguage);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::GetName(nsAString& aName)
+{
+  aName.Truncate();
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  nsAutoString name;
+  Name(name);
+  aName.Assign(name);
+
+  return NS_OK;
+}
+
+ENameValueFlag
+Accessible::Name(nsString& aName)
+{
+  aName.Truncate();
+
+  if (!HasOwnContent())
+    return eNameOK;
+
+  ARIAName(aName);
+  if (!aName.IsEmpty())
+    return eNameOK;
+
+  nsCOMPtr<nsIXBLAccessible> xblAccessible(do_QueryInterface(mContent));
+  if (xblAccessible) {
+    xblAccessible->GetAccessibleName(aName);
+    if (!aName.IsEmpty())
+      return eNameOK;
+  }
+
+  ENameValueFlag nameFlag = NativeName(aName);
+  if (!aName.IsEmpty())
+    return nameFlag;
+
+  // In the end get the name from tooltip.
+  if (mContent->IsHTML()) {
+    if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::title, aName)) {
+      aName.CompressWhitespace();
+      return eNameFromTooltip;
+    }
+  } else if (mContent->IsXUL()) {
+    if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::tooltiptext, aName)) {
+      aName.CompressWhitespace();
+      return eNameFromTooltip;
+    }
+  } else if (mContent->IsSVG()) {
+    // If user agents need to choose among multiple ‘desc’ or ‘title’ elements
+    // for processing, the user agent shall choose the first one.
+    for (nsIContent* childElm = mContent->GetFirstChild(); childElm;
+         childElm = childElm->GetNextSibling()) {
+      if (childElm->IsSVG(nsGkAtoms::desc)) {
+        nsTextEquivUtils::AppendTextEquivFromContent(this, childElm, &aName);
+        return eNameFromTooltip;
+      }
+    }
+  }
+
+  if (nameFlag != eNoNameOnPurpose)
+    aName.SetIsVoid(true);
+
+  return nameFlag;
+}
+
+NS_IMETHODIMP
+Accessible::GetDescription(nsAString& aDescription)
+{
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  nsAutoString desc;
+  Description(desc);
+  aDescription.Assign(desc);
+
+  return NS_OK;
+}
+
+void
+Accessible::Description(nsString& aDescription)
+{
+  // There are 4 conditions that make an accessible have no accDescription:
+  // 1. it's a text node; or
+  // 2. It has no DHTML describedby property
+  // 3. it doesn't have an accName; or
+  // 4. its title attribute already equals to its accName nsAutoString name; 
+
+  if (!HasOwnContent() || mContent->IsNodeOfType(nsINode::eTEXT))
+    return;
+
+  nsTextEquivUtils::
+    GetTextEquivFromIDRefs(this, nsGkAtoms::aria_describedby,
+                           aDescription);
+
+  if (aDescription.IsEmpty()) {
+    bool isXUL = mContent->IsXUL();
+    if (isXUL) {
+      // Try XUL <description control="[id]">description text</description>
+      XULDescriptionIterator iter(Document(), mContent);
+      Accessible* descr = nullptr;
+      while ((descr = iter.Next())) {
+        nsTextEquivUtils::AppendTextEquivFromContent(this, descr->GetContent(),
+                                                     &aDescription);
+      }
+    }
+
+    if (aDescription.IsEmpty()) {
+      // Keep the Name() method logic.
+      if (mContent->IsHTML()) {
+        mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::title, aDescription);
+      } else if (mContent->IsXUL()) {
+        mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::tooltiptext, aDescription);
+      } else if (mContent->IsSVG()) {
+        for (nsIContent* childElm = mContent->GetFirstChild(); childElm;
+             childElm = childElm->GetNextSibling()) {
+          if (childElm->IsSVG(nsGkAtoms::desc)) {
+            nsTextEquivUtils::AppendTextEquivFromContent(this, childElm,
+                                                         &aDescription);
+            break;
+          }
+        }
+      }
+
+      if (!aDescription.IsEmpty()) {
+        nsAutoString name;
+        ENameValueFlag nameFlag = Name(name);
+
+        // Don't use tooltip for a description if it was used for a name.
+        if (nameFlag == eNameFromTooltip)
+          aDescription.Truncate();
+      }
+    }
+  }
+  aDescription.CompressWhitespace();
+}
+
+NS_IMETHODIMP
+Accessible::GetAccessKey(nsAString& aAccessKey)
+{
+  aAccessKey.Truncate();
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  AccessKey().ToString(aAccessKey);
+  return NS_OK;
+}
+
+KeyBinding
+Accessible::AccessKey() const
+{
+  if (!HasOwnContent())
+    return KeyBinding();
+
+  uint32_t key = nsCoreUtils::GetAccessKeyFor(mContent);
+  if (!key && mContent->IsElement()) {
+    Accessible* label = nullptr;
+
+    // Copy access key from label node.
+    if (mContent->IsHTML()) {
+      // Unless it is labeled via an ancestor <label>, in which case that would
+      // be redundant.
+      HTMLLabelIterator iter(Document(), this,
+                             HTMLLabelIterator::eSkipAncestorLabel);
+      label = iter.Next();
+
+    } else if (mContent->IsXUL()) {
+      XULLabelIterator iter(Document(), mContent);
+      label = iter.Next();
+    }
+
+    if (label)
+      key = nsCoreUtils::GetAccessKeyFor(label->GetContent());
+  }
+
+  if (!key)
+    return KeyBinding();
+
+  // Get modifier mask. Use ui.key.generalAccessKey (unless it is -1).
+  switch (Preferences::GetInt("ui.key.generalAccessKey", -1)) {
+  case -1:
+    break;
+  case nsIDOMKeyEvent::DOM_VK_SHIFT:
+    return KeyBinding(key, KeyBinding::kShift);
+  case nsIDOMKeyEvent::DOM_VK_CONTROL:
+    return KeyBinding(key, KeyBinding::kControl);
+  case nsIDOMKeyEvent::DOM_VK_ALT:
+    return KeyBinding(key, KeyBinding::kAlt);
+  case nsIDOMKeyEvent::DOM_VK_META:
+    return KeyBinding(key, KeyBinding::kMeta);
+  default:
+    return KeyBinding();
+  }
+
+  // Determine the access modifier used in this context.
+  nsIDocument* document = mContent->GetCurrentDoc();
+  if (!document)
+    return KeyBinding();
+
+  nsCOMPtr<nsIDocShellTreeItem> treeItem(document->GetDocShell());
+  if (!treeItem)
+    return KeyBinding();
+
+  nsresult rv = NS_ERROR_FAILURE;
+  int32_t modifierMask = 0;
+  switch (treeItem->ItemType()) {
+    case nsIDocShellTreeItem::typeChrome:
+      rv = Preferences::GetInt("ui.key.chromeAccess", &modifierMask);
+      break;
+    case nsIDocShellTreeItem::typeContent:
+      rv = Preferences::GetInt("ui.key.contentAccess", &modifierMask);
+      break;
+  }
+
+  return NS_SUCCEEDED(rv) ? KeyBinding(key, modifierMask) : KeyBinding();
+}
+
+KeyBinding
+Accessible::KeyboardShortcut() const
+{
+  return KeyBinding();
+}
+
+NS_IMETHODIMP
+Accessible::GetParent(nsIAccessible** aParent)
+{
+  NS_ENSURE_ARG_POINTER(aParent);
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  NS_IF_ADDREF(*aParent = Parent());
+  return *aParent ? NS_OK : NS_ERROR_FAILURE;
+}
+
+  /* readonly attribute nsIAccessible nextSibling; */
+NS_IMETHODIMP
+Accessible::GetNextSibling(nsIAccessible** aNextSibling)
+{
+  NS_ENSURE_ARG_POINTER(aNextSibling);
+  *aNextSibling = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  nsresult rv = NS_OK;
+  NS_IF_ADDREF(*aNextSibling = GetSiblingAtOffset(1, &rv));
+  return rv;
+}
+
+  /* readonly attribute nsIAccessible previousSibling; */
+NS_IMETHODIMP
+Accessible::GetPreviousSibling(nsIAccessible ** aPreviousSibling)
+{
+  NS_ENSURE_ARG_POINTER(aPreviousSibling);
+  *aPreviousSibling = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  nsresult rv = NS_OK;
+  NS_IF_ADDREF(*aPreviousSibling = GetSiblingAtOffset(-1, &rv));
+  return rv;
+}
+
+  /* readonly attribute nsIAccessible firstChild; */
+NS_IMETHODIMP
+Accessible::GetFirstChild(nsIAccessible** aFirstChild)
+{
+  NS_ENSURE_ARG_POINTER(aFirstChild);
+  *aFirstChild = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  NS_IF_ADDREF(*aFirstChild = FirstChild());
+  return NS_OK;
+}
+
+  /* readonly attribute nsIAccessible lastChild; */
+NS_IMETHODIMP
+Accessible::GetLastChild(nsIAccessible** aLastChild)
+{
+  NS_ENSURE_ARG_POINTER(aLastChild);
+  *aLastChild = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  NS_IF_ADDREF(*aLastChild = LastChild());
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::GetChildAt(int32_t aChildIndex, nsIAccessible** aChild)
+{
+  NS_ENSURE_ARG_POINTER(aChild);
+  *aChild = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  // If child index is negative, then return last child.
+  // XXX: do we really need this?
+  if (aChildIndex < 0)
+    aChildIndex = ChildCount() - 1;
+
+  Accessible* child = GetChildAt(aChildIndex);
+  if (!child)
+    return NS_ERROR_INVALID_ARG;
+
+  NS_ADDREF(*aChild = child);
+  return NS_OK;
+}
+
+// readonly attribute nsIArray children;
+NS_IMETHODIMP
+Accessible::GetChildren(nsIArray** aOutChildren)
+{
+  NS_ENSURE_ARG_POINTER(aOutChildren);
+  *aOutChildren = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMutableArray> children =
+    do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint32_t childCount = ChildCount();
+  for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
+    nsIAccessible* child = GetChildAt(childIdx);
+    children->AppendElement(child, false);
+  }
+
+  NS_ADDREF(*aOutChildren = children);
+  return NS_OK;
+}
+
+bool
+Accessible::CanHaveAnonChildren()
+{
+  return true;
+}
+
+/* readonly attribute long childCount; */
+NS_IMETHODIMP
+Accessible::GetChildCount(int32_t* aChildCount)
+{
+  NS_ENSURE_ARG_POINTER(aChildCount);
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  *aChildCount = ChildCount();
+  return NS_OK;
+}
+
+/* readonly attribute long indexInParent; */
+NS_IMETHODIMP
+Accessible::GetIndexInParent(int32_t* aIndexInParent)
+{
+  NS_ENSURE_ARG_POINTER(aIndexInParent);
+
+  *aIndexInParent = IndexInParent();
+  return *aIndexInParent != -1 ? NS_OK : NS_ERROR_FAILURE;
+}
+
+void 
+Accessible::TranslateString(const nsString& aKey, nsAString& aStringOut)
+{
+  nsCOMPtr<nsIStringBundleService> stringBundleService =
+    services::GetStringBundleService();
+  if (!stringBundleService)
+    return;
+
+  nsCOMPtr<nsIStringBundle> stringBundle;
+  stringBundleService->CreateBundle(
+    "chrome://global-platform/locale/accessible.properties", 
+    getter_AddRefs(stringBundle));
+  if (!stringBundle)
+    return;
+
+  nsXPIDLString xsValue;
+  nsresult rv = stringBundle->GetStringFromName(aKey.get(), getter_Copies(xsValue));
+  if (NS_SUCCEEDED(rv))
+    aStringOut.Assign(xsValue);
+}
+
+uint64_t
+Accessible::VisibilityState()
+{
+  nsIFrame* frame = GetFrame();
+  if (!frame)
+    return states::INVISIBLE;
+
+  // Walk the parent frame chain to see if there's invisible parent or the frame
+  // is in background tab.
+  if (!frame->StyleVisibility()->IsVisible())
+    return states::INVISIBLE;
+
+  nsIFrame* curFrame = frame;
+  do {
+    nsView* view = curFrame->GetView();
+    if (view && view->GetVisibility() == nsViewVisibility_kHide)
+      return states::INVISIBLE;
+
+    if (nsLayoutUtils::IsPopup(curFrame))
+      return 0;
+
+    // Offscreen state for background tab content and invisible for not selected
+    // deck panel.
+    nsIFrame* parentFrame = curFrame->GetParent();
+    nsDeckFrame* deckFrame = do_QueryFrame(parentFrame);
+    if (deckFrame && deckFrame->GetSelectedBox() != curFrame) {
+      if (deckFrame->GetContent()->IsXUL() &&
+          deckFrame->GetContent()->Tag() == nsGkAtoms::tabpanels)
+        return states::OFFSCREEN;
+
+      NS_NOTREACHED("Children of not selected deck panel are not accessible.");
+      return states::INVISIBLE;
+    }
+
+    // If contained by scrollable frame then check that at least 12 pixels
+    // around the object is visible, otherwise the object is offscreen.
+    nsIScrollableFrame* scrollableFrame = do_QueryFrame(parentFrame);
+    if (scrollableFrame) {
+      nsRect scrollPortRect = scrollableFrame->GetScrollPortRect();
+      nsRect frameRect = nsLayoutUtils::TransformFrameRectToAncestor(
+        frame, frame->GetRectRelativeToSelf(), parentFrame);
+      if (!scrollPortRect.Contains(frameRect)) {
+        const nscoord kMinPixels = nsPresContext::CSSPixelsToAppUnits(12);
+        scrollPortRect.Deflate(kMinPixels, kMinPixels);
+        if (!scrollPortRect.Intersects(frameRect))
+          return states::OFFSCREEN;
+      }
+    }
+
+    if (!parentFrame) {
+      parentFrame = nsLayoutUtils::GetCrossDocParentFrame(curFrame);
+      if (parentFrame && !parentFrame->StyleVisibility()->IsVisible())
+        return states::INVISIBLE;
+    }
+
+    curFrame = parentFrame;
+  } while (curFrame);
+
+  // Zero area rects can occur in the first frame of a multi-frame text flow,
+  // in which case the rendered text is not empty and the frame should not be
+  // marked invisible.
+  // XXX Can we just remove this check? Why do we need to mark empty
+  // text invisible?
+  if (frame->GetType() == nsGkAtoms::textFrame &&
+      !(frame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) &&
+      frame->GetRect().IsEmpty()) {
+    nsAutoString renderedText;
+    frame->GetRenderedText(&renderedText, nullptr, nullptr, 0, 1);
+    if (renderedText.IsEmpty())
+      return states::INVISIBLE;
+  }
+
+  return 0;
+}
+
+uint64_t
+Accessible::NativeState()
+{
+  uint64_t state = 0;
+
+  if (!IsInDocument())
+    state |= states::STALE;
+
+  if (HasOwnContent() && mContent->IsElement()) {
+    EventStates elementState = mContent->AsElement()->State();
+
+    if (elementState.HasState(NS_EVENT_STATE_INVALID))
+      state |= states::INVALID;
+
+    if (elementState.HasState(NS_EVENT_STATE_REQUIRED))
+      state |= states::REQUIRED;
+
+    state |= NativeInteractiveState();
+    if (FocusMgr()->IsFocused(this))
+      state |= states::FOCUSED;
+  }
+
+  // Gather states::INVISIBLE and states::OFFSCREEN flags for this object.
+  state |= VisibilityState();
+
+  nsIFrame *frame = GetFrame();
+  if (frame) {
+    if (frame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)
+      state |= states::FLOATING;
+
+    // XXX we should look at layout for non XUL box frames, but need to decide
+    // how that interacts with ARIA.
+    if (HasOwnContent() && mContent->IsXUL() && frame->IsBoxFrame()) {
+      const nsStyleXUL* xulStyle = frame->StyleXUL();
+      if (xulStyle && frame->IsBoxFrame()) {
+        // In XUL all boxes are either vertical or horizontal
+        if (xulStyle->mBoxOrient == NS_STYLE_BOX_ORIENT_VERTICAL)
+          state |= states::VERTICAL;
+        else
+          state |= states::HORIZONTAL;
+      }
+    }
+  }
+
+  // Check if a XUL element has the popup attribute (an attached popup menu).
+  if (HasOwnContent() && mContent->IsXUL() &&
+      mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::popup))
+    state |= states::HASPOPUP;
+
+  // Bypass the link states specialization for non links.
+  if (!mRoleMapEntry || mRoleMapEntry->roleRule == kUseNativeRole ||
+      mRoleMapEntry->role == roles::LINK)
+    state |= NativeLinkState();
+
+  return state;
+}
+
+uint64_t
+Accessible::NativeInteractiveState() const
+{
+  if (!mContent->IsElement())
+    return 0;
+
+  if (NativelyUnavailable())
+    return states::UNAVAILABLE;
+
+  nsIFrame* frame = GetFrame();
+  if (frame && frame->IsFocusable())
+    return states::FOCUSABLE;
+
+  return 0;
+}
+
+uint64_t
+Accessible::NativeLinkState() const
+{
+  return 0;
+}
+
+bool
+Accessible::NativelyUnavailable() const
+{
+  if (mContent->IsHTML())
+    return mContent->AsElement()->State().HasState(NS_EVENT_STATE_DISABLED);
+
+  return mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
+                               nsGkAtoms::_true, eCaseMatters);
+}
+
+  /* readonly attribute boolean focusedChild; */
+NS_IMETHODIMP
+Accessible::GetFocusedChild(nsIAccessible** aChild)
+{
+  NS_ENSURE_ARG_POINTER(aChild);
+  *aChild = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  NS_IF_ADDREF(*aChild = FocusedChild());
+  return NS_OK;
+}
+
+Accessible*
+Accessible::FocusedChild()
+{
+  Accessible* focus = FocusMgr()->FocusedAccessible();
+  if (focus && (focus == this || focus->Parent() == this))
+    return focus;
+
+  return nullptr;
+}
+
+Accessible*
+Accessible::ChildAtPoint(int32_t aX, int32_t aY,
+                         EWhichChildAtPoint aWhichChild)
+{
+  // If we can't find the point in a child, we will return the fallback answer:
+  // we return |this| if the point is within it, otherwise nullptr.
+  int32_t x = 0, y = 0, width = 0, height = 0;
+  nsresult rv = GetBounds(&x, &y, &width, &height);
+  NS_ENSURE_SUCCESS(rv, nullptr);
+
+  Accessible* fallbackAnswer = nullptr;
+  if (aX >= x && aX < x + width && aY >= y && aY < y + height)
+    fallbackAnswer = this;
+
+  if (nsAccUtils::MustPrune(this))  // Do not dig any further
+    return fallbackAnswer;
+
+  // Search an accessible at the given point starting from accessible document
+  // because containing block (see CSS2) for out of flow element (for example,
+  // absolutely positioned element) may be different from its DOM parent and
+  // therefore accessible for containing block may be different from accessible
+  // for DOM parent but GetFrameForPoint() should be called for containing block
+  // to get an out of flow element.
+  DocAccessible* accDocument = Document();
+  NS_ENSURE_TRUE(accDocument, nullptr);
+
+  nsIFrame* rootFrame = accDocument->GetFrame();
+  NS_ENSURE_TRUE(rootFrame, nullptr);
+
+  nsIFrame* startFrame = rootFrame;
+
+  // Check whether the point is at popup content.
+  nsIWidget* rootWidget = rootFrame->GetView()->GetNearestWidget(nullptr);
+  NS_ENSURE_TRUE(rootWidget, nullptr);
+
+  nsIntRect rootRect;
+  rootWidget->GetScreenBounds(rootRect);
+
+  WidgetMouseEvent dummyEvent(true, NS_MOUSE_MOVE, rootWidget,
+                              WidgetMouseEvent::eSynthesized);
+  dummyEvent.refPoint = LayoutDeviceIntPoint(aX - rootRect.x, aY - rootRect.y);
+
+  nsIFrame* popupFrame = nsLayoutUtils::
+    GetPopupFrameForEventCoordinates(accDocument->PresContext()->GetRootPresContext(),
+                                     &dummyEvent);
+  if (popupFrame) {
+    // If 'this' accessible is not inside the popup then ignore the popup when
+    // searching an accessible at point.
+    DocAccessible* popupDoc =
+      GetAccService()->GetDocAccessible(popupFrame->GetContent()->OwnerDoc());
+    Accessible* popupAcc =
+      popupDoc->GetAccessibleOrContainer(popupFrame->GetContent());
+    Accessible* popupChild = this;
+    while (popupChild && !popupChild->IsDoc() && popupChild != popupAcc)
+      popupChild = popupChild->Parent();
+
+    if (popupChild == popupAcc)
+      startFrame = popupFrame;
+  }
+
+  nsPresContext* presContext = startFrame->PresContext();
+  nsRect screenRect = startFrame->GetScreenRectInAppUnits();
+    nsPoint offset(presContext->DevPixelsToAppUnits(aX) - screenRect.x,
+                   presContext->DevPixelsToAppUnits(aY) - screenRect.y);
+  nsIFrame* foundFrame = nsLayoutUtils::GetFrameForPoint(startFrame, offset);
+
+  nsIContent* content = nullptr;
+  if (!foundFrame || !(content = foundFrame->GetContent()))
+    return fallbackAnswer;
+
+  // Get accessible for the node with the point or the first accessible in
+  // the DOM parent chain.
+  DocAccessible* contentDocAcc = GetAccService()->
+    GetDocAccessible(content->OwnerDoc());
+
+  // contentDocAcc in some circumstances can be nullptr. See bug 729861
+  NS_ASSERTION(contentDocAcc, "could not get the document accessible");
+  if (!contentDocAcc)
+    return fallbackAnswer;
+
+  Accessible* accessible = contentDocAcc->GetAccessibleOrContainer(content);
+  if (!accessible)
+    return fallbackAnswer;
+
+  // Hurray! We have an accessible for the frame that layout gave us.
+  // Since DOM node of obtained accessible may be out of flow then we should
+  // ensure obtained accessible is a child of this accessible.
+  Accessible* child = accessible;
+  while (child != this) {
+    Accessible* parent = child->Parent();
+    if (!parent) {
+      // Reached the top of the hierarchy. These bounds were inside an
+      // accessible that is not a descendant of this one.
+      return fallbackAnswer;
+    }
+
+    // If we landed on a legitimate child of |this|, and we want the direct
+    // child, return it here.
+    if (parent == this && aWhichChild == eDirectChild)
+        return child;
+
+    child = parent;
+  }
+
+  // Manually walk through accessible children and see if the are within this
+  // point. Skip offscreen or invisible accessibles. This takes care of cases
+  // where layout won't walk into things for us, such as image map areas and
+  // sub documents (XXX: subdocuments should be handled by methods of
+  // OuterDocAccessibles).
+  uint32_t childCount = accessible->ChildCount();
+  for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
+    Accessible* child = accessible->GetChildAt(childIdx);
+
+    int32_t childX, childY, childWidth, childHeight;
+    child->GetBounds(&childX, &childY, &childWidth, &childHeight);
+    if (aX >= childX && aX < childX + childWidth &&
+        aY >= childY && aY < childY + childHeight &&
+        (child->State() & states::INVISIBLE) == 0) {
+
+      if (aWhichChild == eDeepestChild)
+        return child->ChildAtPoint(aX, aY, eDeepestChild);
+
+      return child;
+    }
+  }
+
+  return accessible;
+}
+
+// nsIAccessible getChildAtPoint(in long x, in long y)
+NS_IMETHODIMP
+Accessible::GetChildAtPoint(int32_t aX, int32_t aY,
+                            nsIAccessible** aAccessible)
+{
+  NS_ENSURE_ARG_POINTER(aAccessible);
+  *aAccessible = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  NS_IF_ADDREF(*aAccessible = ChildAtPoint(aX, aY, eDirectChild));
+  return NS_OK;
+}
+
+// nsIAccessible getDeepestChildAtPoint(in long x, in long y)
+NS_IMETHODIMP
+Accessible::GetDeepestChildAtPoint(int32_t aX, int32_t aY,
+                                   nsIAccessible** aAccessible)
+{
+  NS_ENSURE_ARG_POINTER(aAccessible);
+  *aAccessible = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  NS_IF_ADDREF(*aAccessible = ChildAtPoint(aX, aY, eDeepestChild));
+  return NS_OK;
+}
+
+void
+Accessible::GetBoundsRect(nsRect& aTotalBounds, nsIFrame** aBoundingFrame)
+{
+  nsIFrame* frame = GetFrame();
+  if (frame && mContent) {
+    nsRect* hitRegionRect = static_cast<nsRect*>(mContent->GetProperty(nsGkAtoms::hitregion));
+
+    if (hitRegionRect) {
+      // This is for canvas fallback content
+      // Find a canvas frame the found hit region is relative to.
+      nsIFrame* canvasFrame = frame->GetParent();
+      while (canvasFrame && (canvasFrame->GetType() != nsGkAtoms::HTMLCanvasFrame))
+        canvasFrame = canvasFrame->GetParent();
+
+      // make the canvas the bounding frame
+      if (canvasFrame) {
+        *aBoundingFrame = canvasFrame;
+
+        aTotalBounds = *hitRegionRect;
+
+        return;
+      }
+    }
+
+    *aBoundingFrame = nsLayoutUtils::GetContainingBlockForClientRect(frame);
+    aTotalBounds = nsLayoutUtils::
+      GetAllInFlowRectsUnion(frame, *aBoundingFrame,
+                             nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS);
+  }
+}
+
+/* void getBounds (out long x, out long y, out long width, out long height); */
+NS_IMETHODIMP
+Accessible::GetBounds(int32_t* aX, int32_t* aY,
+                      int32_t* aWidth, int32_t* aHeight)
+{
+  NS_ENSURE_ARG_POINTER(aX);
+  *aX = 0;
+  NS_ENSURE_ARG_POINTER(aY);
+  *aY = 0;
+  NS_ENSURE_ARG_POINTER(aWidth);
+  *aWidth = 0;
+  NS_ENSURE_ARG_POINTER(aHeight);
+  *aHeight = 0;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  // This routine will get the entire rectangle for all the frames in this node.
+  // -------------------------------------------------------------------------
+  //      Primary Frame for node
+  //  Another frame, same node                <- Example
+  //  Another frame, same node
+
+  nsRect unionRectTwips;
+  nsIFrame* boundingFrame = nullptr;
+  GetBoundsRect(unionRectTwips, &boundingFrame);   // Unions up all primary frames for this node and all siblings after it
+  NS_ENSURE_STATE(boundingFrame);
+
+  nsPresContext* presContext = mDoc->PresContext();
+  *aX = presContext->AppUnitsToDevPixels(unionRectTwips.x);
+  *aY = presContext->AppUnitsToDevPixels(unionRectTwips.y);
+  *aWidth = presContext->AppUnitsToDevPixels(unionRectTwips.width);
+  *aHeight = presContext->AppUnitsToDevPixels(unionRectTwips.height);
+
+  // We have the union of the rectangle, now we need to put it in absolute screen coords
+  nsIntRect orgRectPixels = boundingFrame->GetScreenRectInAppUnits().
+    ToNearestPixels(presContext->AppUnitsPerDevPixel());
+  *aX += orgRectPixels.x;
+  *aY += orgRectPixels.y;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::SetSelected(bool aSelect)
+{
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  if (!HasOwnContent())
+    return NS_OK;
+
+  Accessible* select = nsAccUtils::GetSelectableContainer(this, State());
+  if (select) {
+    if (select->State() & states::MULTISELECTABLE) {
+      if (mRoleMapEntry) {
+        if (aSelect) {
+          return mContent->SetAttr(kNameSpaceID_None,
+                                   nsGkAtoms::aria_selected,
+                                   NS_LITERAL_STRING("true"), true);
+        }
+        return mContent->UnsetAttr(kNameSpaceID_None,
+                                   nsGkAtoms::aria_selected, true);
+      }
+
+      return NS_OK;
+    }
+
+    return aSelect ? TakeFocus() : NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::TakeSelection()
+{
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  Accessible* select = nsAccUtils::GetSelectableContainer(this, State());
+  if (select) {
+    if (select->State() & states::MULTISELECTABLE)
+      select->UnselectAll();
+    return SetSelected(true);
+  }
+
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+Accessible::TakeFocus()
+{
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  nsIFrame *frame = GetFrame();
+  NS_ENSURE_STATE(frame);
+
+  nsIContent* focusContent = mContent;
+
+  // If the accessible focus is managed by container widget then focus the
+  // widget and set the accessible as its current item.
+  if (!frame->IsFocusable()) {
+    Accessible* widget = ContainerWidget();
+    if (widget && widget->AreItemsOperable()) {
+      nsIContent* widgetElm = widget->GetContent();
+      nsIFrame* widgetFrame = widgetElm->GetPrimaryFrame();
+      if (widgetFrame && widgetFrame->IsFocusable()) {
+        focusContent = widgetElm;
+        widget->SetCurrentItem(this);
+      }
+    }
+  }
+
+  nsCOMPtr<nsIDOMElement> element(do_QueryInterface(focusContent));
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm)
+    fm->SetFocus(element, 0);
+
+  return NS_OK;
+}
+
+void
+Accessible::XULElmName(DocAccessible* aDocument,
+                       nsIContent* aElm, nsString& aName)
+{
+  /**
+   * 3 main cases for XUL Controls to be labeled
+   *   1 - control contains label="foo"
+   *   2 - control has, as a child, a label element
+   *        - label has either value="foo" or children
+   *   3 - non-child label contains control="controlID"
+   *        - label has either value="foo" or children
+   * Once a label is found, the search is discontinued, so a control
+   *  that has a label child as well as having a label external to
+   *  the control that uses the control="controlID" syntax will use
+   *  the child label for its Name.
+   */
+
+  // CASE #1 (via label attribute) -- great majority of the cases
+  nsCOMPtr<nsIDOMXULLabeledControlElement> labeledEl = do_QueryInterface(aElm);
+  if (labeledEl) {
+    labeledEl->GetLabel(aName);
+  } else {
+    nsCOMPtr<nsIDOMXULSelectControlItemElement> itemEl = do_QueryInterface(aElm);
+    if (itemEl) {
+      itemEl->GetLabel(aName);
+    } else {
+      nsCOMPtr<nsIDOMXULSelectControlElement> select = do_QueryInterface(aElm);
+      // Use label if this is not a select control element which 
+      // uses label attribute to indicate which option is selected
+      if (!select) {
+        nsCOMPtr<nsIDOMXULElement> xulEl(do_QueryInterface(aElm));
+        if (xulEl)
+          xulEl->GetAttribute(NS_LITERAL_STRING("label"), aName);
+      }
+    }
+  }
+
+  // CASES #2 and #3 ------ label as a child or <label control="id" ... > </label>
+  if (aName.IsEmpty()) {
+    Accessible* labelAcc = nullptr;
+    XULLabelIterator iter(aDocument, aElm);
+    while ((labelAcc = iter.Next())) {
+      nsCOMPtr<nsIDOMXULLabelElement> xulLabel =
+        do_QueryInterface(labelAcc->GetContent());
+      // Check if label's value attribute is used
+      if (xulLabel && NS_SUCCEEDED(xulLabel->GetValue(aName)) && aName.IsEmpty()) {
+        // If no value attribute, a non-empty label must contain
+        // children that define its text -- possibly using HTML
+        nsTextEquivUtils::
+          AppendTextEquivFromContent(labelAcc, labelAcc->GetContent(), &aName);
+      }
+    }
+  }
+
+  aName.CompressWhitespace();
+  if (!aName.IsEmpty())
+    return;
+
+  // Can get text from title of <toolbaritem> if we're a child of a <toolbaritem>
+  nsIContent *bindingParent = aElm->GetBindingParent();
+  nsIContent* parent =
+    bindingParent? bindingParent->GetParent() : aElm->GetParent();
+  while (parent) {
+    if (parent->Tag() == nsGkAtoms::toolbaritem &&
+        parent->GetAttr(kNameSpaceID_None, nsGkAtoms::title, aName)) {
+      aName.CompressWhitespace();
+      return;
+    }
+    parent = parent->GetParent();
+  }
+}
+
+nsresult
+Accessible::HandleAccEvent(AccEvent* aEvent)
+{
+  NS_ENSURE_ARG_POINTER(aEvent);
+
+  nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();
+  NS_ENSURE_TRUE(obsService, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsISimpleEnumerator> observers;
+  obsService->EnumerateObservers(NS_ACCESSIBLE_EVENT_TOPIC,
+                                 getter_AddRefs(observers));
+
+  NS_ENSURE_STATE(observers);
+
+  bool hasObservers = false;
+  observers->HasMoreElements(&hasObservers);
+  if (hasObservers) {
+    nsCOMPtr<nsIAccessibleEvent> event = MakeXPCEvent(aEvent);
+    return obsService->NotifyObservers(event, NS_ACCESSIBLE_EVENT_TOPIC, nullptr);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::GetRole(uint32_t *aRole)
+{
+  NS_ENSURE_ARG_POINTER(aRole);
+  *aRole = nsIAccessibleRole::ROLE_NOTHING;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  *aRole = Role();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::GetAttributes(nsIPersistentProperties** aAttributes)
+{
+  NS_ENSURE_ARG_POINTER(aAttributes);
+  *aAttributes = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIPersistentProperties> attributes = Attributes();
+  attributes.swap(*aAttributes);
+
+  return NS_OK;
+}
+
+already_AddRefed<nsIPersistentProperties>
+Accessible::Attributes()
+{
+  nsCOMPtr<nsIPersistentProperties> attributes = NativeAttributes();
+  if (!HasOwnContent() || !mContent->IsElement())
+    return attributes.forget();
+
+  // 'xml-roles' attribute coming from ARIA.
+  nsAutoString xmlRoles, unused;
+  if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::role, xmlRoles)) {
+    attributes->SetStringProperty(NS_LITERAL_CSTRING("xml-roles"),
+                                  xmlRoles, unused);
+  }
+
+  // Expose object attributes from ARIA attributes.
+  aria::AttrIterator attribIter(mContent);
+  nsAutoString name, value;
+  while(attribIter.Next(name, value))
+    attributes->SetStringProperty(NS_ConvertUTF16toUTF8(name), value, unused);
+
+  // If there is no aria-live attribute then expose default value of 'live'
+  // object attribute used for ARIA role of this accessible.
+  if (mRoleMapEntry) {
+    nsAutoString live;
+    nsAccUtils::GetAccAttr(attributes, nsGkAtoms::live, live);
+    if (live.IsEmpty()) {
+      if (nsAccUtils::GetLiveAttrValue(mRoleMapEntry->liveAttRule, live))
+        nsAccUtils::SetAccAttr(attributes, nsGkAtoms::live, live);
+    }
+  }
+
+  return attributes.forget();
+}
+
+already_AddRefed<nsIPersistentProperties>
+Accessible::NativeAttributes()
+{
+  nsCOMPtr<nsIPersistentProperties> attributes =
+    do_CreateInstance(NS_PERSISTENTPROPERTIES_CONTRACTID);
+
+  nsAutoString unused;
+
+  // We support values, so expose the string value as well, via the valuetext
+  // object attribute. We test for the value interface because we don't want
+  // to expose traditional Value() information such as URL's on links and
+  // documents, or text in an input.
+  if (HasNumericValue()) {
+    nsAutoString valuetext;
+    GetValue(valuetext);
+    attributes->SetStringProperty(NS_LITERAL_CSTRING("valuetext"), valuetext,
+                                  unused);
+  }
+
+  // Expose checkable object attribute if the accessible has checkable state
+  if (State() & states::CHECKABLE) {
+    nsAccUtils::SetAccAttr(attributes, nsGkAtoms::checkable,
+                           NS_LITERAL_STRING("true"));
+  }
+
+  // Expose 'explicit-name' attribute.
+  nsAutoString name;
+  if (Name(name) != eNameFromSubtree && !name.IsVoid()) {
+    attributes->SetStringProperty(NS_LITERAL_CSTRING("explicit-name"),
+                                  NS_LITERAL_STRING("true"), unused);
+  }
+
+  // Group attributes (level/setsize/posinset)
+  GroupPos groupPos = GroupPosition();
+  nsAccUtils::SetAccGroupAttrs(attributes, groupPos.level,
+                               groupPos.setSize, groupPos.posInSet);
+
+  // If the accessible doesn't have own content (such as list item bullet or
+  // xul tree item) then don't calculate content based attributes.
+  if (!HasOwnContent())
+    return attributes.forget();
+
+  nsEventShell::GetEventAttributes(GetNode(), attributes);
+
+  // Get container-foo computed live region properties based on the closest
+  // container with the live region attribute. Inner nodes override outer nodes
+  // within the same document. The inner nodes can be used to override live
+  // region behavior on more general outer nodes. However, nodes in outer
+  // documents override nodes in inner documents: outer doc author may want to
+  // override properties on a widget they used in an iframe.
+  nsIContent* startContent = mContent;
+  while (startContent) {
+    nsIDocument* doc = startContent->GetDocument();
+    if (!doc)
+      break;
+
+    nsAccUtils::SetLiveContainerAttributes(attributes, startContent,
+                                           nsCoreUtils::GetRoleContent(doc));
+
+    // Allow ARIA live region markup from outer documents to override
+    nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem = doc->GetDocShell();
+    if (!docShellTreeItem)
+      break;
+
+    nsCOMPtr<nsIDocShellTreeItem> sameTypeParent;
+    docShellTreeItem->GetSameTypeParent(getter_AddRefs(sameTypeParent));
+    if (!sameTypeParent || sameTypeParent == docShellTreeItem)
+      break;
+
+    nsIDocument* parentDoc = doc->GetParentDocument();
+    if (!parentDoc)
+      break;
+
+    startContent = parentDoc->FindContentForSubDocument(doc);
+  }
+
+  if (!mContent->IsElement())
+    return attributes.forget();
+
+  nsAutoString id;
+  if (nsCoreUtils::GetID(mContent, id))
+    attributes->SetStringProperty(NS_LITERAL_CSTRING("id"), id, unused);
+
+  // Expose class because it may have useful microformat information.
+  nsAutoString _class;
+  if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::_class, _class))
+    nsAccUtils::SetAccAttr(attributes, nsGkAtoms::_class, _class);
+
+  // Expose tag.
+  nsAutoString tagName;
+  mContent->NodeInfo()->GetName(tagName);
+  nsAccUtils::SetAccAttr(attributes, nsGkAtoms::tag, tagName);
+
+  // Expose draggable object attribute.
+  nsCOMPtr<nsIDOMHTMLElement> htmlElement = do_QueryInterface(mContent);
+  if (htmlElement) {
+    bool draggable = false;
+    htmlElement->GetDraggable(&draggable);
+    if (draggable) {
+      nsAccUtils::SetAccAttr(attributes, nsGkAtoms::draggable,
+                             NS_LITERAL_STRING("true"));
+    }
+  }
+
+  // Don't calculate CSS-based object attributes when no frame (i.e.
+  // the accessible is unattached from the tree).
+  if (!mContent->GetPrimaryFrame())
+    return attributes.forget();
+
+  // CSS style based object attributes.
+  nsAutoString value;
+  StyleInfo styleInfo(mContent->AsElement(), mDoc->PresShell());
+
+  // Expose 'display' attribute.
+  styleInfo.Display(value);
+  nsAccUtils::SetAccAttr(attributes, nsGkAtoms::display, value);
+
+  // Expose 'text-align' attribute.
+  styleInfo.TextAlign(value);
+  nsAccUtils::SetAccAttr(attributes, nsGkAtoms::textAlign, value);
+
+  // Expose 'text-indent' attribute.
+  styleInfo.TextIndent(value);
+  nsAccUtils::SetAccAttr(attributes, nsGkAtoms::textIndent, value);
+
+  // Expose 'margin-left' attribute.
+  styleInfo.MarginLeft(value);
+  nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginLeft, value);
+
+  // Expose 'margin-right' attribute.
+  styleInfo.MarginRight(value);
+  nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginRight, value);
+
+  // Expose 'margin-top' attribute.
+  styleInfo.MarginTop(value);
+  nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginTop, value);
+
+  // Expose 'margin-bottom' attribute.
+  styleInfo.MarginBottom(value);
+  nsAccUtils::SetAccAttr(attributes, nsGkAtoms::marginBottom, value);
+
+  return attributes.forget();
+}
+
+GroupPos
+Accessible::GroupPosition()
+{
+  GroupPos groupPos;
+  if (!HasOwnContent())
+    return groupPos;
+
+  // Get group position from ARIA attributes.
+  nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_level, &groupPos.level);
+  nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_setsize, &groupPos.setSize);
+  nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_posinset, &groupPos.posInSet);
+
+  // If ARIA is missed and the accessible is visible then calculate group
+  // position from hierarchy.
+  if (State() & states::INVISIBLE)
+    return groupPos;
+
+  // Calculate group level if ARIA is missed.
+  if (groupPos.level == 0) {
+    int32_t level = GetLevelInternal();
+    if (level != 0)
+      groupPos.level = level;
+  }
+
+  // Calculate position in group and group size if ARIA is missed.
+  if (groupPos.posInSet == 0 || groupPos.setSize == 0) {
+    int32_t posInSet = 0, setSize = 0;
+    GetPositionAndSizeInternal(&posInSet, &setSize);
+    if (posInSet != 0 && setSize != 0) {
+      if (groupPos.posInSet == 0)
+        groupPos.posInSet = posInSet;
+
+      if (groupPos.setSize == 0)
+        groupPos.setSize = setSize;
+    }
+  }
+
+  return groupPos;
+}
+
+NS_IMETHODIMP
+Accessible::ScriptableGroupPosition(int32_t* aGroupLevel,
+                                    int32_t* aSimilarItemsInGroup,
+                                    int32_t* aPositionInGroup)
+{
+  NS_ENSURE_ARG_POINTER(aGroupLevel);
+  *aGroupLevel = 0;
+
+  NS_ENSURE_ARG_POINTER(aSimilarItemsInGroup);
+  *aSimilarItemsInGroup = 0;
+
+  NS_ENSURE_ARG_POINTER(aPositionInGroup);
+  *aPositionInGroup = 0;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  GroupPos groupPos = GroupPosition();
+
+  *aGroupLevel = groupPos.level;
+  *aSimilarItemsInGroup = groupPos.setSize;
+  *aPositionInGroup = groupPos.posInSet;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::GetState(uint32_t* aState, uint32_t* aExtraState)
+{
+  NS_ENSURE_ARG_POINTER(aState);
+
+  nsAccUtils::To32States(State(), aState, aExtraState);
+  return NS_OK;
+}
+
+uint64_t
+Accessible::State()
+{
+  if (IsDefunct())
+    return states::DEFUNCT;
+
+  uint64_t state = NativeState();
+  // Apply ARIA states to be sure accessible states will be overridden.
+  ApplyARIAState(&state);
+
+  // If this is an ARIA item of the selectable widget and if it's focused and
+  // not marked unselected explicitly (i.e. aria-selected="false") then expose
+  // it as selected to make ARIA widget authors life easier.
+  if (mRoleMapEntry && !(state & states::SELECTED) &&
+      !mContent->AttrValueIs(kNameSpaceID_None,
+                             nsGkAtoms::aria_selected,
+                             nsGkAtoms::_false, eCaseMatters)) {
+    // Special case for tabs: focused tab or focus inside related tab panel
+    // implies selected state.
+    if (mRoleMapEntry->role == roles::PAGETAB) {
+      if (state & states::FOCUSED) {
+        state |= states::SELECTED;
+      } else {
+        // If focus is in a child of the tab panel surely the tab is selected!
+        Relation rel = RelationByType(RelationType::LABEL_FOR);
+        Accessible* relTarget = nullptr;
+        while ((relTarget = rel.Next())) {
+          if (relTarget->Role() == roles::PROPERTYPAGE &&
+              FocusMgr()->IsFocusWithin(relTarget))
+            state |= states::SELECTED;
+        }
+      }
+    } else if (state & states::FOCUSED) {
+      Accessible* container = nsAccUtils::GetSelectableContainer(this, state);
+      if (container &&
+          !nsAccUtils::HasDefinedARIAToken(container->GetContent(),
+                                           nsGkAtoms::aria_multiselectable)) {
+        state |= states::SELECTED;
+      }
+    }
+  }
+
+  const uint32_t kExpandCollapseStates = states::COLLAPSED | states::EXPANDED;
+  if ((state & kExpandCollapseStates) == kExpandCollapseStates) {
+    // Cannot be both expanded and collapsed -- this happens in ARIA expanded
+    // combobox because of limitation of ARIAMap.
+    // XXX: Perhaps we will be able to make this less hacky if we support
+    // extended states in ARIAMap, e.g. derive COLLAPSED from
+    // EXPANDABLE && !EXPANDED.
+    state &= ~states::COLLAPSED;
+  }
+
+  if (!(state & states::UNAVAILABLE)) {
+    state |= states::ENABLED | states::SENSITIVE;
+
+    // If the object is a current item of container widget then mark it as
+    // ACTIVE. This allows screen reader virtual buffer modes to know which
+    // descendant is the current one that would get focus if the user navigates
+    // to the container widget.
+    Accessible* widget = ContainerWidget();
+    if (widget && widget->CurrentItem() == this)
+      state |= states::ACTIVE;
+  }
+
+  if ((state & states::COLLAPSED) || (state & states::EXPANDED))
+    state |= states::EXPANDABLE;
+
+  // For some reasons DOM node may have not a frame. We tract such accessibles
+  // as invisible.
+  nsIFrame *frame = GetFrame();
+  if (!frame)
+    return state;
+
+  const nsStyleDisplay* display = frame->StyleDisplay();
+  if (display && display->mOpacity == 1.0f &&
+      !(state & states::INVISIBLE)) {
+    state |= states::OPAQUE1;
+  }
+
+  return state;
+}
+
+void
+Accessible::ApplyARIAState(uint64_t* aState) const
+{
+  if (!mContent->IsElement())
+    return;
+
+  dom::Element* element = mContent->AsElement();
+
+  // Test for universal states first
+  *aState |= aria::UniversalStatesFor(element);
+
+  if (mRoleMapEntry) {
+
+    // We only force the readonly bit off if we have a real mapping for the aria
+    // role. This preserves the ability for screen readers to use readonly
+    // (primarily on the document) as the hint for creating a virtual buffer.
+    if (mRoleMapEntry->role != roles::NOTHING)
+      *aState &= ~states::READONLY;
+
+    if (mContent->HasAttr(kNameSpaceID_None, mContent->GetIDAttributeName())) {
+      // If has a role & ID and aria-activedescendant on the container, assume focusable
+      nsIContent *ancestorContent = mContent;
+      while ((ancestorContent = ancestorContent->GetParent()) != nullptr) {
+        if (ancestorContent->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_activedescendant)) {
+            // ancestor has activedescendant property, this content could be active
+          *aState |= states::FOCUSABLE;
+          break;
+        }
+      }
+    }
+  }
+
+  if (*aState & states::FOCUSABLE) {
+    // Special case: aria-disabled propagates from ancestors down to any focusable descendant
+    nsIContent *ancestorContent = mContent;
+    while ((ancestorContent = ancestorContent->GetParent()) != nullptr) {
+      if (ancestorContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::aria_disabled,
+                                       nsGkAtoms::_true, eCaseMatters)) {
+          // ancestor has aria-disabled property, this is disabled
+        *aState |= states::UNAVAILABLE;
+        break;
+      }
+    }    
+  }
+
+  // special case: A native button element whose role got transformed by ARIA to a toggle button
+  if (IsButton())
+    aria::MapToState(aria::eARIAPressed, element, aState);
+
+  if (!mRoleMapEntry)
+    return;
+
+  *aState |= mRoleMapEntry->state;
+
+  if (aria::MapToState(mRoleMapEntry->attributeMap1, element, aState) &&
+      aria::MapToState(mRoleMapEntry->attributeMap2, element, aState))
+    aria::MapToState(mRoleMapEntry->attributeMap3, element, aState);
+
+  // ARIA gridcell inherits editable/readonly states from the grid until it's
+  // overridden.
+  if ((mRoleMapEntry->Is(nsGkAtoms::gridcell) ||
+       mRoleMapEntry->Is(nsGkAtoms::columnheader) ||
+       mRoleMapEntry->Is(nsGkAtoms::rowheader)) &&
+      !(*aState & (states::READONLY | states::EDITABLE))) {
+    const TableCellAccessible* cell = AsTableCell();
+    if (cell) {
+      TableAccessible* table = cell->Table();
+      if (table) {
+        Accessible* grid = table->AsAccessible();
+        uint64_t gridState = 0;
+        grid->ApplyARIAState(&gridState);
+        *aState |= (gridState & (states::READONLY | states::EDITABLE));
+      }
+    }
+  }
+}
+
+NS_IMETHODIMP
+Accessible::GetValue(nsAString& aValue)
+{
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  nsAutoString value;
+  Value(value);
+  aValue.Assign(value);
+
+  return NS_OK;
+}
+
+void
+Accessible::Value(nsString& aValue)
+{
+  if (!mRoleMapEntry)
+    return;
+
+  if (mRoleMapEntry->valueRule != eNoValue) {
+    // aria-valuenow is a number, and aria-valuetext is the optional text
+    // equivalent. For the string value, we will try the optional text
+    // equivalent first.
+    if (!mContent->GetAttr(kNameSpaceID_None,
+                           nsGkAtoms::aria_valuetext, aValue)) {
+      mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_valuenow,
+                        aValue);
+    }
+    return;
+  }
+
+  // Value of textbox is a textified subtree.
+  if (mRoleMapEntry->Is(nsGkAtoms::textbox)) {
+    nsTextEquivUtils::GetTextEquivFromSubtree(this, aValue);
+    return;
+  }
+
+  // Value of combobox is a text of current or selected item.
+  if (mRoleMapEntry->Is(nsGkAtoms::combobox)) {
+    Accessible* option = CurrentItem();
+    if (!option) {
+      Accessible* listbox = nullptr;
+      IDRefsIterator iter(mDoc, mContent, nsGkAtoms::aria_owns);
+      while ((listbox = iter.Next()) && !listbox->IsListControl());
+
+      if (!listbox) {
+        uint32_t childCount = ChildCount();
+        for (uint32_t idx = 0; idx < childCount; idx++) {
+          Accessible* child = mChildren.ElementAt(idx);
+          if (child->IsListControl())
+            listbox = child;
+        }
+      }
+
+      if (listbox)
+        option = listbox->GetSelectedItem(0);
+    }
+
+    if (option)
+      nsTextEquivUtils::GetTextEquivFromSubtree(option, aValue);
+  }
+}
+
+double
+Accessible::MaxValue() const
+{
+  return AttrNumericValue(nsGkAtoms::aria_valuemax);
+}
+
+double
+Accessible::MinValue() const
+{
+  return AttrNumericValue(nsGkAtoms::aria_valuemin);
+}
+
+double
+Accessible::Step() const
+{
+  return UnspecifiedNaN<double>(); // no mimimum increment (step) in ARIA.
+}
+
+double
+Accessible::CurValue() const
+{
+  return AttrNumericValue(nsGkAtoms::aria_valuenow);
+}
+
+bool
+Accessible::SetCurValue(double aValue)
+{
+  if (!mRoleMapEntry || mRoleMapEntry->valueRule == eNoValue)
+    return false;
+
+  const uint32_t kValueCannotChange = states::READONLY | states::UNAVAILABLE;
+  if (State() & kValueCannotChange)
+    return false;
+
+  double checkValue = MinValue();
+  if (!IsNaN(checkValue) && aValue < checkValue)
+    return false;
+
+  checkValue = MaxValue();
+  if (!IsNaN(checkValue) && aValue > checkValue)
+    return false;
+
+  nsAutoString strValue;
+  strValue.AppendFloat(aValue);
+
+  return NS_SUCCEEDED(
+    mContent->SetAttr(kNameSpaceID_None, nsGkAtoms::aria_valuenow, strValue, true));
+}
+
+/* void setName (in DOMString name); */
+NS_IMETHODIMP
+Accessible::SetName(const nsAString& aName)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+Accessible::GetKeyboardShortcut(nsAString& aKeyBinding)
+{
+  aKeyBinding.Truncate();
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  KeyboardShortcut().ToString(aKeyBinding);
+  return NS_OK;
+}
+
+role
+Accessible::ARIATransformRole(role aRole)
+{
+  // XXX: these unfortunate exceptions don't fit into the ARIA table. This is
+  // where the accessible role depends on both the role and ARIA state.
+  if (aRole == roles::PUSHBUTTON) {
+    if (nsAccUtils::HasDefinedARIAToken(mContent, nsGkAtoms::aria_pressed)) {
+      // For simplicity, any existing pressed attribute except "" or "undefined"
+      // indicates a toggle.
+      return roles::TOGGLE_BUTTON;
+    }
+
+    if (mContent->AttrValueIs(kNameSpaceID_None,
+                              nsGkAtoms::aria_haspopup,
+                              nsGkAtoms::_true,
+                              eCaseMatters)) {
+      // For button with aria-haspopup="true".
+      return roles::BUTTONMENU;
+    }
+
+  } else if (aRole == roles::LISTBOX) {
+    // A listbox inside of a combobox needs a special role because of ATK
+    // mapping to menu.
+    if (mParent && mParent->Role() == roles::COMBOBOX) {
+      return roles::COMBOBOX_LIST;
+
+      Relation rel = RelationByType(RelationType::NODE_CHILD_OF);
+      Accessible* targetAcc = nullptr;
+      while ((targetAcc = rel.Next()))
+        if (targetAcc->Role() == roles::COMBOBOX)
+          return roles::COMBOBOX_LIST;
+    }
+
+  } else if (aRole == roles::OPTION) {
+    if (mParent && mParent->Role() == roles::COMBOBOX_LIST)
+      return roles::COMBOBOX_OPTION;
+
+  } else if (aRole == roles::MENUITEM) {
+    // Menuitem has a submenu.
+    if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::aria_haspopup,
+                              nsGkAtoms::_true, eCaseMatters)) {
+      return roles::PARENT_MENUITEM;
+    }
+  }
+
+  return aRole;
+}
+
+role
+Accessible::NativeRole()
+{
+  return roles::NOTHING;
+}
+
+// readonly attribute uint8_t actionCount
+NS_IMETHODIMP
+Accessible::GetActionCount(uint8_t* aActionCount)
+{
+  NS_ENSURE_ARG_POINTER(aActionCount);
+  *aActionCount = 0;
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  *aActionCount = ActionCount();
+  return NS_OK;
+}
+
+uint8_t
+Accessible::ActionCount()
+{
+  return GetActionRule() == eNoAction ? 0 : 1;
+}
+
+/* DOMString getAccActionName (in uint8_t index); */
+NS_IMETHODIMP
+Accessible::GetActionName(uint8_t aIndex, nsAString& aName)
+{
+  aName.Truncate();
+
+  if (aIndex != 0)
+    return NS_ERROR_INVALID_ARG;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  uint32_t actionRule = GetActionRule();
+
+ switch (actionRule) {
+   case eActivateAction:
+     aName.AssignLiteral("activate");
+     return NS_OK;
+
+   case eClickAction:
+     aName.AssignLiteral("click");
+     return NS_OK;
+
+   case ePressAction:
+     aName.AssignLiteral("press");
+     return NS_OK;
+
+   case eCheckUncheckAction:
+   {
+     uint64_t state = State();
+     if (state & states::CHECKED)
+       aName.AssignLiteral("uncheck");
+     else if (state & states::MIXED)
+       aName.AssignLiteral("cycle");
+     else
+       aName.AssignLiteral("check");
+     return NS_OK;
+   }
+
+   case eJumpAction:
+     aName.AssignLiteral("jump");
+     return NS_OK;
+
+   case eOpenCloseAction:
+     if (State() & states::COLLAPSED)
+       aName.AssignLiteral("open");
+     else
+       aName.AssignLiteral("close");
+     return NS_OK;
+
+   case eSelectAction:
+     aName.AssignLiteral("select");
+     return NS_OK;
+
+   case eSwitchAction:
+     aName.AssignLiteral("switch");
+     return NS_OK;
+
+   case eSortAction:
+     aName.AssignLiteral("sort");
+     return NS_OK;
+
+   case eExpandAction:
+     if (State() & states::COLLAPSED)
+       aName.AssignLiteral("expand");
+     else
+       aName.AssignLiteral("collapse");
+     return NS_OK;
+  }
+
+  return NS_ERROR_INVALID_ARG;
+}
+
+// AString getActionDescription(in uint8_t index)
+NS_IMETHODIMP
+Accessible::GetActionDescription(uint8_t aIndex, nsAString& aDescription)
+{
+  // default to localized action name.
+  nsAutoString name;
+  nsresult rv = GetActionName(aIndex, name);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  TranslateString(name, aDescription);
+  return NS_OK;
+}
+
+// void doAction(in uint8_t index)
+NS_IMETHODIMP
+Accessible::DoAction(uint8_t aIndex)
+{
+  if (aIndex != 0)
+    return NS_ERROR_INVALID_ARG;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  if (GetActionRule() != eNoAction) {
+    DoCommand();
+    return NS_OK;
+  }
+
+  return NS_ERROR_INVALID_ARG;
+}
+
+/* DOMString getHelp (); */
+NS_IMETHODIMP Accessible::GetHelp(nsAString& _retval)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+nsIContent*
+Accessible::GetAtomicRegion() const
+{
+  nsIContent *loopContent = mContent;
+  nsAutoString atomic;
+  while (loopContent && !loopContent->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_atomic, atomic))
+    loopContent = loopContent->GetParent();
+
+  return atomic.EqualsLiteral("true") ? loopContent : nullptr;
+}
+
+// nsIAccessible getRelationByType()
+NS_IMETHODIMP
+Accessible::GetRelationByType(uint32_t aType, nsIAccessibleRelation** aRelation)
+{
+  NS_ENSURE_ARG_POINTER(aRelation);
+  *aRelation = nullptr;
+
+  NS_ENSURE_ARG(aType <= static_cast<uint32_t>(RelationType::LAST));
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  Relation rel = RelationByType(static_cast<RelationType>(aType));
+  NS_ADDREF(*aRelation = new nsAccessibleRelation(aType, &rel));
+  return *aRelation ? NS_OK : NS_ERROR_FAILURE;
+}
+
+Relation
+Accessible::RelationByType(RelationType aType)
+{
+  if (!HasOwnContent())
+    return Relation();
+
+  // Relationships are defined on the same content node that the role would be
+  // defined on.
+  switch (aType) {
+    case RelationType::LABELLED_BY: {
+      Relation rel(new IDRefsIterator(mDoc, mContent,
+                                      nsGkAtoms::aria_labelledby));
+      if (mContent->IsHTML()) {
+        rel.AppendIter(new HTMLLabelIterator(Document(), this));
+      } else if (mContent->IsXUL()) {
+        rel.AppendIter(new XULLabelIterator(Document(), mContent));
+      }
+
+      return rel;
+    }
+
+    case RelationType::LABEL_FOR: {
+      Relation rel(new RelatedAccIterator(Document(), mContent,
+                                          nsGkAtoms::aria_labelledby));
+      if (mContent->Tag() == nsGkAtoms::label && mContent->IsXUL())
+        rel.AppendIter(new IDRefsIterator(mDoc, mContent, nsGkAtoms::control));
+
+      return rel;
+    }
+
+    case RelationType::DESCRIBED_BY: {
+      Relation rel(new IDRefsIterator(mDoc, mContent,
+                                      nsGkAtoms::aria_describedby));
+      if (mContent->IsXUL())
+        rel.AppendIter(new XULDescriptionIterator(Document(), mContent));
+
+      return rel;
+    }
+
+    case RelationType::DESCRIPTION_FOR: {
+      Relation rel(new RelatedAccIterator(Document(), mContent,
+                                          nsGkAtoms::aria_describedby));
+
+      // This affectively adds an optional control attribute to xul:description,
+      // which only affects accessibility, by allowing the description to be
+      // tied to a control.
+      if (mContent->Tag() == nsGkAtoms::description &&
+          mContent->IsXUL())
+        rel.AppendIter(new IDRefsIterator(mDoc, mContent,
+                                          nsGkAtoms::control));
+
+      return rel;
+    }
+
+    case RelationType::NODE_CHILD_OF: {
+      Relation rel(new RelatedAccIterator(Document(), mContent,
+                                          nsGkAtoms::aria_owns));
+
+      // This is an ARIA tree or treegrid that doesn't use owns, so we need to
+      // get the parent the hard way.
+      if (mRoleMapEntry && (mRoleMapEntry->role == roles::OUTLINEITEM ||
+                            mRoleMapEntry->role == roles::LISTITEM ||
+                            mRoleMapEntry->role == roles::ROW)) {
+        rel.AppendTarget(GetGroupInfo()->ConceptualParent());
+      }
+
+      // If accessible is in its own Window, or is the root of a document,
+      // then we should provide NODE_CHILD_OF relation so that MSAA clients
+      // can easily get to true parent instead of getting to oleacc's
+      // ROLE_WINDOW accessible which will prevent us from going up further
+      // (because it is system generated and has no idea about the hierarchy
+      // above it).
+      nsIFrame *frame = GetFrame();
+      if (frame) {
+        nsView *view = frame->GetViewExternal();
+        if (view) {
+          nsIScrollableFrame *scrollFrame = do_QueryFrame(frame);
+          if (scrollFrame || view->GetWidget() || !frame->GetParent())
+            rel.AppendTarget(Parent());
+        }
+      }
+
+      return rel;
+    }
+
+    case RelationType::NODE_PARENT_OF: {
+      Relation rel(new IDRefsIterator(mDoc, mContent, nsGkAtoms::aria_owns));
+
+      // ARIA tree or treegrid can do the hierarchy by @aria-level, ARIA trees
+      // also can be organized by groups.
+      if (mRoleMapEntry &&
+          (mRoleMapEntry->role == roles::OUTLINEITEM ||
+           mRoleMapEntry->role == roles::LISTITEM ||
+           mRoleMapEntry->role == roles::ROW ||
+           mRoleMapEntry->role == roles::OUTLINE ||
+           mRoleMapEntry->role == roles::LIST ||
+           mRoleMapEntry->role == roles::TREE_TABLE)) {
+        rel.AppendIter(new ItemIterator(this));
+      }
+
+      return rel;
+    }
+
+    case RelationType::CONTROLLED_BY:
+      return Relation(new RelatedAccIterator(Document(), mContent,
+                                             nsGkAtoms::aria_controls));
+
+    case RelationType::CONTROLLER_FOR: {
+      Relation rel(new IDRefsIterator(mDoc, mContent,
+                                      nsGkAtoms::aria_controls));
+      rel.AppendIter(new HTMLOutputIterator(Document(), mContent));
+      return rel;
+    }
+
+    case RelationType::FLOWS_TO:
+      return Relation(new IDRefsIterator(mDoc, mContent,
+                                         nsGkAtoms::aria_flowto));
+
+    case RelationType::FLOWS_FROM:
+      return Relation(new RelatedAccIterator(Document(), mContent,
+                                             nsGkAtoms::aria_flowto));
+
+    case RelationType::MEMBER_OF:
+          return Relation(mDoc, GetAtomicRegion());
+
+    case RelationType::SUBWINDOW_OF:
+    case RelationType::EMBEDS:
+    case RelationType::EMBEDDED_BY:
+    case RelationType::POPUP_FOR:
+    case RelationType::PARENT_WINDOW_OF:
+      return Relation();
+
+    case RelationType::DEFAULT_BUTTON: {
+      if (mContent->IsHTML()) {
+        // HTML form controls implements nsIFormControl interface.
+        nsCOMPtr<nsIFormControl> control(do_QueryInterface(mContent));
+        if (control) {
+          nsCOMPtr<nsIForm> form(do_QueryInterface(control->GetFormElement()));
+          if (form) {
+            nsCOMPtr<nsIContent> formContent =
+              do_QueryInterface(form->GetDefaultSubmitElement());
+            return Relation(mDoc, formContent);
+          }
+        }
+      } else {
+        // In XUL, use first <button default="true" .../> in the document
+        nsCOMPtr<nsIDOMXULDocument> xulDoc =
+          do_QueryInterface(mContent->OwnerDoc());
+        nsCOMPtr<nsIDOMXULButtonElement> buttonEl;
+        if (xulDoc) {
+          nsCOMPtr<nsIDOMNodeList> possibleDefaultButtons;
+          xulDoc->GetElementsByAttribute(NS_LITERAL_STRING("default"),
+                                         NS_LITERAL_STRING("true"),
+                                         getter_AddRefs(possibleDefaultButtons));
+          if (possibleDefaultButtons) {
+            uint32_t length;
+            possibleDefaultButtons->GetLength(&length);
+            nsCOMPtr<nsIDOMNode> possibleButton;
+            // Check for button in list of default="true" elements
+            for (uint32_t count = 0; count < length && !buttonEl; count ++) {
+              possibleDefaultButtons->Item(count, getter_AddRefs(possibleButton));
+              buttonEl = do_QueryInterface(possibleButton);
+            }
+          }
+          if (!buttonEl) { // Check for anonymous accept button in <dialog>
+            dom::Element* rootElm = mContent->OwnerDoc()->GetRootElement();
+            if (rootElm) {
+              nsIContent* possibleButtonEl = rootElm->OwnerDoc()->
+                GetAnonymousElementByAttribute(rootElm, nsGkAtoms::_default,
+                                               NS_LITERAL_STRING("true"));
+              buttonEl = do_QueryInterface(possibleButtonEl);
+            }
+          }
+          nsCOMPtr<nsIContent> relatedContent(do_QueryInterface(buttonEl));
+          return Relation(mDoc, relatedContent);
+        }
+      }
+      return Relation();
+    }
+
+    case RelationType::CONTAINING_DOCUMENT:
+      return Relation(mDoc);
+
+    case RelationType::CONTAINING_TAB_PANE: {
+      nsCOMPtr<nsIDocShell> docShell =
+        nsCoreUtils::GetDocShellFor(GetNode());
+      if (docShell) {
+        // Walk up the parent chain without crossing the boundary at which item
+        // types change, preventing us from walking up out of tab content.
+        nsCOMPtr<nsIDocShellTreeItem> root;
+        docShell->GetSameTypeRootTreeItem(getter_AddRefs(root));
+        if (root) {
+          // If the item type is typeContent, we assume we are in browser tab
+          // content. Note, this includes content such as about:addons,
+          // for consistency.
+          if (root->ItemType() == nsIDocShellTreeItem::typeContent) {
+            return Relation(nsAccUtils::GetDocAccessibleFor(root));
+          }
+        }
+      }
+      return  Relation();
+    }
+
+    case RelationType::CONTAINING_APPLICATION:
+      return Relation(ApplicationAcc());
+
+    default:
+      return Relation();
+  }
+}
+
+NS_IMETHODIMP
+Accessible::GetRelations(nsIArray **aRelations)
+{
+  NS_ENSURE_ARG_POINTER(aRelations);
+  *aRelations = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIMutableArray> relations = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  NS_ENSURE_TRUE(relations, NS_ERROR_OUT_OF_MEMORY);
+
+  static const uint32_t relationTypes[] = {
+    nsIAccessibleRelation::RELATION_LABELLED_BY,
+    nsIAccessibleRelation::RELATION_LABEL_FOR,
+    nsIAccessibleRelation::RELATION_DESCRIBED_BY,
+    nsIAccessibleRelation::RELATION_DESCRIPTION_FOR,
+    nsIAccessibleRelation::RELATION_NODE_CHILD_OF,
+    nsIAccessibleRelation::RELATION_NODE_PARENT_OF,
+    nsIAccessibleRelation::RELATION_CONTROLLED_BY,
+    nsIAccessibleRelation::RELATION_CONTROLLER_FOR,
+    nsIAccessibleRelation::RELATION_FLOWS_TO,
+    nsIAccessibleRelation::RELATION_FLOWS_FROM,
+    nsIAccessibleRelation::RELATION_MEMBER_OF,
+    nsIAccessibleRelation::RELATION_SUBWINDOW_OF,
+    nsIAccessibleRelation::RELATION_EMBEDS,
+    nsIAccessibleRelation::RELATION_EMBEDDED_BY,
+    nsIAccessibleRelation::RELATION_POPUP_FOR,
+    nsIAccessibleRelation::RELATION_PARENT_WINDOW_OF,
+    nsIAccessibleRelation::RELATION_DEFAULT_BUTTON,
+    nsIAccessibleRelation::RELATION_CONTAINING_DOCUMENT,
+    nsIAccessibleRelation::RELATION_CONTAINING_TAB_PANE,
+    nsIAccessibleRelation::RELATION_CONTAINING_APPLICATION
+  };
+
+  for (uint32_t idx = 0; idx < ArrayLength(relationTypes); idx++) {
+    nsCOMPtr<nsIAccessibleRelation> relation;
+    nsresult rv = GetRelationByType(relationTypes[idx], getter_AddRefs(relation));
+
+    if (NS_SUCCEEDED(rv) && relation) {
+      uint32_t targets = 0;
+      relation->GetTargetsCount(&targets);
+      if (targets)
+        relations->AppendElement(relation, false);
+    }
+  }
+
+  NS_ADDREF(*aRelations = relations);
+  return NS_OK;
+}
+
+/* void extendSelection (); */
+NS_IMETHODIMP Accessible::ExtendSelection()
+{
+  // XXX Should be implemented, but not high priority
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [noscript] void getNativeInterface(out voidPtr aOutAccessible); */
+NS_IMETHODIMP Accessible::GetNativeInterface(void **aOutAccessible)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+void
+Accessible::DoCommand(nsIContent *aContent, uint32_t aActionIndex)
+{
+  class Runnable MOZ_FINAL : public nsRunnable
+  {
+  public:
+    Runnable(Accessible* aAcc, nsIContent* aContent, uint32_t aIdx) :
+      mAcc(aAcc), mContent(aContent), mIdx(aIdx) { }
+
+    NS_IMETHOD Run()
+    {
+      if (mAcc)
+        mAcc->DispatchClickEvent(mContent, mIdx);
+
+      return NS_OK;
+    }
+
+    void Revoke()
+    {
+      mAcc = nullptr;
+      mContent = nullptr;
+    }
+
+  private:
+    nsRefPtr<Accessible> mAcc;
+    nsCOMPtr<nsIContent> mContent;
+    uint32_t mIdx;
+  };
+
+  nsIContent* content = aContent ? aContent : mContent.get();
+  nsCOMPtr<nsIRunnable> runnable = new Runnable(this, content, aActionIndex);
+  NS_DispatchToMainThread(runnable);
+}
+
+void
+Accessible::DispatchClickEvent(nsIContent *aContent, uint32_t aActionIndex)
+{
+  if (IsDefunct())
+    return;
+
+  nsCOMPtr<nsIPresShell> presShell = mDoc->PresShell();
+
+  // Scroll into view.
+  presShell->ScrollContentIntoView(aContent,
+                                   nsIPresShell::ScrollAxis(),
+                                   nsIPresShell::ScrollAxis(),
+                                   nsIPresShell::SCROLL_OVERFLOW_HIDDEN);
+
+  nsWeakFrame frame = aContent->GetPrimaryFrame();
+  if (!frame)
+    return;
+
+  // Compute x and y coordinates.
+  nsPoint point;
+  nsCOMPtr<nsIWidget> widget = frame->GetNearestWidget(point);
+  if (!widget)
+    return;
+
+  nsSize size = frame->GetSize();
+
+  nsRefPtr<nsPresContext> presContext = presShell->GetPresContext();
+  int32_t x = presContext->AppUnitsToDevPixels(point.x + size.width / 2);
+  int32_t y = presContext->AppUnitsToDevPixels(point.y + size.height / 2);
+
+  // Simulate a touch interaction by dispatching touch events with mouse events.
+  nsCoreUtils::DispatchTouchEvent(NS_TOUCH_START, x, y, aContent, frame, presShell, widget);
+  nsCoreUtils::DispatchMouseEvent(NS_MOUSE_BUTTON_DOWN, x, y, aContent, frame, presShell, widget);
+  nsCoreUtils::DispatchTouchEvent(NS_TOUCH_END, x, y, aContent, frame, presShell, widget);
+  nsCoreUtils::DispatchMouseEvent(NS_MOUSE_BUTTON_UP, x, y, aContent, frame, presShell, widget);
+}
+
+NS_IMETHODIMP
+Accessible::ScrollTo(uint32_t aHow)
+{
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  nsCoreUtils::ScrollTo(mDoc->PresShell(), mContent, aHow);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::ScrollToPoint(uint32_t aCoordinateType, int32_t aX, int32_t aY)
+{
+  nsIFrame *frame = GetFrame();
+  if (!frame)
+    return NS_ERROR_FAILURE;
+
+  nsIntPoint coords = nsAccUtils::ConvertToScreenCoords(aX, aY, aCoordinateType,
+                                                        this);
+
+  nsIFrame *parentFrame = frame;
+  while ((parentFrame = parentFrame->GetParent()))
+    nsCoreUtils::ScrollFrameToPoint(parentFrame, frame, coords);
+
+  return NS_OK;
+}
+
+// nsIAccessibleHyperLink
+// Because of new-atk design, any embedded object in text can implement
+// nsIAccessibleHyperLink, which helps determine where it is located
+// within containing text
+
+// readonly attribute long nsIAccessibleHyperLink::anchorCount
+NS_IMETHODIMP
+Accessible::GetAnchorCount(int32_t *aAnchorCount)
+{
+  NS_ENSURE_ARG_POINTER(aAnchorCount);
+  *aAnchorCount = 0;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  *aAnchorCount = AnchorCount();
+  return NS_OK;
+}
+
+// readonly attribute long nsIAccessibleHyperLink::startIndex
+NS_IMETHODIMP
+Accessible::GetStartIndex(int32_t *aStartIndex)
+{
+  NS_ENSURE_ARG_POINTER(aStartIndex);
+  *aStartIndex = 0;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  *aStartIndex = StartOffset();
+  return NS_OK;
+}
+
+// readonly attribute long nsIAccessibleHyperLink::endIndex
+NS_IMETHODIMP
+Accessible::GetEndIndex(int32_t *aEndIndex)
+{
+  NS_ENSURE_ARG_POINTER(aEndIndex);
+  *aEndIndex = 0;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  *aEndIndex = EndOffset();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+Accessible::GetURI(int32_t aIndex, nsIURI **aURI)
+{
+  NS_ENSURE_ARG_POINTER(aURI);
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  if (aIndex < 0 || aIndex >= static_cast<int32_t>(AnchorCount()))
+    return NS_ERROR_INVALID_ARG;
+
+  nsRefPtr<nsIURI>(AnchorURIAt(aIndex)).forget(aURI);
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+Accessible::GetAnchor(int32_t aIndex, nsIAccessible** aAccessible)
+{
+  NS_ENSURE_ARG_POINTER(aAccessible);
+  *aAccessible = nullptr;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  if (aIndex < 0 || aIndex >= static_cast<int32_t>(AnchorCount()))
+    return NS_ERROR_INVALID_ARG;
+
+  NS_IF_ADDREF(*aAccessible = AnchorAt(aIndex));
+  return NS_OK;
+}
+
+// readonly attribute boolean nsIAccessibleHyperLink::valid
+NS_IMETHODIMP
+Accessible::GetValid(bool *aValid)
+{
+  NS_ENSURE_ARG_POINTER(aValid);
+  *aValid = false;
+
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
+  *aValid = IsLinkValid();
+  return NS_OK;
+}
+
+void
+Accessible::AppendTextTo(nsAString& aText, uint32_t aStartOffset,
+                         uint32_t aLength)
+{
+  // Return text representation of non-text accessible within hypertext
+  // accessible. Text accessible overrides this method to return enclosed text.
+  if (aStartOffset != 0 || aLength == 0)
+    return;
+
+  nsIFrame *frame = GetFrame();
+  if (!frame)
+    return;
+
+  NS_ASSERTION(mParent,
+               "Called on accessible unbound from tree. Result can be wrong.");
+
+  if (frame->GetType() == nsGkAtoms::brFrame) {
+    aText += kForcedNewLineChar;
+  } else if (mParent && nsAccUtils::MustPrune(mParent)) {
+    // Expose the embedded object accessible as imaginary embedded object
+    // character if its parent hypertext accessible doesn't expose children to
+    // AT.
+    aText += kImaginaryEmbeddedObjectChar;
+  } else {
+    aText += kEmbeddedObjectChar;
+  }
+}
+
+void
+Accessible::Shutdown()
+{
+  // Mark the accessible as defunct, invalidate the child count and pointers to 
+  // other accessibles, also make sure none of its children point to this parent
+  mStateFlags |= eIsDefunct;
+
+  InvalidateChildren();
+  if (mParent)
+    mParent->RemoveChild(this);
+
+  mContent = nullptr;
+  mDoc = nullptr;
+}
+
+// Accessible protected
+void
+Accessible::ARIAName(nsString& aName)
+{
+  // aria-labelledby now takes precedence over aria-label
+  nsresult rv = nsTextEquivUtils::
+    GetTextEquivFromIDRefs(this, nsGkAtoms::aria_labelledby, aName);
+  if (NS_SUCCEEDED(rv)) {
+    aName.CompressWhitespace();
+  }
+
+  if (aName.IsEmpty() &&
+      mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::aria_label, aName)) {
+    aName.CompressWhitespace();
+  }
+}
+
+// Accessible protected
+ENameValueFlag
+Accessible::NativeName(nsString& aName)
+{
+  if (mContent->IsHTML()) {
+    Accessible* label = nullptr;
+    HTMLLabelIterator iter(Document(), this);
+    while ((label = iter.Next())) {
+      nsTextEquivUtils::AppendTextEquivFromContent(this, label->GetContent(),
+                                                   &aName);
+      aName.CompressWhitespace();
+    }
+
+    if (!aName.IsEmpty())
+      return eNameOK;
+
+    nsTextEquivUtils::GetNameFromSubtree(this, aName);
+    return aName.IsEmpty() ? eNameOK : eNameFromSubtree;
+  }
+
+  if (mContent->IsXUL()) {
+    XULElmName(mDoc, mContent, aName);
+    if (!aName.IsEmpty())
+      return eNameOK;
+
+    nsTextEquivUtils::GetNameFromSubtree(this, aName);
+    return aName.IsEmpty() ? eNameOK : eNameFromSubtree;
+  }
+
+  if (mContent->IsSVG()) {
+    // If user agents need to choose among multiple ‘desc’ or ‘title’ elements
+    // for processing, the user agent shall choose the first one.
+    for (nsIContent* childElm = mContent->GetFirstChild(); childElm;
+         childElm = childElm->GetNextSibling()) {
+      if (childElm->IsSVG(nsGkAtoms::title)) {
+        nsTextEquivUtils::AppendTextEquivFromContent(this, childElm, &aName);
+        return eNameOK;
+      }
+    }
+  }
+
+  return eNameOK;
+}
+
+// Accessible protected
+void
+Accessible::BindToParent(Accessible* aParent, uint32_t aIndexInParent)
+{
+  NS_PRECONDITION(aParent, "This method isn't used to set null parent!");
+
+  if (mParent) {
+    if (mParent != aParent) {
+      NS_ERROR("Adopting child!");
+      mParent->RemoveChild(this);
+      mParent->InvalidateChildrenGroupInfo();
+    } else {
+      NS_ERROR("Binding to the same parent!");
+      return;
+    }
+  }
+
+  mParent = aParent;
+  mIndexInParent = aIndexInParent;
+
+  mParent->InvalidateChildrenGroupInfo();
+
+  // Note: this is currently only used for richlistitems and their children.
+  if (mParent->HasNameDependentParent() || mParent->IsXULListItem())
+    mContextFlags |= eHasNameDependentParent;
+  else
+    mContextFlags &= ~eHasNameDependentParent;
+}
+
+// Accessible protected
+void
+Accessible::UnbindFromParent()
+{
+  mParent->InvalidateChildrenGroupInfo();
+  mParent = nullptr;
+  mIndexInParent = -1;
+  mIndexOfEmbeddedChild = -1;
+  mGroupInfo = nullptr;
+  mContextFlags &= ~eHasNameDependentParent;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Accessible public methods
+
+RootAccessible*
+Accessible::RootAccessible() const
+{
+  nsCOMPtr<nsIDocShell> docShell = nsCoreUtils::GetDocShellFor(GetNode());
+  NS_ASSERTION(docShell, "No docshell for mContent");
+  if (!docShell) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIDocShellTreeItem> root;
+  docShell->GetRootTreeItem(getter_AddRefs(root));
+  NS_ASSERTION(root, "No root content tree item");
+  if (!root) {
+    return nullptr;
+  }
+
+  DocAccessible* docAcc = nsAccUtils::GetDocAccessibleFor(root);
+  return docAcc ? docAcc->AsRoot() : nullptr;
+}
+
+nsIFrame*
+Accessible::GetFrame() const
+{
+  return mContent ? mContent->GetPrimaryFrame() : nullptr;
+}
+
+nsINode*
+Accessible::GetNode() const
+{
+  return mContent;
+}
+
+void
+Accessible::Language(nsAString& aLanguage)
+{
+  aLanguage.Truncate();
+
+  if (!mDoc)
+    return;
+
+  nsCoreUtils::GetLanguageFor(mContent, nullptr, aLanguage);
+  if (aLanguage.IsEmpty()) { // Nothing found, so use document's language
+    mDoc->DocumentNode()->GetHeaderData(nsGkAtoms::headerContentLanguage,
+                                        aLanguage);
+  }
+}
+
+void
+Accessible::InvalidateChildren()
+{
+  int32_t childCount = mChildren.Length();
+  for (int32_t childIdx = 0; childIdx < childCount; childIdx++) {
+    Accessible* child = mChildren.ElementAt(childIdx);
+    child->UnbindFromParent();
+  }
+
+  mEmbeddedObjCollector = nullptr;
+  mChildren.Clear();
+  SetChildrenFlag(eChildrenUninitialized);
+}
+
+bool
+Accessible::InsertChildAt(uint32_t aIndex, Accessible* aChild)
+{
+  if (!aChild)
+    return false;
+
+  if (aIndex == mChildren.Length()) {
+    if (!mChildren.AppendElement(aChild))
+      return false;
+
+  } else {
+    if (!mChildren.InsertElementAt(aIndex, aChild))
+      return false;
+
+    for (uint32_t idx = aIndex + 1; idx < mChildren.Length(); idx++) {
+      NS_ASSERTION(static_cast<uint32_t>(mChildren[idx]->mIndexInParent) == idx - 1,
+                   "Accessible child index doesn't match");
+      mChildren[idx]->mIndexInParent = idx;
+    }
+
+    mEmbeddedObjCollector = nullptr;
+  }
+
+  if (!nsAccUtils::IsEmbeddedObject(aChild))
+    SetChildrenFlag(eMixedChildren);
+
+  aChild->BindToParent(this, aIndex);
+  return true;
+}
+
+bool
+Accessible::RemoveChild(Accessible* aChild)
+{
+  if (!aChild)
+    return false;
+
+  if (aChild->mParent != this || aChild->mIndexInParent == -1)
+    return false;
+
+  uint32_t index = static_cast<uint32_t>(aChild->mIndexInParent);
+  if (index >= mChildren.Length() || mChildren[index] != aChild) {
+    NS_ERROR("Child is bound to parent but parent hasn't this child at its index!");
+    aChild->UnbindFromParent();
+    return false;
+  }
+
+  for (uint32_t idx = index + 1; idx < mChildren.Length(); idx++) {
+    NS_ASSERTION(static_cast<uint32_t>(mChildren[idx]->mIndexInParent) == idx,
+                 "Accessible child index doesn't match");
+    mChildren[idx]->mIndexInParent = idx - 1;
+  }
+
+  aChild->UnbindFromParent();
+  mChildren.RemoveElementAt(index);
+  mEmbeddedObjCollector = nullptr;
+
+  return true;
+}
+
+Accessible*
+Accessible::GetChildAt(uint32_t aIndex) const
+{
+  Accessible* child = mChildren.SafeElementAt(aIndex, nullptr);
+  if (!child)
+    return nullptr;
+
+#ifdef DEBUG
+  Accessible* realParent = child->mParent;
+  NS_ASSERTION(!realParent || realParent == this,
+               "Two accessibles have the same first child accessible!");
+#endif
+
+  return child;
+}
+
+uint32_t
+Accessible::ChildCount() const
+{
+  return mChildren.Length();
+}
+
+int32_t
+Accessible::IndexInParent() const
+{
+  return mIndexInParent;
+}
+
+uint32_t
+Accessible::EmbeddedChildCount()
+{
+  if (IsChildrenFlag(eMixedChildren)) {
+    if (!mEmbeddedObjCollector)
+      mEmbeddedObjCollector = new EmbeddedObjCollector(this);
+    return mEmbeddedObjCollector->Count();
+  }
+
+  return ChildCount();
+}
+
+Accessible*
+Accessible::GetEmbeddedChildAt(uint32_t aIndex)
+{
+  if (IsChildrenFlag(eMixedChildren)) {
+    if (!mEmbeddedObjCollector)
+      mEmbeddedObjCollector = new EmbeddedObjCollector(this);
+    return mEmbeddedObjCollector ?
+      mEmbeddedObjCollector->GetAccessibleAt(aIndex) : nullptr;
+  }
+
+  return GetChildAt(aIndex);
+}
+
+int32_t
+Accessible::GetIndexOfEmbeddedChild(Accessible* aChild)
+{
+  if (IsChildrenFlag(eMixedChildren)) {
+    if (!mEmbeddedObjCollector)
+      mEmbeddedObjCollector = new EmbeddedObjCollector(this);
+    return mEmbeddedObjCollector ?
+      mEmbeddedObjCollector->GetIndexAt(aChild) : -1;
+  }
+
+  return GetIndexOf(aChild);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// HyperLinkAccessible methods
+
+bool
+Accessible::IsLink()
+{
+  // Every embedded accessible within hypertext accessible implements
+  // hyperlink interface.
+  return mParent && mParent->IsHyperText() && nsAccUtils::IsEmbeddedObject(this);
+}
+
+uint32_t
+Accessible::StartOffset()
+{
+  NS_PRECONDITION(IsLink(), "StartOffset is called not on hyper link!");
+
+  HyperTextAccessible* hyperText = mParent ? mParent->AsHyperText() : nullptr;
+  return hyperText ? hyperText->GetChildOffset(this) : 0;
+}
+
+uint32_t
+Accessible::EndOffset()
+{
+  NS_PRECONDITION(IsLink(), "EndOffset is called on not hyper link!");
+
+  HyperTextAccessible* hyperText = mParent ? mParent->AsHyperText() : nullptr;
+  return hyperText ? (hyperText->GetChildOffset(this) + 1) : 0;
+}
+
+uint32_t
+Accessible::AnchorCount()
+{
+  NS_PRECONDITION(IsLink(), "AnchorCount is called on not hyper link!");
+  return 1;
+}
+
+Accessible*
+Accessible::AnchorAt(uint32_t aAnchorIndex)
+{
+  NS_PRECONDITION(IsLink(), "GetAnchor is called on not hyper link!");
+  return aAnchorIndex == 0 ? this : nullptr;
+}
+
+already_AddRefed<nsIURI>
+Accessible::AnchorURIAt(uint32_t aAnchorIndex)
+{
+  NS_PRECONDITION(IsLink(), "AnchorURIAt is called on not hyper link!");
+  return nullptr;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// SelectAccessible
+
+already_AddRefed<nsIArray>
+Accessible::SelectedItems()
+{
+  nsCOMPtr<nsIMutableArray> selectedItems = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  if (!selectedItems)
+    return nullptr;
+
+  AccIterator iter(this, filters::GetSelected);
+  nsIAccessible* selected = nullptr;
+  while ((selected = iter.Next()))
+    selectedItems->AppendElement(selected, false);
+
+  return selectedItems.forget();
+}
+
+uint32_t
+Accessible::SelectedItemCount()
+{
+  uint32_t count = 0;
+  AccIterator iter(this, filters::GetSelected);
+  Accessible* selected = nullptr;
+  while ((selected = iter.Next()))
+    ++count;
+
+  return count;
+}
+
+Accessible*
+Accessible::GetSelectedItem(uint32_t aIndex)
+{
+  AccIterator iter(this, filters::GetSelected);
+  Accessible* selected = nullptr;
+
+  uint32_t index = 0;
+  while ((selected = iter.Next()) && index < aIndex)
+    index++;
+
+  return selected;
+}
+
+bool
+Accessible::IsItemSelected(uint32_t aIndex)
+{
+  uint32_t index = 0;
+  AccIterator iter(this, filters::GetSelectable);
+  Accessible* selected = nullptr;
+  while ((selected = iter.Next()) && index < aIndex)
+    index++;
+
+  return selected &&
+    selected->State() & states::SELECTED;
+}
+
+bool
+Accessible::AddItemToSelection(uint32_t aIndex)
+{
+  uint32_t index = 0;
+  AccIterator iter(this, filters::GetSelectable);
+  Accessible* selected = nullptr;
+  while ((selected = iter.Next()) && index < aIndex)
+    index++;
+
+  if (selected)
+    selected->SetSelected(true);
+
+  return static_cast<bool>(selected);
+}
+
+bool
+Accessible::RemoveItemFromSelection(uint32_t aIndex)
+{
+  uint32_t index = 0;
+  AccIterator iter(this, filters::GetSelectable);
+  Accessible* selected = nullptr;
+  while ((selected = iter.Next()) && index < aIndex)
+    index++;
+
+  if (selected)
+    selected->SetSelected(false);
+
+  return static_cast<bool>(selected);
+}
+
+bool
+Accessible::SelectAll()
+{
+  bool success = false;
+  Accessible* selectable = nullptr;
+
+  AccIterator iter(this, filters::GetSelectable);
+  while((selectable = iter.Next())) {
+    success = true;
+    selectable->SetSelected(true);
+  }
+  return success;
+}
+
+bool
+Accessible::UnselectAll()
+{
+  bool success = false;
+  Accessible* selected = nullptr;
+
+  AccIterator iter(this, filters::GetSelected);
+  while ((selected = iter.Next())) {
+    success = true;
+    selected->SetSelected(false);
+  }
+  return success;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Widgets
+
+bool
+Accessible::IsWidget() const
+{
+  return false;
+}
+
+bool
+Accessible::IsActiveWidget() const
+{
+  if (FocusMgr()->HasDOMFocus(mContent))
+    return true;
+
+  // If text entry of combobox widget has a focus then the combobox widget is
+  // active.
+  if (mRoleMapEntry && mRoleMapEntry->Is(nsGkAtoms::combobox)) {
+    uint32_t childCount = ChildCount();
+    for (uint32_t idx = 0; idx < childCount; idx++) {
+      Accessible* child = mChildren.ElementAt(idx);
+      if (child->Role() == roles::ENTRY)
+        return FocusMgr()->HasDOMFocus(child->GetContent());
+    }
+  }
+
+  return false;
+}
+
+bool
+Accessible::AreItemsOperable() const
+{
+  return HasOwnContent() &&
+    mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_activedescendant);
+}
+
+Accessible*
+Accessible::CurrentItem()
+{
+  // Check for aria-activedescendant, which changes which element has focus.
+  // For activedescendant, the ARIA spec does not require that the user agent
+  // checks whether pointed node is actually a DOM descendant of the element
+  // with the aria-activedescendant attribute.
+  nsAutoString id;
+  if (HasOwnContent() &&
+      mContent->GetAttr(kNameSpaceID_None,
+                        nsGkAtoms::aria_activedescendant, id)) {
+    nsIDocument* DOMDoc = mContent->OwnerDoc();
+    dom::Element* activeDescendantElm = DOMDoc->GetElementById(id);
+    if (activeDescendantElm) {
+      DocAccessible* document = Document();
+      if (document)
+        return document->GetAccessible(activeDescendantElm);
+    }
+  }
+  return nullptr;
+}
+
+void
+Accessible::SetCurrentItem(Accessible* aItem)
+{
+  nsIAtom* id = aItem->GetContent()->GetID();
+  if (id) {
+    nsAutoString idStr;
+    id->ToString(idStr);
+    mContent->SetAttr(kNameSpaceID_None,
+                      nsGkAtoms::aria_activedescendant, idStr, true);
+  }
+}
+
+Accessible*
+Accessible::ContainerWidget() const
+{
+  if (HasARIARole() && mContent->HasID()) {
+    for (Accessible* parent = Parent(); parent; parent = parent->Parent()) {
+      nsIContent* parentContent = parent->GetContent();
+      if (parentContent &&
+        parentContent->HasAttr(kNameSpaceID_None,
+                               nsGkAtoms::aria_activedescendant)) {
+        return parent;
+      }
+
+      // Don't cross DOM document boundaries.
+      if (parent->IsDoc())
+        break;
+    }
+  }
+  return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Accessible protected methods
+
+void
+Accessible::LastRelease()
+{
+  // First cleanup if needed...
+  if (mDoc) {
+    Shutdown();
+    NS_ASSERTION(!mDoc,
+                 "A Shutdown() impl forgot to call its parent's Shutdown?");
+  }
+  // ... then die.
+  delete this;
+}
+
+void
+Accessible::CacheChildren()
+{
+  DocAccessible* doc = Document();
+  NS_ENSURE_TRUE_VOID(doc);
+
+  TreeWalker walker(this, mContent);
+
+  Accessible* child = nullptr;
+  while ((child = walker.NextChild()) && AppendChild(child));
+}
+
+void
+Accessible::TestChildCache(Accessible* aCachedChild) const
+{
+#ifdef DEBUG
+  int32_t childCount = mChildren.Length();
+  if (childCount == 0) {
+    NS_ASSERTION(IsChildrenFlag(eChildrenUninitialized),
+                 "No children but initialized!");
+    return;
+  }
+
+  Accessible* child = nullptr;
+  for (int32_t childIdx = 0; childIdx < childCount; childIdx++) {
+    child = mChildren[childIdx];
+    if (child == aCachedChild)
+      break;
+  }
+
+  NS_ASSERTION(child == aCachedChild,
+               "[TestChildCache] cached accessible wasn't found. Wrong accessible tree!");  
+#endif
+}
+
+// Accessible public
+bool
+Accessible::EnsureChildren()
+{
+  if (IsDefunct()) {
+    SetChildrenFlag(eChildrenUninitialized);
+    return true;
+  }
+
+  if (!IsChildrenFlag(eChildrenUninitialized))
+    return false;
+
+  // State is embedded children until text leaf accessible is appended.
+  SetChildrenFlag(eEmbeddedChildren); // Prevent reentry
+
+  CacheChildren();
+  return false;
+}
+
+Accessible*
+Accessible::GetSiblingAtOffset(int32_t aOffset, nsresult* aError) const
+{
+  if (!mParent || mIndexInParent == -1) {
+    if (aError)
+      *aError = NS_ERROR_UNEXPECTED;
+
+    return nullptr;
+  }
+
+  if (aError &&
+      mIndexInParent + aOffset >= static_cast<int32_t>(mParent->ChildCount())) {
+    *aError = NS_OK; // fail peacefully
+    return nullptr;
+  }
+
+  Accessible* child = mParent->GetChildAt(mIndexInParent + aOffset);
+  if (aError && !child)
+    *aError = NS_ERROR_UNEXPECTED;
+
+  return child;
+}
+
+double
+Accessible::AttrNumericValue(nsIAtom* aAttr) const
+{
+  if (!mRoleMapEntry || mRoleMapEntry->valueRule == eNoValue)
+    return UnspecifiedNaN<double>();
+
+  nsAutoString attrValue;
+  if (!mContent->GetAttr(kNameSpaceID_None, aAttr, attrValue))
+    return UnspecifiedNaN<double>();
+
+  nsresult error = NS_OK;
+  double value = attrValue.ToDouble(&error);
+  return NS_FAILED(error) ? UnspecifiedNaN<double>() : value;
+}
+
+uint32_t
+Accessible::GetActionRule()
+{
+  if (!HasOwnContent() || (InteractiveState() & states::UNAVAILABLE))
+    return eNoAction;
+
+  // Return "click" action on elements that have an attached popup menu.
+  if (mContent->IsXUL())
+    if (mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::popup))
+      return eClickAction;
+
+  // Has registered 'click' event handler.
+  bool isOnclick = nsCoreUtils::HasClickListener(mContent);
+
+  if (isOnclick)
+    return eClickAction;
+  
+  // Get an action based on ARIA role.
+  if (mRoleMapEntry &&
+      mRoleMapEntry->actionRule != eNoAction)
+    return mRoleMapEntry->actionRule;
+
+  // Get an action based on ARIA attribute.
+  if (nsAccUtils::HasDefinedARIAToken(mContent,
+                                      nsGkAtoms::aria_expanded))
+    return eExpandAction;
+
+  return eNoAction;
+}
+
+AccGroupInfo*
+Accessible::GetGroupInfo()
+{
+  if (mGroupInfo){
+    if (HasDirtyGroupInfo()) {
+      mGroupInfo->Update();
+      SetDirtyGroupInfo(false);
+    }
+
+    return mGroupInfo;
+  }
+
+  mGroupInfo = AccGroupInfo::CreateGroupInfo(this);
+  return mGroupInfo;
+}
+
+void
+Accessible::InvalidateChildrenGroupInfo()
+{
+  uint32_t length = mChildren.Length();
+  for (uint32_t i = 0; i < length; i++) {
+    Accessible* child = mChildren[i];
+    child->SetDirtyGroupInfo(true);
+  }
+}
+
+void
+Accessible::GetPositionAndSizeInternal(int32_t *aPosInSet, int32_t *aSetSize)
+{
+  AccGroupInfo* groupInfo = GetGroupInfo();
+  if (groupInfo) {
+    *aPosInSet = groupInfo->PosInSet();
+    *aSetSize = groupInfo->SetSize();
+  }
+}
+
+int32_t
+Accessible::GetLevelInternal()
+{
+  int32_t level = nsAccUtils::GetDefaultLevel(this);
+
+  if (!IsBoundToParent())
+    return level;
+
+  roles::Role role = Role();
+  if (role == roles::OUTLINEITEM) {
+    // Always expose 'level' attribute for 'outlineitem' accessible. The number
+    // of nested 'grouping' accessibles containing 'outlineitem' accessible is
+    // its level.
+    level = 1;
+
+    Accessible* parent = this;
+    while ((parent = parent->Parent())) {
+      roles::Role parentRole = parent->Role();
+
+      if (parentRole == roles::OUTLINE)
+        break;
+      if (parentRole == roles::GROUPING)
+        ++ level;
+
+    }
+
+  } else if (role == roles::LISTITEM) {
+    // Expose 'level' attribute on nested lists. We support two hierarchies:
+    // a) list -> listitem -> list -> listitem (nested list is a last child
+    //   of listitem of the parent list);
+    // b) list -> listitem -> group -> listitem (nested listitems are contained
+    //   by group that is a last child of the parent listitem).
+
+    // Calculate 'level' attribute based on number of parent listitems.
+    level = 0;
+    Accessible* parent = this;
+    while ((parent = parent->Parent())) {
+      roles::Role parentRole = parent->Role();
+
+      if (parentRole == roles::LISTITEM)
+        ++ level;
+      else if (parentRole != roles::LIST && parentRole != roles::GROUPING)
+        break;
+    }
+
+    if (level == 0) {
+      // If this listitem is on top of nested lists then expose 'level'
+      // attribute.
+      parent = Parent();
+      uint32_t siblingCount = parent->ChildCount();
+      for (uint32_t siblingIdx = 0; siblingIdx < siblingCount; siblingIdx++) {
+        Accessible* sibling = parent->GetChildAt(siblingIdx);
+
+        Accessible* siblingChild = sibling->LastChild();
+        if (siblingChild) {
+          roles::Role lastChildRole = siblingChild->Role();
+          if (lastChildRole == roles::LIST || lastChildRole == roles::GROUPING)
+            return 1;
+        }
+      }
+    } else {
+      ++ level; // level is 1-index based
+    }
+  }
+
+  return level;
+}
+
+void
+Accessible::StaticAsserts() const
+{
+  static_assert(eLastChildrenFlag <= (1 << kChildrenFlagsBits) - 1,
+                "Accessible::mChildrenFlags was oversized by eLastChildrenFlag!");
+  static_assert(eLastStateFlag <= (1 << kStateFlagsBits) - 1,
+                "Accessible::mStateFlags was oversized by eLastStateFlag!");
+  static_assert(eLastAccType <= (1 << kTypeBits) - 1,
+                "Accessible::mType was oversized by eLastAccType!");
+  static_assert(eLastContextFlag <= (1 << kContextFlagsBits) - 1,
+                "Accessible::mContextFlags was oversized by eLastContextFlag!");
+  static_assert(eLastAccGenericType <= (1 << kGenericTypesBits) - 1,
+                "Accessible::mGenericType was oversized by eLastAccGenericType!");
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// KeyBinding class
+
+void
+KeyBinding::ToPlatformFormat(nsAString& aValue) const
+{
+  nsCOMPtr<nsIStringBundle> keyStringBundle;
+  nsCOMPtr<nsIStringBundleService> stringBundleService =
+      mozilla::services::GetStringBundleService();
+  if (stringBundleService)
+    stringBundleService->CreateBundle(
+      "chrome://global-platform/locale/platformKeys.properties",
+      getter_AddRefs(keyStringBundle));
+
+  if (!keyStringBundle)
+    return;
+
+  nsAutoString separator;
+  keyStringBundle->GetStringFromName(MOZ_UTF16("MODIFIER_SEPARATOR"),
+                                     getter_Copies(separator));
+
+  nsAutoString modifierName;
+  if (mModifierMask & kControl) {
+    keyStringBundle->GetStringFromName(MOZ_UTF16("VK_CONTROL"),
+                                       getter_Copies(modifierName));
+
+    aValue.Append(modifierName);
+    aValue.Append(separator);
+  }
+
+  if (mModifierMask & kAlt) {
+    keyStringBundle->GetStringFromName(MOZ_UTF16("VK_ALT"),
+                                       getter_Copies(modifierName));
+
+    aValue.Append(modifierName);
+    aValue.Append(separator);
+  }
+
+  if (mModifierMask & kShift) {
+    keyStringBundle->GetStringFromName(MOZ_UTF16("VK_SHIFT"),
+                                       getter_Copies(modifierName));
+
+    aValue.Append(modifierName);
+    aValue.Append(separator);
+  }
+
+  if (mModifierMask & kMeta) {
+    keyStringBundle->GetStringFromName(MOZ_UTF16("VK_META"),
+                                       getter_Copies(modifierName));
+
+    aValue.Append(modifierName);
+    aValue.Append(separator);
+  }
+
+  aValue.Append(mKey);
+}
+
+void
+KeyBinding::ToAtkFormat(nsAString& aValue) const
+{
+  nsAutoString modifierName;
+  if (mModifierMask & kControl)
+    aValue.Append(NS_LITERAL_STRING("<Control>"));
+
+  if (mModifierMask & kAlt)
+    aValue.Append(NS_LITERAL_STRING("<Alt>"));
+
+  if (mModifierMask & kShift)
+    aValue.Append(NS_LITERAL_STRING("<Shift>"));
+
+  if (mModifierMask & kMeta)
+      aValue.Append(NS_LITERAL_STRING("<Meta>"));
+
+  aValue.Append(mKey);
+}
+