[ tor-browser ].git.dasho

QuotaParent.cpp (38584B)
      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 file,
      5 * You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "QuotaParent.h"
      8 
      9 #include <mozilla/Assertions.h>
     10 
     11 #include "OriginOperations.h"
     12 #include "QuotaRequestBase.h"
     13 #include "mozilla/RefPtr.h"
     14 #include "mozilla/dom/quota/ErrorHandling.h"
     15 #include "mozilla/dom/quota/PQuota.h"
     16 #include "mozilla/dom/quota/PQuotaRequestParent.h"
     17 #include "mozilla/dom/quota/PQuotaUsageRequestParent.h"
     18 #include "mozilla/dom/quota/PrincipalUtils.h"
     19 #include "mozilla/dom/quota/QuotaManager.h"
     20 #include "mozilla/dom/quota/QuotaUsageRequestParent.h"
     21 #include "mozilla/dom/quota/ResultExtensions.h"
     22 #include "mozilla/ipc/BackgroundParent.h"
     23 #include "nsDebug.h"
     24 #include "nsError.h"
     25 
     26 // CUF == CRASH_UNLESS_FUZZING
     27 #define QM_CUF_AND_IPC_FAIL(actor)                           \
     28  [&_actor = *actor](const auto& aFunc, const auto& aExpr) { \
     29    MOZ_CRASH_UNLESS_FUZZING();                              \
     30    return QM_IPC_FAIL(&_actor)(aFunc, aExpr);               \
     31  }
     32 
     33 namespace mozilla::dom::quota {
     34 
     35 using namespace mozilla::ipc;
     36 
     37 namespace {
     38 
     39 template <typename PromiseType, typename ResolverType, bool MoveOnly>
     40 class PromiseResolveOrRejectCallbackBase {
     41 public:
     42  PromiseResolveOrRejectCallbackBase(RefPtr<Quota> aQuota,
     43                                     ResolverType&& aResolver)
     44      : mResolver(std::move(aResolver)), mQuota(std::move(aQuota)) {}
     45 
     46 protected:
     47  bool CanSend() const { return mQuota->CanSend(); }
     48 
     49  ResolverType mResolver;
     50 
     51 private:
     52  RefPtr<Quota> mQuota;
     53 };
     54 
     55 template <typename PromiseType, typename ResolverType, bool MoveOnly>
     56 class PromiseResolveOrRejectCallback
     57    : public PromiseResolveOrRejectCallbackBase<PromiseType, ResolverType,
     58                                                MoveOnly> {};
     59 
     60 template <typename PromiseType, typename ResolverType>
     61 class PromiseResolveOrRejectCallback<PromiseType, ResolverType, true>
     62    : public PromiseResolveOrRejectCallbackBase<PromiseType, ResolverType,
     63                                                true> {
     64  using Base =
     65      PromiseResolveOrRejectCallbackBase<PromiseType, ResolverType, true>;
     66 
     67  using Base::CanSend;
     68  using Base::mResolver;
     69 
     70 public:
     71  PromiseResolveOrRejectCallback(RefPtr<Quota> aQuota, ResolverType&& aResolver)
     72      : Base(std::move(aQuota), std::move(aResolver)) {}
     73 
     74  void operator()(typename PromiseType::ResolveOrRejectValue&& aValue) {
     75    if (!CanSend()) {
     76      return;
     77    }
     78    if (aValue.IsResolve()) {
     79      mResolver(std::move(aValue.ResolveValue()));
     80    } else {
     81      mResolver(aValue.RejectValue());
     82    }
     83  }
     84 };
     85 
     86 template <typename PromiseType, typename ResolverType>
     87 class PromiseResolveOrRejectCallback<PromiseType, ResolverType, false>
     88    : public PromiseResolveOrRejectCallbackBase<PromiseType, ResolverType,
     89                                                false> {
     90  using Base =
     91      PromiseResolveOrRejectCallbackBase<PromiseType, ResolverType, false>;
     92 
     93  using Base::CanSend;
     94  using Base::mResolver;
     95 
     96 public:
     97  PromiseResolveOrRejectCallback(RefPtr<Quota> aQuota, ResolverType&& aResolver)
     98      : Base(std::move(aQuota), std::move(aResolver)) {}
     99 
    100  void operator()(const typename PromiseType::ResolveOrRejectValue& aValue) {
    101    if (!CanSend()) {
    102      return;
    103    }
    104 
    105    if (aValue.IsResolve()) {
    106      mResolver(aValue.ResolveValue());
    107    } else {
    108      mResolver(aValue.RejectValue());
    109    }
    110  }
    111 };
    112 
    113 using BoolPromiseResolveOrRejectCallback =
    114    PromiseResolveOrRejectCallback<BoolPromise, BoolResponseResolver, false>;
    115 using UInt64PromiseResolveOrRejectCallback =
    116    PromiseResolveOrRejectCallback<UInt64Promise, UInt64ResponseResolver,
    117                                   false>;
    118 using CStringArrayPromiseResolveOrRejectCallback =
    119    PromiseResolveOrRejectCallback<CStringArrayPromise,
    120                                   CStringArrayResponseResolver, true>;
    121 using OriginUsageMetadataArrayPromiseResolveOrRejectCallback =
    122    PromiseResolveOrRejectCallback<OriginUsageMetadataArrayPromise,
    123                                   OriginUsageMetadataArrayResponseResolver,
    124                                   true>;
    125 using UsageInfoPromiseResolveOrRejectCallback =
    126    PromiseResolveOrRejectCallback<UsageInfoPromise, UsageInfoResponseResolver,
    127                                   false>;
    128 
    129 }  // namespace
    130 
    131 already_AddRefed<PQuotaParent> AllocPQuotaParent() {
    132  AssertIsOnBackgroundThread();
    133 
    134  if (NS_WARN_IF(QuotaManager::IsShuttingDown())) {
    135    return nullptr;
    136  }
    137 
    138  auto actor = MakeRefPtr<Quota>();
    139 
    140  return actor.forget();
    141 }
    142 
    143 Quota::Quota()
    144 #ifdef DEBUG
    145    : mActorDestroyed(false)
    146 #endif
    147 {
    148 }
    149 
    150 Quota::~Quota() { MOZ_ASSERT(mActorDestroyed); }
    151 
    152 bool Quota::TrustParams() const {
    153 #ifdef DEBUG
    154  // Never trust parameters in DEBUG builds!
    155  bool trustParams = false;
    156 #else
    157  bool trustParams = !BackgroundParent::IsOtherProcessActor(Manager());
    158 #endif
    159 
    160  return trustParams;
    161 }
    162 
    163 bool Quota::VerifyRequestParams(const RequestParams& aParams) const {
    164  AssertIsOnBackgroundThread();
    165  MOZ_ASSERT(aParams.type() != RequestParams::T__None);
    166 
    167  switch (aParams.type()) {
    168    case RequestParams::TStorageNameParams:
    169      break;
    170 
    171    case RequestParams::TGetFullOriginMetadataParams: {
    172      const GetFullOriginMetadataParams& params =
    173          aParams.get_GetFullOriginMetadataParams();
    174      if (NS_WARN_IF(!IsBestEffortPersistenceType(params.persistenceType()))) {
    175        MOZ_CRASH_UNLESS_FUZZING();
    176        return false;
    177      }
    178 
    179      if (NS_WARN_IF(!IsPrincipalInfoValid(params.principalInfo()))) {
    180        MOZ_CRASH_UNLESS_FUZZING();
    181        return false;
    182      }
    183 
    184      break;
    185    }
    186 
    187    case RequestParams::TPersistedParams: {
    188      const PersistedParams& params = aParams.get_PersistedParams();
    189 
    190      if (NS_WARN_IF(!IsPrincipalInfoValid(params.principalInfo()))) {
    191        MOZ_CRASH_UNLESS_FUZZING();
    192        return false;
    193      }
    194 
    195      break;
    196    }
    197 
    198    case RequestParams::TPersistParams: {
    199      const PersistParams& params = aParams.get_PersistParams();
    200 
    201      if (NS_WARN_IF(!IsPrincipalInfoValid(params.principalInfo()))) {
    202        MOZ_CRASH_UNLESS_FUZZING();
    203        return false;
    204      }
    205 
    206      break;
    207    }
    208 
    209    case RequestParams::TEstimateParams: {
    210      const EstimateParams& params = aParams.get_EstimateParams();
    211 
    212      if (NS_WARN_IF(!IsPrincipalInfoValid(params.principalInfo()))) {
    213        MOZ_CRASH_UNLESS_FUZZING();
    214        return false;
    215      }
    216 
    217      break;
    218    }
    219 
    220    default:
    221      MOZ_CRASH("Should never get here!");
    222  }
    223 
    224  return true;
    225 }
    226 
    227 void Quota::ActorDestroy(ActorDestroyReason aWhy) {
    228  AssertIsOnBackgroundThread();
    229 #ifdef DEBUG
    230  MOZ_ASSERT(!mActorDestroyed);
    231  mActorDestroyed = true;
    232 #endif
    233 }
    234 
    235 PQuotaRequestParent* Quota::AllocPQuotaRequestParent(
    236    const RequestParams& aParams) {
    237  AssertIsOnBackgroundThread();
    238  MOZ_ASSERT(aParams.type() != RequestParams::T__None);
    239 
    240  if (NS_WARN_IF(QuotaManager::IsShuttingDown())) {
    241    return nullptr;
    242  }
    243 
    244  if (!TrustParams() && NS_WARN_IF(!VerifyRequestParams(aParams))) {
    245    MOZ_CRASH_UNLESS_FUZZING();
    246    return nullptr;
    247  }
    248 
    249  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    250                QuotaManager::GetOrCreate(), nullptr);
    251 
    252  auto actor = [&]() -> RefPtr<QuotaRequestBase> {
    253    switch (aParams.type()) {
    254      case RequestParams::TStorageNameParams:
    255        return CreateStorageNameOp(quotaManager);
    256 
    257      case RequestParams::TGetFullOriginMetadataParams:
    258        return CreateGetFullOriginMetadataOp(
    259            quotaManager, aParams.get_GetFullOriginMetadataParams());
    260 
    261      case RequestParams::TPersistedParams:
    262        return CreatePersistedOp(quotaManager, aParams);
    263 
    264      case RequestParams::TPersistParams:
    265        return CreatePersistOp(quotaManager, aParams);
    266 
    267      case RequestParams::TEstimateParams:
    268        return CreateEstimateOp(quotaManager, aParams.get_EstimateParams());
    269 
    270      default:
    271        MOZ_CRASH("Should never get here!");
    272    }
    273  }();
    274 
    275  MOZ_ASSERT(actor);
    276 
    277  quotaManager->RegisterNormalOriginOp(*actor);
    278 
    279  // Transfer ownership to IPDL.
    280  return actor.forget().take();
    281 }
    282 
    283 mozilla::ipc::IPCResult Quota::RecvPQuotaRequestConstructor(
    284    PQuotaRequestParent* aActor, const RequestParams& aParams) {
    285  AssertIsOnBackgroundThread();
    286  MOZ_ASSERT(aActor);
    287  MOZ_ASSERT(aParams.type() != RequestParams::T__None);
    288  MOZ_ASSERT(!QuotaManager::IsShuttingDown());
    289 
    290  auto* op = static_cast<QuotaRequestBase*>(aActor);
    291 
    292  op->RunImmediately();
    293  return IPC_OK();
    294 }
    295 
    296 bool Quota::DeallocPQuotaRequestParent(PQuotaRequestParent* aActor) {
    297  AssertIsOnBackgroundThread();
    298  MOZ_ASSERT(aActor);
    299 
    300  // Transfer ownership back from IPDL.
    301  RefPtr<QuotaRequestBase> actor =
    302      dont_AddRef(static_cast<QuotaRequestBase*>(aActor));
    303  return true;
    304 }
    305 
    306 mozilla::ipc::IPCResult Quota::RecvStorageInitialized(
    307    StorageInitializedResolver&& aResolver) {
    308  AssertIsOnBackgroundThread();
    309 
    310  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    311         ResolveBoolResponseAndReturn(aResolver));
    312 
    313  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    314                QuotaManager::GetOrCreate(),
    315                ResolveBoolResponseAndReturn(aResolver));
    316 
    317  quotaManager->StorageInitialized()->Then(
    318      GetCurrentSerialEventTarget(), __func__,
    319      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    320 
    321  return IPC_OK();
    322 }
    323 
    324 mozilla::ipc::IPCResult Quota::RecvPersistentStorageInitialized(
    325    TemporaryStorageInitializedResolver&& aResolver) {
    326  AssertIsOnBackgroundThread();
    327 
    328  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    329         ResolveBoolResponseAndReturn(aResolver));
    330 
    331  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    332                QuotaManager::GetOrCreate(),
    333                ResolveBoolResponseAndReturn(aResolver));
    334 
    335  quotaManager->PersistentStorageInitialized()->Then(
    336      GetCurrentSerialEventTarget(), __func__,
    337      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    338 
    339  return IPC_OK();
    340 }
    341 
    342 mozilla::ipc::IPCResult Quota::RecvTemporaryStorageInitialized(
    343    TemporaryStorageInitializedResolver&& aResolver) {
    344  AssertIsOnBackgroundThread();
    345 
    346  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    347         ResolveBoolResponseAndReturn(aResolver));
    348 
    349  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    350                QuotaManager::GetOrCreate(),
    351                ResolveBoolResponseAndReturn(aResolver));
    352 
    353  quotaManager->TemporaryStorageInitialized()->Then(
    354      GetCurrentSerialEventTarget(), __func__,
    355      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    356 
    357  return IPC_OK();
    358 }
    359 
    360 mozilla::ipc::IPCResult Quota::RecvTemporaryGroupInitialized(
    361    const PrincipalInfo& aPrincipalInfo,
    362    TemporaryOriginInitializedResolver&& aResolve) {
    363  AssertIsOnBackgroundThread();
    364 
    365  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    366         ResolveBoolResponseAndReturn(aResolve));
    367 
    368  if (!TrustParams()) {
    369    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    370           QM_CUF_AND_IPC_FAIL(this));
    371  }
    372 
    373  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    374                QuotaManager::GetOrCreate(),
    375                ResolveBoolResponseAndReturn(aResolve));
    376 
    377  QM_TRY_UNWRAP(
    378      PrincipalMetadata principalMetadata,
    379      GetInfoFromValidatedPrincipalInfo(*quotaManager, aPrincipalInfo),
    380      ResolveBoolResponseAndReturn(aResolve));
    381 
    382  quotaManager->TemporaryGroupInitialized(principalMetadata)
    383      ->Then(GetCurrentSerialEventTarget(), __func__,
    384             BoolPromiseResolveOrRejectCallback(this, std::move(aResolve)));
    385 
    386  return IPC_OK();
    387 }
    388 
    389 mozilla::ipc::IPCResult Quota::RecvPersistentOriginInitialized(
    390    const PrincipalInfo& aPrincipalInfo,
    391    PersistentOriginInitializedResolver&& aResolve) {
    392  AssertIsOnBackgroundThread();
    393 
    394  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    395         ResolveBoolResponseAndReturn(aResolve));
    396 
    397  if (!TrustParams()) {
    398    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    399           QM_CUF_AND_IPC_FAIL(this));
    400  }
    401 
    402  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    403                QuotaManager::GetOrCreate(),
    404                ResolveBoolResponseAndReturn(aResolve));
    405 
    406  QM_TRY_UNWRAP(
    407      PrincipalMetadata principalMetadata,
    408      GetInfoFromValidatedPrincipalInfo(*quotaManager, aPrincipalInfo),
    409      ResolveBoolResponseAndReturn(aResolve));
    410 
    411  quotaManager
    412      ->PersistentOriginInitialized(OriginMetadata{std::move(principalMetadata),
    413                                                   PERSISTENCE_TYPE_PERSISTENT})
    414      ->Then(GetCurrentSerialEventTarget(), __func__,
    415             BoolPromiseResolveOrRejectCallback(this, std::move(aResolve)));
    416 
    417  return IPC_OK();
    418 }
    419 
    420 mozilla::ipc::IPCResult Quota::RecvTemporaryOriginInitialized(
    421    const PersistenceType& aPersistenceType,
    422    const PrincipalInfo& aPrincipalInfo,
    423    TemporaryOriginInitializedResolver&& aResolve) {
    424  AssertIsOnBackgroundThread();
    425 
    426  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    427         ResolveBoolResponseAndReturn(aResolve));
    428 
    429  if (!TrustParams()) {
    430    QM_TRY(MOZ_TO_RESULT(IsValidPersistenceType(aPersistenceType)),
    431           QM_CUF_AND_IPC_FAIL(this));
    432 
    433    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    434           QM_CUF_AND_IPC_FAIL(this));
    435  }
    436 
    437  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    438                QuotaManager::GetOrCreate(),
    439                ResolveBoolResponseAndReturn(aResolve));
    440 
    441  QM_TRY_UNWRAP(
    442      PrincipalMetadata principalMetadata,
    443      GetInfoFromValidatedPrincipalInfo(*quotaManager, aPrincipalInfo),
    444      ResolveBoolResponseAndReturn(aResolve));
    445 
    446  quotaManager
    447      ->TemporaryOriginInitialized(
    448          OriginMetadata{std::move(principalMetadata), aPersistenceType})
    449      ->Then(GetCurrentSerialEventTarget(), __func__,
    450             BoolPromiseResolveOrRejectCallback(this, std::move(aResolve)));
    451 
    452  return IPC_OK();
    453 }
    454 
    455 mozilla::ipc::IPCResult Quota::RecvInitializeStorage(
    456    InitializeStorageResolver&& aResolver) {
    457  AssertIsOnBackgroundThread();
    458 
    459  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    460         ResolveBoolResponseAndReturn(aResolver));
    461 
    462  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    463                QuotaManager::GetOrCreate(),
    464                ResolveBoolResponseAndReturn(aResolver));
    465 
    466  quotaManager->InitializeStorage()->Then(
    467      GetCurrentSerialEventTarget(), __func__,
    468      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    469 
    470  return IPC_OK();
    471 }
    472 
    473 mozilla::ipc::IPCResult Quota::RecvInitializePersistentStorage(
    474    InitializeStorageResolver&& aResolver) {
    475  AssertIsOnBackgroundThread();
    476 
    477  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    478         ResolveBoolResponseAndReturn(aResolver));
    479 
    480  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    481                QuotaManager::GetOrCreate(),
    482                ResolveBoolResponseAndReturn(aResolver));
    483 
    484  quotaManager->InitializePersistentStorage()->Then(
    485      GetCurrentSerialEventTarget(), __func__,
    486      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    487 
    488  return IPC_OK();
    489 }
    490 
    491 mozilla::ipc::IPCResult Quota::RecvInitializeAllTemporaryOrigins(
    492    InitializeAllTemporaryOriginsResolver&& aResolver) {
    493  AssertIsOnBackgroundThread();
    494 
    495  if (NS_WARN_IF(!StaticPrefs::dom_quotaManager_testing())) {
    496    return IPC_FAIL(this, "QuotaManager is not in testing mode!");
    497  }
    498 
    499  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    500         ResolveBoolResponseAndReturn(aResolver));
    501 
    502  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    503                QuotaManager::GetOrCreate(),
    504                ResolveBoolResponseAndReturn(aResolver));
    505 
    506  quotaManager->InitializeAllTemporaryOrigins()->Then(
    507      GetCurrentSerialEventTarget(), __func__,
    508      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    509 
    510  return IPC_OK();
    511 }
    512 
    513 mozilla::ipc::IPCResult Quota::RecvInitializeTemporaryGroup(
    514    const PrincipalInfo& aPrincipalInfo,
    515    InitializeTemporaryOriginResolver&& aResolve) {
    516  AssertIsOnBackgroundThread();
    517 
    518  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    519         ResolveBoolResponseAndReturn(aResolve));
    520 
    521  if (!TrustParams()) {
    522    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    523           QM_CUF_AND_IPC_FAIL(this));
    524  }
    525 
    526  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    527                QuotaManager::GetOrCreate(),
    528                ResolveBoolResponseAndReturn(aResolve));
    529 
    530  QM_TRY_UNWRAP(
    531      PrincipalMetadata principalMetadata,
    532      GetInfoFromValidatedPrincipalInfo(*quotaManager, aPrincipalInfo),
    533      ResolveBoolResponseAndReturn(aResolve));
    534 
    535  quotaManager->InitializeTemporaryGroup(principalMetadata)
    536      ->Then(GetCurrentSerialEventTarget(), __func__,
    537             BoolPromiseResolveOrRejectCallback(this, std::move(aResolve)));
    538 
    539  return IPC_OK();
    540 }
    541 
    542 mozilla::ipc::IPCResult Quota::RecvInitializePersistentOrigin(
    543    const PrincipalInfo& aPrincipalInfo,
    544    InitializePersistentOriginResolver&& aResolve) {
    545  AssertIsOnBackgroundThread();
    546 
    547  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    548         ResolveBoolResponseAndReturn(aResolve));
    549 
    550  if (!TrustParams()) {
    551    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    552           QM_CUF_AND_IPC_FAIL(this));
    553  }
    554 
    555  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    556                QuotaManager::GetOrCreate(),
    557                ResolveBoolResponseAndReturn(aResolve));
    558 
    559  QM_TRY_UNWRAP(
    560      PrincipalMetadata principalMetadata,
    561      GetInfoFromValidatedPrincipalInfo(*quotaManager, aPrincipalInfo),
    562      ResolveBoolResponseAndReturn(aResolve));
    563 
    564  quotaManager
    565      ->InitializePersistentOrigin(OriginMetadata{std::move(principalMetadata),
    566                                                  PERSISTENCE_TYPE_PERSISTENT})
    567      ->Then(GetCurrentSerialEventTarget(), __func__,
    568             BoolPromiseResolveOrRejectCallback(this, std::move(aResolve)));
    569 
    570  return IPC_OK();
    571 }
    572 
    573 mozilla::ipc::IPCResult Quota::RecvInitializeTemporaryOrigin(
    574    const PersistenceType& aPersistenceType,
    575    const PrincipalInfo& aPrincipalInfo, const bool& aCreateIfNonExistent,
    576    InitializeTemporaryOriginResolver&& aResolve) {
    577  AssertIsOnBackgroundThread();
    578 
    579  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    580         ResolveBoolResponseAndReturn(aResolve));
    581 
    582  if (!TrustParams()) {
    583    QM_TRY(MOZ_TO_RESULT(IsValidPersistenceType(aPersistenceType)),
    584           QM_CUF_AND_IPC_FAIL(this));
    585 
    586    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    587           QM_CUF_AND_IPC_FAIL(this));
    588  }
    589 
    590  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    591                QuotaManager::GetOrCreate(),
    592                ResolveBoolResponseAndReturn(aResolve));
    593 
    594  QM_TRY_UNWRAP(
    595      PrincipalMetadata principalMetadata,
    596      GetInfoFromValidatedPrincipalInfo(*quotaManager, aPrincipalInfo),
    597      ResolveBoolResponseAndReturn(aResolve));
    598 
    599  quotaManager
    600      ->InitializeTemporaryOrigin(
    601          OriginMetadata{std::move(principalMetadata), aPersistenceType},
    602          aCreateIfNonExistent)
    603      ->Then(GetCurrentSerialEventTarget(), __func__,
    604             BoolPromiseResolveOrRejectCallback(this, std::move(aResolve)));
    605 
    606  return IPC_OK();
    607 }
    608 
    609 mozilla::ipc::IPCResult Quota::RecvInitializePersistentClient(
    610    const PrincipalInfo& aPrincipalInfo, const Type& aClientType,
    611    InitializeTemporaryClientResolver&& aResolve) {
    612  AssertIsOnBackgroundThread();
    613 
    614  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    615         ResolveBoolResponseAndReturn(aResolve));
    616 
    617  if (!TrustParams()) {
    618    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    619           QM_CUF_AND_IPC_FAIL(this));
    620 
    621    QM_TRY(MOZ_TO_RESULT(Client::IsValidType(aClientType)),
    622           QM_CUF_AND_IPC_FAIL(this));
    623  }
    624 
    625  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    626                QuotaManager::GetOrCreate(),
    627                ResolveBoolResponseAndReturn(aResolve));
    628 
    629  QM_TRY_UNWRAP(
    630      PrincipalMetadata principalMetadata,
    631      GetInfoFromValidatedPrincipalInfo(*quotaManager, aPrincipalInfo),
    632      ResolveBoolResponseAndReturn(aResolve));
    633 
    634  OriginMetadata originMetadata{std::move(principalMetadata),
    635                                PERSISTENCE_TYPE_PERSISTENT};
    636 
    637  ClientMetadata clientMetadata{std::move(originMetadata), aClientType};
    638 
    639  quotaManager->InitializePersistentClient(clientMetadata)
    640      ->Then(GetCurrentSerialEventTarget(), __func__,
    641             BoolPromiseResolveOrRejectCallback(this, std::move(aResolve)));
    642 
    643  return IPC_OK();
    644 }
    645 
    646 mozilla::ipc::IPCResult Quota::RecvInitializeTemporaryClient(
    647    const PersistenceType& aPersistenceType,
    648    const PrincipalInfo& aPrincipalInfo, const Type& aClientType,
    649    const bool& aCreateIfNonExistent,
    650    InitializeTemporaryClientResolver&& aResolve) {
    651  AssertIsOnBackgroundThread();
    652 
    653  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    654         ResolveBoolResponseAndReturn(aResolve));
    655 
    656  if (!TrustParams()) {
    657    QM_TRY(MOZ_TO_RESULT(IsValidPersistenceType(aPersistenceType)),
    658           QM_CUF_AND_IPC_FAIL(this));
    659 
    660    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    661           QM_CUF_AND_IPC_FAIL(this));
    662 
    663    QM_TRY(MOZ_TO_RESULT(Client::IsValidType(aClientType)),
    664           QM_CUF_AND_IPC_FAIL(this));
    665  }
    666 
    667  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    668                QuotaManager::GetOrCreate(),
    669                ResolveBoolResponseAndReturn(aResolve));
    670 
    671  QM_TRY_UNWRAP(
    672      PrincipalMetadata principalMetadata,
    673      GetInfoFromValidatedPrincipalInfo(*quotaManager, aPrincipalInfo),
    674      ResolveBoolResponseAndReturn(aResolve));
    675 
    676  OriginMetadata originMetadata{std::move(principalMetadata), aPersistenceType};
    677 
    678  ClientMetadata clientMetadata{std::move(originMetadata), aClientType};
    679 
    680  quotaManager->InitializeTemporaryClient(clientMetadata, aCreateIfNonExistent)
    681      ->Then(GetCurrentSerialEventTarget(), __func__,
    682             BoolPromiseResolveOrRejectCallback(this, std::move(aResolve)));
    683 
    684  return IPC_OK();
    685 }
    686 
    687 mozilla::ipc::IPCResult Quota::RecvInitializeTemporaryStorage(
    688    InitializeTemporaryStorageResolver&& aResolver) {
    689  AssertIsOnBackgroundThread();
    690 
    691  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    692         ResolveBoolResponseAndReturn(aResolver));
    693 
    694  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    695                QuotaManager::GetOrCreate(),
    696                ResolveBoolResponseAndReturn(aResolver));
    697 
    698  quotaManager->InitializeTemporaryStorage()->Then(
    699      GetCurrentSerialEventTarget(), __func__,
    700      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    701 
    702  return IPC_OK();
    703 }
    704 
    705 mozilla::ipc::IPCResult Quota::RecvGetUsage(
    706    const bool& aGetAll,
    707    ManagedEndpoint<PQuotaUsageRequestParent>&& aParentEndpoint,
    708    GetUsageResolver&& aResolve) {
    709  AssertIsOnBackgroundThread();
    710 
    711  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    712         ResolveOriginUsageMetadataArrayResponseAndReturn(aResolve));
    713 
    714  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    715                QuotaManager::GetOrCreate(),
    716                ResolveOriginUsageMetadataArrayResponseAndReturn(aResolve));
    717 
    718  auto parentActor = MakeRefPtr<QuotaUsageRequestParent>();
    719 
    720  auto cancelPromise = parentActor->OnCancel();
    721 
    722  QM_TRY(MOZ_TO_RESULT(BindPQuotaUsageRequestEndpoint(
    723             std::move(aParentEndpoint), parentActor)),
    724         ResolveOriginUsageMetadataArrayResponseAndReturn(aResolve));
    725 
    726  quotaManager->GetUsage(aGetAll, std::move(cancelPromise))
    727      ->Then(
    728          GetCurrentSerialEventTarget(), __func__,
    729          [parentActor](
    730              OriginUsageMetadataArrayPromise::ResolveOrRejectValue&& aValue) {
    731            parentActor->Destroy();
    732 
    733            return OriginUsageMetadataArrayPromise::CreateAndResolveOrReject(
    734                std::move(aValue), __func__);
    735          })
    736      ->Then(GetCurrentSerialEventTarget(), __func__,
    737             OriginUsageMetadataArrayPromiseResolveOrRejectCallback(
    738                 this, std::move(aResolve)));
    739 
    740  return IPC_OK();
    741 }
    742 
    743 mozilla::ipc::IPCResult Quota::RecvGetOriginUsage(
    744    const PrincipalInfo& aPrincipalInfo,
    745    ManagedEndpoint<PQuotaUsageRequestParent>&& aParentEndpoint,
    746    GetOriginUsageResolver&& aResolve) {
    747  AssertIsOnBackgroundThread();
    748 
    749  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    750         ResolveUsageInfoResponseAndReturn(aResolve));
    751 
    752  if (!TrustParams()) {
    753    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    754           QM_CUF_AND_IPC_FAIL(this));
    755  }
    756 
    757  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    758                QuotaManager::GetOrCreate(),
    759                ResolveUsageInfoResponseAndReturn(aResolve));
    760 
    761  auto parentActor = MakeRefPtr<QuotaUsageRequestParent>();
    762 
    763  auto cancelPromise = parentActor->OnCancel();
    764 
    765  QM_TRY(MOZ_TO_RESULT(BindPQuotaUsageRequestEndpoint(
    766             std::move(aParentEndpoint), parentActor)),
    767         ResolveUsageInfoResponseAndReturn(aResolve));
    768 
    769  quotaManager->GetOriginUsage(aPrincipalInfo, std::move(cancelPromise))
    770      ->Then(
    771          GetCurrentSerialEventTarget(), __func__,
    772          [parentActor](const UsageInfoPromise::ResolveOrRejectValue& aValue) {
    773            parentActor->Destroy();
    774 
    775            return UsageInfoPromise::CreateAndResolveOrReject(aValue, __func__);
    776          })
    777      ->Then(
    778          GetCurrentSerialEventTarget(), __func__,
    779          UsageInfoPromiseResolveOrRejectCallback(this, std::move(aResolve)));
    780 
    781  return IPC_OK();
    782 }
    783 
    784 mozilla::ipc::IPCResult Quota::RecvGetCachedOriginUsage(
    785    const PrincipalInfo& aPrincipalInfo,
    786    GetCachedOriginUsageResolver&& aResolver) {
    787  AssertIsOnBackgroundThread();
    788 
    789  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    790         ResolveUInt64ResponseAndReturn(aResolver));
    791 
    792  if (!TrustParams()) {
    793    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    794           QM_CUF_AND_IPC_FAIL(this));
    795  }
    796 
    797  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    798                QuotaManager::GetOrCreate(),
    799                ResolveUInt64ResponseAndReturn(aResolver));
    800 
    801  quotaManager->GetCachedOriginUsage(aPrincipalInfo)
    802      ->Then(GetCurrentSerialEventTarget(), __func__,
    803             UInt64PromiseResolveOrRejectCallback(this, std::move(aResolver)));
    804 
    805  return IPC_OK();
    806 }
    807 
    808 mozilla::ipc::IPCResult Quota::RecvListOrigins(
    809    ListCachedOriginsResolver&& aResolver) {
    810  AssertIsOnBackgroundThread();
    811 
    812  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    813         ResolveCStringArrayResponseAndReturn(aResolver));
    814 
    815  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    816                QuotaManager::GetOrCreate(),
    817                ResolveCStringArrayResponseAndReturn(aResolver));
    818 
    819  quotaManager->ListOrigins()->Then(
    820      GetCurrentSerialEventTarget(), __func__,
    821      CStringArrayPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    822 
    823  return IPC_OK();
    824 }
    825 
    826 mozilla::ipc::IPCResult Quota::RecvListCachedOrigins(
    827    ListCachedOriginsResolver&& aResolver) {
    828  AssertIsOnBackgroundThread();
    829 
    830  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    831         ResolveCStringArrayResponseAndReturn(aResolver));
    832 
    833  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    834                QuotaManager::GetOrCreate(),
    835                ResolveCStringArrayResponseAndReturn(aResolver));
    836 
    837  quotaManager->ListCachedOrigins()->Then(
    838      GetCurrentSerialEventTarget(), __func__,
    839      CStringArrayPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    840 
    841  return IPC_OK();
    842 }
    843 
    844 mozilla::ipc::IPCResult Quota::RecvClearStoragesForOrigin(
    845    const Maybe<PersistenceType>& aPersistenceType,
    846    const PrincipalInfo& aPrincipalInfo,
    847    ClearStoragesForOriginResolver&& aResolver) {
    848  AssertIsOnBackgroundThread();
    849 
    850  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    851         ResolveBoolResponseAndReturn(aResolver));
    852 
    853  if (!TrustParams()) {
    854    if (aPersistenceType) {
    855      QM_TRY(MOZ_TO_RESULT(IsValidPersistenceType(*aPersistenceType)),
    856             QM_CUF_AND_IPC_FAIL(this));
    857    }
    858 
    859    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    860           QM_CUF_AND_IPC_FAIL(this));
    861  }
    862 
    863  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    864                QuotaManager::GetOrCreate(),
    865                ResolveBoolResponseAndReturn(aResolver));
    866 
    867  quotaManager->ClearStoragesForOrigin(aPersistenceType, aPrincipalInfo)
    868      ->Then(GetCurrentSerialEventTarget(), __func__,
    869             BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    870 
    871  return IPC_OK();
    872 }
    873 
    874 mozilla::ipc::IPCResult Quota::RecvClearStoragesForClient(
    875    const Maybe<PersistenceType>& aPersistenceType,
    876    const PrincipalInfo& aPrincipalInfo, const Type& aClientType,
    877    ClearStoragesForClientResolver&& aResolver) {
    878  AssertIsOnBackgroundThread();
    879 
    880  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    881         ResolveBoolResponseAndReturn(aResolver));
    882 
    883  if (!TrustParams()) {
    884    if (aPersistenceType) {
    885      QM_TRY(MOZ_TO_RESULT(IsValidPersistenceType(*aPersistenceType)),
    886             QM_CUF_AND_IPC_FAIL(this));
    887    }
    888 
    889    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    890           QM_CUF_AND_IPC_FAIL(this));
    891 
    892    QM_TRY(MOZ_TO_RESULT(Client::IsValidType(aClientType)),
    893           QM_CUF_AND_IPC_FAIL(this));
    894  }
    895 
    896  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    897                QuotaManager::GetOrCreate(),
    898                ResolveBoolResponseAndReturn(aResolver));
    899 
    900  quotaManager
    901      ->ClearStoragesForClient(aPersistenceType, aPrincipalInfo, aClientType)
    902      ->Then(GetCurrentSerialEventTarget(), __func__,
    903             BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    904 
    905  return IPC_OK();
    906 }
    907 
    908 mozilla::ipc::IPCResult Quota::RecvClearStoragesForOriginPrefix(
    909    const Maybe<PersistenceType>& aPersistenceType,
    910    const PrincipalInfo& aPrincipalInfo,
    911    ClearStoragesForOriginResolver&& aResolver) {
    912  AssertIsOnBackgroundThread();
    913 
    914  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    915         ResolveBoolResponseAndReturn(aResolver));
    916 
    917  if (!TrustParams()) {
    918    if (aPersistenceType) {
    919      QM_TRY(MOZ_TO_RESULT(IsValidPersistenceType(*aPersistenceType)),
    920             QM_CUF_AND_IPC_FAIL(this));
    921    }
    922 
    923    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
    924           QM_CUF_AND_IPC_FAIL(this));
    925  }
    926 
    927  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    928                QuotaManager::GetOrCreate(),
    929                ResolveBoolResponseAndReturn(aResolver));
    930 
    931  quotaManager->ClearStoragesForOriginPrefix(aPersistenceType, aPrincipalInfo)
    932      ->Then(GetCurrentSerialEventTarget(), __func__,
    933             BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    934 
    935  return IPC_OK();
    936 }
    937 
    938 mozilla::ipc::IPCResult Quota::RecvClearStoragesForOriginAttributesPattern(
    939    const OriginAttributesPattern& aPattern,
    940    ClearStoragesForOriginAttributesPatternResolver&& aResolver) {
    941  AssertIsOnBackgroundThread();
    942 
    943  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    944         ResolveBoolResponseAndReturn(aResolver));
    945 
    946  if (!TrustParams()) {
    947    QM_TRY(MOZ_TO_RESULT(!BackgroundParent::IsOtherProcessActor(Manager())),
    948           QM_CUF_AND_IPC_FAIL(this));
    949  }
    950 
    951  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    952                QuotaManager::GetOrCreate(),
    953                ResolveBoolResponseAndReturn(aResolver));
    954 
    955  quotaManager->ClearStoragesForOriginAttributesPattern(aPattern)->Then(
    956      GetCurrentSerialEventTarget(), __func__,
    957      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    958 
    959  return IPC_OK();
    960 }
    961 
    962 mozilla::ipc::IPCResult Quota::RecvClearStoragesForPrivateBrowsing(
    963    ClearStoragesForPrivateBrowsingResolver&& aResolver) {
    964  AssertIsOnBackgroundThread();
    965 
    966  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    967         ResolveBoolResponseAndReturn(aResolver));
    968 
    969  if (!TrustParams()) {
    970    QM_TRY(MOZ_TO_RESULT(!BackgroundParent::IsOtherProcessActor(Manager())),
    971           QM_CUF_AND_IPC_FAIL(this));
    972  }
    973 
    974  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    975                QuotaManager::GetOrCreate(),
    976                ResolveBoolResponseAndReturn(aResolver));
    977 
    978  quotaManager->ClearPrivateRepository()->Then(
    979      GetCurrentSerialEventTarget(), __func__,
    980      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    981 
    982  return IPC_OK();
    983 }
    984 
    985 mozilla::ipc::IPCResult Quota::RecvClearStorage(
    986    ShutdownStorageResolver&& aResolver) {
    987  AssertIsOnBackgroundThread();
    988 
    989  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
    990         ResolveBoolResponseAndReturn(aResolver));
    991 
    992  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
    993                QuotaManager::GetOrCreate(),
    994                ResolveBoolResponseAndReturn(aResolver));
    995 
    996  quotaManager->ClearStorage()->Then(
    997      GetCurrentSerialEventTarget(), __func__,
    998      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
    999 
   1000  return IPC_OK();
   1001 }
   1002 
   1003 mozilla::ipc::IPCResult Quota::RecvShutdownStoragesForOrigin(
   1004    const Maybe<PersistenceType>& aPersistenceType,
   1005    const PrincipalInfo& aPrincipalInfo,
   1006    ShutdownStoragesForOriginResolver&& aResolver) {
   1007  AssertIsOnBackgroundThread();
   1008 
   1009  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
   1010         ResolveBoolResponseAndReturn(aResolver));
   1011 
   1012  if (!TrustParams()) {
   1013    if (aPersistenceType) {
   1014      QM_TRY(MOZ_TO_RESULT(IsValidPersistenceType(*aPersistenceType)),
   1015             QM_CUF_AND_IPC_FAIL(this));
   1016    }
   1017 
   1018    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
   1019           QM_CUF_AND_IPC_FAIL(this));
   1020  }
   1021 
   1022  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
   1023                QuotaManager::GetOrCreate(),
   1024                ResolveBoolResponseAndReturn(aResolver));
   1025 
   1026  quotaManager->ShutdownStoragesForOrigin(aPersistenceType, aPrincipalInfo)
   1027      ->Then(GetCurrentSerialEventTarget(), __func__,
   1028             BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
   1029 
   1030  return IPC_OK();
   1031 }
   1032 
   1033 mozilla::ipc::IPCResult Quota::RecvShutdownStoragesForClient(
   1034    const Maybe<PersistenceType>& aPersistenceType,
   1035    const PrincipalInfo& aPrincipalInfo, const Type& aClientType,
   1036    ShutdownStoragesForClientResolver&& aResolver) {
   1037  AssertIsOnBackgroundThread();
   1038 
   1039  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
   1040         ResolveBoolResponseAndReturn(aResolver));
   1041 
   1042  if (!TrustParams()) {
   1043    if (aPersistenceType) {
   1044      QM_TRY(MOZ_TO_RESULT(IsValidPersistenceType(*aPersistenceType)),
   1045             QM_CUF_AND_IPC_FAIL(this));
   1046    }
   1047 
   1048    QM_TRY(MOZ_TO_RESULT(IsPrincipalInfoValid(aPrincipalInfo)),
   1049           QM_CUF_AND_IPC_FAIL(this));
   1050 
   1051    QM_TRY(MOZ_TO_RESULT(Client::IsValidType(aClientType)),
   1052           QM_CUF_AND_IPC_FAIL(this));
   1053  }
   1054 
   1055  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
   1056                QuotaManager::GetOrCreate(),
   1057                ResolveBoolResponseAndReturn(aResolver));
   1058 
   1059  quotaManager
   1060      ->ShutdownStoragesForClient(aPersistenceType, aPrincipalInfo, aClientType)
   1061      ->Then(GetCurrentSerialEventTarget(), __func__,
   1062             BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
   1063 
   1064  return IPC_OK();
   1065 }
   1066 
   1067 mozilla::ipc::IPCResult Quota::RecvShutdownStorage(
   1068    ShutdownStorageResolver&& aResolver) {
   1069  AssertIsOnBackgroundThread();
   1070 
   1071  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()),
   1072         ResolveBoolResponseAndReturn(aResolver));
   1073 
   1074  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
   1075                QuotaManager::GetOrCreate(),
   1076                ResolveBoolResponseAndReturn(aResolver));
   1077 
   1078  quotaManager->ShutdownStorage()->Then(
   1079      GetCurrentSerialEventTarget(), __func__,
   1080      BoolPromiseResolveOrRejectCallback(this, std::move(aResolver)));
   1081 
   1082  return IPC_OK();
   1083 }
   1084 
   1085 mozilla::ipc::IPCResult Quota::RecvStartIdleMaintenance() {
   1086  AssertIsOnBackgroundThread();
   1087 
   1088  PBackgroundParent* actor = Manager();
   1089  MOZ_ASSERT(actor);
   1090 
   1091  if (BackgroundParent::IsOtherProcessActor(actor)) {
   1092    MOZ_CRASH_UNLESS_FUZZING();
   1093    return IPC_FAIL(this, "Wrong actor");
   1094  }
   1095 
   1096  if (QuotaManager::IsShuttingDown()) {
   1097    return IPC_OK();
   1098  }
   1099 
   1100  QM_TRY(QuotaManager::EnsureCreated(), IPC_OK());
   1101 
   1102  QuotaManager* quotaManager = QuotaManager::Get();
   1103  MOZ_ASSERT(quotaManager);
   1104 
   1105  quotaManager->StartIdleMaintenance();
   1106 
   1107  return IPC_OK();
   1108 }
   1109 
   1110 mozilla::ipc::IPCResult Quota::RecvStopIdleMaintenance() {
   1111  AssertIsOnBackgroundThread();
   1112 
   1113  PBackgroundParent* actor = Manager();
   1114  MOZ_ASSERT(actor);
   1115 
   1116  if (BackgroundParent::IsOtherProcessActor(actor)) {
   1117    MOZ_CRASH_UNLESS_FUZZING();
   1118    return IPC_FAIL(this, "Wrong actor");
   1119  }
   1120 
   1121  if (QuotaManager::IsShuttingDown()) {
   1122    return IPC_OK();
   1123  }
   1124 
   1125  QuotaManager* quotaManager = QuotaManager::Get();
   1126  if (!quotaManager) {
   1127    return IPC_OK();
   1128  }
   1129 
   1130  quotaManager->StopIdleMaintenance();
   1131 
   1132  return IPC_OK();
   1133 }
   1134 
   1135 mozilla::ipc::IPCResult Quota::RecvAbortOperationsForProcess(
   1136    const ContentParentId& aContentParentId) {
   1137  AssertIsOnBackgroundThread();
   1138 
   1139  PBackgroundParent* actor = Manager();
   1140  MOZ_ASSERT(actor);
   1141 
   1142  if (BackgroundParent::IsOtherProcessActor(actor)) {
   1143    MOZ_CRASH_UNLESS_FUZZING();
   1144    return IPC_FAIL(this, "Wrong actor");
   1145  }
   1146 
   1147  if (QuotaManager::IsShuttingDown()) {
   1148    return IPC_OK();
   1149  }
   1150 
   1151  QuotaManager* quotaManager = QuotaManager::Get();
   1152  if (!quotaManager) {
   1153    return IPC_OK();
   1154  }
   1155 
   1156  quotaManager->AbortOperationsForProcess(aContentParentId);
   1157 
   1158  return IPC_OK();
   1159 }
   1160 
   1161 mozilla::ipc::IPCResult Quota::RecvSetThumbnailPrivateIdentityId(
   1162    const uint32_t& aThumbnailPrivateIdentityId) {
   1163  AssertIsOnBackgroundThread();
   1164 
   1165  QM_TRY(MOZ_TO_RESULT(!QuotaManager::IsShuttingDown()), IPC_OK());
   1166 
   1167  if (!TrustParams()) {
   1168    QM_TRY(MOZ_TO_RESULT(!BackgroundParent::IsOtherProcessActor(Manager())),
   1169           QM_CUF_AND_IPC_FAIL(this));
   1170  }
   1171 
   1172  QM_TRY_UNWRAP(const NotNull<RefPtr<QuotaManager>> quotaManager,
   1173                QuotaManager::GetOrCreate(), IPC_OK());
   1174 
   1175  MOZ_ALWAYS_SUCCEEDS(quotaManager->IOThread()->Dispatch(
   1176      NS_NewRunnableFunction(
   1177          "dom::quota::Quota::RecvSetThumbnailPrivateIdentityId",
   1178          [aThumbnailPrivateIdentityId]() {
   1179            QuotaManager* quotaManager = QuotaManager::Get();
   1180            MOZ_ASSERT(quotaManager);
   1181 
   1182            quotaManager->SetThumbnailPrivateIdentityId(
   1183                aThumbnailPrivateIdentityId);
   1184          }),
   1185      NS_DISPATCH_NORMAL));
   1186 
   1187  return IPC_OK();
   1188 }
   1189 
   1190 }  // namespace mozilla::dom::quota
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE