dom/quota/StorageManager.cpp

   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 "StorageManager.h"
   8
   9 #include <cstdint>
  10 #include <cstdlib>
  11 #include <utility>
  12 #include "ErrorList.h"
  13 #include "MainThreadUtils.h"
  14 #include "js/CallArgs.h"
  15 #include "js/TypeDecls.h"
  16 #include "mozilla/Attributes.h"
  17 #include "mozilla/ErrorResult.h"
  18 #include "mozilla/MacroForEach.h"
  19 #include "mozilla/Maybe.h"
  20 #include "mozilla/Mutex.h"
  21 #include "mozilla/RefPtr.h"
  22 #include "mozilla/Telemetry.h"
  23 #include "mozilla/TelemetryScalarEnums.h"
  24 #include "mozilla/dom/BindingDeclarations.h"
  25 #include "mozilla/dom/Document.h"
  26 #include "mozilla/dom/Promise.h"
  27 #include "mozilla/dom/PromiseWorkerProxy.h"
  28 #include "mozilla/dom/StorageManagerBinding.h"
  29 #include "mozilla/dom/WorkerCommon.h"
  30 #include "mozilla/dom/WorkerPrivate.h"
  31 #include "mozilla/dom/WorkerRunnable.h"
  32 #include "mozilla/dom/WorkerStatus.h"
  33 #include "mozilla/dom/quota/QuotaManagerService.h"
  34 #include "nsContentPermissionHelper.h"
  35 #include "nsContentUtils.h"
  36 #include "nsDebug.h"
  37 #include "nsError.h"
  38 #include "nsIGlobalObject.h"
  39 #include "nsIPrincipal.h"
  40 #include "nsIQuotaCallbacks.h"
  41 #include "nsIQuotaManagerService.h"
  42 #include "nsIQuotaRequests.h"
  43 #include "nsIQuotaResults.h"
  44 #include "nsIVariant.h"
  45 #include "nsLiteralString.h"
  46 #include "nsPIDOMWindow.h"
  47 #include "nsString.h"
  48 #include "nsStringFlags.h"
  49 #include "nsTLiteralString.h"
  50 #include "nscore.h"
  51
  52 class JSObject;
  53 struct JSContext;
  54 struct nsID;
  55
  56 namespace mozilla {
  57 class Runnable;
  58 }
  59
  60 using namespace mozilla::dom::quota;
  61
  62 namespace mozilla::dom {
  63
  64 namespace {
  65
  66 // This class is used to get quota usage, request persist and check persisted
  67 // status callbacks.
  68 class RequestResolver final : public nsIQuotaCallback {
  69  public:
  70   enum Type { Estimate, Persist, Persisted };
  71
  72  private:
  73   class FinishWorkerRunnable;
  74
  75   // If this resolver was created for a window then mPromise must be non-null.
  76   // Otherwise mProxy must be non-null.
  77   RefPtr<Promise> mPromise;
  78   RefPtr<PromiseWorkerProxy> mProxy;
  79
  80   nsresult mResultCode;
  81   StorageEstimate mStorageEstimate;
  82   const Type mType;
  83   bool mPersisted;
  84
  85  public:
  86   RequestResolver(Type aType, Promise* aPromise)
  87       : mPromise(aPromise),
  88         mResultCode(NS_OK),
  89         mType(aType),
  90         mPersisted(false) {
  91     MOZ_ASSERT(NS_IsMainThread());
  92     MOZ_ASSERT(aPromise);
  93   }
  94
  95   RequestResolver(Type aType, PromiseWorkerProxy* aProxy)
  96       : mProxy(aProxy), mResultCode(NS_OK), mType(aType), mPersisted(false) {
  97     MOZ_ASSERT(NS_IsMainThread());
  98     MOZ_ASSERT(aProxy);
  99   }
 100
 101   void ResolveOrReject();
 102
 103   NS_DECL_THREADSAFE_ISUPPORTS
 104   NS_DECL_NSIQUOTACALLBACK
 105
 106  private:
 107   ~RequestResolver() = default;
 108
 109   nsresult GetStorageEstimate(nsIVariant* aResult);
 110
 111   nsresult GetPersisted(nsIVariant* aResult);
 112
 113   nsresult OnCompleteInternal(nsIQuotaRequest* aRequest);
 114
 115   nsresult Finish();
 116 };
 117
 118 // This class is used to return promise on worker thread.
 119 class RequestResolver::FinishWorkerRunnable final : public WorkerRunnable {
 120   RefPtr<RequestResolver> mResolver;
 121
 122  public:
 123   explicit FinishWorkerRunnable(RequestResolver* aResolver)
 124       : WorkerRunnable(aResolver->mProxy->GetWorkerPrivate()),
 125         mResolver(aResolver) {
 126     MOZ_ASSERT(NS_IsMainThread());
 127     MOZ_ASSERT(aResolver);
 128   }
 129
 130   bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override;
 131 };
 132
 133 class EstimateWorkerMainThreadRunnable final : public WorkerMainThreadRunnable {
 134   RefPtr<PromiseWorkerProxy> mProxy;
 135
 136  public:
 137   EstimateWorkerMainThreadRunnable(WorkerPrivate* aWorkerPrivate,
 138                                    PromiseWorkerProxy* aProxy)
 139       : WorkerMainThreadRunnable(aWorkerPrivate,
 140                                  "StorageManager :: Estimate"_ns),
 141         mProxy(aProxy) {
 142     MOZ_ASSERT(aWorkerPrivate);
 143     aWorkerPrivate->AssertIsOnWorkerThread();
 144     MOZ_ASSERT(aProxy);
 145   }
 146
 147   bool MainThreadRun() override;
 148 };
 149
 150 class PersistedWorkerMainThreadRunnable final
 151     : public WorkerMainThreadRunnable {
 152   RefPtr<PromiseWorkerProxy> mProxy;
 153
 154  public:
 155   PersistedWorkerMainThreadRunnable(WorkerPrivate* aWorkerPrivate,
 156                                     PromiseWorkerProxy* aProxy)
 157       : WorkerMainThreadRunnable(aWorkerPrivate,
 158                                  "StorageManager :: Persisted"_ns),
 159         mProxy(aProxy) {
 160     MOZ_ASSERT(aWorkerPrivate);
 161     aWorkerPrivate->AssertIsOnWorkerThread();
 162     MOZ_ASSERT(aProxy);
 163   }
 164
 165   bool MainThreadRun() override;
 166 };
 167
 168 /*******************************************************************************
 169  * PersistentStoragePermissionRequest
 170  ******************************************************************************/
 171
 172 class PersistentStoragePermissionRequest final
 173     : public ContentPermissionRequestBase {
 174   RefPtr<Promise> mPromise;
 175
 176  public:
 177   PersistentStoragePermissionRequest(nsIPrincipal* aPrincipal,
 178                                      nsPIDOMWindowInner* aWindow,
 179                                      Promise* aPromise)
 180       : ContentPermissionRequestBase(aPrincipal, aWindow,
 181                                      "dom.storageManager"_ns,
 182                                      "persistent-storage"_ns),
 183         mPromise(aPromise) {
 184     MOZ_ASSERT(aWindow);
 185     MOZ_ASSERT(aPromise);
 186   }
 187
 188   nsresult Start();
 189
 190   NS_DECL_ISUPPORTS_INHERITED
 191   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PersistentStoragePermissionRequest,
 192                                            ContentPermissionRequestBase)
 193
 194   // nsIContentPermissionRequest
 195   NS_IMETHOD Cancel(void) override;
 196   NS_IMETHOD Allow(JS::HandleValue choices) override;
 197
 198  private:
 199   ~PersistentStoragePermissionRequest() = default;
 200 };
 201
 202 nsresult Estimate(nsIPrincipal* aPrincipal, nsIQuotaCallback* aCallback,
 203                   nsIQuotaRequest** aRequest) {
 204   MOZ_ASSERT(aPrincipal);
 205   MOZ_ASSERT(aCallback);
 206   MOZ_ASSERT(aRequest);
 207
 208   // Firefox and Quota Manager have always used the schemeless origin group
 209   // (https://storage.spec.whatwg.org/#schemeless-origin-group) for quota limit
 210   // purposes. This has been to prevent a site/eTLD+1 from claiming more than
 211   // its fair share of storage through the use of sub-domains. Because the limit
 212   // is at the group level and the usage needs to make sense in the context of
 213   // that limit, we also expose the group usage. Bug 1374970 reflects this
 214   // reality and bug 1305665 tracks our plan to eliminate our use of groups for
 215   // this.
 216
 217   nsCOMPtr<nsIQuotaManagerService> qms = QuotaManagerService::GetOrCreate();
 218   if (NS_WARN_IF(!qms)) {
 219     return NS_ERROR_FAILURE;
 220   }
 221
 222   nsCOMPtr<nsIQuotaRequest> request;
 223   nsresult rv = qms->Estimate(aPrincipal, getter_AddRefs(request));
 224   if (NS_WARN_IF(NS_FAILED(rv))) {
 225     return rv;
 226   }
 227
 228   MOZ_ALWAYS_SUCCEEDS(request->SetCallback(aCallback));
 229
 230   request.forget(aRequest);
 231   return NS_OK;
 232 };
 233
 234 nsresult Persisted(nsIPrincipal* aPrincipal, nsIQuotaCallback* aCallback,
 235                    nsIQuotaRequest** aRequest) {
 236   MOZ_ASSERT(aPrincipal);
 237   MOZ_ASSERT(aCallback);
 238   MOZ_ASSERT(aRequest);
 239
 240   nsCOMPtr<nsIQuotaManagerService> qms = QuotaManagerService::GetOrCreate();
 241   if (NS_WARN_IF(!qms)) {
 242     return NS_ERROR_FAILURE;
 243   }
 244
 245   nsCOMPtr<nsIQuotaRequest> request;
 246   nsresult rv = qms->Persisted(aPrincipal, getter_AddRefs(request));
 247   if (NS_WARN_IF(NS_FAILED(rv))) {
 248     return rv;
 249   }
 250
 251   // All the methods in nsIQuotaManagerService shouldn't synchronously fire
 252   // any callbacks when they are being executed. Even when a result is ready,
 253   // a new runnable should be dispatched to current thread to fire the callback
 254   // asynchronously. It's safe to set the callback after we call Persisted().
 255   MOZ_ALWAYS_SUCCEEDS(request->SetCallback(aCallback));
 256
 257   request.forget(aRequest);
 258
 259   return NS_OK;
 260 };
 261
 262 already_AddRefed<Promise> ExecuteOpOnMainOrWorkerThread(
 263     nsIGlobalObject* aGlobal, RequestResolver::Type aType, ErrorResult& aRv) {
 264   MOZ_ASSERT(aGlobal);
 265   MOZ_ASSERT_IF(aType == RequestResolver::Type::Persist, NS_IsMainThread());
 266
 267   RefPtr<Promise> promise = Promise::Create(aGlobal, aRv);
 268   if (NS_WARN_IF(!promise)) {
 269     return nullptr;
 270   }
 271
 272   if (NS_IsMainThread()) {
 273     nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aGlobal);
 274     if (NS_WARN_IF(!window)) {
 275       aRv.Throw(NS_ERROR_FAILURE);
 276       return nullptr;
 277     }
 278
 279     nsCOMPtr<Document> doc = window->GetExtantDoc();
 280     if (NS_WARN_IF(!doc)) {
 281       aRv.Throw(NS_ERROR_FAILURE);
 282       return nullptr;
 283     }
 284
 285     nsCOMPtr<nsIPrincipal> principal = doc->NodePrincipal();
 286     MOZ_ASSERT(principal);
 287
 288     // Storage Standard 7. API
 289     // If origin is an opaque origin, then reject promise with a TypeError.
 290     if (principal->GetIsNullPrincipal()) {
 291       switch (aType) {
 292         case RequestResolver::Type::Persisted:
 293           promise->MaybeRejectWithTypeError(
 294               "persisted() called for opaque origin");
 295           break;
 296         case RequestResolver::Type::Persist:
 297           promise->MaybeRejectWithTypeError(
 298               "persist() called for opaque origin");
 299           break;
 300         case RequestResolver::Type::Estimate:
 301           promise->MaybeRejectWithTypeError(
 302               "estimate() called for opaque origin");
 303           break;
 304       }
 305
 306       return promise.forget();
 307     }
 308
 309     switch (aType) {
 310       case RequestResolver::Type::Persisted: {
 311         RefPtr<RequestResolver> resolver =
 312             new RequestResolver(RequestResolver::Type::Persisted, promise);
 313
 314         RefPtr<nsIQuotaRequest> request;
 315         aRv = Persisted(principal, resolver, getter_AddRefs(request));
 316
 317         break;
 318       }
 319
 320       case RequestResolver::Type::Persist: {
 321         RefPtr<PersistentStoragePermissionRequest> request =
 322             new PersistentStoragePermissionRequest(principal, window, promise);
 323
 324         // In private browsing mode, no permission prompt.
 325         if (nsContentUtils::IsInPrivateBrowsing(doc)) {
 326           aRv = request->Cancel();
 327         } else if (!request->CheckPermissionDelegate()) {
 328           aRv = request->Cancel();
 329         } else {
 330           aRv = request->Start();
 331         }
 332
 333         break;
 334       }
 335
 336       case RequestResolver::Type::Estimate: {
 337         RefPtr<RequestResolver> resolver =
 338             new RequestResolver(RequestResolver::Type::Estimate, promise);
 339
 340         RefPtr<nsIQuotaRequest> request;
 341         aRv = Estimate(principal, resolver, getter_AddRefs(request));
 342
 343         break;
 344       }
 345
 346       default:
 347         MOZ_CRASH("Invalid aRequest type!");
 348     }
 349
 350     if (NS_WARN_IF(aRv.Failed())) {
 351       return nullptr;
 352     }
 353
 354     return promise.forget();
 355   }
 356
 357   WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
 358   MOZ_ASSERT(workerPrivate);
 359
 360   RefPtr<PromiseWorkerProxy> promiseProxy =
 361       PromiseWorkerProxy::Create(workerPrivate, promise);
 362   if (NS_WARN_IF(!promiseProxy)) {
 363     return nullptr;
 364   }
 365
 366   switch (aType) {
 367     case RequestResolver::Type::Estimate: {
 368       RefPtr<EstimateWorkerMainThreadRunnable> runnnable =
 369           new EstimateWorkerMainThreadRunnable(promiseProxy->GetWorkerPrivate(),
 370                                                promiseProxy);
 371       runnnable->Dispatch(Canceling, aRv);
 372
 373       break;
 374     }
 375
 376     case RequestResolver::Type::Persisted: {
 377       RefPtr<PersistedWorkerMainThreadRunnable> runnnable =
 378           new PersistedWorkerMainThreadRunnable(
 379               promiseProxy->GetWorkerPrivate(), promiseProxy);
 380       runnnable->Dispatch(Canceling, aRv);
 381
 382       break;
 383     }
 384
 385     default:
 386       MOZ_CRASH("Invalid aRequest type");
 387   }
 388
 389   if (NS_WARN_IF(aRv.Failed())) {
 390     return nullptr;
 391   }
 392
 393   return promise.forget();
 394 };
 395
 396 }  // namespace
 397
 398 /*******************************************************************************
 399  * Local class implementations
 400  ******************************************************************************/
 401
 402 void RequestResolver::ResolveOrReject() {
 403   class MOZ_STACK_CLASS AutoCleanup final {
 404     RefPtr<PromiseWorkerProxy> mProxy;
 405
 406    public:
 407     explicit AutoCleanup(PromiseWorkerProxy* aProxy) : mProxy(aProxy) {
 408       MOZ_ASSERT(aProxy);
 409     }
 410
 411     ~AutoCleanup() {
 412       MOZ_ASSERT(mProxy);
 413
 414       mProxy->CleanUp();
 415     }
 416   };
 417
 418   RefPtr<Promise> promise;
 419   Maybe<AutoCleanup> autoCleanup;
 420
 421   if (mPromise) {
 422     promise = mPromise;
 423   } else {
 424     MOZ_ASSERT(mProxy);
 425
 426     promise = mProxy->WorkerPromise();
 427
 428     // Only clean up for worker case.
 429     autoCleanup.emplace(mProxy);
 430   }
 431
 432   MOZ_ASSERT(promise);
 433
 434   if (mType == Type::Estimate) {
 435     if (NS_SUCCEEDED(mResultCode)) {
 436       promise->MaybeResolve(mStorageEstimate);
 437     } else {
 438       promise->MaybeRejectWithTypeError(
 439           "Internal error while estimating storage usage");
 440     }
 441
 442     return;
 443   }
 444
 445   MOZ_ASSERT(mType == Type::Persist || mType == Type::Persisted);
 446
 447   if (NS_SUCCEEDED(mResultCode)) {
 448     promise->MaybeResolve(mPersisted);
 449   } else {
 450     promise->MaybeResolve(false);
 451   }
 452 }
 453
 454 NS_IMPL_ISUPPORTS(RequestResolver, nsIQuotaCallback)
 455
 456 nsresult RequestResolver::GetStorageEstimate(nsIVariant* aResult) {
 457   MOZ_ASSERT(aResult);
 458   MOZ_ASSERT(mType == Type::Estimate);
 459
 460   MOZ_ASSERT(aResult->GetDataType() == nsIDataType::VTYPE_INTERFACE_IS);
 461
 462   nsID* iid;
 463   nsCOMPtr<nsISupports> supports;
 464   nsresult rv = aResult->GetAsInterface(&iid, getter_AddRefs(supports));
 465   if (NS_WARN_IF(NS_FAILED(rv))) {
 466     return rv;
 467   }
 468
 469   free(iid);
 470
 471   nsCOMPtr<nsIQuotaEstimateResult> estimateResult = do_QueryInterface(supports);
 472   MOZ_ASSERT(estimateResult);
 473
 474   MOZ_ALWAYS_SUCCEEDS(
 475       estimateResult->GetUsage(&mStorageEstimate.mUsage.Construct()));
 476
 477   MOZ_ALWAYS_SUCCEEDS(
 478       estimateResult->GetLimit(&mStorageEstimate.mQuota.Construct()));
 479
 480   return NS_OK;
 481 }
 482
 483 nsresult RequestResolver::GetPersisted(nsIVariant* aResult) {
 484   MOZ_ASSERT(aResult);
 485   MOZ_ASSERT(mType == Type::Persist || mType == Type::Persisted);
 486
 487 #ifdef DEBUG
 488   uint16_t dataType = aResult->GetDataType();
 489 #endif
 490
 491   if (mType == Type::Persist) {
 492     MOZ_ASSERT(dataType == nsIDataType::VTYPE_VOID);
 493
 494     mPersisted = true;
 495     return NS_OK;
 496   }
 497
 498   MOZ_ASSERT(dataType == nsIDataType::VTYPE_BOOL);
 499
 500   bool persisted;
 501   nsresult rv = aResult->GetAsBool(&persisted);
 502   if (NS_WARN_IF(NS_FAILED(rv))) {
 503     return rv;
 504   }
 505
 506   mPersisted = persisted;
 507   return NS_OK;
 508 }
 509
 510 nsresult RequestResolver::OnCompleteInternal(nsIQuotaRequest* aRequest) {
 511   MOZ_ASSERT(NS_IsMainThread());
 512   MOZ_ASSERT(aRequest);
 513
 514   nsresult resultCode;
 515   nsresult rv = aRequest->GetResultCode(&resultCode);
 516   if (NS_WARN_IF(NS_FAILED(rv))) {
 517     return rv;
 518   }
 519
 520   if (NS_FAILED(resultCode)) {
 521     return resultCode;
 522   }
 523
 524   nsCOMPtr<nsIVariant> result;
 525   rv = aRequest->GetResult(getter_AddRefs(result));
 526   if (NS_WARN_IF(NS_FAILED(rv))) {
 527     return rv;
 528   }
 529
 530   if (mType == Type::Estimate) {
 531     rv = GetStorageEstimate(result);
 532   } else {
 533     MOZ_ASSERT(mType == Type::Persist || mType == Type::Persisted);
 534
 535     rv = GetPersisted(result);
 536   }
 537   if (NS_WARN_IF(NS_FAILED(rv))) {
 538     return rv;
 539   }
 540
 541   return NS_OK;
 542 }
 543
 544 nsresult RequestResolver::Finish() {
 545   // In a main thread request.
 546   if (!mProxy) {
 547     MOZ_ASSERT(mPromise);
 548
 549     ResolveOrReject();
 550     return NS_OK;
 551   }
 552
 553   {
 554     // In a worker thread request.
 555     MutexAutoLock lock(mProxy->Lock());
 556
 557     if (NS_WARN_IF(mProxy->CleanedUp())) {
 558       return NS_ERROR_FAILURE;
 559     }
 560
 561     RefPtr<FinishWorkerRunnable> runnable = new FinishWorkerRunnable(this);
 562     if (NS_WARN_IF(!runnable->Dispatch())) {
 563       return NS_ERROR_FAILURE;
 564     }
 565   }
 566
 567   return NS_OK;
 568 }
 569
 570 NS_IMETHODIMP
 571 RequestResolver::OnComplete(nsIQuotaRequest* aRequest) {
 572   MOZ_ASSERT(NS_IsMainThread());
 573   MOZ_ASSERT(aRequest);
 574
 575   mResultCode = OnCompleteInternal(aRequest);
 576
 577   nsresult rv = Finish();
 578   if (NS_WARN_IF(NS_FAILED(rv))) {
 579     return rv;
 580   }
 581
 582   return NS_OK;
 583 }
 584
 585 bool RequestResolver::FinishWorkerRunnable::WorkerRun(
 586     JSContext* aCx, WorkerPrivate* aWorkerPrivate) {
 587   MOZ_ASSERT(aCx);
 588   MOZ_ASSERT(aWorkerPrivate);
 589   aWorkerPrivate->AssertIsOnWorkerThread();
 590
 591   MOZ_ASSERT(mResolver);
 592   mResolver->ResolveOrReject();
 593
 594   return true;
 595 }
 596
 597 bool EstimateWorkerMainThreadRunnable::MainThreadRun() {
 598   MOZ_ASSERT(NS_IsMainThread());
 599
 600   nsCOMPtr<nsIPrincipal> principal;
 601
 602   {
 603     MutexAutoLock lock(mProxy->Lock());
 604     if (mProxy->CleanedUp()) {
 605       return true;
 606     }
 607     principal = mProxy->GetWorkerPrivate()->GetPrincipal();
 608   }
 609
 610   MOZ_ASSERT(principal);
 611
 612   RefPtr<RequestResolver> resolver =
 613       new RequestResolver(RequestResolver::Type::Estimate, mProxy);
 614
 615   RefPtr<nsIQuotaRequest> request;
 616   nsresult rv = Estimate(principal, resolver, getter_AddRefs(request));
 617   if (NS_WARN_IF(NS_FAILED(rv))) {
 618     return false;
 619   }
 620
 621   return true;
 622 }
 623
 624 bool PersistedWorkerMainThreadRunnable::MainThreadRun() {
 625   MOZ_ASSERT(NS_IsMainThread());
 626
 627   nsCOMPtr<nsIPrincipal> principal;
 628
 629   {
 630     MutexAutoLock lock(mProxy->Lock());
 631     if (mProxy->CleanedUp()) {
 632       return true;
 633     }
 634     principal = mProxy->GetWorkerPrivate()->GetPrincipal();
 635   }
 636
 637   MOZ_ASSERT(principal);
 638
 639   RefPtr<RequestResolver> resolver =
 640       new RequestResolver(RequestResolver::Type::Persisted, mProxy);
 641
 642   RefPtr<nsIQuotaRequest> request;
 643   nsresult rv = Persisted(principal, resolver, getter_AddRefs(request));
 644   if (NS_WARN_IF(NS_FAILED(rv))) {
 645     return false;
 646   }
 647
 648   return true;
 649 }
 650
 651 nsresult PersistentStoragePermissionRequest::Start() {
 652   MOZ_ASSERT(NS_IsMainThread());
 653
 654   PromptResult pr;
 655 #ifdef MOZ_WIDGET_ANDROID
 656   // on Android calling `ShowPrompt` here calls
 657   // `nsContentPermissionUtils::AskPermission` once, and a response of
 658   // `PromptResult::Pending` calls it again. This results in multiple requests
 659   // for storage access, so we check the prompt prefs only to ensure we only
 660   // request it once.
 661   pr = CheckPromptPrefs();
 662 #else
 663   nsresult rv = ShowPrompt(pr);
 664   if (NS_WARN_IF(NS_FAILED(rv))) {
 665     return rv;
 666   }
 667 #endif
 668   if (pr == PromptResult::Granted) {
 669     return Allow(JS::UndefinedHandleValue);
 670   }
 671   if (pr == PromptResult::Denied) {
 672     return Cancel();
 673   }
 674
 675   return nsContentPermissionUtils::AskPermission(this, mWindow);
 676 }
 677
 678 NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(
 679     PersistentStoragePermissionRequest, ContentPermissionRequestBase)
 680
 681 NS_IMPL_CYCLE_COLLECTION_INHERITED(PersistentStoragePermissionRequest,
 682                                    ContentPermissionRequestBase, mPromise)
 683
 684 NS_IMETHODIMP
 685 PersistentStoragePermissionRequest::Cancel() {
 686   MOZ_ASSERT(NS_IsMainThread());
 687   MOZ_ASSERT(mPromise);
 688
 689   RefPtr<RequestResolver> resolver =
 690       new RequestResolver(RequestResolver::Type::Persisted, mPromise);
 691
 692   RefPtr<nsIQuotaRequest> request;
 693
 694   return Persisted(mPrincipal, resolver, getter_AddRefs(request));
 695 }
 696
 697 NS_IMETHODIMP
 698 PersistentStoragePermissionRequest::Allow(JS::HandleValue aChoices) {
 699   MOZ_ASSERT(NS_IsMainThread());
 700
 701   RefPtr<RequestResolver> resolver =
 702       new RequestResolver(RequestResolver::Type::Persist, mPromise);
 703
 704   nsCOMPtr<nsIQuotaManagerService> qms = QuotaManagerService::GetOrCreate();
 705   if (NS_WARN_IF(!qms)) {
 706     return NS_ERROR_FAILURE;
 707   }
 708
 709   RefPtr<nsIQuotaRequest> request;
 710
 711   nsresult rv = qms->Persist(mPrincipal, getter_AddRefs(request));
 712   if (NS_WARN_IF(NS_FAILED(rv))) {
 713     return rv;
 714   }
 715
 716   MOZ_ALWAYS_SUCCEEDS(request->SetCallback(resolver));
 717
 718   return NS_OK;
 719 }
 720
 721 /*******************************************************************************
 722  * StorageManager
 723  ******************************************************************************/
 724
 725 StorageManager::StorageManager(nsIGlobalObject* aGlobal) : mOwner(aGlobal) {
 726   MOZ_ASSERT(aGlobal);
 727 }
 728
 729 StorageManager::~StorageManager() = default;
 730
 731 already_AddRefed<Promise> StorageManager::Persisted(ErrorResult& aRv) {
 732   MOZ_ASSERT(mOwner);
 733
 734   return ExecuteOpOnMainOrWorkerThread(mOwner, RequestResolver::Type::Persisted,
 735                                        aRv);
 736 }
 737
 738 already_AddRefed<Promise> StorageManager::Persist(ErrorResult& aRv) {
 739   MOZ_ASSERT(mOwner);
 740
 741   Telemetry::ScalarAdd(Telemetry::ScalarID::NAVIGATOR_STORAGE_PERSIST_COUNT, 1);
 742   return ExecuteOpOnMainOrWorkerThread(mOwner, RequestResolver::Type::Persist,
 743                                        aRv);
 744 }
 745
 746 already_AddRefed<Promise> StorageManager::Estimate(ErrorResult& aRv) {
 747   MOZ_ASSERT(mOwner);
 748
 749   Telemetry::ScalarAdd(Telemetry::ScalarID::NAVIGATOR_STORAGE_ESTIMATE_COUNT,
 750                        1);
 751   return ExecuteOpOnMainOrWorkerThread(mOwner, RequestResolver::Type::Estimate,
 752                                        aRv);
 753 }
 754
 755 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(StorageManager, mOwner)
 756
 757 NS_IMPL_CYCLE_COLLECTING_ADDREF(StorageManager)
 758 NS_IMPL_CYCLE_COLLECTING_RELEASE(StorageManager)
 759
 760 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(StorageManager)
 761   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
 762   NS_INTERFACE_MAP_ENTRY(nsISupports)
 763 NS_INTERFACE_MAP_END
 764
 765 JSObject* StorageManager::WrapObject(JSContext* aCx,
 766                                      JS::Handle<JSObject*> aGivenProto) {
 767   return StorageManager_Binding::Wrap(aCx, this, aGivenProto);
 768 }
 769
 770 }  // namespace mozilla::dom