自学教程：C++ GetAccService函数代码示例

nsAccessible*nsXFormsSelectableAccessible::GetSelectedItem(PRUint32 aIndex){  nsresult rv;  nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));  if (mIsSelect1Element) {    if (aIndex != 0)      return nsnull;    nsCOMPtr<nsIDOMNode> itemDOMNode;    rv = sXFormsService->GetSelectedItemForSelect1(DOMNode,                                                   getter_AddRefs(itemDOMNode));    if (NS_SUCCEEDED(rv) && itemDOMNode) {      nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));      return GetAccService()->GetAccessibleInWeakShell(itemNode, mWeakShell);    }    return nsnull;  }  nsCOMPtr<nsIDOMNodeList> itemNodeList;  rv = sXFormsService->GetSelectedItemsForSelect(DOMNode,                                                 getter_AddRefs(itemNodeList));  if (NS_FAILED(rv) || !itemNodeList)    return nsnull;  nsCOMPtr<nsIDOMNode> itemDOMNode;  itemNodeList->Item(aIndex, getter_AddRefs(itemDOMNode));  nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));  return GetAccService()->GetAccessibleInWeakShell(itemNode, mWeakShell);}

already_AddRefed<nsIArray>nsXFormsSelectableAccessible::SelectedItems(){  nsCOMPtr<nsIMutableArray> selectedItems =    do_CreateInstance(NS_ARRAY_CONTRACTID);  if (!selectedItems)    return nsnull;  nsresult rv;  nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));  if (mIsSelect1Element) {    nsCOMPtr<nsIDOMNode> itemDOMNode;    rv = sXFormsService->GetSelectedItemForSelect1(DOMNode,                                                   getter_AddRefs(itemDOMNode));    if (NS_FAILED(rv) || !itemDOMNode)      return nsnull;    nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));    nsIAccessible* item = GetAccService()->GetAccessibleInWeakShell(itemNode,                                                                    mWeakShell);    if (item)      selectedItems->AppendElement(item, PR_FALSE);    nsIMutableArray* items = nsnull;    selectedItems.forget(&items);    return items;  }  nsCOMPtr<nsIDOMNodeList> itemNodeList;  rv = sXFormsService->GetSelectedItemsForSelect(DOMNode,                                                 getter_AddRefs(itemNodeList));  if (NS_FAILED(rv) || !itemNodeList)    return nsnull;  PRUint32 length = 0;  itemNodeList->GetLength(&length);  for (PRUint32 index = 0; index < length; index++) {    nsCOMPtr<nsIDOMNode> itemDOMNode;    itemNodeList->Item(index, getter_AddRefs(itemDOMNode));    if (!itemDOMNode)      return nsnull;    nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemDOMNode));    nsIAccessible* item = GetAccService()->GetAccessibleInWeakShell(itemNode,                                                                    mWeakShell);    if (item)      selectedItems->AppendElement(item, PR_FALSE);  }  nsIMutableArray* items = nsnull;  selectedItems.forget(&items);  return items;}

