wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-27 02:47:31 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #1288 - Part 1b: Rewrite nsHTTPCompressConv.

Browse source 
This also includes formatting changes.
This commit is contained in:
wolfbeast 2019-11-14 09:46:28 +01:00 • committed by Roy Tam
commit 0d109e3c9f
2 changed files with 466 additions and 405 deletions
Download patch file Download diff file Expand all files Collapse all files

205
netwerk/streamconv/converters/nsHTTPCompressConv.cpp
View file

@ -20,7 +20,7 @@
// brotli headers // brotli headers
#include "state.h" #include "state.h"
#include "decode.h" #include "brotli/decode.h"
namespace mozilla { namespace mozilla {
namespace net { namespace net {
@ -33,7 +33,8 @@ NS_IMPL_ISUPPORTS(nsHTTPCompressConv,
nsIStreamConverter, nsIStreamConverter,
nsIStreamListener, nsIStreamListener,
nsIRequestObserver, nsIRequestObserver,
nsICompressConvStats) nsICompressConvStats,
nsIThreadRetargetableStreamListener)
// nsFTPDirListingConv methods // nsFTPDirListingConv methods
nsHTTPCompressConv::nsHTTPCompressConv() nsHTTPCompressConv::nsHTTPCompressConv()
@ -45,11 +46,14 @@ nsHTTPCompressConv::nsHTTPCompressConv()
, mCheckHeaderDone(false) , mCheckHeaderDone(false)
, mStreamEnded(false) , mStreamEnded(false)
, mStreamInitialized(false) , mStreamInitialized(false)
, mDummyStreamInitialised(false)
, d_stream{}
, mLen(0) , mLen(0)
, hMode(0) , hMode(0)
, mSkipCount(0) , mSkipCount(0)
, mFlags(0) , mFlags(0)
, mDecodedDataLength(0) , mDecodedDataLength(0)
, mMutex("nsHTTPCompressConv")
{ {
LOG(("nsHttpCompresssConv %p ctor\n", this)); LOG(("nsHttpCompresssConv %p ctor\n", this));
if (NS_IsMainThread()) { if (NS_IsMainThread()) {
@ -60,8 +64,7 @@ nsHTTPCompressConv::nsHTTPCompressConv()
} }
} }
nsHTTPCompressConv::~nsHTTPCompressConv() nsHTTPCompressConv::~nsHTTPCompressConv() {
{
LOG(("nsHttpCompresssConv %p dtor\n", this)); LOG(("nsHttpCompresssConv %p dtor\n", this));
if (mInpBuffer) { if (mInpBuffer) {
free(mInpBuffer); free(mInpBuffer);
@ -79,18 +82,15 @@ nsHTTPCompressConv::~nsHTTPCompressConv()
} }
NS_IMETHODIMP NS_IMETHODIMP
nsHTTPCompressConv::GetDecodedDataLength(uint64_t *aDecodedDataLength) nsHTTPCompressConv::GetDecodedDataLength(uint64_t* aDecodedDataLength) {
{
*aDecodedDataLength = mDecodedDataLength; *aDecodedDataLength = mDecodedDataLength;
return NS_OK; return NS_OK;
} }
NS_IMETHODIMP NS_IMETHODIMP
nsHTTPCompressConv::AsyncConvertData(const char *aFromType, nsHTTPCompressConv::AsyncConvertData(const char* aFromType, const char* aToType,
const char *aToType,
nsIStreamListener* aListener, nsIStreamListener* aListener,
nsISupports *aCtxt) nsISupports* aCtxt) {
{
if (!PL_strncasecmp(aFromType, HTTP_COMPRESS_TYPE, sizeof(HTTP_COMPRESS_TYPE) - 1) || if (!PL_strncasecmp(aFromType, HTTP_COMPRESS_TYPE, sizeof(HTTP_COMPRESS_TYPE) - 1) ||
!PL_strncasecmp(aFromType, HTTP_X_COMPRESS_TYPE, sizeof(HTTP_X_COMPRESS_TYPE) - 1)) { !PL_strncasecmp(aFromType, HTTP_X_COMPRESS_TYPE, sizeof(HTTP_X_COMPRESS_TYPE) - 1)) {
mMode = HTTP_COMPRESS_COMPRESS; mMode = HTTP_COMPRESS_COMPRESS;
@ -102,29 +102,33 @@ nsHTTPCompressConv::AsyncConvertData(const char *aFromType,
} else if (!PL_strncasecmp(aFromType, HTTP_BROTLI_TYPE, sizeof(HTTP_BROTLI_TYPE) - 1)) { } else if (!PL_strncasecmp(aFromType, HTTP_BROTLI_TYPE, sizeof(HTTP_BROTLI_TYPE) - 1)) {
mMode = HTTP_COMPRESS_BROTLI; mMode = HTTP_COMPRESS_BROTLI;
} }
LOG(("nsHttpCompresssConv %p AsyncConvertData %s %s mode %d\n", LOG(("nsHttpCompresssConv %p AsyncConvertData %s %s mode %d\n", this,
this, aFromType, aToType, mMode)); aFromType, aToType, (CompressMode)mMode));
MutexAutoLock lock(mMutex);
// hook ourself up with the receiving listener. // hook ourself up with the receiving listener.
mListener = aListener; mListener = aListener;
mAsyncConvContext = aCtxt;
return NS_OK; return NS_OK;
} }
NS_IMETHODIMP NS_IMETHODIMP
nsHTTPCompressConv::OnStartRequest(nsIRequest* request, nsISupports *aContext) nsHTTPCompressConv::OnStartRequest(nsIRequest* request, nsISupports* aContext) {
{
LOG(("nsHttpCompresssConv %p onstart\n", this)); LOG(("nsHttpCompresssConv %p onstart\n", this));
return mListener->OnStartRequest(request, aContext); nsCOMPtr<nsIStreamListener> listener;
{
MutexAutoLock lock(mMutex);
listener = mListener;
}
return listener->OnStartRequest(request, aContext);
} }
NS_IMETHODIMP NS_IMETHODIMP
nsHTTPCompressConv::OnStopRequest(nsIRequest* request, nsISupports* aContext, nsHTTPCompressConv::OnStopRequest(nsIRequest* request, nsISupports* aContext,
nsresult aStatus) nsresult aStatus) {
{
nsresult status = aStatus; nsresult status = aStatus;
LOG(("nsHttpCompresssConv %p onstop %x\n", this, aStatus)); LOG(("nsHttpCompresssConv %p onstop %" PRIx32 "\n", this,
static_cast<uint32_t>(aStatus)));
// Framing integrity is enforced for content-encoding: gzip, but not for // Framing integrity is enforced for content-encoding: gzip, but not for
// content-encoding: deflate. Note that gzip vs deflate is NOT determined // content-encoding: deflate. Note that gzip vs deflate is NOT determined
@ -144,22 +148,31 @@ nsHTTPCompressConv::OnStopRequest(nsIRequest* request, nsISupports *aContext,
if (fpChannel && !isPending) { if (fpChannel && !isPending) {
fpChannel->ForcePending(true); fpChannel->ForcePending(true);
} }
if (mBrotli && (mBrotli->mTotalOut == 0) && !BrotliStateIsStreamEnd(&mBrotli->mState)) { if (mBrotli && (mBrotli->mTotalOut == 0) && !mBrotli->mBrotliStateIsStreamEnd) {
status = NS_ERROR_INVALID_CONTENT_ENCODING; status = NS_ERROR_INVALID_CONTENT_ENCODING;
} }
LOG(("nsHttpCompresssConv %p onstop brotlihandler rv %x\n", this, status)); LOG(("nsHttpCompresssConv %p onstop brotlihandler rv %" PRIx32 "\n", this,
static_cast<uint32_t>(status)));
if (fpChannel && !isPending) { if (fpChannel && !isPending) {
fpChannel->ForcePending(false); fpChannel->ForcePending(false);
} }
} }
return mListener->OnStopRequest(request, aContext, status);
nsCOMPtr<nsIStreamListener> listener;
{
MutexAutoLock lock(mMutex);
listener = mListener;
}
return listener->OnStopRequest(request, aContext, status);
} }
/* static */
/* static */ nsresult nsresult nsHTTPCompressConv::BrotliHandler(nsIInputStream* stream,
nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream, void *closure, const char *dataIn, void* closure,
uint32_t, uint32_t aAvail, uint32_t *countRead) const char* dataIn,
{ uint32_t,
uint32_t aAvail,
uint32_t* countRead) {
MOZ_ASSERT(stream); MOZ_ASSERT(stream);
nsHTTPCompressConv* self = static_cast<nsHTTPCompressConv*>(closure); nsHTTPCompressConv* self = static_cast<nsHTTPCompressConv*>(closure);
*countRead = 0; *countRead = 0;
@ -168,7 +181,7 @@ nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream, void *closure, const c
uint8_t* outPtr; uint8_t* outPtr;
size_t outSize; size_t outSize;
size_t avail = aAvail; size_t avail = aAvail;
BrotliResult res; BrotliDecoderResult res;
if (!self->mBrotli) { if (!self->mBrotli) {
*countRead = aAvail; *countRead = aAvail;
@ -186,15 +199,21 @@ nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream, void *closure, const c
outPtr = outBuffer.get(); outPtr = outBuffer.get();
// brotli api is documented in brotli/dec/decode.h and brotli/dec/decode.c // brotli api is documented in brotli/dec/decode.h and brotli/dec/decode.c
LOG(("nsHttpCompresssConv %p brotlihandler decompress %d\n", self, avail)); LOG(("nsHttpCompresssConv %p brotlihandler decompress %zu\n", self, avail));
res = ::BrotliDecompressStream( size_t totalOut = self->mBrotli->mTotalOut;
&avail, reinterpret_cast<const unsigned char **>(&dataIn), res = ::BrotliDecoderDecompressStream(
&outSize, &outPtr, &self->mBrotli->mTotalOut, &self->mBrotli->mState); &self->mBrotli->mState, &avail,
reinterpret_cast<const unsigned char**>(&dataIn), &outSize, &outPtr,
&totalOut);
outSize = kOutSize - outSize; outSize = kOutSize - outSize;
LOG(("nsHttpCompresssConv %p brotlihandler decompress rv=%x out=%d\n", self->mBrotli->mTotalOut = totalOut;
self, res, outSize)); self->mBrotli->mBrotliStateIsStreamEnd =
BrotliDecoderIsFinished(&self->mBrotli->mState);
LOG(("nsHttpCompresssConv %p brotlihandler decompress rv=%" PRIx32
" out=%zu\n",
self, static_cast<uint32_t>(res), outSize));
if (res == BROTLI_RESULT_ERROR) { if (res == BROTLI_DECODER_RESULT_ERROR) {
LOG(("nsHttpCompressConv %p marking invalid encoding", self)); LOG(("nsHttpCompressConv %p marking invalid encoding", self));
self->mBrotli->mStatus = NS_ERROR_INVALID_CONTENT_ENCODING; self->mBrotli->mStatus = NS_ERROR_INVALID_CONTENT_ENCODING;
return self->mBrotli->mStatus; return self->mBrotli->mStatus;
@ -202,7 +221,7 @@ nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream, void *closure, const c
// in 'the current implementation' brotli must consume everything before // in 'the current implementation' brotli must consume everything before
// asking for more input // asking for more input
if (res == BROTLI_RESULT_NEEDS_MORE_INPUT) { if (res == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
MOZ_ASSERT(!avail); MOZ_ASSERT(!avail);
if (avail) { if (avail) {
LOG(("nsHttpCompressConv %p did not consume all input", self)); LOG(("nsHttpCompressConv %p did not consume all input", self));
@ -216,20 +235,21 @@ nsHTTPCompressConv::BrotliHandler(nsIInputStream *stream, void *closure, const c
self->mBrotli->mSourceOffset, self->mBrotli->mSourceOffset,
reinterpret_cast<const char*>(outBuffer.get()), reinterpret_cast<const char*>(outBuffer.get()),
outSize); outSize);
LOG(("nsHttpCompressConv %p BrotliHandler ODA rv=%x", self, rv)); LOG(("nsHttpCompressConv %p BrotliHandler ODA rv=%" PRIx32, self,
static_cast<uint32_t>(rv)));
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
self->mBrotli->mStatus = rv; self->mBrotli->mStatus = rv;
return self->mBrotli->mStatus; return self->mBrotli->mStatus;
} }
} }
if (res == BROTLI_RESULT_SUCCESS || if (res == BROTLI_DECODER_RESULT_SUCCESS ||
res == BROTLI_RESULT_NEEDS_MORE_INPUT) { res == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
*countRead = aAvail; *countRead = aAvail;
return NS_OK; return NS_OK;
} }
MOZ_ASSERT (res == BROTLI_RESULT_NEEDS_MORE_OUTPUT); MOZ_ASSERT(res == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT);
} while (res == BROTLI_RESULT_NEEDS_MORE_OUTPUT); } while (res == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT);
self->mBrotli->mStatus = NS_ERROR_UNEXPECTED; self->mBrotli->mStatus = NS_ERROR_UNEXPECTED;
return self->mBrotli->mStatus; return self->mBrotli->mStatus;
@ -240,8 +260,7 @@ nsHTTPCompressConv::OnDataAvailable(nsIRequest* request,
nsISupports* aContext, nsISupports* aContext,
nsIInputStream* iStr, nsIInputStream* iStr,
uint64_t aSourceOffset, uint64_t aSourceOffset,
uint32_t aCount) uint32_t aCount) {
{
nsresult rv = NS_ERROR_INVALID_CONTENT_ENCODING; nsresult rv = NS_ERROR_INVALID_CONTENT_ENCODING;
uint32_t streamLen = aCount; uint32_t streamLen = aCount;
LOG(("nsHttpCompressConv %p OnDataAvailable %d", this, aCount)); LOG(("nsHttpCompressConv %p OnDataAvailable %d", this, aCount));
@ -276,10 +295,16 @@ nsHTTPCompressConv::OnDataAvailable(nsIRequest* request,
case HTTP_COMPRESS_DEFLATE: case HTTP_COMPRESS_DEFLATE:
if (mInpBuffer != nullptr && streamLen > mInpBufferLen) { if (mInpBuffer != nullptr && streamLen > mInpBufferLen) {
mInpBuffer = (unsigned char *) realloc(mInpBuffer, mInpBufferLen = streamLen); unsigned char* originalInpBuffer = mInpBuffer;
if (!(mInpBuffer = (unsigned char*)realloc(originalInpBuffer, mInpBufferLen = streamLen))) {
free(originalInpBuffer);
}
if (mOutBufferLen < streamLen * 2) { if (mOutBufferLen < streamLen * 2) {
mOutBuffer = (unsigned char *) realloc(mOutBuffer, mOutBufferLen = streamLen * 3); unsigned char* originalOutBuffer = mOutBuffer;
if (!(mOutBuffer = (unsigned char*)realloc(mOutBuffer, mOutBufferLen = streamLen * 3))) {
free(originalOutBuffer);
}
} }
if (mInpBuffer == nullptr || mOutBuffer == nullptr) { if (mInpBuffer == nullptr || mOutBuffer == nullptr) {
@ -350,10 +375,9 @@ nsHTTPCompressConv::OnDataAvailable(nsIRequest* request,
} }
break; break;
} else if (code == Z_DATA_ERROR) { } else if (code == Z_DATA_ERROR) {
// some servers (notably Apache with mod_deflate) don't generate zlib headers // some servers (notably Apache with mod_deflate) don't generate
// insert a dummy header and try again // zlib headers insert a dummy header and try again
static char dummy_head[2] = static char dummy_head[2] = {
{
0x8 + 0x7 * 0x10, 0x8 + 0x7 * 0x10,
(((0x8 + 0x7 * 0x10) * 0x100 + 30) / 31 * 31) & 0xFF, (((0x8 + 0x7 * 0x10) * 0x100 + 30) / 31 * 31) & 0xFF,
}; };
@ -366,9 +390,11 @@ nsHTTPCompressConv::OnDataAvailable(nsIRequest* request,
return NS_ERROR_FAILURE; return NS_ERROR_FAILURE;
} }
// stop an endless loop caused by non-deflate data being labelled as deflate // stop an endless loop caused by non-deflate data being labelled as
// deflate
if (mDummyStreamInitialised) { if (mDummyStreamInitialised) {
NS_WARNING("endless loop detected" NS_WARNING(
"endless loop detected"
" - invalid deflate"); " - invalid deflate");
return NS_ERROR_INVALID_CONTENT_ENCODING; return NS_ERROR_INVALID_CONTENT_ENCODING;
} }
@ -434,14 +460,13 @@ nsHTTPCompressConv::OnDataAvailable(nsIRequest* request,
} /* gzip */ } /* gzip */
break; break;
case HTTP_COMPRESS_BROTLI: case HTTP_COMPRESS_BROTLI: {
{
if (!mBrotli) { if (!mBrotli) {
mBrotli = new BrotliWrapper(); mBrotli = new BrotliWrapper();
} }
mBrotli->mRequest = request; mBrotli->mRequest = request;
mBrotli->mContext = aContext; mBrotli->mContext = nullptr;
mBrotli->mSourceOffset = aSourceOffset; mBrotli->mSourceOffset = aSourceOffset;
uint32_t countRead; uint32_t countRead;
@ -452,11 +477,15 @@ nsHTTPCompressConv::OnDataAvailable(nsIRequest* request,
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
return rv; return rv;
} }
} } break;
break;
default: default:
rv = mListener->OnDataAvailable(request, aContext, iStr, aSourceOffset, aCount); nsCOMPtr<nsIStreamListener> listener;
{
MutexAutoLock lock(mMutex);
listener = mListener;
}
rv = listener->OnDataAvailable(request, aContext, iStr, aSourceOffset, aCount);
if (NS_FAILED(rv)) { if (NS_FAILED(rv)) {
return rv; return rv;
} }
@ -472,16 +501,15 @@ nsHTTPCompressConv::Convert(nsIInputStream *aFromStream,
const char* aFromType, const char* aFromType,
const char* aToType, const char* aToType,
nsISupports* aCtxt, nsISupports* aCtxt,
nsIInputStream **_retval) nsIInputStream** _retval) {
{
return NS_ERROR_NOT_IMPLEMENTED; return NS_ERROR_NOT_IMPLEMENTED;
} }
nsresult nsresult nsHTTPCompressConv::do_OnDataAvailable(nsIRequest* request,
nsHTTPCompressConv::do_OnDataAvailable(nsIRequest* request, nsISupports* context,
nsISupports *context, uint64_t offset, uint64_t offset,
const char *buffer, uint32_t count) const char* buffer,
{ uint32_t count) {
if (!mStream) { if (!mStream) {
mStream = do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID); mStream = do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID);
NS_ENSURE_STATE(mStream); NS_ENSURE_STATE(mStream);
@ -489,8 +517,12 @@ nsHTTPCompressConv::do_OnDataAvailable(nsIRequest* request,
mStream->ShareData(buffer, count); mStream->ShareData(buffer, count);
nsresult rv = mListener->OnDataAvailable(request, context, mStream, nsCOMPtr<nsIStreamListener> listener;
offset, count); {
MutexAutoLock lock(mMutex);
listener = mListener;
}
nsresult rv = listener->OnDataAvailable(request, context, mStream, offset, count);
// Make sure the stream no longer references |buffer| in case our listener // Make sure the stream no longer references |buffer| in case our listener
// is crazy enough to try to read from |mStream| after ODA. // is crazy enough to try to read from |mStream| after ODA.
@ -509,10 +541,18 @@ nsHTTPCompressConv::do_OnDataAvailable(nsIRequest* request,
static unsigned gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */ static unsigned gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
uint32_t uint32_t nsHTTPCompressConv::check_header(nsIInputStream* iStr,
nsHTTPCompressConv::check_header(nsIInputStream *iStr, uint32_t streamLen, nsresult *rs) uint32_t streamLen, nsresult* rs) {
{ enum {
enum { GZIP_INIT = 0, GZIP_OS, GZIP_EXTRA0, GZIP_EXTRA1, GZIP_EXTRA2, GZIP_ORIG, GZIP_COMMENT, GZIP_CRC }; GZIP_INIT = 0,
GZIP_OS,
GZIP_EXTRA0,
GZIP_EXTRA1,
GZIP_EXTRA2,
GZIP_ORIG,
GZIP_COMMENT,
GZIP_CRC
};
char c; char c;
*rs = NS_OK; *rs = NS_OK;
@ -598,8 +638,7 @@ nsHTTPCompressConv::check_header(nsIInputStream *iStr, uint32_t streamLen, nsres
if (mFlags & ORIG_NAME) { if (mFlags & ORIG_NAME) {
iStr->Read(&c, 1, &unused); iStr->Read(&c, 1, &unused);
streamLen--; streamLen--;
if (c == 0) if (c == 0) hMode = GZIP_COMMENT;
hMode = GZIP_COMMENT;
} else { } else {
hMode = GZIP_COMMENT; hMode = GZIP_COMMENT;
} }
@ -638,13 +677,27 @@ nsHTTPCompressConv::check_header(nsIInputStream *iStr, uint32_t streamLen, nsres
return streamLen; return streamLen;
} }
NS_IMETHODIMP
nsHTTPCompressConv::CheckListenerChain() {
nsCOMPtr<nsIThreadRetargetableStreamListener> listener;
{
MutexAutoLock lock(mMutex);
listener = do_QueryInterface(mListener);
}
if (!listener) {
return NS_ERROR_NO_INTERFACE;
}
return listener->CheckListenerChain();
}
} // namespace net } // namespace net
} // namespace mozilla } // namespace mozilla
nsresult nsresult NS_NewHTTPCompressConv(
NS_NewHTTPCompressConv(mozilla::net::nsHTTPCompressConv **aHTTPCompressConv) mozilla::net::nsHTTPCompressConv** aHTTPCompressConv) {
{ MOZ_ASSERT(aHTTPCompressConv != nullptr, "null ptr");
NS_PRECONDITION(aHTTPCompressConv != nullptr, "null ptr");
if (!aHTTPCompressConv) { if (!aHTTPCompressConv) {
return NS_ERROR_NULL_POINTER; return NS_ERROR_NULL_POINTER;
} }

60
netwerk/streamconv/converters/nsHTTPCompressConv.h
View file

@ -9,8 +9,11 @@
#include "nsIStreamConverter.h" #include "nsIStreamConverter.h"
#include "nsICompressConvStats.h" #include "nsICompressConvStats.h"
#include "nsIThreadRetargetableStreamListener.h"
#include "nsCOMPtr.h" #include "nsCOMPtr.h"
#include "nsAutoPtr.h" #include "nsAutoPtr.h"
#include "mozilla/Atomics.h"
#include "mozilla/Mutex.h"
#include "zlib.h" #include "zlib.h"
@ -30,7 +33,6 @@ class nsIStringInputStream;
{0xab, 0xf4, 0x07, 0x98, 0x61, 0x51, 0x02, 0x2d} \ {0xab, 0xf4, 0x07, 0x98, 0x61, 0x51, 0x02, 0x2d} \
} }
#define HTTP_DEFLATE_TYPE "deflate" #define HTTP_DEFLATE_TYPE "deflate"
#define HTTP_GZIP_TYPE "gzip" #define HTTP_GZIP_TYPE "gzip"
#define HTTP_X_GZIP_TYPE "x-gzip" #define HTTP_X_GZIP_TYPE "x-gzip"
@ -51,39 +53,39 @@ typedef enum {
HTTP_COMPRESS_IDENTITY HTTP_COMPRESS_IDENTITY
} CompressMode; } CompressMode;
class BrotliWrapper class BrotliWrapper {
{
public: public:
BrotliWrapper() BrotliWrapper()
: mTotalOut(0) : mTotalOut(0),
, mStatus(NS_OK) mStatus(NS_OK),
{ mBrotliStateIsStreamEnd(false),
BrotliStateInit(&mState); mRequest(nullptr),
} mContext(nullptr),
~BrotliWrapper() mSourceOffset(0) {
{ BrotliDecoderStateInit(&mState, 0, 0, 0);
BrotliStateCleanup(&mState);
} }
~BrotliWrapper() { BrotliDecoderStateCleanup(&mState); }
BrotliState mState; BrotliDecoderState mState;
size_t mTotalOut; Atomic<size_t, Relaxed> mTotalOut;
nsresult mStatus; nsresult mStatus;
Atomic<bool, Relaxed> mBrotliStateIsStreamEnd;
nsIRequest* mRequest; nsIRequest* mRequest;
nsISupports* mContext; nsISupports* mContext;
uint64_t mSourceOffset; uint64_t mSourceOffset;
}; };
class nsHTTPCompressConv class nsHTTPCompressConv : public nsIStreamConverter,
: public nsIStreamConverter public nsICompressConvStats,
, public nsICompressConvStats public nsIThreadRetargetableStreamListener {
{
public: public:
// nsISupports methods // nsISupports methods
NS_DECL_THREADSAFE_ISUPPORTS NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIREQUESTOBSERVER NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER NS_DECL_NSISTREAMLISTENER
NS_DECL_NSICOMPRESSCONVSTATS NS_DECL_NSICOMPRESSCONVSTATS
NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
// nsIStreamConverter methods // nsIStreamConverter methods
NS_DECL_NSISTREAMCONVERTER NS_DECL_NSISTREAMCONVERTER
@ -94,7 +96,7 @@ private:
virtual ~nsHTTPCompressConv(); virtual ~nsHTTPCompressConv();
nsCOMPtr<nsIStreamListener> mListener; // this guy gets the converted data via his OnDataAvailable () nsCOMPtr<nsIStreamListener> mListener; // this guy gets the converted data via his OnDataAvailable ()
CompressMode mMode; Atomic<CompressMode, Relaxed> mMode;
unsigned char* mOutBuffer; unsigned char* mOutBuffer;
unsigned char* mInpBuffer; unsigned char* mInpBuffer;
@ -104,19 +106,23 @@ private:
nsAutoPtr<BrotliWrapper> mBrotli; nsAutoPtr<BrotliWrapper> mBrotli;
nsCOMPtr<nsISupports> mAsyncConvContext;
nsCOMPtr<nsIStringInputStream> mStream; nsCOMPtr<nsIStringInputStream> mStream;
static nsresult static nsresult BrotliHandler(nsIInputStream* stream,
BrotliHandler(nsIInputStream *stream, void *closure, const char *dataIn, void* closure,
uint32_t, uint32_t avail, uint32_t *countRead); const char* dataIn,
uint32_t,
uint32_t avail,
uint32_t* countRead);
nsresult do_OnDataAvailable (nsIRequest *request, nsISupports *aContext, nsresult do_OnDataAvailable(nsIRequest* request,
uint64_t aSourceOffset, const char *buffer, nsISupports* aContext,
uint64_t aSourceOffset,
const char* buffer,
uint32_t aCount); uint32_t aCount);
bool mCheckHeaderDone; bool mCheckHeaderDone;
bool mStreamEnded; Atomic<bool> mStreamEnded;
bool mStreamInitialized; bool mStreamInitialized;
bool mDummyStreamInitialised; bool mDummyStreamInitialised;
bool mFailUncleanStops; bool mFailUncleanStops;
@ -126,7 +132,9 @@ private:
uint32_t check_header(nsIInputStream* iStr, uint32_t streamLen, nsresult* rv); uint32_t check_header(nsIInputStream* iStr, uint32_t streamLen, nsresult* rv);
uint32_t mDecodedDataLength; Atomic<uint32_t, Relaxed> mDecodedDataLength;
mutable mozilla::Mutex mMutex;
}; };
} // namespace net } // namespace net