Adding upstream version 110.0.1.upstream/110.0.1upstream

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

1 files changed, 771 insertions, 0 deletions

diff --git a/accessible/mac/HyperTextAccessibleWrap.mm b/accessible/mac/HyperTextAccessibleWrap.mm
new file mode 100644
index 0000000000..361eb9ca22
--- /dev/null
+++ b/accessible/mac/HyperTextAccessibleWrap.mm
@@ -0,0 +1,771 @@
+/* clang-format off */
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* clang-format on */
+/* 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 "HyperTextAccessibleWrap.h"
+
+#include "LocalAccessible-inl.h"
+#include "HTMLListAccessible.h"
+#include "nsAccUtils.h"
+#include "nsFrameSelection.h"
+#include "TextRange.h"
+#include "TreeWalker.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+// HyperTextIterator
+
+class HyperTextIterator {
+ public:
+  HyperTextIterator(HyperTextAccessible* aStartContainer, int32_t aStartOffset,
+                    HyperTextAccessible* aEndContainer, int32_t aEndOffset)
+      : mCurrentContainer(aStartContainer),
+        mCurrentStartOffset(0),
+        mCurrentEndOffset(0),
+        mEndContainer(aEndContainer),
+        mEndOffset(0) {
+    mCurrentStartOffset =
+        std::min(aStartOffset,
+                 static_cast<int32_t>(mCurrentContainer->CharacterCount()));
+    mCurrentEndOffset = mCurrentStartOffset;
+    mEndOffset = std::min(
+        aEndOffset, static_cast<int32_t>(mEndContainer->CharacterCount()));
+  }
+
+  bool Next();
+
+  int32_t SegmentLength();
+
+  // If offset is set to a child hyperlink, adjust it so it set on the first
+  // offset in the deepest link. Or, if the offset to the last character, set it
+  // to the outermost end offset in an ancestor. Returns true if iterator was
+  // mutated.
+  bool NormalizeForward();
+
+  // If offset is set right after child hyperlink, adjust it so it set on the
+  // last offset in the deepest link. Or, if the offset is on the first
+  // character of a link, set it to the outermost start offset in an ancestor.
+  // Returns true if iterator was mutated.
+  bool NormalizeBackward();
+
+  HyperTextAccessible* mCurrentContainer;
+  int32_t mCurrentStartOffset;
+  int32_t mCurrentEndOffset;
+
+ private:
+  int32_t NextLinkOffset();
+
+  HyperTextAccessible* mEndContainer;
+  int32_t mEndOffset;
+};
+
+bool HyperTextIterator::NormalizeForward() {
+  if (mCurrentStartOffset == nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT ||
+      mCurrentStartOffset >=
+          static_cast<int32_t>(mCurrentContainer->CharacterCount())) {
+    // If this is the end of the current container, mutate to its parent's
+    // end offset.
+    if (!mCurrentContainer->IsLink()) {
+      // If we are not a link, it is a root hypertext accessible.
+      return false;
+    }
+    if (!mCurrentContainer->LocalParent() ||
+        !mCurrentContainer->LocalParent()->IsHyperText()) {
+      // If we are a link, but our parent is not a hypertext accessible
+      // treat the current container as the root hypertext accessible.
+      // This can be the case with some XUL containers that are not
+      // hypertext accessibles.
+      return false;
+    }
+    uint32_t endOffset = mCurrentContainer->EndOffset();
+    if (endOffset != 0) {
+      mCurrentContainer = mCurrentContainer->LocalParent()->AsHyperText();
+      mCurrentStartOffset = endOffset;
+
+      if (mCurrentContainer == mEndContainer &&
+          mCurrentStartOffset >= mEndOffset) {
+        // Reached end boundary.
+        return false;
+      }
+
+      // Call NormalizeForward recursively to get top-most link if at the end of
+      // one, or innermost link if at the beginning.
+      NormalizeForward();
+      return true;
+    }
+  } else {
+    LocalAccessible* link = mCurrentContainer->LinkAt(
+        mCurrentContainer->LinkIndexAtOffset(mCurrentStartOffset));
+
+    // If there is a link at this offset, mutate into it.
+    if (link && link->IsHyperText()) {
+      if (mCurrentStartOffset > 0 &&
+          mCurrentContainer->LinkIndexAtOffset(mCurrentStartOffset) ==
+              mCurrentContainer->LinkIndexAtOffset(mCurrentStartOffset - 1)) {
+        MOZ_ASSERT_UNREACHABLE("Same link for previous offset");
+        return false;
+      }
+
+      mCurrentContainer = link->AsHyperText();
+      if (link->IsHTMLListItem()) {
+        LocalAccessible* bullet = link->AsHTMLListItem()->Bullet();
+        mCurrentStartOffset = bullet ? nsAccUtils::TextLength(bullet) : 0;
+      } else {
+        mCurrentStartOffset = 0;
+      }
+
+      if (mCurrentContainer == mEndContainer &&
+          mCurrentStartOffset >= mEndOffset) {
+        // Reached end boundary.
+        return false;
+      }
+
+      // Call NormalizeForward recursively to get top-most embedding ancestor
+      // if at the end of one, or innermost link if at the beginning.
+      NormalizeForward();
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool HyperTextIterator::NormalizeBackward() {
+  if (mCurrentStartOffset == 0) {
+    // If this is the start of the current container, mutate to its parent's
+    // start offset.
+    if (!mCurrentContainer->IsLink()) {
+      // If we are not a link, it is a root hypertext accessible.
+      return false;
+    }
+    if (!mCurrentContainer->LocalParent() ||
+        !mCurrentContainer->LocalParent()->IsHyperText()) {
+      // If we are a link, but our parent is not a hypertext accessible
+      // treat the current container as the root hypertext accessible.
+      // This can be the case with some XUL containers that are not
+      // hypertext accessibles.
+      return false;
+    }
+
+    uint32_t startOffset = mCurrentContainer->StartOffset();
+    mCurrentContainer = mCurrentContainer->LocalParent()->AsHyperText();
+    mCurrentStartOffset = startOffset;
+
+    // Call NormalizeBackward recursively to get top-most link if at the
+    // beginning of one, or innermost link if at the end.
+    NormalizeBackward();
+    return true;
+  } else {
+    LocalAccessible* link =
+        mCurrentContainer->GetChildAtOffset(mCurrentStartOffset - 1);
+
+    // If there is a link before this offset, mutate into it,
+    // and set the offset to its last character.
+    if (link && link->IsHyperText()) {
+      mCurrentContainer = link->AsHyperText();
+      mCurrentStartOffset = mCurrentContainer->CharacterCount();
+
+      // Call NormalizeBackward recursively to get top-most top-most embedding
+      // ancestor if at the beginning of one, or innermost link if at the end.
+      NormalizeBackward();
+      return true;
+    }
+
+    if (mCurrentContainer->IsHTMLListItem() &&
+        mCurrentContainer->AsHTMLListItem()->Bullet() == link) {
+      mCurrentStartOffset = 0;
+      NormalizeBackward();
+      return true;
+    }
+  }
+
+  return false;
+}
+
+int32_t HyperTextIterator::SegmentLength() {
+  int32_t endOffset = mCurrentEndOffset < 0
+                          ? mCurrentContainer->CharacterCount()
+                          : mCurrentEndOffset;
+
+  return endOffset - mCurrentStartOffset;
+}
+
+int32_t HyperTextIterator::NextLinkOffset() {
+  int32_t linkCount = mCurrentContainer->LinkCount();
+  for (int32_t i = 0; i < linkCount; i++) {
+    LocalAccessible* link = mCurrentContainer->LinkAt(i);
+    MOZ_ASSERT(link);
+    int32_t linkStartOffset = link->StartOffset();
+    if (mCurrentStartOffset < linkStartOffset) {
+      return linkStartOffset;
+    }
+  }
+
+  return -1;
+}
+
+bool HyperTextIterator::Next() {
+  if (!mCurrentContainer->Document()->HasLoadState(
+          DocAccessible::eTreeConstructed)) {
+    // If the accessible tree is still being constructed the text tree
+    // is not in a traversable state yet.
+    return false;
+  }
+
+  if (mCurrentContainer == mEndContainer &&
+      (mCurrentEndOffset == -1 || mEndOffset <= mCurrentEndOffset)) {
+    return false;
+  } else {
+    mCurrentStartOffset = mCurrentEndOffset;
+    NormalizeForward();
+  }
+
+  int32_t nextLinkOffset = NextLinkOffset();
+  if (mCurrentContainer == mEndContainer &&
+      (nextLinkOffset == -1 || nextLinkOffset > mEndOffset)) {
+    mCurrentEndOffset =
+        mEndOffset < 0 ? mEndContainer->CharacterCount() : mEndOffset;
+  } else {
+    mCurrentEndOffset = nextLinkOffset < 0 ? mCurrentContainer->CharacterCount()
+                                           : nextLinkOffset;
+  }
+
+  return mCurrentStartOffset != mCurrentEndOffset;
+}
+
+void HyperTextAccessibleWrap::TextForRange(nsAString& aText,
+                                           int32_t aStartOffset,
+                                           HyperTextAccessible* aEndContainer,
+                                           int32_t aEndOffset) {
+  if (IsHTMLListItem()) {
+    LocalAccessible* maybeBullet = GetChildAtOffset(aStartOffset - 1);
+    if (maybeBullet) {
+      LocalAccessible* bullet = AsHTMLListItem()->Bullet();
+      if (maybeBullet == bullet) {
+        TextSubstring(0, nsAccUtils::TextLength(bullet), aText);
+      }
+    }
+  }
+
+  HyperTextIterator iter(this, aStartOffset, aEndContainer, aEndOffset);
+  while (iter.Next()) {
+    nsAutoString text;
+    iter.mCurrentContainer->TextSubstring(iter.mCurrentStartOffset,
+                                          iter.mCurrentEndOffset, text);
+    aText.Append(text);
+  }
+}
+
+void HyperTextAccessibleWrap::AttributedTextForRange(
+    nsTArray<nsString>& aStrings, nsTArray<RefPtr<AccAttributes>>& aProperties,
+    nsTArray<LocalAccessible*>& aContainers, int32_t aStartOffset,
+    HyperTextAccessible* aEndContainer, int32_t aEndOffset) {
+  if (IsHTMLListItem()) {
+    LocalAccessible* maybeBullet = GetChildAtOffset(aStartOffset - 1);
+    if (maybeBullet) {
+      LocalAccessible* bullet = AsHTMLListItem()->Bullet();
+      if (maybeBullet == bullet) {
+        nsAutoString text;
+        TextSubstring(0, nsAccUtils::TextLength(bullet), text);
+
+        int32_t unusedAttrStartOffset, unusedAttrEndOffset;
+        RefPtr<AccAttributes> props =
+            TextAttributes(true, aStartOffset - 1, &unusedAttrStartOffset,
+                           &unusedAttrEndOffset);
+
+        aStrings.AppendElement(text);
+        aProperties.AppendElement(props);
+        aContainers.AppendElement(this);
+      }
+    }
+  }
+
+  HyperTextIterator iter(this, aStartOffset, aEndContainer, aEndOffset);
+  while (iter.Next()) {
+    int32_t attrStartOffset = 0;
+    int32_t attrEndOffset = iter.mCurrentStartOffset;
+    do {
+      int32_t oldEndOffset = attrEndOffset;
+      RefPtr<AccAttributes> props = iter.mCurrentContainer->TextAttributes(
+          true, attrEndOffset, &attrStartOffset, &attrEndOffset);
+
+      if (oldEndOffset == attrEndOffset) {
+        MOZ_ASSERT_UNREACHABLE("new attribute end offset should be different");
+        break;
+      }
+
+      nsAutoString text;
+      iter.mCurrentContainer->TextSubstring(
+          attrStartOffset < iter.mCurrentStartOffset ? iter.mCurrentStartOffset
+                                                     : attrStartOffset,
+          attrEndOffset < iter.mCurrentEndOffset ? attrEndOffset
+                                                 : iter.mCurrentEndOffset,
+          text);
+
+      aStrings.AppendElement(text);
+      aProperties.AppendElement(props);
+      aContainers.AppendElement(iter.mCurrentContainer);
+    } while (attrEndOffset < iter.mCurrentEndOffset);
+  }
+}
+
+LayoutDeviceIntRect HyperTextAccessibleWrap::BoundsForRange(
+    int32_t aStartOffset, HyperTextAccessible* aEndContainer,
+    int32_t aEndOffset) {
+  LayoutDeviceIntRect rect;
+  HyperTextIterator iter(this, aStartOffset, aEndContainer, aEndOffset);
+  while (iter.Next()) {
+    LayoutDeviceIntRect stringRect = iter.mCurrentContainer->TextBounds(
+        iter.mCurrentStartOffset, iter.mCurrentEndOffset);
+    rect.UnionRect(rect, stringRect);
+  }
+
+  return rect;
+}
+
+int32_t HyperTextAccessibleWrap::LengthForRange(
+    int32_t aStartOffset, HyperTextAccessible* aEndContainer,
+    int32_t aEndOffset) {
+  int32_t length = 0;
+  HyperTextIterator iter(this, aStartOffset, aEndContainer, aEndOffset);
+  while (iter.Next()) {
+    length += iter.SegmentLength();
+  }
+
+  return length;
+}
+
+void HyperTextAccessibleWrap::OffsetAtIndex(int32_t aIndex,
+                                            HyperTextAccessible** aContainer,
+                                            int32_t* aOffset) {
+  int32_t index = aIndex;
+  HyperTextIterator iter(this, 0, this, CharacterCount());
+  while (iter.Next()) {
+    int32_t segmentLength = iter.SegmentLength();
+    if (index <= segmentLength) {
+      *aContainer = iter.mCurrentContainer;
+      *aOffset = iter.mCurrentStartOffset + index;
+      break;
+    }
+    index -= segmentLength;
+  }
+}
+
+void HyperTextAccessibleWrap::RangeAt(int32_t aOffset, EWhichRange aRangeType,
+                                      HyperTextAccessible** aStartContainer,
+                                      int32_t* aStartOffset,
+                                      HyperTextAccessible** aEndContainer,
+                                      int32_t* aEndOffset) {
+  switch (aRangeType) {
+    case EWhichRange::eLeftWord:
+      LeftWordAt(aOffset, aStartContainer, aStartOffset, aEndContainer,
+                 aEndOffset);
+      break;
+    case EWhichRange::eRightWord:
+      RightWordAt(aOffset, aStartContainer, aStartOffset, aEndContainer,
+                  aEndOffset);
+      break;
+    case EWhichRange::eLine:
+    case EWhichRange::eLeftLine:
+      LineAt(aOffset, false, aStartContainer, aStartOffset, aEndContainer,
+             aEndOffset);
+      break;
+    case EWhichRange::eRightLine:
+      LineAt(aOffset, true, aStartContainer, aStartOffset, aEndContainer,
+             aEndOffset);
+      break;
+    case EWhichRange::eParagraph:
+      ParagraphAt(aOffset, aStartContainer, aStartOffset, aEndContainer,
+                  aEndOffset);
+      break;
+    case EWhichRange::eStyle:
+      StyleAt(aOffset, aStartContainer, aStartOffset, aEndContainer,
+              aEndOffset);
+      break;
+    default:
+      break;
+  }
+}
+
+void HyperTextAccessibleWrap::LeftWordAt(int32_t aOffset,
+                                         HyperTextAccessible** aStartContainer,
+                                         int32_t* aStartOffset,
+                                         HyperTextAccessible** aEndContainer,
+                                         int32_t* aEndOffset) {
+  TextPoint here(this, aOffset);
+  TextPoint start =
+      FindTextPoint(aOffset, eDirPrevious, eSelectWord, eStartWord);
+  if (!start.mContainer) {
+    return;
+  }
+
+  auto* startContainer = static_cast<HyperTextAccessibleWrap*>(
+      start.mContainer->AsLocal()->AsHyperText());
+  if ((NativeState() & states::EDITABLE) &&
+      !(startContainer->NativeState() & states::EDITABLE)) {
+    // The word search crossed an editable boundary. Return the first word of
+    // the editable root.
+    return EditableRoot()->RightWordAt(0, aStartContainer, aStartOffset,
+                                       aEndContainer, aEndOffset);
+  }
+
+  TextPoint end = startContainer->FindTextPoint(start.mOffset, eDirNext,
+                                                eSelectWord, eEndWord);
+  if (end < here) {
+    *aStartContainer = end.mContainer->AsLocal()->AsHyperText();
+    *aEndContainer = here.mContainer->AsLocal()->AsHyperText();
+    *aStartOffset = end.mOffset;
+    *aEndOffset = here.mOffset;
+  } else {
+    *aStartContainer = startContainer;
+    *aEndContainer = end.mContainer->AsLocal()->AsHyperText();
+    *aStartOffset = start.mOffset;
+    *aEndOffset = end.mOffset;
+  }
+}
+
+void HyperTextAccessibleWrap::RightWordAt(int32_t aOffset,
+                                          HyperTextAccessible** aStartContainer,
+                                          int32_t* aStartOffset,
+                                          HyperTextAccessible** aEndContainer,
+                                          int32_t* aEndOffset) {
+  TextPoint here(this, aOffset);
+  TextPoint end = FindTextPoint(aOffset, eDirNext, eSelectWord, eEndWord);
+  if (!end.mContainer || end < here || here == end) {
+    // If we didn't find a word end, or if we wrapped around (bug 1652833),
+    // return with no result.
+    return;
+  }
+
+  auto* endContainer = static_cast<HyperTextAccessibleWrap*>(
+      end.mContainer->AsLocal()->AsHyperText());
+  if ((NativeState() & states::EDITABLE) &&
+      !(endContainer->NativeState() & states::EDITABLE)) {
+    // The word search crossed an editable boundary. Return with no result.
+    return;
+  }
+
+  TextPoint start = endContainer->FindTextPoint(end.mOffset, eDirPrevious,
+                                                eSelectWord, eStartWord);
+
+  if (here < start) {
+    *aStartContainer = here.mContainer->AsLocal()->AsHyperText();
+    *aEndContainer = start.mContainer->AsLocal()->AsHyperText();
+    *aStartOffset = here.mOffset;
+    *aEndOffset = start.mOffset;
+  } else {
+    *aStartContainer = start.mContainer->AsLocal()->AsHyperText();
+    *aEndContainer = endContainer;
+    *aStartOffset = start.mOffset;
+    *aEndOffset = end.mOffset;
+  }
+}
+
+void HyperTextAccessibleWrap::LineAt(int32_t aOffset, bool aNextLine,
+                                     HyperTextAccessible** aStartContainer,
+                                     int32_t* aStartOffset,
+                                     HyperTextAccessible** aEndContainer,
+                                     int32_t* aEndOffset) {
+  TextPoint here(this, aOffset);
+  TextPoint end =
+      FindTextPoint(aOffset, eDirNext, eSelectEndLine, eDefaultBehavior);
+  if (!end.mContainer || end < here) {
+    // If we didn't find a word end, or if we wrapped around (bug 1652833),
+    // return with no result.
+    return;
+  }
+
+  auto* endContainer = static_cast<HyperTextAccessibleWrap*>(
+      end.mContainer->AsLocal()->AsHyperText());
+  TextPoint start = endContainer->FindTextPoint(
+      end.mOffset, eDirPrevious, eSelectBeginLine, eDefaultBehavior);
+
+  if (!aNextLine && here < start) {
+    start = FindTextPoint(aOffset, eDirPrevious, eSelectBeginLine,
+                          eDefaultBehavior);
+    if (!start.mContainer) {
+      return;
+    }
+
+    auto* startContainer = static_cast<HyperTextAccessibleWrap*>(
+        start.mContainer->AsLocal()->AsHyperText());
+    end = startContainer->FindTextPoint(start.mOffset, eDirNext, eSelectEndLine,
+                                        eDefaultBehavior);
+  }
+
+  *aStartContainer = start.mContainer->AsLocal()->AsHyperText();
+  *aEndContainer = end.mContainer->AsLocal()->AsHyperText();
+  *aStartOffset = start.mOffset;
+  *aEndOffset = end.mOffset;
+}
+
+void HyperTextAccessibleWrap::ParagraphAt(int32_t aOffset,
+                                          HyperTextAccessible** aStartContainer,
+                                          int32_t* aStartOffset,
+                                          HyperTextAccessible** aEndContainer,
+                                          int32_t* aEndOffset) {
+  TextPoint here(this, aOffset);
+  TextPoint end =
+      FindTextPoint(aOffset, eDirNext, eSelectParagraph, eDefaultBehavior);
+
+  if (!end.mContainer || end < here) {
+    // If we didn't find a word end, or if we wrapped around (bug 1652833),
+    // return with no result.
+    return;
+  }
+
+  if (end.mOffset == -1 && LocalParent() && LocalParent()->IsHyperText()) {
+    // If end offset is -1 we didn't find a paragraph boundary.
+    // This must be an inline container, go to its parent to
+    // retrieve paragraph boundaries.
+    static_cast<HyperTextAccessibleWrap*>(LocalParent()->AsHyperText())
+        ->ParagraphAt(StartOffset(), aStartContainer, aStartOffset,
+                      aEndContainer, aEndOffset);
+    return;
+  }
+
+  auto* endContainer = static_cast<HyperTextAccessibleWrap*>(
+      end.mContainer->AsLocal()->AsHyperText());
+  TextPoint start = static_cast<HyperTextAccessibleWrap*>(endContainer)
+                        ->FindTextPoint(end.mOffset, eDirPrevious,
+                                        eSelectParagraph, eDefaultBehavior);
+
+  *aStartContainer = start.mContainer->AsLocal()->AsHyperText();
+  *aEndContainer = endContainer;
+  *aStartOffset = start.mOffset;
+  *aEndOffset = end.mOffset;
+}
+
+void HyperTextAccessibleWrap::StyleAt(int32_t aOffset,
+                                      HyperTextAccessible** aStartContainer,
+                                      int32_t* aStartOffset,
+                                      HyperTextAccessible** aEndContainer,
+                                      int32_t* aEndOffset) {
+  // Get the range of the text leaf at this offset.
+  // A text leaf represents a stretch of like-styled text.
+  auto leaf = LeafAtOffset(aOffset);
+  if (!leaf) {
+    return;
+  }
+
+  MOZ_ASSERT(leaf->LocalParent()->IsHyperText());
+  HyperTextAccessibleWrap* container =
+      static_cast<HyperTextAccessibleWrap*>(leaf->LocalParent()->AsHyperText());
+  if (!container) {
+    return;
+  }
+
+  *aStartContainer = *aEndContainer = container;
+  container->RangeOfChild(leaf, aStartOffset, aEndOffset);
+}
+
+void HyperTextAccessibleWrap::NextClusterAt(
+    int32_t aOffset, HyperTextAccessible** aNextContainer,
+    int32_t* aNextOffset) {
+  TextPoint here(this, aOffset);
+  TextPoint next =
+      FindTextPoint(aOffset, eDirNext, eSelectCluster, eDefaultBehavior);
+
+  if ((next.mOffset == nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT &&
+       next.mContainer == Document()) ||
+      (next < here)) {
+    // If we reached the end of the doc, or if we wrapped to the start of the
+    // doc return given offset as-is.
+    *aNextContainer = this;
+    *aNextOffset = aOffset;
+  } else {
+    *aNextContainer = next.mContainer->AsLocal()->AsHyperText();
+    *aNextOffset = next.mOffset;
+  }
+}
+
+void HyperTextAccessibleWrap::PreviousClusterAt(
+    int32_t aOffset, HyperTextAccessible** aPrevContainer,
+    int32_t* aPrevOffset) {
+  TextPoint prev =
+      FindTextPoint(aOffset, eDirPrevious, eSelectCluster, eDefaultBehavior);
+  *aPrevContainer = prev.mContainer->AsLocal()->AsHyperText();
+  *aPrevOffset = prev.mOffset;
+}
+
+void HyperTextAccessibleWrap::RangeOfChild(LocalAccessible* aChild,
+                                           int32_t* aStartOffset,
+                                           int32_t* aEndOffset) {
+  MOZ_ASSERT(aChild->LocalParent() == this);
+  *aStartOffset = *aEndOffset = -1;
+  int32_t index = GetIndexOf(aChild);
+  if (index != -1) {
+    *aStartOffset = GetChildOffset(index);
+    // If this is the last child index + 1 will return the total
+    // chracter count.
+    *aEndOffset = GetChildOffset(index + 1);
+  }
+}
+
+LocalAccessible* HyperTextAccessibleWrap::LeafAtOffset(int32_t aOffset) {
+  HyperTextAccessible* text = this;
+  LocalAccessible* child = nullptr;
+  // The offset needed should "attach" the previous accessible if
+  // in between two accessibles.
+  int32_t innerOffset = aOffset > 0 ? aOffset - 1 : aOffset;
+  do {
+    int32_t childIdx = text->GetChildIndexAtOffset(innerOffset);
+    if (childIdx == -1) {
+      return text;
+    }
+
+    child = text->LocalChildAt(childIdx);
+    if (!child || nsAccUtils::MustPrune(text)) {
+      return text;
+    }
+
+    innerOffset -= text->GetChildOffset(childIdx);
+
+    text = child->AsHyperText();
+  } while (text);
+
+  return child;
+}
+
+void HyperTextAccessibleWrap::SelectRange(int32_t aStartOffset,
+                                          HyperTextAccessible* aEndContainer,
+                                          int32_t aEndOffset) {
+  TextRange range(this, this, aStartOffset, aEndContainer, aEndOffset);
+  range.SetSelectionAt(0);
+}
+
+TextPoint HyperTextAccessibleWrap::FindTextPoint(
+    int32_t aOffset, nsDirection aDirection, nsSelectionAmount aAmount,
+    EWordMovementType aWordMovementType) {
+  // Layout can remain trapped in an editable. We normalize out of
+  // it if we are in its last offset.
+  HyperTextIterator iter(this, aOffset, this, CharacterCount());
+  if (aDirection == eDirNext) {
+    iter.NormalizeForward();
+  } else {
+    iter.NormalizeBackward();
+  }
+
+  // Find a leaf accessible frame to start with. PeekOffset wants this.
+  HyperTextAccessible* text = iter.mCurrentContainer;
+  LocalAccessible* child = nullptr;
+  int32_t innerOffset = iter.mCurrentStartOffset;
+
+  do {
+    int32_t childIdx = text->GetChildIndexAtOffset(innerOffset);
+
+    // We can have an empty text leaf as our only child. Since empty text
+    // leaves are not accessible we then have no children, but 0 is a valid
+    // innerOffset.
+    if (childIdx == -1) {
+      NS_ASSERTION(innerOffset == 0 && !text->ChildCount(), "No childIdx?");
+      return TextPoint(text, 0);
+    }
+
+    child = text->LocalChildAt(childIdx);
+    if (child->IsHyperText() && !child->ChildCount()) {
+      // If this is a childless hypertext, jump to its
+      // previous or next sibling, depending on
+      // direction.
+      if (aDirection == eDirPrevious && childIdx > 0) {
+        child = text->LocalChildAt(--childIdx);
+      } else if (aDirection == eDirNext &&
+                 childIdx + 1 < static_cast<int32_t>(text->ChildCount())) {
+        child = text->LocalChildAt(++childIdx);
+      }
+    }
+
+    int32_t childOffset = text->GetChildOffset(childIdx);
+
+    if (child->IsHyperText() && aDirection == eDirPrevious && childIdx > 0 &&
+        innerOffset - childOffset == 0) {
+      // If we are searching backwards, and this is the begining of a
+      // segment, get the previous sibling so that layout will start
+      // its search there.
+      childIdx--;
+      innerOffset -= text->GetChildOffset(childIdx);
+      child = text->LocalChildAt(childIdx);
+    } else {
+      innerOffset -= childOffset;
+    }
+
+    text = child->AsHyperText();
+  } while (text);
+
+  nsIFrame* childFrame = child->GetFrame();
+  if (!childFrame) {
+    NS_ERROR("No child frame");
+    return TextPoint(this, aOffset);
+  }
+
+  int32_t innerContentOffset = innerOffset;
+  if (child->IsTextLeaf()) {
+    NS_ASSERTION(childFrame->IsTextFrame(), "Wrong frame!");
+    RenderedToContentOffset(childFrame, innerOffset, &innerContentOffset);
+  }
+
+  nsIFrame* frameAtOffset = childFrame;
+  int32_t offsetInFrame = 0;
+  childFrame->GetChildFrameContainingOffset(innerContentOffset, true,
+                                            &offsetInFrame, &frameAtOffset);
+  if (aDirection == eDirPrevious && offsetInFrame == 0) {
+    // If we are searching backwards, and we are at the start of a frame,
+    // get the previous continuation frame.
+    if (nsIFrame* prevInContinuation = frameAtOffset->GetPrevContinuation()) {
+      frameAtOffset = prevInContinuation;
+    }
+  }
+
+  const bool kIsJumpLinesOk = true;       // okay to jump lines
+  const bool kIsScrollViewAStop = false;  // do not stop at scroll views
+  const bool kIsKeyboardSelect = true;    // is keyboard selection
+  const bool kIsVisualBidi = false;       // use visual order for bidi text
+  nsPeekOffsetStruct pos(
+      aAmount, aDirection, innerContentOffset, nsPoint(0, 0), kIsJumpLinesOk,
+      kIsScrollViewAStop, kIsKeyboardSelect, kIsVisualBidi, false,
+      nsPeekOffsetStruct::ForceEditableRegion::No, aWordMovementType, false);
+  nsresult rv = frameAtOffset->PeekOffset(&pos);
+
+  // PeekOffset fails on last/first lines of the text in certain cases.
+  if (NS_FAILED(rv) && aAmount == eSelectLine) {
+    pos.mAmount = aDirection == eDirNext ? eSelectEndLine : eSelectBeginLine;
+    frameAtOffset->PeekOffset(&pos);
+  }
+  if (!pos.mResultContent) {
+    NS_ERROR("No result content!");
+    return TextPoint(this, aOffset);
+  }
+
+  if (aDirection == eDirNext &&
+      nsContentUtils::PositionIsBefore(pos.mResultContent, mContent, nullptr,
+                                       nullptr)) {
+    // Bug 1652833 makes us sometimes return the first element on the doc.
+    return TextPoint(Document(), nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT);
+  }
+
+  HyperTextAccessible* container =
+      nsAccUtils::GetTextContainer(pos.mResultContent);
+  int32_t offset = container ? container->DOMPointToOffset(
+                                   pos.mResultContent, pos.mContentOffset,
+                                   aDirection == eDirNext)
+                             : 0;
+  return TextPoint(container, offset);
+}
+
+HyperTextAccessibleWrap* HyperTextAccessibleWrap::EditableRoot() {
+  LocalAccessible* editable = nullptr;
+  for (LocalAccessible* acc = this; acc && acc != Document();
+       acc = acc->LocalParent()) {
+    if (acc->NativeState() & states::EDITABLE) {
+      editable = acc;
+    } else {
+      break;
+    }
+  }
+
+  return static_cast<HyperTextAccessibleWrap*>(editable->AsHyperText());
+}