Revert "Bug 1981349 - Add referenceTarget support for label/for, label wrapped and output/for. r=credential-management-reviewers,webidl,dimi,Jamie,smaug" for causing accessibility crashes (bug 2008970)

This reverts commit d46abe6.

Revert "Bug 1981346 - Add referenceTarget support for the form attribute. r=credential-management-reviewers,webidl,dimi,Jamie,smaug"

This reverts commit df11a46.

Revert "Bug 1981345 - Implement referenceTarget support for multiple element attributes. r=dom-core,Jamie,smaug"

This reverts commit 89cc779.

Revert "Bug 1984685 - Refactor: consistently return Maybe<nsTArray<RefPtr<Element>>> when getting attr-associated elements, and key AttrRelProviders on nsAtom rather than nsString. r=dom-core,morgan,Jamie,smaug"

This reverts commit 33130e7.

Revert "Bug 1981344 - Implement referenceTarget support for single-element attributes. r=dom-core,credential-management-reviewers,webidl,layout-reviewers,emilio,keithamus,smaug,mtigley"

This reverts commit d6440c4.

Revert "Bug 1983766 - Split single element attribute getters into bindings/internals versions. r=dom-core,credential-management-reviewers,webidl,layout-reviewers,smaug,keithamus,jwatt,mtigley"

This reverts commit 83b70e0.

Revert "Bug 1989323 - Make `referenceTarget` IDL attributes on ShadowRoot, HTMLTemplateElement and ShadowRootInit nullable. r=dom-core,webidl,saschanaz,smaug"

This reverts commit 3a0b291.

Author: Sandor Molnar

accessible/base/AccIterator.cpp

@@ -14,9 +14,7 @@
 #include "mozilla/a11y/DocAccessibleParent.h"
 #include "mozilla/dom/DocumentOrShadowRoot.h"
 #include "mozilla/dom/Element.h"
-#include "mozilla/dom/ElementInternals.h"
 #include "mozilla/dom/HTMLLabelElement.h"
-#include "mozilla/dom/TreeOrderedArrayInlines.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
@@ -78,76 +76,69 @@ RelatedAccIterator::RelatedAccIterator(DocAccessible* aDocument,
                                        nsAtom* aRelAttr)
     : mDocument(aDocument),
       mDependentContent(aDependentContent),
