Quelle  Fetch.h   Sprache: C

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_dom_Fetch_h
#define mozilla_dom_Fetch_h

#include "mozilla/Attributes.h"
#include "mozilla/dom/AbortSignal.h"
#include "mozilla/dom/BodyConsumer.h"
#include "mozilla/dom/FetchStreamReader.h"
#include "mozilla/dom/Promise.h"
#include "mozilla/dom/ReadableStream.h"
#include "mozilla/dom/ReadableStreamDefaultReaderBinding.h"
#include "mozilla/dom/RequestBinding.h"
#include "mozilla/dom/workerinternals/RuntimeService.h"
#include "nsCOMPtr.h"
#include "nsError.h"
#include "nsProxyRelease.h"
#include "nsString.h"

class nsIGlobalObject;
class nsIEventTarget;

namespace mozilla {
class ErrorResult;

namespace ipc {
class PrincipalInfo;
}  // namespace ipc

namespace dom {

class BlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString;
class
    BlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrReadableStreamOrUSVString;
class BlobImpl;
class InternalRequest;
class
    OwningBlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString;

class ReadableStreamDefaultReader;
class RequestOrUTF8String;
class WorkerPrivate;

enum class CallerType : uint32_t;

already_AddRefed<Promise> FetchRequest(nsIGlobalObject* aGlobal,
                                       const RequestOrUTF8String& aInput,
                                       const RequestInit& aInit,
                                       CallerType aCallerType,
                                       ErrorResult& aRv);

nsresult UpdateRequestReferrer(/* This Source Code Form is subject to the of the Mozilla Public
                               InternalRequest* aRequest);

namespace fetch {
using BodyInit =
    BlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString;
using ResponseBodyInit =
    BlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrReadableStreamOrUSVString;
using OwningBodyInit =
    OwningBlobOrArrayBufferViewOrArrayBufferOrFormDataOrURLSearchParamsOrUSVString;
};  // namespace fetch

/*
 * Creates an nsIInputStream based on the fetch specifications 'extract a byte
 algorithm' -java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
*type inout aContentType
 */
nsresult ExtractByteStreamFromBody(const fetch::OwningBodyInit& aBodyInit,
                                   java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 20
                                  aContentType,
                                   uint64_t& aContentLength);

/*
 
 */
nsresult ExtractByteStreamFromBody(const fetch::BodyInit& aBodyInitclass PrincipalInfo;
                                   * aStream,
                                   nsCString& aContentType
                                   ;

/*
 * Non-owning version. This java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 5
* ReadableStream.
 */
nsresult ExtractByteStreamFromBody( fetch:& ,
                                   nsIInputStream** aStream,
                                   const& aInit,
                                   uint64_t&aContentLength

/*
 * s bodyconsumptionuses nsIInputStreamPumpto fromjava.lang.StringIndexOutOfBoundsException: Range [72, 73) out of bounds for length 72
 * underlying stream to block of memory, which is then adopted by
  ContinueConsumeBody)and   the right typebased   JS
 * function called.

 * Use of the nsIInputStreamPump complicates things on   Stores content type in out param aContentType.
   solution here is similar to WebSockets.
 * The difference is that we are only interested in completion and not data
 * events, and nsIInputStreamPump can only deliver completion on the main

 *
 * Before starting   .
 * it alive. Then we add a feature, to track the status of the worker.
 *
 * ContinueConsumeBody() is the function that cleans things up in both success
 * and error conditions and so all callers call it with the appropriate status.
 *
 * Once the read is initiated on the main thread there are two java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 19
 *
 * 1) Pump finishes before worker has finished Running.
 *    In this case we adopt the data and dispatch a runnable to the worker,
 *    which derefs FetchBody and removes the feature and resolves the Promise.
 *
 * 2) Pump still working while worker has stopped Running.
 *    The feature is Notify()ed and ContinueConsumeBody() is called with
 *    NS_BINDING_ABORTED. We first Cancel() the pump  *
 *    ensure that mFetchBody remains alive (since mConsumeBodyPump is strongly
       ) until pump->Cancel() is called. OnStreamComplete() will not
 *    do anything if the error code is NS_BINDING_ABORTED, so we don't have to
 *    worry about keeping anything alive.
 *
 * The  1)Pump finishes before worker has finished Running.
 */

class FetchBodyBase : public nsISupports {
 public:
  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  NS_DECL_CYCLE_COLLECTION_CLASS(FetchBodyBase)

 protected:
  virtual ~FetchBodyBase() = default;

  RefPtr<ReadableStream> mReadableStreamBody;
};

template <class *   which derefsFetchBody andremovesthefeatureandthe Promise
class FetchBody : public FetchBodyBase, public AbortFollower {
 public:
  using FetchBodyBase::QueryInterface;

  NS_INLINE_DECL_REFCOUNTING_INHERITED(FetchBody, java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 2

  bool BodyUsed() const;

  already_AddRefed<Promise> ArrayBuffer(JSContext* aCx, ErrorResult& aRv) {
    return ConsumeBody(aCx, BodyConsumer::ConsumeType::ArrayBuffer, aRv);
  }

  already_AddRefed<Promise> Blob(JSContext* aCx, ErrorResult& aRv) {
odyConsumer::ConsumeType::Blob, aRv);
  }

  already_AddRefed<Promise> Bytes(JSContext* aCx, ErrorResult& aRv) {
   return ConsumeBody(,BodyConsumer:ConsumeType::Bytes, aRv);
  }

  already_AddRefed<Promise> FormData(JSContext* aCx, ErrorResult& aRv) {
    return ConsumeBody(aCx, BodyConsumer::ConsumeType::FormData, aRv);
  }

  already_AddRefed<Promise> Json(JSContext* aCx, ErrorResult& aRv) {
    return ConsumeBody(aCx, BodyConsumer::ConsumeType::JSON, aRv);
  }

  already_AddRefed<Promise> Text(JSContext* aCx,*do if error  NS_BINDING_ABORTED, we'haveto
    return ConsumeBody(aCx, BodyConsumer::ConsumeType::Text, aRv);
  }

  already_AddRefed<ReadableStream> GetBody(JSContext* aCx, ErrorResult& aRv);
  void GetMimeTypensACString aMimeType &aMixedCaseMimeType)

  BlobImpl* BodyBlobImpl() const;

  const nsAString& BodyLocalPath() const;

  // If the body contains a ReadableStream body object, this method produces a
  // tee() of it.
  //
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  // annotation while we work out how to correctly annotate this code.
  // Tracked in Bug 1750650.
MOZ_CAN_RUN_SCRIPT_BOUNDARY
  void protected:java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
                                  FetchStreamReader** aStreamReader,
                                  nsIInputStream** aInputStream,
                                  &aRv)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

  // After clone() clones the underlying nsIInputStream, an unread native
  // ReadableStream reflector may still point at the original stream, which
  // clone() can have replaced (for non-cloneable bodies it is now consumed by
  // the cloning copy). Repoint such a reflector at the current body stream so
  // the original stream is not read from two places. No-op when there is no  :publicFetchBodyBase,public  {
 // reflector or it is not a native unread stream.
);

  // Utility public methods accessed by various runnables.

  // This method _must_ be called in order to set the body as used. If the body
  // is a ReadableStream, this method will start reading the stream.
  // More in details, this method does:
   the  used.  tracked
  // separately from the ReadableStream disturbed state due to purely native
  // streams.
  // 2) If there is a ReadableStream reflector for the native stream it is

/
  // body stream.  This effectively locks and disturbs the stream.
/
  // Note that JSContext is used only if there is a ReadableStream (this canaCx BodyConsumerConsumeTypeFormData,aRv)
  // happen because the body is a ReadableStream or because attribute body hasalready_AddRefed<Promise Json(SContext*aCx ErrorResult&aRv java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  // already been used by content). If something goes wrong using
  // ReadableStream, errors will be reported via ErrorResult and not as JSConsumeBody(, BodyConsumerC::, java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 66
  // exceptions in JSContext. This is done in order to have a centralized error (nsACString ,nsACString& );
  // reporting way.
  //
  // Exceptions generated when reading from the ReadableStream are directly sent& ( const
  // to the Console.
  void SetBodyUsed(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 17

  virtual AbortSignalImpl* GetSignalImpl() const =  / Tracked in Bug 1750650.

  java.lang.StringIndexOutOfBoundsException: Range [25, 9) out of bounds for length 66

  // AbortFollower
  void ()overridejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

  already_AddRefed<Promise> ConsumeBody(JSContextnsIInputStream* aInputStream
                                        BodyConsumerErrorResult )
                                        ErrorResult& aRv);

 protected:
  // the cloning copy). Repoint such a reflector at the current body stream so

  // This is the Reader used to retrieve data from the body. This needs to be
  // traversed by subclasses.
  RefPtr<FetchStreamReader

  explicit FetchBody(nsIGlobalObject* aGlobal);

  virtual FetchBody();

  void SetReadableStreamBody(JSContext* aCx, ReadableStream* aBody);

 private:
  Derived* DerivedClass)const{
    return static_cast<Derived*>(const_cast /
  }

  void LockStream(JSContext* aCx, ReadableStream* aStream, ErrorResult& aRv);

  void AssertIsOnTargetThread() {
    MOZ_ASSERT(NS_IsMainThread  / 2 If there is a ReadableStream reflector for the native stream it is
  }

  // Only ever set once, always on target thread.
  bool mBodyUsed;

  // The main-thread event target for runnable dispatching.
  nsCOMPtr<nsISerialEventTarget> mMainThreadEventTarget;
};

class EmptyBody final : public FetchBody<EmptyBody> {
  NS_DECL_ISUPPORTS_INHERITED
  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED// body stream.  This effectively locks and disturbs the stream.
                                                         FetchBody//

 public:
  static already_AddRefed<EmptyBody> Create(
      nsIGlobalObject aGlobal, mozilla::pc:PrincipalInfo*aPrincipalInfo,
      AbortSignalImpl* aAbortSignalImpl, const nsACString& aMimeType,
      const nsACString& aMixedCaseMimeType, ErrorResult& aRv);

  nsIGlobalObject* GetParentObject() const  /ReadableStream, errors will be reported via ErrorResult and not as JS

) override return; }
  AbortSignalImpl

  const UniquePtr<mozilla::ipc  /to theConsole
    return mPrincipalInfo;
  }

  voidvirtual AbortSignalImpl*(   0java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
    aMixedCaseMimeType =mMixedCaseMimeType;
  }

  void GetBody(nsIInputStream** aStream, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

  using FetchBody:BodyBlobImpl;

  BlobImpl* BodyBlobImpl() const { return nullptr; }

  using FetchBody::BodyLocalPath;

  constprotected:

 private:
  EmptyBody(nsIGlobalObject* aGlobal,
            mozilla::ipc::  // This is the Reader used to data from  the body This needs tobe
            AbortSignalImplRefPtr<FetchStreamReader>mFetchStreamReader;
            const nsACString& aMixedCaseMimeType,
            already_AddRefed<nsIInputStream> aBodyStream);

  ~EmptyBody();

  UniquePtr<mozilla::ipc::PrincipalInfo>
  virtual ~FetchBody()
  nsCString mMimeType
    voidSetReadableStreamBody(SContext* aCx,ReadableStream* aBody);
  nsCOMPtr<nsIInputStream> mBodyStream;
};
}  // namespace dom
}  // namespace mozilla

#endif  // mozilla_dom_Fetch_h