The Tor Browser: accessible/src/windows/ia2/ia2AccessibleValue.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:expandtab:shiftwidth=2:tabstop=2:

     3  */

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

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

     6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     8 #include "ia2AccessibleValue.h"

    10 #include "AccessibleValue_i.c"

    12 #include "AccessibleWrap.h"

    13 #include "Accessible-inl.h"

    14 #include "IUnknownImpl.h"

    16 #include "mozilla/FloatingPoint.h"

    18 using namespace mozilla::a11y;

    20 // IUnknown

    22 STDMETHODIMP

    23 ia2AccessibleValue::QueryInterface(REFIID iid, void** ppv)

    24 {

    25   if (!ppv)

    26     return E_INVALIDARG;

    28   *ppv = nullptr;

    30   if (IID_IAccessibleValue == iid) {

    31     AccessibleWrap* valueAcc = static_cast<AccessibleWrap*>(this);

    32     if (valueAcc->HasNumericValue()) {

    33       *ppv = static_cast<IAccessibleValue*>(this);

    34       valueAcc->AddRef();

    35       return S_OK;

    36     }

    38     return E_NOINTERFACE;

    39   }

    41   return E_NOINTERFACE;

    42 }

    44 // IAccessibleValue

    46 STDMETHODIMP

    47 ia2AccessibleValue::get_currentValue(VARIANT* aCurrentValue)

    48 {

    49   A11Y_TRYBLOCK_BEGIN

    51   if (!aCurrentValue)

    52     return E_INVALIDARG;

    54   VariantInit(aCurrentValue);

    56   AccessibleWrap* valueAcc = static_cast<AccessibleWrap*>(this);

    57   if (valueAcc->IsDefunct())

    58     return CO_E_OBJNOTCONNECTED;

    60   double currentValue = valueAcc->CurValue();

    61   if (IsNaN(currentValue))

    62     return S_FALSE;

    64   aCurrentValue->vt = VT_R8;

    65   aCurrentValue->dblVal = currentValue;

    66   return S_OK;

    68   A11Y_TRYBLOCK_END

    69 }

    71 STDMETHODIMP

    72 ia2AccessibleValue::setCurrentValue(VARIANT aValue)

    73 {

    74   A11Y_TRYBLOCK_BEGIN

    76   AccessibleWrap* valueAcc = static_cast<AccessibleWrap*>(this);

    77   if (valueAcc->IsDefunct())

    78     return CO_E_OBJNOTCONNECTED;

    80   if (aValue.vt != VT_R8)

    81     return E_INVALIDARG;

    83   return valueAcc->SetCurValue(aValue.dblVal) ? S_OK : E_FAIL;

    85   A11Y_TRYBLOCK_END

    86 }

    88 STDMETHODIMP

    89 ia2AccessibleValue::get_maximumValue(VARIANT* aMaximumValue)

    90 {

    91   A11Y_TRYBLOCK_BEGIN

    93   if (!aMaximumValue)

    94     return E_INVALIDARG;

    96   VariantInit(aMaximumValue);

    98   AccessibleWrap* valueAcc = static_cast<AccessibleWrap*>(this);

    99   if (valueAcc->IsDefunct())

   100     return CO_E_OBJNOTCONNECTED;

   102   double maximumValue = valueAcc->MaxValue();

   103   if (IsNaN(maximumValue))

   104     return S_FALSE;

   106   aMaximumValue->vt = VT_R8;

   107   aMaximumValue->dblVal = maximumValue;

   108   return S_OK;

   110   A11Y_TRYBLOCK_END

   111 }

   113 STDMETHODIMP

   114 ia2AccessibleValue::get_minimumValue(VARIANT* aMinimumValue)

   115 {

   116   A11Y_TRYBLOCK_BEGIN

   118   if (!aMinimumValue)

   119     return E_INVALIDARG;

   121   VariantInit(aMinimumValue);

   123   AccessibleWrap* valueAcc = static_cast<AccessibleWrap*>(this);

   124   if (valueAcc->IsDefunct())

   125     return CO_E_OBJNOTCONNECTED;

   127   double minimumValue = valueAcc->MinValue();

   128   if (IsNaN(minimumValue))

   129     return S_FALSE;

   131   aMinimumValue->vt = VT_R8;

   132   aMinimumValue->dblVal = minimumValue;

   133   return S_OK;

   135   A11Y_TRYBLOCK_END

   136 }

The Tor Browser / file revision

accessible/src/windows/ia2/ia2AccessibleValue.cpp@97036ab72558

accessible/src/windows/ia2/ia2AccessibleValue.cpp