dom/cache/Cache.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
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/cache/Cache.h"
   8
   9 #include "js/Array.h"               // JS::GetArrayLength, JS::IsArrayObject
  10 #include "js/PropertyAndElement.h"  // JS_GetElement
  11 #include "mozilla/dom/Headers.h"
  12 #include "mozilla/dom/InternalResponse.h"
  13 #include "mozilla/dom/Promise.h"
  14 #include "mozilla/dom/PromiseNativeHandler.h"
  15 #include "mozilla/dom/Response.h"
  16 #include "mozilla/dom/RootedDictionary.h"
  17 #include "mozilla/dom/WorkerPrivate.h"
  18 #include "mozilla/dom/CacheBinding.h"
  19 #include "mozilla/dom/cache/AutoUtils.h"
  20 #include "mozilla/dom/cache/CacheChild.h"
  21 #include "mozilla/dom/cache/CacheCommon.h"
  22 #include "mozilla/dom/cache/CacheWorkerRef.h"
  23 #include "mozilla/dom/quota/ResultExtensions.h"
  24 #include "mozilla/ErrorResult.h"
  25 #include "mozilla/Preferences.h"
  26 #include "mozilla/Unused.h"
  27 #include "nsIGlobalObject.h"
  28
  29 namespace mozilla::dom::cache {
  30
  31 using mozilla::ipc::PBackgroundChild;
  32
  33 namespace {
  34
  35 enum class PutStatusPolicy { Default, RequireOK };
  36
  37 bool IsValidPutRequestURL(const nsACString& aUrl, ErrorResult& aRv) {
  38   bool validScheme = false;
  39
  40   // make a copy because ProcessURL strips the fragmet
  41   nsAutoCString url(aUrl);
  42   TypeUtils::ProcessURL(url, &validScheme, nullptr, nullptr, aRv);
  43   if (aRv.Failed()) {
  44     return false;
  45   }
  46
  47   if (!validScheme) {
  48     // `url` has been modified, so don't use it here.
  49     aRv.ThrowTypeError<MSG_INVALID_URL_SCHEME>("Request", aUrl);
  50     return false;
  51   }
  52
  53   return true;
  54 }
  55
  56 static bool IsValidPutRequestMethod(const Request& aRequest, ErrorResult& aRv) {
  57   nsAutoCString method;
  58   aRequest.GetMethod(method);
  59   if (!method.LowerCaseEqualsLiteral("get")) {
  60     aRv.ThrowTypeError<MSG_INVALID_REQUEST_METHOD>(method);
  61     return false;
  62   }
  63
  64   return true;
  65 }
  66
  67 static bool IsValidPutRequestMethod(const RequestOrUTF8String& aRequest,
  68                                     ErrorResult& aRv) {
  69   // If the provided request is a string URL, then it will default to
  70   // a valid http method automatically.
  71   if (!aRequest.IsRequest()) {
  72     return true;
  73   }
  74   return IsValidPutRequestMethod(aRequest.GetAsRequest(), aRv);
  75 }
  76
  77 static bool IsValidPutResponseStatus(Response& aResponse,
  78                                      PutStatusPolicy aPolicy,
  79                                      ErrorResult& aRv) {
  80   if ((aPolicy == PutStatusPolicy::RequireOK && !aResponse.Ok()) ||
  81       aResponse.Status() == 206) {
  82     nsAutoCString url;
  83     aResponse.GetUrl(url);
  84     aRv.ThrowTypeError<MSG_CACHE_ADD_FAILED_RESPONSE>(
  85         GetEnumString(aResponse.Type()), IntToCString(aResponse.Status()), url);
  86     return false;
  87   }
  88
  89   return true;
  90 }
  91
  92 }  // namespace
  93
  94 // Helper class to wait for Add()/AddAll() fetch requests to complete and
  95 // then perform a PutAll() with the responses.  This class holds a WorkerRef
  96 // to keep the Worker thread alive.  This is mainly to ensure that Add/AddAll
  97 // act the same as other Cache operations that directly create a CacheOpChild
  98 // actor.
  99 class Cache::FetchHandler final : public PromiseNativeHandler {
 100  public:
 101   FetchHandler(SafeRefPtr<CacheWorkerRef> aWorkerRef, Cache* aCache,
 102                nsTArray<SafeRefPtr<Request>>&& aRequestList, Promise* aPromise)
 103       : mWorkerRef(std::move(aWorkerRef)),
 104         mCache(aCache),
 105         mRequestList(std::move(aRequestList)),
 106         mPromise(aPromise) {
 107     MOZ_ASSERT_IF(!NS_IsMainThread(), mWorkerRef);
 108     MOZ_DIAGNOSTIC_ASSERT(mCache);
 109     MOZ_DIAGNOSTIC_ASSERT(mPromise);
 110   }
 111
 112   virtual void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
 113                                 ErrorResult& aRv) override {
 114     NS_ASSERT_OWNINGTHREAD(FetchHandler);
 115
 116     // Stop holding the worker alive when we leave this method.
 117     const SafeRefPtr<CacheWorkerRef> workerRef = std::move(mWorkerRef);
 118
 119     // Promise::All() passed an array of fetch() Promises should give us
 120     // an Array of Response objects.  The following code unwraps these
 121     // JS values back to an nsTArray<RefPtr<Response>>.
 122
 123     AutoTArray<RefPtr<Response>, 256> responseList;
 124     responseList.SetCapacity(mRequestList.Length());
 125
 126     const auto failOnErr = [this](const auto) { Fail(); };
 127
 128     bool isArray;
 129     QM_TRY(OkIf(JS::IsArrayObject(aCx, aValue, &isArray)), QM_VOID, failOnErr);
 130     QM_TRY(OkIf(isArray), QM_VOID, failOnErr);
 131
 132     JS::Rooted<JSObject*> obj(aCx, &aValue.toObject());
 133
 134     uint32_t length;
 135     QM_TRY(OkIf(JS::GetArrayLength(aCx, obj, &length)), QM_VOID, failOnErr);
 136
 137     for (uint32_t i = 0; i < length; ++i) {
 138       JS::Rooted<JS::Value> value(aCx);
 139
 140       QM_TRY(OkIf(JS_GetElement(aCx, obj, i, &value)), QM_VOID, failOnErr);
 141
 142       QM_TRY(OkIf(value.isObject()), QM_VOID, failOnErr);
 143
 144       JS::Rooted<JSObject*> responseObj(aCx, &value.toObject());
 145
 146       RefPtr<Response> response;
 147       QM_TRY(MOZ_TO_RESULT(UNWRAP_OBJECT(Response, responseObj, response)),
 148              QM_VOID, failOnErr);
 149
 150       QM_TRY(OkIf(response->Type() != ResponseType::Error), QM_VOID, failOnErr);
 151
 152       // Do not allow the convenience methods .add()/.addAll() to store failed
 153       // or invalid responses.  A consequence of this is that these methods
 154       // cannot be used to store opaque or opaqueredirect responses since they
 155       // always expose a 0 status value.
 156       ErrorResult errorResult;
 157       if (!IsValidPutResponseStatus(*response, PutStatusPolicy::RequireOK,
 158                                     errorResult)) {
 159         // TODO: abort the fetch requests we have running (bug 1157434)
 160         mPromise->MaybeReject(std::move(errorResult));
 161         return;
 162       }
 163
 164       responseList.AppendElement(std::move(response));
 165     }
 166
 167     MOZ_DIAGNOSTIC_ASSERT(mRequestList.Length() == responseList.Length());
 168
 169     // Now store the unwrapped Response list in the Cache.
 170     ErrorResult result;
 171     // TODO: Here we use the JSContext as received by the ResolvedCallback, and
 172     // its state could be the wrong one. The spec doesn't say anything
 173     // about it, yet (bug 1384006)
 174     RefPtr<Promise> put =
 175         mCache->PutAll(aCx, mRequestList, responseList, result);
 176     result.WouldReportJSException();
 177     if (NS_WARN_IF(result.Failed())) {
 178       // TODO: abort the fetch requests we have running (bug 1157434)
 179       mPromise->MaybeReject(std::move(result));
 180       return;
 181     }
 182
 183     // Chain the Cache::Put() promise to the original promise returned to
 184     // the content script.
 185     mPromise->MaybeResolve(put);
 186   }
 187
 188   virtual void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue,
 189                                 ErrorResult& aRv) override {
 190     NS_ASSERT_OWNINGTHREAD(FetchHandler);
 191     Fail();
 192   }
 193
 194  private:
 195   ~FetchHandler() = default;
 196
 197   void Fail() { mPromise->MaybeRejectWithTypeError<MSG_FETCH_FAILED>(); }
 198
 199   SafeRefPtr<CacheWorkerRef> mWorkerRef;
 200   RefPtr<Cache> mCache;
 201   nsTArray<SafeRefPtr<Request>> mRequestList;
 202   RefPtr<Promise> mPromise;
 203
 204   NS_DECL_ISUPPORTS
 205 };
 206
 207 NS_IMPL_ISUPPORTS0(Cache::FetchHandler)
 208
 209 NS_IMPL_CYCLE_COLLECTING_ADDREF(mozilla::dom::cache::Cache);
 210 NS_IMPL_CYCLE_COLLECTING_RELEASE(mozilla::dom::cache::Cache);
 211 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(mozilla::dom::cache::Cache, mGlobal);
 212
 213 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Cache)
 214   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
 215   NS_INTERFACE_MAP_ENTRY(nsISupports)
 216 NS_INTERFACE_MAP_END
 217
 218 Cache::Cache(nsIGlobalObject* aGlobal, CacheChild* aActor, Namespace aNamespace)
 219     : mGlobal(aGlobal), mActor(aActor), mNamespace(aNamespace) {
 220   MOZ_DIAGNOSTIC_ASSERT(mGlobal);
 221   MOZ_DIAGNOSTIC_ASSERT(mActor);
 222   MOZ_DIAGNOSTIC_ASSERT(mNamespace != INVALID_NAMESPACE);
 223   mActor->SetListener(this);
 224 }
 225
 226 already_AddRefed<Promise> Cache::Match(JSContext* aCx,
 227                                        const RequestOrUTF8String& aRequest,
 228                                        const CacheQueryOptions& aOptions,
 229                                        ErrorResult& aRv) {
 230   if (NS_WARN_IF(!mActor)) {
 231     aRv.Throw(NS_ERROR_UNEXPECTED);
 232     return nullptr;
 233   }
 234
 235   CacheChild::AutoLock actorLock(*mActor);
 236
 237   SafeRefPtr<InternalRequest> ir =
 238       ToInternalRequest(aCx, aRequest, IgnoreBody, aRv);
 239   if (NS_WARN_IF(aRv.Failed())) {
 240     return nullptr;
 241   }
 242
 243   CacheQueryParams params;
 244   ToCacheQueryParams(params, aOptions);
 245
 246   AutoChildOpArgs args(
 247       this, CacheMatchArgs(CacheRequest(), params, GetOpenMode()), 1);
 248
 249   args.Add(*ir, IgnoreBody, IgnoreInvalidScheme, aRv);
 250   if (NS_WARN_IF(aRv.Failed())) {
 251     return nullptr;
 252   }
 253
 254   return ExecuteOp(args, aRv);
 255 }
 256
 257 already_AddRefed<Promise> Cache::MatchAll(
 258     JSContext* aCx, const Optional<RequestOrUTF8String>& aRequest,
 259     const CacheQueryOptions& aOptions, ErrorResult& aRv) {
 260   if (NS_WARN_IF(!mActor)) {
 261     aRv.Throw(NS_ERROR_UNEXPECTED);
 262     return nullptr;
 263   }
 264
 265   CacheChild::AutoLock actorLock(*mActor);
 266
 267   CacheQueryParams params;
 268   ToCacheQueryParams(params, aOptions);
 269
 270   AutoChildOpArgs args(this,
 271                        CacheMatchAllArgs(Nothing(), params, GetOpenMode()), 1);
 272
 273   if (aRequest.WasPassed()) {
 274     SafeRefPtr<InternalRequest> ir =
 275         ToInternalRequest(aCx, aRequest.Value(), IgnoreBody, aRv);
 276     if (aRv.Failed()) {
 277       return nullptr;
 278     }
 279
 280     args.Add(*ir, IgnoreBody, IgnoreInvalidScheme, aRv);
 281     if (aRv.Failed()) {
 282       return nullptr;
 283     }
 284   }
 285
 286   return ExecuteOp(args, aRv);
 287 }
 288
 289 already_AddRefed<Promise> Cache::Add(JSContext* aContext,
 290                                      const RequestOrUTF8String& aRequest,
 291                                      CallerType aCallerType, ErrorResult& aRv) {
 292   if (NS_WARN_IF(!mActor)) {
 293     aRv.Throw(NS_ERROR_UNEXPECTED);
 294     return nullptr;
 295   }
 296
 297   CacheChild::AutoLock actorLock(*mActor);
 298
 299   if (!IsValidPutRequestMethod(aRequest, aRv)) {
 300     return nullptr;
 301   }
 302
 303   GlobalObject global(aContext, mGlobal->GetGlobalJSObject());
 304   MOZ_DIAGNOSTIC_ASSERT(!global.Failed());
 305
 306   nsTArray<SafeRefPtr<Request>> requestList(1);
 307   RootedDictionary<RequestInit> requestInit(aContext);
 308   SafeRefPtr<Request> request =
 309       Request::Constructor(global, aRequest, requestInit, aRv);
 310   if (NS_WARN_IF(aRv.Failed())) {
 311     return nullptr;
 312   }
 313
 314   nsAutoCString url;
 315   request->GetUrl(url);
 316   if (NS_WARN_IF(!IsValidPutRequestURL(url, aRv))) {
 317     return nullptr;
 318   }
 319
 320   requestList.AppendElement(std::move(request));
 321   return AddAll(global, std::move(requestList), aCallerType, aRv);
 322 }
 323
 324 already_AddRefed<Promise> Cache::AddAll(
 325     JSContext* aContext,
 326     const Sequence<OwningRequestOrUTF8String>& aRequestList,
 327     CallerType aCallerType, ErrorResult& aRv) {
 328   if (NS_WARN_IF(!mActor)) {
 329     aRv.Throw(NS_ERROR_UNEXPECTED);
 330     return nullptr;
 331   }
 332
 333   CacheChild::AutoLock actorLock(*mActor);
 334
 335   GlobalObject global(aContext, mGlobal->GetGlobalJSObject());
 336   MOZ_DIAGNOSTIC_ASSERT(!global.Failed());
 337
 338   nsTArray<SafeRefPtr<Request>> requestList(aRequestList.Length());
 339   for (uint32_t i = 0; i < aRequestList.Length(); ++i) {
 340     RequestOrUTF8String requestOrString;
 341
 342     if (aRequestList[i].IsRequest()) {
 343       requestOrString.SetAsRequest() = aRequestList[i].GetAsRequest();
 344       if (NS_WARN_IF(
 345               !IsValidPutRequestMethod(requestOrString.GetAsRequest(), aRv))) {
 346         return nullptr;
 347       }
 348     } else {
 349       requestOrString.SetAsUTF8String().ShareOrDependUpon(
 350           aRequestList[i].GetAsUTF8String());
 351     }
 352
 353     RootedDictionary<RequestInit> requestInit(aContext);
 354     SafeRefPtr<Request> request =
 355         Request::Constructor(global, requestOrString, requestInit, aRv);
 356     if (NS_WARN_IF(aRv.Failed())) {
 357       return nullptr;
 358     }
 359
 360     nsAutoCString url;
 361     request->GetUrl(url);
 362     if (NS_WARN_IF(!IsValidPutRequestURL(url, aRv))) {
 363       return nullptr;
 364     }
 365
 366     requestList.AppendElement(std::move(request));
 367   }
 368
 369   return AddAll(global, std::move(requestList), aCallerType, aRv);
 370 }
 371
 372 already_AddRefed<Promise> Cache::Put(JSContext* aCx,
 373                                      const RequestOrUTF8String& aRequest,
 374                                      Response& aResponse, ErrorResult& aRv) {
 375   if (NS_WARN_IF(!mActor)) {
 376     aRv.Throw(NS_ERROR_UNEXPECTED);
 377     return nullptr;
 378   }
 379
 380   CacheChild::AutoLock actorLock(*mActor);
 381
 382   if (NS_WARN_IF(!IsValidPutRequestMethod(aRequest, aRv))) {
 383     return nullptr;
 384   }
 385
 386   if (!IsValidPutResponseStatus(aResponse, PutStatusPolicy::Default, aRv)) {
 387     return nullptr;
 388   }
 389
 390   if (NS_WARN_IF(aResponse.GetPrincipalInfo() &&
 391                  aResponse.GetPrincipalInfo()->type() ==
 392                      mozilla::ipc::PrincipalInfo::TExpandedPrincipalInfo)) {
 393     // WebExtensions Content Scripts can currently run fetch from their global
 394     // which will end up to have an expanded principal, but we require that the
 395     // contents of Cache storage for the content origin to be same-origin, and
 396     // never an expanded principal (See Bug 1753810).
 397     aRv.ThrowSecurityError("Disallowed on WebExtension ContentScript Request");
 398     return nullptr;
 399   }
 400
 401   SafeRefPtr<InternalRequest> ir =
 402       ToInternalRequest(aCx, aRequest, ReadBody, aRv);
 403   if (NS_WARN_IF(aRv.Failed())) {
 404     return nullptr;
 405   }
 406
 407   AutoChildOpArgs args(this, CachePutAllArgs(), 1);
 408
 409   args.Add(aCx, *ir, ReadBody, TypeErrorOnInvalidScheme, aResponse, aRv);
 410   if (NS_WARN_IF(aRv.Failed())) {
 411     return nullptr;
 412   }
 413
 414   return ExecuteOp(args, aRv);
 415 }
 416
 417 already_AddRefed<Promise> Cache::Delete(JSContext* aCx,
 418                                         const RequestOrUTF8String& aRequest,
 419                                         const CacheQueryOptions& aOptions,
 420                                         ErrorResult& aRv) {
 421   if (NS_WARN_IF(!mActor)) {
 422     aRv.Throw(NS_ERROR_UNEXPECTED);
 423     return nullptr;
 424   }
 425
 426   CacheChild::AutoLock actorLock(*mActor);
 427
 428   SafeRefPtr<InternalRequest> ir =
 429       ToInternalRequest(aCx, aRequest, IgnoreBody, aRv);
 430   if (NS_WARN_IF(aRv.Failed())) {
 431     return nullptr;
 432   }
 433
 434   CacheQueryParams params;
 435   ToCacheQueryParams(params, aOptions);
 436
 437   AutoChildOpArgs args(this, CacheDeleteArgs(CacheRequest(), params), 1);
 438
 439   args.Add(*ir, IgnoreBody, IgnoreInvalidScheme, aRv);
 440   if (NS_WARN_IF(aRv.Failed())) {
 441     return nullptr;
 442   }
 443
 444   return ExecuteOp(args, aRv);
 445 }
 446
 447 already_AddRefed<Promise> Cache::Keys(
 448     JSContext* aCx, const Optional<RequestOrUTF8String>& aRequest,
 449     const CacheQueryOptions& aOptions, ErrorResult& aRv) {
 450   if (NS_WARN_IF(!mActor)) {
 451     aRv.Throw(NS_ERROR_UNEXPECTED);
 452     return nullptr;
 453   }
 454
 455   CacheChild::AutoLock actorLock(*mActor);
 456
 457   CacheQueryParams params;
 458   ToCacheQueryParams(params, aOptions);
 459
 460   AutoChildOpArgs args(this, CacheKeysArgs(Nothing(), params, GetOpenMode()),
 461                        1);
 462
 463   if (aRequest.WasPassed()) {
 464     SafeRefPtr<InternalRequest> ir =
 465         ToInternalRequest(aCx, aRequest.Value(), IgnoreBody, aRv);
 466     if (NS_WARN_IF(aRv.Failed())) {
 467       return nullptr;
 468     }
 469
 470     args.Add(*ir, IgnoreBody, IgnoreInvalidScheme, aRv);
 471     if (NS_WARN_IF(aRv.Failed())) {
 472       return nullptr;
 473     }
 474   }
 475
 476   return ExecuteOp(args, aRv);
 477 }
 478
 479 nsISupports* Cache::GetParentObject() const { return mGlobal; }
 480
 481 JSObject* Cache::WrapObject(JSContext* aContext,
 482                             JS::Handle<JSObject*> aGivenProto) {
 483   return Cache_Binding::Wrap(aContext, this, aGivenProto);
 484 }
 485
 486 void Cache::DestroyInternal(CacheChild* aActor) {
 487   MOZ_DIAGNOSTIC_ASSERT(mActor);
 488   MOZ_DIAGNOSTIC_ASSERT(mActor == aActor);
 489   mActor->ClearListener();
 490   mActor = nullptr;
 491 }
 492
 493 nsIGlobalObject* Cache::GetGlobalObject() const { return mGlobal; }
 494
 495 #ifdef DEBUG
 496 void Cache::AssertOwningThread() const { NS_ASSERT_OWNINGTHREAD(Cache); }
 497 #endif
 498
 499 PBackgroundChild* Cache::GetIPCManager() {
 500   NS_ASSERT_OWNINGTHREAD(Cache);
 501   MOZ_DIAGNOSTIC_ASSERT(mActor);
 502   return mActor->Manager();
 503 }
 504
 505 Cache::~Cache() {
 506   NS_ASSERT_OWNINGTHREAD(Cache);
 507   if (mActor) {
 508     mActor->StartDestroyFromListener();
 509     // DestroyInternal() is called synchronously by StartDestroyFromListener().
 510     // So we should have already cleared the mActor.
 511     MOZ_DIAGNOSTIC_ASSERT(!mActor);
 512   }
 513 }
 514
 515 already_AddRefed<Promise> Cache::ExecuteOp(AutoChildOpArgs& aOpArgs,
 516                                            ErrorResult& aRv) {
 517   MOZ_DIAGNOSTIC_ASSERT(mActor);
 518
 519   RefPtr<Promise> promise = Promise::Create(mGlobal, aRv);
 520   if (NS_WARN_IF(!promise)) {
 521     return nullptr;
 522   }
 523
 524   mActor->ExecuteOp(mGlobal, promise, this, aOpArgs.SendAsOpArgs());
 525   return promise.forget();
 526 }
 527
 528 already_AddRefed<Promise> Cache::AddAll(
 529     const GlobalObject& aGlobal, nsTArray<SafeRefPtr<Request>>&& aRequestList,
 530     CallerType aCallerType, ErrorResult& aRv) {
 531   MOZ_DIAGNOSTIC_ASSERT(mActor);
 532
 533   // If there is no work to do, then resolve immediately
 534   if (aRequestList.IsEmpty()) {
 535     RefPtr<Promise> promise = Promise::Create(mGlobal, aRv);
 536     if (NS_WARN_IF(!promise)) {
 537       return nullptr;
 538     }
 539
 540     promise->MaybeResolveWithUndefined();
 541     return promise.forget();
 542   }
 543
 544   AutoTArray<RefPtr<Promise>, 256> fetchList;
 545   fetchList.SetCapacity(aRequestList.Length());
 546
 547   // Begin fetching each request in parallel.  For now, if an error occurs just
 548   // abandon our previous fetch calls.  In theory we could cancel them in the
 549   // future once fetch supports it.
 550
 551   for (uint32_t i = 0; i < aRequestList.Length(); ++i) {
 552     RequestOrUTF8String requestOrString;
 553     requestOrString.SetAsRequest() = aRequestList[i].unsafeGetRawPtr();
 554     RootedDictionary<RequestInit> requestInit(aGlobal.Context());
 555     RefPtr<Promise> fetch =
 556         FetchRequest(mGlobal, requestOrString, requestInit, aCallerType, aRv);
 557     if (NS_WARN_IF(aRv.Failed())) {
 558       return nullptr;
 559     }
 560
 561     fetchList.AppendElement(std::move(fetch));
 562   }
 563
 564   RefPtr<Promise> promise = Promise::Create(mGlobal, aRv);
 565   if (NS_WARN_IF(aRv.Failed())) {
 566     return nullptr;
 567   }
 568
 569   RefPtr<FetchHandler> handler =
 570       new FetchHandler(mActor->GetWorkerRefPtr().clonePtr(), this,
 571                        std::move(aRequestList), promise);
 572
 573   RefPtr<Promise> fetchPromise =
 574       Promise::All(aGlobal.Context(), fetchList, aRv);
 575   if (NS_WARN_IF(aRv.Failed())) {
 576     return nullptr;
 577   }
 578   fetchPromise->AppendNativeHandler(handler);
 579
 580   return promise.forget();
 581 }
 582
 583 already_AddRefed<Promise> Cache::PutAll(
 584     JSContext* aCx, const nsTArray<SafeRefPtr<Request>>& aRequestList,
 585     const nsTArray<RefPtr<Response>>& aResponseList, ErrorResult& aRv) {
 586   MOZ_DIAGNOSTIC_ASSERT(aRequestList.Length() == aResponseList.Length());
 587
 588   if (NS_WARN_IF(!mActor)) {
 589     aRv.Throw(NS_ERROR_UNEXPECTED);
 590     return nullptr;
 591   }
 592
 593   CacheChild::AutoLock actorLock(*mActor);
 594
 595   AutoChildOpArgs args(this, CachePutAllArgs(), aRequestList.Length());
 596
 597   for (uint32_t i = 0; i < aRequestList.Length(); ++i) {
 598     SafeRefPtr<InternalRequest> ir = aRequestList[i]->GetInternalRequest();
 599     args.Add(aCx, *ir, ReadBody, TypeErrorOnInvalidScheme, *aResponseList[i],
 600              aRv);
 601     if (NS_WARN_IF(aRv.Failed())) {
 602       return nullptr;
 603     }
 604   }
 605
 606   return ExecuteOp(args, aRv);
 607 }
 608
 609 OpenMode Cache::GetOpenMode() const {
 610   return mNamespace == CHROME_ONLY_NAMESPACE ? OpenMode::Eager : OpenMode::Lazy;
 611 }
 612
 613 }  // namespace mozilla::dom::cache