nagai/fune
3
0
Fork 0
forked from mirrors/gecko-dev
Code Pull requests Activity

Bug 1800342: Make NS_NewPipe2 and NS_NewPipe infallible, to reflect reality. r=xpcom-reviewers,necko-reviewers,nika,kershaw

Browse source 
This patch doesn't change behavior; these APIs were already effectively
infallible, in the sense that it was impossible for them to return anything
other than NS_OK.

The actual API changes here are in xpcom/io/nsIPipe.idl and
xpcom/io/nsPipe3.cpp, and the rest of this patch is just updates to callsites,
removing code that handled failure-flavored return values from these functions.
(All of this removed code was already dead code, effectively.)

Differential Revision: https://phabricator.services.mozilla.com/D161947
This commit is contained in:
Daniel Holbert 2022-11-14 23:22:16 +00:00
parent 83f7b24611
commit 7f83cbcfba
27 changed files with 143 additions and 225 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

32
dom/fetch/FetchDriver.cpp
View file

@ -223,17 +223,11 @@ AlternativeDataStreamListener::OnStartRequest(nsIRequest* aRequest) {
NS_SUCCEEDED(cic->GetCacheEntryId(&mAlternativeDataCacheEntryId))) {
MOZ_DIAGNOSTIC_ASSERT(!mPipeAlternativeInputStream);
MOZ_DIAGNOSTIC_ASSERT(!mPipeAlternativeOutputStream);
nsresult rv =
NS_NewPipe(getter_AddRefs(mPipeAlternativeInputStream),
getter_AddRefs(mPipeAlternativeOutputStream),
0 /* default segment size */, UINT32_MAX /* infinite pipe */,
true /* non-blocking input, otherwise you deadlock */,
false /* blocking output, since the pipe is 'in'finite */);
if (NS_FAILED(rv)) {
mFetchDriver->FailWithNetworkError(rv);
return rv;
}
NS_NewPipe(getter_AddRefs(mPipeAlternativeInputStream),
getter_AddRefs(mPipeAlternativeOutputStream),
0 /* default segment size */, UINT32_MAX /* infinite pipe */,
true /* non-blocking input, otherwise you deadlock */,
false /* blocking output, since the pipe is 'in'finite */);
MOZ_DIAGNOSTIC_ASSERT(!mCacheInfoChannel);
mCacheInfoChannel = cic;
@ -1144,17 +1138,11 @@ FetchDriver::OnStartRequest(nsIRequest* aRequest) {
// to suspend the channel and then resume when there is space available, but
// for now use an infinite pipe to avoid blocking.
nsCOMPtr<nsIInputStream> pipeInputStream;
rv = NS_NewPipe(getter_AddRefs(pipeInputStream),
getter_AddRefs(mPipeOutputStream),
0, /* default segment size */
UINT32_MAX /* infinite pipe */,
true /* non-blocking input, otherwise you deadlock */,
false /* blocking output, since the pipe is 'in'finite */);
if (NS_WARN_IF(NS_FAILED(rv))) {
FailWithNetworkError(rv);
// Cancel request.
return rv;
}
NS_NewPipe(getter_AddRefs(pipeInputStream), getter_AddRefs(mPipeOutputStream),
0, /* default segment size */
UINT32_MAX /* infinite pipe */,
true /* non-blocking input, otherwise you deadlock */,
false /* blocking output, since the pipe is 'in'finite */);
response->SetBody(pipeInputStream, contentLength);
// If the request is a file channel, then remember the local path to

8
dom/fetch/FetchStreamReader.cpp
View file

@ -64,12 +64,8 @@ nsresult FetchStreamReader::Create(JSContext* aCx, nsIGlobalObject* aGlobal,
nsCOMPtr<nsIAsyncInputStream> pipeIn;
nsresult rv =
NS_NewPipe2(getter_AddRefs(pipeIn),
getter_AddRefs(streamReader->mPipeOut), true, true, 0, 0);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(streamReader->mPipeOut),
true, true, 0, 0);
if (!NS_IsMainThread()) {
WorkerPrivate* workerPrivate = GetWorkerPrivateFromContext(aCx);

8
dom/file/StreamBlobImpl.cpp
View file

@ -43,12 +43,10 @@ static already_AddRefed<nsICloneableInputStream> EnsureCloneableStream(
// source stream locally without waiting for the blob to be consumed.
nsCOMPtr<nsIAsyncInputStream> reader;
nsCOMPtr<nsIAsyncOutputStream> writer;
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, segmentSize, UINT32_MAX);
if (NS_WARN_IF(NS_FAILED(rv))) {
return nullptr;
}
NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer), true, true,
segmentSize, UINT32_MAX);
nsresult rv;
nsCOMPtr<nsIEventTarget> target =
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID, &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {

12
dom/file/ipc/RemoteLazyInputStream.cpp
View file

@ -587,11 +587,7 @@ RemoteLazyInputStream::CloneWithRange(uint64_t aStart, uint64_t aLength,
// copy into a pipe and replace our internal stream.
nsCOMPtr<nsIAsyncInputStream> pipeIn;
nsCOMPtr<nsIAsyncOutputStream> pipeOut;
rv = NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true,
true);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true, true);
RefPtr<RemoteLazyInputStreamThread> thread =
RemoteLazyInputStreamThread::GetOrCreate();
@ -1083,11 +1079,7 @@ nsresult RemoteLazyInputStream::EnsureAsyncRemoteStream() {
// Let's make the stream async using the DOMFile thread.
nsCOMPtr<nsIAsyncInputStream> pipeIn;
nsCOMPtr<nsIAsyncOutputStream> pipeOut;
rv = NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true,
true);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true, true);
RefPtr<RemoteLazyInputStreamThread> thread =
RemoteLazyInputStreamThread::GetOrCreate();