already_AddRefed<nsIAccessibleText>nsAccUtils::GetTextAccessibleFromSelection(nsISelection *aSelection,                                           nsIDOMNode **aNode){  // Get accessible from selection's focus DOM point (the DOM point where  // selection is ended).  nsCOMPtr<nsIDOMNode> focusNode;  aSelection->GetFocusNode(getter_AddRefs(focusNode));  if (!focusNode)    return nsnull;  PRInt32 focusOffset = 0;  aSelection->GetFocusOffset(&focusOffset);  nsCOMPtr<nsIDOMNode> resultNode =    nsCoreUtils::GetDOMNodeFromDOMPoint(focusNode, focusOffset);  // Get text accessible containing the result node.  while (resultNode) {    // Make sure to get the correct starting node for selection events inside    // XBL content trees.    nsCOMPtr<nsIDOMNode> relevantNode;    GetAccService()->GetRelevantContentNodeFor(resultNode,                                                getter_AddRefs(relevantNode));    if (relevantNode)      resultNode.swap(relevantNode);    nsCOMPtr<nsIContent> content = do_QueryInterface(resultNode);    if (!content || !content->IsNodeOfType(nsINode::eTEXT)) {      nsCOMPtr<nsIAccessible> accessible;      GetAccService()->GetAccessibleFor(resultNode, getter_AddRefs(accessible));      if (accessible) {        nsIAccessibleText *textAcc = nsnull;        CallQueryInterface(accessible, &textAcc);        if (textAcc) {          if (aNode)            NS_ADDREF(*aNode = resultNode);          return textAcc;        }      }    }    nsCOMPtr<nsIDOMNode> parentNode;    resultNode->GetParentNode(getter_AddRefs(parentNode));    resultNode.swap(parentNode);  }  NS_NOTREACHED("No nsIAccessibleText for selection change event!");  return nsnull;}

// Interface methodsNS_IMETHODIMP nsXULSelectableAccessible::GetSelectedChildren(nsIArray **aChildren){  *aChildren = nsnull;  if (!mSelectControl) {    return NS_ERROR_FAILURE;  }  nsCOMPtr<nsIMutableArray> selectedAccessibles =    do_CreateInstance(NS_ARRAY_CONTRACTID);  NS_ENSURE_STATE(selectedAccessibles);  // For XUL multi-select control  nsCOMPtr<nsIDOMXULMultiSelectControlElement> xulMultiSelect =    do_QueryInterface(mSelectControl);  nsCOMPtr<nsIAccessible> selectedAccessible;  if (xulMultiSelect) {    PRInt32 length = 0;    xulMultiSelect->GetSelectedCount(&length);    for (PRInt32 index = 0; index < length; index++) {      nsCOMPtr<nsIDOMXULSelectControlItemElement> selectedItem;      xulMultiSelect->GetSelectedItem(index, getter_AddRefs(selectedItem));      nsCOMPtr<nsIDOMNode> selectedNode(do_QueryInterface(selectedItem));      GetAccService()->GetAccessibleInWeakShell(selectedNode, mWeakShell,                                            getter_AddRefs(selectedAccessible));      if (selectedAccessible)        selectedAccessibles->AppendElement(selectedAccessible, PR_FALSE);    }  }  else {  // Single select?    nsCOMPtr<nsIDOMXULSelectControlItemElement> selectedItem;    mSelectControl->GetSelectedItem(getter_AddRefs(selectedItem));    nsCOMPtr<nsIDOMNode> selectedNode(do_QueryInterface(selectedItem));    if(selectedNode) {      GetAccService()->GetAccessibleInWeakShell(selectedNode, mWeakShell,                                            getter_AddRefs(selectedAccessible));      if (selectedAccessible)        selectedAccessibles->AppendElement(selectedAccessible, PR_FALSE);    }  }  PRUint32 uLength = 0;  selectedAccessibles->GetLength(&uLength);  if (uLength != 0) { // length of nsIArray containing selected options    NS_ADDREF(*aChildren = selectedAccessibles);  }  return NS_OK;}

voidFocusManager::NotifyOfDOMBlur(nsISupports* aTarget){#ifdef A11Y_LOG  if (logging::IsEnabled(logging::eFocus))    logging::FocusNotificationTarget("DOM blur", "Target", aTarget);#endif  mActiveItem = nullptr;  // If DOM document stays focused then fire accessible focus event to process  // the case when no element within this DOM document will be focused.  nsCOMPtr<nsINode> targetNode(do_QueryInterface(aTarget));  if (targetNode && targetNode->OwnerDoc() == FocusedDOMDocument()) {    nsIDocument* DOMDoc = targetNode->OwnerDoc();    DocAccessible* document =      GetAccService()->GetDocAccessible(DOMDoc);    if (document) {      // Clear selection listener for previously focused element.      if (targetNode->IsElement())        SelectionMgr()->ClearControlSelectionListener();      document->HandleNotification<FocusManager, nsINode>        (this, &FocusManager::ProcessDOMFocus, DOMDoc);    }  }}

mozilla::ipc::IPCResultDocAccessibleParent::RecvSelectionEvent(const uint64_t& aID,                                        const uint64_t& aWidgetID,                                        const uint32_t& aType){  if (mShutdown) {    return IPC_OK();  }  ProxyAccessible* target = GetAccessible(aID);  ProxyAccessible* widget = GetAccessible(aWidgetID);  if (!target || !widget) {    NS_ERROR("invalid id in selection event");    return IPC_OK();  }  ProxySelectionEvent(target, widget, aType);  if (!nsCoreUtils::AccEventObserversExist()) {    return IPC_OK();  }  xpcAccessibleGeneric* xpcTarget = GetXPCAccessible(target);  xpcAccessibleDocument* xpcDoc = GetAccService()->GetXPCDocument(this);  RefPtr<xpcAccEvent> event = new xpcAccEvent(aType, xpcTarget, xpcDoc,                                              nullptr, false);  nsCoreUtils::DispatchAccEvent(Move(event));  return IPC_OK();}

NS_IMETHODIMPnsXULListboxAccessible::GetCellAt(PRInt32 aRow, PRInt32 aColumn,                                  nsIAccessible **aAccessibleCell){  NS_ENSURE_ARG_POINTER(aAccessibleCell);  *aAccessibleCell = nsnull;  if (IsDefunct())    return NS_OK;  nsCOMPtr<nsIDOMXULSelectControlElement> control =    do_QueryInterface(mContent);  nsCOMPtr<nsIDOMXULSelectControlItemElement> item;  control->GetItemAtIndex(aRow, getter_AddRefs(item));  NS_ENSURE_TRUE(item, NS_ERROR_INVALID_ARG);  nsCOMPtr<nsIContent> itemContent(do_QueryInterface(item));  nsAccessible *row =    GetAccService()->GetAccessibleInWeakShell(itemContent, mWeakShell);  NS_ENSURE_STATE(row);  nsresult rv = row->GetChildAt(aColumn, aAccessibleCell);  NS_ENSURE_SUCCESS(rv, NS_ERROR_INVALID_ARG);  return NS_OK;}

voidFocusManager::ProcessDOMFocus(nsINode* aTarget){#ifdef A11Y_LOG  if (logging::IsEnabled(logging::eFocus))    logging::FocusNotificationTarget("process DOM focus", "Target", aTarget);#endif  DocAccessible* document =    GetAccService()->GetDocAccessible(aTarget->OwnerDoc());  if (!document)    return;  Accessible* target = document->GetAccessibleEvenIfNotInMapOrContainer(aTarget);  if (target) {    // Check if still focused. Otherwise we can end up with storing the active    // item for control that isn't focused anymore.    nsINode* focusedNode = FocusedDOMNode();    if (!focusedNode)      return;    Accessible* DOMFocus =      document->GetAccessibleEvenIfNotInMapOrContainer(focusedNode);    if (target != DOMFocus)      return;    Accessible* activeItem = target->CurrentItem();    if (activeItem) {      mActiveItem = activeItem;      target = activeItem;    }    DispatchFocusEvent(document, target);  }}

NS_IMETHODIMPnsXULComboboxAccessible::GetDescription(nsAString& aDescription){  aDescription.Truncate();  if (IsDefunct())    return NS_ERROR_FAILURE;  // Use description of currently focused option  nsCOMPtr<nsIDOMXULMenuListElement> menuListElm(do_QueryInterface(mDOMNode));  if (!menuListElm)    return NS_ERROR_FAILURE;  nsCOMPtr<nsIDOMXULSelectControlItemElement> focusedOptionItem;  menuListElm->GetSelectedItem(getter_AddRefs(focusedOptionItem));  nsCOMPtr<nsIDOMNode> focusedOptionNode(do_QueryInterface(focusedOptionItem));  if (focusedOptionNode) {    nsCOMPtr<nsIAccessible> focusedOption;    GetAccService()->GetAccessibleInWeakShell(focusedOptionNode, mWeakShell,                                               getter_AddRefs(focusedOption));    NS_ENSURE_TRUE(focusedOption, NS_ERROR_FAILURE);    return focusedOption->GetDescription(aDescription);  }  return NS_OK;}

voidProxyAccessible::Shutdown(){  MOZ_DIAGNOSTIC_ASSERT(!IsDoc());  NS_ASSERTION(!mOuterDoc, "Why do we still have a child doc?");  xpcAccessibleDocument* xpcDoc =    GetAccService()->GetCachedXPCDocument(Document());  if (xpcDoc) {    xpcDoc->NotifyOfShutdown(this);  }  // XXX Ideally  this wouldn't be necessary, but it seems OuterDoc accessibles  // can be destroyed before the doc they own.  if (!mOuterDoc) {    uint32_t childCount = mChildren.Length();    for (uint32_t idx = 0; idx < childCount; idx++)      mChildren[idx]->Shutdown();  } else {    if (mChildren.Length() != 1)      MOZ_CRASH("outer doc doesn't own adoc!");    mChildren[0]->AsDoc()->Unbind();  }  mChildren.Clear();  ProxyDestroyed(this);  mDoc->RemoveAccessible(this);}

voidnsXFormsAccessible::CacheSelectChildren(nsIDOMNode *aContainerNode){  nsCOMPtr<nsIDOMNode> container(aContainerNode);  if (!container)    container = do_QueryInterface(mContent);  nsCOMPtr<nsIDOMNodeList> children;  sXFormsService->GetSelectChildrenFor(container, getter_AddRefs(children));  if (!children)    return;  nsCOMPtr<nsIPresShell> presShell(do_QueryReferent(mWeakShell));  PRUint32 length = 0;  children->GetLength(&length);  for (PRUint32 index = 0; index < length; index++) {    nsCOMPtr<nsIDOMNode> DOMChild;    children->Item(index, getter_AddRefs(DOMChild));    if (!DOMChild)      continue;    nsCOMPtr<nsIContent> child(do_QueryInterface(DOMChild));    nsAccessible* accessible =      GetAccService()->GetOrCreateAccessible(child, presShell, mWeakShell);    if (!accessible)      continue;    AppendChild(accessible);  }}

nsAccessible *AccEvent::GetAccessibleForNode() const{  if (!mNode)    return nsnull;  nsAccessible *accessible = GetAccService()->GetAccessible(mNode);#ifdef MOZ_XUL  // hack for xul tree table. We need a better way for firing delayed event  // against xul tree table. see bug 386821.  // There will be problem if some day we want to fire delayed event against  // the xul tree itself or an unselected treeitem.  nsCOMPtr<nsIContent> content(do_QueryInterface(mNode));  if (content && content->NodeInfo()->Equals(nsAccessibilityAtoms::tree,                                             kNameSpaceID_XUL)) {    nsCOMPtr<nsIDOMXULMultiSelectControlElement> multiSelect =      do_QueryInterface(mNode);    if (multiSelect) {      PRInt32 treeIndex = -1;      multiSelect->GetCurrentIndex(&treeIndex);      if (treeIndex >= 0) {        nsRefPtr<nsXULTreeAccessible> treeAcc = do_QueryObject(accessible);        if (treeAcc)          return treeAcc->GetTreeItemAccessible(treeIndex);      }    }  }#endif  return accessible;}

voidnsHTMLSelectListAccessible::CacheOptSiblings(nsIContent *aParentContent){  nsCOMPtr<nsIPresShell> presShell(do_QueryReferent(mWeakShell));  PRUint32 numChildren = aParentContent->GetChildCount();  for (PRUint32 count = 0; count < numChildren; count ++) {    nsIContent *childContent = aParentContent->GetChildAt(count);    if (!childContent->IsHTML()) {      continue;    }    nsCOMPtr<nsIAtom> tag = childContent->Tag();    if (tag == nsAccessibilityAtoms::option ||        tag == nsAccessibilityAtoms::optgroup) {      // Get an accessible for option or optgroup and cache it.      nsRefPtr<nsAccessible> accessible =        GetAccService()->GetOrCreateAccessible(childContent, presShell,                                               mWeakShell);      if (accessible)        AppendChild(accessible);      // Deep down into optgroup element.      if (tag == nsAccessibilityAtoms::optgroup)        CacheOptSiblings(childContent);    }  }}

PRBoolnsHTMLSelectableAccessible::iterator::GetAccessibleIfSelected(PRInt32 aIndex,                                                              nsPresContext *aContext,                                                               nsIAccessible **aAccessible){  PRBool isSelected = PR_FALSE;  *aAccessible = nsnull;  if (mOption) {    mOption->GetSelected(&isSelected);    if (isSelected) {      if (mSelCount == aIndex) {        nsCOMPtr<nsIContent> optionContent(do_QueryInterface(mOption));        nsAccessible *accessible =          GetAccService()->GetAccessibleInWeakShell(optionContent, mWeakShell);        NS_IF_ADDREF(*aAccessible = accessible);        return PR_TRUE;      }      mSelCount++;    }  }  return PR_FALSE;}

PRBoolnsAccUtils::IsNodeRelevant(nsIDOMNode *aNode){  nsCOMPtr<nsIDOMNode> relevantNode;  GetAccService()->GetRelevantContentNodeFor(aNode, getter_AddRefs(relevantNode));  return aNode == relevantNode;}

boolDocAccessibleParent::RecvEvent(const uint64_t& aID, const uint32_t& aEventType){  ProxyAccessible* proxy = GetAccessible(aID);  if (!proxy) {    NS_ERROR("no proxy for event!");    return true;  }  ProxyEvent(proxy, aEventType);  if (!nsCoreUtils::AccEventObserversExist()) {    return true;  }  xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(proxy);  xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);  nsIDOMNode* node = nullptr;  bool fromUser = true; // XXX fix me  RefPtr<xpcAccEvent> event = new xpcAccEvent(aEventType, xpcAcc, doc, node,                                              fromUser);  nsCoreUtils::DispatchAccEvent(Move(event));  return true;}

mozilla::ipc::IPCResultDocAccessibleParent::RecvFocusEvent(const uint64_t& aID,                                    const LayoutDeviceIntRect& aCaretRect){  if (mShutdown) {    return IPC_OK();  }  ProxyAccessible* proxy = GetAccessible(aID);  if (!proxy) {    NS_ERROR("no proxy for event!");    return IPC_OK();  }  ProxyFocusEvent(proxy, aCaretRect);  if (!nsCoreUtils::AccEventObserversExist()) {    return IPC_OK();  }  xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(proxy);  xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);  nsIDOMNode* node = nullptr;  bool fromUser = true; // XXX fix me  RefPtr<xpcAccEvent> event = new xpcAccEvent(nsIAccessibleEvent::EVENT_FOCUS,                                              xpcAcc, doc, node, fromUser);  nsCoreUtils::DispatchAccEvent(Move(event));  return IPC_OK();}

NS_IMETHODIMPnsXULTreeGridCellAccessible::GetColumnHeaderCells(nsIArray **aHeaderCells){  NS_ENSURE_ARG_POINTER(aHeaderCells);  *aHeaderCells = nsnull;  if (IsDefunct())    return NS_ERROR_FAILURE;  nsresult rv = NS_OK;  nsCOMPtr<nsIMutableArray> headerCells =    do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);  NS_ENSURE_SUCCESS(rv, rv);  nsCOMPtr<nsIDOMElement> columnElm;  mColumn->GetElement(getter_AddRefs(columnElm));  nsCOMPtr<nsIContent> columnContent(do_QueryInterface(columnElm));  nsAccessible *headerCell =    GetAccService()->GetAccessibleInWeakShell(columnContent, mWeakShell);  if (headerCell)    headerCells->AppendElement(static_cast<nsIAccessible*>(headerCell),                               PR_FALSE);  NS_ADDREF(*aHeaderCells = headerCells);  return NS_OK;}

voidnsDeckFrame::IndexChanged(){  //did the index change?  int32_t index = GetSelectedIndex();  if (index == mIndex)    return;  // redraw  InvalidateFrame();  // hide the currently showing box  nsIFrame* currentBox = GetSelectedBox();  if (currentBox) // only hide if it exists    HideBox(currentBox);  mIndex = index;#ifdef ACCESSIBILITY  nsAccessibilityService* accService = GetAccService();  if (accService) {    accService->DeckPanelSwitched(PresContext()->GetPresShell(), mContent,                                  currentBox, GetSelectedBox());  }#endif}

void nsHTMLSelectOptionAccessible::SelectionChangedIfOption(nsIContent *aPossibleOption){  if (!aPossibleOption || aPossibleOption->Tag() != nsAccessibilityAtoms::option ||      !aPossibleOption->IsNodeOfType(nsINode::eHTML)) {    return;  }  nsCOMPtr<nsIDOMNode> optionNode(do_QueryInterface(aPossibleOption));  NS_ASSERTION(optionNode, "No option node for nsIContent with option tag!");  nsCOMPtr<nsIAccessible> multiSelect =    nsAccUtils::GetMultiSelectFor(optionNode);  if (!multiSelect)    return;  nsCOMPtr<nsIAccessible> optionAccessible;  GetAccService()->GetAccessibleFor(optionNode,                                    getter_AddRefs(optionAccessible));  if (!optionAccessible)    return;  nsAccUtils::FireAccEvent(nsIAccessibleEvent::EVENT_SELECTION_WITHIN,                           multiSelect);  PRUint32 state = nsAccUtils::State(optionAccessible);  PRUint32 eventType;  if (state & nsIAccessibleStates::STATE_SELECTED) {    eventType = nsIAccessibleEvent::EVENT_SELECTION_ADD;  }  else {    eventType = nsIAccessibleEvent::EVENT_SELECTION_REMOVE;  }  nsAccUtils::FireAccEvent(eventType, optionAccessible);}

voidDocAccessibleParent::Destroy(){  NS_ASSERTION(mChildDocs.IsEmpty(),               "why weren't the child docs destroyed already?");  MOZ_ASSERT(!mShutdown);  mShutdown = true;  uint32_t childDocCount = mChildDocs.Length();  for (uint32_t i = childDocCount - 1; i < childDocCount; i--)    mChildDocs[i]->Destroy();  for (auto iter = mAccessibles.Iter(); !iter.Done(); iter.Next()) {    MOZ_ASSERT(iter.Get()->mProxy != this);    ProxyDestroyed(iter.Get()->mProxy);    iter.Remove();  }  DocManager::NotifyOfRemoteDocShutdown(this);  ProxyDestroyed(this);  if (mParentDoc)    mParentDoc->RemoveChildDoc(this);  else if (IsTopLevel())    GetAccService()->RemoteDocShutdown(this);}

// return the nth selected child's nsIAccessible objectNS_IMETHODIMP nsXULSelectableAccessible::RefSelection(PRInt32 aIndex, nsIAccessible **aAccessible){  *aAccessible = nsnull;  if (!mSelectControl) {    return NS_ERROR_FAILURE;  }  nsCOMPtr<nsIDOMXULSelectControlItemElement> selectedItem;  nsCOMPtr<nsIDOMXULMultiSelectControlElement> xulMultiSelect =    do_QueryInterface(mSelectControl);  if (xulMultiSelect)    xulMultiSelect->GetSelectedItem(aIndex, getter_AddRefs(selectedItem));  if (aIndex == 0)    mSelectControl->GetSelectedItem(getter_AddRefs(selectedItem));  if (selectedItem) {    nsCOMPtr<nsIAccessibilityService> accService = GetAccService();    if (accService) {      accService->GetAccessibleInWeakShell(selectedItem, mWeakShell, aAccessible);      if (*aAccessible) {        NS_ADDREF(*aAccessible);        return NS_OK;      }    }  }  return NS_ERROR_FAILURE;}

xpcAccessibleGeneric*DocAccessibleParent::GetXPCAccessible(ProxyAccessible* aProxy){  xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);  MOZ_ASSERT(doc);  return doc->GetXPCAccessible(aProxy);}

nsDocAccessible*AccEvent::GetDocAccessible(){  nsINode *node = GetNode();  if (node)    return GetAccService()->GetDocAccessible(node->OwnerDoc());  return nsnull;}

boolDocAccessibleParent::RecvHideEvent(const uint64_t& aRootID,                                   const bool& aFromUser){  if (mShutdown)    return true;  MOZ_DIAGNOSTIC_ASSERT(CheckDocTree());  // We shouldn't actually need this because mAccessibles shouldn't have an  // entry for the document itself, but it doesn't hurt to be explicit.  if (!aRootID) {    NS_ERROR("trying to hide entire document?");    return false;  }  ProxyEntry* rootEntry = mAccessibles.GetEntry(aRootID);  if (!rootEntry) {    NS_ERROR("invalid root being removed!");    return true;  }  ProxyAccessible* root = rootEntry->mProxy;  if (!root) {    NS_ERROR("invalid root being removed!");    return true;  }  ProxyAccessible* parent = root->Parent();  ProxyShowHideEvent(root, parent, false, aFromUser);  RefPtr<xpcAccHideEvent> event = nullptr;  if (nsCoreUtils::AccEventObserversExist()) {    uint32_t type = nsIAccessibleEvent::EVENT_HIDE;    xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(root);    xpcAccessibleGeneric* xpcParent = GetXPCAccessible(parent);    ProxyAccessible* next = root->NextSibling();    xpcAccessibleGeneric* xpcNext = next ? GetXPCAccessible(next) : nullptr;    ProxyAccessible* prev = root->PrevSibling();    xpcAccessibleGeneric* xpcPrev = prev ? GetXPCAccessible(prev) : nullptr;    xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);    nsIDOMNode* node = nullptr;    event = new xpcAccHideEvent(type, xpcAcc, doc, node, aFromUser, xpcParent,                                xpcNext, xpcPrev);  }  parent->RemoveChild(root);  root->Shutdown();  MOZ_DIAGNOSTIC_ASSERT(CheckDocTree());  if (event) {    nsCoreUtils::DispatchAccEvent(Move(event));  }  return true;}

nsAccessible *nsAccUtils::GetMultiSelectableContainer(nsINode *aNode){  nsAccessible *accessible = GetAccService()->GetAccessible(aNode);  nsAccessible *container = GetSelectableContainer(accessible,                                                   State(accessible));  if (State(container) & nsIAccessibleStates::STATE_MULTISELECTABLE)    return container;  return nsnull;}

voidnsOuterDocAccessible::CacheChildren(){  // Request document accessible for the content document to make sure it's  // created. It will appended to outerdoc accessible children asynchronously.  nsIDocument* outerDoc = mContent->GetCurrentDoc();  if (outerDoc) {    nsIDocument* innerDoc = outerDoc->GetSubDocumentFor(mContent);    if (innerDoc)      GetAccService()->GetDocAccessible(innerDoc);  }}