dom/fetch/Fetch.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_Fetch_h
   8 #define mozilla_dom_Fetch_h
   9
  10 #include "mozilla/Attributes.h"
  11 #include "nsCOMPtr.h"
  12 #include "nsError.h"
  13 #include "nsProxyRelease.h"
  14 #include "nsString.h"
  15
  16 #include "mozilla/DebugOnly.h"
  17 #include "mozilla/dom/AbortSignal.h"
  18 #include "mozilla/dom/BodyConsumer.h"
  19 #include "mozilla/dom/Promise.h"
  20 #include "mozilla/dom/FetchStreamReader.h"
  21 #include "mozilla/dom/ReadableStream.h"
  22 #include "mozilla/dom/ReadableStreamDefaultReaderBinding.h"
  23 #include "mozilla/dom/RequestBinding.h"
  24 #include "mozilla/dom/workerinternals/RuntimeService.h"
  25
  26 class nsIGlobalObject;
  27 class nsIEventTarget;
  28
  29 namespace mozilla {
  30 class ErrorResult;
  31
  32 namespace ipc {
  33 class PrincipalInfo;
  34 }  // namespace ipc
  35
  36 namespace dom {
  37
  38 class BlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString;
  39 class
  40     BlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrReadableStreamOrUSVString;
  41 class BlobImpl;
  42 class InternalRequest;
  43 class
  44     OwningBlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString;
  45
  46 class ReadableStreamDefaultReader;
  47 class RequestOrUTF8String;
  48 class WorkerPrivate;
  49
  50 enum class CallerType : uint32_t;
  51
  52 already_AddRefed<Promise> FetchRequest(nsIGlobalObject* aGlobal,
  53                                        const RequestOrUTF8String& aInput,
  54                                        const RequestInit& aInit,
  55                                        CallerType aCallerType,
  56                                        ErrorResult& aRv);
  57
  58 nsresult UpdateRequestReferrer(nsIGlobalObject* aGlobal,
  59                                InternalRequest* aRequest);
  60
  61 namespace fetch {
  62 using BodyInit =
  63     BlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString;
  64 using ResponseBodyInit =
  65     BlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrReadableStreamOrUSVString;
  66 using OwningBodyInit =
  67     OwningBlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString;
  68 };  // namespace fetch
  69
  70 /*
  71  * Creates an nsIInputStream based on the fetch specifications 'extract a byte
  72  * stream algorithm' - http://fetch.spec.whatwg.org/#concept-bodyinit-extract.
  73  * Stores content type in out param aContentType.
  74  */
  75 nsresult ExtractByteStreamFromBody(const fetch::OwningBodyInit& aBodyInit,
  76                                    nsIInputStream** aStream,
  77                                    nsCString& aContentType,
  78                                    uint64_t& aContentLength);
  79
  80 /*
  81  * Non-owning version.
  82  */
  83 nsresult ExtractByteStreamFromBody(const fetch::BodyInit& aBodyInit,
  84                                    nsIInputStream** aStream,
  85                                    nsCString& aContentType,
  86                                    uint64_t& aContentLength);
  87
  88 /*
  89  * Non-owning version. This method should go away when BodyInit will contain
  90  * ReadableStream.
  91  */
  92 nsresult ExtractByteStreamFromBody(const fetch::ResponseBodyInit& aBodyInit,
  93                                    nsIInputStream** aStream,
  94                                    nsCString& aContentType,
  95                                    uint64_t& aContentLength);
  96
  97 /*
  98  * FetchBody's body consumption uses nsIInputStreamPump to read from the
  99  * underlying stream to a block of memory, which is then adopted by
 100  * ContinueConsumeBody() and converted to the right type based on the JS
 101  * function called.
 102  *
 103  * Use of the nsIInputStreamPump complicates things on the worker thread.
 104  * The solution used here is similar to WebSockets.
 105  * The difference is that we are only interested in completion and not data
 106  * events, and nsIInputStreamPump can only deliver completion on the main
 107  * thread.
 108  *
 109  * Before starting the pump on the main thread, we addref the FetchBody to keep
 110  * it alive. Then we add a feature, to track the status of the worker.
 111  *
 112  * ContinueConsumeBody() is the function that cleans things up in both success
 113  * and error conditions and so all callers call it with the appropriate status.
 114  *
 115  * Once the read is initiated on the main thread there are two possibilities.
 116  *
 117  * 1) Pump finishes before worker has finished Running.
 118  *    In this case we adopt the data and dispatch a runnable to the worker,
 119  *    which derefs FetchBody and removes the feature and resolves the Promise.
 120  *
 121  * 2) Pump still working while worker has stopped Running.
 122  *    The feature is Notify()ed and ContinueConsumeBody() is called with
 123  *    NS_BINDING_ABORTED. We first Cancel() the pump using a sync runnable to
 124  *    ensure that mFetchBody remains alive (since mConsumeBodyPump is strongly
 125  *    held by it) until pump->Cancel() is called. OnStreamComplete() will not
 126  *    do anything if the error code is NS_BINDING_ABORTED, so we don't have to
 127  *    worry about keeping anything alive.
 128  *
 129  * The pump is always released on the main thread.
 130  */
 131
 132 class FetchBodyBase : public nsISupports {
 133  public:
 134   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 135   NS_DECL_CYCLE_COLLECTION_CLASS(FetchBodyBase)
 136
 137  protected:
 138   virtual ~FetchBodyBase() = default;
 139
 140   RefPtr<ReadableStream> mReadableStreamBody;
 141 };
 142
 143 template <class Derived>
 144 class FetchBody : public FetchBodyBase, public AbortFollower {
 145  public:
 146   using FetchBodyBase::QueryInterface;
 147
 148   NS_INLINE_DECL_REFCOUNTING_INHERITED(FetchBody, FetchBodyBase)
 149
 150   bool BodyUsed() const;
 151
 152   already_AddRefed<Promise> ArrayBuffer(JSContext* aCx, ErrorResult& aRv) {
 153     return ConsumeBody(aCx, BodyConsumer::ConsumeType::ArrayBuffer, aRv);
 154   }
 155
 156   already_AddRefed<Promise> Blob(JSContext* aCx, ErrorResult& aRv) {
 157     return ConsumeBody(aCx, BodyConsumer::ConsumeType::Blob, aRv);
 158   }
 159
 160   already_AddRefed<Promise> Bytes(JSContext* aCx, ErrorResult& aRv) {
 161     return ConsumeBody(aCx, BodyConsumer::ConsumeType::Bytes, aRv);
 162   }
 163
 164   already_AddRefed<Promise> FormData(JSContext* aCx, ErrorResult& aRv) {
 165     return ConsumeBody(aCx, BodyConsumer::ConsumeType::FormData, aRv);
 166   }
 167
 168   already_AddRefed<Promise> Json(JSContext* aCx, ErrorResult& aRv) {
 169     return ConsumeBody(aCx, BodyConsumer::ConsumeType::JSON, aRv);
 170   }
 171
 172   already_AddRefed<Promise> Text(JSContext* aCx, ErrorResult& aRv) {
 173     return ConsumeBody(aCx, BodyConsumer::ConsumeType::Text, aRv);
 174   }
 175
 176   already_AddRefed<ReadableStream> GetBody(JSContext* aCx, ErrorResult& aRv);
 177   void GetMimeType(nsACString& aMimeType, nsACString& aMixedCaseMimeType);
 178
 179   const nsACString& BodyBlobURISpec() const;
 180
 181   const nsAString& BodyLocalPath() const;
 182
 183   // If the body contains a ReadableStream body object, this method produces a
 184   // tee() of it.
 185   //
 186   // This is marked as a script boundary minimize changes required for
 187   // annotation while we work out how to correctly annotate this code.
 188   // Tracked in Bug 1750650.
 189   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 190   void MaybeTeeReadableStreamBody(JSContext* aCx, ReadableStream** aBodyOut,
 191                                   FetchStreamReader** aStreamReader,
 192                                   nsIInputStream** aInputStream,
 193                                   ErrorResult& aRv);
 194
 195   // Utility public methods accessed by various runnables.
 196
 197   // This method _must_ be called in order to set the body as used. If the body
 198   // is a ReadableStream, this method will start reading the stream.
 199   // More in details, this method does:
 200   // 1) It uses an internal flag to track if the body is used.  This is tracked
 201   // separately from the ReadableStream disturbed state due to purely native
 202   // streams.
 203   // 2) If there is a ReadableStream reflector for the native stream it is
 204   // Locked.
 205   // 3) If there is a JS ReadableStream then we begin pumping it into the native
 206   // body stream.  This effectively locks and disturbs the stream.
 207   //
 208   // Note that JSContext is used only if there is a ReadableStream (this can
 209   // happen because the body is a ReadableStream or because attribute body has
 210   // already been used by content). If something goes wrong using
 211   // ReadableStream, errors will be reported via ErrorResult and not as JS
 212   // exceptions in JSContext. This is done in order to have a centralized error
 213   // reporting way.
 214   //
 215   // Exceptions generated when reading from the ReadableStream are directly sent
 216   // to the Console.
 217   void SetBodyUsed(JSContext* aCx, ErrorResult& aRv);
 218
 219   virtual AbortSignalImpl* GetSignalImpl() const = 0;
 220
 221   virtual AbortSignalImpl* GetSignalImplToConsumeBody() const = 0;
 222
 223   // AbortFollower
 224   void RunAbortAlgorithm() override;
 225
 226   already_AddRefed<Promise> ConsumeBody(JSContext* aCx,
 227                                         BodyConsumer::ConsumeType aType,
 228                                         ErrorResult& aRv);
 229
 230  protected:
 231   nsCOMPtr<nsIGlobalObject> mOwner;
 232
 233   // This is the Reader used to retrieve data from the body. This needs to be
 234   // traversed by subclasses.
 235   RefPtr<FetchStreamReader> mFetchStreamReader;
 236
 237   explicit FetchBody(nsIGlobalObject* aOwner);
 238
 239   virtual ~FetchBody();
 240
 241   void SetReadableStreamBody(JSContext* aCx, ReadableStream* aBody);
 242
 243  private:
 244   Derived* DerivedClass() const {
 245     return static_cast<Derived*>(const_cast<FetchBody*>(this));
 246   }
 247
 248   void LockStream(JSContext* aCx, ReadableStream* aStream, ErrorResult& aRv);
 249
 250   void AssertIsOnTargetThread() {
 251     MOZ_ASSERT(NS_IsMainThread() == !GetCurrentThreadWorkerPrivate());
 252   }
 253
 254   // Only ever set once, always on target thread.
 255   bool mBodyUsed;
 256
 257   // The main-thread event target for runnable dispatching.
 258   nsCOMPtr<nsISerialEventTarget> mMainThreadEventTarget;
 259 };
 260
 261 class EmptyBody final : public FetchBody<EmptyBody> {
 262   NS_DECL_ISUPPORTS_INHERITED
 263   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(EmptyBody,
 264                                                          FetchBody<EmptyBody>)
 265
 266  public:
 267   static already_AddRefed<EmptyBody> Create(
 268       nsIGlobalObject* aGlobal, mozilla::ipc::PrincipalInfo* aPrincipalInfo,
 269       AbortSignalImpl* aAbortSignalImpl, const nsACString& aMimeType,
 270       const nsACString& aMixedCaseMimeType, ErrorResult& aRv);
 271
 272   nsIGlobalObject* GetParentObject() const { return mOwner; }
 273
 274   AbortSignalImpl* GetSignalImpl() const override { return mAbortSignalImpl; }
 275   AbortSignalImpl* GetSignalImplToConsumeBody() const final { return nullptr; }
 276
 277   const UniquePtr<mozilla::ipc::PrincipalInfo>& GetPrincipalInfo() const {
 278     return mPrincipalInfo;
 279   }
 280
 281   void GetMimeType(nsACString& aMimeType, nsACString& aMixedCaseMimeType) {
 282     aMimeType = mMimeType;
 283     aMixedCaseMimeType = mMixedCaseMimeType;
 284   }
 285
 286   void GetBody(nsIInputStream** aStream, int64_t* aBodyLength = nullptr);
 287
 288   using FetchBody::BodyBlobURISpec;
 289
 290   const nsACString& BodyBlobURISpec() const { return EmptyCString(); }
 291
 292   using FetchBody::BodyLocalPath;
 293
 294   const nsAString& BodyLocalPath() const { return EmptyString(); }
 295
 296  private:
 297   EmptyBody(nsIGlobalObject* aGlobal,
 298             mozilla::ipc::PrincipalInfo* aPrincipalInfo,
 299             AbortSignalImpl* aAbortSignalImpl, const nsACString& aMimeType,
 300             const nsACString& aMixedCaseMimeType,
 301             already_AddRefed<nsIInputStream> aBodyStream);
 302
 303   ~EmptyBody();
 304
 305   UniquePtr<mozilla::ipc::PrincipalInfo> mPrincipalInfo;
 306   RefPtr<AbortSignalImpl> mAbortSignalImpl;
 307   nsCString mMimeType;
 308   nsCString mMixedCaseMimeType;
 309   nsCOMPtr<nsIInputStream> mBodyStream;
 310 };
 311 }  // namespace dom
 312 }  // namespace mozilla
 313
 314 #endif  // mozilla_dom_Fetch_h