dom/fetch/Request.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
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_Request_h
   8 #define mozilla_dom_Request_h
   9
  10 #include "nsISupportsImpl.h"
  11 #include "nsWrapperCache.h"
  12
  13 #include "mozilla/dom/Fetch.h"
  14 #include "mozilla/dom/InternalRequest.h"
  15 // Required here due to certain WebIDL enums/classes being declared in both
  16 // files.
  17 #include "mozilla/dom/RequestBinding.h"
  18 #include "mozilla/dom/SafeRefPtr.h"
  19
  20 namespace mozilla::dom {
  21
  22 class Headers;
  23 class InternalHeaders;
  24 class RequestOrUSVString;
  25
  26 class Request final : public FetchBody<Request>, public nsWrapperCache {
  27   NS_DECL_ISUPPORTS_INHERITED
  28   NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS_INHERITED(Request,
  29                                                         FetchBody<Request>)
  30
  31  public:
  32   Request(nsIGlobalObject* aOwner, SafeRefPtr<InternalRequest> aRequest,
  33           AbortSignal* aSignal);
  34
  35   JSObject* WrapObject(JSContext* aCx,
  36                        JS::Handle<JSObject*> aGivenProto) override {
  37     return Request_Binding::Wrap(aCx, this, aGivenProto);
  38   }
  39
  40   void GetUrl(nsAString& aUrl) const {
  41     nsAutoCString url;
  42     mRequest->GetURL(url);
  43     CopyUTF8toUTF16(url, aUrl);
  44   }
  45
  46   void GetMethod(nsCString& aMethod) const { aMethod = mRequest->mMethod; }
  47
  48   RequestMode Mode() const { return mRequest->mMode; }
  49
  50   RequestCredentials Credentials() const { return mRequest->mCredentialsMode; }
  51
  52   RequestCache Cache() const { return mRequest->GetCacheMode(); }
  53
  54   RequestRedirect Redirect() const { return mRequest->GetRedirectMode(); }
  55
  56   void GetIntegrity(nsAString& aIntegrity) const {
  57     aIntegrity = mRequest->GetIntegrity();
  58   }
  59
  60   bool MozErrors() const { return mRequest->MozErrors(); }
  61
  62   RequestDestination Destination() const { return mRequest->Destination(); }
  63
  64   void OverrideContentPolicyType(uint32_t aContentPolicyType) {
  65     mRequest->OverrideContentPolicyType(
  66         static_cast<nsContentPolicyType>(aContentPolicyType));
  67   }
  68
  69   bool IsContentPolicyTypeOverridden() const {
  70     return mRequest->IsContentPolicyTypeOverridden();
  71   }
  72
  73   void GetReferrer(nsAString& aReferrer) const {
  74     mRequest->GetReferrer(aReferrer);
  75   }
  76
  77   ReferrerPolicy ReferrerPolicy_() const { return mRequest->ReferrerPolicy_(); }
  78
  79   InternalHeaders* GetInternalHeaders() const { return mRequest->Headers(); }
  80
  81   Headers* Headers_();
  82
  83   using FetchBody::GetBody;
  84
  85   void GetBody(nsIInputStream** aStream, int64_t* aBodyLength = nullptr) {
  86     mRequest->GetBody(aStream, aBodyLength);
  87   }
  88
  89   void SetBody(nsIInputStream* aStream, int64_t aBodyLength) {
  90     mRequest->SetBody(aStream, aBodyLength);
  91   }
  92
  93   using FetchBody::BodyBlobURISpec;
  94
  95   const nsACString& BodyBlobURISpec() const {
  96     return mRequest->BodyBlobURISpec();
  97   }
  98
  99   using FetchBody::BodyLocalPath;
 100
 101   const nsAString& BodyLocalPath() const { return mRequest->BodyLocalPath(); }
 102
 103   static SafeRefPtr<Request> Constructor(const GlobalObject& aGlobal,
 104                                          const RequestOrUSVString& aInput,
 105                                          const RequestInit& aInit,
 106                                          ErrorResult& rv);
 107
 108   static SafeRefPtr<Request> Constructor(nsIGlobalObject* aGlobal,
 109                                          JSContext* aCx,
 110                                          const RequestOrUSVString& aInput,
 111                                          const RequestInit& aInit,
 112                                          ErrorResult& rv);
 113
 114   nsIGlobalObject* GetParentObject() const { return mOwner; }
 115
 116   SafeRefPtr<Request> Clone(ErrorResult& aRv);
 117
 118   SafeRefPtr<InternalRequest> GetInternalRequest();
 119
 120   const UniquePtr<mozilla::ipc::PrincipalInfo>& GetPrincipalInfo() const {
 121     return mRequest->GetPrincipalInfo();
 122   }
 123
 124   AbortSignal* GetOrCreateSignal();
 125
 126   // This can return a null AbortSignalImpl.
 127   AbortSignalImpl* GetSignalImpl() const override;
 128   AbortSignalImpl* GetSignalImplToConsumeBody() const final;
 129
 130  private:
 131   ~Request();
 132
 133   SafeRefPtr<InternalRequest> mRequest;
 134
 135   // Lazily created.
 136   RefPtr<Headers> mHeaders;
 137   RefPtr<AbortSignal> mSignal;
 138 };
 139
 140 }  // namespace mozilla::dom
 141
 142 #endif  // mozilla_dom_Request_h