2015-05-03 19:32:37 +00:00
|
|
|
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
2014-10-06 18:01:20 +00:00
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
|
2015-08-13 15:22:19 +00:00
|
|
|
|
#include "mozilla/DebugOnly.h"
|
2014-10-06 18:01:20 +00:00
|
|
|
|
#include "mozilla/dom/FetchDriver.h"
|
|
|
|
|
|
2015-10-08 20:41:38 +00:00
|
|
|
|
#include "nsIAsyncVerifyRedirectCallback.h"
|
2019-01-02 13:05:23 +00:00
|
|
|
|
#include "mozilla/dom/Document.h"
|
2014-12-10 08:51:59 +00:00
|
|
|
|
#include "nsIInputStream.h"
|
|
|
|
|
#include "nsIOutputStream.h"
|
2018-09-11 19:13:15 +00:00
|
|
|
|
#include "nsIFileChannel.h"
|
2014-12-10 08:51:59 +00:00
|
|
|
|
#include "nsIHttpChannel.h"
|
2014-12-24 10:08:41 +00:00
|
|
|
|
#include "nsIHttpChannelInternal.h"
|
2014-10-06 18:01:20 +00:00
|
|
|
|
#include "nsIScriptSecurityManager.h"
|
2017-05-19 05:29:00 +00:00
|
|
|
|
#include "nsISupportsPriority.h"
|
2014-12-10 08:51:59 +00:00
|
|
|
|
#include "nsIThreadRetargetableRequest.h"
|
|
|
|
|
#include "nsIUploadChannel2.h"
|
2015-07-07 02:17:00 +00:00
|
|
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
|
|
|
#include "nsIPipe.h"
|
2014-10-06 18:01:20 +00:00
|
|
|
|
|
|
|
|
|
#include "nsContentPolicyUtils.h"
|
|
|
|
|
#include "nsDataHandler.h"
|
|
|
|
|
#include "nsNetUtil.h"
|
2015-04-23 14:45:00 +00:00
|
|
|
|
#include "nsPrintfCString.h"
|
2017-12-05 17:13:54 +00:00
|
|
|
|
#include "nsProxyRelease.h"
|
2014-12-10 08:51:59 +00:00
|
|
|
|
#include "nsStreamUtils.h"
|
2014-10-06 18:01:20 +00:00
|
|
|
|
#include "nsStringStream.h"
|
2015-11-24 02:47:10 +00:00
|
|
|
|
#include "nsHttpChannel.h"
|
2014-10-06 18:01:20 +00:00
|
|
|
|
|
2018-06-02 13:51:42 +00:00
|
|
|
|
#include "mozilla/dom/BlobURLProtocolHandler.h"
|
2014-10-06 18:01:20 +00:00
|
|
|
|
#include "mozilla/dom/File.h"
|
2018-01-24 16:17:31 +00:00
|
|
|
|
#include "mozilla/dom/PerformanceStorage.h"
|
2018-01-31 07:24:59 +00:00
|
|
|
|
#include "mozilla/dom/WorkerCommon.h"
|
2019-02-20 10:05:42 +00:00
|
|
|
|
#include "mozilla/net/NeckoChannelParams.h"
|
2017-04-21 05:29:31 +00:00
|
|
|
|
#include "mozilla/EventStateManager.h"
|
2016-10-26 07:07:25 +00:00
|
|
|
|
#include "mozilla/ipc/PBackgroundSharedTypes.h"
|
2019-07-26 01:10:23 +00:00
|
|
|
|
#include "mozilla/StaticPrefs_browser.h"
|
|
|
|
|
#include "mozilla/StaticPrefs_network.h"
|
|
|
|
|
#include "mozilla/StaticPrefs_privacy.h"
|
2016-08-23 04:09:32 +00:00
|
|
|
|
#include "mozilla/Unused.h"
|
2014-10-06 18:01:20 +00:00
|
|
|
|
|
|
|
|
|
#include "Fetch.h"
|
2016-11-14 07:15:32 +00:00
|
|
|
|
#include "FetchUtil.h"
|
2014-10-06 18:01:20 +00:00
|
|
|
|
#include "InternalRequest.h"
|
|
|
|
|
#include "InternalResponse.h"
|
|
|
|
|
|
|
|
|
|
namespace mozilla {
|
|
|
|
|
namespace dom {
|
|
|
|
|
|
2017-08-25 08:36:59 +00:00
|
|
|
|
namespace {
|
|
|
|
|
|
2018-10-06 17:34:24 +00:00
|
|
|
|
void GetBlobURISpecFromChannel(nsIRequest* aRequest, nsCString& aBlobURISpec) {
|
|
|
|
|
MOZ_ASSERT(aRequest);
|
|
|
|
|
|
|
|
|
|
aBlobURISpec.SetIsVoid(true);
|
|
|
|
|
|
|
|
|
|
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
|
|
|
|
|
if (!channel) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
|
nsresult rv = channel->GetURI(getter_AddRefs(uri));
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!dom::IsBlobURI(uri)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uri->GetSpec(aBlobURISpec);
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-25 08:36:59 +00:00
|
|
|
|
bool ShouldCheckSRI(const InternalRequest* const aRequest,
|
|
|
|
|
const InternalResponse* const aResponse) {
|
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(aRequest);
|
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(aResponse);
|
|
|
|
|
|
|
|
|
|
return !aRequest->GetIntegrity().IsEmpty() &&
|
|
|
|
|
aResponse->Type() != ResponseType::Error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
2017-12-04 06:39:15 +00:00
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
// AlternativeDataStreamListener
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
class AlternativeDataStreamListener final
|
|
|
|
|
: public nsIStreamListener,
|
|
|
|
|
public nsIThreadRetargetableStreamListener {
|
|
|
|
|
public:
|
|
|
|
|
NS_DECL_THREADSAFE_ISUPPORTS
|
|
|
|
|
NS_DECL_NSIREQUESTOBSERVER
|
|
|
|
|
NS_DECL_NSISTREAMLISTENER
|
|
|
|
|
NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
|
|
|
|
|
|
|
|
|
|
// The status of AlternativeDataStreamListener
|
|
|
|
|
// LOADING: is the initial status, loading the alternative data
|
|
|
|
|
// COMPLETED: Alternative data loading is completed
|
|
|
|
|
// CANCELED: Alternative data loading is canceled, this would make
|
|
|
|
|
// AlternativeDataStreamListener ignore all channel callbacks
|
|
|
|
|
// FALLBACK: fallback the channel callbacks to FetchDriver
|
|
|
|
|
// Depends on different situaions, the status transition could be followings
|
|
|
|
|
// 1. LOADING->COMPLETED
|
|
|
|
|
// This is the normal status transition for alternative data loading
|
|
|
|
|
//
|
|
|
|
|
// 2. LOADING->CANCELED
|
|
|
|
|
// LOADING->COMPLETED->CANCELED
|
|
|
|
|
// Alternative data loading could be canceled when cacheId from alternative
|
|
|
|
|
// data channel does not match with from main data channel(The cacheID
|
|
|
|
|
// checking is in FetchDriver::OnStartRequest).
|
|
|
|
|
// Notice the alternative data loading could finish before the cacheID
|
|
|
|
|
// checking, so the statust transition could be
|
|
|
|
|
// LOADING->COMPLETED->CANCELED
|
|
|
|
|
//
|
|
|
|
|
// 3. LOADING->FALLBACK
|
|
|
|
|
// For the case that alternative data loading could not be initialized,
|
|
|
|
|
// i.e. alternative data does not exist or no preferred alternative data
|
|
|
|
|
// type is requested. Once the status becomes FALLBACK,
|
|
|
|
|
// AlternativeDataStreamListener transits the channel callback request to
|
|
|
|
|
// FetchDriver, and the status should not go back to LOADING, COMPLETED, or
|
|
|
|
|
// CANCELED anymore.
|
|
|
|
|
enum eStatus { LOADING = 0, COMPLETED, CANCELED, FALLBACK };
|
2018-11-30 10:46:48 +00:00
|
|
|
|
|
2017-12-04 06:39:15 +00:00
|
|
|
|
AlternativeDataStreamListener(FetchDriver* aFetchDriver, nsIChannel* aChannel,
|
|
|
|
|
const nsACString& aAlternativeDataType);
|
|
|
|
|
eStatus Status();
|
|
|
|
|
void Cancel();
|
|
|
|
|
uint64_t GetAlternativeDataCacheEntryId();
|
2017-12-04 06:39:26 +00:00
|
|
|
|
const nsACString& GetAlternativeDataType() const;
|
2017-12-04 06:39:15 +00:00
|
|
|
|
already_AddRefed<nsICacheInfoChannel> GetCacheInfoChannel();
|
|
|
|
|
already_AddRefed<nsIInputStream> GetAlternativeInputStream();
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
~AlternativeDataStreamListener() = default;
|
|
|
|
|
|
|
|
|
|
// This creates a strong reference cycle with FetchDriver and its
|
|
|
|
|
// mAltDataListener. We need to clear at least one reference of them once the
|
|
|
|
|
// data loading finishes.
|
|
|
|
|
RefPtr<FetchDriver> mFetchDriver;
|
|
|
|
|
nsCString mAlternativeDataType;
|
|
|
|
|
nsCOMPtr<nsIInputStream> mPipeAlternativeInputStream;
|
|
|
|
|
nsCOMPtr<nsIOutputStream> mPipeAlternativeOutputStream;
|
|
|
|
|
uint64_t mAlternativeDataCacheEntryId;
|
|
|
|
|
nsCOMPtr<nsICacheInfoChannel> mCacheInfoChannel;
|
|
|
|
|
nsCOMPtr<nsIChannel> mChannel;
|
|
|
|
|
Atomic<eStatus> mStatus;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
NS_IMPL_ISUPPORTS(AlternativeDataStreamListener, nsIStreamListener,
|
|
|
|
|
nsIThreadRetargetableStreamListener)
|
|
|
|
|
|
|
|
|
|
AlternativeDataStreamListener::AlternativeDataStreamListener(
|
|
|
|
|
FetchDriver* aFetchDriver, nsIChannel* aChannel,
|
|
|
|
|
const nsACString& aAlternativeDataType)
|
|
|
|
|
: mFetchDriver(aFetchDriver),
|
|
|
|
|
mAlternativeDataType(aAlternativeDataType),
|
|
|
|
|
mAlternativeDataCacheEntryId(0),
|
|
|
|
|
mChannel(aChannel),
|
|
|
|
|
mStatus(AlternativeDataStreamListener::LOADING) {
|
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mFetchDriver);
|
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mChannel);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
AlternativeDataStreamListener::eStatus AlternativeDataStreamListener::Status() {
|
|
|
|
|
return mStatus;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void AlternativeDataStreamListener::Cancel() {
|
|
|
|
|
mAlternativeDataCacheEntryId = 0;
|
|
|
|
|
mCacheInfoChannel = nullptr;
|
|
|
|
|
mPipeAlternativeOutputStream = nullptr;
|
|
|
|
|
mPipeAlternativeInputStream = nullptr;
|
|
|
|
|
if (mChannel && mStatus != AlternativeDataStreamListener::FALLBACK) {
|
|
|
|
|
// if mStatus is fallback, we need to keep channel to forward request back
|
|
|
|
|
// to FetchDriver
|
|
|
|
|
mChannel->Cancel(NS_BINDING_ABORTED);
|
|
|
|
|
mChannel = nullptr;
|
|
|
|
|
}
|
|
|
|
|
mStatus = AlternativeDataStreamListener::CANCELED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint64_t AlternativeDataStreamListener::GetAlternativeDataCacheEntryId() {
|
|
|
|
|
return mAlternativeDataCacheEntryId;
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-04 06:39:26 +00:00
|
|
|
|
const nsACString& AlternativeDataStreamListener::GetAlternativeDataType()
|
|
|
|
|
const {
|
|
|
|
|
return mAlternativeDataType;
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-04 06:39:15 +00:00
|
|
|
|
already_AddRefed<nsIInputStream>
|
|
|
|
|
AlternativeDataStreamListener::GetAlternativeInputStream() {
|
|
|
|
|
nsCOMPtr<nsIInputStream> inputStream = mPipeAlternativeInputStream;
|
|
|
|
|
return inputStream.forget();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
already_AddRefed<nsICacheInfoChannel>
|
|
|
|
|
AlternativeDataStreamListener::GetCacheInfoChannel() {
|
|
|
|
|
nsCOMPtr<nsICacheInfoChannel> channel = mCacheInfoChannel;
|
|
|
|
|
return channel.forget();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2019-02-27 23:41:04 +00:00
|
|
|
|
AlternativeDataStreamListener::OnStartRequest(nsIRequest* aRequest) {
|
2018-02-05 18:55:07 +00:00
|
|
|
|
AssertIsOnMainThread();
|
2017-12-04 06:39:15 +00:00
|
|
|
|
MOZ_ASSERT(!mAlternativeDataType.IsEmpty());
|
|
|
|
|
// Checking the alternative data type is the same between we asked and the
|
|
|
|
|
// saved in the channel.
|
|
|
|
|
nsAutoCString alternativeDataType;
|
|
|
|
|
nsCOMPtr<nsICacheInfoChannel> cic = do_QueryInterface(aRequest);
|
|
|
|
|
mStatus = AlternativeDataStreamListener::LOADING;
|
|
|
|
|
if (cic && NS_SUCCEEDED(cic->GetAlternativeDataType(alternativeDataType)) &&
|
|
|
|
|
mAlternativeDataType.Equals(alternativeDataType) &&
|
|
|
|
|
NS_SUCCEEDED(cic->GetCacheEntryId(&mAlternativeDataCacheEntryId))) {
|
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(!mPipeAlternativeInputStream);
|
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(!mPipeAlternativeOutputStream);
|
|
|
|
|
nsresult rv =
|
|
|
|
|
NS_NewPipe(getter_AddRefs(mPipeAlternativeInputStream),
|
|
|
|
|
getter_AddRefs(mPipeAlternativeOutputStream),
|
|
|
|
|
0 /* default segment size */, UINT32_MAX /* infinite pipe */,
|
|
|
|
|
true /* non-blocking input, otherwise you deadlock */,
|
|
|
|
|
false /* blocking output, since the pipe is 'in'finite */);
|
|
|
|
|
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
|
mFetchDriver->FailWithNetworkError(rv);
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(!mCacheInfoChannel);
|
|
|
|
|
mCacheInfoChannel = cic;
|
|
|
|
|
|
|
|
|
|
// call FetchDriver::HttpFetch to load main body
|
|
|
|
|
MOZ_ASSERT(mFetchDriver);
|
|
|
|
|
return mFetchDriver->HttpFetch();
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
// Needn't load alternative data, since alternative data does not exist.
|
|
|
|
|
// Set status to FALLBACK to reuse the opened channel to load main body,
|
|
|
|
|
// then call FetchDriver::OnStartRequest to continue the work. Unfortunately
|
|
|
|
|
// can't change the stream listener to mFetchDriver, need to keep
|
|
|
|
|
// AlternativeDataStreamListener alive to redirect OnDataAvailable and
|
|
|
|
|
// OnStopRequest to mFetchDriver.
|
|
|
|
|
MOZ_ASSERT(alternativeDataType.IsEmpty());
|
|
|
|
|
mStatus = AlternativeDataStreamListener::FALLBACK;
|
|
|
|
|
mAlternativeDataCacheEntryId = 0;
|
|
|
|
|
MOZ_ASSERT(mFetchDriver);
|
2019-02-27 23:41:04 +00:00
|
|
|
|
return mFetchDriver->OnStartRequest(aRequest);
|
2017-12-04 06:39:15 +00:00
|
|
|
|
}
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
|
AlternativeDataStreamListener::OnDataAvailable(nsIRequest* aRequest,
|
|
|
|
|
nsIInputStream* aInputStream,
|
|
|
|
|
uint64_t aOffset,
|
|
|
|
|
uint32_t aCount) {
|
|
|
|
|
if (mStatus == AlternativeDataStreamListener::LOADING) {
|
|
|
|
|
MOZ_ASSERT(mPipeAlternativeOutputStream);
|
|
|
|
|
uint32_t read;
|
|
|
|
|
return aInputStream->ReadSegments(
|
|
|
|
|
NS_CopySegmentToStream, mPipeAlternativeOutputStream, aCount, &read);
|
|
|
|
|
}
|
|
|
|
|
if (mStatus == AlternativeDataStreamListener::FALLBACK) {
|
|
|
|
|
MOZ_ASSERT(mFetchDriver);
|
2019-02-27 23:42:27 +00:00
|
|
|
|
return mFetchDriver->OnDataAvailable(aRequest, aInputStream, aOffset,
|
2017-12-04 06:39:15 +00:00
|
|
|
|
aCount);
|
|
|
|
|
}
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
|
AlternativeDataStreamListener::OnStopRequest(nsIRequest* aRequest,
|
|
|
|
|
nsresult aStatusCode) {
|
2018-02-05 18:55:07 +00:00
|
|
|
|
AssertIsOnMainThread();
|
2017-12-04 06:39:15 +00:00
|
|
|
|
|
|
|
|
|
// Alternative data loading is going to finish, breaking the reference cycle
|
|
|
|
|
// here by taking the ownership to a loacl variable.
|
|
|
|
|
RefPtr<FetchDriver> fetchDriver = mFetchDriver.forget();
|
|
|
|
|
|
|
|
|
|
if (mStatus == AlternativeDataStreamListener::CANCELED) {
|
|
|
|
|
// do nothing
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mStatus == AlternativeDataStreamListener::FALLBACK) {
|
|
|
|
|
MOZ_ASSERT(fetchDriver);
|
2019-02-27 23:41:31 +00:00
|
|
|
|
return fetchDriver->OnStopRequest(aRequest, aStatusCode);
|
2017-12-04 06:39:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mStatus == AlternativeDataStreamListener::LOADING);
|
|
|
|
|
|
|
|
|
|
MOZ_ASSERT(!mAlternativeDataType.IsEmpty() && mPipeAlternativeOutputStream &&
|
|
|
|
|
mPipeAlternativeInputStream);
|
|
|
|
|
|
|
|
|
|
mPipeAlternativeOutputStream->Close();
|
|
|
|
|
mPipeAlternativeOutputStream = nullptr;
|
|
|
|
|
|
|
|
|
|
// Cleanup the states for alternative data if needed.
|
|
|
|
|
if (NS_FAILED(aStatusCode)) {
|
|
|
|
|
mAlternativeDataCacheEntryId = 0;
|
|
|
|
|
mCacheInfoChannel = nullptr;
|
|
|
|
|
mPipeAlternativeInputStream = nullptr;
|
|
|
|
|
}
|
|
|
|
|
mStatus = AlternativeDataStreamListener::COMPLETED;
|
|
|
|
|
// alternative data loading finish, call FetchDriver::FinishOnStopRequest to
|
|
|
|
|
// continue the final step for the case FetchDriver::OnStopRequest is called
|
|
|
|
|
// earlier than AlternativeDataStreamListener::OnStopRequest
|
|
|
|
|
MOZ_ASSERT(fetchDriver);
|
|
|
|
|
return fetchDriver->FinishOnStopRequest(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
|
|
|
|
AlternativeDataStreamListener::CheckListenerChain() { return NS_OK; }
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
// FetchDriver
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
2016-01-19 21:54:15 +00:00
|
|
|
|
NS_IMPL_ISUPPORTS(FetchDriver, nsIStreamListener, nsIChannelEventSink,
|
2015-10-08 20:41:38 +00:00
|
|
|
|
nsIInterfaceRequestor, nsIThreadRetargetableStreamListener)
|
2014-12-10 08:51:59 +00:00
|
|
|
|
|
2018-01-24 16:17:31 +00:00
|
|
|
|
FetchDriver::FetchDriver(InternalRequest* aRequest, nsIPrincipal* aPrincipal,
|
|
|
|
|
nsILoadGroup* aLoadGroup,
|
|
|
|
|
nsIEventTarget* aMainThreadEventTarget,
|
2019-03-08 09:04:11 +00:00
|
|
|
|
nsICookieSettings* aCookieSettings,
|
2018-01-24 16:17:31 +00:00
|
|
|
|
PerformanceStorage* aPerformanceStorage,
|
2017-05-16 10:27:01 +00:00
|
|
|
|
bool aIsTrackingFetch)
|
2014-12-10 08:51:59 +00:00
|
|
|
|
: mPrincipal(aPrincipal),
|
2015-01-08 16:55:05 +00:00
|
|
|
|
mLoadGroup(aLoadGroup),
|
2014-12-10 08:51:59 +00:00
|
|
|
|
mRequest(aRequest),
|
2017-05-16 10:27:01 +00:00
|
|
|
|
mMainThreadEventTarget(aMainThreadEventTarget),
|
2019-03-08 09:04:11 +00:00
|
|
|
|
mCookieSettings(aCookieSettings),
|
2018-01-24 16:17:31 +00:00
|
|
|
|
mPerformanceStorage(aPerformanceStorage),
|
2017-10-13 02:23:16 +00:00
|
|
|
|
mNeedToObserveOnDataAvailable(false),
|
2017-05-19 05:29:00 +00:00
|
|
|
|
mIsTrackingFetch(aIsTrackingFetch),
|
2018-06-16 14:21:46 +00:00
|
|
|
|
mOnStopRequestCalled(false)
|
2016-02-26 15:52:06 +00:00
|
|
|
|
#ifdef DEBUG
|
2014-12-10 08:51:59 +00:00
|
|
|
|
,
|
|
|
|
|
mResponseAvailableCalled(false),
|
2015-10-20 01:24:36 +00:00
|
|
|
|
mFetchCalled(false)
|
2016-02-26 15:52:06 +00:00
|
|
|
|
#endif
|
2018-04-13 13:01:28 +00:00
|
|
|
|
{
|
|
|
|
|
AssertIsOnMainThread();
|
2017-09-26 10:53:00 +00:00
|
|
|
|
|
2018-04-13 13:01:28 +00:00
|
|
|
|
MOZ_ASSERT(aRequest);
|
|
|
|
|
MOZ_ASSERT(aPrincipal);
|
|
|
|
|
MOZ_ASSERT(aMainThreadEventTarget);
|
2014-10-06 18:01:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
FetchDriver::~FetchDriver() {
|
2017-09-26 10:53:00 +00:00
|
|
|
|
AssertIsOnMainThread();
|
|
|
|
|
|
2014-12-10 08:51:59 +00:00
|
|
|
|
// We assert this since even on failures, we should call
|
|
|
|
|
// FailWithNetworkError().
|
|
|
|
|
MOZ_ASSERT(mResponseAvailableCalled);
|
2014-10-06 18:01:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-08-26 12:16:21 +00:00
|
|
|
|
nsresult FetchDriver::Fetch(AbortSignalImpl* aSignalImpl,
|
|
|
|
|
FetchDriverObserver* aObserver) {
|
2018-02-05 18:55:07 +00:00
|
|
|
|
AssertIsOnMainThread();
|
2016-02-26 15:52:06 +00:00
|
|
|
|
#ifdef DEBUG
|
2015-10-20 01:24:36 +00:00
|
|
|
|
MOZ_ASSERT(!mFetchCalled);
|
|
|
|
|
mFetchCalled = true;
|
2016-02-26 15:52:06 +00:00
|
|
|
|
#endif
|
2015-10-20 01:24:36 +00:00
|
|
|
|
|
2014-10-06 18:01:20 +00:00
|
|
|
|
mObserver = aObserver;
|
|
|
|
|
|
2015-03-27 10:47:00 +00:00
|
|
|
|
Telemetry::Accumulate(Telemetry::SERVICE_WORKER_REQUEST_PASSTHROUGH,
|
|
|
|
|
mRequest->WasCreatedByFetchEvent());
|
|
|
|
|
|
2014-10-06 18:01:20 +00:00
|
|
|
|
// FIXME(nsm): Deal with HSTS.
|
|
|
|
|
|
2015-10-20 01:24:36 +00:00
|
|
|
|
MOZ_RELEASE_ASSERT(!mRequest->IsSynchronous(),
|
|
|
|
|
"Synchronous fetch not supported");
|
2014-10-06 18:01:20 +00:00
|
|
|
|
|
2016-10-26 07:07:25 +00:00
|
|
|
|
UniquePtr<mozilla::ipc::PrincipalInfo> principalInfo(
|
|
|
|
|
new mozilla::ipc::PrincipalInfo());
|
|
|
|
|
nsresult rv = PrincipalToPrincipalInfo(mPrincipal, principalInfo.get());
|
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-30 19:15:35 +00:00
|
|
|
|
mRequest->SetPrincipalInfo(std::move(principalInfo));
|
2017-03-22 10:06:08 +00:00
|
|
|
|
|
|
|
|
|
// If the signal is aborted, it's time to inform the observer and terminate
|
|
|
|
|
// the operation.
|
2018-08-26 12:16:21 +00:00
|
|
|
|
if (aSignalImpl) {
|
|
|
|
|
if (aSignalImpl->Aborted()) {
|
2017-08-29 09:31:07 +00:00
|
|
|
|
Abort();
|
2017-03-22 10:06:08 +00:00
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2018-08-26 12:16:21 +00:00
|
|
|
|
Follow(aSignalImpl);
|
2017-03-22 10:06:08 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-12-04 06:39:15 +00:00
|
|
|
|
rv = HttpFetch(mRequest->GetPreferredAlternativeDataType());
|
2017-11-15 19:53:42 +00:00
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
|
FailWithNetworkError(rv);
|
2015-08-31 21:26:29 +00:00
|
|
|
|
}
|
2016-05-03 01:48:40 +00:00
|
|
|
|
|
2016-06-14 03:08:00 +00:00
|
|
|
|
// Any failure is handled by FailWithNetworkError notifying the aObserver.
|
|
|
|
|
return NS_OK;
|
2015-10-20 01:24:36 +00:00
|
|
|
|
}
|
2015-08-31 21:26:29 +00:00
|
|
|
|
|
2015-01-07 23:50:54 +00:00
|
|
|
|
// This function implements the "HTTP Fetch" algorithm from the Fetch spec.
|
|
|
|
|
// Functionality is often split between here, the CORS listener proxy and the
|
|
|
|
|
// Necko HTTP implementation.
|
2017-12-04 06:39:15 +00:00
|
|
|
|
nsresult FetchDriver::HttpFetch(
|
|
|
|
|
const nsACString& aPreferredAlternativeDataType) {
|
2017-01-05 03:30:07 +00:00
|
|
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
|
|
2015-01-07 23:50:54 +00:00
|
|
|
|
// Step 1. "Let response be null."
|
2014-12-10 08:51:59 +00:00
|
|
|
|
mResponse = nullptr;
|
2017-12-04 06:39:15 +00:00
|
|
|
|
mOnStopRequestCalled = false;
|
2014-12-10 08:51:59 +00:00
|
|
|
|
nsresult rv;
|
|
|
|
|
|
|
|
|
|
nsCOMPtr<nsIIOService> ios = do_GetIOService(&rv);
|
2015-10-20 01:24:36 +00:00
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2014-12-10 08:51:59 +00:00
|
|
|
|
|
|
|
|
|
nsAutoCString url;
|
2014-12-10 06:35:22 +00:00
|
|
|
|
mRequest->GetURL(url);
|
2014-12-10 08:51:59 +00:00
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
2019-07-15 13:39:51 +00:00
|
|
|
|
rv = NS_NewURI(getter_AddRefs(uri), url);
|
2015-10-20 01:24:36 +00:00
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
2015-12-06 23:33:14 +00:00
|
|
|
|
// Unsafe requests aren't allowed with when using no-core mode.
|
|
|
|
|
if (mRequest->Mode() == RequestMode::No_cors && mRequest->UnsafeRequest() &&
|
|
|
|
|
(!mRequest->HasSimpleMethod() ||
|
|
|
|
|
!mRequest->Headers()->HasOnlySimpleHeaders())) {
|
|
|
|
|
MOZ_ASSERT(false, "The API should have caught this");
|
|
|
|
|
return NS_ERROR_DOM_BAD_URI;
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-06 09:13:19 +00:00
|
|
|
|
// non-GET requests aren't allowed for blob.
|
|
|
|
|
if (IsBlobURI(uri)) {
|
|
|
|
|
nsAutoCString method;
|
|
|
|
|
mRequest->GetMethod(method);
|
|
|
|
|
if (!method.EqualsLiteral("GET")) {
|
|
|
|
|
return NS_ERROR_DOM_NETWORK_ERR;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-07 23:50:54 +00:00
|
|
|
|
// Step 2 deals with letting ServiceWorkers intercept requests. This is
|
|
|
|
|
// handled by Necko after the channel is opened.
|
|
|
|
|
// FIXME(nsm): Bug 1119026: The channel's skip service worker flag should be
|
|
|
|
|
// set based on the Request's flag.
|
|
|
|
|
|
2015-01-15 22:28:14 +00:00
|
|
|
|
// Step 3.1 "If the CORS preflight flag is set and one of these conditions is
|
|
|
|
|
// true..." is handled by the CORS proxy.
|
|
|
|
|
//
|
|
|
|
|
// Step 3.2 "Set request's skip service worker flag." This isn't required
|
|
|
|
|
// since Necko will fall back to the network if the ServiceWorker does not
|
|
|
|
|
// respond with a valid Response.
|
|
|
|
|
//
|
|
|
|
|
// NS_StartCORSPreflight() will automatically kick off the original request
|
|
|
|
|
// if it succeeds, so we need to have everything setup for the original
|
|
|
|
|
// request too.
|
|
|
|
|
|
2015-10-07 21:33:31 +00:00
|
|
|
|
// Step 3.3 "Let credentials flag be set if one of
|
|
|
|
|
// - request's credentials mode is "include"
|
|
|
|
|
// - request's credentials mode is "same-origin" and either the CORS flag
|
|
|
|
|
// is unset or response tainting is "opaque"
|
|
|
|
|
// is true, and unset otherwise."
|
2015-01-15 22:28:14 +00:00
|
|
|
|
|
2015-10-06 13:37:07 +00:00
|
|
|
|
// Set skip serviceworker flag.
|
|
|
|
|
// While the spec also gates on the client being a ServiceWorker, we can't
|
|
|
|
|
// infer that here. Instead we rely on callers to set the flag correctly.
|
|
|
|
|
const nsLoadFlags bypassFlag = mRequest->SkipServiceWorker()
|
|
|
|
|
? nsIChannel::LOAD_BYPASS_SERVICE_WORKER
|
|
|
|
|
: 0;
|
|
|
|
|
|
2018-08-04 01:52:36 +00:00
|
|
|
|
nsSecurityFlags secFlags = 0;
|
2015-12-06 23:33:15 +00:00
|
|
|
|
if (mRequest->Mode() == RequestMode::Cors) {
|
|
|
|
|
secFlags |= nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS;
|
2016-01-13 23:15:37 +00:00
|
|
|
|
} else if (mRequest->Mode() == RequestMode::Same_origin ||
|
|
|
|
|
mRequest->Mode() == RequestMode::Navigate) {
|
2015-12-06 23:33:15 +00:00
|
|
|
|
secFlags |= nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_INHERITS;
|
2015-10-20 01:24:36 +00:00
|
|
|
|
} else if (mRequest->Mode() == RequestMode::No_cors) {
|
2015-12-06 23:33:15 +00:00
|
|
|
|
secFlags |= nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS;
|
2015-10-20 01:24:36 +00:00
|
|
|
|
} else {
|
|
|
|
|
MOZ_ASSERT_UNREACHABLE("Unexpected request mode!");
|
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-24 02:47:10 +00:00
|
|
|
|
if (mRequest->GetRedirectMode() != RequestRedirect::Follow) {
|
|
|
|
|
secFlags |= nsILoadInfo::SEC_DONT_FOLLOW_REDIRECTS;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-06 23:33:15 +00:00
|
|
|
|
// This is handles the use credentials flag in "HTTP
|
|
|
|
|
// network or cache fetch" in the spec and decides whether to transmit
|
|
|
|
|
// cookies and other identifying information.
|
|
|
|
|
if (mRequest->GetCredentialsMode() == RequestCredentials::Include) {
|
|
|
|
|
secFlags |= nsILoadInfo::SEC_COOKIES_INCLUDE;
|
|
|
|
|
} else if (mRequest->GetCredentialsMode() == RequestCredentials::Omit) {
|
|
|
|
|
secFlags |= nsILoadInfo::SEC_COOKIES_OMIT;
|
|
|
|
|
} else if (mRequest->GetCredentialsMode() ==
|
|
|
|
|
RequestCredentials::Same_origin) {
|
|
|
|
|
secFlags |= nsILoadInfo::SEC_COOKIES_SAME_ORIGIN;
|
|
|
|
|
} else {
|
|
|
|
|
MOZ_ASSERT_UNREACHABLE("Unexpected credentials mode!");
|
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-07 23:50:54 +00:00
|
|
|
|
// From here on we create a channel and set its properties with the
|
|
|
|
|
// information from the InternalRequest. This is an implementation detail.
|
2015-01-08 16:55:05 +00:00
|
|
|
|
MOZ_ASSERT(mLoadGroup);
|
2014-12-10 08:51:59 +00:00
|
|
|
|
nsCOMPtr<nsIChannel> chan;
|
2015-10-20 01:24:36 +00:00
|
|
|
|
|
2019-03-25 12:47:57 +00:00
|
|
|
|
nsLoadFlags loadFlags = nsIRequest::LOAD_BACKGROUND | bypassFlag;
|
2015-11-16 19:43:12 +00:00
|
|
|
|
if (mDocument) {
|
|
|
|
|
MOZ_ASSERT(mDocument->NodePrincipal() == mPrincipal);
|
2019-03-08 09:04:11 +00:00
|
|
|
|
MOZ_ASSERT(mDocument->CookieSettings() == mCookieSettings);
|
2015-10-20 01:24:36 +00:00
|
|
|
|
rv = NS_NewChannel(getter_AddRefs(chan), uri, mDocument, secFlags,
|
|
|
|
|
mRequest->ContentPolicyType(),
|
2018-01-24 16:17:31 +00:00
|
|
|
|
nullptr, /* aPerformanceStorage */
|
2015-10-20 01:24:36 +00:00
|
|
|
|
mLoadGroup, nullptr, /* aCallbacks */
|
2015-12-01 00:27:56 +00:00
|
|
|
|
loadFlags, ios);
|
2018-01-23 15:38:54 +00:00
|
|
|
|
} else if (mClientInfo.isSome()) {
|
2019-03-08 09:04:11 +00:00
|
|
|
|
rv = NS_NewChannel(getter_AddRefs(chan), uri, mPrincipal, mClientInfo.ref(),
|
|
|
|
|
mController, secFlags, mRequest->ContentPolicyType(),
|
|
|
|
|
mCookieSettings, mPerformanceStorage, mLoadGroup,
|
|
|
|
|
nullptr, /* aCallbacks */
|
|
|
|
|
loadFlags, ios);
|
|
|
|
|
} else {
|
2018-01-23 15:38:54 +00:00
|
|
|
|
rv =
|
2019-03-08 09:04:11 +00:00
|
|
|
|
NS_NewChannel(getter_AddRefs(chan), uri, mPrincipal, secFlags,
|
|
|
|
|
mRequest->ContentPolicyType(), mCookieSettings,
|
2018-01-23 15:38:54 +00:00
|
|
|
|
mPerformanceStorage, mLoadGroup, nullptr, /* aCallbacks */
|
|
|
|
|
loadFlags, ios);
|
2015-10-20 01:24:36 +00:00
|
|
|
|
}
|
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
2018-10-23 06:17:13 +00:00
|
|
|
|
if (mCSPEventListener) {
|
2019-02-20 12:27:25 +00:00
|
|
|
|
nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
|
2018-10-23 06:17:13 +00:00
|
|
|
|
rv = loadInfo->SetCspEventListener(mCSPEventListener);
|
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-19 21:54:15 +00:00
|
|
|
|
// Insert ourselves into the notification callbacks chain so we can set
|
|
|
|
|
// headers on redirects.
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
{
|
|
|
|
|
nsCOMPtr<nsIInterfaceRequestor> notificationCallbacks;
|
|
|
|
|
chan->GetNotificationCallbacks(getter_AddRefs(notificationCallbacks));
|
|
|
|
|
MOZ_ASSERT(!notificationCallbacks);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
chan->SetNotificationCallbacks(this);
|
|
|
|
|
|
2017-04-21 05:29:31 +00:00
|
|
|
|
nsCOMPtr<nsIClassOfService> cos(do_QueryInterface(chan));
|
|
|
|
|
// Mark channel as urgent-start if the Fetch is triggered by user input
|
|
|
|
|
// events.
|
|
|
|
|
if (cos && EventStateManager::IsHandlingUserInput()) {
|
|
|
|
|
cos->AddClassFlags(nsIClassOfService::UrgentStart);
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-07 23:50:54 +00:00
|
|
|
|
// Step 3.5 begins "HTTP network or cache fetch".
|
|
|
|
|
// HTTP network or cache fetch
|
|
|
|
|
// ---------------------------
|
|
|
|
|
// Step 1 "Let HTTPRequest..." The channel is the HTTPRequest.
|
2014-12-10 08:51:59 +00:00
|
|
|
|
nsCOMPtr<nsIHttpChannel> httpChan = do_QueryInterface(chan);
|
|
|
|
|
if (httpChan) {
|
2015-01-07 23:50:54 +00:00
|
|
|
|
// Copy the method.
|
2014-12-10 08:51:59 +00:00
|
|
|
|
nsAutoCString method;
|
|
|
|
|
mRequest->GetMethod(method);
|
|
|
|
|
rv = httpChan->SetRequestMethod(method);
|
2015-10-20 01:24:36 +00:00
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2014-12-10 06:35:22 +00:00
|
|
|
|
|
2015-01-07 23:50:54 +00:00
|
|
|
|
// Set the same headers.
|
2016-01-19 21:54:15 +00:00
|
|
|
|
SetRequestHeaders(httpChan);
|
2015-10-26 15:25:16 +00:00
|
|
|
|
|
2018-01-18 15:57:14 +00:00
|
|
|
|
// Step 5 of https://fetch.spec.whatwg.org/#main-fetch
|
2016-11-14 07:15:32 +00:00
|
|
|
|
// If request's referrer policy is the empty string and request's client is
|
|
|
|
|
// non-null, then set request's referrer policy to request's client's
|
|
|
|
|
// associated referrer policy.
|
|
|
|
|
// Basically, "client" is not in our implementation, we use
|
|
|
|
|
// EnvironmentReferrerPolicy of the worker or document context
|
2018-01-16 21:26:26 +00:00
|
|
|
|
net::ReferrerPolicy net_referrerPolicy =
|
|
|
|
|
mRequest->GetEnvironmentReferrerPolicy();
|
2016-11-14 07:15:32 +00:00
|
|
|
|
if (mRequest->ReferrerPolicy_() == ReferrerPolicy::_empty) {
|
|
|
|
|
mRequest->SetReferrerPolicy(net_referrerPolicy);
|
2016-02-26 22:36:45 +00:00
|
|
|
|
}
|
2018-01-18 15:57:14 +00:00
|
|
|
|
// Step 6 of https://fetch.spec.whatwg.org/#main-fetch
|
2016-11-14 07:15:32 +00:00
|
|
|
|
// If request’s referrer policy is the empty string,
|
2018-01-16 21:26:26 +00:00
|
|
|
|
// then set request’s referrer policy to the user-set default policy.
|
2016-11-14 07:15:32 +00:00
|
|
|
|
if (mRequest->ReferrerPolicy_() == ReferrerPolicy::_empty) {
|
2019-02-20 12:27:25 +00:00
|
|
|
|
nsCOMPtr<nsILoadInfo> loadInfo = httpChan->LoadInfo();
|
2018-01-18 15:57:14 +00:00
|
|
|
|
bool isPrivate = loadInfo->GetOriginAttributes().mPrivateBrowsingId > 0;
|
|
|
|
|
net::ReferrerPolicy referrerPolicy = static_cast<net::ReferrerPolicy>(
|
2019-05-02 12:33:55 +00:00
|
|
|
|
ReferrerInfo::GetDefaultReferrerPolicy(httpChan, uri, isPrivate));
|
2017-01-05 03:30:07 +00:00
|
|
|
|
mRequest->SetReferrerPolicy(referrerPolicy);
|
2014-12-10 06:35:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2016-11-14 07:15:32 +00:00
|
|
|
|
rv = FetchUtil::SetRequestReferrer(mPrincipal, mDocument, httpChan,
|
|
|
|
|
mRequest);
|
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
2015-01-07 23:50:54 +00:00
|
|
|
|
// Bug 1120722 - Authorization will be handled later.
|
|
|
|
|
// Auth may require prompting, we don't support it yet.
|
|
|
|
|
// The next patch in this same bug prevents this from aborting the request.
|
|
|
|
|
// Credentials checks for CORS are handled by nsCORSListenerProxy,
|
2015-08-31 21:26:29 +00:00
|
|
|
|
|
|
|
|
|
nsCOMPtr<nsIHttpChannelInternal> internalChan = do_QueryInterface(httpChan);
|
|
|
|
|
|
|
|
|
|
// Conversion between enumerations is safe due to static asserts in
|
|
|
|
|
// dom/workers/ServiceWorkerManager.cpp
|
2016-12-20 03:49:32 +00:00
|
|
|
|
rv = internalChan->SetCorsMode(static_cast<uint32_t>(mRequest->Mode()));
|
|
|
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
|
|
|
|
rv = internalChan->SetRedirectMode(
|
|
|
|
|
static_cast<uint32_t>(mRequest->GetRedirectMode()));
|
|
|
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
2016-03-02 23:09:30 +00:00
|
|
|
|
mRequest->MaybeSkipCacheIfPerformingRevalidation();
|
2016-12-20 03:49:32 +00:00
|
|
|
|
rv = internalChan->SetFetchCacheMode(
|
|
|
|
|
static_cast<uint32_t>(mRequest->GetCacheMode()));
|
|
|
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
|
|
|
|
rv = internalChan->SetIntegrityMetadata(mRequest->GetIntegrity());
|
|
|
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
2018-01-24 11:45:59 +00:00
|
|
|
|
|
|
|
|
|
// Set the initiator type
|
|
|
|
|
nsCOMPtr<nsITimedChannel> timedChannel(do_QueryInterface(httpChan));
|
|
|
|
|
if (timedChannel) {
|
|
|
|
|
timedChannel->SetInitiatorType(NS_LITERAL_STRING("fetch"));
|
|
|
|
|
}
|
2014-12-10 08:51:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
2015-01-07 23:50:54 +00:00
|
|
|
|
// Step 5. Proxy authentication will be handled by Necko.
|
|
|
|
|
|
|
|
|
|
// Continue setting up 'HTTPRequest'. Content-Type and body data.
|
2014-12-10 06:35:22 +00:00
|
|
|
|
nsCOMPtr<nsIUploadChannel2> uploadChan = do_QueryInterface(chan);
|
|
|
|
|
if (uploadChan) {
|
|
|
|
|
nsAutoCString contentType;
|
|
|
|
|
ErrorResult result;
|
2016-10-10 17:20:14 +00:00
|
|
|
|
mRequest->Headers()->GetFirst(NS_LITERAL_CSTRING("content-type"),
|
|
|
|
|
contentType, result);
|
2017-01-15 03:43:17 +00:00
|
|
|
|
// We don't actually expect "result" to have failed here: that only happens
|
|
|
|
|
// for invalid header names. But if for some reason it did, just propagate
|
|
|
|
|
// it out.
|
2014-12-10 06:35:22 +00:00
|
|
|
|
if (result.Failed()) {
|
2015-10-20 01:24:36 +00:00
|
|
|
|
return result.StealNSResult();
|
2014-12-10 06:35:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-01-15 03:43:17 +00:00
|
|
|
|
// Now contentType is the header that was set in mRequest->Headers(), or a
|
|
|
|
|
// void string if no header was set.
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
bool hasContentTypeHeader =
|
|
|
|
|
mRequest->Headers()->Has(NS_LITERAL_CSTRING("content-type"), result);
|
|
|
|
|
MOZ_ASSERT(!result.Failed());
|
|
|
|
|
MOZ_ASSERT_IF(!hasContentTypeHeader, contentType.IsVoid());
|
|
|
|
|
#endif // DEBUG
|
|
|
|
|
|
2017-09-08 14:06:26 +00:00
|
|
|
|
int64_t bodyLength;
|
2014-12-10 06:35:22 +00:00
|
|
|
|
nsCOMPtr<nsIInputStream> bodyStream;
|
2017-09-08 14:06:26 +00:00
|
|
|
|
mRequest->GetBody(getter_AddRefs(bodyStream), &bodyLength);
|
2014-12-10 06:35:22 +00:00
|
|
|
|
if (bodyStream) {
|
|
|
|
|
nsAutoCString method;
|
|
|
|
|
mRequest->GetMethod(method);
|
2017-09-08 14:06:26 +00:00
|
|
|
|
rv = uploadChan->ExplicitSetUploadStream(bodyStream, contentType,
|
|
|
|
|
bodyLength, method,
|
|
|
|
|
false /* aStreamHasHeaders */);
|
2015-10-20 01:24:36 +00:00
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
2014-12-10 06:35:22 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2015-01-07 23:50:54 +00:00
|
|
|
|
|
|
|
|
|
// If preflight is required, start a "CORS preflight fetch"
|
|
|
|
|
// https://fetch.spec.whatwg.org/#cors-preflight-fetch-0. All the
|
2015-10-20 01:24:36 +00:00
|
|
|
|
// implementation is handled by the http channel calling into
|
|
|
|
|
// nsCORSListenerProxy. We just inform it which unsafe headers are included
|
|
|
|
|
// in the request.
|
2015-12-06 23:33:14 +00:00
|
|
|
|
if (mRequest->Mode() == RequestMode::Cors) {
|
2016-02-02 15:36:30 +00:00
|
|
|
|
AutoTArray<nsCString, 5> unsafeHeaders;
|
2015-01-07 23:50:54 +00:00
|
|
|
|
mRequest->Headers()->GetUnsafeHeaders(unsafeHeaders);
|
2019-02-20 12:27:25 +00:00
|
|
|
|
nsCOMPtr<nsILoadInfo> loadInfo = chan->LoadInfo();
|
|
|
|
|
loadInfo->SetCorsPreflightInfo(unsafeHeaders, false);
|
2015-01-07 23:50:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-05-01 21:10:31 +00:00
|
|
|
|
if (mIsTrackingFetch && StaticPrefs::network_http_tailing_enabled() && cos) {
|
2017-08-30 13:32:00 +00:00
|
|
|
|
cos->AddClassFlags(nsIClassOfService::Throttleable |
|
|
|
|
|
nsIClassOfService::Tail);
|
2017-08-31 10:07:00 +00:00
|
|
|
|
}
|
2017-08-30 13:32:00 +00:00
|
|
|
|
|
2018-12-14 11:40:16 +00:00
|
|
|
|
if (mIsTrackingFetch &&
|
|
|
|
|
StaticPrefs::privacy_trackingprotection_lower_network_priority()) {
|
2017-05-19 05:29:00 +00:00
|
|
|
|
nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(chan);
|
|
|
|
|
if (p) {
|
|
|
|
|
p->SetPriority(nsISupportsPriority::PRIORITY_LOWEST);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-15 16:46:22 +00:00
|
|
|
|
NotifyNetworkMonitorAlternateStack(chan, std::move(mOriginStack));
|
|
|
|
|
|
2017-12-04 06:39:15 +00:00
|
|
|
|
// if the preferred alternative data type in InternalRequest is not empty, set
|
|
|
|
|
// the data type on the created channel and also create a
|
|
|
|
|
// AlternativeDataStreamListener to be the stream listener of the channel.
|
|
|
|
|
if (!aPreferredAlternativeDataType.IsEmpty()) {
|
|
|
|
|
nsCOMPtr<nsICacheInfoChannel> cic = do_QueryInterface(chan);
|
|
|
|
|
if (cic) {
|
Bug 1487100 - Allow calling nsICacheInfoChannel.preferAlternativeDataType(altDataType, contentType) multiple times r=michal,luke
This patch changes the way we set and handle the preferred alternate data type.
It is no longer just one choice, but a set of preferences, each conditional
on the contentType of the resource.
For example:
var cc = chan.QueryInterface(Ci.nsICacheInfoChannel);
cc.preferAlternativeDataType("js-bytecode", "text/javascript");
cc.preferAlternativeDataType("ammended-text", "text/plain");
cc.preferAlternativeDataType("something-else", "");
When loaded from the cache, the available alt-data type will be checked against
"js-bytecode" if the contentType is "text/javascript", "ammended-text" if the contentType is "text/plain" or "something-else" for all contentTypes.
Note that the alt-data type could be "something-else" even if the contentType is "text/javascript".
The preferences are saved as an nsTArray<mozilla::Tuple<nsCString, nsCString>>.
Differential Revision: https://phabricator.services.mozilla.com/D8071
--HG--
extra : rebase_source : eb4961f05a52e557e7d2d986d59e0a2cf18a3447
extra : source : dd1c31ea78c2b15d14750d137037a54d50719997
2018-10-17 13:58:30 +00:00
|
|
|
|
cic->PreferAlternativeDataType(aPreferredAlternativeDataType,
|
2019-02-20 10:05:42 +00:00
|
|
|
|
EmptyCString(), true);
|
2017-12-04 06:39:15 +00:00
|
|
|
|
MOZ_ASSERT(!mAltDataListener);
|
|
|
|
|
mAltDataListener = new AlternativeDataStreamListener(
|
|
|
|
|
this, chan, aPreferredAlternativeDataType);
|
2019-02-12 16:08:25 +00:00
|
|
|
|
rv = chan->AsyncOpen(mAltDataListener);
|
2017-12-04 06:39:15 +00:00
|
|
|
|
} else {
|
2019-02-12 16:08:25 +00:00
|
|
|
|
rv = chan->AsyncOpen(this);
|
2017-12-04 06:39:15 +00:00
|
|
|
|
}
|
|
|
|
|
} else {
|
2019-02-20 10:05:35 +00:00
|
|
|
|
// Integrity check cannot be done on alt-data yet.
|
|
|
|
|
if (mRequest->GetIntegrity().IsEmpty()) {
|
|
|
|
|
nsCOMPtr<nsICacheInfoChannel> cic = do_QueryInterface(chan);
|
|
|
|
|
if (cic) {
|
|
|
|
|
cic->PreferAlternativeDataType(
|
|
|
|
|
NS_LITERAL_CSTRING(WASM_ALT_DATA_TYPE_V1),
|
2019-02-20 10:05:42 +00:00
|
|
|
|
NS_LITERAL_CSTRING(WASM_CONTENT_TYPE), false);
|
2019-02-20 10:05:35 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-12 16:08:25 +00:00
|
|
|
|
rv = chan->AsyncOpen(this);
|
2017-12-04 06:39:15 +00:00
|
|
|
|
}
|
2019-02-20 10:05:35 +00:00
|
|
|
|
|
2018-02-09 22:04:03 +00:00
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
2015-10-20 01:24:36 +00:00
|
|
|
|
|
2015-01-07 23:50:54 +00:00
|
|
|
|
// Step 4 onwards of "HTTP Fetch" is handled internally by Necko.
|
2017-03-22 10:06:08 +00:00
|
|
|
|
|
|
|
|
|
mChannel = chan;
|
2015-01-07 23:50:54 +00:00
|
|
|
|
return NS_OK;
|
2014-12-10 08:51:59 +00:00
|
|
|
|
}
|
2015-11-24 02:47:10 +00:00
|
|
|
|
already_AddRefed<InternalResponse> FetchDriver::BeginAndGetFilteredResponse(
|
|
|
|
|
InternalResponse* aResponse, bool aFoundOpaqueRedirect) {
|
2014-10-06 18:01:20 +00:00
|
|
|
|
MOZ_ASSERT(aResponse);
|
2016-05-03 01:48:40 +00:00
|
|
|
|
AutoTArray<nsCString, 4> reqURLList;
|
2016-11-07 02:16:34 +00:00
|
|
|
|
mRequest->GetURLListWithoutFragment(reqURLList);
|
2016-05-03 01:48:40 +00:00
|
|
|
|
MOZ_ASSERT(!reqURLList.IsEmpty());
|
|
|
|
|
aResponse->SetURLList(reqURLList);
|
2015-10-18 05:24:48 +00:00
|
|
|
|
RefPtr<InternalResponse> filteredResponse;
|
2015-11-24 02:47:10 +00:00
|
|
|
|
if (aFoundOpaqueRedirect) {
|
2015-10-22 18:07:32 +00:00
|
|
|
|
filteredResponse = aResponse->OpaqueRedirectResponse();
|
|
|
|
|
} else {
|
|
|
|
|
switch (mRequest->GetResponseTainting()) {
|
2015-10-22 18:07:32 +00:00
|
|
|
|
case LoadTainting::Basic:
|
2015-10-22 18:07:32 +00:00
|
|
|
|
filteredResponse = aResponse->BasicResponse();
|
|
|
|
|
break;
|
2015-10-22 18:07:32 +00:00
|
|
|
|
case LoadTainting::CORS:
|
2015-10-22 18:07:32 +00:00
|
|
|
|
filteredResponse = aResponse->CORSResponse();
|
|
|
|
|
break;
|
2017-07-10 09:03:24 +00:00
|
|
|
|
case LoadTainting::Opaque: {
|
2015-10-22 18:07:32 +00:00
|
|
|
|
filteredResponse = aResponse->OpaqueResponse();
|
2017-07-10 09:03:24 +00:00
|
|
|
|
nsresult rv = filteredResponse->GeneratePaddingInfo();
|
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
|
|
|
return nullptr;
|
|
|
|
|
}
|
2015-10-22 18:07:32 +00:00
|
|
|
|
break;
|
2017-07-10 09:03:24 +00:00
|
|
|
|
}
|
2015-10-22 18:07:32 +00:00
|
|
|
|
default:
|
|
|
|
|
MOZ_CRASH("Unexpected case");
|
|
|
|
|
}
|
2014-10-06 18:01:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MOZ_ASSERT(filteredResponse);
|
2015-01-07 23:50:54 +00:00
|
|
|
|
MOZ_ASSERT(mObserver);
|
2017-08-25 08:36:59 +00:00
|
|
|
|
if (!ShouldCheckSRI(mRequest, filteredResponse)) {
|
2016-09-07 02:20:23 +00:00
|
|
|
|
mObserver->OnResponseAvailable(filteredResponse);
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
mResponseAvailableCalled = true;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-10 08:51:59 +00:00
|
|
|
|
return filteredResponse.forget();
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-15 19:53:42 +00:00
|
|
|
|
void FetchDriver::FailWithNetworkError(nsresult rv) {
|
2018-02-05 18:55:07 +00:00
|
|
|
|
AssertIsOnMainThread();
|
2017-11-15 19:53:42 +00:00
|
|
|
|
RefPtr<InternalResponse> error = InternalResponse::NetworkError(rv);
|
2015-01-07 23:50:54 +00:00
|
|
|
|
if (mObserver) {
|
|
|
|
|
mObserver->OnResponseAvailable(error);
|
2016-02-26 15:52:06 +00:00
|
|
|
|
#ifdef DEBUG
|
2015-01-07 23:50:54 +00:00
|
|
|
|
mResponseAvailableCalled = true;
|
2016-02-26 15:52:06 +00:00
|
|
|
|
#endif
|
2017-03-22 10:06:08 +00:00
|
|
|
|
mObserver->OnResponseEnd(FetchDriverObserver::eByNetworking);
|
2015-01-07 23:50:54 +00:00
|
|
|
|
mObserver = nullptr;
|
|
|
|
|
}
|
2017-03-22 10:06:08 +00:00
|
|
|
|
|
|
|
|
|
mChannel = nullptr;
|
2014-12-10 08:51:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2019-02-27 23:41:04 +00:00
|
|
|
|
FetchDriver::OnStartRequest(nsIRequest* aRequest) {
|
2018-02-05 18:55:07 +00:00
|
|
|
|
AssertIsOnMainThread();
|
2015-08-31 21:26:29 +00:00
|
|
|
|
|
|
|
|
|
// Note, this can be called multiple times if we are doing an opaqueredirect.
|
|
|
|
|
// In that case we will get a simulated OnStartRequest() and then the real
|
|
|
|
|
// channel will call in with an errored OnStartRequest().
|
|
|
|
|
|
2018-02-26 21:32:15 +00:00
|
|
|
|
if (!mChannel) {
|
|
|
|
|
MOZ_ASSERT(!mObserver);
|
|
|
|
|
return NS_BINDING_ABORTED;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-10 08:51:59 +00:00
|
|
|
|
nsresult rv;
|
|
|
|
|
aRequest->GetStatus(&rv);
|
2016-03-11 19:18:07 +00:00
|
|
|
|
if (NS_FAILED(rv)) {
|
2017-11-15 19:53:42 +00:00
|
|
|
|
FailWithNetworkError(rv);
|
2014-12-10 08:51:59 +00:00
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-31 21:26:29 +00:00
|
|
|
|
// We should only get to the following code once.
|
|
|
|
|
MOZ_ASSERT(!mPipeOutputStream);
|
2019-08-15 12:52:54 +00:00
|
|
|
|
|
|
|
|
|
if (!mObserver) {
|
|
|
|
|
MOZ_ASSERT(false, "We should have mObserver here.");
|
|
|
|
|
FailWithNetworkError(NS_ERROR_UNEXPECTED);
|
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
|
}
|
2015-08-31 21:26:29 +00:00
|
|
|
|
|
2017-10-13 02:23:16 +00:00
|
|
|
|
mNeedToObserveOnDataAvailable = mObserver->NeedOnDataAvailable();
|
|
|
|
|
|
2015-10-18 05:24:48 +00:00
|
|
|
|
RefPtr<InternalResponse> response;
|
2015-10-20 01:24:36 +00:00
|
|
|
|
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
|
2015-05-07 18:42:07 +00:00
|
|
|
|
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest);
|
2015-10-20 01:24:36 +00:00
|
|
|
|
|
2015-12-06 23:33:15 +00:00
|
|
|
|
// On a successful redirect we perform the following substeps of HTTP Fetch,
|
|
|
|
|
// step 5, "redirect status", step 11.
|
|
|
|
|
|
2015-11-24 02:47:10 +00:00
|
|
|
|
bool foundOpaqueRedirect = false;
|
|
|
|
|
|
2019-02-20 10:05:35 +00:00
|
|
|
|
nsAutoCString contentType;
|
|
|
|
|
channel->GetContentType(contentType);
|
|
|
|
|
|
2016-06-01 21:02:29 +00:00
|
|
|
|
int64_t contentLength = InternalResponse::UNKNOWN_BODY_SIZE;
|
|
|
|
|
rv = channel->GetContentLength(&contentLength);
|
|
|
|
|
MOZ_ASSERT_IF(NS_FAILED(rv),
|
|
|
|
|
contentLength == InternalResponse::UNKNOWN_BODY_SIZE);
|
|
|
|
|
|
2015-05-07 18:42:07 +00:00
|
|
|
|
if (httpChannel) {
|
|
|
|
|
uint32_t responseStatus;
|
2016-12-20 03:49:32 +00:00
|
|
|
|
rv = httpChannel->GetResponseStatus(&responseStatus);
|
|
|
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
2014-12-10 08:51:59 +00:00
|
|
|
|
|
2015-11-24 02:47:10 +00:00
|
|
|
|
if (mozilla::net::nsHttpChannel::IsRedirectStatus(responseStatus)) {
|
|
|
|
|
if (mRequest->GetRedirectMode() == RequestRedirect::Error) {
|
2017-11-15 19:53:42 +00:00
|
|
|
|
FailWithNetworkError(NS_BINDING_ABORTED);
|
2015-11-24 02:47:10 +00:00
|
|
|
|
return NS_BINDING_FAILED;
|
|
|
|
|
}
|
|
|
|
|
if (mRequest->GetRedirectMode() == RequestRedirect::Manual) {
|
|
|
|
|
foundOpaqueRedirect = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-07 18:42:07 +00:00
|
|
|
|
nsAutoCString statusText;
|
2016-12-20 03:49:32 +00:00
|
|
|
|
rv = httpChannel->GetResponseStatusText(statusText);
|
|
|
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
2014-12-10 06:35:22 +00:00
|
|
|
|
|
2019-07-16 08:50:14 +00:00
|
|
|
|
response = new InternalResponse(responseStatus, statusText,
|
|
|
|
|
mRequest->GetCredentialsMode());
|
2014-12-10 08:51:59 +00:00
|
|
|
|
|
2018-12-19 14:48:29 +00:00
|
|
|
|
UniquePtr<mozilla::ipc::PrincipalInfo> principalInfo(
|
|
|
|
|
new mozilla::ipc::PrincipalInfo());
|
|
|
|
|
nsresult rv = PrincipalToPrincipalInfo(mPrincipal, principalInfo.get());
|
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
response->SetPrincipalInfo(std::move(principalInfo));
|
|
|
|
|
|
2017-02-14 15:06:39 +00:00
|
|
|
|
response->Headers()->FillResponseHeaders(httpChannel);
|
2016-06-01 21:02:29 +00:00
|
|
|
|
|
|
|
|
|
// If Content-Encoding or Transfer-Encoding headers are set, then the actual
|
|
|
|
|
// Content-Length (which refer to the decoded data) is obscured behind the
|
|
|
|
|
// encodings.
|
|
|
|
|
ErrorResult result;
|
|
|
|
|
if (response->Headers()->Has(NS_LITERAL_CSTRING("content-encoding"),
|
|
|
|
|
result) ||
|
|
|
|
|
response->Headers()->Has(NS_LITERAL_CSTRING("transfer-encoding"),
|
|
|
|
|
result)) {
|
2018-02-12 22:54:14 +00:00
|
|
|
|
// We cannot trust the content-length when content-encoding or
|
|
|
|
|
// transfer-encoding are set. There are many servers which just
|
|
|
|
|
// get this wrong.
|
2016-06-01 21:02:29 +00:00
|
|
|
|
contentLength = InternalResponse::UNKNOWN_BODY_SIZE;
|
|
|
|
|
}
|
|
|
|
|
MOZ_ASSERT(!result.Failed());
|
2015-10-20 01:24:36 +00:00
|
|
|
|
} else {
|
2019-07-16 08:50:14 +00:00
|
|
|
|
response = new InternalResponse(200, NS_LITERAL_CSTRING("OK"),
|
|
|
|
|
mRequest->GetCredentialsMode());
|
2015-10-20 01:24:36 +00:00
|
|
|
|
|
2019-02-20 10:05:35 +00:00
|
|
|
|
if (!contentType.IsEmpty()) {
|
2015-10-20 01:24:36 +00:00
|
|
|
|
nsAutoCString contentCharset;
|
|
|
|
|
channel->GetContentCharset(contentCharset);
|
|
|
|
|
if (NS_SUCCEEDED(rv) && !contentCharset.IsEmpty()) {
|
|
|
|
|
contentType += NS_LITERAL_CSTRING(";charset=") + contentCharset;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-20 10:05:35 +00:00
|
|
|
|
IgnoredErrorResult result;
|
2015-10-20 01:24:36 +00:00
|
|
|
|
response->Headers()->Append(NS_LITERAL_CSTRING("Content-Type"),
|
|
|
|
|
contentType, result);
|
|
|
|
|
MOZ_ASSERT(!result.Failed());
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-01 21:02:29 +00:00
|
|
|
|
if (contentLength > 0) {
|
2015-10-20 01:24:36 +00:00
|
|
|
|
nsAutoCString contentLenStr;
|
|
|
|
|
contentLenStr.AppendInt(contentLength);
|
2019-02-20 10:05:35 +00:00
|
|
|
|
|
|
|
|
|
IgnoredErrorResult result;
|
2015-10-20 01:24:36 +00:00
|
|
|
|
response->Headers()->Append(NS_LITERAL_CSTRING("Content-Length"),
|
|
|
|
|
contentLenStr, result);
|
|
|
|
|
MOZ_ASSERT(!result.Failed());
|
|
|
|
|
}
|
2014-12-10 08:51:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-12-04 06:39:15 +00:00
|
|
|
|
nsCOMPtr<nsICacheInfoChannel> cic = do_QueryInterface(aRequest);
|
2019-02-20 10:05:35 +00:00
|
|
|
|
if (cic) {
|
|
|
|
|
if (mAltDataListener) {
|
|
|
|
|
// Skip the case that mAltDataListener->Status() equals to FALLBACK, that
|
|
|
|
|
// means the opened channel for alternative data loading is reused for
|
|
|
|
|
// loading the main data.
|
|
|
|
|
if (mAltDataListener->Status() !=
|
|
|
|
|
AlternativeDataStreamListener::FALLBACK) {
|
|
|
|
|
// Verify the cache ID is the same with from alternative data cache.
|
|
|
|
|
// If the cache ID is different, droping the alternative data loading,
|
|
|
|
|
// otherwise setup the response's alternative body and cacheInfoChannel.
|
|
|
|
|
uint64_t cacheEntryId = 0;
|
|
|
|
|
if (NS_SUCCEEDED(cic->GetCacheEntryId(&cacheEntryId)) &&
|
|
|
|
|
cacheEntryId !=
|
|
|
|
|
mAltDataListener->GetAlternativeDataCacheEntryId()) {
|
|
|
|
|
mAltDataListener->Cancel();
|
|
|
|
|
} else {
|
|
|
|
|
// AlternativeDataStreamListener::OnStartRequest had already been
|
|
|
|
|
// called, the alternative data input stream and cacheInfo channel
|
|
|
|
|
// must be created.
|
|
|
|
|
nsCOMPtr<nsICacheInfoChannel> cacheInfo =
|
|
|
|
|
mAltDataListener->GetCacheInfoChannel();
|
|
|
|
|
nsCOMPtr<nsIInputStream> altInputStream =
|
|
|
|
|
mAltDataListener->GetAlternativeInputStream();
|
|
|
|
|
MOZ_ASSERT(altInputStream && cacheInfo);
|
|
|
|
|
response->SetAlternativeBody(altInputStream);
|
|
|
|
|
nsMainThreadPtrHandle<nsICacheInfoChannel> handle(
|
|
|
|
|
new nsMainThreadPtrHolder<nsICacheInfoChannel>(
|
|
|
|
|
"nsICacheInfoChannel", cacheInfo, false));
|
|
|
|
|
response->SetCacheInfoChannel(handle);
|
|
|
|
|
}
|
|
|
|
|
} else if (!mAltDataListener->GetAlternativeDataType().IsEmpty()) {
|
|
|
|
|
// If the status is FALLBACK and the
|
|
|
|
|
// mAltDataListener::mAlternativeDataType is not empty, that means the
|
|
|
|
|
// data need to be saved into cache, setup the response's
|
|
|
|
|
// nsICacheInfoChannel for caching the data after loading.
|
|
|
|
|
nsMainThreadPtrHandle<nsICacheInfoChannel> handle(
|
|
|
|
|
new nsMainThreadPtrHolder<nsICacheInfoChannel>(
|
|
|
|
|
"nsICacheInfoChannel", cic, false));
|
|
|
|
|
response->SetCacheInfoChannel(handle);
|
|
|
|
|
}
|
|
|
|
|
} else if (!cic->PreferredAlternativeDataTypes().IsEmpty()) {
|
|
|
|
|
MOZ_ASSERT(cic->PreferredAlternativeDataTypes().Length() == 1);
|
2019-02-20 10:05:42 +00:00
|
|
|
|
MOZ_ASSERT(cic->PreferredAlternativeDataTypes()[0].type().EqualsLiteral(
|
|
|
|
|
WASM_ALT_DATA_TYPE_V1));
|
|
|
|
|
MOZ_ASSERT(
|
|
|
|
|
cic->PreferredAlternativeDataTypes()[0].contentType().EqualsLiteral(
|
|
|
|
|
WASM_CONTENT_TYPE));
|
2019-02-20 10:05:35 +00:00
|
|
|
|
|
|
|
|
|
if (contentType.EqualsLiteral(WASM_CONTENT_TYPE)) {
|
|
|
|
|
// We want to attach the CacheInfoChannel to the response object such
|
|
|
|
|
// that we can track its origin when the Response object is manipulated
|
|
|
|
|
// by JavaScript code. This is important for WebAssembly, which uses
|
|
|
|
|
// fetch to query its sources in JavaScript and transfer the Response
|
|
|
|
|
// object to other function responsible for storing the alternate data
|
|
|
|
|
// using the CacheInfoChannel.
|
2017-12-05 17:13:54 +00:00
|
|
|
|
nsMainThreadPtrHandle<nsICacheInfoChannel> handle(
|
|
|
|
|
new nsMainThreadPtrHolder<nsICacheInfoChannel>(
|
2019-02-20 10:05:35 +00:00
|
|
|
|
"nsICacheInfoChannel", cic, false));
|
2017-12-05 17:13:54 +00:00
|
|
|
|
response->SetCacheInfoChannel(handle);
|
2017-12-04 06:39:26 +00:00
|
|
|
|
}
|
2017-12-04 06:39:15 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-10 08:51:59 +00:00
|
|
|
|
// We open a pipe so that we can immediately set the pipe's read end as the
|
|
|
|
|
// response's body. Setting the segment size to UINT32_MAX means that the
|
|
|
|
|
// pipe has infinite space. The nsIChannel will continue to buffer data in
|
|
|
|
|
// xpcom events even if we block on a fixed size pipe. It might be possible
|
|
|
|
|
// to suspend the channel and then resume when there is space available, but
|
|
|
|
|
// for now use an infinite pipe to avoid blocking.
|
|
|
|
|
nsCOMPtr<nsIInputStream> pipeInputStream;
|
|
|
|
|
rv = NS_NewPipe(getter_AddRefs(pipeInputStream),
|
|
|
|
|
getter_AddRefs(mPipeOutputStream),
|
|
|
|
|
0, /* default segment size */
|
2015-03-03 09:16:00 +00:00
|
|
|
|
UINT32_MAX /* infinite pipe */,
|
|
|
|
|
true /* non-blocking input, otherwise you deadlock */,
|
|
|
|
|
false /* blocking output, since the pipe is 'in'finite */);
|
2014-12-10 08:51:59 +00:00
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
2017-11-15 19:53:42 +00:00
|
|
|
|
FailWithNetworkError(rv);
|
2014-12-10 08:51:59 +00:00
|
|
|
|
// Cancel request.
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
2016-06-01 21:02:29 +00:00
|
|
|
|
response->SetBody(pipeInputStream, contentLength);
|
2014-12-10 08:51:59 +00:00
|
|
|
|
|
2018-09-11 19:13:15 +00:00
|
|
|
|
// If the request is a file channel, then remember the local path to
|
|
|
|
|
// that file so we can later create File blobs rather than plain ones.
|
|
|
|
|
nsCOMPtr<nsIFileChannel> fc = do_QueryInterface(aRequest);
|
|
|
|
|
if (fc) {
|
|
|
|
|
nsCOMPtr<nsIFile> file;
|
|
|
|
|
rv = fc->GetFile(getter_AddRefs(file));
|
|
|
|
|
if (!NS_WARN_IF(NS_FAILED(rv))) {
|
|
|
|
|
nsAutoString path;
|
|
|
|
|
file->GetPath(path);
|
|
|
|
|
response->SetBodyLocalPath(path);
|
|
|
|
|
}
|
2018-10-06 17:34:24 +00:00
|
|
|
|
} else {
|
|
|
|
|
// If the request is a blob URI, then remember that URI so that we
|
|
|
|
|
// can later just use that blob instance instead of cloning it.
|
|
|
|
|
nsCString blobURISpec;
|
|
|
|
|
GetBlobURISpecFromChannel(aRequest, blobURISpec);
|
|
|
|
|
if (!blobURISpec.IsVoid()) {
|
|
|
|
|
response->SetBodyBlobURISpec(blobURISpec);
|
|
|
|
|
}
|
2018-09-11 19:13:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
2015-05-25 18:21:05 +00:00
|
|
|
|
response->InitChannelInfo(channel);
|
2015-03-22 06:52:12 +00:00
|
|
|
|
|
2015-06-09 19:21:13 +00:00
|
|
|
|
nsCOMPtr<nsIURI> channelURI;
|
|
|
|
|
rv = channel->GetURI(getter_AddRefs(channelURI));
|
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
2017-11-15 19:53:42 +00:00
|
|
|
|
FailWithNetworkError(rv);
|
2015-06-09 19:21:13 +00:00
|
|
|
|
// Cancel request.
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-20 12:27:25 +00:00
|
|
|
|
nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo();
|
2015-10-22 18:07:32 +00:00
|
|
|
|
// Propagate any tainting from the channel back to our response here. This
|
|
|
|
|
// step is not reflected in the spec because the spec is written such that
|
|
|
|
|
// FetchEvent.respondWith() just passes the already-tainted Response back to
|
|
|
|
|
// the outer fetch(). In gecko, however, we serialize the Response through
|
|
|
|
|
// the channel and must regenerate the tainting from the channel in the
|
|
|
|
|
// interception case.
|
2015-12-06 23:33:15 +00:00
|
|
|
|
mRequest->MaybeIncreaseResponseTainting(loadInfo->GetTainting());
|
2015-10-22 18:07:32 +00:00
|
|
|
|
|
2015-03-22 06:52:12 +00:00
|
|
|
|
// Resolves fetch() promise which may trigger code running in a worker. Make
|
|
|
|
|
// sure the Response is fully initialized before calling this.
|
2016-05-03 01:48:40 +00:00
|
|
|
|
mResponse = BeginAndGetFilteredResponse(response, foundOpaqueRedirect);
|
2017-07-10 09:03:24 +00:00
|
|
|
|
if (NS_WARN_IF(!mResponse)) {
|
|
|
|
|
// Fail to generate a paddingInfo for opaque response.
|
2019-04-24 08:49:36 +00:00
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(mRequest->GetResponseTainting() ==
|
|
|
|
|
LoadTainting::Opaque &&
|
|
|
|
|
!foundOpaqueRedirect);
|
2017-11-15 19:53:42 +00:00
|
|
|
|
FailWithNetworkError(NS_ERROR_UNEXPECTED);
|
2019-04-01 14:35:46 +00:00
|
|
|
|
return NS_ERROR_UNEXPECTED;
|
2017-07-10 09:03:24 +00:00
|
|
|
|
}
|
2014-12-10 08:51:59 +00:00
|
|
|
|
|
2017-08-25 08:36:59 +00:00
|
|
|
|
// From "Main Fetch" step 19: SRI-part1.
|
|
|
|
|
if (ShouldCheckSRI(mRequest, mResponse) && mSRIMetadata.IsEmpty()) {
|
2017-08-29 08:00:35 +00:00
|
|
|
|
nsIConsoleReportCollector* reporter = nullptr;
|
2016-09-07 02:20:23 +00:00
|
|
|
|
if (mObserver) {
|
2017-08-29 08:00:35 +00:00
|
|
|
|
reporter = mObserver->GetReporter();
|
2016-09-07 02:20:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nsAutoCString sourceUri;
|
|
|
|
|
if (mDocument && mDocument->GetDocumentURI()) {
|
|
|
|
|
mDocument->GetDocumentURI()->GetAsciiSpec(sourceUri);
|
|
|
|
|
} else if (!mWorkerScript.IsEmpty()) {
|
|
|
|
|
sourceUri.Assign(mWorkerScript);
|
|
|
|
|
}
|
|
|
|
|
SRICheck::IntegrityMetadata(mRequest->GetIntegrity(), sourceUri, reporter,
|
2017-08-29 08:00:35 +00:00
|
|
|
|
&mSRIMetadata);
|
2016-09-07 02:20:23 +00:00
|
|
|
|
mSRIDataVerifier =
|
|
|
|
|
new SRICheckDataVerifier(mSRIMetadata, sourceUri, reporter);
|
|
|
|
|
|
|
|
|
|
// Do not retarget off main thread when using SRI API.
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-10 08:51:59 +00:00
|
|
|
|
nsCOMPtr<nsIEventTarget> sts =
|
|
|
|
|
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
|
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
2017-11-15 19:53:42 +00:00
|
|
|
|
FailWithNetworkError(rv);
|
2014-12-10 08:51:59 +00:00
|
|
|
|
// Cancel request.
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Try to retarget off main thread.
|
2015-08-28 20:49:07 +00:00
|
|
|
|
if (nsCOMPtr<nsIThreadRetargetableRequest> rr = do_QueryInterface(aRequest)) {
|
2016-09-02 07:12:24 +00:00
|
|
|
|
Unused << NS_WARN_IF(NS_FAILED(rr->RetargetDeliveryTo(sts)));
|
2014-12-10 08:51:59 +00:00
|
|
|
|
}
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-22 10:07:27 +00:00
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
// Runnable to call the observer OnDataAvailable on the main-thread.
|
|
|
|
|
class DataAvailableRunnable final : public Runnable {
|
|
|
|
|
RefPtr<FetchDriverObserver> mObserver;
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
explicit DataAvailableRunnable(FetchDriverObserver* aObserver)
|
2017-06-12 19:34:10 +00:00
|
|
|
|
: Runnable("dom::DataAvailableRunnable"), mObserver(aObserver) {
|
2017-03-22 10:07:27 +00:00
|
|
|
|
MOZ_ASSERT(aObserver);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NS_IMETHOD
|
|
|
|
|
Run() override {
|
|
|
|
|
mObserver->OnDataAvailable();
|
|
|
|
|
mObserver = nullptr;
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2017-06-06 04:49:32 +00:00
|
|
|
|
struct SRIVerifierAndOutputHolder {
|
|
|
|
|
SRIVerifierAndOutputHolder(SRICheckDataVerifier* aVerifier,
|
|
|
|
|
nsIOutputStream* aOutputStream)
|
|
|
|
|
: mVerifier(aVerifier), mOutputStream(aOutputStream) {}
|
|
|
|
|
|
|
|
|
|
SRICheckDataVerifier* mVerifier;
|
|
|
|
|
nsIOutputStream* mOutputStream;
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
SRIVerifierAndOutputHolder() = delete;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Just like NS_CopySegmentToStream, but also sends the data into an
|
|
|
|
|
// SRICheckDataVerifier.
|
|
|
|
|
nsresult CopySegmentToStreamAndSRI(nsIInputStream* aInStr, void* aClosure,
|
|
|
|
|
const char* aBuffer, uint32_t aOffset,
|
|
|
|
|
uint32_t aCount, uint32_t* aCountWritten) {
|
|
|
|
|
auto holder = static_cast<SRIVerifierAndOutputHolder*>(aClosure);
|
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(holder && holder->mVerifier && holder->mOutputStream,
|
|
|
|
|
"Bogus holder");
|
|
|
|
|
nsresult rv = holder->mVerifier->Update(
|
|
|
|
|
aCount, reinterpret_cast<const uint8_t*>(aBuffer));
|
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
|
|
|
|
|
// The rest is just like NS_CopySegmentToStream.
|
|
|
|
|
*aCountWritten = 0;
|
|
|
|
|
while (aCount) {
|
|
|
|
|
uint32_t n = 0;
|
|
|
|
|
rv = holder->mOutputStream->Write(aBuffer, aCount, &n);
|
|
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
aBuffer += n;
|
|
|
|
|
aCount -= n;
|
|
|
|
|
*aCountWritten += n;
|
|
|
|
|
}
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-22 10:07:27 +00:00
|
|
|
|
} // anonymous namespace
|
|
|
|
|
|
2014-12-10 08:51:59 +00:00
|
|
|
|
NS_IMETHODIMP
|
2019-02-27 23:42:27 +00:00
|
|
|
|
FetchDriver::OnDataAvailable(nsIRequest* aRequest, nsIInputStream* aInputStream,
|
2014-12-10 08:51:59 +00:00
|
|
|
|
uint64_t aOffset, uint32_t aCount) {
|
2015-08-28 20:49:07 +00:00
|
|
|
|
// NB: This can be called on any thread! But we're guaranteed that it is
|
|
|
|
|
// called between OnStartRequest and OnStopRequest, so we don't need to worry
|
|
|
|
|
// about races.
|
|
|
|
|
|
2017-10-13 02:23:16 +00:00
|
|
|
|
if (mNeedToObserveOnDataAvailable) {
|
|
|
|
|
mNeedToObserveOnDataAvailable = false;
|
|
|
|
|
if (mObserver) {
|
|
|
|
|
if (NS_IsMainThread()) {
|
|
|
|
|
mObserver->OnDataAvailable();
|
|
|
|
|
} else {
|
|
|
|
|
RefPtr<Runnable> runnable = new DataAvailableRunnable(mObserver);
|
|
|
|
|
nsresult rv = mMainThreadEventTarget->Dispatch(runnable.forget(),
|
|
|
|
|
NS_DISPATCH_NORMAL);
|
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
2017-03-22 10:07:27 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-04 23:04:55 +00:00
|
|
|
|
// Needs to be initialized to 0 because in some cases nsStringInputStream may
|
|
|
|
|
// not write to aRead.
|
|
|
|
|
uint32_t aRead = 0;
|
2014-12-10 08:51:59 +00:00
|
|
|
|
MOZ_ASSERT(mResponse);
|
|
|
|
|
MOZ_ASSERT(mPipeOutputStream);
|
|
|
|
|
|
2017-08-25 08:36:59 +00:00
|
|
|
|
// From "Main Fetch" step 19: SRI-part2.
|
|
|
|
|
// Note: Avoid checking the hidden opaque body.
|
2018-01-04 23:04:55 +00:00
|
|
|
|
nsresult rv;
|
2017-08-25 08:36:59 +00:00
|
|
|
|
if (mResponse->Type() != ResponseType::Opaque &&
|
|
|
|
|
ShouldCheckSRI(mRequest, mResponse)) {
|
2016-09-07 02:20:23 +00:00
|
|
|
|
MOZ_ASSERT(mSRIDataVerifier);
|
|
|
|
|
|
2017-06-06 04:49:32 +00:00
|
|
|
|
SRIVerifierAndOutputHolder holder(mSRIDataVerifier, mPipeOutputStream);
|
2018-01-04 23:04:55 +00:00
|
|
|
|
rv = aInputStream->ReadSegments(CopySegmentToStreamAndSRI, &holder, aCount,
|
|
|
|
|
&aRead);
|
|
|
|
|
} else {
|
|
|
|
|
rv = aInputStream->ReadSegments(NS_CopySegmentToStream, mPipeOutputStream,
|
|
|
|
|
aCount, &aRead);
|
2016-09-07 02:20:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-01-04 23:04:55 +00:00
|
|
|
|
// If no data was read, it's possible the output stream is closed but the
|
|
|
|
|
// ReadSegments call followed its contract of returning NS_OK despite write
|
|
|
|
|
// errors. Unfortunately, nsIOutputStream has an ill-conceived contract when
|
|
|
|
|
// taken together with ReadSegments' contract, because the pipe will just
|
|
|
|
|
// NS_OK if we try and invoke its Write* functions ourselves with a 0 count.
|
|
|
|
|
// So we must just assume the pipe is broken.
|
|
|
|
|
if (aRead == 0 && aCount != 0) {
|
|
|
|
|
return NS_BASE_STREAM_CLOSED;
|
|
|
|
|
}
|
2014-12-10 08:51:59 +00:00
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NS_IMETHODIMP
|
2019-02-27 23:41:31 +00:00
|
|
|
|
FetchDriver::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
|
2018-02-05 18:55:07 +00:00
|
|
|
|
AssertIsOnMainThread();
|
2017-06-21 12:28:34 +00:00
|
|
|
|
|
2017-12-04 06:39:15 +00:00
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(!mOnStopRequestCalled);
|
|
|
|
|
mOnStopRequestCalled = true;
|
|
|
|
|
|
|
|
|
|
// main data loading is going to finish, breaking the reference cycle.
|
|
|
|
|
RefPtr<AlternativeDataStreamListener> altDataListener =
|
|
|
|
|
mAltDataListener.forget();
|
|
|
|
|
|
2017-06-21 12:28:34 +00:00
|
|
|
|
// We need to check mObserver, which is nulled by FailWithNetworkError(),
|
|
|
|
|
// because in the case of "error" redirect mode, aStatusCode may be NS_OK but
|
|
|
|
|
// mResponse will definitely be null so we must not take the else branch.
|
|
|
|
|
if (NS_FAILED(aStatusCode) || !mObserver) {
|
2015-09-14 15:05:35 +00:00
|
|
|
|
nsCOMPtr<nsIAsyncOutputStream> outputStream =
|
|
|
|
|
do_QueryInterface(mPipeOutputStream);
|
|
|
|
|
if (outputStream) {
|
2018-10-08 23:57:23 +00:00
|
|
|
|
outputStream->CloseWithStatus(NS_FAILED(aStatusCode) ? aStatusCode
|
|
|
|
|
: NS_BINDING_FAILED);
|
2015-09-14 15:05:35 +00:00
|
|
|
|
}
|
2017-12-04 06:39:15 +00:00
|
|
|
|
if (altDataListener) {
|
|
|
|
|
altDataListener->Cancel();
|
|
|
|
|
}
|
2015-10-20 01:24:36 +00:00
|
|
|
|
|
2015-09-14 15:05:35 +00:00
|
|
|
|
// We proceed as usual here, since we've already created a successful
|
|
|
|
|
// response from OnStartRequest.
|
2015-10-20 01:24:36 +00:00
|
|
|
|
} else {
|
|
|
|
|
MOZ_ASSERT(mResponse);
|
|
|
|
|
MOZ_ASSERT(!mResponse->IsError());
|
|
|
|
|
|
2017-08-25 08:36:59 +00:00
|
|
|
|
// From "Main Fetch" step 19: SRI-part3.
|
|
|
|
|
if (ShouldCheckSRI(mRequest, mResponse)) {
|
2016-09-07 02:20:23 +00:00
|
|
|
|
MOZ_ASSERT(mSRIDataVerifier);
|
|
|
|
|
|
|
|
|
|
nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
|
|
|
|
|
|
2017-08-29 08:00:35 +00:00
|
|
|
|
nsIConsoleReportCollector* reporter = nullptr;
|
2016-09-07 02:20:23 +00:00
|
|
|
|
if (mObserver) {
|
2017-08-29 08:00:35 +00:00
|
|
|
|
reporter = mObserver->GetReporter();
|
2016-09-07 02:20:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nsAutoCString sourceUri;
|
|
|
|
|
if (mDocument && mDocument->GetDocumentURI()) {
|
|
|
|
|
mDocument->GetDocumentURI()->GetAsciiSpec(sourceUri);
|
|
|
|
|
} else if (!mWorkerScript.IsEmpty()) {
|
|
|
|
|
sourceUri.Assign(mWorkerScript);
|
|
|
|
|
}
|
|
|
|
|
nsresult rv =
|
|
|
|
|
mSRIDataVerifier->Verify(mSRIMetadata, channel, sourceUri, reporter);
|
|
|
|
|
if (NS_FAILED(rv)) {
|
2017-12-04 06:39:15 +00:00
|
|
|
|
if (altDataListener) {
|
|
|
|
|
altDataListener->Cancel();
|
|
|
|
|
}
|
2017-11-15 19:53:42 +00:00
|
|
|
|
FailWithNetworkError(rv);
|
2016-09-07 02:20:23 +00:00
|
|
|
|
// Cancel request.
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-20 01:24:36 +00:00
|
|
|
|
if (mPipeOutputStream) {
|
|
|
|
|
mPipeOutputStream->Close();
|
|
|
|
|
}
|
2015-09-11 18:53:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-12-04 06:39:15 +00:00
|
|
|
|
return FinishOnStopRequest(altDataListener);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nsresult FetchDriver::FinishOnStopRequest(
|
|
|
|
|
AlternativeDataStreamListener* aAltDataListener) {
|
2018-02-05 18:55:07 +00:00
|
|
|
|
AssertIsOnMainThread();
|
2017-12-04 06:39:15 +00:00
|
|
|
|
// OnStopRequest is not called from channel, that means the main data loading
|
|
|
|
|
// does not finish yet. Reaching here since alternative data loading finishes.
|
|
|
|
|
if (!mOnStopRequestCalled) {
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(!mAltDataListener);
|
|
|
|
|
// Wait for alternative data loading finish if we needed it.
|
|
|
|
|
if (aAltDataListener &&
|
|
|
|
|
aAltDataListener->Status() == AlternativeDataStreamListener::LOADING) {
|
|
|
|
|
// For LOADING case, channel holds the reference of altDataListener, no need
|
|
|
|
|
// to restore it to mAltDataListener.
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-20 01:24:36 +00:00
|
|
|
|
if (mObserver) {
|
2017-08-25 08:36:59 +00:00
|
|
|
|
// From "Main Fetch" step 19.1, 19.2: Process response.
|
|
|
|
|
if (ShouldCheckSRI(mRequest, mResponse)) {
|
2016-09-07 02:20:23 +00:00
|
|
|
|
MOZ_ASSERT(mResponse);
|
|
|
|
|
mObserver->OnResponseAvailable(mResponse);
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
mResponseAvailableCalled = true;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-22 10:06:08 +00:00
|
|
|
|
mObserver->OnResponseEnd(FetchDriverObserver::eByNetworking);
|
2015-10-20 01:24:36 +00:00
|
|
|
|
mObserver = nullptr;
|
2015-09-14 15:05:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-03-22 10:06:08 +00:00
|
|
|
|
mChannel = nullptr;
|
2014-10-06 18:01:20 +00:00
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-19 21:54:15 +00:00
|
|
|
|
NS_IMETHODIMP
|
|
|
|
|
FetchDriver::AsyncOnChannelRedirect(nsIChannel* aOldChannel,
|
|
|
|
|
nsIChannel* aNewChannel, uint32_t aFlags,
|
|
|
|
|
nsIAsyncVerifyRedirectCallback* aCallback) {
|
|
|
|
|
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aNewChannel);
|
|
|
|
|
if (httpChannel) {
|
|
|
|
|
SetRequestHeaders(httpChannel);
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-03 01:48:40 +00:00
|
|
|
|
// "HTTP-redirect fetch": step 14 "Append locationURL to request's URL list."
|
2017-10-09 17:03:40 +00:00
|
|
|
|
// However, ignore internal redirects here. We don't want to flip
|
|
|
|
|
// Response.redirected to true if an internal redirect occurs. These
|
|
|
|
|
// should be transparent to script.
|
2018-09-12 12:44:30 +00:00
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
|
|
|
MOZ_ALWAYS_SUCCEEDS(aNewChannel->GetURI(getter_AddRefs(uri)));
|
2017-10-09 17:03:40 +00:00
|
|
|
|
|
2018-09-12 12:44:30 +00:00
|
|
|
|
nsCOMPtr<nsIURI> uriClone;
|
|
|
|
|
nsresult rv = NS_GetURIWithoutRef(uri, getter_AddRefs(uriClone));
|
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
nsCString spec;
|
|
|
|
|
rv = uriClone->GetSpec(spec);
|
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
|
|
|
|
nsCString fragment;
|
|
|
|
|
rv = uri->GetRef(fragment);
|
|
|
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
|
|
|
return rv;
|
|
|
|
|
}
|
2016-05-03 01:48:40 +00:00
|
|
|
|
|
2018-09-12 12:44:30 +00:00
|
|
|
|
if (!(aFlags & nsIChannelEventSink::REDIRECT_INTERNAL)) {
|
2017-10-09 17:03:40 +00:00
|
|
|
|
mRequest->AddURL(spec, fragment);
|
2018-09-12 12:44:30 +00:00
|
|
|
|
} else {
|
|
|
|
|
// Overwrite the URL only when the request is redirected by a service
|
|
|
|
|
// worker.
|
|
|
|
|
mRequest->SetURLForInternalRedirect(aFlags, spec, fragment);
|
2016-11-07 02:16:34 +00:00
|
|
|
|
}
|
2016-05-03 01:48:40 +00:00
|
|
|
|
|
2019-07-29 13:51:17 +00:00
|
|
|
|
// In redirect, httpChannel already took referrer-policy into account, so
|
|
|
|
|
// updates request’s associated referrer policy from channel.
|
|
|
|
|
if (httpChannel) {
|
|
|
|
|
nsCOMPtr<nsIURI> computedReferrer;
|
|
|
|
|
nsCOMPtr<nsIReferrerInfo> referrerInfo = httpChannel->GetReferrerInfo();
|
|
|
|
|
if (referrerInfo) {
|
|
|
|
|
mRequest->SetReferrerPolicy(
|
|
|
|
|
static_cast<net::ReferrerPolicy>(referrerInfo->GetReferrerPolicy()));
|
|
|
|
|
computedReferrer = referrerInfo->GetComputedReferrer();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Step 8 https://fetch.spec.whatwg.org/#main-fetch
|
|
|
|
|
// If request’s referrer is not "no-referrer" (empty), set request’s
|
|
|
|
|
// referrer to the result of invoking determine request’s referrer.
|
|
|
|
|
if (computedReferrer) {
|
|
|
|
|
nsAutoCString spec;
|
|
|
|
|
rv = computedReferrer->GetSpec(spec);
|
|
|
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
|
mRequest->SetReferrer(NS_ConvertUTF8toUTF16(spec));
|
|
|
|
|
} else {
|
|
|
|
|
mRequest->SetReferrer(EmptyString());
|
2016-07-19 07:38:26 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-19 21:54:15 +00:00
|
|
|
|
aCallback->OnRedirectVerifyCallback(NS_OK);
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-28 20:49:07 +00:00
|
|
|
|
NS_IMETHODIMP
|
|
|
|
|
FetchDriver::CheckListenerChain() { return NS_OK; }
|
|
|
|
|
|
2015-01-07 21:47:18 +00:00
|
|
|
|
NS_IMETHODIMP
|
|
|
|
|
FetchDriver::GetInterface(const nsIID& aIID, void** aResult) {
|
2016-01-19 21:54:15 +00:00
|
|
|
|
if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
|
|
|
|
|
*aResult = static_cast<nsIChannelEventSink*>(this);
|
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
2015-10-08 20:41:38 +00:00
|
|
|
|
if (aIID.Equals(NS_GET_IID(nsIStreamListener))) {
|
2015-01-07 21:47:18 +00:00
|
|
|
|
*aResult = static_cast<nsIStreamListener*>(this);
|
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
2015-10-08 20:41:38 +00:00
|
|
|
|
if (aIID.Equals(NS_GET_IID(nsIRequestObserver))) {
|
2015-01-07 21:47:18 +00:00
|
|
|
|
*aResult = static_cast<nsIRequestObserver*>(this);
|
|
|
|
|
NS_ADDREF_THIS();
|
|
|
|
|
return NS_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return QueryInterface(aIID, aResult);
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-02 13:05:23 +00:00
|
|
|
|
void FetchDriver::SetDocument(Document* aDocument) {
|
2015-03-05 20:16:18 +00:00
|
|
|
|
// Cannot set document after Fetch() has been called.
|
2015-10-20 01:24:36 +00:00
|
|
|
|
MOZ_ASSERT(!mFetchCalled);
|
2015-03-05 20:16:18 +00:00
|
|
|
|
mDocument = aDocument;
|
|
|
|
|
}
|
2015-07-13 15:25:42 +00:00
|
|
|
|
|
2018-10-23 06:17:13 +00:00
|
|
|
|
void FetchDriver::SetCSPEventListener(nsICSPEventListener* aCSPEventListener) {
|
|
|
|
|
MOZ_ASSERT(!mFetchCalled);
|
|
|
|
|
mCSPEventListener = aCSPEventListener;
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-23 15:38:54 +00:00
|
|
|
|
void FetchDriver::SetClientInfo(const ClientInfo& aClientInfo) {
|
|
|
|
|
MOZ_ASSERT(!mFetchCalled);
|
|
|
|
|
mClientInfo.emplace(aClientInfo);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void FetchDriver::SetController(
|
|
|
|
|
const Maybe<ServiceWorkerDescriptor>& aController) {
|
|
|
|
|
MOZ_ASSERT(!mFetchCalled);
|
|
|
|
|
mController = aController;
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-19 21:54:15 +00:00
|
|
|
|
void FetchDriver::SetRequestHeaders(nsIHttpChannel* aChannel) const {
|
|
|
|
|
MOZ_ASSERT(aChannel);
|
|
|
|
|
|
2018-12-19 14:48:30 +00:00
|
|
|
|
// nsIHttpChannel has a set of pre-configured headers (Accept,
|
|
|
|
|
// Accept-Languages, ...) and we don't want to merge the Request's headers
|
|
|
|
|
// with them. This array is used to know if the current header has been aleady
|
|
|
|
|
// set, if yes, we ask necko to merge it with the previous one, otherwise, we
|
|
|
|
|
// don't want the merge.
|
|
|
|
|
nsTArray<nsCString> headersSet;
|
|
|
|
|
|
2016-02-02 15:36:30 +00:00
|
|
|
|
AutoTArray<InternalHeaders::Entry, 5> headers;
|
2016-01-19 21:54:15 +00:00
|
|
|
|
mRequest->Headers()->GetEntries(headers);
|
|
|
|
|
for (uint32_t i = 0; i < headers.Length(); ++i) {
|
2018-12-19 14:48:30 +00:00
|
|
|
|
bool alreadySet = headersSet.Contains(headers[i].mName);
|
|
|
|
|
if (!alreadySet) {
|
|
|
|
|
headersSet.AppendElement(headers[i].mName);
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-19 21:54:15 +00:00
|
|
|
|
if (headers[i].mValue.IsEmpty()) {
|
2016-12-20 03:49:32 +00:00
|
|
|
|
DebugOnly<nsresult> rv =
|
|
|
|
|
aChannel->SetEmptyRequestHeader(headers[i].mName);
|
|
|
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
2016-01-19 21:54:15 +00:00
|
|
|
|
} else {
|
2016-12-20 03:49:32 +00:00
|
|
|
|
DebugOnly<nsresult> rv = aChannel->SetRequestHeader(
|
2018-12-19 14:48:30 +00:00
|
|
|
|
headers[i].mName, headers[i].mValue, alreadySet /* merge */);
|
2016-12-20 03:49:32 +00:00
|
|
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
2016-01-19 21:54:15 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-21 10:33:47 +00:00
|
|
|
|
nsAutoCString method;
|
|
|
|
|
mRequest->GetMethod(method);
|
|
|
|
|
if (!method.EqualsLiteral("GET") && !method.EqualsLiteral("HEAD")) {
|
2016-01-19 21:54:15 +00:00
|
|
|
|
nsAutoString origin;
|
|
|
|
|
if (NS_SUCCEEDED(nsContentUtils::GetUTFOrigin(mPrincipal, origin))) {
|
2018-11-05 21:40:36 +00:00
|
|
|
|
DebugOnly<nsresult> rv = aChannel->SetRequestHeader(
|
|
|
|
|
nsDependentCString(net::nsHttp::Origin),
|
2016-12-20 03:49:32 +00:00
|
|
|
|
NS_ConvertUTF16toUTF8(origin), false /* merge */);
|
|
|
|
|
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
2016-01-19 21:54:15 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-29 09:31:07 +00:00
|
|
|
|
void FetchDriver::Abort() {
|
2019-08-15 12:52:54 +00:00
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(NS_IsMainThread());
|
|
|
|
|
|
2017-03-22 10:06:08 +00:00
|
|
|
|
if (mObserver) {
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
mResponseAvailableCalled = true;
|
|
|
|
|
#endif
|
|
|
|
|
mObserver->OnResponseEnd(FetchDriverObserver::eAborted);
|
|
|
|
|
mObserver = nullptr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (mChannel) {
|
|
|
|
|
mChannel->Cancel(NS_BINDING_ABORTED);
|
|
|
|
|
mChannel = nullptr;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-06 18:01:20 +00:00
|
|
|
|
} // namespace dom
|
|
|
|
|
} // namespace mozilla
|