7
dom/security/ReferrerInfo.cpp
View file

@ -1474,17 +1474,14 @@ nsresult ReferrerInfo::ReadTailDataBeforeGecko100(
// We need to create a new pipe in order to read the aData and the rest of
// the input stream together in the old format. This would also help us with
// handling big endian correctly.
nsresult rv = NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer));
nsCOMPtr<nsIBinaryOutputStream> binaryPipeWriter =
NS_NewObjectOutputStream(writer);
// Write back the aData so that we can read bytes from it and handle big
// endian correctly.
rv = binaryPipeWriter->Write32(aData);
nsresult rv = binaryPipeWriter->Write32(aData);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}

12
dom/workers/ScriptLoader.cpp
View file

@ -950,14 +950,10 @@ nsresult WorkerScriptLoader::LoadScript(ScriptLoadRequest* aRequest) {
// In case we return early.
loadContext->mCacheStatus = WorkerLoadContext::Cancel;
rv = NS_NewPipe(
getter_AddRefs(loadContext->mCacheReadStream), getter_AddRefs(writer),
0,
UINT32_MAX, // unlimited size to avoid writer WOULD_BLOCK case
true, false); // non-blocking reader, blocking writer
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
NS_NewPipe(getter_AddRefs(loadContext->mCacheReadStream),
getter_AddRefs(writer), 0,
UINT32_MAX, // unlimited size to avoid writer WOULD_BLOCK case
true, false); // non-blocking reader, blocking writer
nsCOMPtr<nsIStreamListenerTee> tee =
do_CreateInstance(NS_STREAMLISTENERTEE_CONTRACTID);

9
image/decoders/icon/gtk/nsIconChannel.cpp
View file

@ -401,7 +401,6 @@ nsresult nsIconChannel::GetIcon(nsIURI* aURI, ByteBuf* aDataOut) {
}
nsresult nsIconChannel::Init(nsIURI* aURI) {
nsresult rv;
nsCOMPtr<nsIInputStream> stream;
using ContentChild = mozilla::dom::ContentChild;
@ -416,10 +415,8 @@ nsresult nsIconChannel::Init(nsIURI* aURI) {
nsCOMPtr<nsIAsyncInputStream> inputStream;
nsCOMPtr<nsIAsyncOutputStream> outputStream;
nsresult rv =
NS_NewPipe2(getter_AddRefs(inputStream), getter_AddRefs(outputStream),
true, false, 0, UINT32_MAX);
NS_ENSURE_SUCCESS(rv, rv);
NS_NewPipe2(getter_AddRefs(inputStream), getter_AddRefs(outputStream), true,
false, 0, UINT32_MAX);
// FIXME: Bug 1718324
// The GetSystemIcon() call will end up on the parent doing GetIcon()
@ -464,7 +461,7 @@ nsresult nsIconChannel::Init(nsIURI* aURI) {
} else {
// Get the icon directly.
ByteBuf bytebuf;
rv = GetIcon(aURI, &bytebuf);
nsresult rv = GetIcon(aURI, &bytebuf);
NS_ENSURE_SUCCESS(rv, rv);
rv = ByteBufToStream(std::move(bytebuf), getter_AddRefs(stream));

12
image/decoders/icon/mac/nsIconChannelCocoa.mm
View file

@ -340,15 +340,13 @@ nsresult nsIconChannel::MakeInputStream(nsIInputStream** _retval, bool aNonBlock
// Now, create a pipe and stuff our data into it
nsCOMPtr<nsIInputStream> inStream;
nsCOMPtr<nsIOutputStream> outStream;
rv = NS_NewPipe(getter_AddRefs(inStream), getter_AddRefs(outStream), bufferCapacity,
bufferCapacity, aNonBlocking);
NS_NewPipe(getter_AddRefs(inStream), getter_AddRefs(outStream), bufferCapacity, bufferCapacity,
aNonBlocking);
uint32_t written;
rv = outStream->Write((char*)fileBuf.get(), bufferCapacity, &written);
if (NS_SUCCEEDED(rv)) {
uint32_t written;
rv = outStream->Write((char*)fileBuf.get(), bufferCapacity, &written);
if (NS_SUCCEEDED(rv)) {
NS_IF_ADDREF(*_retval = inStream);
}
NS_IF_ADDREF(*_retval = inStream);
}
// Drop notification callbacks to prevent cycles.

14
image/decoders/icon/win/nsIconChannel.cpp
View file

@ -735,10 +735,9 @@ nsIconChannel::Open(nsIInputStream** aStream) {
// Create the asynchronous pipe with a blocking read end
nsCOMPtr<nsIAsyncInputStream> inputStream;
nsCOMPtr<nsIAsyncOutputStream> outputStream;
rv = NS_NewPipe2(getter_AddRefs(inputStream), getter_AddRefs(outputStream),
false /*nonBlockingInput*/, false /*nonBlockingOutput*/,
iconBuffer.mLen /*segmentSize*/, 1 /*segmentCount*/);
NS_ENSURE_SUCCESS(rv, rv);
NS_NewPipe2(getter_AddRefs(inputStream), getter_AddRefs(outputStream),
false /*nonBlockingInput*/, false /*nonBlockingOutput*/,
iconBuffer.mLen /*segmentSize*/, 1 /*segmentCount*/);
rv = WriteByteBufToOutputStream(iconBuffer, outputStream);
@ -794,10 +793,9 @@ nsresult nsIconChannel::StartAsyncOpen() {
// Create the asynchronous pipe with a non-blocking read end
nsCOMPtr<nsIAsyncInputStream> inputStream;
nsCOMPtr<nsIAsyncOutputStream> outputStream;
rv = NS_NewPipe2(getter_AddRefs(inputStream), getter_AddRefs(outputStream),
true /*nonBlockingInput*/, false /*nonBlockingOutput*/,
0 /*segmentSize*/, UINT32_MAX /*segmentCount*/);
NS_ENSURE_SUCCESS(rv, rv);
NS_NewPipe2(getter_AddRefs(inputStream), getter_AddRefs(outputStream),
true /*nonBlockingInput*/, false /*nonBlockingOutput*/,
0 /*segmentSize*/, UINT32_MAX /*segmentCount*/);
// If we are in content, we asynchronously request the ICO buffer from
// the parent process because the APIs to load icons don't work with

13
netwerk/base/BackgroundFileSaver.cpp
View file

@ -95,18 +95,15 @@ BackgroundFileSaver::~BackgroundFileSaver() {
nsresult BackgroundFileSaver::Init() {
MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
nsresult rv;
rv = NS_NewPipe2(getter_AddRefs(mPipeInputStream),
getter_AddRefs(mPipeOutputStream), true, true, 0,
HasInfiniteBuffer() ? UINT32_MAX : 0);
NS_ENSURE_SUCCESS(rv, rv);
NS_NewPipe2(getter_AddRefs(mPipeInputStream),
getter_AddRefs(mPipeOutputStream), true, true, 0,
HasInfiniteBuffer() ? UINT32_MAX : 0);
mControlEventTarget = GetCurrentEventTarget();
NS_ENSURE_TRUE(mControlEventTarget, NS_ERROR_NOT_INITIALIZED);
rv = NS_CreateBackgroundTaskQueue("BgFileSaver",
getter_AddRefs(mBackgroundET));
nsresult rv = NS_CreateBackgroundTaskQueue("BgFileSaver",
getter_AddRefs(mBackgroundET));
NS_ENSURE_SUCCESS(rv, rv);
sThreadCount++;

12
netwerk/base/nsSocketTransport2.cpp
View file

@ -105,7 +105,7 @@ class nsSocketEvent : public Runnable {
//-----------------------------------------------------------------------------
//#define TEST_CONNECT_ERRORS
// #define TEST_CONNECT_ERRORS
#ifdef TEST_CONNECT_ERRORS
# include <stdlib.h>
static PRErrorCode RandomizeConnectError(PRErrorCode code) {
@ -2317,9 +2317,8 @@ nsSocketTransport::OpenInputStream(uint32_t flags, uint32_t segsize,
// create a pipe
nsCOMPtr<nsIAsyncOutputStream> pipeOut;
rv = NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut),
!openBlocking, true, segsize, segcount);
if (NS_FAILED(rv)) return rv;
NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), !openBlocking,
true, segsize, segcount);
// async copy from socket to pipe
rv = NS_AsyncCopy(&mInput, pipeOut, mSocketTransportService,
@ -2364,9 +2363,8 @@ nsSocketTransport::OpenOutputStream(uint32_t flags, uint32_t segsize,
// create a pipe
nsCOMPtr<nsIAsyncInputStream> pipeIn;
rv = NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true,
!openBlocking, segsize, segcount);
if (NS_FAILED(rv)) return rv;
NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true,
!openBlocking, segsize, segcount);
// async copy from socket to pipe
rv = NS_AsyncCopy(pipeIn, &mOutput, mSocketTransportService,

5
netwerk/base/nsStreamTransportService.cpp
View file

@ -104,9 +104,8 @@ nsInputStreamTransport::OpenInputStream(uint32_t flags, uint32_t segsize,
net_ResolveSegmentParams(segsize, segcount);
nsCOMPtr<nsIAsyncOutputStream> pipeOut;
rv = NS_NewPipe2(getter_AddRefs(mPipeIn), getter_AddRefs(pipeOut),
nonblocking, true, segsize, segcount);
if (NS_FAILED(rv)) return rv;
NS_NewPipe2(getter_AddRefs(mPipeIn), getter_AddRefs(pipeOut), nonblocking,
true, segsize, segcount);
mInProgress = true;

9
netwerk/base/nsSyncStreamListener.cpp
View file

@ -12,10 +12,11 @@
using namespace mozilla::net;
nsresult nsSyncStreamListener::Init() {
return NS_NewPipe(getter_AddRefs(mPipeIn), getter_AddRefs(mPipeOut),
mozilla::net::nsIOService::gDefaultSegmentSize,
UINT32_MAX, // no size limit
false, false);
NS_NewPipe(getter_AddRefs(mPipeIn), getter_AddRefs(mPipeOut),
mozilla::net::nsIOService::gDefaultSegmentSize,
UINT32_MAX, // no size limit
false, false);
return NS_OK;
}
// static

12
netwerk/base/nsUDPSocket.cpp
View file

@ -432,16 +432,12 @@ void nsUDPSocket::OnSocketReady(PRFileDesc* fd, int16_t outFlags) {
uint32_t segsize = UDP_PACKET_CHUNK_SIZE;
uint32_t segcount = 0;
net_ResolveSegmentParams(segsize, segcount);
nsresult rv = NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut),
true, true, segsize, segcount);
if (NS_FAILED(rv)) {
return;
}
NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true, true,
segsize, segcount);
RefPtr<nsUDPOutputStream> os = new nsUDPOutputStream(this, mFD, prClientAddr);
rv = NS_AsyncCopy(pipeIn, os, mSts, NS_ASYNCCOPY_VIA_READSEGMENTS,
UDP_PACKET_CHUNK_SIZE);
nsresult rv = NS_AsyncCopy(pipeIn, os, mSts, NS_ASYNCCOPY_VIA_READSEGMENTS,
UDP_PACKET_CHUNK_SIZE);
if (NS_FAILED(rv)) {
return;

9
netwerk/protocol/about/nsAboutCache.cpp
View file

@ -49,12 +49,11 @@ nsresult nsAboutCache::Channel::Init(nsIURI* aURI, nsILoadInfo* aLoadInfo) {
mCancel = false;
nsCOMPtr<nsIInputStream> inputStream;
rv = NS_NewPipe(getter_AddRefs(inputStream), getter_AddRefs(mStream), 16384,
(uint32_t)-1,
true, // non-blocking input
false // blocking output
NS_NewPipe(getter_AddRefs(inputStream), getter_AddRefs(mStream), 16384,
(uint32_t)-1,
true, // non-blocking input
false // blocking output
);
if (NS_FAILED(rv)) return rv;
nsAutoCString storageName;
rv = ParseURI(aURI, storageName);

5
netwerk/protocol/about/nsAboutCacheEntry.cpp
View file

@ -140,9 +140,8 @@ nsresult nsAboutCacheEntry::Channel::GetContentStream(nsIURI* uri,
// Init: (block size, maximum length)
nsCOMPtr<nsIAsyncInputStream> inputStream;
rv = NS_NewPipe2(getter_AddRefs(inputStream), getter_AddRefs(mOutputStream),
true, false, 256, UINT32_MAX);
if (NS_FAILED(rv)) return rv;
NS_NewPipe2(getter_AddRefs(inputStream), getter_AddRefs(mOutputStream), true,
false, 256, UINT32_MAX);
constexpr auto buffer =
"<!DOCTYPE html>\n"

9
netwerk/protocol/http/Http3WebTransportStream.cpp
View file

@ -137,12 +137,9 @@ NS_IMETHODIMP Http3WebTransportStream::OnInputStreamReady(
nsresult Http3WebTransportStream::InitOutputPipe() {
nsCOMPtr<nsIAsyncOutputStream> out;
nsCOMPtr<nsIAsyncInputStream> in;
nsresult rv = NS_NewPipe2(getter_AddRefs(in), getter_AddRefs(out), true, true,
nsIOService::gDefaultSegmentSize,
nsIOService::gDefaultSegmentCount);
if (NS_FAILED(rv)) {
return rv;
}
NS_NewPipe2(getter_AddRefs(in), getter_AddRefs(out), true, true,
nsIOService::gDefaultSegmentSize,
nsIOService::gDefaultSegmentCount);
{
MutexAutoLock lock(mMutex);

7
netwerk/protocol/http/nsHttpTransaction.cpp
View file

@ -347,10 +347,9 @@ nsresult nsHttpTransaction::Init(
: -1;
// create pipe for response stream
rv = NS_NewPipe2(getter_AddRefs(mPipeIn), getter_AddRefs(mPipeOut), true,
true, nsIOService::gDefaultSegmentSize,
nsIOService::gDefaultSegmentCount);
if (NS_FAILED(rv)) return rv;
NS_NewPipe2(getter_AddRefs(mPipeIn), getter_AddRefs(mPipeOut), true, true,
nsIOService::gDefaultSegmentSize,
nsIOService::gDefaultSegmentCount);
if (transWithPushedStream && aPushedStreamId) {
RefPtr<nsHttpTransaction> trans =

18
netwerk/streamconv/converters/nsUnknownDecoder.cpp
View file

@ -715,18 +715,16 @@ nsresult nsUnknownDecoder::FireListenerNotifications(nsIRequest* request,
nsCOMPtr<nsIOutputStream> out;
// Create a pipe and fill it with the data from the sniffer buffer.
rv = NS_NewPipe(getter_AddRefs(in), getter_AddRefs(out), MAX_BUFFER_SIZE,
MAX_BUFFER_SIZE);
NS_NewPipe(getter_AddRefs(in), getter_AddRefs(out), MAX_BUFFER_SIZE,
MAX_BUFFER_SIZE);
rv = out->Write(mBuffer, mBufferLen, &len);
if (NS_SUCCEEDED(rv)) {
rv = out->Write(mBuffer, mBufferLen, &len);
if (NS_SUCCEEDED(rv)) {
if (len == mBufferLen) {
rv = listener->OnDataAvailable(request, in, 0, len);
} else {
NS_ERROR("Unable to write all the data into the pipe.");
rv = NS_ERROR_FAILURE;
}
if (len == mBufferLen) {
rv = listener->OnDataAvailable(request, in, 0, len);
} else {
NS_ERROR("Unable to write all the data into the pipe.");
rv = NS_ERROR_FAILURE;
}
}
}

7
toolkit/components/places/PageIconProtocolHandler.cpp
View file

@ -386,10 +386,9 @@ nsresult PageIconProtocolHandler::GetStreams(nsIAsyncInputStream** inStream,
static constexpr size_t kSegmentSize = 4096;
nsCOMPtr<nsIAsyncInputStream> pipeIn;
nsCOMPtr<nsIAsyncOutputStream> pipeOut;
nsresult rv = NS_NewPipe2(
getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true, true, kSegmentSize,
nsIFaviconService::MAX_FAVICON_BUFFER_SIZE / kSegmentSize);
NS_ENSURE_SUCCESS(rv, rv);
NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true, true,
kSegmentSize,
nsIFaviconService::MAX_FAVICON_BUFFER_SIZE / kSegmentSize);
pipeIn.forget(inStream);
pipeOut.forget(outStream);

4
xpcom/io/nsIPipe.idl
View file

@ -127,7 +127,7 @@ class nsIOutputStream;
* this mode can be useful in some cases, but should always be used with
* caution. the default value for this parameter is a finite value.
*/
[[nodiscard]] extern nsresult
extern void
NS_NewPipe2(nsIAsyncInputStream **pipeIn,
nsIAsyncOutputStream **pipeOut,
bool nonBlockingInput = false,
@ -160,7 +160,7 @@ NS_NewPipe2(nsIAsyncInputStream **pipeIn,
* @param nonBlockingOutput
* true specifies non-blocking output stream behavior
*/
[[nodiscard]] extern nsresult
extern void
NS_NewPipe(nsIInputStream **pipeIn,
nsIOutputStream **pipeOut,
uint32_t segmentSize = 0,

34
xpcom/io/nsPipe3.cpp
View file

@ -336,8 +336,8 @@ class nsPipe final {
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsPipe)
// public constructor
friend nsresult NS_NewPipe2(nsIAsyncInputStream**, nsIAsyncOutputStream**,
bool, bool, uint32_t, uint32_t);
friend void NS_NewPipe2(nsIAsyncInputStream**, nsIAsyncOutputStream**, bool,
bool, uint32_t, uint32_t);
private:
nsPipe(uint32_t aSegmentSize, uint32_t aSegmentCount);
@ -1770,9 +1770,9 @@ nsPipeOutputStream::AsyncWait(nsIOutputStreamCallback* aCallback,
////////////////////////////////////////////////////////////////////////////////
nsresult NS_NewPipe(nsIInputStream** aPipeIn, nsIOutputStream** aPipeOut,
uint32_t aSegmentSize, uint32_t aMaxSize,
bool aNonBlockingInput, bool aNonBlockingOutput) {
void NS_NewPipe(nsIInputStream** aPipeIn, nsIOutputStream** aPipeOut,
uint32_t aSegmentSize, uint32_t aMaxSize,
bool aNonBlockingInput, bool aNonBlockingOutput) {
if (aSegmentSize == 0) {
aSegmentSize = DEFAULT_SEGMENT_SIZE;
}
@ -1787,23 +1787,19 @@ nsresult NS_NewPipe(nsIInputStream** aPipeIn, nsIOutputStream** aPipeOut,
nsIAsyncInputStream* in;
nsIAsyncOutputStream* out;
nsresult rv = NS_NewPipe2(&in, &out, aNonBlockingInput, aNonBlockingOutput,
aSegmentSize, segmentCount);
if (NS_FAILED(rv)) {
return rv;
}
NS_NewPipe2(&in, &out, aNonBlockingInput, aNonBlockingOutput, aSegmentSize,
segmentCount);
*aPipeIn = in;
*aPipeOut = out;
return NS_OK;
}
// Disable thread safety analysis as this is logically a constructor, and no
// additional threads can observe these objects yet.
nsresult NS_NewPipe2(nsIAsyncInputStream** aPipeIn,
nsIAsyncOutputStream** aPipeOut, bool aNonBlockingInput,
bool aNonBlockingOutput, uint32_t aSegmentSize,
uint32_t aSegmentCount) MOZ_NO_THREAD_SAFETY_ANALYSIS {
void NS_NewPipe2(nsIAsyncInputStream** aPipeIn, nsIAsyncOutputStream** aPipeOut,
bool aNonBlockingInput, bool aNonBlockingOutput,
uint32_t aSegmentSize,
uint32_t aSegmentCount) MOZ_NO_THREAD_SAFETY_ANALYSIS {
RefPtr<nsPipe> pipe =
new nsPipe(aSegmentSize ? aSegmentSize : DEFAULT_SEGMENT_SIZE,
aSegmentCount ? aSegmentCount : DEFAULT_SEGMENT_COUNT);
@ -1817,7 +1813,6 @@ nsresult NS_NewPipe2(nsIAsyncInputStream** aPipeIn,
pipeIn.forget(aPipeIn);
pipeOut.forget(aPipeOut);
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
@ -1844,9 +1839,10 @@ nsPipeHolder::Init(bool aNonBlockingInput, bool aNonBlockingOutput,
if (mInput || mOutput) {
return NS_ERROR_ALREADY_INITIALIZED;
}
return NS_NewPipe2(getter_AddRefs(mInput), getter_AddRefs(mOutput),
aNonBlockingInput, aNonBlockingOutput, aSegmentSize,
aSegmentCount);
NS_NewPipe2(getter_AddRefs(mInput), getter_AddRefs(mOutput),
aNonBlockingInput, aNonBlockingOutput, aSegmentSize,
aSegmentCount);
return NS_OK;
}
NS_IMETHODIMP

11
xpcom/io/nsStreamUtils.cpp
View file

@ -876,12 +876,9 @@ nsresult NS_CloneInputStream(nsIInputStream* aSource,
nsCOMPtr<nsIInputStream> readerClone;
nsCOMPtr<nsIOutputStream> writer;
nsresult rv = NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer), 0,
0, // default segment size and max size
true, true); // non-blocking
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer), 0,
0, // default segment size and max size
true, true); // non-blocking
// Propagate length information provided by nsIInputStreamLength. We don't use
// InputStreamLengthHelper::GetSyncLength to avoid the risk of blocking when
@ -896,7 +893,7 @@ nsresult NS_CloneInputStream(nsIInputStream* aSource,
cloneable = do_QueryInterface(reader);
MOZ_ASSERT(cloneable && cloneable->GetCloneable());
rv = cloneable->Clone(getter_AddRefs(readerClone));
nsresult rv = cloneable->Clone(getter_AddRefs(readerClone));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}

3
xpcom/tests/gtest/TestMultiplexInputStream.cpp
View file

@ -929,8 +929,7 @@ TEST(MultiplexInputStream, ReadWhileWaiting_nsPipe)
{
nsCOMPtr<nsIAsyncInputStream> pipeIn;
nsCOMPtr<nsIAsyncOutputStream> pipeOut;
ASSERT_TRUE(NS_SUCCEEDED(NS_NewPipe2(getter_AddRefs(pipeIn),
getter_AddRefs(pipeOut), true, true)));
NS_NewPipe2(getter_AddRefs(pipeIn), getter_AddRefs(pipeOut), true, true);
TestMultiplexStreamReadWhileWaiting(pipeIn, pipeOut);
}

81
xpcom/tests/gtest/TestPipes.cpp
View file

@ -290,13 +290,11 @@ TEST(Pipes, ChainedPipes)
nsCOMPtr<nsIInputStream> in1;
nsCOMPtr<nsIOutputStream> out1;
rv = NS_NewPipe(getter_AddRefs(in1), getter_AddRefs(out1), 20, 1999);
if (NS_FAILED(rv)) return;
NS_NewPipe(getter_AddRefs(in1), getter_AddRefs(out1), 20, 1999);
nsCOMPtr<nsIInputStream> in2;
nsCOMPtr<nsIOutputStream> out2;
rv = NS_NewPipe(getter_AddRefs(in2), getter_AddRefs(out2), 200, 401);
if (NS_FAILED(rv)) return;
NS_NewPipe(getter_AddRefs(in2), getter_AddRefs(out2), 200, 401);
RefPtr<nsPump> pump = new nsPump(in1, out2);
if (pump == nullptr) return;
@ -349,16 +347,14 @@ static void RunTests(uint32_t segSize, uint32_t segCount) {
bufSize);
printf("Testing long writes...\n");
}
rv = NS_NewPipe(getter_AddRefs(in), getter_AddRefs(out), segSize, bufSize);
EXPECT_NS_SUCCEEDED(rv);
NS_NewPipe(getter_AddRefs(in), getter_AddRefs(out), segSize, bufSize);
rv = TestPipe(in, out);
EXPECT_NS_SUCCEEDED(rv);
if (gTrace) {
printf("Testing short writes...\n");
}
rv = NS_NewPipe(getter_AddRefs(in), getter_AddRefs(out), segSize, bufSize);
EXPECT_NS_SUCCEEDED(rv);
NS_NewPipe(getter_AddRefs(in), getter_AddRefs(out), segSize, bufSize);
rv = TestShortWrites(in, out);
EXPECT_NS_SUCCEEDED(rv);
}
@ -384,9 +380,8 @@ static void TestPipe2(uint32_t aNumBytes,
uint32_t maxSize = std::max(aNumBytes, aSegmentSize);
nsresult rv = NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer),
aSegmentSize, maxSize);
ASSERT_NS_SUCCEEDED(rv);
NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer), aSegmentSize,
maxSize);
nsTArray<char> inputData;
testing::CreateData(aNumBytes, inputData);
@ -439,10 +434,8 @@ static void TestPipeClone(uint32_t aTotalBytes, uint32_t aNumWrites,
// Use async input streams so we can NS_ConsumeStream() the current data
// while the pipe is still being written to.
nsresult rv =
NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer), aSegmentSize,
maxSize, true, false); // non-blocking - reader, writer
ASSERT_NS_SUCCEEDED(rv);
NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer), aSegmentSize,
maxSize, true, false); // non-blocking - reader, writer
nsCOMPtr<nsICloneableInputStream> cloneable = do_QueryInterface(reader);
ASSERT_TRUE(cloneable);
@ -458,6 +451,7 @@ static void TestPipeClone(uint32_t aTotalBytes, uint32_t aNumWrites,
// Clone the initial input stream the specified number of times
// before performing any writes.
nsresult rv;
for (uint32_t i = 0; i < aNumInitialClones; ++i) {
nsCOMPtr<nsIInputStream>* clone = streamList.AppendElement();
rv = cloneable->Clone(getter_AddRefs(*clone));
@ -632,16 +626,16 @@ TEST(Pipes, Write_AsyncWait)
const uint32_t segmentSize = 1024;
const uint32_t numSegments = 1;
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_NS_SUCCEEDED(rv);
NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer), true,
true, // non-blocking - reader, writer
segmentSize, numSegments);
nsTArray<char> inputData;
testing::CreateData(segmentSize, inputData);
uint32_t numWritten = 0;
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
nsresult rv =
writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_NS_SUCCEEDED(rv);
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
@ -668,13 +662,12 @@ TEST(Pipes, Write_AsyncWait_Clone)
const uint32_t segmentSize = 1024;
const uint32_t numSegments = 1;
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_NS_SUCCEEDED(rv);
NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer), true,
true, // non-blocking - reader, writer
segmentSize, numSegments);
nsCOMPtr<nsIInputStream> clone;
rv = NS_CloneInputStream(reader, getter_AddRefs(clone));
nsresult rv = NS_CloneInputStream(reader, getter_AddRefs(clone));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> inputData;
@ -751,13 +744,12 @@ TEST(Pipes, Write_AsyncWait_Clone_CloseOriginal)
const uint32_t segmentSize = 1024;
const uint32_t numSegments = 1;
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_NS_SUCCEEDED(rv);
NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer), true,
true, // non-blocking - reader, writer
segmentSize, numSegments);
nsCOMPtr<nsIInputStream> clone;
rv = NS_CloneInputStream(reader, getter_AddRefs(clone));
nsresult rv = NS_CloneInputStream(reader, getter_AddRefs(clone));
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> inputData;
@ -876,17 +868,16 @@ TEST(Pipes, Read_AsyncWait)
const uint32_t segmentSize = 1024;
const uint32_t numSegments = 1;
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_NS_SUCCEEDED(rv);
NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer), true,
true, // non-blocking - reader, writer
segmentSize, numSegments);
nsTArray<char> inputData;
testing::CreateData(segmentSize, inputData);
RefPtr<testing::InputStreamCallback> cb = new testing::InputStreamCallback();
rv = reader->AsyncWait(cb, 0, 0, nullptr);
nsresult rv = reader->AsyncWait(cb, 0, 0, nullptr);
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb->Called());
@ -908,13 +899,12 @@ TEST(Pipes, Read_AsyncWait_Clone)
const uint32_t segmentSize = 1024;
const uint32_t numSegments = 1;
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_NS_SUCCEEDED(rv);
NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer), true,
true, // non-blocking - reader, writer
segmentSize, numSegments);
nsCOMPtr<nsIInputStream> clone;
rv = NS_CloneInputStream(reader, getter_AddRefs(clone));
nsresult rv = NS_CloneInputStream(reader, getter_AddRefs(clone));
ASSERT_NS_SUCCEEDED(rv);
nsCOMPtr<nsIAsyncInputStream> asyncClone = do_QueryInterface(clone);
@ -979,16 +969,16 @@ void TestCloseDuringRead(uint32_t aSegmentSize, uint32_t aDataSize) {
const uint32_t maxSize = aSegmentSize;
nsresult rv = NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer),
aSegmentSize, maxSize);
ASSERT_NS_SUCCEEDED(rv);
NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer), aSegmentSize,
maxSize);
nsTArray<char> inputData;
testing::CreateData(aDataSize, inputData);
uint32_t numWritten = 0;
rv = writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
nsresult rv =
writer->Write(inputData.Elements(), inputData.Length(), &numWritten);
ASSERT_NS_SUCCEEDED(rv);
nsTArray<char> outputData;
@ -1019,8 +1009,7 @@ TEST(Pipes, Interfaces)
nsCOMPtr<nsIInputStream> reader;
nsCOMPtr<nsIOutputStream> writer;
nsresult rv = NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer));
ASSERT_NS_SUCCEEDED(rv);
NS_NewPipe(getter_AddRefs(reader), getter_AddRefs(writer));
nsCOMPtr<nsIAsyncInputStream> readerType1 = do_QueryInterface(reader);
ASSERT_TRUE(readerType1);

9
xpcom/tests/gtest/TestSlicedInputStream.cpp
View file

@ -467,10 +467,9 @@ TEST(TestSlicedInputStream, AsyncInputStream)
const uint32_t segmentSize = 1024;
const uint32_t numSegments = 1;
nsresult rv = NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer),
true, true, // non-blocking - reader, writer
segmentSize, numSegments);
ASSERT_NS_SUCCEEDED(rv);
NS_NewPipe2(getter_AddRefs(reader), getter_AddRefs(writer), true,
true, // non-blocking - reader, writer
segmentSize, numSegments);
nsTArray<char> inputData;
testing::CreateData(segmentSize, inputData);
@ -490,7 +489,7 @@ TEST(TestSlicedInputStream, AsyncInputStream)
RefPtr<testing::InputStreamCallback> cb = new testing::InputStreamCallback();
rv = async->AsyncWait(cb, 0, 0, nullptr);
nsresult rv = async->AsyncWait(cb, 0, 0, nullptr);
ASSERT_NS_SUCCEEDED(rv);
ASSERT_FALSE(cb->Called());

6
xpcom/tests/gtest/TestSnappyStreams.cpp
View file

@ -24,11 +24,7 @@ using mozilla::SnappyUncompressInputStream;
static already_AddRefed<nsIOutputStream> CompressPipe(
nsIInputStream** aReaderOut) {
nsCOMPtr<nsIOutputStream> pipeWriter;
nsresult rv = NS_NewPipe(aReaderOut, getter_AddRefs(pipeWriter));
if (NS_FAILED(rv)) {
return nullptr;
}
NS_NewPipe(aReaderOut, getter_AddRefs(pipeWriter));
nsCOMPtr<nsIOutputStream> compress =
new SnappyCompressOutputStream(pipeWriter);