gecko-dev/intl/uconv/nsConverterInputStream.cpp
Sylvestre Ledru 265e672179 Bug 1511181 - Reformat everything to the Google coding style r=ehsan a=clang-format
# ignore-this-changeset

--HG--
extra : amend_source : 4d301d3b0b8711c4692392aa76088ba7fd7d1022
2018-11-30 11:46:48 +01:00

241 lines
7.4 KiB
C++

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
#include "nsConverterInputStream.h"
#include "nsIInputStream.h"
#include "nsReadLine.h"
#include "nsStreamUtils.h"
#include <algorithm>
#include "mozilla/Unused.h"
using namespace mozilla;
#define CONVERTER_BUFFER_SIZE 8192
NS_IMPL_ISUPPORTS(nsConverterInputStream, nsIConverterInputStream,
nsIUnicharInputStream, nsIUnicharLineInputStream)
NS_IMETHODIMP
nsConverterInputStream::Init(nsIInputStream* aStream, const char* aCharset,
int32_t aBufferSize, char16_t aReplacementChar) {
nsAutoCString label;
if (!aCharset) {
label.AssignLiteral("UTF-8");
} else {
label = aCharset;
}
auto encoding = Encoding::ForLabelNoReplacement(label);
if (!encoding) {
return NS_ERROR_UCONV_NOCONV;
}
// Previously, the implementation auto-switched only
// between the two UTF-16 variants and only when
// initialized with an endianness-unspecific label.
mConverter = encoding->NewDecoder();
size_t outputBufferSize;
if (aBufferSize <= 0) {
aBufferSize = CONVERTER_BUFFER_SIZE;
outputBufferSize = CONVERTER_BUFFER_SIZE;
} else {
// NetUtil.jsm assumes that if buffer size equals
// the input size, the whole stream will be processed
// as one readString. This is not true with encoding_rs,
// because encoding_rs might want to see space for a
// surrogate pair, so let's compute a larger output
// buffer length.
CheckedInt<size_t> needed = mConverter->MaxUTF16BufferLength(aBufferSize);
if (!needed.isValid()) {
return NS_ERROR_OUT_OF_MEMORY;
}
outputBufferSize = needed.value();
}
// set up our buffers.
if (!mByteData.SetCapacity(aBufferSize, mozilla::fallible) ||
!mUnicharData.SetLength(outputBufferSize, mozilla::fallible)) {
return NS_ERROR_OUT_OF_MEMORY;
}
mInput = aStream;
mErrorsAreFatal = !aReplacementChar;
return NS_OK;
}
NS_IMETHODIMP
nsConverterInputStream::Close() {
nsresult rv = mInput ? mInput->Close() : NS_OK;
mLineBuffer = nullptr;
mInput = nullptr;
mConverter = nullptr;
mByteData.Clear();
mUnicharData.Clear();
return rv;
}
NS_IMETHODIMP
nsConverterInputStream::Read(char16_t* aBuf, uint32_t aCount,
uint32_t* aReadCount) {
NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
uint32_t readCount = mUnicharDataLength - mUnicharDataOffset;
if (0 == readCount) {
// Fill the unichar buffer
readCount = Fill(&mLastErrorCode);
if (readCount == 0) {
*aReadCount = 0;
return mLastErrorCode;
}
}
if (readCount > aCount) {
readCount = aCount;
}
memcpy(aBuf, mUnicharData.Elements() + mUnicharDataOffset,
readCount * sizeof(char16_t));
mUnicharDataOffset += readCount;
*aReadCount = readCount;
return NS_OK;
}
NS_IMETHODIMP
nsConverterInputStream::ReadSegments(nsWriteUnicharSegmentFun aWriter,
void* aClosure, uint32_t aCount,
uint32_t* aReadCount) {
NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
uint32_t bytesToWrite = mUnicharDataLength - mUnicharDataOffset;
nsresult rv;
if (0 == bytesToWrite) {
// Fill the unichar buffer
bytesToWrite = Fill(&rv);
if (bytesToWrite <= 0) {
*aReadCount = 0;
return rv;
}
if (NS_FAILED(rv)) {
return rv;
}
}
if (bytesToWrite > aCount) bytesToWrite = aCount;
uint32_t bytesWritten;
uint32_t totalBytesWritten = 0;
while (bytesToWrite) {
rv = aWriter(this, aClosure, mUnicharData.Elements() + mUnicharDataOffset,
totalBytesWritten, bytesToWrite, &bytesWritten);
if (NS_FAILED(rv)) {
// don't propagate errors to the caller
break;
}
bytesToWrite -= bytesWritten;
totalBytesWritten += bytesWritten;
mUnicharDataOffset += bytesWritten;
}
*aReadCount = totalBytesWritten;
return NS_OK;
}
NS_IMETHODIMP
nsConverterInputStream::ReadString(uint32_t aCount, nsAString& aString,
uint32_t* aReadCount) {
NS_ASSERTION(mUnicharDataLength >= mUnicharDataOffset, "unsigned madness");
uint32_t readCount = mUnicharDataLength - mUnicharDataOffset;
if (0 == readCount) {
// Fill the unichar buffer
readCount = Fill(&mLastErrorCode);
if (readCount == 0) {
*aReadCount = 0;
return mLastErrorCode;
}
}
if (readCount > aCount) {
readCount = aCount;
}
const char16_t* buf = mUnicharData.Elements() + mUnicharDataOffset;
aString.Assign(buf, readCount);
mUnicharDataOffset += readCount;
*aReadCount = readCount;
return NS_OK;
}
uint32_t nsConverterInputStream::Fill(nsresult* aErrorCode) {
if (nullptr == mInput) {
// We already closed the stream!
*aErrorCode = NS_BASE_STREAM_CLOSED;
return 0;
}
if (NS_FAILED(mLastErrorCode)) {
// We failed to completely convert last time, and error-recovery
// is disabled. We will fare no better this time, so...
*aErrorCode = mLastErrorCode;
return 0;
}
// We assume a many to one conversion and are using equal sizes for
// the two buffers. However if an error happens at the very start
// of a byte buffer we may end up in a situation where n bytes lead
// to n+1 unicode chars. Thus we need to keep track of the leftover
// bytes as we convert.
uint32_t nb;
*aErrorCode = NS_FillArray(mByteData, mInput, mLeftOverBytes, &nb);
if (nb == 0 && mLeftOverBytes == 0) {
// No more data
*aErrorCode = NS_OK;
return 0;
}
NS_ASSERTION(uint32_t(nb) + mLeftOverBytes == mByteData.Length(),
"mByteData is lying to us somewhere");
// Now convert as much of the byte buffer to unicode as possible
auto src = AsBytes(MakeSpan(mByteData));
auto dst = MakeSpan(mUnicharData);
// mUnicharData.Length() is the buffer length, not the fill status.
// mUnicharDataLength reflects the current fill status.
mUnicharDataLength = 0;
// Whenever we convert, mUnicharData is logically empty.
mUnicharDataOffset = 0;
// Truncation from size_t to uint32_t below is OK, because the sizes
// are bounded by the lengths of mByteData and mUnicharData.
uint32_t result;
size_t read;
size_t written;
bool hadErrors;
// The design of this class is fundamentally bogus in that trailing
// errors are ignored. Always passing false as the last argument to
// Decode* calls below.
if (mErrorsAreFatal) {
Tie(result, read, written) =
mConverter->DecodeToUTF16WithoutReplacement(src, dst, false);
} else {
Tie(result, read, written, hadErrors) =
mConverter->DecodeToUTF16(src, dst, false);
}
Unused << hadErrors;
mLeftOverBytes = mByteData.Length() - read;
mUnicharDataLength = written;
if (result == kInputEmpty || result == kOutputFull) {
*aErrorCode = NS_OK;
} else {
MOZ_ASSERT(mErrorsAreFatal, "How come DecodeToUTF16() reported error?");
*aErrorCode = NS_ERROR_UDEC_ILLEGALINPUT;
}
return mUnicharDataLength;
}
NS_IMETHODIMP
nsConverterInputStream::ReadLine(nsAString& aLine, bool* aResult) {
if (!mLineBuffer) {
mLineBuffer = new nsLineBuffer<char16_t>;
}
return NS_ReadLine(this, mLineBuffer.get(), aLine, aResult);
}