accessible/generic/DocAccessible.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef mozilla_a11y_DocAccessible_h__
   7 #define mozilla_a11y_DocAccessible_h__
   8
   9 #include "HyperTextAccessible.h"
  10 #include "AccEvent.h"
  11
  12 #include "nsClassHashtable.h"
  13 #include "nsTHashMap.h"
  14 #include "mozilla/UniquePtr.h"
  15 #include "nsIDocumentObserver.h"
  16 #include "nsITimer.h"
  17 #include "nsTHashSet.h"
  18 #include "nsWeakReference.h"
  19
  20 const uint32_t kDefaultCacheLength = 128;
  21
  22 namespace mozilla {
  23
  24 class EditorBase;
  25 class PresShell;
  26
  27 namespace dom {
  28 class Document;
  29 }
  30
  31 namespace a11y {
  32
  33 class DocManager;
  34 class NotificationController;
  35 class DocAccessibleChild;
  36 class RelatedAccIterator;
  37 template <class Class, class... Args>
  38 class TNotification;
  39
  40 /**
  41  * An accessibility tree node that originated in a content process and
  42  * represents a document. Tabs, in-process iframes, and out-of-process iframes
  43  * all use this class to represent the doc they contain.
  44  */
  45 class DocAccessible : public HyperTextAccessible,
  46                       public nsIDocumentObserver,
  47                       public nsSupportsWeakReference {
  48   NS_DECL_ISUPPORTS_INHERITED
  49   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DocAccessible, LocalAccessible)
  50
  51  protected:
  52   typedef mozilla::dom::Document Document;
  53
  54  public:
  55   DocAccessible(Document* aDocument, PresShell* aPresShell);
  56
  57   // nsIDocumentObserver
  58   NS_DECL_NSIDOCUMENTOBSERVER
  59
  60   // LocalAccessible
  61   virtual void Init();
  62   virtual void Shutdown() override;
  63   virtual nsIFrame* GetFrame() const override;
  64   virtual nsINode* GetNode() const override;
  65   Document* DocumentNode() const { return mDocumentNode; }
  66
  67   virtual mozilla::a11y::ENameValueFlag Name(nsString& aName) const override;
  68   virtual void Description(nsString& aDescription) const override;
  69   virtual Accessible* FocusedChild() override;
  70   virtual mozilla::a11y::role NativeRole() const override;
  71   virtual uint64_t NativeState() const override;
  72   virtual uint64_t NativeInteractiveState() const override;
  73   virtual bool NativelyUnavailable() const override;
  74   virtual void ApplyARIAState(uint64_t* aState) const override;
  75
  76   virtual void TakeFocus() const override;
  77
  78 #ifdef A11Y_LOG
  79   virtual nsresult HandleAccEvent(AccEvent* aEvent) override;
  80 #endif
  81
  82   virtual nsRect RelativeBounds(nsIFrame** aRelativeFrame) const override;
  83
  84   // ActionAccessible
  85   virtual bool HasPrimaryAction() const override;
  86   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
  87
  88   // HyperTextAccessible
  89   virtual already_AddRefed<EditorBase> GetEditor() const override;
  90
  91   // DocAccessible
  92
  93   /**
  94    * Return document URL.
  95    */
  96   void URL(nsAString& aURL) const;
  97
  98   /**
  99    * Return DOM document title.
 100    */
 101   void Title(nsString& aTitle) const;
 102
 103   /**
 104    * Return DOM document mime type.
 105    */
 106   void MimeType(nsAString& aType) const;
 107   /**
 108    * Return DOM document type.
 109    */
 110   void DocType(nsAString& aType) const;
 111
 112   /**
 113    * Adds an entry to mQueuedCacheUpdates indicating aAcc requires
 114    * a cache update on domain aNewDomain. If we've already queued an update
 115    * for aAcc, aNewDomain is or'd with the existing domain(s)
 116    * and the map is updated. Otherwise, the entry is simply inserted.
 117    * This function also schedules processing on the controller.
 118    * Note that this CANNOT be used for anything which fires events, since events
 119    * must be fired after their associated cache update.
 120    */
 121   void QueueCacheUpdate(LocalAccessible* aAcc, uint64_t aNewDomain);
 122
 123   /**
 124    * Walks the mDependentIDsHashes list for the given accessible and
 125    * queues a CacheDomain::Relations cache update fore each related acc.
 126    * We call this when we observe an ID mutation or when an acc is bound
 127    * to its document.
 128    */
 129   void QueueCacheUpdateForDependentRelations(LocalAccessible* aAcc);
 130
 131   /**
 132    * Returns true if the instance has shutdown.
 133    */
 134   bool HasShutdown() const { return !mPresShell; }
 135
 136   /**
 137    * Return presentation shell for this document accessible.
 138    */
 139   PresShell* PresShellPtr() const {
 140     MOZ_DIAGNOSTIC_ASSERT(!HasShutdown());
 141     return mPresShell;
 142   }
 143
 144   /**
 145    * Return the presentation shell's context.
 146    */
 147   nsPresContext* PresContext() const;
 148
 149   /**
 150    * Return true if associated DOM document was loaded and isn't unloading.
 151    */
 152   bool IsContentLoaded() const;
 153
 154   bool IsHidden() const;
 155
 156   void SetViewportCacheDirty(bool aDirty) { mViewportCacheDirty = aDirty; }
 157
 158   /**
 159    * Document load states.
 160    */
 161   enum LoadState {
 162     // initial tree construction is pending
 163     eTreeConstructionPending = 0,
 164     // initial tree construction done
 165     eTreeConstructed = 1,
 166     // DOM document is loaded.
 167     eDOMLoaded = 1 << 1,
 168     // document is ready
 169     eReady = eTreeConstructed | eDOMLoaded,
 170     // document and all its subdocuments are ready
 171     eCompletelyLoaded = eReady | 1 << 2
 172   };
 173
 174   /**
 175    * Return true if the document has given document state.
 176    */
 177   bool HasLoadState(LoadState aState) const {
 178     return (mLoadState & static_cast<uint32_t>(aState)) ==
 179            static_cast<uint32_t>(aState);
 180   }
 181
 182   /**
 183    * Return a native window handler or pointer depending on platform.
 184    */
 185   virtual void* GetNativeWindow() const;
 186
 187   /**
 188    * Return the parent document.
 189    */
 190   DocAccessible* ParentDocument() const {
 191     return mParent ? mParent->Document() : nullptr;
 192   }
 193
 194   /**
 195    * Return the child document count.
 196    */
 197   uint32_t ChildDocumentCount() const { return mChildDocuments.Length(); }
 198
 199   /**
 200    * Return the child document at the given index.
 201    */
 202   DocAccessible* GetChildDocumentAt(uint32_t aIndex) const {
 203     return mChildDocuments.SafeElementAt(aIndex, nullptr);
 204   }
 205
 206   /**
 207    * Fire accessible event asynchronously.
 208    */
 209   void FireDelayedEvent(AccEvent* aEvent);
 210   void FireDelayedEvent(uint32_t aEventType, LocalAccessible* aTarget);
 211   void FireEventsOnInsertion(LocalAccessible* aContainer);
 212
 213   /**
 214    * Fire value change event on the given accessible if applicable.
 215    */
 216   void MaybeNotifyOfValueChange(LocalAccessible* aAccessible);
 217
 218   /**
 219    * Get/set the anchor jump.
 220    */
 221   LocalAccessible* AnchorJump() {
 222     return GetAccessibleOrContainer(mAnchorJumpElm);
 223   }
 224
 225   void SetAnchorJump(nsIContent* aTargetNode) { mAnchorJumpElm = aTargetNode; }
 226
 227   /**
 228    * Bind the child document to the tree.
 229    */
 230   void BindChildDocument(DocAccessible* aDocument);
 231
 232   /**
 233    * Process the generic notification.
 234    *
 235    * @note  The caller must guarantee that the given instance still exists when
 236    *          notification is processed.
 237    * @see   NotificationController::HandleNotification
 238    */
 239   template <class Class, class... Args>
 240   void HandleNotification(
 241       Class* aInstance,
 242       typename TNotification<Class, Args...>::Callback aMethod, Args*... aArgs);
 243
 244   /**
 245    * Return the cached accessible by the given DOM node if it's in subtree of
 246    * this document accessible or the document accessible itself, otherwise null.
 247    *
 248    * @return the accessible object
 249    */
 250   LocalAccessible* GetAccessible(nsINode* aNode) const;
 251
 252   /**
 253    * Return an accessible for the given node even if the node is not in
 254    * document's node map cache (like HTML area element).
 255    *
 256    * XXX: it should be really merged with GetAccessible().
 257    */
 258   LocalAccessible* GetAccessibleEvenIfNotInMap(nsINode* aNode) const;
 259   LocalAccessible* GetAccessibleEvenIfNotInMapOrContainer(nsINode* aNode) const;
 260
 261   /**
 262    * Return whether the given DOM node has an accessible or not.
 263    */
 264   bool HasAccessible(nsINode* aNode) const { return GetAccessible(aNode); }
 265
 266   /**
 267    * Return the cached accessible by the given unique ID within this document.
 268    *
 269    * @note   the unique ID matches with the uniqueID() of Accessible
 270    *
 271    * @param  aUniqueID  [in] the unique ID used to cache the node.
 272    */
 273   LocalAccessible* GetAccessibleByUniqueID(void* aUniqueID) {
 274     return UniqueID() == aUniqueID ? this : mAccessibleCache.GetWeak(aUniqueID);
 275   }
 276
 277   /**
 278    * Return the cached accessible by the given unique ID looking through
 279    * this and nested documents.
 280    */
 281   LocalAccessible* GetAccessibleByUniqueIDInSubtree(void* aUniqueID);
 282
 283   /**
 284    * Return an accessible for the given DOM node or container accessible if
 285    * the node is not accessible. If aNoContainerIfPruned is true it will return
 286    * null if the node is in a pruned subtree (eg. aria-hidden or unselected deck
 287    * panel)
 288    */
 289   LocalAccessible* GetAccessibleOrContainer(
 290       nsINode* aNode, bool aNoContainerIfPruned = false) const;
 291
 292   /**
 293    * Return a container accessible for the given DOM node.
 294    */
 295   LocalAccessible* GetContainerAccessible(nsINode* aNode) const;
 296
 297   /**
 298    * Return an accessible for the given node if any, or an immediate accessible
 299    * container for it.
 300    */
 301   LocalAccessible* AccessibleOrTrueContainer(
 302       nsINode* aNode, bool aNoContainerIfPruned = false) const;
 303
 304   /**
 305    * Return an accessible for the given node or its first accessible descendant.
 306    */
 307   LocalAccessible* GetAccessibleOrDescendant(nsINode* aNode) const;
 308
 309   /**
 310    * Returns aria-owns seized child at the given index.
 311    */
 312   LocalAccessible* ARIAOwnedAt(LocalAccessible* aParent,
 313                                uint32_t aIndex) const {
 314     nsTArray<RefPtr<LocalAccessible>>* children = mARIAOwnsHash.Get(aParent);
 315     if (children) {
 316       return children->SafeElementAt(aIndex);
 317     }
 318     return nullptr;
 319   }
 320   uint32_t ARIAOwnedCount(LocalAccessible* aParent) const {
 321     nsTArray<RefPtr<LocalAccessible>>* children = mARIAOwnsHash.Get(aParent);
 322     return children ? children->Length() : 0;
 323   }
 324
 325   /**
 326    * Return true if the given ID is referred by relation attribute.
 327    */
 328   bool IsDependentID(dom::Element* aElement, const nsAString& aID) const {
 329     return GetRelProviders(aElement, aID);
 330   }
 331
 332   /**
 333    * Initialize the newly created accessible and put it into document caches.
 334    *
 335    * @param  aAccessible    [in] created accessible
 336    * @param  aRoleMapEntry  [in] the role map entry role the ARIA role or
 337    * nullptr if none
 338    */
 339   void BindToDocument(LocalAccessible* aAccessible,
 340                       const nsRoleMapEntry* aRoleMapEntry);
 341
 342   /**
 343    * Remove from document and shutdown the given accessible.
 344    */
 345   void UnbindFromDocument(LocalAccessible* aAccessible);
 346
 347   /**
 348    * Notify the document accessible that content was inserted.
 349    */
 350   void ContentInserted(nsIContent* aStartChildNode, nsIContent* aEndChildNode);
 351
 352   /**
 353    * @see nsAccessibilityService::ScheduleAccessibilitySubtreeUpdate
 354    */
 355   void ScheduleTreeUpdate(nsIContent* aContent);
 356
 357   /**
 358    * Update the tree on content removal.
 359    */
 360   void ContentRemoved(LocalAccessible* aAccessible);
 361   void ContentRemoved(nsIContent* aContentNode);
 362
 363   /**
 364    * Updates accessible tree when rendered text is changed.
 365    */
 366   void UpdateText(nsIContent* aTextNode);
 367
 368   /**
 369    * Recreate an accessible, results in hide/show events pair.
 370    */
 371   void RecreateAccessible(nsIContent* aContent);
 372
 373   /**
 374    * Schedule ARIA owned element relocation if needed. Return true if relocation
 375    * was scheduled.
 376    */
 377   bool RelocateARIAOwnedIfNeeded(nsIContent* aEl);
 378
 379   /**
 380    * Return a notification controller associated with the document.
 381    */
 382   NotificationController* Controller() const { return mNotificationController; }
 383
 384   /**
 385    * If this document is in a content process return the object responsible for
 386    * communicating with the main process for it.
 387    */
 388   DocAccessibleChild* IPCDoc() const { return mIPCDoc; }
 389
 390   /**
 391    * Notify the document that a DOM node has been scrolled. document will
 392    * dispatch throttled accessibility events for scrolling, and a scroll-end
 393    * event. This function also queues a cache update for ScrollPosition.
 394    */
 395   void HandleScroll(nsINode* aTarget);
 396
 397   /**
 398    * Retrieves the scroll frame (if it exists) for the given accessible
 399    * and returns its scroll position and scroll range. If the given
 400    * accessible is `this`, return the scroll position and range of
 401    * the root scroll frame. Return values have been scaled by the
 402    * PresShell's resolution.
 403    */
 404   std::pair<nsPoint, nsRect> ComputeScrollData(LocalAccessible* aAcc);
 405
 406   /**
 407    * Only works in content process documents.
 408    */
 409   bool IsAccessibleBeingMoved(LocalAccessible* aAcc) {
 410     return mMovedAccessibles.Contains(aAcc);
 411   }
 412
 413  protected:
 414   virtual ~DocAccessible();
 415
 416   void LastRelease();
 417
 418   // DocAccessible
 419   virtual nsresult AddEventListeners();
 420   virtual nsresult RemoveEventListeners();
 421
 422   /**
 423    * Marks this document as loaded or loading.
 424    */
 425   void NotifyOfLoad(uint32_t aLoadEventType);
 426   void NotifyOfLoading(bool aIsReloading);
 427
 428   friend class DocManager;
 429
 430   /**
 431    * Perform initial update (create accessible tree).
 432    * Can be overridden by wrappers to prepare initialization work.
 433    */
 434   virtual void DoInitialUpdate();
 435
 436   /**
 437    * Updates root element and picks up ARIA role on it if any.
 438    */
 439   void UpdateRootElIfNeeded();
 440
 441   /**
 442    * Process document load notification, fire document load and state busy
 443    * events if applicable.
 444    */
 445   void ProcessLoad();
 446
 447   /**
 448    * Append the given document accessible to this document's child document
 449    * accessibles.
 450    */
 451   bool AppendChildDocument(DocAccessible* aChildDocument) {
 452     // XXX(Bug 1631371) Check if this should use a fallible operation as it
 453     // pretended earlier, or change the return type to void.
 454     mChildDocuments.AppendElement(aChildDocument);
 455     return true;
 456   }
 457
 458   /**
 459    * Remove the given document accessible from this document's child document
 460    * accessibles.
 461    */
 462   void RemoveChildDocument(DocAccessible* aChildDocument) {
 463     mChildDocuments.RemoveElement(aChildDocument);
 464   }
 465
 466   /**
 467    * Add dependent IDs pointed by accessible element by relation attribute to
 468    * cache. If the relation attribute is missed then all relation attributes
 469    * are checked.
 470    *
 471    * @param aRelProvider [in] accessible that element has relation attribute
 472    * @param aRelAttr     [in, optional] relation attribute
 473    */
 474   void AddDependentIDsFor(LocalAccessible* aRelProvider,
 475                           nsAtom* aRelAttr = nullptr);
 476
 477   /**
 478    * Remove dependent IDs pointed by accessible element by relation attribute
 479    * from cache. If the relation attribute is absent then all relation
 480    * attributes are checked.
 481    *
 482    * @param aRelProvider [in] accessible that element has relation attribute
 483    * @param aRelAttr     [in, optional] relation attribute
 484    */
 485   void RemoveDependentIDsFor(LocalAccessible* aRelProvider,
 486                              nsAtom* aRelAttr = nullptr);
 487
 488   /**
 489    * Update or recreate an accessible depending on a changed attribute.
 490    *
 491    * @param aElement   [in] the element the attribute was changed on
 492    * @param aAttribute [in] the changed attribute
 493    * @return            true if an action was taken on the attribute change
 494    */
 495   bool UpdateAccessibleOnAttrChange(mozilla::dom::Element* aElement,
 496                                     nsAtom* aAttribute);
 497
 498   /**
 499    * Process ARIA active-descendant attribute change.
 500    */
 501   void ARIAActiveDescendantChanged(LocalAccessible* aAccessible);
 502
 503   /**
 504    * Update the accessible tree for inserted content.
 505    */
 506   void ProcessContentInserted(
 507       LocalAccessible* aContainer,
 508       const nsTArray<nsCOMPtr<nsIContent>>* aInsertedContent);
 509   void ProcessContentInserted(LocalAccessible* aContainer,
 510                               nsIContent* aInsertedContent);
 511
 512   /**
 513    * Used to notify the document to make it process the invalidation list.
 514    *
 515    * While children are cached we may encounter the case there's no accessible
 516    * for referred content by related accessible. Store these related nodes to
 517    * invalidate their containers later.
 518    */
 519   void ProcessInvalidationList();
 520
 521   /**
 522    * Process mPendingUpdates
 523    */
 524   void ProcessPendingUpdates();
 525
 526   /**
 527    * Called from NotificationController to process this doc's
 528    * mQueuedCacheUpdates list. For each acc in the map, this function
 529    * sends a cache update with its corresponding CacheDomain.
 530    */
 531   void ProcessQueuedCacheUpdates();
 532
 533   /**
 534    * Called from NotificationController before mutation events are processed to
 535    * notify the parent process which Accessibles are being moved (if any).
 536    */
 537   void SendAccessiblesWillMove();
 538
 539   /**
 540    * Called from NotificationController after all mutation events have been
 541    * processed to clear our data about Accessibles that were moved during this
 542    * tick.
 543    */
 544   void ClearMovedAccessibles() {
 545     mMovedAccessibles.Clear();
 546     mInsertedAccessibles.Clear();
 547   }
 548
 549   /**
 550    * Steals or puts back accessible subtrees.
 551    */
 552   void DoARIAOwnsRelocation(LocalAccessible* aOwner);
 553
 554   /**
 555    * Moves children back under their original parents.
 556    */
 557   void PutChildrenBack(nsTArray<RefPtr<LocalAccessible>>* aChildren,
 558                        uint32_t aStartIdx);
 559
 560   bool MoveChild(LocalAccessible* aChild, LocalAccessible* aNewParent,
 561                  int32_t aIdxInParent);
 562
 563   /**
 564    * Create accessible tree.
 565    *
 566    * @param aRoot       [in] a root of subtree to create
 567    * @param aFocusedAcc [in, optional] a focused accessible under created
 568    *                      subtree if any
 569    */
 570   void CacheChildrenInSubtree(LocalAccessible* aRoot,
 571                               LocalAccessible** aFocusedAcc = nullptr);
 572   void CreateSubtree(LocalAccessible* aRoot);
 573
 574   /**
 575    * Remove accessibles in subtree from node to accessible map.
 576    */
 577   void UncacheChildrenInSubtree(LocalAccessible* aRoot);
 578
 579   /**
 580    * Shutdown any cached accessible in the subtree.
 581    *
 582    * @param aAccessible  [in] the root of the subrtee to invalidate accessible
 583    *                      child/parent refs in
 584    */
 585   void ShutdownChildrenInSubtree(LocalAccessible* aAccessible);
 586
 587   /**
 588    * Return true if the document is a target of document loading events
 589    * (for example, state busy change or document reload events).
 590    *
 591    * Rules: The root chrome document accessible is never an event target
 592    * (for example, Firefox UI window). If the sub document is loaded within its
 593    * parent document then the parent document is a target only (aka events
 594    * coalescence).
 595    */
 596   bool IsLoadEventTarget() const;
 597
 598   /*
 599    * Set the object responsible for communicating with the main process on
 600    * behalf of this document.
 601    */
 602   void SetIPCDoc(DocAccessibleChild* aIPCDoc);
 603
 604   friend class DocAccessibleChild;
 605
 606   /**
 607    * Used to fire scrolling end event after page scroll.
 608    *
 609    * @param aTimer    [in] the timer object
 610    * @param aClosure  [in] the document accessible where scrolling happens
 611    */
 612   static void ScrollTimerCallback(nsITimer* aTimer, void* aClosure);
 613
 614   void DispatchScrollingEvent(nsINode* aTarget, uint32_t aEventType);
 615
 616   /**
 617    * Check if an id attribute change affects aria-activedescendant and handle
 618    * the aria-activedescendant change if appropriate.
 619    * If the currently focused element has aria-activedescendant and an
 620    * element's id changes to match this, the id was probably moved from the
 621    * previous active descendant, thus making this element the new active
 622    * descendant. In that case, accessible focus must be changed accordingly.
 623    */
 624   void ARIAActiveDescendantIDMaybeMoved(LocalAccessible* aAccessible);
 625
 626   /**
 627    * Traverse content subtree and for each node do one of 3 things:
 628    * 1. Check if content node has an accessible that should be removed and
 629    *    remove it.
 630    * 2. Check if content node has an accessible that needs to be recreated.
 631    *    Remove it and schedule it for reinsertion.
 632    * 3. Check if content node has no accessible but needs one. Schedule one for
 633    *    insertion.
 634    *
 635    * Returns true if the root node should be reinserted.
 636    */
 637   bool PruneOrInsertSubtree(nsIContent* aRoot);
 638
 639  protected:
 640   /**
 641    * State and property flags, kept by mDocFlags.
 642    */
 643   enum {
 644     // Whether the document is a top level content document in this process.
 645     eTopLevelContentDocInProcess = 1 << 0
 646   };
 647
 648   /**
 649    * Cache of accessibles within this document accessible.
 650    */
 651   AccessibleHashtable mAccessibleCache;
 652   nsTHashMap<nsPtrHashKey<const nsINode>, LocalAccessible*>
 653       mNodeToAccessibleMap;
 654
 655   Document* mDocumentNode;
 656   nsCOMPtr<nsITimer> mScrollWatchTimer;
 657   nsTHashMap<nsPtrHashKey<nsINode>, TimeStamp> mLastScrollingDispatch;
 658
 659   /**
 660    * Bit mask of document load states (@see LoadState).
 661    */
 662   uint32_t mLoadState : 3;
 663
 664   /**
 665    * Bit mask of other states and props.
 666    */
 667   uint32_t mDocFlags : 27;
 668
 669   /**
 670    * Tracks whether we have seen changes to this document's content that
 671    * indicate we should re-send the viewport cache we use for hittesting.
 672    * This value is set in `BundleFieldsForCache` and processed in
 673    * `ProcessQueuedCacheUpdates`.
 674    */
 675   bool mViewportCacheDirty : 1;
 676
 677   /**
 678    * Type of document load event fired after the document is loaded completely.
 679    */
 680   uint32_t mLoadEventType;
 681
 682   /**
 683    * Reference to anchor jump element.
 684    */
 685   nsCOMPtr<nsIContent> mAnchorJumpElm;
 686
 687   /**
 688    * A generic state (see items below) before the attribute value was changed.
 689    * @see AttributeWillChange and AttributeChanged notifications.
 690    */
 691
 692   // Previous state bits before attribute change
 693   uint64_t mPrevStateBits;
 694
 695   nsTArray<RefPtr<DocAccessible>> mChildDocuments;
 696
 697   /**
 698    * A storage class for pairing content with one of its relation attributes.
 699    */
 700   class AttrRelProvider {
 701    public:
 702     AttrRelProvider(nsAtom* aRelAttr, nsIContent* aContent)
 703         : mRelAttr(aRelAttr), mContent(aContent) {}
 704
 705     nsAtom* mRelAttr;
 706     nsCOMPtr<nsIContent> mContent;
 707
 708    private:
 709     AttrRelProvider();
 710     AttrRelProvider(const AttrRelProvider&);
 711     AttrRelProvider& operator=(const AttrRelProvider&);
 712   };
 713
 714   typedef nsTArray<mozilla::UniquePtr<AttrRelProvider>> AttrRelProviders;
 715   typedef nsClassHashtable<nsStringHashKey, AttrRelProviders>
 716       DependentIDsHashtable;
 717
 718   /**
 719    * Returns/creates/removes attribute relation providers associated with
 720    * a DOM document if the element is in uncomposed document or associated
 721    * with shadow DOM the element is in.
 722    */
 723   AttrRelProviders* GetRelProviders(dom::Element* aElement,
 724                                     const nsAString& aID) const;
 725   AttrRelProviders* GetOrCreateRelProviders(dom::Element* aElement,
 726                                             const nsAString& aID);
 727   void RemoveRelProvidersIfEmpty(dom::Element* aElement, const nsAString& aID);
 728
 729   /**
 730    * The cache of IDs pointed by relation attributes.
 731    */
 732   nsClassHashtable<nsPtrHashKey<dom::DocumentOrShadowRoot>,
 733                    DependentIDsHashtable>
 734       mDependentIDsHashes;
 735
 736   friend class RelatedAccIterator;
 737
 738   /**
 739    * Used for our caching algorithm. We store the list of nodes that should be
 740    * invalidated.
 741    *
 742    * @see ProcessInvalidationList
 743    */
 744   nsTArray<RefPtr<nsIContent>> mInvalidationList;
 745
 746   /**
 747    * Holds a list of aria-owns relocations.
 748    */
 749   nsClassHashtable<nsPtrHashKey<LocalAccessible>,
 750                    nsTArray<RefPtr<LocalAccessible>>>
 751       mARIAOwnsHash;
 752
 753   /**
 754    * Keeps a list of pending subtrees to update post-refresh.
 755    */
 756   nsTArray<RefPtr<nsIContent>> mPendingUpdates;
 757
 758   /**
 759    * Used to process notification from core and accessible events.
 760    */
 761   RefPtr<NotificationController> mNotificationController;
 762   friend class EventTree;
 763   friend class NotificationController;
 764
 765  private:
 766   void SetRoleMapEntryForDoc(dom::Element* aElement);
 767
 768   /**
 769    * This must be called whenever an Accessible is moved in a content process.
 770    * It keeps track of Accessibles moved during this tick.
 771    */
 772   void TrackMovedAccessible(LocalAccessible* aAcc);
 773
 774   /**
 775    * For hidden subtrees, fire a name/description change event if the subtree
 776    * is a target of aria-labelledby/describedby.
 777    * This does nothing if it is called on a node which is not part of a hidden
 778    * aria-labelledby/describedby target.
 779    */
 780   void MaybeHandleChangeToHiddenNameOrDescription(nsIContent* aChild);
 781
 782   PresShell* mPresShell;
 783
 784   // Exclusively owned by IPDL so don't manually delete it!
 785   DocAccessibleChild* mIPCDoc;
 786
 787   // A hash map between LocalAccessibles and CacheDomains, tracking
 788   // cache updates that have been queued during the current tick
 789   // but not yet sent. It is possible for this map to contain a reference
 790   // to the document it lives on. We clear the list in Shutdown() to
 791   // avoid cyclical references.
 792   nsTHashMap<RefPtr<LocalAccessible>, uint64_t> mQueuedCacheUpdates;
 793
 794   // A set of Accessibles moved during this tick. Only used in content
 795   // processes.
 796   nsTHashSet<RefPtr<LocalAccessible>> mMovedAccessibles;
 797   // A set of Accessibles inserted during this tick. Only used in content
 798   // processes. This is needed to prevent insertions + moves of the same
 799   // Accessible in the same tick from being tracked as moves.
 800   nsTHashSet<RefPtr<LocalAccessible>> mInsertedAccessibles;
 801 };
 802
 803 inline DocAccessible* LocalAccessible::AsDoc() {
 804   return IsDoc() ? static_cast<DocAccessible*>(this) : nullptr;
 805 }
 806
 807 }  // namespace a11y
 808 }  // namespace mozilla
 809
 810 #endif