dom/xhr/XMLHttpRequestWorker.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_XMLHttpRequestWorker_h
   8 #define mozilla_dom_XMLHttpRequestWorker_h
   9
  10 #include "XMLHttpRequest.h"
  11 #include "XMLHttpRequestString.h"
  12 #include "mozilla/WeakPtr.h"
  13 #include "mozilla/dom/BodyExtractor.h"
  14 #include "mozilla/dom/TypedArray.h"
  15
  16 // XXX Avoid including this here by moving function bodies to the cpp file
  17 #include "mozilla/dom/BlobImpl.h"
  18
  19 namespace mozilla::dom {
  20
  21 class Proxy;
  22 class DOMString;
  23 class SendRunnable;
  24 class StrongWorkerRef;
  25 class WorkerPrivate;
  26
  27 class XMLHttpRequestWorker final : public SupportsWeakPtr,
  28                                    public XMLHttpRequest {
  29  public:
  30   // This defines the xhr.response value.
  31   struct ResponseData {
  32     nsresult mResponseResult;
  33
  34     // responseType is empty or text.
  35     XMLHttpRequestStringSnapshot mResponseText;
  36
  37     // responseType is blob
  38     RefPtr<BlobImpl> mResponseBlobImpl;
  39
  40     // responseType is arrayBuffer;
  41     RefPtr<ArrayBufferBuilder> mResponseArrayBufferBuilder;
  42
  43     // responseType is json
  44     nsString mResponseJSON;
  45
  46     ResponseData() : mResponseResult(NS_OK) {}
  47   };
  48
  49   struct StateData {
  50     nsString mResponseURL;
  51     uint32_t mStatus;
  52     nsCString mStatusText;
  53     uint16_t mReadyState;
  54     bool mFlagSend;
  55     nsresult mStatusResult;
  56
  57     StateData()
  58         : mStatus(0), mReadyState(0), mFlagSend(false), mStatusResult(NS_OK) {}
  59   };
  60
  61  private:
  62   RefPtr<XMLHttpRequestUpload> mUpload;
  63   WorkerPrivate* mWorkerPrivate;
  64   RefPtr<StrongWorkerRef> mWorkerRef;
  65   RefPtr<XMLHttpRequestWorker> mPinnedSelfRef;
  66   RefPtr<Proxy> mProxy;
  67
  68   XMLHttpRequestResponseType mResponseType;
  69
  70   UniquePtr<StateData> mStateData;
  71
  72   UniquePtr<ResponseData> mResponseData;
  73   RefPtr<Blob> mResponseBlob;
  74   JS::Heap<JSObject*> mResponseArrayBufferValue;
  75   JS::Heap<JS::Value> mResponseJSONValue;
  76
  77   uint32_t mTimeout;
  78
  79   bool mBackgroundRequest;
  80   bool mWithCredentials;
  81   bool mCanceled;
  82   bool mFlagSendActive;
  83
  84   bool mMozAnon;
  85   bool mMozSystem;
  86
  87   nsString mMimeTypeOverride;
  88
  89  public:
  90   NS_DECL_ISUPPORTS_INHERITED
  91   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(XMLHttpRequestWorker,
  92                                                          XMLHttpRequest)
  93
  94   static already_AddRefed<XMLHttpRequest> Construct(
  95       const GlobalObject& aGlobal, const MozXMLHttpRequestParameters& aParams,
  96       ErrorResult& aRv);
  97
  98   void Unpin();
  99
 100   virtual uint16_t ReadyState() const override {
 101     return mStateData->mReadyState;
 102   }
 103
 104   virtual void Open(const nsACString& aMethod, const nsAString& aUrl,
 105                     ErrorResult& aRv) override {
 106     Open(aMethod, aUrl, true, Optional<nsAString>(), Optional<nsAString>(),
 107          aRv);
 108   }
 109
 110   virtual void Open(const nsACString& aMethod, const nsAString& aUrl,
 111                     bool aAsync, const nsAString& aUsername,
 112                     const nsAString& aPassword, ErrorResult& aRv) override {
 113     Optional<nsAString> username;
 114     username = &aUsername;
 115     Optional<nsAString> password;
 116     password = &aPassword;
 117     Open(aMethod, aUrl, aAsync, username, password, aRv);
 118   }
 119
 120   void Open(const nsACString& aMethod, const nsAString& aUrl, bool aAsync,
 121             const Optional<nsAString>& aUser,
 122             const Optional<nsAString>& aPassword, ErrorResult& aRv);
 123
 124   virtual void SetRequestHeader(const nsACString& aHeader,
 125                                 const nsACString& aValue,
 126                                 ErrorResult& aRv) override;
 127
 128   virtual uint32_t Timeout() const override { return mTimeout; }
 129
 130   virtual void SetTimeout(uint32_t aTimeout, ErrorResult& aRv) override;
 131
 132   virtual bool WithCredentials() const override { return mWithCredentials; }
 133
 134   virtual void SetWithCredentials(bool aWithCredentials,
 135                                   ErrorResult& aRv) override;
 136
 137   virtual bool MozBackgroundRequest() const override {
 138     return mBackgroundRequest;
 139   }
 140
 141   virtual void SetMozBackgroundRequest(bool aBackgroundRequest,
 142                                        ErrorResult& aRv) override;
 143
 144   virtual nsIChannel* GetChannel() const override {
 145     MOZ_CRASH("This method cannot be called on workers.");
 146   }
 147
 148   virtual XMLHttpRequestUpload* GetUpload(ErrorResult& aRv) override;
 149
 150   virtual void Send(
 151       const Nullable<
 152           DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString>&
 153           aData,
 154       ErrorResult& aRv) override;
 155
 156   virtual void SendInputStream(nsIInputStream* aInputStream,
 157                                ErrorResult& aRv) override {
 158     MOZ_CRASH("nsIInputStream is not a valid argument for XHR in workers.");
 159   }
 160
 161   virtual void Abort(ErrorResult& aRv) override;
 162
 163   virtual void GetResponseURL(nsAString& aUrl) override {
 164     aUrl = mStateData->mResponseURL;
 165   }
 166
 167   uint32_t GetStatus(ErrorResult& aRv) override {
 168     aRv = mStateData->mStatusResult;
 169     return mStateData->mStatus;
 170   }
 171
 172   virtual void GetStatusText(nsACString& aStatusText,
 173                              ErrorResult& aRv) override {
 174     aStatusText = mStateData->mStatusText;
 175   }
 176
 177   virtual void GetResponseHeader(const nsACString& aHeader,
 178                                  nsACString& aResponseHeader,
 179                                  ErrorResult& aRv) override;
 180
 181   virtual void GetAllResponseHeaders(nsACString& aResponseHeaders,
 182                                      ErrorResult& aRv) override;
 183
 184   virtual void OverrideMimeType(const nsAString& aMimeType,
 185                                 ErrorResult& aRv) override;
 186
 187   virtual XMLHttpRequestResponseType ResponseType() const override {
 188     return mResponseType;
 189   }
 190
 191   virtual void SetResponseType(XMLHttpRequestResponseType aResponseType,
 192                                ErrorResult& aRv) override;
 193
 194   virtual void GetResponse(JSContext* /* unused */,
 195                            JS::MutableHandle<JS::Value> aResponse,
 196                            ErrorResult& aRv) override;
 197
 198   virtual void GetResponseText(DOMString& aResponseText,
 199                                ErrorResult& aRv) override;
 200
 201   virtual Document* GetResponseXML(ErrorResult& aRv) override {
 202     MOZ_CRASH("This method should not be called.");
 203   }
 204
 205   virtual void GetInterface(JSContext* aCx, JS::Handle<JS::Value> aIID,
 206                             JS::MutableHandle<JS::Value> aRetval,
 207                             ErrorResult& aRv) override {
 208     aRv.Throw(NS_ERROR_FAILURE);
 209   }
 210
 211   virtual void SetOriginAttributes(
 212       const mozilla::dom::OriginAttributesDictionary& aAttrs) override {
 213     MOZ_CRASH("This method cannot be called on workers.");
 214   }
 215
 216   XMLHttpRequestUpload* GetUploadObjectNoCreate() const { return mUpload; }
 217
 218   void UpdateState(UniquePtr<StateData>&& aStateData,
 219                    UniquePtr<ResponseData>&& aResponseData);
 220
 221   virtual uint16_t ErrorCode() const override {
 222     return 0;  // eOK
 223   }
 224
 225   virtual bool MozAnon() const override { return mMozAnon; }
 226
 227   virtual bool MozSystem() const override { return mMozSystem; }
 228
 229   bool SendInProgress() const { return !!mWorkerRef; }
 230
 231  private:
 232   XMLHttpRequestWorker(WorkerPrivate* aWorkerPrivate,
 233                        nsIGlobalObject* aGlobalObject);
 234   ~XMLHttpRequestWorker();
 235
 236   enum ReleaseType { Default, XHRIsGoingAway, WorkerIsGoingAway };
 237
 238   void ReleaseProxy(ReleaseType aType = Default);
 239
 240   void MaybePin(ErrorResult& aRv);
 241
 242   void MaybeDispatchPrematureAbortEvents(ErrorResult& aRv);
 243
 244   void FireEvent(EventTarget* aTarget, const EventType& aEventType,
 245                  bool aUploadTarget, ErrorResult& aRv);
 246
 247   void Send(JSContext* aCx, JS::Handle<JSObject*> aBody, ErrorResult& aRv);
 248
 249   void SendInternal(const BodyExtractorBase* aBody, ErrorResult& aRv);
 250
 251   void ResetResponseData();
 252 };
 253
 254 }  // namespace mozilla::dom
 255
 256 #endif  // mozilla_dom_workers_xmlhttprequest_h__