summaryrefslogtreecommitdiffstats
path: root/dom/xhr/XMLHttpRequestMainThread.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /dom/xhr/XMLHttpRequestMainThread.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/xhr/XMLHttpRequestMainThread.h')
-rw-r--r--dom/xhr/XMLHttpRequestMainThread.h873
1 files changed, 873 insertions, 0 deletions
diff --git a/dom/xhr/XMLHttpRequestMainThread.h b/dom/xhr/XMLHttpRequestMainThread.h
new file mode 100644
index 0000000000..b248e03664
--- /dev/null
+++ b/dom/xhr/XMLHttpRequestMainThread.h
@@ -0,0 +1,873 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef mozilla_dom_XMLHttpRequestMainThread_h
+#define mozilla_dom_XMLHttpRequestMainThread_h
+
+#include <bitset>
+#include "nsISupportsUtils.h"
+#include "nsIURI.h"
+#include "mozilla/dom/Document.h"
+#include "nsIStreamListener.h"
+#include "nsIChannelEventSink.h"
+#include "nsIAsyncVerifyRedirectCallback.h"
+#include "nsIDOMEventListener.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIHttpHeaderVisitor.h"
+#include "nsIProgressEventSink.h"
+#include "nsJSUtils.h"
+#include "nsTArray.h"
+#include "nsITimer.h"
+#include "nsIPrincipal.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsISizeOfEventTarget.h"
+#include "nsIInputStream.h"
+#include "nsIContentSecurityPolicy.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/NotNull.h"
+#include "mozilla/dom/MutableBlobStorage.h"
+#include "mozilla/dom/BodyExtractor.h"
+#include "mozilla/dom/ClientInfo.h"
+#include "mozilla/dom/TypedArray.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/FormData.h"
+#include "mozilla/dom/MimeType.h"
+#include "mozilla/dom/PerformanceStorage.h"
+#include "mozilla/dom/ServiceWorkerDescriptor.h"
+#include "mozilla/dom/URLSearchParams.h"
+#include "mozilla/dom/XMLHttpRequest.h"
+#include "mozilla/dom/XMLHttpRequestBinding.h"
+#include "mozilla/dom/XMLHttpRequestEventTarget.h"
+#include "mozilla/dom/XMLHttpRequestString.h"
+#include "mozilla/Encoding.h"
+
+#ifdef Status
+/* Xlib headers insist on this for some reason... Nuke it because
+ it'll override our member name */
+typedef Status __StatusTmp;
+# undef Status
+typedef __StatusTmp Status;
+#endif
+
+class nsIHttpChannel;
+class nsIJARChannel;
+class nsILoadGroup;
+
+namespace mozilla {
+class ProfileChunkedBuffer;
+
+namespace dom {
+
+class DOMString;
+class XMLHttpRequestUpload;
+class SerializedStackHolder;
+struct OriginAttributesDictionary;
+
+// A helper for building up an ArrayBuffer object's data
+// before creating the ArrayBuffer itself. Will do doubling
+// based reallocation, up to an optional maximum growth given.
+//
+// When all the data has been appended, call GetArrayBuffer,
+// passing in the JSContext* for which the ArrayBuffer object
+// is to be created. This also implicitly resets the builder.
+class ArrayBufferBuilder {
+ public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ArrayBufferBuilder);
+
+ ArrayBufferBuilder();
+
+ // Will truncate if aNewCap is < Length().
+ bool SetCapacity(uint32_t aNewCap);
+
+ // Append aDataLen bytes from data to the current buffer. If we
+ // need to grow the buffer, grow by doubling the size up to a
+ // maximum of aMaxGrowth (if given). If aDataLen is greater than
+ // what the new capacity would end up as, then grow by aDataLen.
+ //
+ // The data parameter must not overlap with anything beyond the
+ // builder's current valid contents [0..length)
+ bool Append(const uint8_t* aNewData, uint32_t aDataLen,
+ uint32_t aMaxGrowth = 0);
+
+ uint32_t Length();
+ uint32_t Capacity();
+
+ JSObject* TakeArrayBuffer(JSContext* aCx);
+
+ // Memory mapping to starting position of file(aFile) in the zip
+ // package(aJarFile).
+ //
+ // The file in the zip package has to be uncompressed and the starting
+ // position of the file must be aligned according to array buffer settings
+ // in JS engine.
+ nsresult MapToFileInPackage(const nsCString& aFile, nsIFile* aJarFile);
+
+ private:
+ ~ArrayBufferBuilder();
+
+ ArrayBufferBuilder(const ArrayBufferBuilder&) = delete;
+ ArrayBufferBuilder& operator=(const ArrayBufferBuilder&) = delete;
+ ArrayBufferBuilder& operator=(const ArrayBufferBuilder&&) = delete;
+
+ bool SetCapacityInternal(uint32_t aNewCap, const MutexAutoLock& aProofOfLock)
+ MOZ_REQUIRES(mMutex);
+
+ static bool AreOverlappingRegions(const uint8_t* aStart1, uint32_t aLength1,
+ const uint8_t* aStart2, uint32_t aLength2);
+
+ Mutex mMutex;
+
+ // All of these are protected by mMutex.
+ uint8_t* mDataPtr MOZ_GUARDED_BY(mMutex);
+ uint32_t mCapacity MOZ_GUARDED_BY(mMutex);
+ uint32_t mLength MOZ_GUARDED_BY(mMutex);
+ void* mMapPtr MOZ_GUARDED_BY(mMutex);
+
+ // This is used in assertions only.
+ bool mNeutered;
+};
+
+class nsXMLHttpRequestXPCOMifier;
+
+class RequestHeaders {
+ struct RequestHeader {
+ nsCString mName;
+ nsCString mValue;
+ };
+ nsTArray<RequestHeader> mHeaders;
+ RequestHeader* Find(const nsACString& aName);
+
+ public:
+ class CharsetIterator {
+ bool mValid;
+ int32_t mCurPos, mCurLen, mCutoff;
+ nsACString& mSource;
+
+ public:
+ explicit CharsetIterator(nsACString& aSource);
+ bool Equals(const nsACString& aOther,
+ const nsCStringComparator& aCmp) const;
+ void Replace(const nsACString& aReplacement);
+ bool Next();
+ };
+
+ bool IsEmpty() const;
+ bool Has(const char* aName);
+ bool Has(const nsACString& aName);
+ void Get(const char* aName, nsACString& aValue);
+ void Get(const nsACString& aName, nsACString& aValue);
+ void Set(const char* aName, const nsACString& aValue);
+ void Set(const nsACString& aName, const nsACString& aValue);
+ void MergeOrSet(const char* aName, const nsACString& aValue);
+ void MergeOrSet(const nsACString& aName, const nsACString& aValue);
+ void Clear();
+ void ApplyToChannel(nsIHttpChannel* aChannel, bool aStripRequestBodyHeader,
+ bool aStripAuth) const;
+ void GetCORSUnsafeHeaders(nsTArray<nsCString>& aArray) const;
+};
+
+class nsXHRParseEndListener;
+class XMLHttpRequestDoneNotifier;
+
+// Make sure that any non-DOM interfaces added here are also added to
+// nsXMLHttpRequestXPCOMifier.
+class XMLHttpRequestMainThread final : public XMLHttpRequest,
+ public nsIStreamListener,
+ public nsIChannelEventSink,
+ public nsIProgressEventSink,
+ public nsIInterfaceRequestor,
+ public nsITimerCallback,
+ public nsISizeOfEventTarget,
+ public nsINamed,
+ public MutableBlobStorageCallback {
+ friend class nsXHRParseEndListener;
+ friend class nsXMLHttpRequestXPCOMifier;
+ friend class XMLHttpRequestDoneNotifier;
+
+ public:
+ enum class ProgressEventType : uint8_t {
+ loadstart,
+ progress,
+ error,
+ abort,
+ timeout,
+ load,
+ loadend,
+ ENUM_MAX
+ };
+
+ // Make sure that any additions done to ErrorType enum are also mirrored in
+ // XHR_ERROR_TYPE enum of TelemetrySend.sys.mjs.
+ enum class ErrorType : uint16_t {
+ eOK,
+ eRequest,
+ eUnreachable,
+ eChannelOpen,
+ eRedirect,
+ eTerminated,
+ ENUM_MAX
+ };
+
+ explicit XMLHttpRequestMainThread(nsIGlobalObject* aGlobalObject);
+
+ void Construct(nsIPrincipal* aPrincipal,
+ nsICookieJarSettings* aCookieJarSettings, bool aForWorker,
+ nsIURI* aBaseURI = nullptr, nsILoadGroup* aLoadGroup = nullptr,
+ PerformanceStorage* aPerformanceStorage = nullptr,
+ nsICSPEventListener* aCSPEventListener = nullptr);
+
+ void InitParameters(bool aAnon, bool aSystem);
+
+ void SetParameters(bool aAnon, bool aSystem) {
+ mIsAnon = aAnon || aSystem;
+ mIsSystem = aSystem;
+ }
+
+ void SetClientInfoAndController(
+ const ClientInfo& aClientInfo,
+ const Maybe<ServiceWorkerDescriptor>& aController);
+
+ NS_DECL_ISUPPORTS_INHERITED
+
+ // nsIStreamListener
+ NS_DECL_NSISTREAMLISTENER
+
+ // nsIRequestObserver
+ NS_DECL_NSIREQUESTOBSERVER
+
+ // nsIChannelEventSink
+ NS_DECL_NSICHANNELEVENTSINK
+
+ // nsIProgressEventSink
+ NS_DECL_NSIPROGRESSEVENTSINK
+
+ // nsIInterfaceRequestor
+ NS_DECL_NSIINTERFACEREQUESTOR
+
+ // nsITimerCallback
+ NS_DECL_NSITIMERCALLBACK
+
+ // nsINamed
+ NS_DECL_NSINAMED
+
+ // nsISizeOfEventTarget
+ virtual size_t SizeOfEventTargetIncludingThis(
+ MallocSizeOf aMallocSizeOf) const override;
+
+ // states
+ virtual uint16_t ReadyState() const override;
+
+ // request
+ nsresult CreateChannel();
+ nsresult InitiateFetch(already_AddRefed<nsIInputStream> aUploadStream,
+ int64_t aUploadLength, nsACString& aUploadContentType);
+
+ virtual void Open(const nsACString& aMethod, const nsAString& aUrl,
+ ErrorResult& aRv) override;
+
+ virtual void Open(const nsACString& aMethod, const nsAString& aUrl,
+ bool aAsync, const nsAString& aUsername,
+ const nsAString& aPassword, ErrorResult& aRv) override;
+
+ void Open(const nsACString& aMethod, const nsACString& aUrl, bool aAsync,
+ const nsAString& aUsername, const nsAString& aPassword,
+ ErrorResult& aRv);
+
+ virtual void SetRequestHeader(const nsACString& aName,
+ const nsACString& aValue,
+ ErrorResult& aRv) override;
+
+ virtual uint32_t Timeout() const override { return mTimeoutMilliseconds; }
+
+ virtual void SetTimeout(uint32_t aTimeout, ErrorResult& aRv) override;
+
+ virtual bool WithCredentials() const override;
+
+ virtual void SetWithCredentials(bool aWithCredentials,
+ ErrorResult& aRv) override;
+
+ virtual XMLHttpRequestUpload* GetUpload(ErrorResult& aRv) override;
+
+ private:
+ virtual ~XMLHttpRequestMainThread();
+
+ nsresult MaybeSilentSendFailure(nsresult aRv);
+ void SendInternal(const BodyExtractorBase* aBody,
+ bool aBodyIsDocumentOrString, ErrorResult& aRv);
+
+ bool IsCrossSiteCORSRequest() const;
+ bool IsDeniedCrossSiteCORSRequest();
+
+ void ResumeTimeout();
+
+ void MaybeLowerChannelPriority();
+
+ public:
+ bool CanSend(ErrorResult& aRv);
+
+ virtual void Send(
+ const Nullable<
+ DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString>&
+ aData,
+ ErrorResult& aRv) override;
+
+ virtual void SendInputStream(nsIInputStream* aInputStream,
+ ErrorResult& aRv) override {
+ if (!CanSend(aRv)) {
+ return;
+ }
+ BodyExtractor<nsIInputStream> body(aInputStream);
+ SendInternal(&body, false, aRv);
+ }
+
+ void RequestErrorSteps(const ProgressEventType aEventType,
+ const nsresult aOptionalException, ErrorResult& aRv);
+
+ void Abort() {
+ IgnoredErrorResult rv;
+ AbortInternal(rv);
+ MOZ_ASSERT(!rv.Failed());
+ }
+
+ virtual void Abort(ErrorResult& aRv) override;
+
+ // response
+ virtual void GetResponseURL(nsAString& aUrl) override;
+
+ virtual uint32_t GetStatus(ErrorResult& aRv) override;
+
+ virtual void GetStatusText(nsACString& aStatusText,
+ ErrorResult& aRv) override;
+
+ virtual void GetResponseHeader(const nsACString& aHeader, nsACString& aResult,
+ ErrorResult& aRv) override;
+
+ void GetResponseHeader(const nsAString& aHeader, nsAString& aResult,
+ ErrorResult& aRv) {
+ nsAutoCString result;
+ GetResponseHeader(NS_ConvertUTF16toUTF8(aHeader), result, aRv);
+ if (result.IsVoid()) {
+ aResult.SetIsVoid(true);
+ } else {
+ // The result value should be inflated:
+ CopyASCIItoUTF16(result, aResult);
+ }
+ }
+
+ virtual void GetAllResponseHeaders(nsACString& aResponseHeaders,
+ ErrorResult& aRv) override;
+
+ bool IsSafeHeader(const nsACString& aHeaderName,
+ NotNull<nsIHttpChannel*> aHttpChannel) const;
+
+ virtual void OverrideMimeType(const nsAString& aMimeType,
+ ErrorResult& aRv) override;
+
+ virtual XMLHttpRequestResponseType ResponseType() const override {
+ return XMLHttpRequestResponseType(mResponseType);
+ }
+
+ virtual void SetResponseType(XMLHttpRequestResponseType aType,
+ ErrorResult& aRv) override;
+
+ void SetResponseTypeRaw(XMLHttpRequestResponseType aType) {
+ mResponseType = aType;
+ }
+
+ virtual void GetResponse(JSContext* aCx,
+ JS::MutableHandle<JS::Value> aResponse,
+ ErrorResult& aRv) override;
+
+ virtual void GetResponseText(DOMString& aResponseText,
+ ErrorResult& aRv) override;
+
+ // GetResponse* for workers:
+ already_AddRefed<BlobImpl> GetResponseBlobImpl();
+ already_AddRefed<ArrayBufferBuilder> GetResponseArrayBufferBuilder();
+ nsresult GetResponseTextForJSON(nsAString& aString);
+ void GetResponseText(XMLHttpRequestStringSnapshot& aSnapshot,
+ ErrorResult& aRv);
+
+ virtual Document* GetResponseXML(ErrorResult& aRv) override;
+
+ virtual bool MozBackgroundRequest() const override;
+
+ void SetMozBackgroundRequestExternal(bool aMozBackgroundRequest,
+ ErrorResult& aRv);
+
+ virtual void SetMozBackgroundRequest(bool aMozBackgroundRequest,
+ ErrorResult& aRv) override;
+
+ void SetOriginStack(UniquePtr<SerializedStackHolder> aOriginStack);
+
+ void SetSource(UniquePtr<ProfileChunkedBuffer> aSource);
+
+ virtual uint16_t ErrorCode() const override {
+ return static_cast<uint16_t>(mErrorLoad);
+ }
+
+ virtual bool MozAnon() const override;
+
+ virtual bool MozSystem() const override;
+
+ virtual nsIChannel* GetChannel() const override { return mChannel; }
+
+ // We need a GetInterface callable from JS for chrome JS
+ virtual void GetInterface(JSContext* aCx, JS::Handle<JS::Value> aIID,
+ JS::MutableHandle<JS::Value> aRetval,
+ ErrorResult& aRv) override;
+
+ // This fires a trusted readystatechange event, which is not cancelable and
+ // doesn't bubble.
+ nsresult FireReadystatechangeEvent();
+ void DispatchProgressEvent(DOMEventTargetHelper* aTarget,
+ const ProgressEventType aType, int64_t aLoaded,
+ int64_t aTotal);
+
+ NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(
+ XMLHttpRequestMainThread, XMLHttpRequest)
+ virtual bool IsCertainlyAliveForCC() const override;
+
+ bool AllowUploadProgress();
+
+ virtual void DisconnectFromOwner() override;
+
+ static void SetDontWarnAboutSyncXHR(bool aVal) {
+ sDontWarnAboutSyncXHR = aVal;
+ }
+ static bool DontWarnAboutSyncXHR() { return sDontWarnAboutSyncXHR; }
+
+ virtual void SetOriginAttributes(
+ const mozilla::dom::OriginAttributesDictionary& aAttrs) override;
+
+ void BlobStoreCompleted(MutableBlobStorage* aBlobStorage, BlobImpl* aBlobImpl,
+ nsresult aResult) override;
+
+ void LocalFileToBlobCompleted(BlobImpl* aBlobImpl);
+
+ protected:
+ nsresult DetectCharset();
+ nsresult AppendToResponseText(Span<const uint8_t> aBuffer,
+ bool aLast = false);
+ static nsresult StreamReaderFunc(nsIInputStream* in, void* closure,
+ const char* fromRawSegment,
+ uint32_t toOffset, uint32_t count,
+ uint32_t* writeCount);
+ nsresult CreateResponseParsedJSON(JSContext* aCx);
+ // Change the state of the object with this. The broadcast argument
+ // determines if the onreadystatechange listener should be called.
+ nsresult ChangeState(uint16_t aState, bool aBroadcast = true);
+ already_AddRefed<nsILoadGroup> GetLoadGroup() const;
+
+ // Finds a preload for this XHR. If it is found it's removed from the preload
+ // table of the document and marked as used. The called doesn't need to do
+ // any more comparative checks.
+ already_AddRefed<PreloaderBase> FindPreload();
+ // If no or unknown mime type is set on the channel this method ensures it's
+ // set to "text/xml".
+ void EnsureChannelContentType();
+
+ already_AddRefed<nsIHttpChannel> GetCurrentHttpChannel();
+ already_AddRefed<nsIJARChannel> GetCurrentJARChannel();
+
+ void TruncateResponseText();
+
+ bool IsSystemXHR() const;
+ bool InUploadPhase() const;
+
+ void OnBodyParseEnd();
+ void ChangeStateToDone(bool aWasSync);
+ void ChangeStateToDoneInternal();
+
+ void StartProgressEventTimer();
+ void StopProgressEventTimer();
+
+ void MaybeCreateBlobStorage();
+
+ nsresult OnRedirectVerifyCallback(nsresult result, bool stripAuth = false);
+
+ nsIEventTarget* GetTimerEventTarget();
+
+ nsresult DispatchToMainThread(already_AddRefed<nsIRunnable> aRunnable);
+
+ void DispatchOrStoreEvent(DOMEventTargetHelper* aTarget, Event* aEvent);
+
+ already_AddRefed<nsXMLHttpRequestXPCOMifier> EnsureXPCOMifier();
+
+ void SuspendEventDispatching();
+ void ResumeEventDispatching();
+
+ void AbortInternal(ErrorResult& aRv);
+
+ struct PendingEvent {
+ RefPtr<DOMEventTargetHelper> mTarget;
+ RefPtr<Event> mEvent;
+ };
+
+ nsTArray<PendingEvent> mPendingEvents;
+
+ nsCOMPtr<nsISupports> mContext;
+ nsCOMPtr<nsIPrincipal> mPrincipal;
+ nsCOMPtr<nsIChannel> mChannel;
+ nsCString mRequestMethod;
+ nsCOMPtr<nsIURI> mRequestURL;
+ RefPtr<Document> mResponseXML;
+
+ nsCOMPtr<nsIStreamListener> mXMLParserStreamListener;
+
+ nsCOMPtr<nsICookieJarSettings> mCookieJarSettings;
+
+ RefPtr<PerformanceStorage> mPerformanceStorage;
+ nsCOMPtr<nsICSPEventListener> mCSPEventListener;
+
+ // used to implement getAllResponseHeaders()
+ class nsHeaderVisitor : public nsIHttpHeaderVisitor {
+ struct HeaderEntry final {
+ nsCString mName;
+ nsCString mValue;
+
+ HeaderEntry(const nsACString& aName, const nsACString& aValue)
+ : mName(aName), mValue(aValue) {}
+
+ bool operator==(const HeaderEntry& aOther) const {
+ return mName == aOther.mName;
+ }
+
+ bool operator<(const HeaderEntry& aOther) const {
+ uint32_t selfLen = mName.Length();
+ uint32_t otherLen = aOther.mName.Length();
+ uint32_t min = XPCOM_MIN(selfLen, otherLen);
+ for (uint32_t i = 0; i < min; ++i) {
+ unsigned char self = mName[i];
+ unsigned char other = aOther.mName[i];
+ MOZ_ASSERT(!(self >= 'A' && self <= 'Z'));
+ MOZ_ASSERT(!(other >= 'A' && other <= 'Z'));
+ if (self == other) {
+ continue;
+ }
+ if (self >= 'a' && self <= 'z') {
+ self -= 0x20;
+ }
+ if (other >= 'a' && other <= 'z') {
+ other -= 0x20;
+ }
+ return self < other;
+ }
+ return selfLen < otherLen;
+ }
+ };
+
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIHTTPHEADERVISITOR
+ nsHeaderVisitor(const XMLHttpRequestMainThread& aXMLHttpRequest,
+ NotNull<nsIHttpChannel*> aHttpChannel);
+ const nsACString& Headers() {
+ for (uint32_t i = 0; i < mHeaderList.Length(); i++) {
+ HeaderEntry& header = mHeaderList.ElementAt(i);
+
+ mHeaders.Append(header.mName);
+ mHeaders.AppendLiteral(": ");
+ mHeaders.Append(header.mValue);
+ mHeaders.AppendLiteral("\r\n");
+ }
+ return mHeaders;
+ }
+
+ private:
+ virtual ~nsHeaderVisitor();
+
+ nsTArray<HeaderEntry> mHeaderList;
+ nsCString mHeaders;
+ const XMLHttpRequestMainThread& mXHR;
+ NotNull<nsCOMPtr<nsIHttpChannel>> mHttpChannel;
+ };
+
+ // The bytes of our response body. Only used for DEFAULT, ARRAYBUFFER and
+ // BLOB responseTypes
+ nsCString mResponseBody;
+
+ // The text version of our response body. This is incrementally decoded into
+ // as we receive network data. However for the DEFAULT responseType we
+ // lazily decode into this from mResponseBody only when .responseText is
+ // accessed.
+ // Only used for DEFAULT and TEXT responseTypes.
+ XMLHttpRequestString mResponseText;
+
+ // For DEFAULT responseType we use this to keep track of how far we've
+ // lazily decoded from mResponseBody to mResponseText
+ uint32_t mResponseBodyDecodedPos;
+
+ // Decoder used for decoding into mResponseText
+ // Only used for DEFAULT, TEXT and JSON responseTypes.
+ // In cases where we've only received half a surrogate, the decoder itself
+ // carries the state to remember this. Next time we receive more data we
+ // simply feed the new data into the decoder which will handle the second
+ // part of the surrogate.
+ mozilla::UniquePtr<mozilla::Decoder> mDecoder;
+
+ void MatchCharsetAndDecoderToResponseDocument();
+
+ XMLHttpRequestResponseType mResponseType;
+
+ RefPtr<BlobImpl> mResponseBlobImpl;
+
+ // This is the cached blob-response, created only at the first GetResponse()
+ // call.
+ RefPtr<Blob> mResponseBlob;
+
+ // We stream data to mBlobStorage when response type is "blob".
+ RefPtr<MutableBlobStorage> mBlobStorage;
+
+ nsString mOverrideMimeType;
+
+ /**
+ * The notification callbacks the channel had when Send() was
+ * called. We want to forward things here as needed.
+ */
+ nsCOMPtr<nsIInterfaceRequestor> mNotificationCallbacks;
+ /**
+ * Sink interfaces that we implement that mNotificationCallbacks may
+ * want to also be notified for. These are inited lazily if we're
+ * asked for the relevant interface.
+ */
+ nsCOMPtr<nsIChannelEventSink> mChannelEventSink;
+ nsCOMPtr<nsIProgressEventSink> mProgressEventSink;
+
+ nsCOMPtr<nsIURI> mBaseURI;
+ nsCOMPtr<nsILoadGroup> mLoadGroup;
+
+ Maybe<ClientInfo> mClientInfo;
+ Maybe<ServiceWorkerDescriptor> mController;
+
+ uint16_t mState;
+
+ // If true, this object is used by the worker's XMLHttpRequest.
+ bool mForWorker;
+
+ bool mFlagSynchronous;
+ bool mFlagAborted;
+ bool mFlagParseBody;
+ bool mFlagSyncLooping;
+ bool mFlagBackgroundRequest;
+ bool mFlagHadUploadListenersOnSend;
+ bool mFlagACwithCredentials;
+ bool mFlagTimedOut;
+ bool mFlagDeleted;
+
+ // The XHR2 spec's send() flag. Set when the XHR begins uploading, until it
+ // finishes downloading (or an error/abort has occurred during either phase).
+ // Used to guard against the user trying to alter headers/etc when it's too
+ // late, and ensure the XHR only handles one in-flight request at once.
+ bool mFlagSend;
+
+ RefPtr<XMLHttpRequestUpload> mUpload;
+ int64_t mUploadTransferred;
+ int64_t mUploadTotal;
+ bool mUploadComplete;
+ bool mProgressSinceLastProgressEvent;
+
+ // Timeout support
+ PRTime mRequestSentTime;
+ uint32_t mTimeoutMilliseconds;
+ nsCOMPtr<nsITimer> mTimeoutTimer;
+ void StartTimeoutTimer();
+ void HandleTimeoutCallback();
+
+ nsCOMPtr<nsIRunnable> mResumeTimeoutRunnable;
+
+ nsCOMPtr<nsITimer> mSyncTimeoutTimer;
+
+ enum SyncTimeoutType { eErrorOrExpired, eTimerStarted, eNoTimerNeeded };
+
+ SyncTimeoutType MaybeStartSyncTimeoutTimer();
+ void HandleSyncTimeoutTimer();
+ void CancelSyncTimeoutTimer();
+
+ ErrorType mErrorLoad;
+ bool mErrorParsingXML;
+ bool mWaitingForOnStopRequest;
+ bool mProgressTimerIsActive;
+ bool mIsHtml;
+ bool mWarnAboutSyncHtml;
+ int64_t mLoadTotal; // -1 if not known.
+ // Number of HTTP message body bytes received so far. This quantity is
+ // in the same units as Content-Length and mLoadTotal, and hence counts
+ // compressed bytes when the channel has gzip Content-Encoding. If the
+ // channel does not have Content-Encoding, this will be the same as
+ // mDataReceived except between the OnProgress that changes mLoadTransferred
+ // and the corresponding OnDataAvailable (which changes mDataReceived).
+ // Ordering of OnProgress and OnDataAvailable is undefined.
+ int64_t mLoadTransferred;
+ nsCOMPtr<nsITimer> mProgressNotifier;
+ void HandleProgressTimerCallback();
+
+ bool mIsSystem;
+ bool mIsAnon;
+
+ /**
+ * Close the XMLHttpRequest's channels.
+ */
+ void CloseRequest();
+
+ void TerminateOngoingFetch();
+
+ /**
+ * Close the XMLHttpRequest's channels and dispatch appropriate progress
+ * events.
+ *
+ * @param aType The progress event type.
+ */
+ void CloseRequestWithError(const ProgressEventType aType);
+
+ nsCOMPtr<nsIAsyncVerifyRedirectCallback> mRedirectCallback;
+ nsCOMPtr<nsIChannel> mNewRedirectChannel;
+
+ JS::Heap<JS::Value> mResultJSON;
+
+ RefPtr<ArrayBufferBuilder> mArrayBufferBuilder;
+ JS::Heap<JSObject*> mResultArrayBuffer;
+ bool mIsMappedArrayBuffer;
+
+ void ResetResponse();
+
+ bool ShouldBlockAuthPrompt();
+
+ RequestHeaders mAuthorRequestHeaders;
+
+ // Helper object to manage our XPCOM scriptability bits
+ nsXMLHttpRequestXPCOMifier* mXPCOMifier;
+
+ // When this is set to true, the event dispatching is suspended. This is
+ // useful to change the correct state when XHR is working sync.
+ bool mEventDispatchingSuspended;
+
+ // True iff mDecoder has processed the end of the stream.
+ // Used in lazy decoding to distinguish between having
+ // processed all the bytes but not the EOF and having
+ // processed all the bytes and the EOF.
+ bool mEofDecoded;
+
+ // This flag will be set in `Send()` when we successfully reuse a "fetch"
+ // preload to satisfy this XHR.
+ bool mFromPreload = false;
+
+ // Our parse-end listener, if we are parsing.
+ RefPtr<nsXHRParseEndListener> mParseEndListener;
+
+ XMLHttpRequestDoneNotifier* mDelayedDoneNotifier;
+ void DisconnectDoneNotifier();
+
+ // Any stack information for the point the XHR was opened. This is deleted
+ // after the XHR is opened, to avoid retaining references to the worker.
+ UniquePtr<SerializedStackHolder> mOriginStack;
+
+ static bool sDontWarnAboutSyncXHR;
+};
+
+class MOZ_STACK_CLASS AutoDontWarnAboutSyncXHR {
+ public:
+ AutoDontWarnAboutSyncXHR()
+ : mOldVal(XMLHttpRequestMainThread::DontWarnAboutSyncXHR()) {
+ XMLHttpRequestMainThread::SetDontWarnAboutSyncXHR(true);
+ }
+
+ ~AutoDontWarnAboutSyncXHR() {
+ XMLHttpRequestMainThread::SetDontWarnAboutSyncXHR(mOldVal);
+ }
+
+ private:
+ bool mOldVal;
+};
+
+// A shim class designed to expose the non-DOM interfaces of
+// XMLHttpRequest via XPCOM stuff.
+class nsXMLHttpRequestXPCOMifier final : public nsIStreamListener,
+ public nsIChannelEventSink,
+ public nsIAsyncVerifyRedirectCallback,
+ public nsIProgressEventSink,
+ public nsIInterfaceRequestor,
+ public nsITimerCallback,
+ public nsINamed {
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsXMLHttpRequestXPCOMifier,
+ nsIStreamListener)
+
+ explicit nsXMLHttpRequestXPCOMifier(XMLHttpRequestMainThread* aXHR)
+ : mXHR(aXHR) {}
+
+ private:
+ ~nsXMLHttpRequestXPCOMifier() {
+ if (mXHR) {
+ mXHR->mXPCOMifier = nullptr;
+ }
+ }
+
+ public:
+ NS_FORWARD_NSISTREAMLISTENER(mXHR->)
+ NS_FORWARD_NSIREQUESTOBSERVER(mXHR->)
+ NS_FORWARD_NSICHANNELEVENTSINK(mXHR->)
+ NS_FORWARD_NSIASYNCVERIFYREDIRECTCALLBACK(mXHR->)
+ NS_FORWARD_NSIPROGRESSEVENTSINK(mXHR->)
+ NS_FORWARD_NSITIMERCALLBACK(mXHR->)
+ NS_FORWARD_NSINAMED(mXHR->)
+
+ NS_DECL_NSIINTERFACEREQUESTOR
+
+ private:
+ RefPtr<XMLHttpRequestMainThread> mXHR;
+};
+
+class XMLHttpRequestDoneNotifier : public Runnable {
+ public:
+ explicit XMLHttpRequestDoneNotifier(XMLHttpRequestMainThread* aXHR)
+ : Runnable("XMLHttpRequestDoneNotifier"), mXHR(aXHR) {}
+
+ NS_IMETHOD Run() override {
+ if (mXHR) {
+ RefPtr<XMLHttpRequestMainThread> xhr = mXHR;
+ // ChangeStateToDoneInternal ends up calling Disconnect();
+ xhr->ChangeStateToDoneInternal();
+ MOZ_ASSERT(!mXHR);
+ }
+ return NS_OK;
+ }
+
+ void Disconnect() { mXHR = nullptr; }
+
+ private:
+ RefPtr<XMLHttpRequestMainThread> mXHR;
+};
+
+class nsXHRParseEndListener : public nsIDOMEventListener {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_IMETHOD HandleEvent(Event* event) override {
+ if (mXHR) {
+ mXHR->OnBodyParseEnd();
+ }
+ mXHR = nullptr;
+ return NS_OK;
+ }
+
+ explicit nsXHRParseEndListener(XMLHttpRequestMainThread* aXHR) : mXHR(aXHR) {}
+
+ void SetIsStale() { mXHR = nullptr; }
+
+ private:
+ virtual ~nsXHRParseEndListener() = default;
+
+ XMLHttpRequestMainThread* mXHR;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_XMLHttpRequestMainThread_h