summaryrefslogtreecommitdiffstats
path: root/dom/xhr/XMLHttpRequestMainThread.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/xhr/XMLHttpRequestMainThread.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/xhr/XMLHttpRequestMainThread.h')
-rw-r--r--dom/xhr/XMLHttpRequestMainThread.h872
1 files changed, 872 insertions, 0 deletions
diff --git a/dom/xhr/XMLHttpRequestMainThread.h b/dom/xhr/XMLHttpRequestMainThread.h
new file mode 100644
index 000000000..c9bcddf99
--- /dev/null
+++ b/dom/xhr/XMLHttpRequestMainThread.h
@@ -0,0 +1,872 @@
+/* -*- 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 "nsAutoPtr.h"
+#include "nsIXMLHttpRequest.h"
+#include "nsISupportsUtils.h"
+#include "nsIURI.h"
+#include "nsIHttpChannel.h"
+#include "nsIDocument.h"
+#include "nsIStreamListener.h"
+#include "nsWeakReference.h"
+#include "nsIChannelEventSink.h"
+#include "nsIAsyncVerifyRedirectCallback.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 "nsIXPConnect.h"
+#include "nsIInputStream.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/NotNull.h"
+#include "mozilla/dom/MutableBlobStorage.h"
+#include "mozilla/dom/TypedArray.h"
+#include "mozilla/dom/XMLHttpRequest.h"
+#include "mozilla/dom/XMLHttpRequestBinding.h"
+#include "mozilla/dom/XMLHttpRequestEventTarget.h"
+#include "mozilla/dom/XMLHttpRequestString.h"
+
+#ifdef Status
+/* Xlib headers insist on this for some reason... Nuke it because
+ it'll override our member name */
+#undef Status
+#endif
+
+class nsIJARChannel;
+class nsILoadGroup;
+class nsIUnicodeDecoder;
+class nsIJSID;
+
+namespace mozilla {
+namespace dom {
+
+class Blob;
+class BlobSet;
+class DOMString;
+class FormData;
+class URLSearchParams;
+class XMLHttpRequestUpload;
+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,
+// or it can be reset explicitly at any point by calling reset().
+class ArrayBufferBuilder
+{
+ uint8_t* mDataPtr;
+ uint32_t mCapacity;
+ uint32_t mLength;
+ void* mMapPtr;
+public:
+ ArrayBufferBuilder();
+ ~ArrayBufferBuilder();
+
+ void reset();
+
+ // 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() { return mLength; }
+ uint32_t capacity() { return mCapacity; }
+
+ JSObject* getArrayBuffer(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);
+
+protected:
+ static bool areOverlappingRegions(const uint8_t* aStart1, uint32_t aLength1,
+ const uint8_t* aStart2, uint32_t aLength2);
+};
+
+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 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) const;
+ void GetCORSUnsafeHeaders(nsTArray<nsCString>& aArray) const;
+};
+
+// Make sure that any non-DOM interfaces added here are also added to
+// nsXMLHttpRequestXPCOMifier.
+class XMLHttpRequestMainThread final : public XMLHttpRequest,
+ public nsIXMLHttpRequest,
+ public nsIJSXMLHttpRequest,
+ public nsIStreamListener,
+ public nsIChannelEventSink,
+ public nsIProgressEventSink,
+ public nsIInterfaceRequestor,
+ public nsSupportsWeakReference,
+ public nsITimerCallback,
+ public nsISizeOfEventTarget,
+ public MutableBlobStorageCallback
+{
+ friend class nsXHRParseEndListener;
+ friend class nsXMLHttpRequestXPCOMifier;
+
+public:
+ enum class ProgressEventType : uint8_t {
+ loadstart,
+ progress,
+ error,
+ abort,
+ timeout,
+ load,
+ loadend,
+ ENUM_MAX
+ };
+
+ XMLHttpRequestMainThread();
+
+ void Construct(nsIPrincipal* aPrincipal,
+ nsIGlobalObject* aGlobalObject,
+ nsIURI* aBaseURI = nullptr,
+ nsILoadGroup* aLoadGroup = nullptr)
+ {
+ MOZ_ASSERT(aPrincipal);
+ MOZ_ASSERT_IF(nsCOMPtr<nsPIDOMWindowInner> win = do_QueryInterface(
+ aGlobalObject), win->IsInnerWindow());
+ mPrincipal = aPrincipal;
+ BindToOwner(aGlobalObject);
+ mBaseURI = aBaseURI;
+ mLoadGroup = aLoadGroup;
+ }
+
+ void InitParameters(bool aAnon, bool aSystem);
+
+ void SetParameters(bool aAnon, bool aSystem)
+ {
+ mIsAnon = aAnon || aSystem;
+ mIsSystem = aSystem;
+ }
+
+ NS_DECL_ISUPPORTS_INHERITED
+
+ // nsIXMLHttpRequest
+ NS_DECL_NSIXMLHTTPREQUEST
+
+ NS_FORWARD_NSIXMLHTTPREQUESTEVENTTARGET(XMLHttpRequestEventTarget::)
+
+ // nsIStreamListener
+ NS_DECL_NSISTREAMLISTENER
+
+ // nsIRequestObserver
+ NS_DECL_NSIREQUESTOBSERVER
+
+ // nsIChannelEventSink
+ NS_DECL_NSICHANNELEVENTSINK
+
+ // nsIProgressEventSink
+ NS_DECL_NSIPROGRESSEVENTSINK
+
+ // nsIInterfaceRequestor
+ NS_DECL_NSIINTERFACEREQUESTOR
+
+ // nsITimerCallback
+ NS_DECL_NSITIMERCALLBACK
+
+ // nsISizeOfEventTarget
+ virtual size_t
+ SizeOfEventTargetIncludingThis(MallocSizeOf aMallocSizeOf) const override;
+
+ NS_REALLY_FORWARD_NSIDOMEVENTTARGET(XMLHttpRequestEventTarget)
+
+ // states
+ virtual uint16_t ReadyState() const override;
+
+ // request
+ nsresult CreateChannel();
+ nsresult InitiateFetch(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;
+
+ nsresult
+ Open(const nsACString& aMethod,
+ const nsACString& aUrl,
+ bool aAsync,
+ const nsAString& aUsername,
+ const nsAString& aPassword);
+
+ virtual void
+ SetRequestHeader(const nsACString& aName, const nsACString& aValue,
+ ErrorResult& aRv) override
+ {
+ aRv = SetRequestHeader(aName, aValue);
+ }
+
+ 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();
+
+ class RequestBodyBase
+ {
+ public:
+ virtual nsresult GetAsStream(nsIInputStream** aResult,
+ uint64_t* aContentLength,
+ nsACString& aContentType,
+ nsACString& aCharset) const
+ {
+ NS_ASSERTION(false, "RequestBodyBase should not be used directly.");
+ return NS_ERROR_FAILURE;
+ }
+ };
+
+ template<typename Type>
+ class RequestBody final : public RequestBodyBase
+ {
+ Type* mBody;
+ public:
+ explicit RequestBody(Type* aBody) : mBody(aBody)
+ {
+ }
+ nsresult GetAsStream(nsIInputStream** aResult,
+ uint64_t* aContentLength,
+ nsACString& aContentType,
+ nsACString& aCharset) const override;
+ };
+
+ nsresult SendInternal(const RequestBodyBase* aBody);
+
+ bool IsCrossSiteCORSRequest() const;
+ bool IsDeniedCrossSiteCORSRequest();
+
+ // Tell our channel what network interface ID we were told to use.
+ // If it's an HTTP channel and we were told to use a non-default
+ // interface ID.
+ void PopulateNetworkInterfaceId();
+
+public:
+ virtual void
+ Send(JSContext* /*aCx*/, ErrorResult& aRv) override
+ {
+ aRv = SendInternal(nullptr);
+ }
+
+ virtual void
+ Send(JSContext* /*aCx*/, const ArrayBuffer& aArrayBuffer,
+ ErrorResult& aRv) override
+ {
+ RequestBody<const ArrayBuffer> body(&aArrayBuffer);
+ aRv = SendInternal(&body);
+ }
+
+ virtual void
+ Send(JSContext* /*aCx*/, const ArrayBufferView& aArrayBufferView,
+ ErrorResult& aRv) override
+ {
+ RequestBody<const ArrayBufferView> body(&aArrayBufferView);
+ aRv = SendInternal(&body);
+ }
+
+ virtual void
+ Send(JSContext* /*aCx*/, Blob& aBlob, ErrorResult& aRv) override
+ {
+ RequestBody<Blob> body(&aBlob);
+ aRv = SendInternal(&body);
+ }
+
+ virtual void Send(JSContext* /*aCx*/, URLSearchParams& aURLSearchParams,
+ ErrorResult& aRv) override
+ {
+ RequestBody<URLSearchParams> body(&aURLSearchParams);
+ aRv = SendInternal(&body);
+ }
+
+ virtual void
+ Send(JSContext* /*aCx*/, nsIDocument& aDoc, ErrorResult& aRv) override
+ {
+ RequestBody<nsIDocument> body(&aDoc);
+ aRv = SendInternal(&body);
+ }
+
+ virtual void
+ Send(JSContext* aCx, const nsAString& aString, ErrorResult& aRv) override
+ {
+ if (DOMStringIsNull(aString)) {
+ Send(aCx, aRv);
+ } else {
+ RequestBody<const nsAString> body(&aString);
+ aRv = SendInternal(&body);
+ }
+ }
+
+ virtual void
+ Send(JSContext* /*aCx*/, FormData& aFormData, ErrorResult& aRv) override
+ {
+ RequestBody<FormData> body(&aFormData);
+ aRv = SendInternal(&body);
+ }
+
+ virtual void
+ Send(JSContext* aCx, nsIInputStream* aStream, ErrorResult& aRv) override
+ {
+ NS_ASSERTION(aStream, "Null should go to string version");
+ RequestBody<nsIInputStream> body(aStream);
+ aRv = SendInternal(&body);
+ }
+
+ void
+ Abort() {
+ ErrorResult rv;
+ Abort(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;
+
+ virtual void
+ GetResponse(JSContext* aCx, JS::MutableHandle<JS::Value> aResponse,
+ ErrorResult& aRv) override;
+
+ virtual void
+ GetResponseText(DOMString& aResponseText, ErrorResult& aRv) override;
+
+ void
+ GetResponseText(XMLHttpRequestStringSnapshot& aSnapshot,
+ ErrorResult& aRv);
+
+ virtual nsIDocument*
+ GetResponseXML(ErrorResult& aRv) override;
+
+ virtual bool
+ MozBackgroundRequest() const override;
+
+ virtual void
+ SetMozBackgroundRequest(bool aMozBackgroundRequest, ErrorResult& aRv) override;
+
+ virtual bool
+ MozAnon() const override;
+
+ virtual bool
+ MozSystem() const override;
+
+ virtual nsIChannel*
+ GetChannel() const override
+ {
+ return mChannel;
+ }
+
+ virtual void
+ GetNetworkInterfaceId(nsACString& aId) const override
+ {
+ aId = mNetworkInterfaceId;
+ }
+
+ virtual void
+ SetNetworkInterfaceId(const nsACString& aId) override
+ {
+ mNetworkInterfaceId = aId;
+ }
+
+ // We need a GetInterface callable from JS for chrome JS
+ virtual void
+ GetInterface(JSContext* aCx, nsIJSID* 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);
+
+ // This is called by the factory constructor.
+ nsresult Init();
+
+ nsresult init(nsIPrincipal* principal,
+ nsPIDOMWindowInner* globalObject,
+ nsIURI* baseURI);
+
+ void SetRequestObserver(nsIRequestObserver* aObserver);
+
+ NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS_INHERITED(XMLHttpRequestMainThread,
+ XMLHttpRequest)
+ 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,
+ Blob* aBlob,
+ nsresult aResult) override;
+
+protected:
+ // XHR states are meant to mirror the XHR2 spec:
+ // https://xhr.spec.whatwg.org/#states
+ enum class State : uint8_t {
+ unsent, // object has been constructed.
+ opened, // open() has been successfully invoked.
+ headers_received, // redirects followed and response headers received.
+ loading, // response body is being received.
+ done, // data transfer concluded, whether success or error.
+ };
+
+ nsresult DetectCharset();
+ nsresult AppendToResponseText(const char * aBuffer, uint32_t aBufferLen);
+ static nsresult StreamReaderFunc(nsIInputStream* in,
+ void* closure,
+ const char* fromRawSegment,
+ uint32_t toOffset,
+ uint32_t count,
+ uint32_t *writeCount);
+ nsresult CreateResponseParsedJSON(JSContext* aCx);
+ void CreatePartialBlob(ErrorResult& aRv);
+ bool CreateDOMBlob(nsIRequest *request);
+ // Change the state of the object with this. The broadcast argument
+ // determines if the onreadystatechange listener should be called.
+ nsresult ChangeState(State aState, bool aBroadcast = true);
+ already_AddRefed<nsILoadGroup> GetLoadGroup() const;
+ nsIURI *GetBaseURI();
+
+ already_AddRefed<nsIHttpChannel> GetCurrentHttpChannel();
+ already_AddRefed<nsIJARChannel> GetCurrentJARChannel();
+
+ void TruncateResponseText();
+
+ bool IsSystemXHR() const;
+ bool InUploadPhase() const;
+
+ void OnBodyParseEnd();
+ void ChangeStateToDone();
+
+ void StartProgressEventTimer();
+ void StopProgressEventTimer();
+
+ void MaybeCreateBlobStorage();
+
+ nsresult OnRedirectVerifyCallback(nsresult result);
+
+ already_AddRefed<nsXMLHttpRequestXPCOMifier> EnsureXPCOMifier();
+
+ nsCOMPtr<nsISupports> mContext;
+ nsCOMPtr<nsIPrincipal> mPrincipal;
+ nsCOMPtr<nsIChannel> mChannel;
+ nsCString mRequestMethod;
+ nsCOMPtr<nsIURI> mRequestURL;
+ nsCOMPtr<nsIDocument> mResponseXML;
+
+ nsCOMPtr<nsIStreamListener> mXMLParserStreamListener;
+
+ // used to implement getAllResponseHeaders()
+ class nsHeaderVisitor : public nsIHttpHeaderVisitor
+ {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIHTTPHEADERVISITOR
+ nsHeaderVisitor(const XMLHttpRequestMainThread& aXMLHttpRequest,
+ NotNull<nsIHttpChannel*> aHttpChannel)
+ : mXHR(aXMLHttpRequest), mHttpChannel(aHttpChannel) {}
+ const nsACString &Headers() { return mHeaders; }
+ private:
+ virtual ~nsHeaderVisitor() {}
+
+ 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.
+ nsCOMPtr<nsIUnicodeDecoder> mDecoder;
+
+ nsCString mResponseCharset;
+
+ void MatchCharsetAndDecoderToResponseDocument();
+
+ XMLHttpRequestResponseType mResponseType;
+
+ // It is either a cached blob-response from the last call to GetResponse,
+ // but is also explicitly set in OnStopRequest.
+ RefPtr<Blob> mResponseBlob;
+ // Non-null only when we are able to get a os-file representation of the
+ // response, i.e. when loading from a file.
+ RefPtr<Blob> mDOMBlob;
+ // We stream data to mBlobStorage when response type is "blob" and mDOMBlob is
+ // null.
+ RefPtr<MutableBlobStorage> mBlobStorage;
+ // We stream data to mBlobStorage when response type is "moz-blob" and
+ // mDOMBlob is null.
+ nsAutoPtr<BlobSet> mBlobSet;
+
+ 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;
+
+ nsIRequestObserver* mRequestObserver;
+
+ nsCOMPtr<nsIURI> mBaseURI;
+ nsCOMPtr<nsILoadGroup> mLoadGroup;
+
+ State mState;
+
+ 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<nsITimer> mSyncTimeoutTimer;
+
+ enum SyncTimeoutType {
+ eErrorOrExpired,
+ eTimerStarted,
+ eNoTimerNeeded
+ };
+
+ SyncTimeoutType MaybeStartSyncTimeoutTimer();
+ void HandleSyncTimeoutTimer();
+ void CancelSyncTimeoutTimer();
+
+ bool mErrorLoad;
+ bool mErrorParsingXML;
+ bool mWaitingForOnStopRequest;
+ bool mProgressTimerIsActive;
+ bool mIsHtml;
+ bool mWarnAboutMultipartHtml;
+ bool mWarnAboutSyncHtml;
+ int64_t mLoadTotal; // -1 if not known.
+ // Amount of script-exposed (i.e. after undoing gzip compresion) data
+ // received.
+ uint64_t mDataAvailable;
+ // 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;
+
+ // A platform-specific identifer to represent the network interface
+ // that this request is associated with.
+ nsCString mNetworkInterfaceId;
+
+ /**
+ * Close the XMLHttpRequest's channels.
+ */
+ void CloseRequest();
+
+ /**
+ * Close the XMLHttpRequest's channels and dispatch appropriate progress
+ * events.
+ *
+ * @param aType The progress event type.
+ */
+ void CloseRequestWithError(const ProgressEventType aType);
+
+ bool mFirstStartRequestSeen;
+ bool mInLoadProgressEvent;
+
+ nsCOMPtr<nsIAsyncVerifyRedirectCallback> mRedirectCallback;
+ nsCOMPtr<nsIChannel> mNewRedirectChannel;
+
+ JS::Heap<JS::Value> mResultJSON;
+
+ ArrayBufferBuilder mArrayBufferBuilder;
+ JS::Heap<JSObject*> mResultArrayBuffer;
+ bool mIsMappedArrayBuffer;
+
+ void ResetResponse();
+
+ bool ShouldBlockAuthPrompt();
+
+ RequestHeaders mAuthorRequestHeaders;
+
+ // Helper object to manage our XPCOM scriptability bits
+ nsXMLHttpRequestXPCOMifier* mXPCOMifier;
+
+ 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
+{
+ 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_DECL_NSIINTERFACEREQUESTOR
+
+private:
+ RefPtr<XMLHttpRequestMainThread> mXHR;
+};
+
+class nsXHRParseEndListener : public nsIDOMEventListener
+{
+public:
+ NS_DECL_ISUPPORTS
+ NS_IMETHOD HandleEvent(nsIDOMEvent *event) override
+ {
+ nsCOMPtr<nsIXMLHttpRequest> xhr = do_QueryReferent(mXHR);
+ if (xhr) {
+ static_cast<XMLHttpRequestMainThread*>(xhr.get())->OnBodyParseEnd();
+ }
+ mXHR = nullptr;
+ return NS_OK;
+ }
+ explicit nsXHRParseEndListener(nsIXMLHttpRequest* aXHR)
+ : mXHR(do_GetWeakReference(aXHR)) {}
+private:
+ virtual ~nsXHRParseEndListener() {}
+
+ nsWeakPtr mXHR;
+};
+
+} // dom namespace
+} // mozilla namespace
+
+#endif // mozilla_dom_XMLHttpRequestMainThread_h