AddrInfo::~AddrInfo()
{
NetAddrElement *addrElement;
while ((addrElement = mAddresses.popLast())) {
delete addrElement;
}
moz_free(mHostName);
moz_free(mCanonicalName);
}
/* AString convertFromByteArray([const,array,size_is(aCount)] in octet aData,
in unsigned long aCount);
*/
NS_IMETHODIMP
nsScriptableUnicodeConverter::ConvertFromByteArray(const uint8_t* aData,
uint32_t aCount,
nsAString& _retval)
{
if (!mDecoder)
return NS_ERROR_FAILURE;
nsresult rv = NS_OK;
int32_t inLength = aCount;
int32_t outLength;
rv = mDecoder->GetMaxLength(reinterpret_cast<const char*>(aData),
inLength, &outLength);
if (NS_SUCCEEDED(rv))
{
PRUnichar* buf = (PRUnichar*)moz_malloc((outLength+1)*sizeof(PRUnichar));
if (!buf)
return NS_ERROR_OUT_OF_MEMORY;
rv = mDecoder->Convert(reinterpret_cast<const char*>(aData),
&inLength, buf, &outLength);
if (NS_SUCCEEDED(rv))
{
buf[outLength] = 0;
_retval.Assign(buf, outLength);
}
moz_free(buf);
return rv;
}
return NS_ERROR_FAILURE;
}
/* void convertToByteArray(in AString aString,
[optional] out unsigned long aLen,
[array, size_is(aLen),retval] out octet aData);
*/
NS_IMETHODIMP
nsScriptableUnicodeConverter::ConvertToByteArray(const nsAString& aString,
uint32_t* aLen,
uint8_t** _aData)
{
char* data;
int32_t len;
nsresult rv = ConvertFromUnicodeWithLength(aString, &len, &data);
if (NS_FAILED(rv))
return rv;
nsXPIDLCString str;
str.Adopt(data, len); // NOTE: This uses the XPIDLCString as a byte array
rv = FinishWithLength(&data, &len);
if (NS_FAILED(rv))
return rv;
str.Append(data, len);
moz_free(data);
// NOTE: this being a byte array, it needs no null termination
*_aData = reinterpret_cast<uint8_t*>(moz_malloc(str.Length()));
if (!*_aData)
return NS_ERROR_OUT_OF_MEMORY;
memcpy(*_aData, str.get(), str.Length());
*aLen = str.Length();
return NS_OK;
}
/* nsIInputStream convertToInputStream(in AString aString); */
NS_IMETHODIMP
nsScriptableUnicodeConverter::ConvertToInputStream(const nsAString& aString,
nsIInputStream** _retval)
{
nsresult rv;
nsCOMPtr<nsIStringInputStream> inputStream =
do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv);
if (NS_FAILED(rv))
return rv;
uint8_t* data;
uint32_t dataLen;
rv = ConvertToByteArray(aString, &dataLen, &data);
if (NS_FAILED(rv))
return rv;
rv = inputStream->AdoptData(reinterpret_cast<char*>(data), dataLen);
if (NS_FAILED(rv)) {
moz_free(data);
return rv;
}
NS_ADDREF(*_retval = inputStream);
return rv;
}
nsresult
nsScriptableUnicodeConverter::ConvertFromUnicodeWithLength(const nsAString& aSrc,
int32_t* aOutLen,
char **_retval)
{
if (!mEncoder)
return NS_ERROR_FAILURE;
nsresult rv = NS_OK;
int32_t inLength = aSrc.Length();
const nsAFlatString& flatSrc = PromiseFlatString(aSrc);
rv = mEncoder->GetMaxLength(flatSrc.get(), inLength, aOutLen);
if (NS_SUCCEEDED(rv)) {
*_retval = (char*)moz_malloc(*aOutLen+1);
if (!*_retval)
return NS_ERROR_OUT_OF_MEMORY;
rv = mEncoder->Convert(flatSrc.get(), &inLength, *_retval, aOutLen);
if (NS_SUCCEEDED(rv))
{
(*_retval)[*aOutLen] = '\0';
return NS_OK;
}
moz_free(*_retval);
}
*_retval = nullptr;
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsBinaryOutputStream::WriteWStringZ(const char16_t* aString)
{
uint32_t length, byteCount;
nsresult rv;
length = NS_strlen(aString);
rv = Write32(length);
if (NS_FAILED(rv)) return rv;
if (length == 0)
return NS_OK;
byteCount = length * sizeof(char16_t);
#ifdef IS_BIG_ENDIAN
rv = WriteBytes(reinterpret_cast<const char*>(aString), byteCount);
#else
// XXX use WriteSegments here to avoid copy!
char16_t *copy, temp[64];
if (length <= 64) {
copy = temp;
} else {
copy = reinterpret_cast<char16_t*>(moz_malloc(byteCount));
if (!copy)
return NS_ERROR_OUT_OF_MEMORY;
}
NS_ASSERTION((uintptr_t(aString) & 0x1) == 0, "aString not properly aligned");
mozilla::NativeEndian::copyAndSwapToBigEndian(copy, aString, length);
rv = WriteBytes(reinterpret_cast<const char*>(copy), byteCount);
if (copy != temp)
moz_free(copy);
#endif
return rv;
}
void
nsAttrAndChildArray::Compact()
{
if (!mImpl) {
return;
}
// First compress away empty attrslots
uint32_t slotCount = AttrSlotCount();
uint32_t attrCount = NonMappedAttrCount();
uint32_t childCount = ChildCount();
if (attrCount < slotCount) {
memmove(mImpl->mBuffer + attrCount * ATTRSIZE,
mImpl->mBuffer + slotCount * ATTRSIZE,
childCount * sizeof(nsIContent*));
SetAttrSlotCount(attrCount);
}
// Then resize or free buffer
uint32_t newSize = attrCount * ATTRSIZE + childCount;
if (!newSize && !mImpl->mMappedAttrs) {
moz_free(mImpl);
mImpl = nullptr;
}
else if (newSize < mImpl->mBufferSize) {
mImpl = static_cast<Impl*>(moz_realloc(mImpl, (newSize + NS_IMPL_EXTRA_SIZE) * sizeof(nsIContent*)));
NS_ASSERTION(mImpl, "failed to reallocate to smaller buffer");
mImpl->mBufferSize = newSize;
}
}
imgFrame::~imgFrame()
{
moz_free(mPalettedImageData);
mPalettedImageData = nullptr;
if (mInformedDiscardTracker) {
DiscardTracker::InformDeallocation(4 * mSize.height * mSize.width);
}
}
XULContentSinkImpl::~XULContentSinkImpl()
{
NS_IF_RELEASE(mParser); // XXX should've been released by now, unless error.
// The context stack _should_ be empty, unless something has gone wrong.
NS_ASSERTION(mContextStack.Depth() == 0, "Context stack not empty?");
mContextStack.Clear();
moz_free(mText);
}
nsAttrAndChildArray::~nsAttrAndChildArray()
{
if (!mImpl) {
return;
}
Clear();
moz_free(mImpl);
}
nsCollationMacUC::~nsCollationMacUC()
{
#ifdef DEBUG
nsresult res =
#endif
CleanUpCollator();
NS_ASSERTION(NS_SUCCEEDED(res), "CleanUpCollator failed");
if (mUseICU) {
if (mLocaleICU) {
moz_free(mLocaleICU);
mLocaleICU = nullptr;
}
} else {
if (mBuffer) {
moz_free(mBuffer);
mBuffer = nullptr;
}
}
}
/* ACString Finish(); */
NS_IMETHODIMP
nsScriptableUnicodeConverter::Finish(nsACString& _retval)
{
int32_t len;
char* str;
nsresult rv = FinishWithLength(&str, &len);
if (NS_SUCCEEDED(rv)) {
// No Adopt on nsACString :(
_retval.Assign(str, len);
moz_free(str);
}
return rv;
}
/* ACString ConvertFromUnicode (in AString src); */
NS_IMETHODIMP
nsScriptableUnicodeConverter::ConvertFromUnicode(const nsAString& aSrc,
nsACString& _retval)
{
int32_t len;
char* str;
nsresult rv = ConvertFromUnicodeWithLength(aSrc, &len, &str);
if (NS_SUCCEEDED(rv)) {
// No Adopt on nsACString :(
_retval.Assign(str, len);
moz_free(str);
}
return rv;
}
NS_IMETHODIMP
nsBinaryInputStream::ReadBytes(uint32_t aLength, char* *_rval)
{
nsresult rv;
uint32_t bytesRead;
char* s;
s = reinterpret_cast<char*>(moz_malloc(aLength));
if (!s)
return NS_ERROR_OUT_OF_MEMORY;
rv = Read(s, aLength, &bytesRead);
if (NS_FAILED(rv)) {
moz_free(s);
return rv;
}
if (bytesRead != aLength) {
moz_free(s);
return NS_ERROR_FAILURE;
}
*_rval = s;
return NS_OK;
}
/* ACString Finish(); */
NS_IMETHODIMP
nsScriptableUnicodeConverter::Finish(nsACString& _retval)
{
int32_t len;
char* str;
nsresult rv = FinishWithLength(&str, &len);
if (NS_SUCCEEDED(rv)) {
// No Adopt on nsACString :(
if (!_retval.Assign(str, len, mozilla::fallible_t())) {
rv = NS_ERROR_OUT_OF_MEMORY;
}
moz_free(str);
}
return rv;
}
bool
nsGIFDecoder2::SetHold(const uint8_t* buf1, uint32_t count1, const uint8_t* buf2 /* = nullptr */, uint32_t count2 /* = 0 */)
{
// We have to handle the case that buf currently points to hold
uint8_t* newHold = (uint8_t *) moz_malloc(std::max(uint32_t(MIN_HOLD_SIZE), count1 + count2));
if (!newHold) {
mGIFStruct.state = gif_error;
return false;
}
memcpy(newHold, buf1, count1);
if (buf2) {
memcpy(newHold + count1, buf2, count2);
}
moz_free(mGIFStruct.hold);
mGIFStruct.hold = newHold;
mGIFStruct.bytes_in_hold = count1 + count2;
return true;
}
nsresult
nsScriptableUnicodeConverter::FinishWithLength(char **_retval, int32_t* aLength)
{
if (!mEncoder)
return NS_ERROR_FAILURE;
int32_t finLength = 32;
*_retval = (char *)moz_malloc(finLength);
if (!*_retval)
return NS_ERROR_OUT_OF_MEMORY;
nsresult rv = mEncoder->Finish(*_retval, &finLength);
if (NS_SUCCEEDED(rv))
*aLength = finLength;
else
moz_free(*_retval);
return rv;
}
bool
AnalyserNode::FFTAnalysis()
{
float* inputBuffer;
bool allocated = false;
if (mWriteIndex == 0) {
inputBuffer = mBuffer.Elements();
} else {
inputBuffer = static_cast<float*>(moz_malloc(FftSize() * sizeof(float)));
if (!inputBuffer) {
return false;
}
memcpy(inputBuffer, mBuffer.Elements() + mWriteIndex, sizeof(float) * (FftSize() - mWriteIndex));
memcpy(inputBuffer + FftSize() - mWriteIndex, mBuffer.Elements(), sizeof(float) * mWriteIndex);
allocated = true;
}
ApplyBlackmanWindow(inputBuffer, FftSize());
mAnalysisBlock.PerformFFT(inputBuffer);
// Normalize so than an input sine wave at 0dBfs registers as 0dBfs (undo FFT scaling factor).
const double magnitudeScale = 1.0 / FftSize();
for (uint32_t i = 0; i < mOutputBuffer.Length(); ++i) {
double scalarMagnitude = NS_hypot(mAnalysisBlock.RealData(i),
mAnalysisBlock.ImagData(i)) *
magnitudeScale;
mOutputBuffer[i] = mSmoothingTimeConstant * mOutputBuffer[i] +
(1.0 - mSmoothingTimeConstant) * scalarMagnitude;
}
if (allocated) {
moz_free(inputBuffer);
}
return true;
}
NS_IMETHODIMP
nsBinaryOutputStream::WriteWStringZ(const PRUnichar* aString)
{
PRUint32 length, byteCount;
nsresult rv;
length = NS_strlen(aString);
rv = Write32(length);
if (NS_FAILED(rv)) return rv;
if (length == 0)
return NS_OK;
byteCount = length * sizeof(PRUnichar);
#ifdef IS_BIG_ENDIAN
rv = WriteBytes(reinterpret_cast<const char*>(aString), byteCount);
#else
// XXX use WriteSegments here to avoid copy!
PRUnichar *copy, temp[64];
if (length <= 64) {
copy = temp;
} else {
copy = reinterpret_cast<PRUnichar*>(moz_malloc(byteCount));
if (!copy)
return NS_ERROR_OUT_OF_MEMORY;
}
NS_ASSERTION((PRUptrdiff(aString) & 0x1) == 0, "aString not properly aligned");
for (PRUint32 i = 0; i < length; i++)
copy[i] = NS_SWAP16(aString[i]);
rv = WriteBytes(reinterpret_cast<const char*>(copy), byteCount);
if (copy != temp)
moz_free(copy);
#endif
return rv;
}
NS_Free(void* aPtr)
{
moz_free(aPtr);
}
// use for zlib data types
void
SpdyStream::zlib_destructor(void *opaque, void *addr)
{
moz_free(addr);
}
void
MediaEngineWebRTCAudioSource::Process(int channel,
webrtc::ProcessingTypes type, sample* audio10ms,
int length, int samplingFreq, bool isStereo)
{
// On initial capture, throw away all far-end data except the most recent sample
// since it's already irrelevant and we want to keep avoid confusing the AEC far-end
// input code with "old" audio.
if (!mStarted) {
mStarted = true;
while (gFarendObserver->Size() > 1) {
moz_free(gFarendObserver->Pop()); // only call if size() > 0
}
}
while (gFarendObserver->Size() > 0) {
FarEndAudioChunk *buffer = gFarendObserver->Pop(); // only call if size() > 0
if (buffer) {
int length = buffer->mSamples;
int res = mVoERender->ExternalPlayoutData(buffer->mData,
gFarendObserver->PlayoutFrequency(),
gFarendObserver->PlayoutChannels(),
mPlayoutDelay,
length);
moz_free(buffer);
if (res == -1) {
return;
}
}
}
MonitorAutoLock lock(mMonitor);
if (mState != kStarted)
return;
uint32_t len = mSources.Length();
for (uint32_t i = 0; i < len; i++) {
nsRefPtr<SharedBuffer> buffer = SharedBuffer::Create(length * sizeof(sample));
sample* dest = static_cast<sample*>(buffer->Data());
memcpy(dest, audio10ms, length * sizeof(sample));
nsAutoPtr<AudioSegment> segment(new AudioSegment());
nsAutoTArray<const sample*,1> channels;
channels.AppendElement(dest);
segment->AppendFrames(buffer.forget(), channels, length);
TimeStamp insertTime;
segment->GetStartTime(insertTime);
if (mSources[i]) {
// Make sure we include the stream and the track.
// The 0:1 is a flag to note when we've done the final insert for a given input block.
LogTime(AsyncLatencyLogger::AudioTrackInsertion, LATENCY_STREAM_ID(mSources[i], mTrackID),
(i+1 < len) ? 0 : 1, insertTime);
// This is safe from any thread, and is safe if the track is Finished
// or Destroyed.
// Note: due to evil magic, the nsAutoPtr<AudioSegment>'s ownership transfers to
// the Runnable (AutoPtr<> = AutoPtr<>)
RUN_ON_THREAD(mThread, WrapRunnable(mSources[i], &SourceMediaStream::AppendToTrack,
mTrackID, segment, (AudioSegment *) nullptr),
NS_DISPATCH_NORMAL);
}
}
return;
}
NS_Free(void* ptr)
{
moz_free(ptr);
}
void Free(uint32_t /* unused */, void* aPtr)
{
moz_free(aPtr);
}
NS_IMETHODIMP nsCollationMacUC::AllocateRawSortKey(int32_t strength, const nsAString& stringIn,
uint8_t** key, uint32_t* outLen)
{
NS_ENSURE_TRUE(mInit, NS_ERROR_NOT_INITIALIZED);
NS_ENSURE_ARG_POINTER(key);
NS_ENSURE_ARG_POINTER(outLen);
nsresult res = EnsureCollator(strength);
NS_ENSURE_SUCCESS(res, res);
uint32_t stringInLen = stringIn.Length();
if (mUseICU) {
const UChar* str = (const UChar*)PromiseFlatString(stringIn).get();
int32_t keyLength = ucol_getSortKey(mCollatorICU, str, stringInLen, nullptr, 0);
NS_ENSURE_TRUE((stringInLen == 0 || keyLength > 0), NS_ERROR_FAILURE);
// Since key is freed elsewhere with PR_Free, allocate with PR_Malloc.
uint8_t* newKey = (uint8_t*)PR_Malloc(keyLength + 1);
if (!newKey) {
return NS_ERROR_OUT_OF_MEMORY;
}
keyLength = ucol_getSortKey(mCollatorICU, str, stringInLen, newKey, keyLength + 1);
NS_ENSURE_TRUE((stringInLen == 0 || keyLength > 0), NS_ERROR_FAILURE);
*key = newKey;
*outLen = keyLength;
return NS_OK;
}
uint32_t maxKeyLen = (1 + stringInLen) * kCollationValueSizeFactor * sizeof(UCCollationValue);
if (maxKeyLen > mBufferLen) {
uint32_t newBufferLen = mBufferLen;
do {
newBufferLen *= 2;
} while (newBufferLen < maxKeyLen);
void* newBuffer = moz_malloc(newBufferLen);
if (!newBuffer) {
return NS_ERROR_OUT_OF_MEMORY;
}
if (mBuffer) {
moz_free(mBuffer);
mBuffer = nullptr;
}
mBuffer = newBuffer;
mBufferLen = newBufferLen;
}
ItemCount actual;
OSStatus err = ::UCGetCollationKey(mCollator, (const UniChar*) PromiseFlatString(stringIn).get(),
(UniCharCount) stringInLen,
(ItemCount) (mBufferLen / sizeof(UCCollationValue)),
&actual, (UCCollationValue *)mBuffer);
NS_ENSURE_TRUE((err == noErr), NS_ERROR_FAILURE);
uint32_t keyLength = actual * sizeof(UCCollationValue);
// Since key is freed elsewhere with PR_Free, allocate with PR_Malloc.
void* newKey = PR_Malloc(keyLength);
if (!newKey) {
return NS_ERROR_OUT_OF_MEMORY;
}
memcpy(newKey, mBuffer, keyLength);
*key = (uint8_t *)newKey;
*outLen = keyLength;
return NS_OK;
}
