forked from mirrors/gecko-dev
156 lines
4.3 KiB
C++
156 lines
4.3 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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_FetchStream_h
|
|
#define mozilla_dom_FetchStream_h
|
|
|
|
#include "Fetch.h"
|
|
#include "jsapi.h"
|
|
#include "nsIAsyncInputStream.h"
|
|
#include "nsIObserver.h"
|
|
#include "nsISupportsImpl.h"
|
|
#include "nsWeakReference.h"
|
|
|
|
class nsIGlobalObject;
|
|
|
|
class nsIInputStream;
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
class FetchStreamHolder;
|
|
class WeakWorkerRef;
|
|
|
|
class FetchStream final : public nsIInputStreamCallback
|
|
, public nsIObserver
|
|
, public nsSupportsWeakReference
|
|
{
|
|
public:
|
|
NS_DECL_THREADSAFE_ISUPPORTS
|
|
NS_DECL_NSIINPUTSTREAMCALLBACK
|
|
NS_DECL_NSIOBSERVER
|
|
|
|
static void
|
|
Create(JSContext* aCx, FetchStreamHolder* aStreamHolder,
|
|
nsIGlobalObject* aGlobal, nsIInputStream* aInputStream,
|
|
JS::MutableHandle<JSObject*> aStream, ErrorResult& aRv);
|
|
|
|
void
|
|
Close();
|
|
|
|
static nsresult
|
|
RetrieveInputStream(void* aUnderlyingReadableStreamSource,
|
|
nsIInputStream** aInputStream);
|
|
|
|
private:
|
|
FetchStream(nsIGlobalObject* aGlobal, FetchStreamHolder* aStreamHolder,
|
|
nsIInputStream* aInputStream);
|
|
~FetchStream();
|
|
|
|
#ifdef DEBUG
|
|
void
|
|
AssertIsOnOwningThread();
|
|
#else
|
|
void
|
|
AssertIsOnOwningThread() {}
|
|
#endif
|
|
|
|
static void
|
|
RequestDataCallback(JSContext* aCx, JS::HandleObject aStream,
|
|
void* aUnderlyingSource, uint8_t aFlags,
|
|
size_t aDesiredSize);
|
|
|
|
static void
|
|
WriteIntoReadRequestCallback(JSContext* aCx, JS::HandleObject aStream,
|
|
void* aUnderlyingSource, uint8_t aFlags,
|
|
void* aBuffer, size_t aLength,
|
|
size_t* aByteWritten);
|
|
|
|
static JS::Value
|
|
CancelCallback(JSContext* aCx, JS::HandleObject aStream,
|
|
void* aUnderlyingSource, uint8_t aFlags,
|
|
JS::HandleValue aReason);
|
|
|
|
static void
|
|
ClosedCallback(JSContext* aCx, JS::HandleObject aStream,
|
|
void* aUnderlyingSource, uint8_t aFlags);
|
|
|
|
static void
|
|
ErroredCallback(JSContext* aCx, JS::HandleObject aStream,
|
|
void* aUnderlyingSource, uint8_t aFlags,
|
|
JS::HandleValue reason);
|
|
|
|
static void
|
|
FinalizeCallback(void* aUnderlyingSource, uint8_t aFlags);
|
|
|
|
void
|
|
ErrorPropagation(JSContext* aCx,
|
|
const MutexAutoLock& aProofOfLock,
|
|
JS::HandleObject aStream, nsresult aRv);
|
|
|
|
void
|
|
CloseAndReleaseObjects(JSContext* aCx,
|
|
const MutexAutoLock& aProofOfLock,
|
|
JS::HandleObject aSteam);
|
|
|
|
class WorkerShutdown;
|
|
|
|
void
|
|
ReleaseObjects(const MutexAutoLock& aProofOfLock);
|
|
|
|
void
|
|
ReleaseObjects();
|
|
|
|
// Common methods
|
|
|
|
enum State {
|
|
// This is the beginning state before any reading operation.
|
|
eInitializing,
|
|
|
|
// RequestDataCallback has not been called yet. We haven't started to read
|
|
// data from the stream yet.
|
|
eWaiting,
|
|
|
|
// We are reading data in a separate I/O thread.
|
|
eReading,
|
|
|
|
// We are ready to write something in the JS Buffer.
|
|
eWriting,
|
|
|
|
// After a writing, we want to check if the stream is closed. After the
|
|
// check, we go back to eWaiting. If a reading request happens in the
|
|
// meantime, we move to eReading state.
|
|
eChecking,
|
|
|
|
// Operation completed.
|
|
eClosed,
|
|
};
|
|
|
|
// We need a mutex because JS engine can release FetchStream on a non-owning
|
|
// thread. We must be sure that the releasing of resources doesn't trigger
|
|
// race conditions.
|
|
Mutex mMutex;
|
|
|
|
// Protected by mutex.
|
|
State mState;
|
|
|
|
nsCOMPtr<nsIGlobalObject> mGlobal;
|
|
RefPtr<FetchStreamHolder> mStreamHolder;
|
|
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
|
|
|
|
// This is the original inputStream received during the CTOR. It will be
|
|
// converted into an nsIAsyncInputStream and stored into mInputStream at the
|
|
// first use.
|
|
nsCOMPtr<nsIInputStream> mOriginalInputStream;
|
|
nsCOMPtr<nsIAsyncInputStream> mInputStream;
|
|
|
|
RefPtr<WeakWorkerRef> mWorkerRef;
|
|
};
|
|
|
|
} // dom namespace
|
|
} // mozilla namespace
|
|
|
|
#endif // mozilla_dom_FetchStream_h
|