tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

XMLHttpRequest.h (7300B)

      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 
     12 #include "mozilla/ErrorResult.h"
     13 #include "mozilla/dom/XMLHttpRequestBinding.h"
     14 #include "mozilla/dom/XMLHttpRequestEventTarget.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 nsACString& aUrl,
    104                    ErrorResult& aRv) = 0;
    105 
    106  virtual void Open(const nsACString& aMethod, const nsACString& aUrl,
    107                    bool aAsync, const nsACString& aUser,
    108                    const nsACString& 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(nsACString& 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