tor-browser

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

Request.h (4534B)

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