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   RequestPriority Priority() const { return mRequest->GetPriorityMode(); }
  57
  58   void GetIntegrity(nsAString& aIntegrity) const {
  59     aIntegrity = mRequest->GetIntegrity();
  60   }
  61
  62   bool MozErrors() const { return mRequest->MozErrors(); }
  63
  64   RequestDestination Destination() const { return mRequest->Destination(); }
  65
  66   void OverrideContentPolicyType(uint32_t aContentPolicyType) {
  67     mRequest->OverrideContentPolicyType(
  68         static_cast<nsContentPolicyType>(aContentPolicyType));
  69   }
  70
  71   bool IsContentPolicyTypeOverridden() const {
  72     return mRequest->IsContentPolicyTypeOverridden();
  73   }
  74
  75   void GetReferrer(nsAString& aReferrer) const {
  76     mRequest->GetReferrer(aReferrer);
  77   }
  78
  79   ReferrerPolicy ReferrerPolicy_() const { return mRequest->ReferrerPolicy_(); }
  80
  81   InternalHeaders* GetInternalHeaders() const { return mRequest->Headers(); }
  82
  83   Headers* Headers_();
  84
  85   using FetchBody::GetBody;
  86
  87   void GetBody(nsIInputStream** aStream, int64_t* aBodyLength = nullptr) {
  88     mRequest->GetBody(aStream, aBodyLength);
  89   }
  90
  91   void SetBody(nsIInputStream* aStream, int64_t aBodyLength) {
  92     mRequest->SetBody(aStream, aBodyLength);
  93   }
  94
  95   using FetchBody::BodyBlobURISpec;
  96
  97   const nsACString& BodyBlobURISpec() const {
  98     return mRequest->BodyBlobURISpec();
  99   }
 100
 101   using FetchBody::BodyLocalPath;
 102
 103   const nsAString& BodyLocalPath() const { return mRequest->BodyLocalPath(); }
 104
 105   static SafeRefPtr<Request> Constructor(const GlobalObject& aGlobal,
 106                                          const RequestOrUSVString& aInput,
 107                                          const RequestInit& aInit,
 108                                          ErrorResult& rv);
 109
 110   static SafeRefPtr<Request> Constructor(nsIGlobalObject* aGlobal,
 111                                          JSContext* aCx,
 112                                          const RequestOrUSVString& aInput,
 113                                          const RequestInit& aInit,
 114                                          ErrorResult& rv);
 115
 116   nsIGlobalObject* GetParentObject() const { return mOwner; }
 117
 118   SafeRefPtr<Request> Clone(ErrorResult& aRv);
 119
 120   SafeRefPtr<InternalRequest> GetInternalRequest();
 121
 122   const UniquePtr<mozilla::ipc::PrincipalInfo>& GetPrincipalInfo() const {
 123     return mRequest->GetPrincipalInfo();
 124   }
 125
 126   AbortSignal* GetOrCreateSignal();
 127
 128   // This can return a null AbortSignalImpl.
 129   AbortSignalImpl* GetSignalImpl() const override;
 130   AbortSignalImpl* GetSignalImplToConsumeBody() const final;
 131
 132  private:
 133   ~Request();
 134
 135   SafeRefPtr<InternalRequest> mRequest;
 136
 137   // Lazily created.
 138   RefPtr<Headers> mHeaders;
 139   RefPtr<AbortSignal> mSignal;
 140 };
 141
 142 }  // namespace mozilla::dom
 143
 144 #endif  // mozilla_dom_Request_h