dom/fetch/FetchDriver.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 "js/Value.h"
   8 #include "mozilla/DebugOnly.h"
   9 #include "mozilla/TaskQueue.h"
  10 #include "mozilla/dom/FetchDriver.h"
  11
  12 #include "mozilla/dom/ReferrerInfo.h"
  13 #include "nsIAsyncVerifyRedirectCallback.h"
  14 #include "mozilla/dom/Document.h"
  15 #include "nsICookieJarSettings.h"
  16 #include "nsIFile.h"
  17 #include "nsIInputStream.h"
  18 #include "nsIInterceptionInfo.h"
  19 #include "nsIOutputStream.h"
  20 #include "nsIFileChannel.h"
  21 #include "nsIHttpChannel.h"
  22 #include "nsIHttpChannelInternal.h"
  23 #include "nsISupportsPriority.h"
  24 #include "nsIThreadRetargetableRequest.h"
  25 #include "nsIUploadChannel2.h"
  26 #include "nsIInterfaceRequestorUtils.h"
  27 #include "nsIPipe.h"
  28 #include "nsIRedirectHistoryEntry.h"
  29
  30 #include "nsBaseChannel.h"
  31 #include "nsContentPolicyUtils.h"
  32 #include "nsDataChannel.h"
  33 #include "nsDataHandler.h"
  34 #include "nsNetUtil.h"
  35 #include "nsPrintfCString.h"
  36 #include "nsProxyRelease.h"
  37 #include "nsStreamUtils.h"
  38 #include "nsStringStream.h"
  39 #include "nsHttpChannel.h"
  40
  41 #include "mozilla/dom/BlobURLProtocolHandler.h"
  42 #include "mozilla/dom/File.h"
  43 #include "mozilla/dom/PerformanceStorage.h"
  44 #include "mozilla/dom/PerformanceTiming.h"
  45 #include "mozilla/dom/ServiceWorkerInterceptController.h"
  46 #include "mozilla/dom/UserActivation.h"
  47 #include "mozilla/dom/WorkerCommon.h"
  48 #include "mozilla/PreloaderBase.h"
  49 #include "mozilla/net/InterceptionInfo.h"
  50 #include "mozilla/net/NeckoChannelParams.h"
  51 #include "mozilla/ipc/PBackgroundSharedTypes.h"
  52 #include "mozilla/StaticPrefs_browser.h"
  53 #include "mozilla/StaticPrefs_network.h"
  54 #include "mozilla/StaticPrefs_privacy.h"
  55 #include "mozilla/StaticPrefs_javascript.h"
  56 #include "mozilla/Unused.h"
  57
  58 #include "Fetch.h"
  59 #include "FetchUtil.h"
  60 #include "InternalRequest.h"
  61 #include "InternalResponse.h"
  62
  63 namespace mozilla::dom {
  64
  65 namespace {
  66
  67 void GetBlobURISpecFromChannel(nsIRequest* aRequest, nsCString& aBlobURISpec) {
  68   MOZ_ASSERT(aRequest);
  69
  70   aBlobURISpec.SetIsVoid(true);
  71
  72   nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
  73   if (!channel) {
  74     return;
  75   }
  76
  77   nsCOMPtr<nsIURI> uri;
  78   nsresult rv = NS_GetFinalChannelURI(channel, getter_AddRefs(uri));
  79   if (NS_FAILED(rv)) {
  80     return;
  81   }
  82
  83   if (!dom::IsBlobURI(uri)) {
  84     return;
  85   }
  86
  87   uri->GetSpec(aBlobURISpec);
  88 }
  89
  90 bool ShouldCheckSRI(const InternalRequest& aRequest,
  91                     const InternalResponse& aResponse) {
  92   return !aRequest.GetIntegrity().IsEmpty() &&
  93          aResponse.Type() != ResponseType::Error;
  94 }
  95
  96 }  // anonymous namespace
  97
  98 //-----------------------------------------------------------------------------
  99 // AlternativeDataStreamListener
 100 //-----------------------------------------------------------------------------
 101 class AlternativeDataStreamListener final
 102     : public nsIStreamListener,
 103       public nsIThreadRetargetableStreamListener {
 104  public:
 105   NS_DECL_THREADSAFE_ISUPPORTS
 106   NS_DECL_NSIREQUESTOBSERVER
 107   NS_DECL_NSISTREAMLISTENER
 108   NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
 109
 110   // The status of AlternativeDataStreamListener
 111   // LOADING: is the initial status, loading the alternative data
 112   // COMPLETED: Alternative data loading is completed
 113   // CANCELED: Alternative data loading is canceled, this would make
 114   //           AlternativeDataStreamListener ignore all channel callbacks
 115   // FALLBACK: fallback the channel callbacks to FetchDriver
 116   // Depends on different situaions, the status transition could be followings
 117   // 1. LOADING->COMPLETED
 118   //    This is the normal status transition for alternative data loading
 119   //
 120   // 2. LOADING->CANCELED
 121   //    LOADING->COMPLETED->CANCELED
 122   //    Alternative data loading could be canceled when cacheId from alternative
 123   //    data channel does not match with from main data channel(The cacheID
 124   //    checking is in FetchDriver::OnStartRequest).
 125   //    Notice the alternative data loading could finish before the cacheID
 126   //    checking, so the statust transition could be
 127   //    LOADING->COMPLETED->CANCELED
 128   //
 129   // 3. LOADING->FALLBACK
 130   //    For the case that alternative data loading could not be initialized,
 131   //    i.e. alternative data does not exist or no preferred alternative data
 132   //    type is requested. Once the status becomes FALLBACK,
 133   //    AlternativeDataStreamListener transits the channel callback request to
 134   //    FetchDriver, and the status should not go back to LOADING, COMPLETED, or
 135   //    CANCELED anymore.
 136   enum eStatus { LOADING = 0, COMPLETED, CANCELED, FALLBACK };
 137
 138   AlternativeDataStreamListener(FetchDriver* aFetchDriver, nsIChannel* aChannel,
 139                                 const nsACString& aAlternativeDataType);
 140   eStatus Status();
 141   void Cancel();
 142   uint64_t GetAlternativeDataCacheEntryId();
 143   const nsACString& GetAlternativeDataType() const;
 144   already_AddRefed<nsICacheInfoChannel> GetCacheInfoChannel();
 145   already_AddRefed<nsIInputStream> GetAlternativeInputStream();
 146
 147  private:
 148   ~AlternativeDataStreamListener() = default;
 149
 150   // This creates a strong reference cycle with FetchDriver and its
 151   // mAltDataListener. We need to clear at least one reference of them once the
 152   // data loading finishes.
 153   RefPtr<FetchDriver> mFetchDriver;
 154   nsCString mAlternativeDataType;
 155   nsCOMPtr<nsIInputStream> mPipeAlternativeInputStream;
 156   nsCOMPtr<nsIOutputStream> mPipeAlternativeOutputStream;
 157   uint64_t mAlternativeDataCacheEntryId;
 158   nsCOMPtr<nsICacheInfoChannel> mCacheInfoChannel;
 159   nsCOMPtr<nsIChannel> mChannel;
 160   Atomic<eStatus> mStatus;
 161 };
 162
 163 NS_IMPL_ISUPPORTS(AlternativeDataStreamListener, nsIStreamListener,
 164                   nsIThreadRetargetableStreamListener)
 165
 166 AlternativeDataStreamListener::AlternativeDataStreamListener(
 167     FetchDriver* aFetchDriver, nsIChannel* aChannel,
 168     const nsACString& aAlternativeDataType)
 169     : mFetchDriver(aFetchDriver),
 170       mAlternativeDataType(aAlternativeDataType),
 171       mAlternativeDataCacheEntryId(0),
 172       mChannel(aChannel),
 173       mStatus(AlternativeDataStreamListener::LOADING) {
 174   MOZ_DIAGNOSTIC_ASSERT(mFetchDriver);
 175   MOZ_DIAGNOSTIC_ASSERT(mChannel);
 176 }
 177
 178 AlternativeDataStreamListener::eStatus AlternativeDataStreamListener::Status() {
 179   return mStatus;
 180 }
 181
 182 void AlternativeDataStreamListener::Cancel() {
 183   mAlternativeDataCacheEntryId = 0;
 184   mCacheInfoChannel = nullptr;
 185   mPipeAlternativeOutputStream = nullptr;
 186   mPipeAlternativeInputStream = nullptr;
 187   if (mChannel && mStatus != AlternativeDataStreamListener::FALLBACK) {
 188     // if mStatus is fallback, we need to keep channel to forward request back
 189     // to FetchDriver
 190     mChannel->CancelWithReason(NS_BINDING_ABORTED,
 191                                "AlternativeDataStreamListener::Cancel"_ns);
 192     mChannel = nullptr;
 193   }
 194   mStatus = AlternativeDataStreamListener::CANCELED;
 195 }
 196
 197 uint64_t AlternativeDataStreamListener::GetAlternativeDataCacheEntryId() {
 198   return mAlternativeDataCacheEntryId;
 199 }
 200
 201 const nsACString& AlternativeDataStreamListener::GetAlternativeDataType()
 202     const {
 203   return mAlternativeDataType;
 204 }
 205
 206 already_AddRefed<nsIInputStream>
 207 AlternativeDataStreamListener::GetAlternativeInputStream() {
 208   nsCOMPtr<nsIInputStream> inputStream = mPipeAlternativeInputStream;
 209   return inputStream.forget();
 210 }
 211
 212 already_AddRefed<nsICacheInfoChannel>
 213 AlternativeDataStreamListener::GetCacheInfoChannel() {
 214   nsCOMPtr<nsICacheInfoChannel> channel = mCacheInfoChannel;
 215   return channel.forget();
 216 }
 217
 218 NS_IMETHODIMP
 219 AlternativeDataStreamListener::OnStartRequest(nsIRequest* aRequest) {
 220   AssertIsOnMainThread();
 221   MOZ_ASSERT(!mAlternativeDataType.IsEmpty());
 222   // Checking the alternative data type is the same between we asked and the
 223   // saved in the channel.
 224   nsAutoCString alternativeDataType;
 225   nsCOMPtr<nsICacheInfoChannel> cic = do_QueryInterface(aRequest);
 226   mStatus = AlternativeDataStreamListener::LOADING;
 227   if (cic && NS_SUCCEEDED(cic->GetAlternativeDataType(alternativeDataType)) &&
 228       mAlternativeDataType.Equals(alternativeDataType) &&
 229       NS_SUCCEEDED(cic->GetCacheEntryId(&mAlternativeDataCacheEntryId))) {
 230     MOZ_DIAGNOSTIC_ASSERT(!mPipeAlternativeInputStream);
 231     MOZ_DIAGNOSTIC_ASSERT(!mPipeAlternativeOutputStream);
 232     NS_NewPipe(getter_AddRefs(mPipeAlternativeInputStream),
 233                getter_AddRefs(mPipeAlternativeOutputStream),
 234                0 /* default segment size */, UINT32_MAX /* infinite pipe */,
 235                true /* non-blocking input, otherwise you deadlock */,
 236                false /* blocking output, since the pipe is 'in'finite */);
 237
 238     MOZ_DIAGNOSTIC_ASSERT(!mCacheInfoChannel);
 239     mCacheInfoChannel = cic;
 240
 241     // call FetchDriver::HttpFetch to load main body
 242     MOZ_ASSERT(mFetchDriver);
 243     return mFetchDriver->HttpFetch();
 244   }
 245   // Needn't load alternative data, since alternative data does not exist.
 246   // Set status to FALLBACK to reuse the opened channel to load main body,
 247   // then call FetchDriver::OnStartRequest to continue the work. Unfortunately
 248   // can't change the stream listener to mFetchDriver, need to keep
 249   // AlternativeDataStreamListener alive to redirect OnDataAvailable and
 250   // OnStopRequest to mFetchDriver.
 251   MOZ_ASSERT(alternativeDataType.IsEmpty());
 252   mStatus = AlternativeDataStreamListener::FALLBACK;
 253   mAlternativeDataCacheEntryId = 0;
 254   MOZ_ASSERT(mFetchDriver);
 255   return mFetchDriver->OnStartRequest(aRequest);
 256 }
 257
 258 NS_IMETHODIMP
 259 AlternativeDataStreamListener::OnDataAvailable(nsIRequest* aRequest,
 260                                                nsIInputStream* aInputStream,
 261                                                uint64_t aOffset,
 262                                                uint32_t aCount) {
 263   if (mStatus == AlternativeDataStreamListener::LOADING) {
 264     MOZ_ASSERT(mPipeAlternativeOutputStream);
 265     uint32_t read = 0;
 266     return aInputStream->ReadSegments(
 267         NS_CopySegmentToStream, mPipeAlternativeOutputStream, aCount, &read);
 268   }
 269   if (mStatus == AlternativeDataStreamListener::FALLBACK) {
 270     MOZ_ASSERT(mFetchDriver);
 271     return mFetchDriver->OnDataAvailable(aRequest, aInputStream, aOffset,
 272                                          aCount);
 273   }
 274   return NS_OK;
 275 }
 276
 277 NS_IMETHODIMP
 278 AlternativeDataStreamListener::OnStopRequest(nsIRequest* aRequest,
 279                                              nsresult aStatusCode) {
 280   AssertIsOnMainThread();
 281
 282   // Alternative data loading is going to finish, breaking the reference cycle
 283   // here by taking the ownership to a loacl variable.
 284   RefPtr<FetchDriver> fetchDriver = std::move(mFetchDriver);
 285
 286   if (mStatus == AlternativeDataStreamListener::CANCELED) {
 287     // do nothing
 288     return NS_OK;
 289   }
 290
 291   if (mStatus == AlternativeDataStreamListener::FALLBACK) {
 292     MOZ_ASSERT(fetchDriver);
 293     return fetchDriver->OnStopRequest(aRequest, aStatusCode);
 294   }
 295
 296   MOZ_DIAGNOSTIC_ASSERT(mStatus == AlternativeDataStreamListener::LOADING);
 297
 298   MOZ_ASSERT(!mAlternativeDataType.IsEmpty() && mPipeAlternativeOutputStream &&
 299              mPipeAlternativeInputStream);
 300
 301   mPipeAlternativeOutputStream->Close();
 302   mPipeAlternativeOutputStream = nullptr;
 303
 304   // Cleanup the states for alternative data if needed.
 305   if (NS_FAILED(aStatusCode)) {
 306     mAlternativeDataCacheEntryId = 0;
 307     mCacheInfoChannel = nullptr;
 308     mPipeAlternativeInputStream = nullptr;
 309   }
 310   mStatus = AlternativeDataStreamListener::COMPLETED;
 311   // alternative data loading finish, call FetchDriver::FinishOnStopRequest to
 312   // continue the final step for the case FetchDriver::OnStopRequest is called
 313   // earlier than AlternativeDataStreamListener::OnStopRequest
 314   MOZ_ASSERT(fetchDriver);
 315   fetchDriver->FinishOnStopRequest(this);
 316   return NS_OK;
 317 }
 318
 319 NS_IMETHODIMP
 320 AlternativeDataStreamListener::CheckListenerChain() { return NS_OK; }
 321 //-----------------------------------------------------------------------------
 322 // FetchDriver
 323 //-----------------------------------------------------------------------------
 324
 325 NS_IMPL_ISUPPORTS(FetchDriver, nsIStreamListener, nsIChannelEventSink,
 326                   nsIInterfaceRequestor, nsIThreadRetargetableStreamListener,
 327                   nsINetworkInterceptController)
 328
 329 FetchDriver::FetchDriver(SafeRefPtr<InternalRequest> aRequest,
 330                          nsIPrincipal* aPrincipal, nsILoadGroup* aLoadGroup,
 331                          nsIEventTarget* aMainThreadEventTarget,
 332                          nsICookieJarSettings* aCookieJarSettings,
 333                          PerformanceStorage* aPerformanceStorage,
 334                          bool aIsTrackingFetch)
 335     : mPrincipal(aPrincipal),
 336       mLoadGroup(aLoadGroup),
 337       mRequest(std::move(aRequest)),
 338       mMainThreadEventTarget(aMainThreadEventTarget),
 339       mCookieJarSettings(aCookieJarSettings),
 340       mPerformanceStorage(aPerformanceStorage),
 341       mNeedToObserveOnDataAvailable(false),
 342       mIsTrackingFetch(aIsTrackingFetch),
 343       mOnStopRequestCalled(false)
 344 #ifdef DEBUG
 345       ,
 346       mResponseAvailableCalled(false),
 347       mFetchCalled(false)
 348 #endif
 349 {
 350   AssertIsOnMainThread();
 351
 352   MOZ_ASSERT(mRequest);
 353   MOZ_ASSERT(aPrincipal);
 354   MOZ_ASSERT(aMainThreadEventTarget);
 355 }
 356
 357 FetchDriver::~FetchDriver() {
 358   AssertIsOnMainThread();
 359
 360   // We assert this since even on failures, we should call
 361   // FailWithNetworkError().
 362   MOZ_ASSERT(mResponseAvailableCalled);
 363 }
 364
 365 already_AddRefed<PreloaderBase> FetchDriver::FindPreload(nsIURI* aURI) {
 366   // Decide if we allow reuse of an existing <link rel=preload as=fetch>
 367   // response for this request.  First examine this fetch requets itself if it
 368   // is 'pure' enough to use the response and then try to find a preload.
 369
 370   if (!mDocument) {
 371     // Preloads are mapped on the document, no document, no preload.
 372     return nullptr;
 373   }
 374   CORSMode cors;
 375   switch (mRequest->Mode()) {
 376     case RequestMode::No_cors:
 377       cors = CORSMode::CORS_NONE;
 378       break;
 379     case RequestMode::Cors:
 380       cors = mRequest->GetCredentialsMode() == RequestCredentials::Include
 381                  ? CORSMode::CORS_USE_CREDENTIALS
 382                  : CORSMode::CORS_ANONYMOUS;
 383       break;
 384     default:
 385       // Can't be satisfied by a preload because preload cannot define any of
 386       // remaining modes.
 387       return nullptr;
 388   }
 389   if (!mRequest->Headers()->HasOnlySimpleHeaders()) {
 390     // Preload can't set any headers.
 391     return nullptr;
 392   }
 393   if (!mRequest->GetIntegrity().IsEmpty()) {
 394     // There is currently no support for SRI checking in the fetch preloader.
 395     return nullptr;
 396   }
 397   if (mRequest->GetCacheMode() != RequestCache::Default) {
 398     // Preload can only go with the default caching mode.
 399     return nullptr;
 400   }
 401   if (mRequest->SkipServiceWorker()) {
 402     // Preload can't be forbidden interception.
 403     return nullptr;
 404   }
 405   if (mRequest->GetRedirectMode() != RequestRedirect::Follow) {
 406     // Preload always follows redirects.
 407     return nullptr;
 408   }
 409   nsAutoCString method;
 410   mRequest->GetMethod(method);
 411   if (!method.EqualsLiteral("GET")) {
 412     // Preload can only do GET, this also eliminates the case we do upload, so
 413     // no need to check if the request has any body to send out.
 414     return nullptr;
 415   }
 416
 417   // OK, this request can be satisfied by a preloaded response, try to find one.
 418
 419   auto preloadKey = PreloadHashKey::CreateAsFetch(aURI, cors);
 420   return mDocument->Preloads().LookupPreload(preloadKey);
 421 }
 422
 423 void FetchDriver::UpdateReferrerInfoFromNewChannel(nsIChannel* aChannel) {
 424   nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel);
 425   if (!httpChannel) {
 426     return;
 427   }
 428
 429   nsCOMPtr<nsIReferrerInfo> referrerInfo = httpChannel->GetReferrerInfo();
 430   if (!referrerInfo) {
 431     return;
 432   }
 433
 434   nsAutoString computedReferrerSpec;
 435   mRequest->SetReferrerPolicy(referrerInfo->ReferrerPolicy());
 436   Unused << referrerInfo->GetComputedReferrerSpec(computedReferrerSpec);
 437   mRequest->SetReferrer(computedReferrerSpec);
 438 }
 439
 440 nsresult FetchDriver::Fetch(AbortSignalImpl* aSignalImpl,
 441                             FetchDriverObserver* aObserver) {
 442   AssertIsOnMainThread();
 443 #ifdef DEBUG
 444   MOZ_ASSERT(!mFetchCalled);
 445   mFetchCalled = true;
 446 #endif
 447
 448   mObserver = aObserver;
 449
 450   // FIXME(nsm): Deal with HSTS.
 451
 452   MOZ_RELEASE_ASSERT(!mRequest->IsSynchronous(),
 453                      "Synchronous fetch not supported");
 454
 455   UniquePtr<mozilla::ipc::PrincipalInfo> principalInfo(
 456       new mozilla::ipc::PrincipalInfo());
 457   nsresult rv = PrincipalToPrincipalInfo(mPrincipal, principalInfo.get());
 458   if (NS_WARN_IF(NS_FAILED(rv))) {
 459     return rv;
 460   }
 461
 462   mRequest->SetPrincipalInfo(std::move(principalInfo));
 463
 464   // If the signal is aborted, it's time to inform the observer and terminate
 465   // the operation.
 466   if (aSignalImpl) {
 467     if (aSignalImpl->Aborted()) {
 468       FetchDriverAbortActions(aSignalImpl);
 469       return NS_OK;
 470     }
 471
 472     Follow(aSignalImpl);
 473   }
 474
 475   rv = HttpFetch(mRequest->GetPreferredAlternativeDataType());
 476   if (NS_FAILED(rv)) {
 477     FailWithNetworkError(rv);
 478   }
 479
 480   // Any failure is handled by FailWithNetworkError notifying the aObserver.
 481   return NS_OK;
 482 }
 483
 484 // This function implements the "HTTP Fetch" algorithm from the Fetch spec.
 485 // Functionality is often split between here, the CORS listener proxy and the
 486 // Necko HTTP implementation.
 487 nsresult FetchDriver::HttpFetch(
 488     const nsACString& aPreferredAlternativeDataType) {
 489   MOZ_ASSERT(NS_IsMainThread());
 490
 491   // Step 1. "Let response be null."
 492   mResponse = nullptr;
 493   mOnStopRequestCalled = false;
 494   nsresult rv;
 495
 496   nsCOMPtr<nsIIOService> ios = do_GetIOService(&rv);
 497   NS_ENSURE_SUCCESS(rv, rv);
 498
 499   nsAutoCString url;
 500   mRequest->GetURL(url);
 501   nsCOMPtr<nsIURI> uri;
 502   rv = NS_NewURI(getter_AddRefs(uri), url);
 503   NS_ENSURE_SUCCESS(rv, rv);
 504
 505   // Unsafe requests aren't allowed with when using no-core mode.
 506   if (mRequest->Mode() == RequestMode::No_cors && mRequest->UnsafeRequest() &&
 507       (!mRequest->HasSimpleMethod() ||
 508        !mRequest->Headers()->HasOnlySimpleHeaders())) {
 509     MOZ_ASSERT(false, "The API should have caught this");
 510     return NS_ERROR_DOM_BAD_URI;
 511   }
 512
 513   // non-GET requests aren't allowed for blob.
 514   if (IsBlobURI(uri)) {
 515     nsAutoCString method;
 516     mRequest->GetMethod(method);
 517     if (!method.EqualsLiteral("GET")) {
 518       return NS_ERROR_DOM_NETWORK_ERR;
 519     }
 520   }
 521
 522   RefPtr<PreloaderBase> fetchPreload = FindPreload(uri);
 523   if (fetchPreload) {
 524     fetchPreload->RemoveSelf(mDocument);
 525     fetchPreload->NotifyUsage(mDocument, PreloaderBase::LoadBackground::Keep);
 526
 527     rv = fetchPreload->AsyncConsume(this);
 528     if (NS_SUCCEEDED(rv)) {
 529       mFromPreload = true;
 530
 531       mChannel = fetchPreload->Channel();
 532       MOZ_ASSERT(mChannel);
 533       mChannel->SetNotificationCallbacks(this);
 534
 535       // Copied from AsyncOnChannelRedirect.
 536       for (const auto& redirect : fetchPreload->Redirects()) {
 537         if (redirect.Flags() & nsIChannelEventSink::REDIRECT_INTERNAL) {
 538           mRequest->SetURLForInternalRedirect(redirect.Flags(), redirect.Spec(),
 539                                               redirect.Fragment());
 540         } else {
 541           mRequest->AddURL(redirect.Spec(), redirect.Fragment());
 542         }
 543       }
 544
 545       return NS_OK;
 546     }
 547
 548     // The preload failed to be consumed.  Behave like there were no preload.
 549     fetchPreload = nullptr;
 550   }
 551
 552   // Step 2 deals with letting ServiceWorkers intercept requests. This is
 553   // handled by Necko after the channel is opened.
 554   // FIXME(nsm): Bug 1119026: The channel's skip service worker flag should be
 555   // set based on the Request's flag.
 556
 557   // Step 3.1 "If the CORS preflight flag is set and one of these conditions is
 558   // true..." is handled by the CORS proxy.
 559   //
 560   // Step 3.2 "Set request's skip service worker flag." This isn't required
 561   // since Necko will fall back to the network if the ServiceWorker does not
 562   // respond with a valid Response.
 563   //
 564   // NS_StartCORSPreflight() will automatically kick off the original request
 565   // if it succeeds, so we need to have everything setup for the original
 566   // request too.
 567
 568   // Step 3.3 "Let credentials flag be set if one of
 569   //  - request's credentials mode is "include"
 570   //  - request's credentials mode is "same-origin" and either the CORS flag
 571   //    is unset or response tainting is "opaque"
 572   // is true, and unset otherwise."
 573
 574   // Set skip serviceworker flag.
 575   // While the spec also gates on the client being a ServiceWorker, we can't
 576   // infer that here. Instead we rely on callers to set the flag correctly.
 577   const nsLoadFlags bypassFlag = mRequest->SkipServiceWorker()
 578                                      ? nsIChannel::LOAD_BYPASS_SERVICE_WORKER
 579                                      : 0;
 580
 581   nsSecurityFlags secFlags = 0;
 582   if (mRequest->Mode() == RequestMode::Cors) {
 583     secFlags |= nsILoadInfo::SEC_REQUIRE_CORS_INHERITS_SEC_CONTEXT;
 584   } else if (mRequest->Mode() == RequestMode::Same_origin ||
 585              mRequest->Mode() == RequestMode::Navigate) {
 586     secFlags |= nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_INHERITS_SEC_CONTEXT;
 587   } else if (mRequest->Mode() == RequestMode::No_cors) {
 588     secFlags |= nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT;
 589   } else {
 590     MOZ_ASSERT_UNREACHABLE("Unexpected request mode!");
 591     return NS_ERROR_UNEXPECTED;
 592   }
 593
 594   if (mRequest->GetRedirectMode() != RequestRedirect::Follow) {
 595     secFlags |= nsILoadInfo::SEC_DONT_FOLLOW_REDIRECTS;
 596   }
 597
 598   // This handles the use credentials flag in "HTTP
 599   // network or cache fetch" in the spec and decides whether to transmit
 600   // cookies and other identifying information.
 601   if (mRequest->GetCredentialsMode() == RequestCredentials::Include) {
 602     secFlags |= nsILoadInfo::SEC_COOKIES_INCLUDE;
 603   } else if (mRequest->GetCredentialsMode() == RequestCredentials::Omit) {
 604     secFlags |= nsILoadInfo::SEC_COOKIES_OMIT;
 605   } else if (mRequest->GetCredentialsMode() ==
 606              RequestCredentials::Same_origin) {
 607     secFlags |= nsILoadInfo::SEC_COOKIES_SAME_ORIGIN;
 608   } else {
 609     MOZ_ASSERT_UNREACHABLE("Unexpected credentials mode!");
 610     return NS_ERROR_UNEXPECTED;
 611   }
 612
 613   // From here on we create a channel and set its properties with the
 614   // information from the InternalRequest. This is an implementation detail.
 615   MOZ_ASSERT(mLoadGroup);
 616   nsCOMPtr<nsIChannel> chan;
 617
 618   nsLoadFlags loadFlags = nsIRequest::LOAD_BACKGROUND | bypassFlag;
 619   if (mDocument) {
 620     MOZ_ASSERT(mDocument->NodePrincipal() == mPrincipal);
 621     MOZ_ASSERT(mDocument->CookieJarSettings() == mCookieJarSettings);
 622     rv = NS_NewChannel(getter_AddRefs(chan), uri, mDocument, secFlags,
 623                        mRequest->ContentPolicyType(),
 624                        nullptr,             /* aPerformanceStorage */
 625                        mLoadGroup, nullptr, /* aCallbacks */
 626                        loadFlags, ios);
 627   } else if (mClientInfo.isSome()) {
 628     rv = NS_NewChannel(getter_AddRefs(chan), uri, mPrincipal, mClientInfo.ref(),
 629                        mController, secFlags, mRequest->ContentPolicyType(),
 630                        mCookieJarSettings, mPerformanceStorage, mLoadGroup,
 631                        nullptr, /* aCallbacks */
 632                        loadFlags, ios);
 633   } else {
 634     rv =
 635         NS_NewChannel(getter_AddRefs(chan), uri, mPrincipal, secFlags,
 636                       mRequest->ContentPolicyType(), mCookieJarSettings,
 637                       mPerformanceStorage, mLoadGroup, nullptr, /* aCallbacks */
 638                       loadFlags, ios);
 639   }
 640   NS_ENSURE_SUCCESS(rv, rv);
 641
 642   if (mCSPEventListener) {
 643     nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
 644     rv = loadInfo->SetCspEventListener(mCSPEventListener);
 645     NS_ENSURE_SUCCESS(rv, rv);
 646   }
 647
 648   {
 649     nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
 650     rv = loadInfo->SetLoadingEmbedderPolicy(mRequest->GetEmbedderPolicy());
 651     NS_ENSURE_SUCCESS(rv, rv);
 652   }
 653
 654   if (mAssociatedBrowsingContextID) {
 655     nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
 656     rv = loadInfo->SetWorkerAssociatedBrowsingContextID(
 657         mAssociatedBrowsingContextID);
 658   }
 659
 660   // If the fetch is created by FetchEvent.request or NavigationPreload request,
 661   // corresponding InterceptedHttpChannel information need to propagte to the
 662   // channel of the fetch.
 663   if (mRequest->GetInterceptionTriggeringPrincipalInfo()) {
 664     auto principalOrErr = mozilla::ipc::PrincipalInfoToPrincipal(
 665         *(mRequest->GetInterceptionTriggeringPrincipalInfo().get()));
 666     if (!principalOrErr.isErr()) {
 667       nsCOMPtr<nsIPrincipal> principal = principalOrErr.unwrap();
 668
 669       nsTArray<nsCOMPtr<nsIRedirectHistoryEntry>> redirectChain;
 670       if (!mRequest->InterceptionRedirectChain().IsEmpty()) {
 671         for (const RedirectHistoryEntryInfo& entryInfo :
 672              mRequest->InterceptionRedirectChain()) {
 673           nsCOMPtr<nsIRedirectHistoryEntry> entry =
 674               mozilla::ipc::RHEntryInfoToRHEntry(entryInfo);
 675           redirectChain.AppendElement(entry);
 676         }
 677       }
 678
 679       nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
 680       MOZ_ASSERT(loadInfo);
 681       loadInfo->SetInterceptionInfo(new mozilla::net::InterceptionInfo(
 682           principal, mRequest->InterceptionContentPolicyType(), redirectChain,
 683           mRequest->InterceptionFromThirdParty()));
 684     }
 685   }
 686
 687   if (mDocument && mDocument->GetEmbedderElement() &&
 688       mDocument->GetEmbedderElement()->IsAnyOfHTMLElements(nsGkAtoms::object,
 689                                                            nsGkAtoms::embed)) {
 690     nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
 691     rv = loadInfo->SetIsFromObjectOrEmbed(true);
 692     NS_ENSURE_SUCCESS(rv, rv);
 693   }
 694
 695   // Insert ourselves into the notification callbacks chain so we can set
 696   // headers on redirects.
 697 #ifdef DEBUG
 698   {
 699     nsCOMPtr<nsIInterfaceRequestor> notificationCallbacks;
 700     chan->GetNotificationCallbacks(getter_AddRefs(notificationCallbacks));
 701     MOZ_ASSERT(!notificationCallbacks);
 702   }
 703 #endif
 704   chan->SetNotificationCallbacks(this);
 705
 706   nsCOMPtr<nsIClassOfService> cos(do_QueryInterface(chan));
 707   // Mark channel as urgent-start if the Fetch is triggered by user input
 708   // events.
 709   if (cos && UserActivation::IsHandlingUserInput()) {
 710     cos->AddClassFlags(nsIClassOfService::UrgentStart);
 711   }
 712
 713   // Step 3.5 begins "HTTP network or cache fetch".
 714   // HTTP network or cache fetch
 715   // ---------------------------
 716   // Step 1 "Let HTTPRequest..." The channel is the HTTPRequest.
 717   nsCOMPtr<nsIHttpChannel> httpChan = do_QueryInterface(chan);
 718   if (httpChan) {
 719     // Copy the method.
 720     nsAutoCString method;
 721     mRequest->GetMethod(method);
 722     rv = httpChan->SetRequestMethod(method);
 723     NS_ENSURE_SUCCESS(rv, rv);
 724
 725     // Set the same headers.
 726     SetRequestHeaders(httpChan, false, false);
 727
 728     // Step 5 of https://fetch.spec.whatwg.org/#main-fetch
 729     // If request's referrer policy is the empty string and request's client is
 730     // non-null, then set request's referrer policy to request's client's
 731     // associated referrer policy.
 732     // Basically, "client" is not in our implementation, we use
 733     // EnvironmentReferrerPolicy of the worker or document context
 734     ReferrerPolicy referrerPolicy = mRequest->GetEnvironmentReferrerPolicy();
 735     if (mRequest->ReferrerPolicy_() == ReferrerPolicy::_empty) {
 736       mRequest->SetReferrerPolicy(referrerPolicy);
 737     }
 738     // Step 6 of https://fetch.spec.whatwg.org/#main-fetch
 739     // If request’s referrer policy is the empty string,
 740     // then set request’s referrer policy to the user-set default policy.
 741     if (mRequest->ReferrerPolicy_() == ReferrerPolicy::_empty) {
 742       nsCOMPtr<nsILoadInfo> loadInfo = httpChan->LoadInfo();
 743       bool isPrivate = loadInfo->GetOriginAttributes().mPrivateBrowsingId > 0;
 744       referrerPolicy =
 745           ReferrerInfo::GetDefaultReferrerPolicy(httpChan, uri, isPrivate);
 746       mRequest->SetReferrerPolicy(referrerPolicy);
 747     }
 748
 749     rv = FetchUtil::SetRequestReferrer(mPrincipal, mDocument, httpChan,
 750                                        *mRequest);
 751     NS_ENSURE_SUCCESS(rv, rv);
 752
 753     // Bug 1120722 - Authorization will be handled later.
 754     // Auth may require prompting, we don't support it yet.
 755     // The next patch in this same bug prevents this from aborting the request.
 756     // Credentials checks for CORS are handled by nsCORSListenerProxy,
 757
 758     nsCOMPtr<nsIHttpChannelInternal> internalChan = do_QueryInterface(httpChan);
 759
 760     rv = internalChan->SetRequestMode(mRequest->Mode());
 761     MOZ_ASSERT(NS_SUCCEEDED(rv));
 762     // Conversion between enumerations is safe due to static asserts in
 763     // dom/workers/ServiceWorkerManager.cpp
 764     rv = internalChan->SetRedirectMode(
 765         static_cast<uint32_t>(mRequest->GetRedirectMode()));
 766     MOZ_ASSERT(NS_SUCCEEDED(rv));
 767     mRequest->MaybeSkipCacheIfPerformingRevalidation();
 768     rv = internalChan->SetFetchCacheMode(
 769         static_cast<uint32_t>(mRequest->GetCacheMode()));
 770     MOZ_ASSERT(NS_SUCCEEDED(rv));
 771     rv = internalChan->SetIntegrityMetadata(mRequest->GetIntegrity());
 772     MOZ_ASSERT(NS_SUCCEEDED(rv));
 773
 774     // Set the initiator type
 775     nsCOMPtr<nsITimedChannel> timedChannel(do_QueryInterface(httpChan));
 776     if (timedChannel) {
 777       timedChannel->SetInitiatorType(u"fetch"_ns);
 778     }
 779   }
 780
 781   // Step 5. Proxy authentication will be handled by Necko.
 782
 783   // Continue setting up 'HTTPRequest'. Content-Type and body data.
 784   nsCOMPtr<nsIUploadChannel2> uploadChan = do_QueryInterface(chan);
 785   if (uploadChan) {
 786     nsAutoCString contentType;
 787     ErrorResult result;
 788     mRequest->Headers()->GetFirst("content-type"_ns, contentType, result);
 789     // We don't actually expect "result" to have failed here: that only happens
 790     // for invalid header names.  But if for some reason it did, just propagate
 791     // it out.
 792     if (result.Failed()) {
 793       return result.StealNSResult();
 794     }
 795
 796     // Now contentType is the header that was set in mRequest->Headers(), or a
 797     // void string if no header was set.
 798 #ifdef DEBUG
 799     bool hasContentTypeHeader =
 800         mRequest->Headers()->Has("content-type"_ns, result);
 801     MOZ_ASSERT(!result.Failed());
 802     MOZ_ASSERT_IF(!hasContentTypeHeader, contentType.IsVoid());
 803 #endif  // DEBUG
 804
 805     int64_t bodyLength;
 806     nsCOMPtr<nsIInputStream> bodyStream;
 807     mRequest->GetBody(getter_AddRefs(bodyStream), &bodyLength);
 808     if (bodyStream) {
 809       nsAutoCString method;
 810       mRequest->GetMethod(method);
 811       rv = uploadChan->ExplicitSetUploadStream(bodyStream, contentType,
 812                                                bodyLength, method,
 813                                                false /* aStreamHasHeaders */);
 814       NS_ENSURE_SUCCESS(rv, rv);
 815     }
 816   }
 817
 818   // If preflight is required, start a "CORS preflight fetch"
 819   // https://fetch.spec.whatwg.org/#cors-preflight-fetch-0. All the
 820   // implementation is handled by the http channel calling into
 821   // nsCORSListenerProxy. We just inform it which unsafe headers are included
 822   // in the request.
 823   if (mRequest->Mode() == RequestMode::Cors) {
 824     AutoTArray<nsCString, 5> unsafeHeaders;
 825     mRequest->Headers()->GetUnsafeHeaders(unsafeHeaders);
 826     nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
 827     loadInfo->SetCorsPreflightInfo(unsafeHeaders, false);
 828   }
 829
 830   if (mIsTrackingFetch && StaticPrefs::network_http_tailing_enabled() && cos) {
 831     cos->AddClassFlags(nsIClassOfService::Throttleable |
 832                        nsIClassOfService::Tail);
 833   }
 834
 835   if (mIsTrackingFetch &&
 836       StaticPrefs::privacy_trackingprotection_lower_network_priority()) {
 837     nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(chan);
 838     if (p) {
 839       p->SetPriority(nsISupportsPriority::PRIORITY_LOWEST);
 840     }
 841   }
 842
 843   NotifyNetworkMonitorAlternateStack(chan, std::move(mOriginStack));
 844   if (mObserver && httpChan) {
 845     mObserver->OnNotifyNetworkMonitorAlternateStack(httpChan->ChannelId());
 846   }
 847
 848   // Should set a Content-Range header for blob scheme, and also slice the
 849   // blob appropriately, so we process the Range header here for later use.
 850   if (IsBlobURI(uri)) {
 851     ErrorResult result;
 852     nsAutoCString range;
 853     mRequest->Headers()->Get("Range"_ns, range, result);
 854     MOZ_ASSERT(!result.Failed());
 855     if (!range.IsVoid()) {
 856       rv = NS_SetChannelContentRangeForBlobURI(chan, uri, range);
 857       if (NS_FAILED(rv)) {
 858         return rv;
 859       }
 860     }
 861   }
 862
 863   // if the preferred alternative data type in InternalRequest is not empty, set
 864   // the data type on the created channel and also create a
 865   // AlternativeDataStreamListener to be the stream listener of the channel.
 866   if (!aPreferredAlternativeDataType.IsEmpty()) {
 867     nsCOMPtr<nsICacheInfoChannel> cic = do_QueryInterface(chan);
 868     if (cic) {
 869       cic->PreferAlternativeDataType(
 870           aPreferredAlternativeDataType, ""_ns,
 871           nsICacheInfoChannel::PreferredAlternativeDataDeliveryType::ASYNC);
 872       MOZ_ASSERT(!mAltDataListener);
 873       mAltDataListener = new AlternativeDataStreamListener(
 874           this, chan, aPreferredAlternativeDataType);
 875       rv = chan->AsyncOpen(mAltDataListener);
 876     } else {
 877       rv = chan->AsyncOpen(this);
 878     }
 879   } else {
 880     // Integrity check cannot be done on alt-data yet.
 881     if (mRequest->GetIntegrity().IsEmpty()) {
 882       MOZ_ASSERT(!FetchUtil::WasmAltDataType.IsEmpty());
 883       nsCOMPtr<nsICacheInfoChannel> cic = do_QueryInterface(chan);
 884       if (cic && StaticPrefs::javascript_options_wasm_caching() &&
 885           !mRequest->SkipWasmCaching()) {
 886         cic->PreferAlternativeDataType(
 887             FetchUtil::WasmAltDataType, nsLiteralCString(WASM_CONTENT_TYPE),
 888             nsICacheInfoChannel::PreferredAlternativeDataDeliveryType::
 889                 SERIALIZE);
 890       }
 891     }
 892
 893     rv = chan->AsyncOpen(this);
 894   }
 895
 896   if (NS_FAILED(rv)) {
 897     return rv;
 898   }
 899
 900   // Step 4 onwards of "HTTP Fetch" is handled internally by Necko.
 901
 902   mChannel = chan;
 903   return NS_OK;
 904 }
 905
 906 SafeRefPtr<InternalResponse> FetchDriver::BeginAndGetFilteredResponse(
 907     SafeRefPtr<InternalResponse> aResponse, bool aFoundOpaqueRedirect) {
 908   MOZ_ASSERT(aResponse);
 909   AutoTArray<nsCString, 4> reqURLList;
 910   mRequest->GetURLListWithoutFragment(reqURLList);
 911   MOZ_ASSERT(!reqURLList.IsEmpty());
 912   aResponse->SetURLList(reqURLList);
 913   SafeRefPtr<InternalResponse> filteredResponse;
 914   if (aFoundOpaqueRedirect) {
 915     filteredResponse = aResponse->OpaqueRedirectResponse();
 916   } else {
 917     switch (mRequest->GetResponseTainting()) {
 918       case LoadTainting::Basic:
 919         filteredResponse = aResponse->BasicResponse();
 920         break;
 921       case LoadTainting::CORS:
 922         filteredResponse = aResponse->CORSResponse();
 923         break;
 924       case LoadTainting::Opaque: {
 925         filteredResponse = aResponse->OpaqueResponse();
 926         nsresult rv = filteredResponse->GeneratePaddingInfo();
 927         if (NS_WARN_IF(NS_FAILED(rv))) {
 928           return nullptr;
 929         }
 930         break;
 931       }
 932       default:
 933         MOZ_CRASH("Unexpected case");
 934     }
 935   }
 936
 937   MOZ_ASSERT(filteredResponse);
 938   MOZ_ASSERT(mObserver);
 939   MOZ_ASSERT(filteredResponse);
 940   if (!ShouldCheckSRI(*mRequest, *filteredResponse)) {
 941     // Need to keep mObserver alive.
 942     RefPtr<FetchDriverObserver> observer = mObserver;
 943     observer->OnResponseAvailable(filteredResponse.clonePtr());
 944 #ifdef DEBUG
 945     mResponseAvailableCalled = true;
 946 #endif
 947   }
 948
 949   return filteredResponse;
 950 }
 951
 952 void FetchDriver::FailWithNetworkError(nsresult rv) {
 953   AssertIsOnMainThread();
 954   if (mObserver) {
 955     // Need to keep mObserver alive.
 956     RefPtr<FetchDriverObserver> observer = mObserver;
 957     observer->OnResponseAvailable(InternalResponse::NetworkError(rv));
 958 #ifdef DEBUG
 959     mResponseAvailableCalled = true;
 960 #endif
 961   }
 962
 963   // mObserver could be null after OnResponseAvailable().
 964   if (mObserver) {
 965     mObserver->OnResponseEnd(FetchDriverObserver::eByNetworking,
 966                              JS::UndefinedHandleValue);
 967     mObserver = nullptr;
 968   }
 969
 970   mChannel = nullptr;
 971   Unfollow();
 972 }
 973
 974 NS_IMETHODIMP
 975 FetchDriver::OnStartRequest(nsIRequest* aRequest) {
 976   AssertIsOnMainThread();
 977
 978   // Note, this can be called multiple times if we are doing an opaqueredirect.
 979   // In that case we will get a simulated OnStartRequest() and then the real
 980   // channel will call in with an errored OnStartRequest().
 981
 982   if (mFromPreload && mAborted) {
 983     aRequest->CancelWithReason(NS_BINDING_ABORTED,
 984                                "FetchDriver::OnStartRequest aborted"_ns);
 985     return NS_BINDING_ABORTED;
 986   }
 987
 988   if (!mChannel) {
 989     MOZ_ASSERT(!mObserver);
 990     return NS_BINDING_ABORTED;
 991   }
 992
 993   nsresult rv;
 994   aRequest->GetStatus(&rv);
 995   if (NS_FAILED(rv)) {
 996     FailWithNetworkError(rv);
 997     return rv;
 998   }
 999
1000   // We should only get to the following code once.
1001   MOZ_ASSERT(!mPipeOutputStream);
1002
1003   if (!mObserver) {
1004     MOZ_ASSERT(false, "We should have mObserver here.");
1005     FailWithNetworkError(NS_ERROR_UNEXPECTED);
1006     return NS_ERROR_UNEXPECTED;
1007   }
1008
1009   mNeedToObserveOnDataAvailable = mObserver->NeedOnDataAvailable();
1010
1011   SafeRefPtr<InternalResponse> response;
1012   nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
1013   nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest);
1014
1015   // On a successful redirect we perform the following substeps of HTTP Fetch,
1016   // step 5, "redirect status", step 11.
1017
1018   bool foundOpaqueRedirect = false;
1019
1020   nsAutoCString contentType;
1021
1022   int64_t contentLength = InternalResponse::UNKNOWN_BODY_SIZE;
1023   rv = channel->GetContentLength(&contentLength);
1024   MOZ_ASSERT_IF(NS_FAILED(rv),
1025                 contentLength == InternalResponse::UNKNOWN_BODY_SIZE);
1026
1027   if (httpChannel) {
1028     channel->GetContentType(contentType);
1029
1030     uint32_t responseStatus = 0;
1031     rv = httpChannel->GetResponseStatus(&responseStatus);
1032     if (NS_FAILED(rv)) {
1033       FailWithNetworkError(rv);
1034       return rv;
1035     }
1036
1037     if (mozilla::net::nsHttpChannel::IsRedirectStatus(responseStatus)) {
1038       if (mRequest->GetRedirectMode() == RequestRedirect::Error) {
1039         FailWithNetworkError(NS_BINDING_ABORTED);
1040         return NS_BINDING_FAILED;
1041       }
1042       if (mRequest->GetRedirectMode() == RequestRedirect::Manual) {
1043         foundOpaqueRedirect = true;
1044       }
1045     }
1046
1047     nsAutoCString statusText;
1048     rv = httpChannel->GetResponseStatusText(statusText);
1049     MOZ_ASSERT(NS_SUCCEEDED(rv));
1050
1051     response = MakeSafeRefPtr<InternalResponse>(responseStatus, statusText,
1052                                                 mRequest->GetCredentialsMode());
1053
1054     UniquePtr<mozilla::ipc::PrincipalInfo> principalInfo(
1055         new mozilla::ipc::PrincipalInfo());
1056     nsresult rv = PrincipalToPrincipalInfo(mPrincipal, principalInfo.get());
1057     if (NS_WARN_IF(NS_FAILED(rv))) {
1058       return rv;
1059     }
1060
1061     response->SetPrincipalInfo(std::move(principalInfo));
1062
1063     response->Headers()->FillResponseHeaders(httpChannel);
1064
1065     // If Content-Encoding or Transfer-Encoding headers are set, then the actual
1066     // Content-Length (which refer to the decoded data) is obscured behind the
1067     // encodings.
1068     ErrorResult result;
1069     if (response->Headers()->Has("content-encoding"_ns, result) ||
1070         response->Headers()->Has("transfer-encoding"_ns, result)) {
1071       // We cannot trust the content-length when content-encoding or
1072       // transfer-encoding are set.  There are many servers which just
1073       // get this wrong.
1074       contentLength = InternalResponse::UNKNOWN_BODY_SIZE;
1075     }
1076     MOZ_ASSERT(!result.Failed());
1077   } else {
1078     // Should set a Content-Range header for blob scheme
1079     // (https://fetch.spec.whatwg.org/#scheme-fetch)
1080     nsAutoCString contentRange(VoidCString());
1081     nsCOMPtr<nsIURI> uri;
1082     channel->GetURI(getter_AddRefs(uri));
1083     if (IsBlobURI(uri)) {
1084       nsBaseChannel* bchan = static_cast<nsBaseChannel*>(channel.get());
1085       MOZ_ASSERT(bchan);
1086       Maybe<nsBaseChannel::ContentRange> range = bchan->GetContentRange();
1087       if (range.isSome()) {
1088         range->AsHeader(contentRange);
1089       }
1090     }
1091
1092     response = MakeSafeRefPtr<InternalResponse>(
1093         contentRange.IsVoid() ? 200 : 206,
1094         contentRange.IsVoid() ? "OK"_ns : "Partial Content"_ns,
1095         mRequest->GetCredentialsMode());
1096
1097     IgnoredErrorResult result;
1098     if (!contentRange.IsVoid()) {
1099       response->Headers()->Append("Content-Range"_ns, contentRange, result);
1100       MOZ_ASSERT(!result.Failed());
1101     }
1102
1103     if (uri && uri->SchemeIs("data")) {
1104       nsDataChannel* dchan = static_cast<nsDataChannel*>(channel.get());
1105       MOZ_ASSERT(dchan);
1106       contentType.Assign(dchan->MimeType());
1107     } else {
1108       channel->GetContentType(contentType);
1109       if (!contentType.IsEmpty()) {
1110         nsAutoCString contentCharset;
1111         channel->GetContentCharset(contentCharset);
1112         if (NS_SUCCEEDED(rv) && !contentCharset.IsEmpty()) {
1113           contentType += ";charset="_ns + contentCharset;
1114         }
1115       }
1116     }
1117
1118     response->Headers()->Append("Content-Type"_ns, contentType, result);
1119     MOZ_ASSERT(!result.Failed());
1120
1121     if (contentLength >= 0) {
1122       nsAutoCString contentLenStr;
1123       contentLenStr.AppendInt(contentLength);
1124
1125       IgnoredErrorResult result;
1126       response->Headers()->Append("Content-Length"_ns, contentLenStr, result);
1127       MOZ_ASSERT(!result.Failed());
1128     }
1129   }
1130
1131   nsCOMPtr<nsICacheInfoChannel> cic = do_QueryInterface(aRequest);
1132   if (cic) {
1133     if (mAltDataListener) {
1134       // Skip the case that mAltDataListener->Status() equals to FALLBACK, that
1135       // means the opened channel for alternative data loading is reused for
1136       // loading the main data.
1137       if (mAltDataListener->Status() !=
1138           AlternativeDataStreamListener::FALLBACK) {
1139         // Verify the cache ID is the same with from alternative data cache.
1140         // If the cache ID is different, droping the alternative data loading,
1141         // otherwise setup the response's alternative body and cacheInfoChannel.
1142         uint64_t cacheEntryId = 0;
1143         if (NS_SUCCEEDED(cic->GetCacheEntryId(&cacheEntryId)) &&
1144             cacheEntryId !=
1145                 mAltDataListener->GetAlternativeDataCacheEntryId()) {
1146           mAltDataListener->Cancel();
1147         } else {
1148           // AlternativeDataStreamListener::OnStartRequest had already been
1149           // called, the alternative data input stream and cacheInfo channel
1150           // must be created.
1151           nsCOMPtr<nsICacheInfoChannel> cacheInfo =
1152               mAltDataListener->GetCacheInfoChannel();
1153           nsCOMPtr<nsIInputStream> altInputStream =
1154               mAltDataListener->GetAlternativeInputStream();
1155           MOZ_ASSERT(altInputStream && cacheInfo);
1156           response->SetAlternativeBody(altInputStream);
1157           nsMainThreadPtrHandle<nsICacheInfoChannel> handle(
1158               new nsMainThreadPtrHolder<nsICacheInfoChannel>(
1159                   "nsICacheInfoChannel", cacheInfo, false));
1160           response->SetCacheInfoChannel(handle);
1161         }
1162       } else if (!mAltDataListener->GetAlternativeDataType().IsEmpty()) {
1163         // If the status is FALLBACK and the
1164         // mAltDataListener::mAlternativeDataType is not empty, that means the
1165         // data need to be saved into cache, setup the response's
1166         // nsICacheInfoChannel for caching the data after loading.
1167         nsMainThreadPtrHandle<nsICacheInfoChannel> handle(
1168             new nsMainThreadPtrHolder<nsICacheInfoChannel>(
1169                 "nsICacheInfoChannel", cic, false));
1170         response->SetCacheInfoChannel(handle);
1171       }
1172     } else if (!cic->PreferredAlternativeDataTypes().IsEmpty()) {
1173       MOZ_ASSERT(cic->PreferredAlternativeDataTypes().Length() == 1);
1174       MOZ_ASSERT(cic->PreferredAlternativeDataTypes()[0].type().Equals(
1175           FetchUtil::WasmAltDataType));
1176       MOZ_ASSERT(
1177           cic->PreferredAlternativeDataTypes()[0].contentType().EqualsLiteral(
1178               WASM_CONTENT_TYPE));
1179
1180       if (contentType.EqualsLiteral(WASM_CONTENT_TYPE)) {
1181         // We want to attach the CacheInfoChannel to the response object such
1182         // that we can track its origin when the Response object is manipulated
1183         // by JavaScript code. This is important for WebAssembly, which uses
1184         // fetch to query its sources in JavaScript and transfer the Response
1185         // object to other function responsible for storing the alternate data
1186         // using the CacheInfoChannel.
1187         nsMainThreadPtrHandle<nsICacheInfoChannel> handle(
1188             new nsMainThreadPtrHolder<nsICacheInfoChannel>(
1189                 "nsICacheInfoChannel", cic, false));
1190         response->SetCacheInfoChannel(handle);
1191       }
1192     }
1193   }
1194
1195   // Fetch spec Main Fetch step 21: ignore body for head/connect methods.
1196   nsAutoCString method;
1197   mRequest->GetMethod(method);
1198   if (!(method.EqualsLiteral("HEAD") || method.EqualsLiteral("CONNECT"))) {
1199     // We open a pipe so that we can immediately set the pipe's read end as the
1200     // response's body. Setting the segment size to UINT32_MAX means that the
1201     // pipe has infinite space. The nsIChannel will continue to buffer data in
1202     // xpcom events even if we block on a fixed size pipe.  It might be possible
1203     // to suspend the channel and then resume when there is space available, but
1204     // for now use an infinite pipe to avoid blocking.
1205     nsCOMPtr<nsIInputStream> pipeInputStream;
1206     NS_NewPipe(getter_AddRefs(pipeInputStream),
1207                getter_AddRefs(mPipeOutputStream), 0, /* default segment size */
1208                UINT32_MAX /* infinite pipe */,
1209                true /* non-blocking input, otherwise you deadlock */,
1210                false /* blocking output, since the pipe is 'in'finite */);
1211     response->SetBody(pipeInputStream, contentLength);
1212   }
1213
1214   // If the request is a file channel, then remember the local path to
1215   // that file so we can later create File blobs rather than plain ones.
1216   nsCOMPtr<nsIFileChannel> fc = do_QueryInterface(aRequest);
1217   if (fc) {
1218     nsCOMPtr<nsIFile> file;
1219     rv = fc->GetFile(getter_AddRefs(file));
1220     if (!NS_WARN_IF(NS_FAILED(rv))) {
1221       nsAutoString path;
1222       file->GetPath(path);
1223       response->SetBodyLocalPath(path);
1224     }
1225   } else {
1226     // If the request is a blob URI, then remember that URI so that we
1227     // can later just use that blob instance instead of cloning it.
1228     nsCString blobURISpec;
1229     GetBlobURISpecFromChannel(aRequest, blobURISpec);
1230     if (!blobURISpec.IsVoid()) {
1231       response->SetBodyBlobURISpec(blobURISpec);
1232     }
1233   }
1234
1235   response->InitChannelInfo(channel);
1236
1237   nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
1238   // Propagate any tainting from the channel back to our response here.  This
1239   // step is not reflected in the spec because the spec is written such that
1240   // FetchEvent.respondWith() just passes the already-tainted Response back to
1241   // the outer fetch().  In gecko, however, we serialize the Response through
1242   // the channel and must regenerate the tainting from the channel in the
1243   // interception case.
1244   mRequest->MaybeIncreaseResponseTainting(loadInfo->GetTainting());
1245
1246   // Resolves fetch() promise which may trigger code running in a worker.  Make
1247   // sure the Response is fully initialized before calling this.
1248   mResponse =
1249       BeginAndGetFilteredResponse(std::move(response), foundOpaqueRedirect);
1250   if (NS_WARN_IF(!mResponse)) {
1251     // Fail to generate a paddingInfo for opaque response.
1252     MOZ_DIAGNOSTIC_ASSERT(mRequest->GetResponseTainting() ==
1253                               LoadTainting::Opaque &&
1254                           !foundOpaqueRedirect);
1255     FailWithNetworkError(NS_ERROR_UNEXPECTED);
1256     return NS_ERROR_UNEXPECTED;
1257   }
1258
1259   // From "Main Fetch" step 19: SRI-part1.
1260   if (ShouldCheckSRI(*mRequest, *mResponse) && mSRIMetadata.IsEmpty()) {
1261     nsIConsoleReportCollector* reporter = nullptr;
1262     if (mObserver) {
1263       reporter = mObserver->GetReporter();
1264     }
1265
1266     nsAutoCString sourceUri;
1267     if (mDocument && mDocument->GetDocumentURI()) {
1268       mDocument->GetDocumentURI()->GetAsciiSpec(sourceUri);
1269     } else if (!mWorkerScript.IsEmpty()) {
1270       sourceUri.Assign(mWorkerScript);
1271     }
1272     SRICheck::IntegrityMetadata(mRequest->GetIntegrity(), sourceUri, reporter,
1273                                 &mSRIMetadata);
1274     mSRIDataVerifier =
1275         MakeUnique<SRICheckDataVerifier>(mSRIMetadata, sourceUri, reporter);
1276
1277     // Do not retarget off main thread when using SRI API.
1278     return NS_OK;
1279   }
1280
1281   nsCOMPtr<nsIEventTarget> sts =
1282       do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
1283   if (NS_WARN_IF(NS_FAILED(rv))) {
1284     FailWithNetworkError(rv);
1285     // Cancel request.
1286     return rv;
1287   }
1288
1289   // Try to retarget off main thread.
1290   if (nsCOMPtr<nsIThreadRetargetableRequest> rr = do_QueryInterface(aRequest)) {
1291     RefPtr<TaskQueue> queue =
1292         TaskQueue::Create(sts.forget(), "FetchDriver STS Delivery Queue");
1293     Unused << NS_WARN_IF(NS_FAILED(rr->RetargetDeliveryTo(queue)));
1294   }
1295   return NS_OK;
1296 }
1297
1298 namespace {
1299
1300 // Runnable to call the observer OnDataAvailable on the main-thread.
1301 class DataAvailableRunnable final : public Runnable {
1302   RefPtr<FetchDriverObserver> mObserver;
1303
1304  public:
1305   explicit DataAvailableRunnable(FetchDriverObserver* aObserver)
1306       : Runnable("dom::DataAvailableRunnable"), mObserver(aObserver) {
1307     MOZ_ASSERT(aObserver);
1308   }
1309
1310   NS_IMETHOD
1311   Run() override {
1312     mObserver->OnDataAvailable();
1313     mObserver = nullptr;
1314     return NS_OK;
1315   }
1316 };
1317
1318 struct SRIVerifierAndOutputHolder {
1319   SRIVerifierAndOutputHolder(SRICheckDataVerifier* aVerifier,
1320                              nsIOutputStream* aOutputStream)
1321       : mVerifier(aVerifier), mOutputStream(aOutputStream) {}
1322
1323   SRICheckDataVerifier* mVerifier;
1324   nsIOutputStream* mOutputStream;
1325
1326  private:
1327   SRIVerifierAndOutputHolder() = delete;
1328 };
1329
1330 // Just like NS_CopySegmentToStream, but also sends the data into an
1331 // SRICheckDataVerifier.
1332 nsresult CopySegmentToStreamAndSRI(nsIInputStream* aInStr, void* aClosure,
1333                                    const char* aBuffer, uint32_t aOffset,
1334                                    uint32_t aCount, uint32_t* aCountWritten) {
1335   auto holder = static_cast<SRIVerifierAndOutputHolder*>(aClosure);
1336   MOZ_DIAGNOSTIC_ASSERT(holder && holder->mVerifier && holder->mOutputStream,
1337                         "Bogus holder");
1338   nsresult rv = holder->mVerifier->Update(
1339       aCount, reinterpret_cast<const uint8_t*>(aBuffer));
1340   NS_ENSURE_SUCCESS(rv, rv);
1341
1342   // The rest is just like NS_CopySegmentToStream.
1343   *aCountWritten = 0;
1344   while (aCount) {
1345     uint32_t n = 0;
1346     rv = holder->mOutputStream->Write(aBuffer, aCount, &n);
1347     if (NS_FAILED(rv)) {
1348       return rv;
1349     }
1350     aBuffer += n;
1351     aCount -= n;
1352     *aCountWritten += n;
1353   }
1354   return NS_OK;
1355 }
1356
1357 }  // anonymous namespace
1358
1359 NS_IMETHODIMP
1360 FetchDriver::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInputStream,
1361                              uint64_t aOffset, uint32_t aCount) {
1362   // NB: This can be called on any thread!  But we're guaranteed that it is
1363   // called between OnStartRequest and OnStopRequest, so we don't need to worry
1364   // about races.
1365
1366   if (!mPipeOutputStream) {
1367     // We ignore the body for HEAD/CONNECT requests.
1368     // nsIStreamListener mandates reading from the stream before returning.
1369     uint32_t totalRead;
1370     nsresult rv = aInputStream->ReadSegments(NS_DiscardSegment, nullptr, aCount,
1371                                              &totalRead);
1372     NS_ENSURE_SUCCESS(rv, rv);
1373     return NS_OK;
1374   }
1375
1376   if (mNeedToObserveOnDataAvailable) {
1377     mNeedToObserveOnDataAvailable = false;
1378     if (mObserver) {
1379       // Need to keep mObserver alive.
1380       RefPtr<FetchDriverObserver> observer = mObserver;
1381       if (NS_IsMainThread()) {
1382         observer->OnDataAvailable();
1383       } else {
1384         RefPtr<Runnable> runnable = new DataAvailableRunnable(observer);
1385         nsresult rv = mMainThreadEventTarget->Dispatch(runnable.forget(),
1386                                                        NS_DISPATCH_NORMAL);
1387         if (NS_WARN_IF(NS_FAILED(rv))) {
1388           return rv;
1389         }
1390       }
1391     }
1392   }
1393
1394   if (!mResponse) {
1395     MOZ_ASSERT(false);
1396     return NS_ERROR_UNEXPECTED;
1397   }
1398
1399   // Needs to be initialized to 0 because in some cases nsStringInputStream may
1400   // not write to aRead.
1401   uint32_t aRead = 0;
1402   MOZ_ASSERT(mPipeOutputStream);
1403
1404   // From "Main Fetch" step 19: SRI-part2.
1405   // Note: Avoid checking the hidden opaque body.
1406   nsresult rv;
1407   if (mResponse->Type() != ResponseType::Opaque &&
1408       ShouldCheckSRI(*mRequest, *mResponse)) {
1409     MOZ_ASSERT(mSRIDataVerifier);
1410
1411     SRIVerifierAndOutputHolder holder(mSRIDataVerifier.get(),
1412                                       mPipeOutputStream);
1413     rv = aInputStream->ReadSegments(CopySegmentToStreamAndSRI, &holder, aCount,
1414                                     &aRead);
1415   } else {
1416     rv = aInputStream->ReadSegments(NS_CopySegmentToStream, mPipeOutputStream,
1417                                     aCount, &aRead);
1418   }
1419
1420   // If no data was read, it's possible the output stream is closed but the
1421   // ReadSegments call followed its contract of returning NS_OK despite write
1422   // errors.  Unfortunately, nsIOutputStream has an ill-conceived contract when
1423   // taken together with ReadSegments' contract, because the pipe will just
1424   // NS_OK if we try and invoke its Write* functions ourselves with a 0 count.
1425   // So we must just assume the pipe is broken.
1426   if (aRead == 0 && aCount != 0) {
1427     return NS_BASE_STREAM_CLOSED;
1428   }
1429   return rv;
1430 }
1431
1432 NS_IMETHODIMP
1433 FetchDriver::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
1434   AssertIsOnMainThread();
1435
1436   MOZ_DIAGNOSTIC_ASSERT(!mOnStopRequestCalled);
1437   mOnStopRequestCalled = true;
1438
1439   // main data loading is going to finish, breaking the reference cycle.
1440   RefPtr<AlternativeDataStreamListener> altDataListener =
1441       std::move(mAltDataListener);
1442
1443   // For PFetch and ServiceWorker navigationPreload, resource timing should be
1444   // reported before the body stream closing.
1445   if (mObserver) {
1446     mObserver->OnReportPerformanceTiming();
1447   }
1448
1449   // We need to check mObserver, which is nulled by FailWithNetworkError(),
1450   // because in the case of "error" redirect mode, aStatusCode may be NS_OK but
1451   // mResponse will definitely be null so we must not take the else branch.
1452   if (NS_FAILED(aStatusCode) || !mObserver) {
1453     nsCOMPtr<nsIAsyncOutputStream> outputStream =
1454         do_QueryInterface(mPipeOutputStream);
1455     if (outputStream) {
1456       outputStream->CloseWithStatus(NS_FAILED(aStatusCode) ? aStatusCode
1457                                                            : NS_BINDING_FAILED);
1458     }
1459     if (altDataListener) {
1460       altDataListener->Cancel();
1461     }
1462
1463     // We proceed as usual here, since we've already created a successful
1464     // response from OnStartRequest.
1465   } else {
1466     MOZ_ASSERT(mResponse);
1467     MOZ_ASSERT(!mResponse->IsError());
1468
1469     // From "Main Fetch" step 19: SRI-part3.
1470     if (ShouldCheckSRI(*mRequest, *mResponse)) {
1471       MOZ_ASSERT(mSRIDataVerifier);
1472
1473       nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
1474
1475       nsIConsoleReportCollector* reporter = nullptr;
1476       if (mObserver) {
1477         reporter = mObserver->GetReporter();
1478       }
1479
1480       nsAutoCString sourceUri;
1481       if (mDocument && mDocument->GetDocumentURI()) {
1482         mDocument->GetDocumentURI()->GetAsciiSpec(sourceUri);
1483       } else if (!mWorkerScript.IsEmpty()) {
1484         sourceUri.Assign(mWorkerScript);
1485       }
1486       nsresult rv =
1487           mSRIDataVerifier->Verify(mSRIMetadata, channel, sourceUri, reporter);
1488       if (NS_FAILED(rv)) {
1489         if (altDataListener) {
1490           altDataListener->Cancel();
1491         }
1492         FailWithNetworkError(rv);
1493         // Cancel request.
1494         return rv;
1495       }
1496     }
1497
1498     if (mPipeOutputStream) {
1499       mPipeOutputStream->Close();
1500     }
1501   }
1502
1503   FinishOnStopRequest(altDataListener);
1504   return NS_OK;
1505 }
1506
1507 void FetchDriver::FinishOnStopRequest(
1508     AlternativeDataStreamListener* aAltDataListener) {
1509   AssertIsOnMainThread();
1510   // OnStopRequest is not called from channel, that means the main data loading
1511   // does not finish yet. Reaching here since alternative data loading finishes.
1512   if (!mOnStopRequestCalled) {
1513     return;
1514   }
1515
1516   MOZ_DIAGNOSTIC_ASSERT(!mAltDataListener);
1517   // Wait for alternative data loading finish if we needed it.
1518   if (aAltDataListener &&
1519       aAltDataListener->Status() == AlternativeDataStreamListener::LOADING) {
1520     // For LOADING case, channel holds the reference of altDataListener, no need
1521     // to restore it to mAltDataListener.
1522     return;
1523   }
1524
1525   if (mObserver) {
1526     // From "Main Fetch" step 19.1, 19.2: Process response.
1527     if (ShouldCheckSRI(*mRequest, *mResponse)) {
1528       MOZ_ASSERT(mResponse);
1529       // Need to keep mObserver alive.
1530       RefPtr<FetchDriverObserver> observer = mObserver;
1531       observer->OnResponseAvailable(mResponse.clonePtr());
1532 #ifdef DEBUG
1533       mResponseAvailableCalled = true;
1534 #endif
1535     }
1536   }
1537
1538   if (mObserver) {
1539     mObserver->OnResponseEnd(FetchDriverObserver::eByNetworking,
1540                              JS::UndefinedHandleValue);
1541     mObserver = nullptr;
1542   }
1543
1544   mChannel = nullptr;
1545   Unfollow();
1546 }
1547
1548 NS_IMETHODIMP
1549 FetchDriver::ShouldPrepareForIntercept(nsIURI* aURI, nsIChannel* aChannel,
1550                                        bool* aShouldIntercept) {
1551   MOZ_ASSERT(aChannel);
1552
1553   if (mInterceptController) {
1554     MOZ_ASSERT(XRE_IsParentProcess());
1555     return mInterceptController->ShouldPrepareForIntercept(aURI, aChannel,
1556                                                            aShouldIntercept);
1557   }
1558
1559   nsCOMPtr<nsINetworkInterceptController> controller;
1560   NS_QueryNotificationCallbacks(nullptr, mLoadGroup,
1561                                 NS_GET_IID(nsINetworkInterceptController),
1562                                 getter_AddRefs(controller));
1563   if (controller) {
1564     return controller->ShouldPrepareForIntercept(aURI, aChannel,
1565                                                  aShouldIntercept);
1566   }
1567
1568   *aShouldIntercept = false;
1569   return NS_OK;
1570 }
1571
1572 NS_IMETHODIMP
1573 FetchDriver::ChannelIntercepted(nsIInterceptedChannel* aChannel) {
1574   if (mInterceptController) {
1575     MOZ_ASSERT(XRE_IsParentProcess());
1576     return mInterceptController->ChannelIntercepted(aChannel);
1577   }
1578
1579   nsCOMPtr<nsINetworkInterceptController> controller;
1580   NS_QueryNotificationCallbacks(nullptr, mLoadGroup,
1581                                 NS_GET_IID(nsINetworkInterceptController),
1582                                 getter_AddRefs(controller));
1583   if (controller) {
1584     return controller->ChannelIntercepted(aChannel);
1585   }
1586
1587   return NS_OK;
1588 }
1589
1590 void FetchDriver::EnableNetworkInterceptControl() {
1591   MOZ_ASSERT(XRE_IsParentProcess());
1592   MOZ_ASSERT(NS_IsMainThread());
1593   MOZ_ASSERT(!mInterceptController);
1594   mInterceptController = new ServiceWorkerInterceptController();
1595 }
1596
1597 NS_IMETHODIMP
1598 FetchDriver::AsyncOnChannelRedirect(nsIChannel* aOldChannel,
1599                                     nsIChannel* aNewChannel, uint32_t aFlags,
1600                                     nsIAsyncVerifyRedirectCallback* aCallback) {
1601   nsCOMPtr<nsIHttpChannel> oldHttpChannel = do_QueryInterface(aOldChannel);
1602   nsCOMPtr<nsIHttpChannel> newHttpChannel = do_QueryInterface(aNewChannel);
1603   if (oldHttpChannel && newHttpChannel) {
1604     nsAutoCString method;
1605     mRequest->GetMethod(method);
1606
1607     // Fetch 4.4.11
1608     bool rewriteToGET = false;
1609     Unused << oldHttpChannel->ShouldStripRequestBodyHeader(method,
1610                                                            &rewriteToGET);
1611
1612     // we need to strip Authentication headers for cross-origin requests
1613     // Ref: https://fetch.spec.whatwg.org/#http-redirect-fetch
1614     bool skipAuthHeader =
1615         (StaticPrefs::network_fetch_redirect_stripAuthHeader() &&
1616          NS_ShouldRemoveAuthHeaderOnRedirect(aOldChannel, aNewChannel, aFlags));
1617
1618     SetRequestHeaders(newHttpChannel, rewriteToGET, skipAuthHeader);
1619   }
1620
1621   // "HTTP-redirect fetch": step 14 "Append locationURL to request's URL list."
1622   // However, ignore internal redirects here.  We don't want to flip
1623   // Response.redirected to true if an internal redirect occurs.  These
1624   // should be transparent to script.
1625   nsCOMPtr<nsIURI> uri;
1626   MOZ_ALWAYS_SUCCEEDS(NS_GetFinalChannelURI(aNewChannel, getter_AddRefs(uri)));
1627
1628   nsCOMPtr<nsIURI> uriClone;
1629   nsresult rv = NS_GetURIWithoutRef(uri, getter_AddRefs(uriClone));
1630   if (NS_WARN_IF(NS_FAILED(rv))) {
1631     return rv;
1632   }
1633   nsCString spec;
1634   rv = uriClone->GetSpec(spec);
1635   if (NS_WARN_IF(NS_FAILED(rv))) {
1636     return rv;
1637   }
1638   nsCString fragment;
1639   rv = uri->GetRef(fragment);
1640   if (NS_WARN_IF(NS_FAILED(rv))) {
1641     return rv;
1642   }
1643
1644   if (!(aFlags & nsIChannelEventSink::REDIRECT_INTERNAL)) {
1645     mRequest->AddURL(spec, fragment);
1646   } else {
1647     // Overwrite the URL only when the request is redirected by a service
1648     // worker.
1649     mRequest->SetURLForInternalRedirect(aFlags, spec, fragment);
1650   }
1651
1652   // In redirect, httpChannel already took referrer-policy into account, so
1653   // updates request’s associated referrer policy from channel.
1654   UpdateReferrerInfoFromNewChannel(aNewChannel);
1655
1656   aCallback->OnRedirectVerifyCallback(NS_OK);
1657   return NS_OK;
1658 }
1659
1660 NS_IMETHODIMP
1661 FetchDriver::CheckListenerChain() { return NS_OK; }
1662
1663 NS_IMETHODIMP
1664 FetchDriver::GetInterface(const nsIID& aIID, void** aResult) {
1665   if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
1666     *aResult = static_cast<nsIChannelEventSink*>(this);
1667     NS_ADDREF_THIS();
1668     return NS_OK;
1669   }
1670   if (aIID.Equals(NS_GET_IID(nsIStreamListener))) {
1671     *aResult = static_cast<nsIStreamListener*>(this);
1672     NS_ADDREF_THIS();
1673     return NS_OK;
1674   }
1675   if (aIID.Equals(NS_GET_IID(nsIRequestObserver))) {
1676     *aResult = static_cast<nsIRequestObserver*>(this);
1677     NS_ADDREF_THIS();
1678     return NS_OK;
1679   }
1680
1681   return QueryInterface(aIID, aResult);
1682 }
1683
1684 void FetchDriver::SetDocument(Document* aDocument) {
1685   // Cannot set document after Fetch() has been called.
1686   MOZ_ASSERT(!mFetchCalled);
1687   mDocument = aDocument;
1688 }
1689
1690 void FetchDriver::SetCSPEventListener(nsICSPEventListener* aCSPEventListener) {
1691   MOZ_ASSERT(!mFetchCalled);
1692   mCSPEventListener = aCSPEventListener;
1693 }
1694
1695 void FetchDriver::SetClientInfo(const ClientInfo& aClientInfo) {
1696   MOZ_ASSERT(!mFetchCalled);
1697   mClientInfo.emplace(aClientInfo);
1698 }
1699
1700 void FetchDriver::SetController(
1701     const Maybe<ServiceWorkerDescriptor>& aController) {
1702   MOZ_ASSERT(!mFetchCalled);
1703   mController = aController;
1704 }
1705
1706 PerformanceTimingData* FetchDriver::GetPerformanceTimingData(
1707     nsAString& aInitiatorType, nsAString& aEntryName) {
1708   MOZ_ASSERT(XRE_IsParentProcess());
1709   if (!mChannel) {
1710     return nullptr;
1711   }
1712
1713   nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(mChannel);
1714   if (!timedChannel) {
1715     return nullptr;
1716   }
1717   nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel);
1718   if (!httpChannel) {
1719     return nullptr;
1720   }
1721   return dom::PerformanceTimingData::Create(timedChannel, httpChannel, 0,
1722                                             aInitiatorType, aEntryName);
1723 }
1724
1725 void FetchDriver::SetRequestHeaders(nsIHttpChannel* aChannel,
1726                                     bool aStripRequestBodyHeader,
1727                                     bool aStripAuthHeader) const {
1728   MOZ_ASSERT(aChannel);
1729
1730   // nsIHttpChannel has a set of pre-configured headers (Accept,
1731   // Accept-Languages, ...) and we don't want to merge the Request's headers
1732   // with them. This array is used to know if the current header has been aleady
1733   // set, if yes, we ask necko to merge it with the previous one, otherwise, we
1734   // don't want the merge.
1735   nsTArray<nsCString> headersSet;
1736
1737   AutoTArray<InternalHeaders::Entry, 5> headers;
1738   mRequest->Headers()->GetEntries(headers);
1739   for (uint32_t i = 0; i < headers.Length(); ++i) {
1740     if (aStripRequestBodyHeader &&
1741         (headers[i].mName.LowerCaseEqualsASCII("content-type") ||
1742          headers[i].mName.LowerCaseEqualsASCII("content-encoding") ||
1743          headers[i].mName.LowerCaseEqualsASCII("content-language") ||
1744          headers[i].mName.LowerCaseEqualsASCII("content-location"))) {
1745       continue;
1746     }
1747
1748     if (aStripAuthHeader &&
1749         headers[i].mName.LowerCaseEqualsASCII("authorization")) {
1750       continue;
1751     }
1752
1753     bool alreadySet = headersSet.Contains(headers[i].mName);
1754     if (!alreadySet) {
1755       headersSet.AppendElement(headers[i].mName);
1756     }
1757
1758     if (headers[i].mValue.IsEmpty()) {
1759       DebugOnly<nsresult> rv =
1760           aChannel->SetEmptyRequestHeader(headers[i].mName);
1761       MOZ_ASSERT(NS_SUCCEEDED(rv));
1762     } else {
1763       DebugOnly<nsresult> rv = aChannel->SetRequestHeader(
1764           headers[i].mName, headers[i].mValue, alreadySet /* merge */);
1765       MOZ_ASSERT(NS_SUCCEEDED(rv));
1766     }
1767   }
1768 }
1769
1770 void FetchDriver::RunAbortAlgorithm() { FetchDriverAbortActions(Signal()); }
1771
1772 void FetchDriver::FetchDriverAbortActions(AbortSignalImpl* aSignalImpl) {
1773   MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
1774
1775   if (mObserver) {
1776 #ifdef DEBUG
1777     mResponseAvailableCalled = true;
1778 #endif
1779     JS::Rooted<JS::Value> reason(RootingCx());
1780     if (aSignalImpl) {
1781       reason.set(aSignalImpl->RawReason());
1782     }
1783     mObserver->OnResponseEnd(FetchDriverObserver::eAborted, reason);
1784     mObserver = nullptr;
1785   }
1786
1787   if (mChannel) {
1788     mChannel->CancelWithReason(NS_BINDING_ABORTED,
1789                                "FetchDriver::RunAbortAlgorithm"_ns);
1790     mChannel = nullptr;
1791   }
1792
1793   mAborted = true;
1794 }
1795
1796 }  // namespace mozilla::dom