dom/streams/ReadableStreamDefaultReader.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent: */
   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 #include "mozilla/dom/ReadableStreamDefaultReader.h"
   8
   9 #include "mozilla/dom/AutoEntryScript.h"
  10 #include "mozilla/dom/ReadableStream.h"
  11 #include "mozilla/dom/RootedDictionary.h"
  12 #include "js/PropertyAndElement.h"
  13 #include "js/TypeDecls.h"
  14 #include "js/Value.h"
  15 #include "jsapi.h"
  16 #include "mozilla/dom/ReadableStreamDefaultReaderBinding.h"
  17 #include "mozilla/dom/UnderlyingSourceBinding.h"
  18 #include "nsCOMPtr.h"
  19 #include "nsCycleCollectionParticipant.h"
  20 #include "nsISupports.h"
  21 #include "nsWrapperCache.h"
  22
  23 namespace mozilla::dom {
  24
  25 using namespace streams_abstract;
  26
  27 NS_IMPL_CYCLE_COLLECTION(ReadableStreamGenericReader, mClosedPromise, mStream,
  28                          mGlobal)
  29 NS_IMPL_CYCLE_COLLECTING_ADDREF(ReadableStreamGenericReader)
  30 NS_IMPL_CYCLE_COLLECTING_RELEASE(ReadableStreamGenericReader)
  31 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(ReadableStreamGenericReader)
  32 NS_IMPL_CYCLE_COLLECTION_TRACE_END
  33
  34 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ReadableStreamGenericReader)
  35   NS_INTERFACE_MAP_ENTRY(nsISupports)
  36 NS_INTERFACE_MAP_END
  37
  38 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_INHERITED(ReadableStreamDefaultReader,
  39                                                 ReadableStreamGenericReader,
  40                                                 mReadRequests)
  41 NS_IMPL_ADDREF_INHERITED(ReadableStreamDefaultReader,
  42                          ReadableStreamGenericReader)
  43 NS_IMPL_RELEASE_INHERITED(ReadableStreamDefaultReader,
  44                           ReadableStreamGenericReader)
  45
  46 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ReadableStreamDefaultReader)
  47   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  48 NS_INTERFACE_MAP_END_INHERITING(ReadableStreamGenericReader)
  49
  50 ReadableStreamDefaultReader::ReadableStreamDefaultReader(nsISupports* aGlobal)
  51     : ReadableStreamGenericReader(do_QueryInterface(aGlobal)) {}
  52
  53 ReadableStreamDefaultReader::~ReadableStreamDefaultReader() {
  54   mReadRequests.clear();
  55 }
  56
  57 JSObject* ReadableStreamDefaultReader::WrapObject(
  58     JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
  59   return ReadableStreamDefaultReader_Binding::Wrap(aCx, this, aGivenProto);
  60 }
  61
  62 namespace streams_abstract {
  63 // https://streams.spec.whatwg.org/#readable-stream-reader-generic-initialize
  64 bool ReadableStreamReaderGenericInitialize(ReadableStreamGenericReader* aReader,
  65                                            ReadableStream* aStream) {
  66   // Step 1.
  67   aReader->SetStream(aStream);
  68
  69   // Step 2.
  70   aStream->SetReader(aReader);
  71
  72   aReader->SetClosedPromise(
  73       Promise::CreateInfallible(aReader->GetParentObject()));
  74
  75   switch (aStream->State()) {
  76       // Step 3.
  77     case ReadableStream::ReaderState::Readable:
  78       // Step 3.1
  79       // Promise created above.
  80       return true;
  81     // Step 4.
  82     case ReadableStream::ReaderState::Closed:
  83       // Step 4.1.
  84       aReader->ClosedPromise()->MaybeResolve(JS::UndefinedHandleValue);
  85
  86       return true;
  87     // Step 5.
  88     case ReadableStream::ReaderState::Errored: {
  89       // Step 5.1 Implicit
  90       // Step 5.2
  91       JS::RootingContext* rcx = RootingCx();
  92       JS::Rooted<JS::Value> rootedError(rcx, aStream->StoredError());
  93       aReader->ClosedPromise()->MaybeReject(rootedError);
  94
  95       // Step 5.3
  96       aReader->ClosedPromise()->SetSettledPromiseIsHandled();
  97       return true;
  98     }
  99     default:
 100       MOZ_ASSERT_UNREACHABLE("Unknown ReaderState");
 101       return false;
 102   }
 103 }
 104 }  // namespace streams_abstract
 105
 106 // https://streams.spec.whatwg.org/#default-reader-constructor &&
 107 // https://streams.spec.whatwg.org/#set-up-readable-stream-default-reader
 108 /* static */
 109 already_AddRefed<ReadableStreamDefaultReader>
 110 ReadableStreamDefaultReader::Constructor(const GlobalObject& aGlobal,
 111                                          ReadableStream& aStream,
 112                                          ErrorResult& aRv) {
 113   RefPtr<ReadableStreamDefaultReader> reader =
 114       new ReadableStreamDefaultReader(aGlobal.GetAsSupports());
 115
 116   // https://streams.spec.whatwg.org/#set-up-readable-stream-default-reader
 117   // Step 1.
 118   if (aStream.Locked()) {
 119     aRv.ThrowTypeError(
 120         "Cannot create a new reader for a readable stream already locked by "
 121         "another reader.");
 122     return nullptr;
 123   }
 124
 125   // Step 2.
 126   RefPtr<ReadableStream> streamPtr = &aStream;
 127   if (!ReadableStreamReaderGenericInitialize(reader, streamPtr)) {
 128     return nullptr;
 129   }
 130
 131   // Step 3.
 132   reader->mReadRequests.clear();
 133
 134   return reader.forget();
 135 }
 136
 137 void Read_ReadRequest::ChunkSteps(JSContext* aCx, JS::Handle<JS::Value> aChunk,
 138                                   ErrorResult& aRv) {
 139   // https://streams.spec.whatwg.org/#default-reader-read Step 3.
 140   // chunk steps, given chunk:
 141   //  Step 1. Resolve promise with «[ "value" → chunk, "done" → false ]».
 142
 143   // Value may need to be wrapped if stream and reader are in different
 144   // compartments.
 145   JS::Rooted<JS::Value> chunk(aCx, aChunk);
 146   if (!JS_WrapValue(aCx, &chunk)) {
 147     aRv.StealExceptionFromJSContext(aCx);
 148     return;
 149   }
 150
 151   RootedDictionary<ReadableStreamReadResult> result(aCx);
 152   result.mValue = chunk;
 153   result.mDone.Construct(false);
 154
 155   // Ensure that the object is created with the current global.
 156   JS::Rooted<JS::Value> value(aCx);
 157   if (!ToJSValue(aCx, std::move(result), &value)) {
 158     aRv.StealExceptionFromJSContext(aCx);
 159     return;
 160   }
 161
 162   mPromise->MaybeResolve(value);
 163 }
 164
 165 void Read_ReadRequest::CloseSteps(JSContext* aCx, ErrorResult& aRv) {
 166   // https://streams.spec.whatwg.org/#default-reader-read Step 3.
 167   // close steps:
 168   //  Step 1. Resolve promise with «[ "value" → undefined, "done" → true ]».
 169   RootedDictionary<ReadableStreamReadResult> result(aCx);
 170   result.mValue.setUndefined();
 171   result.mDone.Construct(true);
 172
 173   JS::Rooted<JS::Value> value(aCx);
 174   if (!ToJSValue(aCx, std::move(result), &value)) {
 175     aRv.StealExceptionFromJSContext(aCx);
 176     return;
 177   }
 178
 179   mPromise->MaybeResolve(value);
 180 }
 181
 182 void Read_ReadRequest::ErrorSteps(JSContext* aCx, JS::Handle<JS::Value> e,
 183                                   ErrorResult& aRv) {
 184   // https://streams.spec.whatwg.org/#default-reader-read Step 3.
 185   // error steps:
 186   //  Step 1. Reject promise with e.
 187   mPromise->MaybeReject(e);
 188 }
 189
 190 NS_IMPL_CYCLE_COLLECTION(ReadRequest)
 191 NS_IMPL_CYCLE_COLLECTION_INHERITED(Read_ReadRequest, ReadRequest, mPromise)
 192 NS_IMPL_CYCLE_COLLECTING_ADDREF(ReadRequest)
 193 NS_IMPL_CYCLE_COLLECTING_RELEASE(ReadRequest)
 194
 195 NS_IMPL_ADDREF_INHERITED(Read_ReadRequest, ReadRequest)
 196 NS_IMPL_RELEASE_INHERITED(Read_ReadRequest, ReadRequest)
 197
 198 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ReadRequest)
 199   NS_INTERFACE_MAP_ENTRY(nsISupports)
 200 NS_INTERFACE_MAP_END
 201
 202 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Read_ReadRequest)
 203 NS_INTERFACE_MAP_END_INHERITING(ReadRequest)
 204
 205 namespace streams_abstract {
 206 // https://streams.spec.whatwg.org/#readable-stream-default-reader-read
 207 void ReadableStreamDefaultReaderRead(JSContext* aCx,
 208                                      ReadableStreamGenericReader* aReader,
 209                                      ReadRequest* aRequest, ErrorResult& aRv) {
 210   // Step 1.
 211   ReadableStream* stream = aReader->GetStream();
 212
 213   // Step 2.
 214   MOZ_ASSERT(stream);
 215
 216   // Step 3.
 217   stream->SetDisturbed(true);
 218
 219   switch (stream->State()) {
 220     // Step 4.
 221     case ReadableStream::ReaderState::Closed: {
 222       aRequest->CloseSteps(aCx, aRv);
 223       return;
 224     }
 225
 226     case ReadableStream::ReaderState::Errored: {
 227       JS::Rooted<JS::Value> storedError(aCx, stream->StoredError());
 228       aRequest->ErrorSteps(aCx, storedError, aRv);
 229       return;
 230     }
 231
 232     case ReadableStream::ReaderState::Readable: {
 233       RefPtr<ReadableStreamController> controller(stream->Controller());
 234       MOZ_ASSERT(controller);
 235       controller->PullSteps(aCx, aRequest, aRv);
 236       return;
 237     }
 238   }
 239 }
 240 }  // namespace streams_abstract
 241
 242 // Return a raw pointer here to avoid refcounting, but make sure it's safe
 243 // (the object should be kept alive by the callee).
 244 // https://streams.spec.whatwg.org/#default-reader-read
 245 already_AddRefed<Promise> ReadableStreamDefaultReader::Read(ErrorResult& aRv) {
 246   // Step 1.
 247   if (!mStream) {
 248     aRv.ThrowTypeError("Reading is not possible after calling releaseLock.");
 249     return nullptr;
 250   }
 251
 252   // Step 2.
 253   RefPtr<Promise> promise = Promise::CreateInfallible(GetParentObject());
 254
 255   // Step 3.
 256   RefPtr<ReadRequest> request = new Read_ReadRequest(promise);
 257
 258   // Step 4.
 259   AutoEntryScript aes(mGlobal, "ReadableStreamDefaultReader::Read");
 260   JSContext* cx = aes.cx();
 261
 262   ReadableStreamDefaultReaderRead(cx, this, request, aRv);
 263   if (aRv.Failed()) {
 264     return nullptr;
 265   }
 266
 267   // Step 5.
 268   return promise.forget();
 269 }
 270
 271 namespace streams_abstract {
 272
 273 // https://streams.spec.whatwg.org/#readable-stream-reader-generic-release
 274 void ReadableStreamReaderGenericRelease(ReadableStreamGenericReader* aReader,
 275                                         ErrorResult& aRv) {
 276   // Step 1. Let stream be reader.[[stream]].
 277   RefPtr<ReadableStream> stream = aReader->GetStream();
 278
 279   // Step 2. Assert: stream is not undefined.
 280   MOZ_ASSERT(stream);
 281
 282   // Step 3. Assert: stream.[[reader]] is reader.
 283   MOZ_ASSERT(stream->GetReader() == aReader);
 284
 285   // Step 4. If stream.[[state]] is "readable", reject reader.[[closedPromise]]
 286   // with a TypeError exception.
 287   if (stream->State() == ReadableStream::ReaderState::Readable) {
 288     aReader->ClosedPromise()->MaybeRejectWithTypeError(
 289         "Releasing lock on readable stream");
 290   } else {
 291     // Step 5. Otherwise, set reader.[[closedPromise]] to a promise rejected
 292     // with a TypeError exception.
 293     RefPtr<Promise> promise = Promise::CreateRejectedWithTypeError(
 294         aReader->GetParentObject(), "Lock Released"_ns, aRv);
 295     aReader->SetClosedPromise(promise.forget());
 296   }
 297
 298   // Step 6. Set reader.[[closedPromise]].[[PromiseIsHandled]] to true.
 299   aReader->ClosedPromise()->SetSettledPromiseIsHandled();
 300
 301   // Step 7. Perform ! stream.[[controller]].[[ReleaseSteps]]().
 302   stream->Controller()->ReleaseSteps();
 303
 304   // Step 8. Set stream.[[reader]] to undefined.
 305   stream->SetReader(nullptr);
 306
 307   // Step 9. Set reader.[[stream]] to undefined.
 308   aReader->SetStream(nullptr);
 309 }
 310
 311 // https://streams.spec.whatwg.org/#abstract-opdef-readablestreamdefaultreadererrorreadrequests
 312 void ReadableStreamDefaultReaderErrorReadRequests(
 313     JSContext* aCx, ReadableStreamDefaultReader* aReader,
 314     JS::Handle<JS::Value> aError, ErrorResult& aRv) {
 315   // Step 1. Let readRequests be reader.[[readRequests]].
 316   LinkedList<RefPtr<ReadRequest>> readRequests =
 317       std::move(aReader->ReadRequests());
 318
 319   // Step 2. Set reader.[[readRequests]] to a new empty list.
 320   // Note: The std::move already cleared this anyway.
 321   aReader->ReadRequests().clear();
 322
 323   // Step 3. For each readRequest of readRequests,
 324   while (RefPtr<ReadRequest> readRequest = readRequests.popFirst()) {
 325     // Step 3.1. Perform readRequest’s error steps, given e.
 326     readRequest->ErrorSteps(aCx, aError, aRv);
 327     if (aRv.Failed()) {
 328       return;
 329     }
 330   }
 331 }
 332
 333 // https://streams.spec.whatwg.org/#abstract-opdef-readablestreamdefaultreaderrelease
 334 void ReadableStreamDefaultReaderRelease(JSContext* aCx,
 335                                         ReadableStreamDefaultReader* aReader,
 336                                         ErrorResult& aRv) {
 337   // Step 1. Perform ! ReadableStreamReaderGenericRelease(reader).
 338   ReadableStreamReaderGenericRelease(aReader, aRv);
 339   if (aRv.Failed()) {
 340     return;
 341   }
 342
 343   // Step 2. Let e be a new TypeError exception.
 344   ErrorResult rv;
 345   rv.ThrowTypeError("Releasing lock");
 346   JS::Rooted<JS::Value> error(aCx);
 347   MOZ_ALWAYS_TRUE(ToJSValue(aCx, std::move(rv), &error));
 348
 349   // Step 3. Perform ! ReadableStreamDefaultReaderErrorReadRequests(reader, e).
 350   ReadableStreamDefaultReaderErrorReadRequests(aCx, aReader, error, aRv);
 351 }
 352
 353 }  // namespace streams_abstract
 354
 355 // https://streams.spec.whatwg.org/#default-reader-release-lock
 356 void ReadableStreamDefaultReader::ReleaseLock(ErrorResult& aRv) {
 357   // Step 1. If this.[[stream]] is undefined, return.
 358   if (!mStream) {
 359     return;
 360   }
 361
 362   AutoJSAPI jsapi;
 363   if (!jsapi.Init(mGlobal)) {
 364     return aRv.ThrowUnknownError("Internal error");
 365   }
 366   JSContext* cx = jsapi.cx();
 367
 368   // Step 2. Perform ! ReadableStreamDefaultReaderRelease(this).
 369   RefPtr<ReadableStreamDefaultReader> thisRefPtr = this;
 370   ReadableStreamDefaultReaderRelease(cx, thisRefPtr, aRv);
 371 }
 372
 373 // https://streams.spec.whatwg.org/#generic-reader-closed
 374 already_AddRefed<Promise> ReadableStreamGenericReader::Closed() const {
 375   // Step 1.
 376   return do_AddRef(mClosedPromise);
 377 }
 378
 379 // https://streams.spec.whatwg.org/#readable-stream-reader-generic-cancel
 380 MOZ_CAN_RUN_SCRIPT
 381 static already_AddRefed<Promise> ReadableStreamGenericReaderCancel(
 382     JSContext* aCx, ReadableStreamGenericReader* aReader,
 383     JS::Handle<JS::Value> aReason, ErrorResult& aRv) {
 384   // Step 1 (Strong ref for below call).
 385   RefPtr<ReadableStream> stream = aReader->GetStream();
 386
 387   // Step 2.
 388   MOZ_ASSERT(stream);
 389
 390   // Step 3.
 391   return ReadableStreamCancel(aCx, stream, aReason, aRv);
 392 }
 393
 394 already_AddRefed<Promise> ReadableStreamGenericReader::Cancel(
 395     JSContext* aCx, JS::Handle<JS::Value> aReason, ErrorResult& aRv) {
 396   // Step 1. If this.[[stream]] is undefined,
 397   // return a promise rejected with a TypeError exception.
 398   if (!mStream) {
 399     aRv.ThrowTypeError("Canceling is not possible after calling releaseLock.");
 400     return nullptr;
 401   }
 402
 403   // Step 2. Return ! ReadableStreamReaderGenericCancel(this, reason).
 404   return ReadableStreamGenericReaderCancel(aCx, this, aReason, aRv);
 405 }
 406
 407 namespace streams_abstract {
 408 // https://streams.spec.whatwg.org/#set-up-readable-stream-default-reader
 409 void SetUpReadableStreamDefaultReader(ReadableStreamDefaultReader* aReader,
 410                                       ReadableStream* aStream,
 411                                       ErrorResult& aRv) {
 412   // Step 1.
 413   if (IsReadableStreamLocked(aStream)) {
 414     return aRv.ThrowTypeError(
 415         "Cannot get a new reader for a readable stream already locked by "
 416         "another reader.");
 417   }
 418
 419   // Step 2.
 420   if (!ReadableStreamReaderGenericInitialize(aReader, aStream)) {
 421     return;
 422   }
 423
 424   // Step 3.
 425   aReader->ReadRequests().clear();
 426 }
 427 }  // namespace streams_abstract
 428
 429 // https://streams.spec.whatwg.org/#readablestreamdefaultreader-read-a-chunk
 430 // To read a chunk from a ReadableStreamDefaultReader reader, given a read
 431 // request readRequest, perform ! ReadableStreamDefaultReaderRead(reader,
 432 // readRequest).
 433 void ReadableStreamDefaultReader::ReadChunk(JSContext* aCx,
 434                                             ReadRequest& aRequest,
 435                                             ErrorResult& aRv) {
 436   ReadableStreamDefaultReaderRead(aCx, this, &aRequest, aRv);
 437 }
 438
 439 }  // namespace mozilla::dom