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