dom/xhr/XMLHttpRequest.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_XMLHttpRequest_h
   8 #define mozilla_dom_XMLHttpRequest_h
   9
  10 #include <iterator>  // std::begin, std::end
  11 #include "mozilla/Attributes.h"
  12 #include "mozilla/ErrorResult.h"
  13 #include "mozilla/dom/XMLHttpRequestEventTarget.h"
  14 #include "mozilla/dom/XMLHttpRequestBinding.h"
  15
  16 class nsIInputStream;
  17
  18 namespace mozilla::dom {
  19
  20 class Blob;
  21 class DOMString;
  22 class FormData;
  23 class URLSearchParams;
  24 class XMLHttpRequestUpload;
  25
  26 class XMLHttpRequest : public XMLHttpRequestEventTarget {
  27  public:
  28   struct EventType {
  29     const char* cStr;
  30     const char16_t* str;
  31
  32     constexpr EventType(const char* name, const char16_t* uname)
  33         : cStr(name), str(uname) {}
  34
  35     constexpr EventType(const EventType& other)
  36         : cStr(other.cStr), str(other.str) {}
  37
  38     operator const nsDependentString() const { return nsDependentString(str); }
  39
  40     friend bool operator==(const EventType& a, const EventType& b) {
  41       return !strcmp(a.cStr, b.cStr);
  42     }
  43
  44     friend bool operator!=(const EventType& a, const EventType& b) {
  45       return strcmp(a.cStr, b.cStr);
  46     }
  47
  48     friend bool operator==(const nsAString& a, const EventType& b) {
  49       return a.Equals(b.str);
  50     }
  51
  52     friend bool operator!=(const nsAString& a, const EventType& b) {
  53       return !a.Equals(b.str);
  54     }
  55
  56     inline bool operator==(const nsString& b) const { return b.Equals(str); }
  57
  58     inline bool operator!=(const nsString& b) const { return !b.Equals(str); }
  59   };
  60
  61   struct ProgressEventType : public EventType {
  62     constexpr ProgressEventType(const char* name, const char16_t* uname)
  63         : EventType(name, uname) {}
  64   };
  65
  66   struct ErrorProgressEventType : public ProgressEventType {
  67     const nsresult errorCode;
  68     constexpr ErrorProgressEventType(const char* name, const char16_t* uname,
  69                                      const nsresult code)
  70         : ProgressEventType(name, uname), errorCode(code) {}
  71   };
  72
  73 #define DECL_EVENT(NAME) static constexpr EventType NAME{#NAME, u## #NAME};
  74
  75 #define DECL_PROGRESSEVENT(NAME) \
  76   static constexpr ProgressEventType NAME { #NAME, u## #NAME }
  77
  78 #define DECL_ERRORPROGRESSEVENT(NAME, ERR) \
  79   static constexpr ErrorProgressEventType NAME{#NAME, u## #NAME, ERR};
  80
  81   struct Events;
  82
  83   static already_AddRefed<XMLHttpRequest> Constructor(
  84       const GlobalObject& aGlobal, const MozXMLHttpRequestParameters& aParams,
  85       ErrorResult& aRv);
  86
  87   static already_AddRefed<XMLHttpRequest> Constructor(
  88       const GlobalObject& aGlobal, const nsAString& ignored, ErrorResult& aRv) {
  89     // Pretend like someone passed null, so we can pick up the default values
  90     MozXMLHttpRequestParameters params;
  91     if (!params.Init(aGlobal.Context(), JS::NullHandleValue)) {
  92       aRv.Throw(NS_ERROR_UNEXPECTED);
  93       return nullptr;
  94     }
  95
  96     return Constructor(aGlobal, params, aRv);
  97   }
  98
  99   IMPL_EVENT_HANDLER(readystatechange)
 100
 101   virtual uint16_t ReadyState() const = 0;
 102
 103   virtual void Open(const nsACString& aMethod, const nsAString& aUrl,
 104                     ErrorResult& aRv) = 0;
 105
 106   virtual void Open(const nsACString& aMethod, const nsAString& aUrl,
 107                     bool aAsync, const nsAString& aUser,
 108                     const nsAString& aPassword, ErrorResult& aRv) = 0;
 109
 110   virtual void SetRequestHeader(const nsACString& aHeader,
 111                                 const nsACString& aValue, ErrorResult& aRv) = 0;
 112
 113   virtual uint32_t Timeout() const = 0;
 114
 115   virtual void SetTimeout(uint32_t aTimeout, ErrorResult& aRv) = 0;
 116
 117   virtual bool WithCredentials() const = 0;
 118
 119   virtual void SetWithCredentials(bool aWithCredentials, ErrorResult& aRv) = 0;
 120
 121   virtual XMLHttpRequestUpload* GetUpload(ErrorResult& aRv) = 0;
 122
 123   virtual void Send(
 124       const Nullable<
 125           DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString>&
 126           aData,
 127       ErrorResult& aRv) = 0;
 128
 129   virtual void SendInputStream(nsIInputStream* aInputStream,
 130                                ErrorResult& aRv) = 0;
 131
 132   virtual void Abort(ErrorResult& aRv) = 0;
 133
 134   virtual void GetResponseURL(nsAString& aUrl) = 0;
 135
 136   virtual uint32_t GetStatus(ErrorResult& aRv) = 0;
 137
 138   virtual void GetStatusText(nsACString& aStatusText, ErrorResult& aRv) = 0;
 139
 140   virtual void GetResponseHeader(const nsACString& aHeader, nsACString& aResult,
 141                                  ErrorResult& aRv) = 0;
 142
 143   virtual void GetAllResponseHeaders(nsACString& aResponseHeaders,
 144                                      ErrorResult& aRv) = 0;
 145
 146   virtual void OverrideMimeType(const nsAString& aMimeType,
 147                                 ErrorResult& aRv) = 0;
 148
 149   virtual XMLHttpRequestResponseType ResponseType() const = 0;
 150
 151   virtual void SetResponseType(XMLHttpRequestResponseType aType,
 152                                ErrorResult& aRv) = 0;
 153
 154   virtual void GetResponse(JSContext* aCx,
 155                            JS::MutableHandle<JS::Value> aResponse,
 156                            ErrorResult& aRv) = 0;
 157
 158   virtual void GetResponseText(DOMString& aResponseText, ErrorResult& aRv) = 0;
 159
 160   virtual Document* GetResponseXML(ErrorResult& aRv) = 0;
 161
 162   virtual bool MozBackgroundRequest() const = 0;
 163
 164   virtual void SetMozBackgroundRequest(bool aMozBackgroundRequest,
 165                                        ErrorResult& aRv) = 0;
 166
 167   virtual nsIChannel* GetChannel() const = 0;
 168
 169   // We need a GetInterface callable from JS for chrome JS
 170   virtual void GetInterface(JSContext* aCx, JS::Handle<JS::Value> aIID,
 171                             JS::MutableHandle<JS::Value> aRetval,
 172                             ErrorResult& aRv) = 0;
 173
 174   virtual void SetOriginAttributes(
 175       const mozilla::dom::OriginAttributesDictionary& aAttrs) = 0;
 176
 177   virtual uint16_t ErrorCode() const = 0;
 178
 179   virtual bool MozAnon() const = 0;
 180
 181   virtual bool MozSystem() const = 0;
 182
 183   virtual JSObject* WrapObject(JSContext* aCx,
 184                                JS::Handle<JSObject*> aGivenProto) override {
 185     return mozilla::dom::XMLHttpRequest_Binding::Wrap(aCx, this, aGivenProto);
 186   }
 187
 188  protected:
 189   explicit XMLHttpRequest(nsIGlobalObject* aGlobalObject)
 190       : XMLHttpRequestEventTarget(aGlobalObject) {}
 191 };
 192
 193 struct XMLHttpRequest::Events {
 194   DECL_EVENT(readystatechange);
 195   DECL_PROGRESSEVENT(loadstart);
 196   DECL_PROGRESSEVENT(progress);
 197   DECL_ERRORPROGRESSEVENT(error, NS_ERROR_DOM_NETWORK_ERR);
 198   DECL_ERRORPROGRESSEVENT(abort, NS_ERROR_DOM_ABORT_ERR);
 199   DECL_ERRORPROGRESSEVENT(timeout, NS_ERROR_DOM_TIMEOUT_ERR);
 200   DECL_PROGRESSEVENT(load);
 201   DECL_PROGRESSEVENT(loadend);
 202
 203   static inline const EventType* All[]{
 204       &readystatechange, &loadstart, &progress, &error, &abort,
 205       &timeout,          &load,      &loadend};
 206
 207   static inline const EventType* ProgressEvents[]{
 208       &loadstart, &progress, &error, &abort, &timeout, &load, &loadend};
 209
 210   static inline const EventType* Find(const nsString& name) {
 211     for (const EventType* type : Events::All) {
 212       if (*type == name) {
 213         return type;
 214       }
 215     }
 216     return nullptr;
 217   }
 218 };
 219
 220 }  // namespace mozilla::dom
 221
 222 #endif  // mozilla_dom_XMLHttpRequest_h