extern "C" NS_EXPORT
void Crash(int16_t how)
{
switch (how) {
case CRASH_INVALID_POINTER_DEREF: {
volatile int* foo = (int*)0x42;
*foo = 0;
// not reached
break;
}
case CRASH_PURE_VIRTUAL_CALL: {
PureVirtualCall();
// not reached
break;
}
case CRASH_RUNTIMEABORT: {
NS_RUNTIMEABORT("Intentional crash");
break;
}
case CRASH_OOM: {
mozilla::unused << moz_xmalloc((size_t) -1);
mozilla::unused << moz_xmalloc((size_t) -1);
mozilla::unused << moz_xmalloc((size_t) -1);
break;
}
case CRASH_MOZ_CRASH: {
MOZ_CRASH();
break;
}
default:
break;
}
}
AddrInfo::AddrInfo(const char *host, const PRAddrInfo *prAddrInfo,
const char *cname)
{
size_t hostlen = strlen(host);
mHostName = static_cast<char*>(moz_xmalloc(hostlen + 1));
memcpy(mHostName, host, hostlen + 1);
if (cname) {
size_t cnameLen = strlen(cname);
mCanonicalName = static_cast<char*>(moz_xmalloc(cnameLen + 1));
memcpy(mCanonicalName, cname, cnameLen + 1);
}
else {
mCanonicalName = nullptr;
}
PRNetAddr tmpAddr;
void *iter = nullptr;
do {
iter = PR_EnumerateAddrInfo(iter, prAddrInfo, 0, &tmpAddr);
if (iter) {
NetAddrElement *addrElement = new NetAddrElement(&tmpAddr);
mAddresses.insertBack(addrElement);
}
} while (iter);
}
// Convert the list of words in iwords to the same capitalization aWord and
// return them in owords.
NS_IMETHODIMP mozEnglishWordUtils::FromRootForm(const char16_t *aWord, const char16_t **iwords, uint32_t icount, char16_t ***owords, uint32_t *ocount)
{
nsAutoString word(aWord);
nsresult rv = NS_OK;
int32_t length;
char16_t **tmpPtr = (char16_t **)moz_xmalloc(sizeof(char16_t *)*icount);
if (!tmpPtr)
return NS_ERROR_OUT_OF_MEMORY;
mozEnglishWordUtils::myspCapitalization ct = captype(word);
for(uint32_t i = 0; i < icount; ++i) {
length = NS_strlen(iwords[i]);
tmpPtr[i] = (char16_t *) moz_xmalloc(sizeof(char16_t) * (length + 1));
if (MOZ_UNLIKELY(!tmpPtr[i])) {
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(i, tmpPtr);
return NS_ERROR_OUT_OF_MEMORY;
}
memcpy(tmpPtr[i], iwords[i], (length + 1) * sizeof(char16_t));
nsAutoString capTest(tmpPtr[i]);
mozEnglishWordUtils::myspCapitalization newCt=captype(capTest);
if(newCt == NoCap){
switch(ct)
{
case HuhCap:
case NoCap:
break;
case AllCap:
ToUpperCase(tmpPtr[i],tmpPtr[i],length);
rv = NS_OK;
break;
case InitCap:
ToUpperCase(tmpPtr[i],tmpPtr[i],1);
rv = NS_OK;
break;
default:
rv = NS_ERROR_FAILURE; // should never get here;
break;
}
}
}
if (NS_SUCCEEDED(rv)){
*owords = tmpPtr;
*ocount = icount;
}
return rv;
}
nsTextFragment&
nsTextFragment::operator=(const nsTextFragment& aOther)
{
ReleaseText();
if (aOther.mState.mLength) {
if (!aOther.mState.mInHeap) {
m1b = aOther.m1b; // This will work even if aOther is using m2b
}
else {
size_t m2bSize = aOther.mState.mLength *
(aOther.mState.mIs2b ? sizeof(char16_t) : sizeof(char));
m2b = static_cast<char16_t*>(malloc(m2bSize));
if (m2b) {
memcpy(m2b, aOther.m2b, m2bSize);
} else {
// allocate a buffer for a single REPLACEMENT CHARACTER
m2b = static_cast<char16_t*>(moz_xmalloc(sizeof(char16_t)));
m2b[0] = 0xFFFD; // REPLACEMENT CHARACTER
mState.mIs2b = true;
mState.mInHeap = true;
mState.mLength = 1;
}
}
if (m1b) {
mAllBits = aOther.mAllBits;
}
}
return *this;
}
NS_IMETHODIMP
nsRandomGenerator::GenerateRandomBytes(uint32_t aLength,
uint8_t** aBuffer)
{
NS_ENSURE_ARG_POINTER(aBuffer);
*aBuffer = nullptr;
nsNSSShutDownPreventionLock locker;
if (isAlreadyShutDown()) {
return NS_ERROR_NOT_AVAILABLE;
}
mozilla::UniquePK11SlotInfo slot(PK11_GetInternalSlot());
if (!slot) {
return NS_ERROR_FAILURE;
}
auto buf = static_cast<uint8_t*>(moz_xmalloc(aLength));
if (!buf) {
return NS_ERROR_OUT_OF_MEMORY;
}
SECStatus srv = PK11_GenerateRandomOnSlot(slot.get(), buf, aLength);
if (srv != SECSuccess) {
free(buf);
return NS_ERROR_FAILURE;
}
*aBuffer = buf;
return NS_OK;
}
//
// CreatePrimitiveForCFHTML
//
// Platform specific CreatePrimitive, windows CF_HTML.
//
void
nsPrimitiveHelpers :: CreatePrimitiveForCFHTML ( const void* aDataBuff,
uint32_t* aDataLen, nsISupports** aPrimitive )
{
if (!aPrimitive)
return;
nsCOMPtr<nsISupportsString> primitive =
do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID);
if (!primitive)
return;
// We need to duplicate the input buffer, since the removal of linebreaks
// might reallocte it.
void* utf8 = moz_xmalloc(*aDataLen);
if (!utf8)
return;
memcpy(utf8, aDataBuff, *aDataLen);
int32_t signedLen = static_cast<int32_t>(*aDataLen);
nsLinebreakHelpers::ConvertPlatformToDOMLinebreaks(kTextMime, &utf8, &signedLen);
*aDataLen = signedLen;
nsAutoString str(NS_ConvertUTF8toUTF16(reinterpret_cast<const char*>(utf8), *aDataLen));
free(utf8);
*aDataLen = str.Length() * sizeof(char16_t);
primitive->SetData(str);
NS_ADDREF(*aPrimitive = primitive);
}
NS_IMETHODIMP
EventListenerService::GetListenerInfoFor(nsIDOMEventTarget* aEventTarget,
uint32_t* aCount,
nsIEventListenerInfo*** aOutArray)
{
NS_ENSURE_ARG_POINTER(aEventTarget);
*aCount = 0;
*aOutArray = nullptr;
nsCOMArray<nsIEventListenerInfo> listenerInfos;
nsCOMPtr<EventTarget> eventTarget = do_QueryInterface(aEventTarget);
NS_ENSURE_TRUE(eventTarget, NS_ERROR_NO_INTERFACE);
EventListenerManager* elm = eventTarget->GetExistingListenerManager();
if (elm) {
elm->GetListenerInfo(&listenerInfos);
}
int32_t count = listenerInfos.Count();
if (count == 0) {
return NS_OK;
}
*aOutArray =
static_cast<nsIEventListenerInfo**>(
moz_xmalloc(sizeof(nsIEventListenerInfo*) * count));
NS_ENSURE_TRUE(*aOutArray, NS_ERROR_OUT_OF_MEMORY);
for (int32_t i = 0; i < count; ++i) {
NS_ADDREF((*aOutArray)[i] = listenerInfos[i]);
}
*aCount = count;
return NS_OK;
}
// Caller is responsible for freeing returned buffer.
static char* CFStringRefToUTF8Buffer(CFStringRef cfString)
{
const char* buffer = ::CFStringGetCStringPtr(cfString, kCFStringEncodingUTF8);
if (buffer) {
return PL_strdup(buffer);
}
int bufferLength =
::CFStringGetMaximumSizeForEncoding(::CFStringGetLength(cfString),
kCFStringEncodingUTF8) + 1;
char* newBuffer = static_cast<char*>(moz_xmalloc(bufferLength));
if (!newBuffer) {
return nullptr;
}
if (!::CFStringGetCString(cfString, newBuffer, bufferLength,
kCFStringEncodingUTF8)) {
free(newBuffer);
return nullptr;
}
newBuffer = static_cast<char*>(moz_xrealloc(newBuffer,
strlen(newBuffer) + 1));
return newBuffer;
}
nsresult nsMsgSearchValidityTable::GetAvailableOperators(
nsMsgSearchAttribValue aAttribute, uint32_t *aLength,
nsMsgSearchOpValue **aResult) {
NS_ENSURE_ARG_POINTER(aLength);
NS_ENSURE_ARG_POINTER(aResult);
nsMsgSearchAttribValue attr;
if (aAttribute == nsMsgSearchAttrib::Default)
attr = m_defaultAttrib;
else
attr = std::min(aAttribute,
(nsMsgSearchAttribValue)nsMsgSearchAttrib::OtherHeader);
uint32_t totalOperators = 0;
int32_t i;
for (i = 0; i < nsMsgSearchOp::kNumMsgSearchOperators; i++) {
if (m_table[attr][i].bitAvailable) totalOperators++;
}
nsMsgSearchOpValue *array = (nsMsgSearchOpValue *)moz_xmalloc(
sizeof(nsMsgSearchOpValue) * totalOperators);
NS_ENSURE_TRUE(array, NS_ERROR_OUT_OF_MEMORY);
uint32_t numStored = 0;
for (i = 0; i < nsMsgSearchOp::kNumMsgSearchOperators; i++) {
if (m_table[attr][i].bitAvailable) array[numStored++] = i;
}
NS_ASSERTION(totalOperators == numStored, "Search Operators not lining up");
*aLength = totalOperators;
*aResult = array;
return NS_OK;
}
static T*
ConvertUnknownBreaks(const T* aInSrc, int32_t& aIoLen, const char* aDestBreak)
{
const T* src = aInSrc;
const T* srcEnd = aInSrc + aIoLen; // includes null, if any
int32_t destBreakLen = strlen(aDestBreak);
int32_t finalLen = 0;
while (src < srcEnd) {
if (*src == nsCRT::CR) {
if (src < srcEnd && src[1] == nsCRT::LF) {
// CRLF
finalLen += destBreakLen;
src++;
} else {
// Lone CR
finalLen += destBreakLen;
}
} else if (*src == nsCRT::LF) {
// Lone LF
finalLen += destBreakLen;
} else {
finalLen++;
}
src++;
}
T* resultString = (T*)moz_xmalloc(sizeof(T) * finalLen);
if (!resultString) {
return nullptr;
}
src = aInSrc;
srcEnd = aInSrc + aIoLen; // includes null, if any
T* dst = resultString;
while (src < srcEnd) {
if (*src == nsCRT::CR) {
if (src < srcEnd && src[1] == nsCRT::LF) {
// CRLF
AppendLinebreak(dst, aDestBreak);
src++;
} else {
// Lone CR
AppendLinebreak(dst, aDestBreak);
}
} else if (*src == nsCRT::LF) {
// Lone LF
AppendLinebreak(dst, aDestBreak);
} else {
*dst++ = *src;
}
src++;
}
aIoLen = finalLen;
return resultString;
}
NS_IMETHODIMP
calIcalComponent::GetReferencedTimezones(uint32_t * aCount, calITimezone *** aTimezones)
{
NS_ENSURE_ARG_POINTER(aCount);
NS_ENSURE_ARG_POINTER(aTimezones);
uint32_t const count = mReferencedTimezones.Count();
if (count == 0) {
*aCount = 0;
*aTimezones = nullptr;
return NS_OK;
}
calITimezone ** const timezones = static_cast<calITimezone **>(
moz_xmalloc(sizeof(calITimezone *) * count));
CAL_ENSURE_MEMORY(timezones);
// tzptr will get used as an iterator by the enumerator function
calITimezone ** tzptr = timezones;
for (auto iter = mReferencedTimezones.ConstIter(); !iter.Done(); iter.Next() ) {
NS_ADDREF(*tzptr = iter.Data());
++tzptr;
}
*aTimezones = timezones;
*aCount = count;
return NS_OK;
}
NS_IMETHODIMP
EventListenerService::GetEventTargetChainFor(nsIDOMEventTarget* aEventTarget,
bool aComposed,
uint32_t* aCount,
nsIDOMEventTarget*** aOutArray)
{
*aCount = 0;
*aOutArray = nullptr;
NS_ENSURE_ARG(aEventTarget);
WidgetEvent event(true, eVoidEvent);
event.SetComposed(aComposed);
nsTArray<EventTarget*> targets;
nsresult rv = EventDispatcher::Dispatch(aEventTarget, nullptr, &event,
nullptr, nullptr, nullptr, &targets);
NS_ENSURE_SUCCESS(rv, rv);
int32_t count = targets.Length();
if (count == 0) {
return NS_OK;
}
*aOutArray =
static_cast<nsIDOMEventTarget**>(
moz_xmalloc(sizeof(nsIDOMEventTarget*) * count));
NS_ENSURE_TRUE(*aOutArray, NS_ERROR_OUT_OF_MEMORY);
for (int32_t i = 0; i < count; ++i) {
NS_ADDREF((*aOutArray)[i] = targets[i]);
}
*aCount = count;
return NS_OK;
}
char*
ToNewUTF8String(const nsAString& aSource, uint32_t* aUTF8Count)
{
nsAString::const_iterator start, end;
CalculateUTF8Size calculator;
copy_string(aSource.BeginReading(start), aSource.EndReading(end),
calculator);
if (aUTF8Count) {
*aUTF8Count = calculator.Size();
}
char* result = static_cast<char*>
(moz_xmalloc(calculator.Size() + 1));
if (!result) {
return nullptr;
}
ConvertUTF16toUTF8 converter(result);
copy_string(aSource.BeginReading(start), aSource.EndReading(end),
converter).write_terminator();
NS_ASSERTION(calculator.Size() == converter.Size(), "length mismatch");
return result;
}
inline
ToCharT*
AllocateStringCopy(const FromStringT& aSource, ToCharT*)
{
return static_cast<ToCharT*>(moz_xmalloc(
(aSource.Length() + 1) * sizeof(ToCharT)));
}
NS_IMETHODIMP
nsProperties::GetKeys(uint32_t* aCount, char*** aKeys)
{
if (NS_WARN_IF(!aCount) || NS_WARN_IF(!aKeys)) {
return NS_ERROR_INVALID_ARG;
}
uint32_t count = Count();
char** keys = (char**)moz_xmalloc(count * sizeof(char*));
uint32_t j = 0;
for (auto iter = this->Iter(); !iter.Done(); iter.Next()) {
const char* key = iter.Key();
keys[j] = strdup(key);
if (!keys[j]) {
// Free 'em all
for (uint32_t i = 0; i < j; i++) {
free(keys[i]);
}
free(keys);
return NS_ERROR_OUT_OF_MEMORY;
}
j++;
}
*aCount = count;
*aKeys = keys;
return NS_OK;
}
NS_IMETHODIMP
nsNSSCertificateFakeTransport::GetClassID(nsCID** aClassID)
{
*aClassID = (nsCID*) moz_xmalloc(sizeof(nsCID));
if (!*aClassID)
return NS_ERROR_OUT_OF_MEMORY;
return GetClassIDNoAlloc(*aClassID);
}
NS_IMETHODIMP
TransportSecurityInfo::GetClassID(nsCID * *aClassID)
{
*aClassID = (nsCID*) moz_xmalloc(sizeof(nsCID));
if (!*aClassID)
return NS_ERROR_OUT_OF_MEMORY;
return GetClassIDNoAlloc(*aClassID);
}
nsresult
CacheFileMetadata::WriteMetadata(uint32_t aOffset,
CacheFileMetadataListener *aListener)
{
LOG(("CacheFileMetadata::WriteMetadata() [this=%p, offset=%d, listener=%p]",
this, aOffset, aListener));
MOZ_ASSERT(!mListener);
MOZ_ASSERT(!mWriteBuf);
MOZ_ASSERT(!mKeyIsHash);
nsresult rv;
mIsDirty = false;
mWriteBuf = static_cast<char *>(moz_xmalloc(sizeof(uint32_t) +
mHashCount * sizeof(CacheHashUtils::Hash16_t) +
sizeof(CacheFileMetadataHeader) + mKey.Length() + 1 +
mElementsSize + sizeof(uint32_t)));
char *p = mWriteBuf + sizeof(uint32_t);
memcpy(p, mHashArray, mHashCount * sizeof(CacheHashUtils::Hash16_t));
p += mHashCount * sizeof(CacheHashUtils::Hash16_t);
memcpy(p, &mMetaHdr, sizeof(CacheFileMetadataHeader));
p += sizeof(CacheFileMetadataHeader);
memcpy(p, mKey.get(), mKey.Length());
p += mKey.Length();
*p = 0;
p++;
memcpy(p, mBuf, mElementsSize);
p += mElementsSize;
CacheHashUtils::Hash32_t hash;
hash = CacheHashUtils::Hash(mWriteBuf + sizeof(uint32_t),
p - mWriteBuf - sizeof(uint32_t));
*reinterpret_cast<uint32_t *>(mWriteBuf) = PR_htonl(hash);
*reinterpret_cast<uint32_t *>(p) = PR_htonl(aOffset);
p += sizeof(uint32_t);
mListener = aListener;
rv = CacheFileIOManager::Write(mHandle, aOffset, mWriteBuf, p - mWriteBuf,
true, this);
if (NS_FAILED(rv)) {
LOG(("CacheFileMetadata::WriteMetadata() - CacheFileIOManager::Write() "
"failed synchronously. [this=%p, rv=0x%08x]", this, rv));
mListener = nullptr;
free(mWriteBuf);
mWriteBuf = nullptr;
NS_ENSURE_SUCCESS(rv, rv);
}
DoMemoryReport(MemoryUsage());
return NS_OK;
}
void*
nsMemory::Clone(const void* aPtr, size_t aSize)
{
void* newPtr = moz_xmalloc(aSize);
if (newPtr) {
memcpy(newPtr, aPtr, aSize);
}
return newPtr;
}
void*
moz_xmalloc(size_t size)
{
void* ptr = malloc(size);
if (UNLIKELY(!ptr)) {
mozalloc_handle_oom();
return moz_xmalloc(size);
}
return ptr;
}
static char* p2cstrdup(StringPtr pstr)
{
int len = pstr[0];
char* cstr = static_cast<char*>(moz_xmalloc(len + 1));
if (cstr) {
memmove(cstr, pstr + 1, len);
cstr[len] = '\0';
}
return cstr;
}
NS_IMETHODIMP
nsSupportsCharImpl::ToString(char** aResult)
{
NS_ASSERTION(aResult, "Bad pointer");
char* result = (char*)moz_xmalloc(2 * sizeof(char));
if (result) {
result[0] = mData;
result[1] = '\0';
}
*aResult = result;
return result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
bool
CryptoBuffer::ToNewUnsignedBuffer(uint8_t** aBuf, uint32_t* aBufLen) const
{
MOZ_ASSERT(aBuf);
MOZ_ASSERT(aBufLen);
uint32_t dataLen = Length();
uint8_t* tmp = reinterpret_cast<uint8_t*>(moz_xmalloc(dataLen));
memcpy(tmp, Elements(), dataLen);
*aBuf = tmp;
*aBufLen = dataLen;
return true;
}
char*
nsSegmentedBuffer::AppendNewSegment()
{
if (GetSize() >= mMaxSize) {
return nullptr;
}
if (!mSegmentArray) {
uint32_t bytes = mSegmentArrayCount * sizeof(char*);
mSegmentArray = (char**)moz_xmalloc(bytes);
if (!mSegmentArray) {
return nullptr;
}
memset(mSegmentArray, 0, bytes);
}
if (IsFull()) {
uint32_t newArraySize = mSegmentArrayCount * 2;
uint32_t bytes = newArraySize * sizeof(char*);
char** newSegArray = (char**)moz_xrealloc(mSegmentArray, bytes);
if (!newSegArray) {
return nullptr;
}
mSegmentArray = newSegArray;
// copy wrapped content to new extension
if (mFirstSegmentIndex > mLastSegmentIndex) {
// deal with wrap around case
memcpy(&mSegmentArray[mSegmentArrayCount],
mSegmentArray,
mLastSegmentIndex * sizeof(char*));
memset(mSegmentArray, 0, mLastSegmentIndex * sizeof(char*));
mLastSegmentIndex += mSegmentArrayCount;
memset(&mSegmentArray[mLastSegmentIndex], 0,
(newArraySize - mLastSegmentIndex) * sizeof(char*));
} else {
memset(&mSegmentArray[mLastSegmentIndex], 0,
(newArraySize - mLastSegmentIndex) * sizeof(char*));
}
mSegmentArrayCount = newArraySize;
}
char* seg = (char*)malloc(mSegmentSize);
if (!seg) {
return nullptr;
}
mSegmentArray[mLastSegmentIndex] = seg;
mLastSegmentIndex = ModSegArraySize(mLastSegmentIndex + 1);
return seg;
}
static already_AddRefed<AudioBlockBuffer> Create(uint32_t aChannelCount)
{
CheckedInt<size_t> size = WEBAUDIO_BLOCK_SIZE;
size *= aChannelCount;
size *= sizeof(float);
size += sizeof(AudioBlockBuffer);
if (!size.isValid()) {
MOZ_CRASH();
}
void* m = moz_xmalloc(size.value());
nsRefPtr<AudioBlockBuffer> p = new (m) AudioBlockBuffer();
NS_ASSERTION((reinterpret_cast<char*>(p.get() + 1) - reinterpret_cast<char*>(p.get())) % 4 == 0,
"AudioBlockBuffers should be at least 4-byte aligned");
return p.forget();
}
void
WebGLShader::ShaderSource(const nsAString& source)
{
const char funcName[] = "shaderSource";
nsString sourceWithoutComments;
if (!TruncateComments(source, &sourceWithoutComments)) {
mContext->ErrorOutOfMemory("%s: Failed to alloc for empting comment contents.",
funcName);
return;
}
if (!ValidateGLSLPreprocString(mContext, funcName, sourceWithoutComments))
return;
// We checked that the source stripped of comments is in the
// 7-bit ASCII range, so we can skip the NS_IsAscii() check.
const NS_LossyConvertUTF16toASCII cleanSource(sourceWithoutComments);
if (PR_GetEnv("MOZ_WEBGL_DUMP_SHADERS")) {
printf_stderr("////////////////////////////////////////\n");
printf_stderr("// MOZ_WEBGL_DUMP_SHADERS:\n");
// Wow - Roll Your Own Foreach-Lines because printf_stderr has a hard-coded
// internal size, so long strings are truncated.
const size_t maxChunkSize = 1024-1; // -1 for null-term.
const UniqueBuffer buf(moz_xmalloc(maxChunkSize+1)); // +1 for null-term
const auto bufBegin = (char*)buf.get();
size_t chunkStart = 0;
while (chunkStart != cleanSource.Length()) {
const auto chunkEnd = std::min(chunkStart + maxChunkSize,
size_t(cleanSource.Length()));
const auto chunkSize = chunkEnd - chunkStart;
memcpy(bufBegin, cleanSource.BeginReading() + chunkStart, chunkSize);
bufBegin[chunkSize + 1] = '\0';
printf_stderr("%s", bufBegin);
chunkStart += chunkSize;
}
printf_stderr("////////////////////////////////////////\n");
}
mSource = source;
mCleanSource = cleanSource;
}
AddrInfo::AddrInfo(const char *host, const PRAddrInfo *prAddrInfo,
bool disableIPv4)
{
size_t hostlen = strlen(host);
mHostName = static_cast<char*>(moz_xmalloc(hostlen + 1));
memcpy(mHostName, host, hostlen + 1);
PRNetAddr tmpAddr;
void *iter = nullptr;
do {
iter = PR_EnumerateAddrInfo(iter, prAddrInfo, 0, &tmpAddr);
if (iter && (!disableIPv4 || tmpAddr.raw.family != PR_AF_INET)) {
NetAddrElement *addrElement = new NetAddrElement(&tmpAddr);
mAddresses.insertBack(addrElement);
}
} while (iter);
}
NS_IMETHODIMP
nsThebesFontEnumerator::EnumerateFonts(const char *aLangGroup,
const char *aGeneric,
uint32_t *aCount,
char16_t ***aResult)
{
NS_ENSURE_ARG_POINTER(aCount);
NS_ENSURE_ARG_POINTER(aResult);
nsTArray<nsString> fontList;
nsAutoCString generic;
if (aGeneric)
generic.Assign(aGeneric);
else
generic.SetIsVoid(true);
nsCOMPtr<nsIAtom> langGroupAtom;
if (aLangGroup) {
nsAutoCString lowered;
lowered.Assign(aLangGroup);
ToLowerCase(lowered);
langGroupAtom = NS_Atomize(lowered);
}
nsresult rv = gfxPlatform::GetPlatform()->GetFontList(langGroupAtom, generic, fontList);
if (NS_FAILED(rv)) {
*aCount = 0;
*aResult = nullptr;
/* XXX in this case, do we want to return the CSS generics? */
return NS_OK;
}
char16_t **fs = static_cast<char16_t **>
(moz_xmalloc(fontList.Length() * sizeof(char16_t*)));
for (uint32_t i = 0; i < fontList.Length(); i++) {
fs[i] = ToNewUnicode(fontList[i]);
}
*aResult = fs;
*aCount = fontList.Length();
return NS_OK;
}
char16_t*
UTF8ToNewUnicode(const nsACString& aSource, uint32_t* aUTF16Count)
{
const uint32_t length = CalcUTF8ToUnicodeLength(aSource);
const size_t buffer_size = (length + 1) * sizeof(char16_t);
char16_t* buffer = static_cast<char16_t*>(moz_xmalloc(buffer_size));
if (!buffer) {
return nullptr;
}
uint32_t copied;
UTF8ToUnicodeBuffer(aSource, buffer, &copied);
NS_ASSERTION(length == copied, "length mismatch");
if (aUTF16Count) {
*aUTF16Count = copied;
}
return buffer;
}
// nsIStreamListener method
NS_IMETHOD OnDataAvailable(nsIRequest* request, nsISupports *ctxt, nsIInputStream *inStr,
uint64_t sourceOffset, uint32_t count) override
{
nsresult rv;
uint32_t read;
uint64_t len64;
rv = inStr->Available(&len64);
if (NS_FAILED(rv)) return rv;
uint32_t len = (uint32_t)std::min(len64, (uint64_t)(UINT32_MAX - 1));
char *buffer = (char*)moz_xmalloc(len + 1);
if (!buffer) return NS_ERROR_OUT_OF_MEMORY;
rv = inStr->Read(buffer, len, &read);
buffer[len] = '\0';
if (NS_SUCCEEDED(rv)) {
printf("CONTEXT %p: Received %u bytes and the following data: \n %s\n\n",
static_cast<void*>(ctxt), read, buffer);
}
free(buffer);
return NS_OK;
}
