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; }