The Tor Browser: accessible/src/xpcom/xpcAccessibleHyperText.cpp@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* vim: set ts=2 et sw=2 tw=80: */

     3 /* This Source Code Form is subject to the terms of the Mozilla Public

     4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,

     5  * You can obtain one at http://mozilla.org/MPL/2.0/. */

     7 #include "xpcAccessibleHyperText.h"

     9 #include "HyperTextAccessible-inl.h"

    10 #include "TextRange.h"

    11 #include "xpcAccessibleTextRange.h"

    13 #include "nsIPersistentProperties2.h"

    14 #include "nsIMutableArray.h"

    16 using namespace mozilla::a11y;

    18 ////////////////////////////////////////////////////////////////////////////////

    19 // nsISupports

    21 nsresult

    22 xpcAccessibleHyperText::QueryInterface(REFNSIID aIID, void** aInstancePtr)

    23 {

    24   *aInstancePtr = nullptr;

    26   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

    27   if (!text->IsTextRole())

    28     return NS_ERROR_NO_INTERFACE;

    30   if (aIID.Equals(NS_GET_IID(nsIAccessibleText)))

    31     *aInstancePtr = static_cast<nsIAccessibleText*>(text);

    32   else if (aIID.Equals(NS_GET_IID(nsIAccessibleEditableText)))

    33     *aInstancePtr = static_cast<nsIAccessibleEditableText*>(text);

    34   else if (aIID.Equals(NS_GET_IID(nsIAccessibleHyperText)))

    35     *aInstancePtr = static_cast<nsIAccessibleHyperText*>(text);

    36   else

    37     return NS_ERROR_NO_INTERFACE;

    39   NS_ADDREF(text);

    40   return NS_OK;

    41 }

    43 ////////////////////////////////////////////////////////////////////////////////

    44 // nsIAccessibleText

    46 NS_IMETHODIMP

    47 xpcAccessibleHyperText::GetCharacterCount(int32_t* aCharacterCount)

    48 {

    49   NS_ENSURE_ARG_POINTER(aCharacterCount);

    50   *aCharacterCount = 0;

    52   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

    53   if (text->IsDefunct())

    54     return NS_ERROR_FAILURE;

    56   *aCharacterCount = text->CharacterCount();

    57   return NS_OK;

    58 }

    60 NS_IMETHODIMP

    61 xpcAccessibleHyperText::GetText(int32_t aStartOffset, int32_t aEndOffset,

    62                                 nsAString& aText)

    63 {

    64   aText.Truncate();

    66   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

    67   if (text->IsDefunct())

    68     return NS_ERROR_FAILURE;

    70   text->TextSubstring(aStartOffset, aEndOffset, aText);

    71   return NS_OK;

    72 }

    74 NS_IMETHODIMP

    75 xpcAccessibleHyperText::GetTextBeforeOffset(int32_t aOffset,

    76                                             AccessibleTextBoundary aBoundaryType,

    77                                             int32_t* aStartOffset,

    78                                             int32_t* aEndOffset,

    79                                             nsAString& aText)

    80 {

    81   NS_ENSURE_ARG_POINTER(aStartOffset);

    82   NS_ENSURE_ARG_POINTER(aEndOffset);

    83   *aStartOffset = *aEndOffset = 0;

    84   aText.Truncate();

    86   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

    87   if (text->IsDefunct())

    88     return NS_ERROR_FAILURE;

    90   text->TextBeforeOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);

    91   return NS_OK;

    92 }

    94 NS_IMETHODIMP

    95 xpcAccessibleHyperText::GetTextAtOffset(int32_t aOffset,

    96                                         AccessibleTextBoundary aBoundaryType,

    97                                         int32_t* aStartOffset,

    98                                         int32_t* aEndOffset, nsAString& aText)

    99 {

   100   NS_ENSURE_ARG_POINTER(aStartOffset);

   101   NS_ENSURE_ARG_POINTER(aEndOffset);

   102   *aStartOffset = *aEndOffset = 0;

   103   aText.Truncate();

   105   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   106   if (text->IsDefunct())

   107     return NS_ERROR_FAILURE;

   109   text->TextAtOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);

   110   return NS_OK;

   111 }

   113 NS_IMETHODIMP

   114 xpcAccessibleHyperText::GetTextAfterOffset(int32_t aOffset,

   115                                            AccessibleTextBoundary aBoundaryType,

   116                                            int32_t* aStartOffset,

   117                                            int32_t* aEndOffset, nsAString& aText)

   118 {

   119   NS_ENSURE_ARG_POINTER(aStartOffset);

   120   NS_ENSURE_ARG_POINTER(aEndOffset);

   121   *aStartOffset = *aEndOffset = 0;

   122   aText.Truncate();

   124   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   125   if (text->IsDefunct())

   126     return NS_ERROR_FAILURE;

   128   text->TextAfterOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);

   129   return NS_OK;

   130 }

   132 NS_IMETHODIMP

   133 xpcAccessibleHyperText::GetCharacterAtOffset(int32_t aOffset,

   134                                              char16_t* aCharacter)

   135 {

   136   NS_ENSURE_ARG_POINTER(aCharacter);

   137   *aCharacter = L'\0';

   139   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   140   if (text->IsDefunct())

   141     return NS_ERROR_FAILURE;

   143   *aCharacter = text->CharAt(aOffset);

   144   return NS_OK;

   145 }

   147 NS_IMETHODIMP

   148 xpcAccessibleHyperText::GetTextAttributes(bool aIncludeDefAttrs,

   149                                           int32_t aOffset,

   150                                           int32_t* aStartOffset,

   151                                           int32_t* aEndOffset,

   152                                           nsIPersistentProperties** aAttributes)

   153 {

   154   NS_ENSURE_ARG_POINTER(aStartOffset);

   155   NS_ENSURE_ARG_POINTER(aEndOffset);

   156   NS_ENSURE_ARG_POINTER(aAttributes);

   157   *aStartOffset = *aEndOffset = 0;

   158   *aAttributes = nullptr;

   160   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   161   if (text->IsDefunct())

   162     return NS_ERROR_FAILURE;

   164   nsCOMPtr<nsIPersistentProperties> attrs =

   165    text->TextAttributes(aIncludeDefAttrs, aOffset, aStartOffset, aEndOffset);

   166   attrs.swap(*aAttributes);

   168   return NS_OK;

   169 }

   171 NS_IMETHODIMP

   172 xpcAccessibleHyperText::GetDefaultTextAttributes(nsIPersistentProperties** aAttributes)

   173 {

   174   NS_ENSURE_ARG_POINTER(aAttributes);

   175   *aAttributes = nullptr;

   177   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   178   if (text->IsDefunct())

   179     return NS_ERROR_FAILURE;

   181   nsCOMPtr<nsIPersistentProperties> attrs = text->DefaultTextAttributes();

   182   attrs.swap(*aAttributes);

   183   return NS_OK;

   184 }

   186 NS_IMETHODIMP

   187 xpcAccessibleHyperText::GetCharacterExtents(int32_t aOffset,

   188                                             int32_t* aX, int32_t* aY,

   189                                             int32_t* aWidth, int32_t* aHeight,

   190                                             uint32_t aCoordType)

   191 {

   192   NS_ENSURE_ARG_POINTER(aX);

   193   NS_ENSURE_ARG_POINTER(aY);

   194   NS_ENSURE_ARG_POINTER(aWidth);

   195   NS_ENSURE_ARG_POINTER(aHeight);

   196   *aX = *aY = *aWidth = *aHeight;

   198   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   199   if (text->IsDefunct())

   200     return NS_ERROR_FAILURE;

   202   nsIntRect rect = text->CharBounds(aOffset, aCoordType);

   203   *aX = rect.x; *aY = rect.y;

   204   *aWidth = rect.width; *aHeight = rect.height;

   205   return NS_OK;

   206 }

   208 NS_IMETHODIMP

   209 xpcAccessibleHyperText::GetRangeExtents(int32_t aStartOffset, int32_t aEndOffset,

   210                                         int32_t* aX, int32_t* aY,

   211                                         int32_t* aWidth, int32_t* aHeight,

   212                                         uint32_t aCoordType)

   213 {

   214   NS_ENSURE_ARG_POINTER(aX);

   215   NS_ENSURE_ARG_POINTER(aY);

   216   NS_ENSURE_ARG_POINTER(aWidth);

   217   NS_ENSURE_ARG_POINTER(aHeight);

   218   *aX = *aY = *aWidth = *aHeight = 0;

   220   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   221   if (text->IsDefunct())

   222     return NS_ERROR_FAILURE;

   224   nsIntRect rect = text->TextBounds(aStartOffset, aEndOffset, aCoordType);

   225   *aX = rect.x; *aY = rect.y;

   226   *aWidth = rect.width; *aHeight = rect.height;

   227   return NS_OK;

   228 }

   230 NS_IMETHODIMP

   231 xpcAccessibleHyperText::GetOffsetAtPoint(int32_t aX, int32_t aY,

   232                                          uint32_t aCoordType, int32_t* aOffset)

   233 {

   234   NS_ENSURE_ARG_POINTER(aOffset);

   235   *aOffset = -1;

   237   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   238   if (text->IsDefunct())

   239     return NS_ERROR_FAILURE;

   241   *aOffset = text->OffsetAtPoint(aX, aY, aCoordType);

   242   return NS_OK;

   243 }

   245 NS_IMETHODIMP

   246 xpcAccessibleHyperText::GetScriptableCaretOffset(int32_t* aCaretOffset)

   247 {

   248   NS_ENSURE_ARG_POINTER(aCaretOffset);

   249   *aCaretOffset = -1;

   251   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   252   if (text->IsDefunct())

   253     return NS_ERROR_FAILURE;

   255   *aCaretOffset = text->CaretOffset();

   256   return NS_OK;

   257 }

   259 NS_IMETHODIMP

   260 xpcAccessibleHyperText::SetScriptableCaretOffset(int32_t aCaretOffset)

   261 {

   262   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   263   if (text->IsDefunct())

   264     return NS_ERROR_FAILURE;

   266   text->SetCaretOffset(aCaretOffset);

   267   return NS_OK;

   268 }

   270 NS_IMETHODIMP

   271 xpcAccessibleHyperText::GetSelectionCount(int32_t* aSelectionCount)

   272 {

   273   NS_ENSURE_ARG_POINTER(aSelectionCount);

   274   *aSelectionCount = 0;

   276   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   277   if (text->IsDefunct())

   278     return NS_ERROR_FAILURE;

   280   *aSelectionCount = text->SelectionCount();

   281   return NS_OK;

   282 }

   284 NS_IMETHODIMP

   285 xpcAccessibleHyperText::GetSelectionBounds(int32_t aSelectionNum,

   286                                            int32_t* aStartOffset,

   287                                            int32_t* aEndOffset)

   288 {

   289   NS_ENSURE_ARG_POINTER(aStartOffset);

   290   NS_ENSURE_ARG_POINTER(aEndOffset);

   291   *aStartOffset = *aEndOffset = 0;

   293   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   294   if (text->IsDefunct())

   295     return NS_ERROR_FAILURE;

   297   if (aSelectionNum < 0 || aSelectionNum >= text->SelectionCount())

   298     return NS_ERROR_INVALID_ARG;

   300   text->SelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);

   301   return NS_OK;

   302 }

   304 NS_IMETHODIMP

   305 xpcAccessibleHyperText::SetSelectionBounds(int32_t aSelectionNum,

   306                                            int32_t aStartOffset,

   307                                            int32_t aEndOffset)

   308 {

   309   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   310   if (text->IsDefunct())

   311     return NS_ERROR_FAILURE;

   313   if (aSelectionNum < 0 ||

   314       !text->SetSelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset))

   315     return NS_ERROR_INVALID_ARG;

   317   return NS_OK;

   318 }

   320 NS_IMETHODIMP

   321 xpcAccessibleHyperText::AddSelection(int32_t aStartOffset, int32_t aEndOffset)

   322 {

   323   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   324   if (text->IsDefunct())

   325     return NS_ERROR_FAILURE;

   327   text->AddToSelection(aStartOffset, aEndOffset);

   328   return NS_OK;

   329 }

   331 NS_IMETHODIMP

   332 xpcAccessibleHyperText::RemoveSelection(int32_t aSelectionNum)

   333 {

   334   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   335   if (text->IsDefunct())

   336     return NS_ERROR_FAILURE;

   338   text->RemoveFromSelection(aSelectionNum);

   339   return NS_OK;

   340 }

   342 NS_IMETHODIMP

   343 xpcAccessibleHyperText::ScriptableScrollSubstringTo(int32_t aStartOffset,

   344                                                     int32_t aEndOffset,

   345                                                     uint32_t aScrollType)

   346 {

   347   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   348   if (text->IsDefunct())

   349     return NS_ERROR_FAILURE;

   351   text->ScrollSubstringTo(aStartOffset, aEndOffset, aScrollType);

   352   return NS_OK;

   353 }

   355 NS_IMETHODIMP

   356 xpcAccessibleHyperText::ScriptableScrollSubstringToPoint(int32_t aStartOffset,

   357                                                          int32_t aEndOffset,

   358                                                          uint32_t aCoordinateType,

   359                                                          int32_t aX, int32_t aY)

   360 {

   361   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   362   if (text->IsDefunct())

   363     return NS_ERROR_FAILURE;

   365   text->ScrollSubstringToPoint(aStartOffset, aEndOffset, aCoordinateType, aX, aY);

   366   return NS_OK;

   367 }

   369 NS_IMETHODIMP

   370 xpcAccessibleHyperText::GetEnclosingRange(nsIAccessibleTextRange** aRange)

   371 {

   372   NS_ENSURE_ARG_POINTER(aRange);

   373   *aRange = nullptr;

   375   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   376   if (text->IsDefunct())

   377     return NS_ERROR_FAILURE;

   379   nsRefPtr<xpcAccessibleTextRange> range = new xpcAccessibleTextRange;

   380   text->EnclosingRange(range->mRange);

   381   NS_ASSERTION(range->mRange.IsValid(),

   382                "Should always have an enclosing range!");

   384   range.forget(aRange);

   386   return NS_OK;

   387 }

   389 NS_IMETHODIMP

   390 xpcAccessibleHyperText::GetSelectionRanges(nsIArray** aRanges)

   391 {

   392   NS_ENSURE_ARG_POINTER(aRanges);

   393   *aRanges = nullptr;

   395   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   396   if (text->IsDefunct())

   397     return NS_ERROR_FAILURE;

   399   nsresult rv = NS_OK;

   400   nsCOMPtr<nsIMutableArray> xpcRanges =

   401     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);

   402   NS_ENSURE_SUCCESS(rv, rv);

   404   nsAutoTArray<TextRange, 1> ranges;

   405   text->SelectionRanges(&ranges);

   406   uint32_t len = ranges.Length();

   407   for (uint32_t idx = 0; idx < len; idx++)

   408     xpcRanges->AppendElement(new xpcAccessibleTextRange(Move(ranges[idx])),

   409                              false);

   411   xpcRanges.forget(aRanges);

   412   return NS_OK;

   413 }

   415 NS_IMETHODIMP

   416 xpcAccessibleHyperText::GetVisibleRanges(nsIArray** aRanges)

   417 {

   418   NS_ENSURE_ARG_POINTER(aRanges);

   419   *aRanges = nullptr;

   421   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   422   if (text->IsDefunct())

   423     return NS_ERROR_FAILURE;

   425   nsresult rv = NS_OK;

   426   nsCOMPtr<nsIMutableArray> xpcRanges =

   427     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);

   428   NS_ENSURE_SUCCESS(rv, rv);

   430   nsTArray<TextRange> ranges;

   431   text->VisibleRanges(&ranges);

   432   uint32_t len = ranges.Length();

   433   for (uint32_t idx = 0; idx < len; idx++)

   434     xpcRanges->AppendElement(new xpcAccessibleTextRange(Move(ranges[idx])),

   435                              false);

   437   xpcRanges.forget(aRanges);

   438   return NS_OK;

   439 }

   441 NS_IMETHODIMP

   442 xpcAccessibleHyperText::GetRangeByChild(nsIAccessible* aChild,

   443                                         nsIAccessibleTextRange** aRange)

   444 {

   445   NS_ENSURE_ARG_POINTER(aRange);

   446   *aRange = nullptr;

   448   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   449   if (text->IsDefunct())

   450     return NS_ERROR_FAILURE;

   452   nsRefPtr<Accessible> child = do_QueryObject(aChild);

   453   if (child) {

   454     nsRefPtr<xpcAccessibleTextRange> range = new xpcAccessibleTextRange;

   455     text->RangeByChild(child, range->mRange);

   456     if (range->mRange.IsValid())

   457       range.forget(aRange);

   458   }

   460   return NS_OK;

   461 }

   463 NS_IMETHODIMP

   464 xpcAccessibleHyperText::GetRangeAtPoint(int32_t aX, int32_t aY,

   465                                         nsIAccessibleTextRange** aRange)

   466 {

   467   NS_ENSURE_ARG_POINTER(aRange);

   468   *aRange = nullptr;

   470   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   471   if (text->IsDefunct())

   472     return NS_ERROR_FAILURE;

   474   nsRefPtr<xpcAccessibleTextRange> range = new xpcAccessibleTextRange;

   475   text->RangeAtPoint(aX, aY, range->mRange);

   476   if (range->mRange.IsValid())

   477     range.forget(aRange);

   479   return NS_OK;

   480 }

   482 ////////////////////////////////////////////////////////////////////////////////

   483 // nsIAccessibleEditableText

   485 NS_IMETHODIMP

   486 xpcAccessibleHyperText::SetTextContents(const nsAString& aText)

   487 {

   488   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   489   if (text->IsDefunct())

   490     return NS_ERROR_FAILURE;

   492   text->ReplaceText(aText);

   493   return NS_OK;

   494 }

   496 NS_IMETHODIMP

   497 xpcAccessibleHyperText::ScriptableInsertText(const nsAString& aText,

   498                                              int32_t aOffset)

   499 {

   500   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   501   if (text->IsDefunct())

   502     return NS_ERROR_FAILURE;

   504   text->InsertText(aText, aOffset);

   505   return NS_OK;

   506 }

   508 NS_IMETHODIMP

   509 xpcAccessibleHyperText::ScriptableCopyText(int32_t aStartOffset,

   510                                            int32_t aEndOffset)

   511 {

   512   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   513   if (text->IsDefunct())

   514     return NS_ERROR_FAILURE;

   516   text->CopyText(aStartOffset, aEndOffset);

   517   return NS_OK;

   518 }

   520 NS_IMETHODIMP

   521 xpcAccessibleHyperText::ScriptableCutText(int32_t aStartOffset,

   522                                           int32_t aEndOffset)

   523 {

   524   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   525   if (text->IsDefunct())

   526     return NS_ERROR_FAILURE;

   528   text->CutText(aStartOffset, aEndOffset);

   529   return NS_OK;

   530 }

   532 NS_IMETHODIMP

   533 xpcAccessibleHyperText::ScriptableDeleteText(int32_t aStartOffset,

   534                                              int32_t aEndOffset)

   535 {

   536   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   537   if (text->IsDefunct())

   538     return NS_ERROR_FAILURE;

   540   text->DeleteText(aStartOffset, aEndOffset);

   541   return NS_OK;

   542 }

   544 NS_IMETHODIMP

   545 xpcAccessibleHyperText::ScriptablePasteText(int32_t aOffset)

   546 {

   547   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   548   if (text->IsDefunct())

   549     return NS_ERROR_FAILURE;

   551   text->PasteText(aOffset);

   552   return NS_OK;

   553 }

   555 ////////////////////////////////////////////////////////////////////////////////

   556 // nsIAccessibleHyperText

   558 NS_IMETHODIMP

   559 xpcAccessibleHyperText::GetLinkCount(int32_t* aLinkCount)

   560 {

   561   NS_ENSURE_ARG_POINTER(aLinkCount);

   562   *aLinkCount = 0;

   564   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   565   if (text->IsDefunct())

   566     return NS_ERROR_FAILURE;

   568   *aLinkCount = text->LinkCount();

   569   return NS_OK;

   570 }

   572 NS_IMETHODIMP

   573 xpcAccessibleHyperText::GetLinkAt(int32_t aIndex, nsIAccessibleHyperLink** aLink)

   574 {

   575   NS_ENSURE_ARG_POINTER(aLink);

   576   *aLink = nullptr;

   578   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   579   if (text->IsDefunct())

   580     return NS_ERROR_FAILURE;

   582   nsCOMPtr<nsIAccessibleHyperLink> link = text->LinkAt(aIndex);

   583   link.forget(aLink);

   585   return NS_OK;

   586 }

   588 NS_IMETHODIMP

   589 xpcAccessibleHyperText::GetLinkIndex(nsIAccessibleHyperLink* aLink,

   590                                      int32_t* aIndex)

   591 {

   592   NS_ENSURE_ARG_POINTER(aLink);

   593   NS_ENSURE_ARG_POINTER(aIndex);

   594   *aIndex = -1;

   596   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   597   if (text->IsDefunct())

   598     return NS_ERROR_FAILURE;

   600   nsRefPtr<Accessible> link(do_QueryObject(aLink));

   601   *aIndex = text->LinkIndexOf(link);

   602   return NS_OK;

   603 }

   605 NS_IMETHODIMP

   606 xpcAccessibleHyperText::GetLinkIndexAtOffset(int32_t aOffset,

   607                                              int32_t* aLinkIndex)

   608 {

   609   NS_ENSURE_ARG_POINTER(aLinkIndex);

   610   *aLinkIndex = -1; // API says this magic value means 'not found'

   612   HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);

   613   if (text->IsDefunct())

   614     return NS_ERROR_FAILURE;

   616   *aLinkIndex = text->LinkIndexAtOffset(aOffset);

   617   return NS_OK;

   618 }

The Tor Browser / file revision

accessible/src/xpcom/xpcAccessibleHyperText.cpp@6474c204b198

accessible/src/xpcom/xpcAccessibleHyperText.cpp