Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 221 insertions, 0 deletions

diff --git a/dom/xhr/XMLHttpRequest.h b/dom/xhr/XMLHttpRequest.h
new file mode 100644
index 0000000000..0d82f8c035
--- /dev/null
+++ b/dom/xhr/XMLHttpRequest.h
@@ -0,0 +1,221 @@
+/* -*- 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_XMLHttpRequest_h
+#define mozilla_dom_XMLHttpRequest_h
+
+#include <iterator>  // std::begin, std::end
+#include "mozilla/Attributes.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/dom/XMLHttpRequestEventTarget.h"
+#include "mozilla/dom/XMLHttpRequestBinding.h"
+
+class nsIInputStream;
+
+namespace mozilla::dom {
+
+class Blob;
+class DOMString;
+class FormData;
+class URLSearchParams;
+class XMLHttpRequestUpload;
+
+class XMLHttpRequest : public XMLHttpRequestEventTarget {
+ public:
+  struct EventType {
+    const char* cStr;
+    const char16_t* str;
+
+    EventType(const char* name, const char16_t* uname)
+        : cStr(name), str(uname) {}
+
+    operator const nsDependentString() const { return nsDependentString(str); }
+
+    friend bool operator==(const EventType& a, const EventType& b) {
+      return !strcmp(a.cStr, b.cStr);
+    }
+
+    friend bool operator!=(const EventType& a, const EventType& b) {
+      return strcmp(a.cStr, b.cStr);
+    }
+
+    friend bool operator==(const nsAString& a, const EventType& b) {
+      return a.Equals(b.str);
+    }
+
+    friend bool operator!=(const nsAString& a, const EventType& b) {
+      return !a.Equals(b.str);
+    }
+
+    inline bool operator==(const nsString& b) const { return b.Equals(str); }
+
+    inline bool operator!=(const nsString& b) const { return !b.Equals(str); }
+  };
+
+  struct ProgressEventType : public EventType {
+    ProgressEventType(const char* name, const char16_t* uname)
+        : EventType(name, uname) {}
+  };
+
+  struct ErrorProgressEventType : public ProgressEventType {
+    const nsresult errorCode;
+
+    ErrorProgressEventType(const char* name, const char16_t* uname,
+                           const nsresult code)
+        : ProgressEventType(name, uname), errorCode(code) {}
+  };
+
+#define DECL_EVENT(NAME) \
+  static inline const EventType NAME = EventType(#NAME, u## #NAME);
+
+#define DECL_PROGRESSEVENT(NAME)               \
+  static inline const ProgressEventType NAME = \
+      ProgressEventType(#NAME, u## #NAME);
+
+#define DECL_ERRORPROGRESSEVENT(NAME, ERR)          \
+  static inline const ErrorProgressEventType NAME = \
+      ErrorProgressEventType(#NAME, u## #NAME, ERR);
+
+  struct Events {
+    DECL_EVENT(readystatechange);
+    DECL_PROGRESSEVENT(loadstart);
+    DECL_PROGRESSEVENT(progress);
+    DECL_ERRORPROGRESSEVENT(error, NS_ERROR_DOM_NETWORK_ERR);
+    DECL_ERRORPROGRESSEVENT(abort, NS_ERROR_DOM_ABORT_ERR);
+    DECL_ERRORPROGRESSEVENT(timeout, NS_ERROR_DOM_TIMEOUT_ERR);
+    DECL_PROGRESSEVENT(load);
+    DECL_PROGRESSEVENT(loadend);
+
+    static inline const EventType* All[]{
+        &readystatechange, &loadstart, &progress, &error, &abort,
+        &timeout,          &load,      &loadend};
+
+    static inline const EventType* ProgressEvents[]{
+        &loadstart, &progress, &error, &abort, &timeout, &load, &loadend};
+
+    static inline const EventType* Find(const nsString& name) {
+      for (const EventType* type : Events::All) {
+        if (*type == name) {
+          return type;
+        }
+      }
+      return nullptr;
+    }
+  };
+
+  static already_AddRefed<XMLHttpRequest> Constructor(
+      const GlobalObject& aGlobal, const MozXMLHttpRequestParameters& aParams,
+      ErrorResult& aRv);
+
+  static already_AddRefed<XMLHttpRequest> Constructor(
+      const GlobalObject& aGlobal, const nsAString& ignored, ErrorResult& aRv) {
+    // Pretend like someone passed null, so we can pick up the default values
+    MozXMLHttpRequestParameters params;
+    if (!params.Init(aGlobal.Context(), JS::NullHandleValue)) {
+      aRv.Throw(NS_ERROR_UNEXPECTED);
+      return nullptr;
+    }
+
+    return Constructor(aGlobal, params, aRv);
+  }
+
+  IMPL_EVENT_HANDLER(readystatechange)
+
+  virtual uint16_t ReadyState() const = 0;
+
+  virtual void Open(const nsACString& aMethod, const nsAString& aUrl,
+                    ErrorResult& aRv) = 0;
+
+  virtual void Open(const nsACString& aMethod, const nsAString& aUrl,
+                    bool aAsync, const nsAString& aUser,
+                    const nsAString& aPassword, ErrorResult& aRv) = 0;
+
+  virtual void SetRequestHeader(const nsACString& aHeader,
+                                const nsACString& aValue, ErrorResult& aRv) = 0;
+
+  virtual uint32_t Timeout() const = 0;
+
+  virtual void SetTimeout(uint32_t aTimeout, ErrorResult& aRv) = 0;
+
+  virtual bool WithCredentials() const = 0;
+
+  virtual void SetWithCredentials(bool aWithCredentials, ErrorResult& aRv) = 0;
+
+  virtual XMLHttpRequestUpload* GetUpload(ErrorResult& aRv) = 0;
+
+  virtual void Send(
+      const Nullable<
+          DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString>&
+          aData,
+      ErrorResult& aRv) = 0;
+
+  virtual void SendInputStream(nsIInputStream* aInputStream,
+                               ErrorResult& aRv) = 0;
+
+  virtual void Abort(ErrorResult& aRv) = 0;
+
+  virtual void GetResponseURL(nsAString& aUrl) = 0;
+
+  virtual uint32_t GetStatus(ErrorResult& aRv) = 0;
+
+  virtual void GetStatusText(nsACString& aStatusText, ErrorResult& aRv) = 0;
+
+  virtual void GetResponseHeader(const nsACString& aHeader, nsACString& aResult,
+                                 ErrorResult& aRv) = 0;
+
+  virtual void GetAllResponseHeaders(nsACString& aResponseHeaders,
+                                     ErrorResult& aRv) = 0;
+
+  virtual void OverrideMimeType(const nsAString& aMimeType,
+                                ErrorResult& aRv) = 0;
+
+  virtual XMLHttpRequestResponseType ResponseType() const = 0;
+
+  virtual void SetResponseType(XMLHttpRequestResponseType aType,
+                               ErrorResult& aRv) = 0;
+
+  virtual void GetResponse(JSContext* aCx,
+                           JS::MutableHandle<JS::Value> aResponse,
+                           ErrorResult& aRv) = 0;
+
+  virtual void GetResponseText(DOMString& aResponseText, ErrorResult& aRv) = 0;
+
+  virtual Document* GetResponseXML(ErrorResult& aRv) = 0;
+
+  virtual bool MozBackgroundRequest() const = 0;
+
+  virtual void SetMozBackgroundRequest(bool aMozBackgroundRequest,
+                                       ErrorResult& aRv) = 0;
+
+  virtual nsIChannel* GetChannel() const = 0;
+
+  // 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) = 0;
+
+  virtual void SetOriginAttributes(
+      const mozilla::dom::OriginAttributesDictionary& aAttrs) = 0;
+
+  virtual uint16_t ErrorCode() const = 0;
+
+  virtual bool MozAnon() const = 0;
+
+  virtual bool MozSystem() const = 0;
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override {
+    return mozilla::dom::XMLHttpRequest_Binding::Wrap(aCx, this, aGivenProto);
+  }
+
+ protected:
+  explicit XMLHttpRequest(nsIGlobalObject* aGlobalObject)
+      : XMLHttpRequestEventTarget(aGlobalObject) {}
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_XMLHttpRequest_h