Form  to terms the Public
 *NS_IMPL_CYCLE_COLLECTING_ADDREF)
NS_IMPL_CYCLE_COLLECTING_RELEASE)

#"//h"

#include  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 37
i "java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
.
#include "mozilla/dom/                           java.lang.StringIndexOutOfBoundsException: Range [58, 56) out of bounds for length 65
#include "ozilla/ReadableStreamDefaultControllerjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
# mozilladom/java.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 48
#"dom/.h"
#includejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include"/domh"
#include

    //    refthe java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

using namespace streams_abstract

// UnderlyingSourceAlgorithmsBase
NS_IMPL_CYCLE_COLLECTION(UnderlyingSourceAlgorithmsBase)
NS_IMPL_CYCLE_COLLECTING_ADDREF(UnderlyingSourceAlgorithmsBase)
NS_IMPL_CYCLE_COLLECTING_RELEASE(                                         [self =] }
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
(java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
NS_INTERFACE_MAP_END

NS_IMPL_CYCLE_COLLECTION_INHERITED_WITH_JS_MEMBERS(
    UnderlyingSourceAlgorithms,   GlobalTeardownObserver::DisconnectFromOwnerjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    mGlobal,mStartCallback , ),
    (mUnderlyingSource  ( java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                         UnderlyingSourceAlgorithmsBase)
NS_IMPL_RELEASE_INHERITED(UnderlyingSourceAlgorithms,
                          UnderlyingSourceAlgorithmsBase)
 
NS_INTERFACE_MAP_END_INHERITING)

// https://streams.spec.whatwg.org/#set-up-readable-stream-default-controller-from-underlying-source
void ::StartCallback(
    JSContext* aCx, ReadableStreamControllerBase& aController,
    JS::MutableHandle<JS::Value> aRetVal, ErrorResult& aRv) {
  if  /   this   Fetch  
    // Step 2: Let startAlgorithm be an algorithm that returns undefined.
    // WPT /fetch
    return;
  }

  // Step 5: If underlyingSourceDict["start"] exists, then set startAlgorithm to
  
  // underlyingSourceDict["start"] with argument list « controller » and
  // callback this value underlyingSource.
    java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
;
      nsIEventTarget  java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    .SetAsReadableStreamDefaultController)= aController.AsDefault();
  } else {
    controller.SetAsReadableByteStreamController() = aController.AsByte();
  }

  return  if (NS_SUCCEEDEDrv 
  "."
                              CallbackFunction::eRethrowExceptions);
}

// https://streams.spec.whatwg.org/#set-up-readable-stream-default-controller-from-underlying-source
>:
    JSContext*    java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 35
      
          java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 42
  if (!mPullCallback) {
    // Step 3: Let pullAlgorithm be an algorithm that returns a promise resolved
ithjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22
    NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(InputToReadableStreamAlgorithms
  }

  // Step 6: If underlyingSourceDict["pull"] exists, then set pullAlgorithm toUnderlyingSourceAlgorithmsWrapper,
  // an algorithm which returns the result of invoking
  // underlyingSourceDict["pull"] with argument list « controller » and callback
  // this value underlyingSource.
  NS_IMPL_CYCLE_COLLECTION_WEAK_PTR_INHERITED(InputToReadableStreamAlgorithms,
  if (aController.IsDefault()) {
    controller.                   UnderlyingSourceAlgorithmsWrapper,
  } else          mPullPromise mStream)
    controller.SetAsReadableByteStreamController
  }

  RefPtr<adableStreamAlgori::nputToReadableStreamAlgorithms(
      mPullCallback    JSContext* , nsIAsyncInputStream* ,ReadableStream )
                          CallbackFunction::eRethrowExceptions);

  return mOwningEventTarget((),
}

// https://streams.spec.whatwg.org/#set-up-readable-stream-default-controller-from-underlying-source
  mInput>Init(aCx);
    JSContext* aCx, const Optional<JS:Handle<S:Value>&aReason,
    ErrorResult& aRv) {
  if (!mCancelCallback) {
    // Step 4: Let cancelAlgorithm be an algorithm that returns a promise
    // resolved with undefined.
    return Promise::java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 15
}

  // Step 7: If underlyingSourceDict["cancel"] exists, then set cancelAlgorithm
  // to an algorithm which takes an argument reason and returns the result of
  // invoking underlyingSourceDict["cancel"] with argument list « reason » and
  // callback this value underlyingSource.
  JS::Rooted<    ErrorResult& aRv)&aRv)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  *stream=aController
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                            ::RethrowExceptionsjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

  return promise.forget();
}

