mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1557121 - Implement Blob.text()/Blob.arrayBuffer()/Blob.stream() - part 1 - Rename FetchStream to BodyStream, r=smaug 

Differential Revision: https://phabricator.services.mozilla.com/D33826

--HG--
rename : dom/fetch/FetchStream.cpp => dom/base/BodyStream.cpp
rename : dom/fetch/FetchStream.h => dom/base/BodyStream.h
extra : moz-landing-system : lando
This commit is contained in:
Andrea Marchesini 2019-06-07 13:09:12 +00:00
Родитель 9b941f21f6
Коммит 16d8326f76
7 изменённых файлов: 86 добавлений и 86 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

101
dom/fetch/FetchStream.cpp → dom/base/BodyStream.cpp
Просмотреть файл

@ -4,10 +4,11 @@
* 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/. */
#include "FetchStream.h"
#include "BodyStream.h"
#include "mozilla/dom/DOMException.h"
#include "mozilla/dom/WorkerCommon.h"
#include "mozilla/dom/WorkerPrivate.h"
#include "mozilla/dom/WorkerRunnable.h"
#include "nsProxyRelease.h"
#include "nsStreamUtils.h"
@ -16,9 +17,9 @@ static NS_DEFINE_CID(kStreamTransportServiceCID, NS_STREAMTRANSPORTSERVICE_CID);
namespace mozilla {
namespace dom {
class FetchStream::WorkerShutdown final : public WorkerControlRunnable {
class BodyStream::WorkerShutdown final : public WorkerControlRunnable {
public:
WorkerShutdown(WorkerPrivate* aWorkerPrivate, RefPtr<FetchStream> aStream)
WorkerShutdown(WorkerPrivate* aWorkerPrivate, RefPtr<BodyStream> aStream)
: WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount),
mStream(aStream) {}
@ -36,23 +37,23 @@ class FetchStream::WorkerShutdown final : public WorkerControlRunnable {
bool aDispatchResult) override {}
private:
RefPtr<FetchStream> mStream;
RefPtr<BodyStream> mStream;
};
NS_IMPL_ISUPPORTS(FetchStream, nsIInputStreamCallback, nsIObserver,
NS_IMPL_ISUPPORTS(BodyStream, nsIInputStreamCallback, nsIObserver,
nsISupportsWeakReference)
/* static */
void FetchStream::Create(JSContext* aCx, FetchStreamHolder* aStreamHolder,
nsIGlobalObject* aGlobal, nsIInputStream* aInputStream,
JS::MutableHandle<JSObject*> aStream,
ErrorResult& aRv) {
void BodyStream::Create(JSContext* aCx, BodyStreamHolder* aStreamHolder,
nsIGlobalObject* aGlobal, nsIInputStream* aInputStream,
JS::MutableHandle<JSObject*> aStream,
ErrorResult& aRv) {
MOZ_DIAGNOSTIC_ASSERT(aCx);
MOZ_DIAGNOSTIC_ASSERT(aStreamHolder);
MOZ_DIAGNOSTIC_ASSERT(aInputStream);
RefPtr<FetchStream> stream =
new FetchStream(aGlobal, aStreamHolder, aInputStream);
RefPtr<BodyStream> stream =
new BodyStream(aGlobal, aStreamHolder, aInputStream);
if (NS_IsMainThread()) {
nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
@ -92,7 +93,7 @@ void FetchStream::Create(JSContext* aCx, FetchStreamHolder* aStreamHolder,
return;
}
// This will be released in FetchStream::FinalizeCallback(). We are
// This will be released in BodyStream::FinalizeCallback(). We are
// guaranteed the jsapi will call FinalizeCallback when ReadableStream
// js object is finalized.
NS_ADDREF(stream.get());
@ -100,8 +101,8 @@ void FetchStream::Create(JSContext* aCx, FetchStreamHolder* aStreamHolder,
aStream.set(body);
}
void FetchStream::requestData(JSContext* aCx, JS::HandleObject aStream,
size_t aDesiredSize) {
void BodyStream::requestData(JSContext* aCx, JS::HandleObject aStream,
size_t aDesiredSize) {
#if MOZ_DIAGNOSTIC_ASSERT_ENABLED
bool disturbed;
if (!JS::ReadableStreamIsDisturbed(aCx, aStream, &disturbed)) {
@ -167,10 +168,10 @@ void FetchStream::requestData(JSContext* aCx, JS::HandleObject aStream,
// All good.
}
void FetchStream::writeIntoReadRequestBuffer(JSContext* aCx,
JS::HandleObject aStream,
void* aBuffer, size_t aLength,
size_t* aByteWritten) {
void BodyStream::writeIntoReadRequestBuffer(JSContext* aCx,
JS::HandleObject aStream,
void* aBuffer, size_t aLength,
size_t* aByteWritten) {
MOZ_DIAGNOSTIC_ASSERT(aBuffer);
MOZ_DIAGNOSTIC_ASSERT(aByteWritten);
@ -206,8 +207,8 @@ void FetchStream::writeIntoReadRequestBuffer(JSContext* aCx,
// All good.
}
JS::Value FetchStream::cancel(JSContext* aCx, JS::HandleObject aStream,
JS::HandleValue aReason) {
JS::Value BodyStream::cancel(JSContext* aCx, JS::HandleObject aStream,
JS::HandleValue aReason) {
AssertIsOnOwningThread();
if (mState == eInitializing) {
@ -230,10 +231,10 @@ JS::Value FetchStream::cancel(JSContext* aCx, JS::HandleObject aStream,
return JS::UndefinedValue();
}
void FetchStream::onClosed(JSContext* aCx, JS::HandleObject aStream) {}
void BodyStream::onClosed(JSContext* aCx, JS::HandleObject aStream) {}
void FetchStream::onErrored(JSContext* aCx, JS::HandleObject aStream,
JS::HandleValue aReason) {
void BodyStream::onErrored(JSContext* aCx, JS::HandleObject aStream,
JS::HandleValue aReason) {
AssertIsOnOwningThread();
if (mState == eInitializing) {
@ -248,19 +249,19 @@ void FetchStream::onErrored(JSContext* aCx, JS::HandleObject aStream,
ReleaseObjects();
}
void FetchStream::finalize() {
void BodyStream::finalize() {
// This can be called in any thread.
// This takes ownership of the ref created in FetchStream::Create().
RefPtr<FetchStream> stream = dont_AddRef(this);
// This takes ownership of the ref created in BodyStream::Create().
RefPtr<BodyStream> stream = dont_AddRef(this);
stream->ReleaseObjects();
}
FetchStream::FetchStream(nsIGlobalObject* aGlobal,
FetchStreamHolder* aStreamHolder,
nsIInputStream* aInputStream)
: mMutex("FetchStream::mMutex"),
BodyStream::BodyStream(nsIGlobalObject* aGlobal,
BodyStreamHolder* aStreamHolder,
nsIInputStream* aInputStream)
: mMutex("BodyStream::mMutex"),
mState(eInitializing),
mGlobal(aGlobal),
mStreamHolder(aStreamHolder),
@ -270,11 +271,11 @@ FetchStream::FetchStream(nsIGlobalObject* aGlobal,
MOZ_DIAGNOSTIC_ASSERT(aStreamHolder);
}
FetchStream::~FetchStream() {}
BodyStream::~BodyStream() {}
void FetchStream::ErrorPropagation(JSContext* aCx,
const MutexAutoLock& aProofOfLock,
JS::HandleObject aStream, nsresult aError) {
void BodyStream::ErrorPropagation(JSContext* aCx,
const MutexAutoLock& aProofOfLock,
JS::HandleObject aStream, nsresult aError) {
AssertIsOnOwningThread();
// Nothing to do.
@ -301,7 +302,7 @@ void FetchStream::ErrorPropagation(JSContext* aCx,
}
NS_IMETHODIMP
FetchStream::OnInputStreamReady(nsIAsyncInputStream* aStream) {
BodyStream::OnInputStreamReady(nsIAsyncInputStream* aStream) {
AssertIsOnOwningThread();
MOZ_DIAGNOSTIC_ASSERT(aStream);
@ -359,14 +360,14 @@ FetchStream::OnInputStreamReady(nsIAsyncInputStream* aStream) {
}
/* static */
nsresult FetchStream::RetrieveInputStream(
nsresult BodyStream::RetrieveInputStream(
JS::ReadableStreamUnderlyingSource* aUnderlyingReadableStreamSource,
nsIInputStream** aInputStream) {
MOZ_ASSERT(aUnderlyingReadableStreamSource);
MOZ_ASSERT(aInputStream);
RefPtr<FetchStream> stream =
static_cast<FetchStream*>(aUnderlyingReadableStreamSource);
RefPtr<BodyStream> stream =
static_cast<BodyStream*>(aUnderlyingReadableStreamSource);
stream->AssertIsOnOwningThread();
// if mOriginalInputStream is null, the reading already started. We don't want
@ -380,7 +381,7 @@ nsresult FetchStream::RetrieveInputStream(
return NS_OK;
}
void FetchStream::Close() {
void BodyStream::Close() {
AssertIsOnOwningThread();
MutexAutoLock lock(mMutex);
@ -400,9 +401,9 @@ void FetchStream::Close() {
CloseAndReleaseObjects(cx, lock, stream);
}
void FetchStream::CloseAndReleaseObjects(JSContext* aCx,
const MutexAutoLock& aProofOfLock,
JS::HandleObject aStream) {
void BodyStream::CloseAndReleaseObjects(JSContext* aCx,
const MutexAutoLock& aProofOfLock,
JS::HandleObject aStream) {
AssertIsOnOwningThread();
MOZ_DIAGNOSTIC_ASSERT(mState != eClosed);
@ -418,12 +419,12 @@ void FetchStream::CloseAndReleaseObjects(JSContext* aCx,
}
}
void FetchStream::ReleaseObjects() {
void BodyStream::ReleaseObjects() {
MutexAutoLock lock(mMutex);
ReleaseObjects(lock);
}
void FetchStream::ReleaseObjects(const MutexAutoLock& aProofOfLock) {
void BodyStream::ReleaseObjects(const MutexAutoLock& aProofOfLock) {
// This method can be called on 2 possible threads: the owning one and a JS
// thread used to release resources. If we are on the JS thread, we need to
// dispatch a runnable to go back to the owning thread in order to release
@ -446,9 +447,9 @@ void FetchStream::ReleaseObjects(const MutexAutoLock& aProofOfLock) {
}
// A normal runnable of the owning thread is the main-thread.
RefPtr<FetchStream> self = this;
RefPtr<BodyStream> self = this;
RefPtr<Runnable> r = NS_NewRunnableFunction(
"FetchStream::ReleaseObjects", [self]() { self->ReleaseObjects(); });
"BodyStream::ReleaseObjects", [self]() { self->ReleaseObjects(); });
mOwningEventTarget->Dispatch(r.forget());
return;
}
@ -470,8 +471,8 @@ void FetchStream::ReleaseObjects(const MutexAutoLock& aProofOfLock) {
}
#ifdef DEBUG
void FetchStream::AssertIsOnOwningThread() {
NS_ASSERT_OWNINGTHREAD(FetchStream);
void BodyStream::AssertIsOnOwningThread() {
NS_ASSERT_OWNINGTHREAD(BodyStream);
}
#endif
@ -479,8 +480,8 @@ void FetchStream::AssertIsOnOwningThread() {
// -----------
NS_IMETHODIMP
FetchStream::Observe(nsISupports* aSubject, const char* aTopic,
const char16_t* aData) {
BodyStream::Observe(nsISupports* aSubject, const char* aTopic,
const char16_t* aData) {
AssertIsOnMainThread();
AssertIsOnOwningThread();

39
dom/fetch/FetchStream.h → dom/base/BodyStream.h
Просмотреть файл

@ -4,10 +4,9 @@
* 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
#ifndef mozilla_dom_BodyStream_h
#define mozilla_dom_BodyStream_h
#include "Fetch.h"
#include "jsapi.h"
#include "js/Stream.h"
#include "nsIAsyncInputStream.h"
@ -22,19 +21,29 @@ class nsIInputStream;
namespace mozilla {
namespace dom {
class FetchStreamHolder;
class WeakWorkerRef;
class FetchStream final : public nsIInputStreamCallback,
public nsIObserver,
public nsSupportsWeakReference,
private JS::ReadableStreamUnderlyingSource {
class BodyStreamHolder {
public:
NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
virtual void NullifyStream() = 0;
virtual void MarkAsRead() = 0;
virtual JSObject* ReadableStreamBody() = 0;
};
class BodyStream final : public nsIInputStreamCallback,
public nsIObserver,
public nsSupportsWeakReference,
private JS::ReadableStreamUnderlyingSource {
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINPUTSTREAMCALLBACK
NS_DECL_NSIOBSERVER
static void Create(JSContext* aCx, FetchStreamHolder* aStreamHolder,
static void Create(JSContext* aCx, BodyStreamHolder* aStreamHolder,
nsIGlobalObject* aGlobal, nsIInputStream* aInputStream,
JS::MutableHandle<JSObject*> aStream, ErrorResult& aRv);
@ -45,9 +54,9 @@ class FetchStream final : public nsIInputStreamCallback,
nsIInputStream** aInputStream);
private:
FetchStream(nsIGlobalObject* aGlobal, FetchStreamHolder* aStreamHolder,
nsIInputStream* aInputStream);
~FetchStream();
BodyStream(nsIGlobalObject* aGlobal, BodyStreamHolder* aStreamHolder,
nsIInputStream* aInputStream);
~BodyStream();
#ifdef DEBUG
void AssertIsOnOwningThread();
@ -109,7 +118,7 @@ class FetchStream final : public nsIInputStreamCallback,
eClosed,
};
// We need a mutex because JS engine can release FetchStream on a non-owning
// We need a mutex because JS engine can release BodyStream on a non-owning
// thread. We must be sure that the releasing of resources doesn't trigger
// race conditions.
Mutex mMutex;
@ -118,7 +127,7 @@ class FetchStream final : public nsIInputStreamCallback,
State mState;
nsCOMPtr<nsIGlobalObject> mGlobal;
RefPtr<FetchStreamHolder> mStreamHolder;
RefPtr<BodyStreamHolder> mStreamHolder;
nsCOMPtr<nsIEventTarget> mOwningEventTarget;
// This is the original inputStream received during the CTOR. It will be
@ -133,4 +142,4 @@ class FetchStream final : public nsIInputStreamCallback,
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_FetchStream_h
#endif // mozilla_dom_BodyStream_h

2
dom/base/moz.build
Просмотреть файл

@ -142,6 +142,7 @@ EXPORTS.mozilla.dom += [
'Attr.h',
'BarProps.h',
'BindContext.h',
'BodyStream.h',
'BodyUtil.h',
'BorrowedAttrInfo.h',
'CharacterData.h',
@ -260,6 +261,7 @@ UNIFIED_SOURCES += [
'Attr.cpp',
'AttrArray.cpp',
'BarProps.cpp',
'BodyStream.cpp',
'BodyUtil.cpp',
'BorrowedAttrInfo.cpp',
'CharacterData.cpp',

5
dom/fetch/Fetch.cpp
Просмотреть файл

@ -6,7 +6,6 @@
#include "Fetch.h"
#include "FetchConsumer.h"
#include "FetchStream.h"
#include "mozilla/dom/Document.h"
#include "nsIGlobalObject.h"
@ -1273,8 +1272,8 @@ void FetchBody<Derived>::GetBody(JSContext* aCx,
}
JS::Rooted<JSObject*> body(aCx);
FetchStream::Create(aCx, this, DerivedClass()->GetParentObject(), inputStream,
&body, aRv);
BodyStream::Create(aCx, this, DerivedClass()->GetParentObject(), inputStream,
&body, aRv);
if (NS_WARN_IF(aRv.Failed())) {
return;
}

18
dom/fetch/Fetch.h
Просмотреть файл

@ -18,6 +18,7 @@
#include "mozilla/DebugOnly.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/dom/AbortSignal.h"
#include "mozilla/dom/BodyStream.h"
#include "mozilla/dom/Promise.h"
#include "mozilla/dom/FetchStreamReader.h"
#include "mozilla/dom/RequestBinding.h"
@ -97,17 +98,6 @@ enum FetchConsumeType {
CONSUME_TEXT,
};
class FetchStreamHolder {
public:
NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
virtual void NullifyStream() = 0;
virtual void MarkAsRead() = 0;
virtual JSObject* ReadableStreamBody() = 0;
};
/*
* FetchBody's body consumption uses nsIInputStreamPump to read from the
* underlying stream to a block of memory, which is then adopted by
@ -143,7 +133,7 @@ class FetchStreamHolder {
* The pump is always released on the main thread.
*/
template <class Derived>
class FetchBody : public FetchStreamHolder, public AbortFollower {
class FetchBody : public BodyStreamHolder, public AbortFollower {
public:
friend class FetchBodyConsumer<Derived>;
@ -214,7 +204,7 @@ class FetchBody : public FetchStreamHolder, public AbortFollower {
const nsCString& MimeType() const { return mMimeType; }
// FetchStreamHolder
// BodyStreamHolder
void NullifyStream() override {
mReadableStreamBody = nullptr;
mReadableStreamReader = nullptr;
@ -243,7 +233,7 @@ class FetchBody : public FetchStreamHolder, public AbortFollower {
WorkerPrivate* mWorkerPrivate;
// This is the ReadableStream exposed to content. It's underlying source is a
// FetchStream object.
// BodyStream object.
JS::Heap<JSObject*> mReadableStreamBody;
// This is the Reader used to retrieve data from the body.

6
dom/fetch/Response.cpp
Просмотреть файл

@ -12,6 +12,7 @@
#include "nsPIDOMWindow.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/dom/BodyStream.h"
#include "mozilla/dom/FetchBinding.h"
#include "mozilla/dom/ResponseBinding.h"
#include "mozilla/dom/Headers.h"
@ -22,7 +23,6 @@
#include "nsDOMString.h"
#include "BodyExtractor.h"
#include "FetchStream.h"
#include "FetchStreamReader.h"
#include "InternalResponse.h"
@ -309,8 +309,8 @@ already_AddRefed<Response> Response::Constructor(
MOZ_ASSERT(underlyingSource);
aRv = FetchStream::RetrieveInputStream(underlyingSource,
getter_AddRefs(bodyStream));
aRv = BodyStream::RetrieveInputStream(underlyingSource,
getter_AddRefs(bodyStream));
// The releasing of the external source is needed in order to avoid an
// extra stream lock.

1
dom/fetch/moz.build
Просмотреть файл

@ -32,7 +32,6 @@ UNIFIED_SOURCES += [
'FetchConsumer.cpp',
'FetchDriver.cpp',
'FetchObserver.cpp',
'FetchStream.cpp',
'FetchStreamReader.cpp',
'FetchUtil.cpp',
'Headers.cpp',