-      mRelAttr(aRelAttr) {}
-
-void RelatedAccIterator::Initialize() {
-  nsIContent* content = mDependentContent;
-  dom::DocumentOrShadowRoot* root =
-      content->GetUncomposedDocOrConnectedShadowRoot();
-
-  while (root) {
-    if (nsAtom* id = content->GetID()) {
-      DocAccessible::AttrRelProviders* idProviders =
-          mDocument->GetRelProviders(content->AsElement(), id);
-
-      if (idProviders) {
-        for (auto& provider : *idProviders) {
-          if (mRelAttr && provider->mRelAttr != mRelAttr) {
-            continue;
-          }
-
-          mRelatedNodes.Insert(*provider->mContent);
-        }
-      }
-    }
-    if (auto result = mDocument->mDependentElementsMap.Lookup(content)) {
-      DocAccessible::AttrRelProviders* elementProviders = &result.Data();
-      if (elementProviders) {
-        for (auto& provider : *elementProviders) {
-          if (mRelAttr && provider->mRelAttr != mRelAttr) {
-            continue;
-          }
-
-          if (nsCoreUtils::IsDescendantOfAnyShadowIncludingAncestor(
-                  content, provider->mContent)) {
-            mRelatedNodes.Insert(*provider->mContent);
-          }
-        }
-      }
-    }
-    dom::ShadowRoot* shadow = content->GetContainingShadow();
-    dom::Element* element =
-        content->IsElement() ? content->AsElement() : nullptr;
-    if (shadow && element && element == shadow->GetReferenceTargetElement()) {
-      content = shadow->Host();
-      root = content->GetUncomposedDocOrConnectedShadowRoot();
-    } else {
-      root = nullptr;
-    }
+      mRelAttr(aRelAttr),
+      mProviders(nullptr),
+      mIndex(0),
+      mIsWalkingDependentElements(false) {
+  nsAutoString id;
+  if (aDependentContent->IsElement() &&
+      aDependentContent->AsElement()->GetAttr(nsGkAtoms::id, id)) {
+    mProviders = mDocument->GetRelProviders(aDependentContent->AsElement(), id);
   }
-
-  mInitialized = true;
 }
 
 LocalAccessible* RelatedAccIterator::Next() {
-  if (!mInitialized) {
-    Initialize();
+  if (!mProviders || mIndex == mProviders->Length()) {
+    if (mIsWalkingDependentElements) {
+      // We've walked both dependent ids and dependent elements, so there are
+      // no more targets.
+      return nullptr;
+    }
+    // We've returned all dependent ids, but there might be dependent elements
+    // too. Walk those next.
+    mIsWalkingDependentElements = true;
+    mIndex = 0;
+    if (auto providers =
+            mDocument->mDependentElementsMap.Lookup(mDependentContent)) {
+      mProviders = &providers.Data();
+    } else {
+      mProviders = nullptr;
+      return nullptr;
+    }
   }
 
-  while (mNextIndex < mRelatedNodes.Length()) {
-    nsIContent* nextContent = mRelatedNodes[mNextIndex];
-    mNextIndex++;
+  while (mIndex < mProviders->Length()) {
+    const auto& provider = (*mProviders)[mIndex++];
 
-    LocalAccessible* next = mDocument->GetAccessible(nextContent);
-    if (next) {
-      return next;
+    // Return related accessible for the given attribute.
+    if (mRelAttr && provider->mRelAttr != mRelAttr) {
+      continue;
+    }
+    // If we're walking elements (not ids), the explicitly set attr-element
+    // `mDependentContent` must be a descendant of any of the refering element
+    // `mProvider->mContent`'s shadow-including ancestors.
+    if (mIsWalkingDependentElements &&
+        !nsCoreUtils::IsDescendantOfAnyShadowIncludingAncestor(
+            mDependentContent, provider->mContent)) {
+      continue;
+    }
+    LocalAccessible* related = mDocument->GetAccessible(provider->mContent);
+    if (related) {
+      return related;
     }
 
-    if (nextContent == mDocument->GetContent()) {
+    // If the document content is pointed by relation then return the
+    // document itself.
+    if (provider->mContent == mDocument->GetContent()) {
       return mDocument;
     }
   }
 
+  // We exhausted mProviders without returning anything.
+  if (!mIsWalkingDependentElements) {
+    // Call this function again to start walking the dependent elements.
+    return Next();
+  }
   return nullptr;
 }
 
@@ -165,7 +156,7 @@ HTMLLabelIterator::HTMLLabelIterator(DocAccessible* aDocument,
 bool HTMLLabelIterator::IsLabel(LocalAccessible* aLabel) {
   dom::HTMLLabelElement* labelEl =
       dom::HTMLLabelElement::FromNode(aLabel->GetContent());
-  return labelEl && labelEl->GetLabeledElementInternal() == mAcc->GetContent();
+  return labelEl && labelEl->GetControl() == mAcc->GetContent();
 }
 
 LocalAccessible* HTMLLabelIterator::Next() {
@@ -179,21 +170,7 @@ LocalAccessible* HTMLLabelIterator::Next() {
   }
 
   // Ignore ancestor label on not widget accessible.
-  if (mLabelFilter == eSkipAncestorLabel) {
-    return nullptr;
-  }
-
-  if (!mAcc->IsWidget()) {
-    nsIContent* content = mAcc->GetContent();
-    if (!content->IsElement()) {
-      return nullptr;
-    }
-    dom::Element* element = content->AsElement();
-    // <output> is not a widget but is labelable.
-    if (!element->IsLabelable()) {
-      return nullptr;
-    }
-  }
+  if (mLabelFilter == eSkipAncestorLabel || !mAcc->IsWidget()) return nullptr;
 
   // Go up tree to get a name of ancestor label if there is one (an ancestor
   // <label> implicitly points to us). Don't go up farther than form or
@@ -272,26 +249,71 @@ LocalAccessible* XULDescriptionIterator::Next() {
 AssociatedElementsIterator::AssociatedElementsIterator(DocAccessible* aDoc,
                                                        nsIContent* aContent,
                                                        nsAtom* aIDRefsAttr)
-    : mContent(aContent), mDoc(aDoc), mElemIdx(0) {
-  if (!mContent->IsElement()) {
-    return;
+    : mContent(aContent), mDoc(aDoc), mCurrIdx(0), mElemIdx(0) {
+  if (mContent->IsElement()) {
+    mContent->AsElement()->GetAttr(aIDRefsAttr, mIDs);
+    if (mIDs.IsEmpty() &&
+        (aria::AttrCharacteristicsFor(aIDRefsAttr) & ATTR_REFLECT_ELEMENTS)) {
+      nsAccUtils::GetARIAElementsAttr(mContent->AsElement(), aIDRefsAttr,
+                                      mElements);
+    }
+  }
+}
+
+const nsDependentSubstring AssociatedElementsIterator::NextID() {
+  for (; mCurrIdx < mIDs.Length(); mCurrIdx++) {
+    if (!NS_IsAsciiWhitespace(mIDs[mCurrIdx])) break;
+  }
+
+  if (mCurrIdx >= mIDs.Length()) return nsDependentSubstring();
+
+  nsAString::index_type idStartIdx = mCurrIdx;
+  while (++mCurrIdx < mIDs.Length()) {
+    if (NS_IsAsciiWhitespace(mIDs[mCurrIdx])) break;
   }
-  auto elements =
-      mContent->AsElement()->GetAttrAssociatedElementsInternal(aIDRefsAttr);
-  if (elements) {
-    mElements.SwapElements(*elements);
-  } else if (auto* element = nsGenericHTMLElement::FromNode(aContent)) {
-    if (auto* internals = element->GetInternals()) {
-      elements = internals->GetAttrElements(aIDRefsAttr);
-      if (elements) {
-        mElements.SwapElements(*elements);
+
+  return Substring(mIDs, idStartIdx, mCurrIdx++ - idStartIdx);
+}
+
+dom::Element* AssociatedElementsIterator::NextElem() {
+  while (true) {
+    const nsDependentSubstring id = NextID();
+    if (id.IsEmpty()) break;
+
+    dom::Element* refContent = GetElem(id);
+    if (refContent) return refContent;
+  }
+
+  while (dom::Element* element = mElements.SafeElementAt(mElemIdx++)) {
+    if (nsCoreUtils::IsDescendantOfAnyShadowIncludingAncestor(element,
+                                                              mContent)) {
+      return element;
+    }
+  }
+
+  return nullptr;
+}
+
+dom::Element* AssociatedElementsIterator::GetElem(nsIContent* aContent,
+                                                  const nsAString& aID) {
+  // Get elements in DOM tree by ID attribute if this is an explicit content.
+  // In case of bound element check its anonymous subtree.
+  if (!aContent->IsInNativeAnonymousSubtree()) {
+    dom::DocumentOrShadowRoot* docOrShadowRoot =
+        aContent->GetUncomposedDocOrConnectedShadowRoot();
+    if (docOrShadowRoot) {
+      dom::Element* refElm = docOrShadowRoot->GetElementById(aID);
+      if (refElm) {
+        return refElm;
       }
     }
   }
+  return nullptr;
 }
 
-dom::Element* AssociatedElementsIterator::NextElem() {
-  return mElements.SafeElementAt(mElemIdx++);
+dom::Element* AssociatedElementsIterator::GetElem(
+    const nsDependentSubstring& aID) {
+  return GetElem(mContent, aID);
 }
 
 LocalAccessible* AssociatedElementsIterator::Next() {

accessible/base/AccIterator.h

@@ -9,10 +9,7 @@
 
 #include "Filters.h"
 #include "mozilla/a11y/DocAccessible.h"
-#include "mozilla/dom/Element.h"
 #include "nsTArray.h"
-#include "nsContentUtils.h"
-#include "mozilla/dom/TreeOrderedArray.h"
 
 #include <memory>
 
@@ -21,8 +18,7 @@ class nsITreeView;
 namespace mozilla {
 namespace dom {
 class Element;
-class HTMLLabelElement;
-}  // namespace dom
+}
 
 namespace a11y {
 class DocAccessibleParent;
@@ -106,16 +102,12 @@ class RelatedAccIterator : public AccIterable {
   RelatedAccIterator(const RelatedAccIterator&);
   RelatedAccIterator& operator=(const RelatedAccIterator&);
 
-  void Initialize();
-
   DocAccessible* mDocument;
   nsIContent* mDependentContent;
   nsAtom* mRelAttr;
-
-  dom::TreeOrderedArray<nsIContent*, TreeKind::ShadowIncludingDOM>
-      mRelatedNodes;
-  size_t mNextIndex = 0;
-  bool mInitialized = false;
+  DocAccessible::AttrRelProviders* mProviders;
+  uint32_t mIndex;
+  bool mIsWalkingDependentElements;
 };
 
 /**
@@ -225,11 +217,22 @@ class AssociatedElementsIterator : public AccIterable {
                              nsAtom* aIDRefsAttr);
   virtual ~AssociatedElementsIterator() {}
 
+  /**
+   * Return next ID.
+   */
+  const nsDependentSubstring NextID();
+
   /**
    * Return next element.
    */
   dom::Element* NextElem();
 
+  /**
+   * Return the element with the given ID.
+   */
+  static dom::Element* GetElem(nsIContent* aContent, const nsAString& aID);
+  dom::Element* GetElem(const nsDependentSubstring& aID);
+
   // AccIterable
   virtual LocalAccessible* Next() override;
 
@@ -238,9 +241,11 @@ class AssociatedElementsIterator : public AccIterable {
   AssociatedElementsIterator(const AssociatedElementsIterator&);
   AssociatedElementsIterator operator=(const AssociatedElementsIterator&);
 
+  nsString mIDs;
   nsIContent* mContent;
   DocAccessible* mDoc;
-  nsTArray<RefPtr<dom::Element>> mElements;
+  nsAString::index_type mCurrIdx;
+  nsTArray<dom::Element*> mElements;
   uint32_t mElemIdx;
 };
 

accessible/base/nsAccUtils.cpp

@@ -579,19 +579,20 @@ const nsAttrValue* nsAccUtils::GetARIAAttr(dom::Element* aElement,
   return defaults->GetAttr(aName, kNameSpaceID_None);
 }
 
-Maybe<nsTArray<RefPtr<dom::Element>>> nsAccUtils::GetARIAElementsAttr(
-    dom::Element* aElement, nsAtom* aName) {
+bool nsAccUtils::GetARIAElementsAttr(dom::Element* aElement, nsAtom* aName,
+                                     nsTArray<dom::Element*>& aElements) {
   if (aElement->HasAttr(aName)) {
-    return aElement->GetExplicitlySetAttrElements(aName);
+    aElement->GetExplicitlySetAttrElements(aName, aElements);
+    return true;
   }
 
   if (auto* element = nsGenericHTMLElement::FromNode(aElement)) {
     if (auto* internals = element->GetInternals()) {
-      return internals->GetAttrElements(aName);
+      return internals->GetAttrElements(aName, aElements);
     }
   }
 
-  return Nothing();
+  return false;
 }
 
 bool nsAccUtils::ARIAAttrValueIs(dom::Element* aElement, const nsAtom* aName,

accessible/base/nsAccUtils.h

@@ -289,8 +289,8 @@ class nsAccUtils {
                           nsAString& aResult);
   static const nsAttrValue* GetARIAAttr(dom::Element* aElement,
                                         const nsAtom* aName);
-  static Maybe<nsTArray<RefPtr<dom::Element>>> GetARIAElementsAttr(
-      dom::Element* aElement, nsAtom* aName);
+  static bool GetARIAElementsAttr(dom::Element* aElement, nsAtom* aName,
+                                  nsTArray<dom::Element*>& aElements);
   static bool ARIAAttrValueIs(dom::Element* aElement, const nsAtom* aName,
                               const nsAString& aValue,
                               nsCaseTreatment aCaseSensitive);

accessible/base/nsAccessibilityService.cpp

@@ -242,7 +242,8 @@ static bool MustBeAccessible(nsIContent* aContent, DocAccessible* aDocument) {
 
     // If the given ID is referred by relation attribute then create an
     // Accessible for it.
-    if (nsAtom* id = aContent->GetID()) {
+    nsAutoString id;
+    if (nsCoreUtils::GetID(aContent, id) && !id.IsEmpty()) {
       return aDocument->IsDependentID(aContent->AsElement(), id);
     }
   }

accessible/base/nsCoreUtils.cpp

@@ -56,7 +56,7 @@ using mozilla::a11y::nsAccUtils;
 
 bool nsCoreUtils::IsLabelWithControl(nsIContent* aContent) {
   dom::HTMLLabelElement* label = dom::HTMLLabelElement::FromNode(aContent);
-  if (label && label->GetLabeledElementInternal()) return true;
+  if (label && label->GetControl()) return true;
 
   return false;
 }