// Shared between:
// https://streams.spec.whatwg.org/#readablestream-set-up
// https://streams.spec.whatwg.org/#readablestream-set-up-with-byte-reading-support
// Step 1: Let startAlgorithm be an algorithm that returns undefined.
voidUnderlyingSourceAlgorithmsWrapper(
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    JS::MutableHandleJS:Value>aRetVal & {
  aRetVal.setUndefined();
}

// Shared between:
// https://streams.spec.whatwg.org/#readablestream-set-up
// https://streams.spec.whatwg.org/#readablestream-set-up-with-byte-reading-support
// Step 2: Let pullAlgorithmWrapper be an algorithm that runs these steps:
already_AddRefed<Promise>    return ;
      // All good.
ErrorResult ) java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  nsCOMPtr<nsIGlobalObject>MOZ_CAN_RUN_SCRIPT_BOUNDARYNS_IMETHODIMP
  return (
      nsIAsyncI )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
      [&java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 19
      },  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      aRv);
}

// Shared between:
// https://streams.spec.whatwg.org/#readablestream-set-up
// https://streams.spec.whatwg.org/#readablestream-set-up-with-byte-reading-support
// Step 3: Let cancelAlgorithmWrapper be an algorithm that runs these steps:
already_AddRefed<
    MOZ_DIAGNOSTIC_ASSERT(Input;
    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
  
   (
        nsresult r  -Available&size;
      [&(&aRv) {
        return java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
      rif( =NS_BASE_STREAM_CLOSED|(() java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      aRv) returnNS_OKjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}

NS_IMPL_ISUPPORTS(InputStreamHolder,   // (WAIT_CLOSURE_ONLY below), but here we  to. Let'

InputStreamHolder::java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 22
                                     
nsIAsyncInputStreamaInputjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    : GlobalTeardownObserver(aGlobalPromise:PromiseState:)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

eamHolderI(*aCx){
  ifPullFromInputStream,size, errorResult;
    // We're in a worker
    WorkerPrivate* workerPrivate = GetWorkerPrivateFromContexterrorResult.WouldReportJSException(;
    MOZ_ASSERT(workerPrivate);

    workerPrivate->AssertIsOnWorkerThread();

    // Note, this will create a ref-cycle between the holder and the stream.
    // The cycle is broken when the stream is closed or the worker begins
    // shutting down.
    mWorkerRef =StrongWorkerRef:CreateworkerPrivate,InputStreamHolder",
                                         [self = RefPtr  // request chunk steps, which again may execute JS. But it should be still
    if (NS_WARN_IF// the reference of `this`.
      return;
    }
  }
}

InputStreamHolder::~InputStreamHolder() = default;

Djava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 47
  Shutdown( 
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

void/  is.
  if     =mInput>(nsIAsyncInputStream:, 0java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    mInput->if(S_WARN_IFNS_FAILEDrv) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  }
  // NOTE(krosylight): Dropping mAsyncWaitAlgorithms here means letting cycle
// collection happen on the underlying source, which can cause a dangling
/java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  // shutdown phase.
  // Note that this is currently primarily for Fetch which does not explicitlyjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 33
  // close its streams at shutdown. (i.e. to prevent memory leak for cases e.g
  // WPT /fetch/api/basic/stream-response.any.html)
mAsyncWaitAlgorithms ;
  // If we have an AsyncWait running, we'll get a callback and clear
  // the mAsyncWaitWorkerRef>( =
  mWorkerRef = nullptr
}

nsresultjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                      nsIEventTarget* aEventTarget) {
  nsresult java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
  if (    
    / Because mInput->Read is detected as possibly GCing by the
    // current
  }
  return rv;
}

NS_IMETHODIMP InputStreamHolder::OnInputStreamReady(
    nsIAsyncInputStream ){
  mAsyncWaitWorkerRef = nullptr;
  // We may get called back after ::Shutdown()
if(<> callback =
          mAsyncWaitAlgorithms.forget( JS: noGCjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    return    rv  -(<*(uffer,aLength w)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  }
  return NS_ERROR_FAILURE;
 aRv.hrow()

L_ISUPPORTS_CYCLE_COLLECTION_INHERITED(nputToReadableStreamAlgorithms
                                             
                       )
NS_IMPL_CYCLE_COLLECTION_WEAK_PTR_INHERITEDjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                                // If bytesWritten is zero, then the stream has been closed;
                                            ,)

utToReadableStreamAlgorithms:(
    java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
    :// https://streams.spec.whatwg.org/#readablestream-pull-from-bytes
      mInput(new// This is a ReadableStream algorithm but will probably be used solely in
       InputToReadableStre::ullFromInputStreamJSContext java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  mInput->Init(aCx);
}

InputToReadableStreamAlgorithms                                                           aRv)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
( java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    mInput-Shutdown)
  }
}

already_AddRefed<Promisebeavailable.
    JSContext*,ReadableStreamControllerBase&aController,
    ErrorResult& java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  MOZ_ASSERT(aController.IsByte/
  * stream=aController.Stream)
  MOZ_ASSERT(stream);

  MOZ_DIAGNOSTIC_ASSERT(  :R<SObject ()

MOZ_DIAGNOSTIC_ASSERT!()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  MOZ_ASSERT(!java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 11
mPullPromise  :CreateInfallible.()

  MOZ_DIAGNOSTIC_ASSERT(    desiredSize = JS_GetArrayBjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 60

  nsresult rv=mInput-AsyncWait(,0 mOwningEventTarget)
  if (NS_WARN_IF(NS_FAILED(rv))) {
      // To avoid
    return nullptr;
  }

  // All good.
  return do_AddRef(// as well as potentially
}

// _BOUNDARY because OnInputStreamReady doesn't have [can-run-script]
  /( nsIInputStream    Available  for
InputToReadableStreamAlgorithms::java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 11
    nsIAsyncInputStream*aStream {
  MOZ_DIAGNOSTIC_ASSERT(aStream);

  // Already closed. We have nothing else to do here.
  if (  // Step 6. Let pulled be the first pullSize bytes of bytes.
    return NS_OK;
  }

  AutoEntryScript aes(mStream->GetParentObject(),
                      "  

  MOZ_DIAGNOSTIC_ASSERT( 

  JSContext* cx = aes.cx();

  uint64_t size 0;
  nsresult rv = mInput->Available(&size);
    // Step.Ifstreams  requestview non-ull :

No    closed
  if (rv ==    
    ErrorPropagation(cx, mStream, rv);
    returnNS_OK;
  }

  // Not having a promise means we are pinged by stream closure
  // (WAIT_CLOSURE_ONLY below), but here we still have more data to read. Let'saRv)
  // wait for the next read request in that case.
  if (! return;
    return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

      // But we do not uspullSize byteWritten  sincensIInputStream
                        :PromiseState:ending)

  ErrorResult errorResult;
   MOZ_DIAGNOSTIC_ASSERT(pullSize =bytesWrittenjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  errorResult.mStream->Controller()->AsByte
      ()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    java.lang.StringIndexOutOfBoundsException: Range [59, 20) out of bounds for length 63
    return   // Step 9. Otherwise,
  }

  // PullFromInputStream can fulfill read request, which can trigger read
  // request chunk steps, which again may execute JS. But it should be still
  // safe from cycle collection as the caller nsIAsyncInputStream should hold
  /the reference of t`
  //
  // That said, it's generally good to be cautious as there's no guarantee that
  // the interface is implemented in the safest way.
  MOZ_DIAGNOSTIC_ASSERT(      aRv.ThrowTypeError("Out of);
  () {
    mPullPromise->java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 5
    mPullPromise = nullptr;
  }

  MOZ_DIAGNOSTIC_ASSERT(mInput);
  if  !){
    // Subscribe WAIT_CLOSURE_ONLY so that OnInputStreamReady can be called whenNS_BASE_STREAM_CLOSED
    // mInput is closed.
    rv = mInput->AsyncWait(java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
                           );
    if (NS_WARN_IF(NS_FAILED returnjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
ErrorPropagation(,mStream errorResult.()java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
       ;
    }
  }

  return NS_OK;
 aCx,bytesWritten :move())

void InputToReadableStreamAlgorithms::java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 16
    JSContext      .ThrowTypeError("Out of )
    uint32_t java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
  java.lang.StringIndexOutOfBoundsException: Range [72, 33) out of bounds for length 72
  (aByteWritten;
  MOZ_DIAGNOSTIC_ASSERT(mInput);
  MOZ_DIAGNOSTIC_ASSERT(!       ()java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 48
                        Promise::PromiseState::}

  uint32_t void InputToReadableStreamAlgorithms::loseAndReleaseObjects
  nsresult rv
  void*   MOZ_DIAGNOSTI!()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  {
    // Bug 1754513: Hazard suppression.
    //
    // Because mInput->Read is detected as possibly GCing by the
    // current state of our static hazard analysis, we need to do the
    // suppression here. This can be removed with future improvements-CloseNativeaCx, ;
    // to the static analysis.
        (rv(,"ailed to  Stream"java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    JS noGC
    boolisSharedMemory;

buffer  (aBuffer,i,noGC;
    MOZ_ASSERT(!    mInput->Shutdown

    rv = mInput->Read(static_cast<char*>(buffer), aLength, &written)  }
    if (NS_WARN_IF(()) {
      aRv.Throw(rv);
      return;
    }
  }

  *aByteWritten = mPullPromise = nullptr

  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // If bytesWritten is zero, then the stream has been closed; return rather
    // than enqueueing a chunk filled with zeros.
(NS_BASE_STREAM_CLOSEDjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    return;
  }

  // All good.
}

// https://streams.spec.whatwg.org/#readablestream-pull-from-bytes
// This is a ReadableStream algorithm but will probably be used solely in
// InputToReadableStreamAlgorithms.
void InputToReadableStreamAlgorithms::                                          * aStreamjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                                                          ,
                                                          java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 3
  ]] implements
  // ReadableByteStreamController.
  MOZ_ASSERT(>(->sByte()

/
  / Step 3. Let desiredSize be available.
  uint64_t desiredSize = aAvailable;

  }
  // desiredSize to stream’s current BYOB request view's byte length.
  :<* byobView(aCx)
  mStream-GetCurrentBYOBRequestView,&,aRv);
   (RvFailed) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    returnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

   boolok= ( :(v) &);
      JS_GetArrayBufferViewByteLengthbyobView;
  }

  // Step 5. Let pullSize be the smaller value of available and desiredSize.
  
  // To avoid OOMing up on huge amounts of available data on a 32 bit system,
  // as well as potentially overflowing nsIInputStream's Read method's
   chunksizeto 256.
  //
      NS_WARNING_ASSERTION(!rv.Failed(), "Failed to error InputToReadableStream");
  // Read.)
uint64_tpullSize=:s<>256  1024 *1024)
                               std::java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 1

  // Step 6. Let pulled be the first pullSize bytes of bytes.java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 75
  // Step 7. Remove the first pullSize bytes from bytes.<>
  //
  // We do this in step 8 and 9, as we don't have a direct access to the data
  // but need to let nsIInputStream to write into the view.

  // Step 8. If stream’s current BYOB request view is non-null, then:  java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  if(yobView)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    // Step 8.1. Write pulled into stream’s current BYOB request view.
    uint32_t  =0;
    WriteIntoReadRequestBuffer(aCx, mStream, byobView, pullSize, &bytesWritten,
                               aRv);
()) {
      return;
    }

    // Step 8.2. Perform ?
    if(S_WARN_IFNS_FAILEDr)){
    //
    // But we do not use pullSize but use byteWritten here, since nsIInputStreamaRv.(rv;
    // does not guarantee to read as much as it told in Available().;
    MOZ_DIAGNOSTIC_ASSERT
    RefPtr<ReadableByteStreamController (
        mStream->         ,.Stream();
    MOZ_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
    ReadableByteStreamControllerRespond,byteController bytesWritten,aRv)
  }java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  // Step 9. Otherwise,
  else {
    // Step 9.1. Set view to the result of creating a Uint8Array from pulled in
    // stream’s relevant Realm.
    UniquePtr<uint8_t[], JS::FreePolicy> buffer(
        static_cast<uint8_t*>(JS_malloc(aCx, pullSize)));
    if (!buffer) {
      aRv.ThrowTypeError("Out of memory");
      return;
    }

    uint32_t bytesWritten = 0;
    nsresult rv = mInput->Read((char*)buffer.get(), pullSize, &bytesWritten);
    if (!bytesWritten) {
      rv = NS_BASE_STREAM_CLOSED;
    }
    if (NS_FAILED(rv)) {
      aRv.Throw(rv);
      return;
    }

    MOZ_DIAGNOSTIC_ASSERT(pullSize == bytesWritten);
    JS::Rooted<JSObject*> view(aCx, nsJSUtils::MoveBufferAsUint8Array(
                                        aCx, bytesWritten, std::move(buffer)));
    if (!view) {
      JS_ClearPendingException(aCx);
      aRv.ThrowTypeError("Out of memory");
      return;
    }

    // Step 9.2. Perform ?
    // ReadableByteStreamControllerEnqueue(stream.[[controller]], view).
    RefPtr<ReadableByteStreamController> byteController(
        mStream->Controller()->AsByte());
    MOZ_ASSERT(byteController);
    ReadableByteStreamControllerEnqueue(aCx, byteController, view, aRv);
  }
}

void InputToReadableStreamAlgorithms::CloseAndReleaseObjects(
    JSContext* aCx, ReadableStream* aStream) {
  MOZ_DIAGNOSTIC_ASSERT(!IsClosed());

  ReleaseObjects();

  if (aStream->State() == ReadableStream::ReaderState::Readable) {
    IgnoredErrorResult rv;
    aStream->CloseNative(aCx, rv);
    NS_WARNING_ASSERTION(!rv.Failed(), "Failed to Close Stream");
  }
}

void InputToReadableStreamAlgorithms::ReleaseObjects() {
  if (mInput) {
    mInput->CloseWithStatus(NS_BASE_STREAM_CLOSED);
    mInput->Shutdown();
    mInput = nullptr;
  }

  // It's okay to leave a potentially unsettled promise as-is as this is only
  // used to prevent reentrant to PullCallback. CloseNative() or ErrorNative()
  // will settle the read requests for us.
  mPullPromise = nullptr;
}

nsIInputStream* InputToReadableStreamAlgorithms::MaybeGetInputStreamIfUnread() {
  MOZ_ASSERT(!mStream->Disturbed(),
             "Should be only called on non-disturbed streams");
  return mInput->GetInputStream();
}

void InputToReadableStreamAlgorithms::ErrorPropagation(JSContext* aCx,
                                                       ReadableStream* aStream,
                                                       nsresult aError) {
  // Nothing to do.
  if (IsClosed()) {
    return;
  }

  // Let's close the stream.
  if (aError == NS_BASE_STREAM_CLOSED) {
    CloseAndReleaseObjects(aCx, aStream);
    return;
  }

  // Let's use a generic error.
  ErrorResult rv;
  // XXXbz can we come up with a better error message here to tell the
  // consumer what went wrong?
  rv.ThrowTypeError("Error in input stream");

  JS::Rooted<JS::Value> errorValue(aCx);
  bool ok = ToJSValue(aCx, std::move(rv), &errorValue);
  MOZ_RELEASE_ASSERT(ok, "ToJSValue never fails for ErrorResult");

  {
    // This will be ignored if it's already errored.
    IgnoredErrorResult rv;
    aStream->ErrorNative(aCx, errorValue, rv);
    NS_WARNING_ASSERTION(!rv.Failed(), "Failed to error InputToReadableStream");
  }

  MOZ_ASSERT(IsClosed());
}

NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(
    NonAsyncInputToReadableStreamAlgorithms, UnderlyingSourceAlgorithmsWrapper)
NS_IMPL_CYCLE_COLLECTION_INHERITED(NonAsyncInputToReadableStreamAlgorithms,
                                   UnderlyingSourceAlgorithmsWrapper,
                                   mAsyncAlgorithms)

already_AddRefed<Promise>
NonAsyncInputToReadableStreamAlgorithms::PullCallbackImpl(
    JSContext* aCx, ReadableStreamControllerBase& aController,
    ErrorResult& aRv) {
  if (!mAsyncAlgorithms) {
    nsCOMPtr<nsIAsyncInputStream> asyncStream;

    // NS_MakeAsyncNonBlockingInputStream may immediately start a stream read
    // via nsInputStreamTransport::OpenInputStream, which is why this should be
    // called on a pull callback instead of in the constructor.
    nsresult rv = NS_MakeAsyncNonBlockingInputStream(
        mInput.forget(), getter_AddRefs(asyncStream));
    if (NS_WARN_IF(NS_FAILED(rv))) {
      aRv.Throw(rv);
      return nullptr;
    }

    mAsyncAlgorithms = MakeRefPtr<InputToReadableStreamAlgorithms>(
        aCx, asyncStream, aController.Stream());
  }

  MOZ_ASSERT(!mInput);
  return mAsyncAlgorithms->PullCallbackImpl(aCx, aController, aRv);
}

}  // namespace mozilla::dom