tor-browser

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

XMLHttpRequestWorker.h (8611B)

      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 file,
      5 * You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #ifndef mozilla_dom_XMLHttpRequestWorker_h
      8 #define mozilla_dom_XMLHttpRequestWorker_h
      9 
     10 #include "XMLHttpRequest.h"
     11 #include "XMLHttpRequestString.h"
     12 #include "mozilla/WeakPtr.h"
     13 #include "mozilla/dom/BodyExtractor.h"
     14 #include "mozilla/dom/TypedArray.h"
     15 
     16 // XXX Avoid including this here by moving function bodies to the cpp file
     17 #include "mozilla/dom/BlobImpl.h"
     18 
     19 namespace mozilla::dom {
     20 
     21 class Proxy;
     22 class DOMString;
     23 class SendRunnable;
     24 class ThreadSafeWorkerRef;
     25 class WorkerPrivate;
     26 
     27 class XMLHttpRequestWorker final : public SupportsWeakPtr,
     28                                   public XMLHttpRequest {
     29 public:
     30  // This defines the xhr.response value.
     31  struct ResponseData {
     32    nsresult mResponseResult;
     33 
     34    // responseType is empty or text.
     35    XMLHttpRequestStringSnapshot mResponseText;
     36 
     37    // responseType is blob
     38    RefPtr<BlobImpl> mResponseBlobImpl;
     39 
     40    // responseType is arrayBuffer;
     41    RefPtr<ArrayBufferBuilder> mResponseArrayBufferBuilder;
     42 
     43    // responseType is json
     44    nsString mResponseJSON;
     45 
     46    ResponseData() : mResponseResult(NS_OK) {}
     47  };
     48 
     49  struct StateData {
     50    nsCString mResponseURL;
     51    uint32_t mStatus{0};
     52    nsCString mStatusText;
     53    uint16_t mReadyState{0};
     54    nsresult mStatusResult{NS_OK};
     55  };
     56 
     57 private:
     58  RefPtr<XMLHttpRequestUpload> mUpload;
     59 
     60  // This is set by SendRunnable::RunOnMainThread when the send process starts
     61  // and is cleared by Proxy::Teardown and is held for the duration of the send.
     62  // Additionally, it will be temporarily saved off by various sync runnables
     63  // and replaced with their own reference to make a ThreadSafeWorkerRef
     64  // available to the proxy for the duration of the sync runnables.
     65  // They will restore the state when their sync runnable completes its main
     66  // thread work.
     67  RefPtr<ThreadSafeWorkerRef> mWorkerRef;
     68  RefPtr<XMLHttpRequestWorker> mPinnedSelfRef;
     69  RefPtr<Proxy> mProxy;
     70 
     71  XMLHttpRequestResponseType mResponseType;
     72 
     73  UniquePtr<StateData> mStateData;
     74 
     75  UniquePtr<ResponseData> mResponseData;
     76  RefPtr<Blob> mResponseBlob;
     77  JS::Heap<JSObject*> mResponseArrayBufferValue;
     78  JS::Heap<JS::Value> mResponseJSONValue;
     79 
     80  uint32_t mEventStreamId{0};
     81  uint32_t mTimeout;
     82 
     83  bool mBackgroundRequest;
     84  bool mWithCredentials;
     85  bool mCanceled;
     86  bool mFlagSend{false};  // spec flag
     87  bool mFlagSendActive;
     88 
     89  bool mMozAnon;
     90  bool mMozSystem;
     91 
     92  nsString mMimeTypeOverride;
     93 
     94 public:
     95  NS_DECL_ISUPPORTS_INHERITED
     96  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(XMLHttpRequestWorker,
     97                                                         XMLHttpRequest)
     98 
     99  static already_AddRefed<XMLHttpRequest> Construct(
    100      const GlobalObject& aGlobal, const MozXMLHttpRequestParameters& aParams,
    101      ErrorResult& aRv);
    102 
    103  void Unpin();
    104 
    105  virtual uint16_t ReadyState() const override;
    106 
    107  virtual void Open(const nsACString& aMethod, const nsACString& aUrl,
    108                    ErrorResult& aRv) override {
    109    Open(aMethod, aUrl, true, Optional<nsACString>(), Optional<nsACString>(),
    110         aRv);
    111  }
    112 
    113  uint32_t EventStreamId() const { return mEventStreamId; }
    114 
    115  virtual void Open(const nsACString& aMethod, const nsACString& aUrl,
    116                    bool aAsync, const nsACString& aUsername,
    117                    const nsACString& aPassword, ErrorResult& aRv) override {
    118    Optional<nsACString> username;
    119    username = &aUsername;
    120    Optional<nsACString> password;
    121    password = &aPassword;
    122    Open(aMethod, aUrl, aAsync, username, password, aRv);
    123  }
    124 
    125  void Open(const nsACString& aMethod, const nsACString& aUrl, bool aAsync,
    126            const Optional<nsACString>& aUser,
    127            const Optional<nsACString>& aPassword, ErrorResult& aRv);
    128 
    129  virtual void SetRequestHeader(const nsACString& aHeader,
    130                                const nsACString& aValue,
    131                                ErrorResult& aRv) override;
    132 
    133  virtual uint32_t Timeout() const override { return mTimeout; }
    134 
    135  virtual void SetTimeout(uint32_t aTimeout, ErrorResult& aRv) override;
    136 
    137  virtual bool WithCredentials() const override { return mWithCredentials; }
    138 
    139  virtual void SetWithCredentials(bool aWithCredentials,
    140                                  ErrorResult& aRv) override;
    141 
    142  virtual bool MozBackgroundRequest() const override {
    143    return mBackgroundRequest;
    144  }
    145 
    146  virtual void SetMozBackgroundRequest(bool aBackgroundRequest,
    147                                       ErrorResult& aRv) override;
    148 
    149  virtual nsIChannel* GetChannel() const override {
    150    MOZ_CRASH("This method cannot be called on workers.");
    151  }
    152 
    153  virtual XMLHttpRequestUpload* GetUpload(ErrorResult& aRv) override;
    154 
    155  virtual void Send(
    156      const Nullable<
    157          DocumentOrBlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString>&
    158          aData,
    159      ErrorResult& aRv) override;
    160 
    161  virtual void SendInputStream(nsIInputStream* aInputStream,
    162                               ErrorResult& aRv) override {
    163    MOZ_CRASH("nsIInputStream is not a valid argument for XHR in workers.");
    164  }
    165 
    166  virtual void Abort(ErrorResult& aRv) override;
    167 
    168  virtual void GetResponseURL(nsACString& aUrl) override {
    169    aUrl = mStateData->mResponseURL;
    170  }
    171 
    172  uint32_t GetStatus(ErrorResult& aRv) override {
    173    aRv = mStateData->mStatusResult;
    174    return mStateData->mStatus;
    175  }
    176 
    177  virtual void GetStatusText(nsACString& aStatusText,
    178                             ErrorResult& aRv) override {
    179    aStatusText = mStateData->mStatusText;
    180  }
    181 
    182  virtual void GetResponseHeader(const nsACString& aHeader,
    183                                 nsACString& aResponseHeader,
    184                                 ErrorResult& aRv) override;
    185 
    186  virtual void GetAllResponseHeaders(nsACString& aResponseHeaders,
    187                                     ErrorResult& aRv) override;
    188 
    189  virtual void OverrideMimeType(const nsAString& aMimeType,
    190                                ErrorResult& aRv) override;
    191 
    192  virtual XMLHttpRequestResponseType ResponseType() const override {
    193    return mResponseType;
    194  }
    195 
    196  virtual void SetResponseType(XMLHttpRequestResponseType aResponseType,
    197                               ErrorResult& aRv) override;
    198 
    199  virtual void GetResponse(JSContext* /* unused */,
    200                           JS::MutableHandle<JS::Value> aResponse,
    201                           ErrorResult& aRv) override;
    202 
    203  virtual void GetResponseText(DOMString& aResponseText,
    204                               ErrorResult& aRv) override;
    205 
    206  virtual Document* GetResponseXML(ErrorResult& aRv) override {
    207    MOZ_CRASH("This method should not be called.");
    208  }
    209 
    210  virtual void GetInterface(JSContext* aCx, JS::Handle<JS::Value> aIID,
    211                            JS::MutableHandle<JS::Value> aRetval,
    212                            ErrorResult& aRv) override {
    213    aRv.Throw(NS_ERROR_FAILURE);
    214  }
    215 
    216  virtual void SetOriginAttributes(
    217      const mozilla::dom::OriginAttributesDictionary& aAttrs) override {
    218    MOZ_CRASH("This method cannot be called on workers.");
    219  }
    220 
    221  XMLHttpRequestUpload* GetUploadObjectNoCreate() const { return mUpload; }
    222 
    223  void UpdateState(UniquePtr<StateData>&& aStateData,
    224                   UniquePtr<ResponseData>&& aResponseData);
    225 
    226  virtual uint16_t ErrorCode() const override {
    227    return 0;  // eOK
    228  }
    229 
    230  virtual bool MozAnon() const override { return mMozAnon; }
    231 
    232  virtual bool MozSystem() const override { return mMozSystem; }
    233 
    234  bool SendInProgress() const { return !!mWorkerRef; }
    235 
    236 private:
    237  XMLHttpRequestWorker(WorkerPrivate* aWorkerPrivate,
    238                       nsIGlobalObject* aGlobalObject);
    239  ~XMLHttpRequestWorker();
    240 
    241  enum ReleaseType { Default, XHRIsGoingAway, WorkerIsGoingAway };
    242 
    243  void ReleaseProxy(ReleaseType aType = Default);
    244 
    245  void MaybePin(ErrorResult& aRv);
    246 
    247  void SetResponseToNetworkError();
    248 
    249  void RequestErrorSteps(ErrorResult& aRv,
    250                         const ErrorProgressEventType& aEventType,
    251                         nsresult aException = NS_ERROR_DOM_INVALID_STATE_ERR);
    252 
    253  bool FireEvent(EventTarget* aTarget, const EventType& aEventType,
    254                 bool aUploadTarget, ErrorResult& aRv);
    255 
    256  void Send(JSContext* aCx, JS::Handle<JSObject*> aBody, ErrorResult& aRv);
    257 
    258  void SendInternal(const BodyExtractorBase* aBody, ErrorResult& aRv);
    259 
    260  void ResetResponseData();
    261 };
    262 
    263 }  // namespace mozilla::dom
    264 
    265 #endif  // mozilla_dom_workers_xmlhttprequest_h__