tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

QuotaRequests.cpp (6351B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=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
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "QuotaRequests.h"
      8 
      9 // Local includes
     10 #include "ActorsChild.h"
     11 
     12 // Global includes
     13 #include "mozilla/ErrorNames.h"
     14 #include "mozilla/dom/quota/QuotaUsageRequestChild.h"
     15 #include "nsDebug.h"
     16 #include "nsIQuotaCallbacks.h"
     17 #include "nsISupportsUtils.h"
     18 #include "nsIVariant.h"
     19 #include "nsStringFwd.h"
     20 #include "nscore.h"
     21 
     22 namespace mozilla {
     23 class Runnable;
     24 }
     25 
     26 namespace mozilla::dom::quota {
     27 
     28 RequestBase::RequestBase() : mResultCode(NS_OK), mHaveResultOrErrorCode(false) {
     29  AssertIsOnOwningThread();
     30 }
     31 
     32 RequestBase::RequestBase(nsIPrincipal* aPrincipal)
     33    : mPrincipal(aPrincipal),
     34      mResultCode(NS_OK),
     35      mHaveResultOrErrorCode(false) {
     36  AssertIsOnOwningThread();
     37 }
     38 
     39 #ifdef DEBUG
     40 
     41 void RequestBase::AssertIsOnOwningThread() const {
     42  NS_ASSERT_OWNINGTHREAD(RequestBase);
     43 }
     44 
     45 #endif  // DEBUG
     46 
     47 void RequestBase::SetError(nsresult aRv) {
     48  AssertIsOnOwningThread();
     49  MOZ_ASSERT(mResultCode == NS_OK);
     50  MOZ_ASSERT(!mHaveResultOrErrorCode);
     51 
     52  mResultCode = aRv;
     53  mHaveResultOrErrorCode = true;
     54 
     55  FireCallback();
     56 }
     57 
     58 NS_IMPL_CYCLE_COLLECTION_0(RequestBase)
     59 
     60 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RequestBase)
     61  NS_INTERFACE_MAP_ENTRY(nsISupports)
     62 NS_INTERFACE_MAP_END
     63 
     64 NS_IMPL_CYCLE_COLLECTING_ADDREF(RequestBase)
     65 NS_IMPL_CYCLE_COLLECTING_RELEASE(RequestBase)
     66 
     67 NS_IMETHODIMP
     68 RequestBase::GetPrincipal(nsIPrincipal** aPrincipal) {
     69  AssertIsOnOwningThread();
     70  MOZ_ASSERT(aPrincipal);
     71 
     72  NS_IF_ADDREF(*aPrincipal = mPrincipal);
     73  return NS_OK;
     74 }
     75 
     76 NS_IMETHODIMP
     77 RequestBase::GetResultCode(nsresult* aResultCode) {
     78  AssertIsOnOwningThread();
     79  MOZ_ASSERT(aResultCode);
     80 
     81  if (!mHaveResultOrErrorCode) {
     82    return NS_ERROR_FAILURE;
     83  }
     84 
     85  *aResultCode = mResultCode;
     86  return NS_OK;
     87 }
     88 
     89 NS_IMETHODIMP
     90 RequestBase::GetResultName(nsACString& aResultName) {
     91  AssertIsOnOwningThread();
     92 
     93  if (!mHaveResultOrErrorCode) {
     94    return NS_ERROR_FAILURE;
     95  }
     96 
     97  mozilla::GetErrorName(mResultCode, aResultName);
     98  return NS_OK;
     99 }
    100 
    101 UsageRequest::UsageRequest(nsIQuotaUsageCallback* aCallback)
    102    : mCallback(aCallback), mBackgroundActor(nullptr), mCanceled(false) {
    103  AssertIsOnOwningThread();
    104  MOZ_ASSERT(aCallback);
    105 }
    106 
    107 UsageRequest::UsageRequest(nsIPrincipal* aPrincipal,
    108                           nsIQuotaUsageCallback* aCallback)
    109    : RequestBase(aPrincipal),
    110      mCallback(aCallback),
    111      mBackgroundActor(nullptr),
    112      mCanceled(false) {
    113  AssertIsOnOwningThread();
    114  MOZ_ASSERT(aPrincipal);
    115  MOZ_ASSERT(aCallback);
    116 }
    117 
    118 UsageRequest::~UsageRequest() { AssertIsOnOwningThread(); }
    119 
    120 void UsageRequest::SetBackgroundActor(
    121    QuotaUsageRequestChild* aBackgroundActor) {
    122  AssertIsOnOwningThread();
    123  MOZ_ASSERT(aBackgroundActor);
    124  MOZ_ASSERT(!mBackgroundActor);
    125 
    126  mBackgroundActor = aBackgroundActor;
    127 
    128  if (mCanceled) {
    129    mBackgroundActor->SendCancel();
    130  }
    131 }
    132 
    133 void UsageRequest::SetResult(nsIVariant* aResult) {
    134  AssertIsOnOwningThread();
    135  MOZ_ASSERT(aResult);
    136  MOZ_ASSERT(!mHaveResultOrErrorCode);
    137 
    138  mResult = aResult;
    139 
    140  mHaveResultOrErrorCode = true;
    141 
    142  FireCallback();
    143 }
    144 
    145 NS_IMPL_CYCLE_COLLECTION_INHERITED(UsageRequest, RequestBase, mCallback)
    146 
    147 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(UsageRequest)
    148  NS_INTERFACE_MAP_ENTRY(nsIQuotaUsageRequest)
    149 NS_INTERFACE_MAP_END_INHERITING(RequestBase)
    150 
    151 NS_IMPL_ADDREF_INHERITED(UsageRequest, RequestBase)
    152 NS_IMPL_RELEASE_INHERITED(UsageRequest, RequestBase)
    153 
    154 NS_IMETHODIMP
    155 UsageRequest::GetResult(nsIVariant** aResult) {
    156  AssertIsOnOwningThread();
    157  MOZ_ASSERT(aResult);
    158 
    159  if (!mHaveResultOrErrorCode) {
    160    return NS_ERROR_FAILURE;
    161  }
    162 
    163  NS_IF_ADDREF(*aResult = mResult);
    164  return NS_OK;
    165 }
    166 
    167 NS_IMETHODIMP
    168 UsageRequest::GetCallback(nsIQuotaUsageCallback** aCallback) {
    169  AssertIsOnOwningThread();
    170  MOZ_ASSERT(aCallback);
    171 
    172  NS_IF_ADDREF(*aCallback = mCallback);
    173  return NS_OK;
    174 }
    175 
    176 NS_IMETHODIMP
    177 UsageRequest::SetCallback(nsIQuotaUsageCallback* aCallback) {
    178  AssertIsOnOwningThread();
    179 
    180  mCallback = aCallback;
    181  return NS_OK;
    182 }
    183 
    184 NS_IMETHODIMP
    185 UsageRequest::Cancel() {
    186  AssertIsOnOwningThread();
    187 
    188  if (mCanceled) {
    189    NS_WARNING("Canceled more than once?!");
    190    return NS_ERROR_UNEXPECTED;
    191  }
    192 
    193  if (mBackgroundActor) {
    194    mBackgroundActor->SendCancel();
    195  }
    196 
    197  mCanceled = true;
    198 
    199  return NS_OK;
    200 }
    201 
    202 void UsageRequest::FireCallback() {
    203  AssertIsOnOwningThread();
    204  MOZ_ASSERT(mCallback);
    205 
    206  mCallback->OnUsageResult(this);
    207 
    208  // Clean up.
    209  mCallback = nullptr;
    210 }
    211 
    212 Request::Request() { AssertIsOnOwningThread(); }
    213 
    214 Request::Request(nsIPrincipal* aPrincipal) : RequestBase(aPrincipal) {
    215  AssertIsOnOwningThread();
    216  MOZ_ASSERT(aPrincipal);
    217 }
    218 
    219 Request::Request(nsIQuotaCallback* aCallback) : mCallback(aCallback) {
    220  AssertIsOnOwningThread();
    221  MOZ_ASSERT(aCallback);
    222 }
    223 
    224 Request::~Request() { AssertIsOnOwningThread(); }
    225 
    226 void Request::SetResult(nsIVariant* aResult) {
    227  AssertIsOnOwningThread();
    228  MOZ_ASSERT(aResult);
    229  MOZ_ASSERT(!mHaveResultOrErrorCode);
    230 
    231  mResult = aResult;
    232 
    233  mHaveResultOrErrorCode = true;
    234 
    235  FireCallback();
    236 }
    237 
    238 NS_IMETHODIMP
    239 Request::GetResult(nsIVariant** aResult) {
    240  AssertIsOnOwningThread();
    241  MOZ_ASSERT(aResult);
    242 
    243  if (!mHaveResultOrErrorCode) {
    244    return NS_ERROR_FAILURE;
    245  }
    246 
    247  NS_IF_ADDREF(*aResult = mResult);
    248  return NS_OK;
    249 }
    250 
    251 NS_IMPL_CYCLE_COLLECTION_INHERITED(Request, RequestBase, mCallback, mResult)
    252 
    253 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Request)
    254  NS_INTERFACE_MAP_ENTRY(nsIQuotaRequest)
    255 NS_INTERFACE_MAP_END_INHERITING(RequestBase)
    256 
    257 NS_IMPL_ADDREF_INHERITED(mozilla::dom::quota::Request, RequestBase)
    258 NS_IMPL_RELEASE_INHERITED(mozilla::dom::quota::Request, RequestBase)
    259 
    260 NS_IMETHODIMP
    261 Request::GetCallback(nsIQuotaCallback** aCallback) {
    262  AssertIsOnOwningThread();
    263  MOZ_ASSERT(aCallback);
    264 
    265  NS_IF_ADDREF(*aCallback = mCallback);
    266  return NS_OK;
    267 }
    268 
    269 NS_IMETHODIMP
    270 Request::SetCallback(nsIQuotaCallback* aCallback) {
    271  AssertIsOnOwningThread();
    272 
    273  mCallback = aCallback;
    274  return NS_OK;
    275 }
    276 
    277 void Request::FireCallback() {
    278  AssertIsOnOwningThread();
    279 
    280  if (mCallback) {
    281    mCallback->OnComplete(this);
    282 
    283    // Clean up.
    284    mCallback = nullptr;
    285  }
    286 }
    287 
    288 }  // namespace mozilla::dom::quota