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 queued cache updates 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 dependent ids and elements maps 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   void AttrElementWillChange(dom::Element* aElement, nsAtom* aAttr);
 414   void AttrElementChanged(dom::Element* aElement, nsAtom* aAttr);
 415
 416  protected:
 417   virtual ~DocAccessible();
 418
 419   void LastRelease();
 420
 421   // DocAccessible
 422   virtual nsresult AddEventListeners();
 423   virtual nsresult RemoveEventListeners();
 424
 425   /**
 426    * Marks this document as loaded or loading.
 427    */
 428   void NotifyOfLoad(uint32_t aLoadEventType);
 429   void NotifyOfLoading(bool aIsReloading);
 430
 431   friend class DocManager;
 432
 433   /**
 434    * Perform initial update (create accessible tree).
 435    * Can be overridden by wrappers to prepare initialization work.
 436    */
 437   virtual void DoInitialUpdate();
 438
 439   /**
 440    * Updates root element and picks up ARIA role on it if any.
 441    */
 442   void UpdateRootElIfNeeded();
 443
 444   /**
 445    * Process document load notification, fire document load and state busy
 446    * events if applicable.
 447    */
 448   void ProcessLoad();
 449
 450   /**
 451    * Append the given document accessible to this document's child document
 452    * accessibles.
 453    */
 454   bool AppendChildDocument(DocAccessible* aChildDocument) {
 455     // XXX(Bug 1631371) Check if this should use a fallible operation as it
 456     // pretended earlier, or change the return type to void.
 457     mChildDocuments.AppendElement(aChildDocument);
 458     return true;
 459   }
 460
 461   /**
 462    * Remove the given document accessible from this document's child document
 463    * accessibles.
 464    */
 465   void RemoveChildDocument(DocAccessible* aChildDocument) {
 466     mChildDocuments.RemoveElement(aChildDocument);
 467   }
 468
 469   /**
 470    * Add dependent IDs pointed by accessible element by relation attribute to
 471    * cache. If the relation attribute is missed then all relation attributes
 472    * are checked.
 473    *
 474    * @param aRelProvider [in] accessible that element has relation attribute
 475    * @param aRelAttr     [in, optional] relation attribute
 476    */
 477   void AddDependentIDsFor(LocalAccessible* aRelProvider,
 478                           nsAtom* aRelAttr = nullptr);
 479
 480   /**
 481    * Remove dependent IDs pointed by accessible element by relation attribute
 482    * from cache. If the relation attribute is absent then all relation
 483    * attributes are checked.
 484    *
 485    * @param aRelProvider [in] accessible that element has relation attribute
 486    * @param aRelAttr     [in, optional] relation attribute
 487    */
 488   void RemoveDependentIDsFor(LocalAccessible* aRelProvider,
 489                              nsAtom* aRelAttr = nullptr);
 490
 491   /**
 492    * Add dependent elements targeted by a relation attribute on an accessible
 493    * element to the dependent elements cache. This is used for reflected IDL
 494    * attributes which return DOM elements and reflect a content attribute, where
 495    * the IDL attribute has been set to an element. For example, if the
 496    * .popoverTargetElement IDL attribute is set to an element using JS, the
 497    * target element will be added to the dependent elements cache. If the
 498    * relation attribute is not specified, then all relation attributes are
 499    * checked.
 500    *
 501    * @param aRelProvider [in] the accessible with the relation IDL attribute.
 502    * @param aRelAttr [in, optional] the name of the reflected content attribute.
 503    *   For example, for the popoverTargetElement IDL attribute, this would be
 504    * "popovertarget".
 505    */
 506   void AddDependentElementsFor(LocalAccessible* aRelProvider,
 507                                nsAtom* aRelAttr = nullptr);
 508
 509   /**
 510    * Remove dependent elements targeted by a relation attribute on an accessible
 511    * element from the dependent elements cache. If the relation attribute is
 512    * not specified, then all relation attributes are checked.
 513    *
 514    * @param aRelProvider [in] the accessible with the relation IDL attribute.
 515    * @param aRelAttr [in, optional] the name of the reflected content attribute.
 516    */
 517   void RemoveDependentElementsFor(LocalAccessible* aRelProvider,
 518                                   nsAtom* aRelAttr = nullptr);
 519
 520   /**
 521    * Update or recreate an accessible depending on a changed attribute.
 522    *
 523    * @param aElement   [in] the element the attribute was changed on
 524    * @param aAttribute [in] the changed attribute
 525    * @return            true if an action was taken on the attribute change
 526    */
 527   bool UpdateAccessibleOnAttrChange(mozilla::dom::Element* aElement,
 528                                     nsAtom* aAttribute);
 529
 530   /**
 531    * Process ARIA active-descendant attribute change.
 532    */
 533   void ARIAActiveDescendantChanged(LocalAccessible* aAccessible);
 534
 535   /**
 536    * Update the accessible tree for inserted content.
 537    */
 538   void ProcessContentInserted(
 539       LocalAccessible* aContainer,
 540       const nsTArray<nsCOMPtr<nsIContent>>* aInsertedContent);
 541   void ProcessContentInserted(LocalAccessible* aContainer,
 542                               nsIContent* aInsertedContent);
 543
 544   /**
 545    * Used to notify the document to make it process the invalidation list.
 546    *
 547    * While children are cached we may encounter the case there's no accessible
 548    * for referred content by related accessible. Store these related nodes to
 549    * invalidate their containers later.
 550    */
 551   void ProcessInvalidationList();
 552
 553   /**
 554    * Process mPendingUpdates
 555    */
 556   void ProcessPendingUpdates();
 557
 558   /**
 559    * Called from NotificationController to process this doc's
 560    * queued cache updates. For each acc in the map, this function
 561    * sends a cache update with its corresponding CacheDomain.
 562    */
 563   void ProcessQueuedCacheUpdates();
 564
 565   /**
 566    * Called from NotificationController before mutation events are processed to
 567    * notify the parent process which Accessibles are being moved (if any).
 568    */
 569   void SendAccessiblesWillMove();
 570
 571   /**
 572    * Called from NotificationController after all mutation events have been
 573    * processed to clear our data about mutations during this tick.
 574    */
 575   void ClearMutationData() {
 576     mMovedAccessibles.Clear();
 577     mInsertedAccessibles.Clear();
 578     mRemovedNodes.Clear();
 579   }
 580
 581   /**
 582    * Steals or puts back accessible subtrees.
 583    */
 584   void DoARIAOwnsRelocation(LocalAccessible* aOwner);
 585
 586   /**
 587    * Moves children back under their original parents.
 588    */
 589   void PutChildrenBack(nsTArray<RefPtr<LocalAccessible>>* aChildren,
 590                        uint32_t aStartIdx);
 591
 592   bool MoveChild(LocalAccessible* aChild, LocalAccessible* aNewParent,
 593                  int32_t aIdxInParent);
 594
 595   /**
 596    * Create accessible tree.
 597    *
 598    * @param aRoot       [in] a root of subtree to create
 599    * @param aFocusedAcc [in, optional] a focused accessible under created
 600    *                      subtree if any
 601    */
 602   void CacheChildrenInSubtree(LocalAccessible* aRoot,
 603                               LocalAccessible** aFocusedAcc = nullptr);
 604   void CreateSubtree(LocalAccessible* aRoot);
 605
 606   /**
 607    * Remove accessibles in subtree from node to accessible map.
 608    */
 609   void UncacheChildrenInSubtree(LocalAccessible* aRoot);
 610
 611   /**
 612    * Shutdown any cached accessible in the subtree.
 613    *
 614    * @param aAccessible  [in] the root of the subrtee to invalidate accessible
 615    *                      child/parent refs in
 616    */
 617   void ShutdownChildrenInSubtree(LocalAccessible* aAccessible);
 618
 619   /**
 620    * Return true if the document is a target of document loading events
 621    * (for example, state busy change or document reload events).
 622    *
 623    * Rules: The root chrome document accessible is never an event target
 624    * (for example, Firefox UI window). If the sub document is loaded within its
 625    * parent document then the parent document is a target only (aka events
 626    * coalescence).
 627    */
 628   bool IsLoadEventTarget() const;
 629
 630   /*
 631    * Set the object responsible for communicating with the main process on
 632    * behalf of this document.
 633    */
 634   void SetIPCDoc(DocAccessibleChild* aIPCDoc);
 635
 636   friend class DocAccessibleChild;
 637
 638   /**
 639    * Used to fire scrolling end event after page scroll.
 640    *
 641    * @param aTimer    [in] the timer object
 642    * @param aClosure  [in] the document accessible where scrolling happens
 643    */
 644   static void ScrollTimerCallback(nsITimer* aTimer, void* aClosure);
 645
 646   void DispatchScrollingEvent(nsINode* aTarget, uint32_t aEventType);
 647
 648   /**
 649    * Check if an id attribute change affects aria-activedescendant and handle
 650    * the aria-activedescendant change if appropriate.
 651    * If the currently focused element has aria-activedescendant and an
 652    * element's id changes to match this, the id was probably moved from the
 653    * previous active descendant, thus making this element the new active
 654    * descendant. In that case, accessible focus must be changed accordingly.
 655    */
 656   void ARIAActiveDescendantIDMaybeMoved(LocalAccessible* aAccessible);
 657
 658   /**
 659    * Traverse content subtree and for each node do one of 3 things:
 660    * 1. Check if content node has an accessible that should be removed and
 661    *    remove it.
 662    * 2. Check if content node has an accessible that needs to be recreated.
 663    *    Remove it and schedule it for reinsertion.
 664    * 3. Check if content node has no accessible but needs one. Schedule one for
 665    *    insertion.
 666    *
 667    * Returns true if the root node should be reinserted.
 668    */
 669   bool PruneOrInsertSubtree(nsIContent* aRoot);
 670
 671  protected:
 672   /**
 673    * State and property flags, kept by mDocFlags.
 674    */
 675   enum {
 676     // Whether the document is a top level content document in this process.
 677     eTopLevelContentDocInProcess = 1 << 0
 678   };
 679
 680   /**
 681    * Cache of accessibles within this document accessible.
 682    */
 683   AccessibleHashtable mAccessibleCache;
 684   nsTHashMap<nsPtrHashKey<const nsINode>, LocalAccessible*>
 685       mNodeToAccessibleMap;
 686
 687   Document* mDocumentNode;
 688   nsCOMPtr<nsITimer> mScrollWatchTimer;
 689   nsTHashMap<nsPtrHashKey<nsINode>, TimeStamp> mLastScrollingDispatch;
 690
 691   /**
 692    * Bit mask of document load states (@see LoadState).
 693    */
 694   uint32_t mLoadState : 3;
 695
 696   /**
 697    * Bit mask of other states and props.
 698    */
 699   uint32_t mDocFlags : 27;
 700
 701   /**
 702    * Tracks whether we have seen changes to this document's content that
 703    * indicate we should re-send the viewport cache we use for hittesting.
 704    * This value is set in `BundleFieldsForCache` and processed in
 705    * `ProcessQueuedCacheUpdates`.
 706    */
 707   bool mViewportCacheDirty : 1;
 708
 709   /**
 710    * Type of document load event fired after the document is loaded completely.
 711    */
 712   uint32_t mLoadEventType;
 713
 714   /**
 715    * Reference to anchor jump element.
 716    */
 717   nsCOMPtr<nsIContent> mAnchorJumpElm;
 718
 719   /**
 720    * A generic state (see items below) before the attribute value was changed.
 721    * @see AttributeWillChange and AttributeChanged notifications.
 722    */
 723
 724   // Previous state bits before attribute change
 725   uint64_t mPrevStateBits;
 726
 727   nsTArray<RefPtr<DocAccessible>> mChildDocuments;
 728
 729   /**
 730    * A storage class for pairing content with one of its relation attributes.
 731    */
 732   class AttrRelProvider {
 733    public:
 734     AttrRelProvider(nsAtom* aRelAttr, nsIContent* aContent)
 735         : mRelAttr(aRelAttr), mContent(aContent) {}
 736
 737     nsAtom* mRelAttr;
 738     nsCOMPtr<nsIContent> mContent;
 739
 740    private:
 741     AttrRelProvider();
 742     AttrRelProvider(const AttrRelProvider&);
 743     AttrRelProvider& operator=(const AttrRelProvider&);
 744   };
 745
 746   typedef nsTArray<mozilla::UniquePtr<AttrRelProvider>> AttrRelProviders;
 747   typedef nsClassHashtable<nsStringHashKey, AttrRelProviders>
 748       DependentIDsHashtable;
 749
 750   /**
 751    * Returns/creates/removes attribute relation providers associated with
 752    * a DOM document if the element is in uncomposed document or associated
 753    * with shadow DOM the element is in.
 754    */
 755   AttrRelProviders* GetRelProviders(dom::Element* aElement,
 756                                     const nsAString& aID) const;
 757   AttrRelProviders* GetOrCreateRelProviders(dom::Element* aElement,
 758                                             const nsAString& aID);
 759   void RemoveRelProvidersIfEmpty(dom::Element* aElement, const nsAString& aID);
 760
 761   /**
 762    * A map used to look up the target node for an implicit reverse relation
 763    * where the target of the explicit relation is specified as an id.
 764    * For example:
 765    * <div id="label">Name:</div><input aria-labelledby="label">
 766    * The div should get a LABEL_FOR relation targeting the input. To facilitate
 767    * that, mDependentIDsHashes maps from "label" to an AttrRelProvider
 768    * specifying aria-labelledby and the input. Because ids are scoped to the
 769    * nearest ancestor document or shadow root, mDependentIDsHashes maps from the
 770    * DocumentOrShadowRoot first.
 771    */
 772   nsClassHashtable<nsPtrHashKey<dom::DocumentOrShadowRoot>,
 773                    DependentIDsHashtable>
 774       mDependentIDsHashes;
 775
 776   /**
 777    * A map used to look up the target element for an implicit reverse relation
 778    * where the target of the explicit relation is also specified as an element.
 779    * This is similar to mDependentIDsHashes, except that this is used when a
 780    * DOM property is used to set the relation target element directly, rather
 781    * than using an id. For example:
 782    * <button>More info</button><div popover>Some info</div>
 783    * The button's .popoverTargetElement property is set to the div so that the
 784    * button invokes the popover.
 785    * To facilitate finding the invoker given the popover, mDependentElementsMap
 786    * maps from the div to an AttrRelProvider specifying popovertarget and the
 787    * button.
 788    */
 789   nsTHashMap<nsIContent*, AttrRelProviders> mDependentElementsMap;
 790
 791   friend class RelatedAccIterator;
 792
 793   /**
 794    * Used for our caching algorithm. We store the list of nodes that should be
 795    * invalidated.
 796    *
 797    * @see ProcessInvalidationList
 798    */
 799   nsTArray<RefPtr<nsIContent>> mInvalidationList;
 800
 801   /**
 802    * Holds a list of aria-owns relocations.
 803    */
 804   nsClassHashtable<nsPtrHashKey<LocalAccessible>,
 805                    nsTArray<RefPtr<LocalAccessible>>>
 806       mARIAOwnsHash;
 807
 808   /**
 809    * Keeps a list of pending subtrees to update post-refresh.
 810    */
 811   nsTArray<RefPtr<nsIContent>> mPendingUpdates;
 812
 813   /**
 814    * Used to process notification from core and accessible events.
 815    */
 816   RefPtr<NotificationController> mNotificationController;
 817   friend class EventTree;
 818   friend class NotificationController;
 819
 820  private:
 821   void SetRoleMapEntryForDoc(dom::Element* aElement);
 822
 823   /**
 824    * This must be called whenever an Accessible is moved in a content process.
 825    * It keeps track of Accessibles moved during this tick.
 826    */
 827   void TrackMovedAccessible(LocalAccessible* aAcc);
 828
 829   /**
 830    * For hidden subtrees, fire a name/description change event if the subtree
 831    * is a target of aria-labelledby/describedby.
 832    * This does nothing if it is called on a node which is not part of a hidden
 833    * aria-labelledby/describedby target.
 834    */
 835   void MaybeHandleChangeToHiddenNameOrDescription(nsIContent* aChild);
 836
 837   void MaybeFireEventsForChangedPopover(LocalAccessible* aAcc);
 838
 839   PresShell* mPresShell;
 840
 841   // Exclusively owned by IPDL so don't manually delete it!
 842   // Cleared in ActorDestroy
 843   DocAccessibleChild* mIPCDoc;
 844
 845   // These data structures map between LocalAccessibles and CacheDomains,
 846   // tracking cache updates that have been queued during the current tick but
 847   // not yet sent. If there are a lot of nearby text cache updates (e.g. during
 848   // a reflow), it is much more performant to process them in order because we
 849   // then benefit from the layout line cursor. However, we still only want to
 850   // process each LocalAccessible only once. Therefore, we use an array for
 851   // ordering and a hash map to avoid duplicates, since Gecko has no ordered
 852   // set data structure. The array contains pairs of LocalAccessible and cache
 853   // domain. The hash map maps from LocalAccessible to the corresponding index
 854   // in the array. These data structures must be kept in sync. It is possible
 855   // for these to contain a reference to the document they live on. We clear
 856   // them in Shutdown() to avoid cyclical references.
 857   nsTArray<std::pair<RefPtr<LocalAccessible>, uint64_t>>
 858       mQueuedCacheUpdatesArray;
 859   nsTHashMap<LocalAccessible*, size_t> mQueuedCacheUpdatesHash;
 860
 861   // A set of Accessibles moved during this tick. Only used in content
 862   // processes.
 863   nsTHashSet<RefPtr<LocalAccessible>> mMovedAccessibles;
 864   // A set of Accessibles inserted during this tick. Only used in content
 865   // processes. This is needed to prevent insertions + moves of the same
 866   // Accessible in the same tick from being tracked as moves.
 867   nsTHashSet<RefPtr<LocalAccessible>> mInsertedAccessibles;
 868   // A set of DOM nodes removed during this tick. This avoids a lot of pointless
 869   // recursive DOM traversals.
 870   nsTHashSet<nsIContent*> mRemovedNodes;
 871 };
 872
 873 inline DocAccessible* LocalAccessible::AsDoc() {
 874   return IsDoc() ? static_cast<DocAccessible*>(this) : nullptr;
 875 }
 876
 877 }  // namespace a11y
 878 }  // namespace mozilla
 879
 880 #endif