The Tor Browser: accessible/src/xpcom/xpcAccessibleTable.cpp@97036ab72558

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

     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 "xpcAccessibleTable.h"

     9 #include "Accessible.h"

    10 #include "TableAccessible.h"

    12 #include "nsIMutableArray.h"

    13 #include "nsComponentManagerUtils.h"

    15 using namespace mozilla::a11y;

    17 static const uint32_t XPC_TABLE_DEFAULT_SIZE = 40;

    19 nsresult

    20 xpcAccessibleTable::GetCaption(nsIAccessible** aCaption)

    21 {

    22   NS_ENSURE_ARG_POINTER(aCaption);

    23   *aCaption = nullptr;

    24   if (!mTable)

    25     return NS_ERROR_FAILURE;

    27   NS_IF_ADDREF(*aCaption = mTable->Caption());

    28   return NS_OK;

    29 }

    31 nsresult

    32 xpcAccessibleTable::GetColumnCount(int32_t* aColumnCount)

    33 {

    34   NS_ENSURE_ARG_POINTER(aColumnCount);

    35   *aColumnCount = 0;

    37   if (!mTable)

    38     return NS_ERROR_FAILURE;

    40   *aColumnCount = mTable->ColCount();

    41   return NS_OK;

    42 }

    44 nsresult

    45 xpcAccessibleTable::GetRowCount(int32_t* aRowCount)

    46 {

    47   NS_ENSURE_ARG_POINTER(aRowCount);

    48   *aRowCount = 0;

    50   if (!mTable)

    51     return NS_ERROR_FAILURE;

    53   *aRowCount = mTable->RowCount();

    54   return NS_OK;

    55 }

    57 nsresult

    58 xpcAccessibleTable::GetCellAt(int32_t aRowIdx, int32_t aColIdx,

    59                               nsIAccessible** aCell)

    60 {

    61   NS_ENSURE_ARG_POINTER(aCell);

    62   *aCell = nullptr;

    64   if (!mTable)

    65     return NS_ERROR_FAILURE;

    67   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount() ||

    68       aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())

    69     return NS_ERROR_INVALID_ARG;

    71   NS_IF_ADDREF(*aCell = mTable->CellAt(aRowIdx, aColIdx));

    72   return NS_OK;

    73 }

    75 nsresult

    76 xpcAccessibleTable::GetCellIndexAt(int32_t aRowIdx, int32_t aColIdx,

    77                                    int32_t* aCellIdx)

    78 {

    79   NS_ENSURE_ARG_POINTER(aCellIdx);

    80   *aCellIdx = -1;

    82   if (!mTable)

    83     return NS_ERROR_FAILURE;

    85   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount() ||

    86       aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())

    87     return NS_ERROR_INVALID_ARG;

    89   *aCellIdx = mTable->CellIndexAt(aRowIdx, aColIdx);

    90   return NS_OK;

    91 }

    93 nsresult

    94 xpcAccessibleTable::GetColumnExtentAt(int32_t aRowIdx, int32_t aColIdx,

    95                                       int32_t* aColumnExtent)

    96 {

    97   NS_ENSURE_ARG_POINTER(aColumnExtent);

    98   *aColumnExtent = -1;

   100   if (!mTable)

   101     return NS_ERROR_FAILURE;

   103   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount() ||

   104       aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())

   105     return NS_ERROR_INVALID_ARG;

   107   *aColumnExtent = mTable->ColExtentAt(aRowIdx, aColIdx);

   108   return NS_OK;

   109 }

   111 nsresult

   112 xpcAccessibleTable::GetRowExtentAt(int32_t aRowIdx, int32_t aColIdx,

   113                                    int32_t* aRowExtent)

   114 {

   115   NS_ENSURE_ARG_POINTER(aRowExtent);

   116   *aRowExtent = -1;

   118   if (!mTable)

   119     return NS_ERROR_FAILURE;

   121   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount() ||

   122       aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())

   123     return NS_ERROR_INVALID_ARG;

   125   *aRowExtent = mTable->RowExtentAt(aRowIdx, aColIdx);

   126   return NS_OK;

   127 }

   129 nsresult

   130 xpcAccessibleTable::GetColumnDescription(int32_t aColIdx,

   131                                          nsAString& aDescription)

   132 {

   133   if (!mTable)

   134     return NS_ERROR_FAILURE;

   136   if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())

   137     return NS_ERROR_INVALID_ARG;

   139   nsAutoString description;

   140   mTable->ColDescription(aColIdx, description);

   141   aDescription.Assign(description);

   143   return NS_OK;

   144 }

   146 nsresult

   147 xpcAccessibleTable::GetRowDescription(int32_t aRowIdx, nsAString& aDescription)

   148 {

   149   if (!mTable)

   150     return NS_ERROR_FAILURE;

   152   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->ColCount())

   153     return NS_ERROR_INVALID_ARG;

   155   nsAutoString description;

   156   mTable->RowDescription(aRowIdx, description);

   157   aDescription.Assign(description);

   159   return NS_OK;

   160 }

   162 nsresult

   163 xpcAccessibleTable::IsColumnSelected(int32_t aColIdx, bool* aIsSelected)

   164 {

   165   NS_ENSURE_ARG_POINTER(aIsSelected);

   166   *aIsSelected = false;

   168   if (!mTable)

   169     return NS_ERROR_FAILURE;

   171   if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())

   172     return NS_ERROR_INVALID_ARG;

   174   *aIsSelected = mTable->IsColSelected(aColIdx);

   175   return NS_OK;

   176 }

   178 nsresult

   179 xpcAccessibleTable::IsRowSelected(int32_t aRowIdx, bool* aIsSelected)

   180 {

   181   NS_ENSURE_ARG_POINTER(aIsSelected);

   182   *aIsSelected = false;

   184   if (!mTable)

   185     return NS_ERROR_FAILURE;

   187   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount())

   188     return NS_ERROR_INVALID_ARG;

   190   *aIsSelected = mTable->IsRowSelected(aRowIdx);

   191   return NS_OK;

   192 }

   194 nsresult

   195 xpcAccessibleTable::IsCellSelected(int32_t aRowIdx, int32_t aColIdx,

   196                                    bool* aIsSelected)

   197 {

   198   NS_ENSURE_ARG_POINTER(aIsSelected);

   199   *aIsSelected = false;

   201   if (!mTable)

   202     return NS_ERROR_FAILURE;

   204   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount() ||

   205       aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())

   206     return NS_ERROR_INVALID_ARG;

   208   *aIsSelected = mTable->IsCellSelected(aRowIdx, aColIdx);

   209   return NS_OK;

   210 }

   212 nsresult

   213 xpcAccessibleTable::GetSelectedCellCount(uint32_t* aSelectedCellCount)

   214 {

   215   NS_ENSURE_ARG_POINTER(aSelectedCellCount);

   216   *aSelectedCellCount = 0;

   218   if (!mTable)

   219     return NS_ERROR_FAILURE;

   221   *aSelectedCellCount = mTable->SelectedCellCount();

   222   return NS_OK;

   223 }

   225 nsresult

   226 xpcAccessibleTable::GetSelectedColumnCount(uint32_t* aSelectedColumnCount)

   227 {

   228   NS_ENSURE_ARG_POINTER(aSelectedColumnCount);

   229   *aSelectedColumnCount = 0;

   231   if (!mTable)

   232     return NS_ERROR_FAILURE;

   234   *aSelectedColumnCount = mTable->SelectedColCount();

   235   return NS_OK;

   236 }

   238 nsresult

   239 xpcAccessibleTable::GetSelectedRowCount(uint32_t* aSelectedRowCount)

   240 {

   241   NS_ENSURE_ARG_POINTER(aSelectedRowCount);

   242   *aSelectedRowCount = 0;

   244   if (!mTable)

   245     return NS_ERROR_FAILURE;

   247   *aSelectedRowCount = mTable->SelectedRowCount();

   248   return NS_OK;

   249 }

   251 nsresult

   252 xpcAccessibleTable::GetSelectedCells(nsIArray** aSelectedCells)

   253 {

   254   NS_ENSURE_ARG_POINTER(aSelectedCells);

   255   *aSelectedCells = nullptr;

   257   if (!mTable)

   258     return NS_ERROR_FAILURE;

   260   nsresult rv = NS_OK;

   261   nsCOMPtr<nsIMutableArray> selCells =

   262     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);

   263   NS_ENSURE_SUCCESS(rv, rv);

   265   nsAutoTArray<Accessible*, XPC_TABLE_DEFAULT_SIZE> cellsArray;

   266   mTable->SelectedCells(&cellsArray);

   268   uint32_t totalCount = cellsArray.Length();

   269   for (uint32_t idx = 0; idx < totalCount; idx++) {

   270     Accessible* cell = cellsArray.ElementAt(idx);

   271     selCells -> AppendElement(static_cast<nsIAccessible*>(cell), false);

   272   }

   274   NS_ADDREF(*aSelectedCells = selCells);

   275   return NS_OK;

   276 }

   278 nsresult

   279 xpcAccessibleTable::GetSelectedCellIndices(uint32_t* aCellsArraySize,

   280                                            int32_t** aCellsArray)

   281 {

   282   NS_ENSURE_ARG_POINTER(aCellsArraySize);

   283   *aCellsArraySize = 0;

   285   NS_ENSURE_ARG_POINTER(aCellsArray);

   286   *aCellsArray = 0;

   288   if (!mTable)

   289     return NS_ERROR_FAILURE;

   291   nsAutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> cellsArray;

   292   mTable->SelectedCellIndices(&cellsArray);

   294   *aCellsArraySize = cellsArray.Length();

   295   *aCellsArray = static_cast<int32_t*>

   296     (moz_xmalloc(*aCellsArraySize * sizeof(int32_t)));

   297   memcpy(*aCellsArray, cellsArray.Elements(),

   298     *aCellsArraySize * sizeof(int32_t));

   300   return NS_OK;

   301 }

   303 nsresult

   304 xpcAccessibleTable::GetSelectedColumnIndices(uint32_t* aColsArraySize,

   305                                              int32_t** aColsArray)

   306 {

   307   NS_ENSURE_ARG_POINTER(aColsArraySize);

   308   *aColsArraySize = 0;

   310   NS_ENSURE_ARG_POINTER(aColsArray);

   311   *aColsArray = 0;

   313   if (!mTable)

   314     return NS_ERROR_FAILURE;

   316   nsAutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> colsArray;

   317   mTable->SelectedColIndices(&colsArray);

   319   *aColsArraySize = colsArray.Length();

   320   *aColsArray = static_cast<int32_t*>

   321     (moz_xmalloc(*aColsArraySize * sizeof(int32_t)));

   322   memcpy(*aColsArray, colsArray.Elements(),

   323     *aColsArraySize * sizeof(int32_t));

   325   return NS_OK;

   326 }

   328 nsresult

   329 xpcAccessibleTable::GetSelectedRowIndices(uint32_t* aRowsArraySize,

   330                                           int32_t** aRowsArray)

   331 {

   332   NS_ENSURE_ARG_POINTER(aRowsArraySize);

   333   *aRowsArraySize = 0;

   335   NS_ENSURE_ARG_POINTER(aRowsArray);

   336   *aRowsArray = 0;

   338   if (!mTable)

   339     return NS_ERROR_FAILURE;

   341   nsAutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> rowsArray;

   342   mTable->SelectedRowIndices(&rowsArray);

   344   *aRowsArraySize = rowsArray.Length();

   345   *aRowsArray = static_cast<int32_t*>

   346     (moz_xmalloc(*aRowsArraySize * sizeof(int32_t)));

   347   memcpy(*aRowsArray, rowsArray.Elements(),

   348     *aRowsArraySize * sizeof(int32_t));

   350   return NS_OK;

   351 }

   353 nsresult

   354 xpcAccessibleTable::GetColumnIndexAt(int32_t aCellIdx, int32_t* aColIdx)

   355 {

   356   NS_ENSURE_ARG_POINTER(aColIdx);

   357   *aColIdx = -1;

   359   if (!mTable)

   360     return NS_ERROR_FAILURE;

   362   if (aCellIdx < 0

   363       || static_cast<uint32_t>(aCellIdx)

   364       >= mTable->RowCount() * mTable->ColCount())

   365     return NS_ERROR_INVALID_ARG;

   367   *aColIdx = mTable->ColIndexAt(aCellIdx);

   368   return NS_OK;

   369 }

   371 nsresult

   372 xpcAccessibleTable::GetRowIndexAt(int32_t aCellIdx, int32_t* aRowIdx)

   373 {

   374   NS_ENSURE_ARG_POINTER(aRowIdx);

   375   *aRowIdx = -1;

   377   if (!mTable)

   378     return NS_ERROR_FAILURE;

   380   if (aCellIdx < 0

   381       || static_cast<uint32_t>(aCellIdx)

   382       >= mTable->RowCount() * mTable->ColCount())

   383     return NS_ERROR_INVALID_ARG;

   385   *aRowIdx = mTable->RowIndexAt(aCellIdx);

   386   return NS_OK;

   387 }

   389 nsresult

   390 xpcAccessibleTable::GetRowAndColumnIndicesAt(int32_t aCellIdx, int32_t* aRowIdx,

   391                                              int32_t* aColIdx)

   392 {

   393   NS_ENSURE_ARG_POINTER(aRowIdx);

   394   *aRowIdx = -1;

   395   NS_ENSURE_ARG_POINTER(aColIdx);

   396   *aColIdx = -1;

   398   if (!mTable)

   399     return NS_ERROR_FAILURE;

   401   if (aCellIdx < 0

   402       || static_cast<uint32_t>(aCellIdx)

   403       >= mTable->RowCount() * mTable->ColCount())

   404     return NS_ERROR_INVALID_ARG;

   406   mTable->RowAndColIndicesAt(aCellIdx, aRowIdx, aColIdx);

   407   return NS_OK;

   408 }

   410 nsresult

   411 xpcAccessibleTable::GetSummary(nsAString& aSummary)

   412 {

   413   if (!mTable)

   414     return NS_ERROR_FAILURE;

   416   nsAutoString summary;

   417   mTable->Summary(summary);

   418   aSummary.Assign(summary);

   420   return NS_OK;

   421 }

   423 nsresult

   424 xpcAccessibleTable::IsProbablyForLayout(bool* aResult)

   425 {

   426   NS_ENSURE_ARG_POINTER(aResult);

   427   *aResult = false;

   428   if (!mTable)

   429     return NS_ERROR_FAILURE;

   431   *aResult = mTable->IsProbablyLayoutTable();

   432   return NS_OK;

   433 }

   435 nsresult

   436 xpcAccessibleTable::SelectColumn(int32_t aColIdx)

   437 {

   438   if (!mTable)

   439     return NS_ERROR_FAILURE;

   441   if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())

   442     return NS_ERROR_INVALID_ARG;

   444   mTable->SelectCol(aColIdx);

   445   return NS_OK;

   446 }

   448 nsresult

   449 xpcAccessibleTable::SelectRow(int32_t aRowIdx)

   450 {

   451   if (!mTable)

   452     return NS_ERROR_FAILURE;

   454   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount())

   455     return NS_ERROR_INVALID_ARG;

   457   mTable->SelectRow(aRowIdx);

   458   return NS_OK;

   459 }

   461 nsresult

   462 xpcAccessibleTable::UnselectColumn(int32_t aColIdx)

   463 {

   464   if (!mTable)

   465     return NS_ERROR_FAILURE;

   467   if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())

   468     return NS_ERROR_INVALID_ARG;

   470   mTable->UnselectCol(aColIdx);

   471   return NS_OK;

   472 }

   474 nsresult

   475 xpcAccessibleTable::UnselectRow(int32_t aRowIdx)

   476 {

   477   if (!mTable)

   478     return NS_ERROR_FAILURE;

   480   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount())

   481     return NS_ERROR_INVALID_ARG;

   483   mTable->UnselectRow(aRowIdx);

   484   return NS_OK;

   485 }

The Tor Browser / file revision

accessible/src/xpcom/xpcAccessibleTable.cpp@97036ab72558

accessible/src/xpcom/xpcAccessibleTable.cpp