1 files changed, 155 insertions, 0 deletions
diff --git a/netwerk/protocol/http/nsHttpRequestHead.h b/netwerk/protocol/http/nsHttpRequestHead.h
new file mode 100644
index 0000000000..e308790bd4
--- /dev/null
+++ b/netwerk/protocol/http/nsHttpRequestHead.h
@@ -0,0 +1,155 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 nsHttpRequestHead_h__
+#define nsHttpRequestHead_h__
+
+#include "nsHttp.h"
+#include "nsHttpHeaderArray.h"
+#include "nsString.h"
+#include "mozilla/RecursiveMutex.h"
+
+class nsIHttpHeaderVisitor;
+
+// This needs to be forward declared here so we can include only this header
+// without also including PHttpChannelParams.h
+namespace IPC {
+template <typename>
+struct ParamTraits;
+}  // namespace IPC
+
+namespace mozilla {
+namespace net {
+
+//-----------------------------------------------------------------------------
+// nsHttpRequestHead represents the request line and headers from an HTTP
+// request.
+//-----------------------------------------------------------------------------
+
+class nsHttpRequestHead {
+ public:
+  nsHttpRequestHead();
+  explicit nsHttpRequestHead(const nsHttpRequestHead& aRequestHead);
+  nsHttpRequestHead(nsHttpRequestHead&& aRequestHead);
+  ~nsHttpRequestHead();
+
+  nsHttpRequestHead& operator=(const nsHttpRequestHead& aRequestHead);
+
+  // The following function is only used in HttpChannelParent to avoid
+  // copying headers. If you use it be careful to do it only under
+  // nsHttpRequestHead lock!!!
+  const nsHttpHeaderArray& Headers() const MOZ_REQUIRES(mRecursiveMutex);
+  void Enter() const MOZ_CAPABILITY_ACQUIRE(mRecursiveMutex) {
+    mRecursiveMutex.Lock();
+  }
+  void Exit() const MOZ_CAPABILITY_RELEASE(mRecursiveMutex) {
+    mRecursiveMutex.Unlock();
+  }
+
+  void SetHeaders(const nsHttpHeaderArray& aHeaders);
+
+  void SetMethod(const nsACString& method);
+  void SetVersion(HttpVersion version);
+  void SetRequestURI(const nsACString& s);
+  void SetPath(const nsACString& s);
+  uint32_t HeaderCount();
+
+  // Using this function it is possible to itereate through all headers
+  // automatically under one lock.
+  [[nodiscard]] nsresult VisitHeaders(
+      nsIHttpHeaderVisitor* visitor,
+      nsHttpHeaderArray::VisitorFilter filter = nsHttpHeaderArray::eFilterAll);
+  void Method(nsACString& aMethod);
+  HttpVersion Version();
+  void RequestURI(nsACString& RequestURI);
+  void Path(nsACString& aPath);
+  void SetHTTPS(bool val);
+  bool IsHTTPS();
+
+  void SetOrigin(const nsACString& scheme, const nsACString& host,
+                 int32_t port);
+  void Origin(nsACString& aOrigin);
+
+  [[nodiscard]] nsresult SetHeader(const nsACString& h, const nsACString& v,
+                                   bool m = false);
+  [[nodiscard]] nsresult SetHeader(const nsHttpAtom& h, const nsACString& v,
+                                   bool m = false);
+  [[nodiscard]] nsresult SetHeader(const nsHttpAtom& h, const nsACString& v,
+                                   bool m,
+                                   nsHttpHeaderArray::HeaderVariety variety);
+  [[nodiscard]] nsresult SetEmptyHeader(const nsACString& h);
+  [[nodiscard]] nsresult GetHeader(const nsHttpAtom& h, nsACString& v);
+
+  [[nodiscard]] nsresult ClearHeader(const nsHttpAtom& h);
+  void ClearHeaders();
+
+  bool HasHeaderValue(const nsHttpAtom& h, const char* v);
+  // This function returns true if header is set even if it is an empty
+  // header.
+  bool HasHeader(const nsHttpAtom& h);
+  void Flatten(nsACString&, bool pruneProxyHeaders = false);
+
+  // Don't allow duplicate values
+  [[nodiscard]] nsresult SetHeaderOnce(const nsHttpAtom& h, const char* v,
+                                       bool merge = false);
+
+  bool IsSafeMethod();
+
+  enum ParsedMethodType {
+    kMethod_Custom,
+    kMethod_Get,
+    kMethod_Post,
+    kMethod_Options,
+    kMethod_Connect,
+    kMethod_Head,
+    kMethod_Put,
+    kMethod_Trace
+  };
+
+  static void ParseMethod(const nsCString& aRawMethod,
+                          ParsedMethodType& aParsedMethod);
+
+  ParsedMethodType ParsedMethod();
+  bool EqualsMethod(ParsedMethodType aType);
+  bool IsGet() { return EqualsMethod(kMethod_Get); }
+  bool IsPost() { return EqualsMethod(kMethod_Post); }
+  bool IsOptions() { return EqualsMethod(kMethod_Options); }
+  bool IsConnect() { return EqualsMethod(kMethod_Connect); }
+  bool IsHead() { return EqualsMethod(kMethod_Head); }
+  bool IsPut() { return EqualsMethod(kMethod_Put); }
+  bool IsTrace() { return EqualsMethod(kMethod_Trace); }
+  void ParseHeaderSet(const char* buffer);
+
+ private:
+  // All members must be copy-constructable and assignable
+  nsHttpHeaderArray mHeaders MOZ_GUARDED_BY(mRecursiveMutex);
+  nsCString mMethod MOZ_GUARDED_BY(mRecursiveMutex){"GET"_ns};
+  HttpVersion mVersion MOZ_GUARDED_BY(mRecursiveMutex){HttpVersion::v1_1};
+
+  // mRequestURI and mPath are strings instead of an nsIURI
+  // because this is used off the main thread
+  // TODO: nsIURI is thread-safe now, should be fixable.
+  nsCString mRequestURI MOZ_GUARDED_BY(mRecursiveMutex);
+  nsCString mPath MOZ_GUARDED_BY(mRecursiveMutex);
+
+  nsCString mOrigin MOZ_GUARDED_BY(mRecursiveMutex);
+  ParsedMethodType mParsedMethod MOZ_GUARDED_BY(mRecursiveMutex){kMethod_Get};
+  bool mHTTPS MOZ_GUARDED_BY(mRecursiveMutex){false};
+
+  // We are using RecursiveMutex instead of a Mutex because VisitHeader
+  // function calls nsIHttpHeaderVisitor::VisitHeader while under lock.
+  mutable RecursiveMutex mRecursiveMutex MOZ_UNANNOTATED{
+      "nsHttpRequestHead.mRecursiveMutex"};
+
+  // During VisitHeader we sould not allow call to SetHeader.
+  bool mInVisitHeaders MOZ_GUARDED_BY(mRecursiveMutex){false};
+
+  friend struct IPC::ParamTraits<nsHttpRequestHead>;
+};
+
+}  // namespace net
+}  // namespace mozilla
+
+#endif  // nsHttpRequestHead_h__