PerformanceInfo
DocGroup::ReportPerformanceInfo()
{
AssertIsOnMainThread();
MOZ_ASSERT(mPerformanceCounter);
#if defined(XP_WIN)
uint32_t pid = GetCurrentProcessId();
#else
uint32_t pid = getpid();
#endif
uint64_t wid = 0;
uint64_t pwid = 0;
uint16_t count = 0;
uint64_t duration = 0;
nsCString host = NS_LITERAL_CSTRING("None");
for (const auto& document : *this) {
// grabbing the host name of the first document
nsCOMPtr<nsIDocument> doc = do_QueryInterface(document);
MOZ_ASSERT(doc);
nsCOMPtr<nsIURI> docURI = doc->GetDocumentURI();
if (!docURI) {
continue;
}
docURI->GetHost(host);
wid = doc->OuterWindowID();
// getting the top window id - if not possible
// pwid gets the same value than wid
pwid = wid;
nsPIDOMWindowInner* win = doc->GetInnerWindow();
if (win) {
nsPIDOMWindowOuter* outer = win->GetOuterWindow();
if (outer) {
nsCOMPtr<nsPIDOMWindowOuter> top = outer->GetTop();
if (top) {
pwid = top->WindowID();
}
}
}
}
duration = mPerformanceCounter->GetExecutionDuration();
FallibleTArray<CategoryDispatch> items;
// now that we have the host and window ids, let's look at the perf counters
for (uint32_t index = 0; index < (uint32_t)TaskCategory::Count; index++) {
TaskCategory category = static_cast<TaskCategory>(index);
count = mPerformanceCounter->GetDispatchCount(DispatchCategory(category));
CategoryDispatch item = CategoryDispatch(index, count);
if (!items.AppendElement(item, fallible)) {
NS_ERROR("Could not complete the operation");
return PerformanceInfo(host, pid, wid, pwid, duration, false, items);
}
}
// setting back all counters to zero
mPerformanceCounter->ResetPerformanceCounters();
return PerformanceInfo(host, pid, wid, pwid, duration, false, items);
}
FileSystemResponseValue
GetFilesTaskParent::GetSuccessRequestResult(ErrorResult& aRv) const
{
AssertIsOnBackgroundThread();
InfallibleTArray<PBlobParent*> blobs;
FallibleTArray<FileSystemFileResponse> inputs;
if (!inputs.SetLength(mTargetBlobImplArray.Length(), mozilla::fallible_t())) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
FileSystemFilesResponse response;
return response;
}
for (unsigned i = 0; i < mTargetBlobImplArray.Length(); i++) {
BlobParent* blobParent =
BlobParent::GetOrCreate(mRequestParent->Manager(),
mTargetBlobImplArray[i]);
inputs[i] = FileSystemFileResponse(blobParent, nullptr);
}
FileSystemFilesResponse response;
response.data().SwapElements(inputs);
return response;
}
nsresult
GDIFontEntry::CopyFontTable(uint32_t aTableTag,
FallibleTArray<uint8_t>& aBuffer)
{
if (!IsTrueType()) {
return NS_ERROR_FAILURE;
}
AutoDC dc;
AutoSelectFont font(dc.GetDC(), &mLogFont);
if (font.IsValid()) {
uint32_t tableSize =
::GetFontData(dc.GetDC(),
NativeEndian::swapToBigEndian(aTableTag),
0, nullptr, 0);
if (tableSize != GDI_ERROR) {
if (aBuffer.SetLength(tableSize)) {
::GetFontData(dc.GetDC(),
NativeEndian::swapToBigEndian(aTableTag), 0,
aBuffer.Elements(), tableSize);
return NS_OK;
}
return NS_ERROR_OUT_OF_MEMORY;
}
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
TCPSocketChild::Send(const JS::Value& aData,
uint32_t aByteOffset,
uint32_t aByteLength,
JSContext* aCx)
{
if (aData.isString()) {
JSString* jsstr = aData.toString();
nsDependentJSString str;
bool ok = str.init(aCx, jsstr);
NS_ENSURE_TRUE(ok, NS_ERROR_FAILURE);
SendData(str);
} else {
NS_ENSURE_TRUE(aData.isObject(), NS_ERROR_FAILURE);
JS::Rooted<JSObject*> obj(aCx, &aData.toObject());
NS_ENSURE_TRUE(JS_IsArrayBufferObject(obj), NS_ERROR_FAILURE);
uint32_t buflen = JS_GetArrayBufferByteLength(obj);
aByteOffset = std::min(buflen, aByteOffset);
uint32_t nbytes = std::min(buflen - aByteOffset, aByteLength);
uint8_t* data = JS_GetArrayBufferData(obj);
if (!data) {
return NS_ERROR_OUT_OF_MEMORY;
}
FallibleTArray<uint8_t> fallibleArr;
if (!fallibleArr.InsertElementsAt(0, data, nbytes)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> arr;
arr.SwapElements(fallibleArr);
SendData(arr);
}
return NS_OK;
}
bool
nsSMILParserUtils::ParseKeySplines(const nsAString& aSpec,
FallibleTArray<nsSMILKeySpline>& aKeySplines)
{
nsCharSeparatedTokenizerTemplate<IsSVGWhitespace> controlPointTokenizer(aSpec, ';');
while (controlPointTokenizer.hasMoreTokens()) {
nsCharSeparatedTokenizerTemplate<IsSVGWhitespace>
tokenizer(controlPointTokenizer.nextToken(), ',',
nsCharSeparatedTokenizer::SEPARATOR_OPTIONAL);
double values[4];
for (int i = 0 ; i < 4; i++) {
if (!tokenizer.hasMoreTokens() ||
!SVGContentUtils::ParseNumber(tokenizer.nextToken(), values[i]) ||
values[i] > 1.0 || values[i] < 0.0) {
return false;
}
}
if (tokenizer.hasMoreTokens() ||
tokenizer.separatorAfterCurrentToken() ||
!aKeySplines.AppendElement(nsSMILKeySpline(values[0],
values[1],
values[2],
values[3]))) {
return false;
}
}
return !aKeySplines.IsEmpty();
}
nsresult
FT2FontEntry::CopyFontTable(uint32_t aTableTag,
FallibleTArray<uint8_t>& aBuffer)
{
AutoFTFace face(this);
if (!face) {
return NS_ERROR_FAILURE;
}
FT_Error status;
FT_ULong len = 0;
status = FT_Load_Sfnt_Table(face, aTableTag, 0, nullptr, &len);
if (status != FT_Err_Ok || len == 0) {
return NS_ERROR_FAILURE;
}
if (!aBuffer.SetLength(len)) {
return NS_ERROR_OUT_OF_MEMORY;
}
uint8_t *buf = aBuffer.Elements();
status = FT_Load_Sfnt_Table(face, aTableTag, 0, buf, &len);
NS_ENSURE_TRUE(status == FT_Err_Ok, NS_ERROR_FAILURE);
return NS_OK;
}
bool
nsSMILParserUtils::ParseSemicolonDelimitedProgressList(const nsAString& aSpec,
bool aNonDecreasing,
FallibleTArray<double>& aArray)
{
nsCharSeparatedTokenizerTemplate<IsSVGWhitespace> tokenizer(aSpec, ';');
double previousValue = -1.0;
while (tokenizer.hasMoreTokens()) {
double value;
if (!SVGContentUtils::ParseNumber(tokenizer.nextToken(), value)) {
return false;
}
if (value > 1.0 || value < 0.0 ||
(aNonDecreasing && value < previousValue)) {
return false;
}
if (!aArray.AppendElement(value)) {
return false;
}
previousValue = value;
}
return !aArray.IsEmpty();
}
mozilla::ipc::IPCResult
MessagePortParent::RecvPostMessages(nsTArray<ClonedMessageData>&& aMessages)
{
// This converts the object in a data struct where we have BlobImpls.
FallibleTArray<RefPtr<SharedMessagePortMessage>> messages;
if (NS_WARN_IF(
!SharedMessagePortMessage::FromMessagesToSharedParent(aMessages,
messages))) {
return IPC_FAIL_NO_REASON(this);
}
if (!mEntangled) {
return IPC_FAIL_NO_REASON(this);
}
if (!mService) {
NS_WARNING("Entangle is called after a shutdown!");
return IPC_FAIL_NO_REASON(this);
}
if (messages.IsEmpty()) {
return IPC_FAIL_NO_REASON(this);
}
if (!mService->PostMessages(this, messages)) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
bool
MessagePortParent::RecvPostMessages(nsTArray<MessagePortMessage>&& aMessages)
{
// This converts the object in a data struct where we have BlobImpls.
FallibleTArray<nsRefPtr<SharedMessagePortMessage>> messages;
if (NS_WARN_IF(
!SharedMessagePortMessage::FromMessagesToSharedParent(aMessages,
messages))) {
return false;
}
if (!mEntangled) {
return false;
}
if (!mService) {
NS_WARNING("Entangle is called after a shutdown!");
return false;
}
if (messages.IsEmpty()) {
return false;
}
return mService->PostMessages(this, messages);
}
nsresult
VariableLengthPrefixSet::GetPrefixes(PrefixStringMap& aPrefixMap)
{
MutexAutoLock lock(mLock);
// 4-bytes prefixes are handled by nsUrlClassifierPrefixSet.
FallibleTArray<uint32_t> array;
nsresult rv = mFixedPrefixSet->GetPrefixesNative(array);
NS_ENSURE_SUCCESS(rv, rv);
size_t count = array.Length();
if (count) {
nsCString* prefixes = new nsCString();
if (!prefixes->SetLength(PREFIX_SIZE_FIXED * count, fallible)) {
return NS_ERROR_OUT_OF_MEMORY;
}
// Writing integer array to character array
uint32_t* begin = reinterpret_cast<uint32_t*>(prefixes->BeginWriting());
for (uint32_t i = 0; i < count; i++) {
begin[i] = NativeEndian::swapToBigEndian(array[i]);
}
aPrefixMap.Put(PREFIX_SIZE_FIXED, prefixes);
}
// Copy variable-length prefix set
for (auto iter = mVLPrefixSet.ConstIter(); !iter.Done(); iter.Next()) {
aPrefixMap.Put(iter.Key(), new nsCString(*iter.Data()));
}
return NS_OK;
}
already_AddRefed<DOMRequest>
MobileMessageManager::Delete(const Sequence<OwningLongOrSmsMessageOrMmsMessage>& aParams,
ErrorResult& aRv)
{
const uint32_t size = aParams.Length();
FallibleTArray<int32_t> idArray;
if (!idArray.SetLength(size, fallible)) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return nullptr;
}
DebugOnly<nsresult> rv;
for (uint32_t i = 0; i < size; i++) {
const OwningLongOrSmsMessageOrMmsMessage& element = aParams[i];
int32_t &id = idArray[i];
if (element.IsLong()) {
id = element.GetAsLong();
} else if (element.IsMmsMessage()) {
id = element.GetAsMmsMessage()->Id();
} else /*if (element.IsSmsMessage())*/ {
id = element.GetAsSmsMessage()->Id();
}
}
return Delete(idArray.Elements(), size, aRv);
}
bool
gfxContext::CurrentDash(FallibleTArray<gfxFloat>& dashes, gfxFloat* offset) const
{
int count = cairo_get_dash_count(mCairo);
if (count <= 0 || !dashes.SetLength(count)) {
return false;
}
cairo_get_dash(mCairo, dashes.Elements(), offset);
return true;
}
NS_IMETHODIMP
UDPSocketParent::OnPacketReceived(nsIUDPSocket* aSocket, nsIUDPMessage* aMessage)
{
// receiving packet from remote host, forward the message content to child process
if (!mIPCOpen) {
return NS_OK;
}
uint16_t port;
nsCString ip;
nsCOMPtr<nsINetAddr> fromAddr;
aMessage->GetFromAddr(getter_AddRefs(fromAddr));
fromAddr->GetPort(&port);
fromAddr->GetAddress(ip);
nsCString data;
aMessage->GetData(data);
const char* buffer = data.get();
uint32_t len = data.Length();
UDPSOCKET_LOG(("%s: %s:%u, length %u", __FUNCTION__, ip.get(), port, len));
if (mFilter) {
bool allowed;
mozilla::net::NetAddr addr;
fromAddr->GetNetAddr(&addr);
nsresult rv = mFilter->FilterPacket(&addr,
(const uint8_t*)buffer, len,
nsIUDPSocketFilter::SF_INCOMING,
&allowed);
// Receiving unallowed data, drop.
if (NS_WARN_IF(NS_FAILED(rv)) || !allowed) {
if (!allowed) {
UDPSOCKET_LOG(("%s: not allowed", __FUNCTION__));
}
return NS_OK;
}
}
FallibleTArray<uint8_t> fallibleArray;
if (!fallibleArray.InsertElementsAt(0, buffer, len)) {
FireInternalError(__LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> infallibleArray;
infallibleArray.SwapElements(fallibleArray);
// compose callback
mozilla::unused << SendCallbackReceivedData(UDPAddressInfo(ip, port), infallibleArray);
return NS_OK;
}
bool
Moof::ProcessCenc()
{
FallibleTArray<MediaByteRange> cencRanges;
if (!GetAuxInfo(AtomType("cenc"), &cencRanges) ||
cencRanges.Length() != mIndex.Length()) {
return false;
}
for (int i = 0; i < cencRanges.Length(); i++) {
mIndex[i].mCencRange = cencRanges[i];
}
return true;
}
/**
* Implement nsIStreamListener
* We buffer the entire content here and kick off verification
*/
NS_METHOD
AppendNextSegment(nsIInputStream* aInputStream, void* aClosure,
const char* aRawSegment, uint32_t aToOffset, uint32_t aCount,
uint32_t* outWrittenCount)
{
FallibleTArray<nsCString>* decodedData =
static_cast<FallibleTArray<nsCString>*>(aClosure);
nsAutoCString segment(aRawSegment, aCount);
if (!decodedData->AppendElement(segment, fallible)) {
return NS_ERROR_OUT_OF_MEMORY;
}
*outWrittenCount = aCount;
return NS_OK;
}
NS_IMETHODIMP
UDPSocketParent::OnPacketReceived(nsIUDPSocket* aSocket, nsIUDPMessage* aMessage)
{
// receiving packet from remote host, forward the message content to child process
if (!mIPCOpen) {
return NS_OK;
}
NS_ASSERTION(mFilter, "No packet filter");
uint16_t port;
nsCString ip;
nsCOMPtr<nsINetAddr> fromAddr;
aMessage->GetFromAddr(getter_AddRefs(fromAddr));
fromAddr->GetPort(&port);
fromAddr->GetAddress(ip);
nsCString data;
aMessage->GetData(data);
const char* buffer = data.get();
uint32_t len = data.Length();
bool allowed;
mozilla::net::NetAddr addr;
fromAddr->GetNetAddr(&addr);
nsresult rv = mFilter->FilterPacket(&addr,
(const uint8_t*)buffer, len,
nsIUDPSocketFilter::SF_INCOMING,
&allowed);
// Receiving unallowed data, drop.
NS_ENSURE_SUCCESS(rv, NS_OK);
NS_ENSURE_TRUE(allowed, NS_OK);
FallibleTArray<uint8_t> fallibleArray;
if (!fallibleArray.InsertElementsAt(0, buffer, len)) {
FireInternalError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> infallibleArray;
infallibleArray.SwapElements(fallibleArray);
// compose callback
mozilla::unused <<
PUDPSocketParent::SendCallback(NS_LITERAL_CSTRING("ondata"),
UDPMessage(ip, port, infallibleArray),
NS_LITERAL_CSTRING("connected"));
return NS_OK;
}
bool
MessagePortService::DisentanglePort(
MessagePortParent* aParent,
FallibleTArray<RefPtr<SharedMessagePortMessage>>& aMessages)
{
MessagePortServiceData* data;
if (!mPorts.Get(aParent->ID(), &data)) {
MOZ_ASSERT(false, "Unknown MessagePortParent should not happen.");
return false;
}
if (data->mParent != aParent) {
MOZ_ASSERT(false, "DisentanglePort() should be called just from the correct parent.");
return false;
}
// Let's put the messages in the correct order. |aMessages| contains the
// unsent messages so they have to go first.
if (!aMessages.AppendElements(data->mMessages, mozilla::fallible)) {
return false;
}
data->mMessages.Clear();
++data->mSequenceID;
// If we don't have a parent, we have to store the pending messages and wait.
uint32_t index = 0;
MessagePortParent* nextParent = nullptr;
for (; index < data->mNextParents.Length(); ++index) {
if (data->mNextParents[index].mSequenceID == data->mSequenceID) {
nextParent = data->mNextParents[index].mParent;
break;
}
}
// We didn't find the parent.
if (!nextParent) {
data->mMessages.SwapElements(aMessages);
data->mWaitingForNewParent = true;
data->mParent = nullptr;
return true;
}
data->mParent = nextParent;
data->mNextParents.RemoveElementAt(index);
FallibleTArray<MessagePortMessage> array;
if (!SharedMessagePortMessage::FromSharedToMessagesParent(data->mParent,
aMessages,
array)) {
return false;
}
Unused << data->mParent->Entangled(array);
return true;
}
nsresult
UDPSocketChild::SendDataInternal(const UDPSocketAddr& aAddr,
const uint8_t* aData,
const uint32_t aByteLength)
{
NS_ENSURE_ARG(aData);
FallibleTArray<uint8_t> fallibleArray;
if (!fallibleArray.InsertElementsAt(0, aData, aByteLength)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> array;
array.SwapElements(fallibleArray);
SendOutgoingData(array, aAddr);
return NS_OK;
}
nsresult
TCPSocketChild::SendSend(const ArrayBuffer& aData,
uint32_t aByteOffset,
uint32_t aByteLength,
uint32_t aTrackingNumber)
{
uint32_t buflen = aData.Length();
uint32_t offset = std::min(buflen, aByteOffset);
uint32_t nbytes = std::min(buflen - aByteOffset, aByteLength);
FallibleTArray<uint8_t> fallibleArr;
if (!fallibleArr.InsertElementsAt(0, aData.Data() + offset, nbytes, fallible)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> arr;
arr.SwapElements(fallibleArr);
SendData(arr, aTrackingNumber);
return NS_OK;
}
NS_IMETHODIMP
UDPSocketChild::Send(const nsACString& aHost,
uint16_t aPort,
const uint8_t *aData,
uint32_t aByteLength)
{
NS_ENSURE_ARG(aData);
FallibleTArray<uint8_t> fallibleArray;
if (!fallibleArray.InsertElementsAt(0, aData, aByteLength)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> array;
array.SwapElements(fallibleArray);
SendData(array, nsCString(aHost), aPort);
return NS_OK;
}
void
StructuredCloneHelper::MoveBufferDataToArray(FallibleTArray<uint8_t>& aArray,
ErrorResult& aRv)
{
MOZ_ASSERT(mBuffer, "MoveBuffer() cannot be called without a Write().");
if (NS_WARN_IF(!aArray.SetLength(BufferSize(), mozilla::fallible))) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return;
}
uint64_t* buffer;
size_t size;
mBuffer->steal(&buffer, &size);
mBuffer = nullptr;
memcpy(aArray.Elements(), buffer, size);
js_free(buffer);
}
NS_IMETHODIMP
UDPSocketChild::SendWithAddress(const NetAddr *aAddr,
const uint8_t *aData,
uint32_t aByteLength)
{
NS_ENSURE_ARG(aAddr);
NS_ENSURE_ARG(aData);
FallibleTArray<uint8_t> fallibleArray;
if (!fallibleArray.InsertElementsAt(0, aData, aByteLength)) {
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> array;
array.SwapElements(fallibleArray);
SendDataWithAddress(array, *aAddr);
return NS_OK;
}
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
nsUDPMessage::nsUDPMessage(NetAddr* aAddr,
nsIOutputStream* aOutputStream,
FallibleTArray<uint8_t>& aData)
: mOutputStream(aOutputStream)
{
memcpy(&mAddr, aAddr, sizeof(NetAddr));
aData.SwapElements(mData);
}
/* static */ void
ThreadSafeChromeUtils::Base64URLDecode(GlobalObject& aGlobal,
const nsACString& aString,
const Base64URLDecodeOptions& aOptions,
JS::MutableHandle<JSObject*> aRetval,
ErrorResult& aRv)
{
Base64URLDecodePaddingPolicy paddingPolicy;
switch (aOptions.mPadding) {
case Base64URLDecodePadding::Require:
paddingPolicy = Base64URLDecodePaddingPolicy::Require;
break;
case Base64URLDecodePadding::Ignore:
paddingPolicy = Base64URLDecodePaddingPolicy::Ignore;
break;
case Base64URLDecodePadding::Reject:
paddingPolicy = Base64URLDecodePaddingPolicy::Reject;
break;
default:
aRv.Throw(NS_ERROR_INVALID_ARG);
return;
}
FallibleTArray<uint8_t> data;
nsresult rv = mozilla::Base64URLDecode(aString, paddingPolicy, data);
if (NS_WARN_IF(NS_FAILED(rv))) {
aRv.Throw(rv);
return;
}
JS::Rooted<JSObject*> buffer(aGlobal.Context(),
ArrayBuffer::Create(aGlobal.Context(),
data.Length(),
data.Elements()));
if (NS_WARN_IF(!buffer)) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return;
}
aRetval.set(buffer);
}
// static
bool
SVGTransformListSMILType::GetTransforms(const nsSMILValue& aValue,
FallibleTArray<nsSVGTransform>& aTransforms)
{
NS_PRECONDITION(aValue.mType == Singleton(), "Unexpected SMIL value type");
const TransformArray& smilTransforms =
*static_cast<const TransformArray*>(aValue.mU.mPtr);
aTransforms.Clear();
if (!aTransforms.SetCapacity(smilTransforms.Length(), fallible))
return false;
for (uint32_t i = 0; i < smilTransforms.Length(); ++i) {
// No need to check the return value below since we have already allocated
// the necessary space
aTransforms.AppendElement(smilTransforms[i].ToSVGTransform(), fallible);
}
return true;
}
static inline bool
ConvertIndex(FallibleTArray<Index::Indice>& aDest,
const nsTArray<stagefright::MediaSource::Indice>& aIndex,
int64_t aMediaTime)
{
if (!aDest.SetCapacity(aIndex.Length(), mozilla::fallible)) {
return false;
}
for (size_t i = 0; i < aIndex.Length(); i++) {
Index::Indice indice;
const stagefright::MediaSource::Indice& s_indice = aIndex[i];
indice.start_offset = s_indice.start_offset;
indice.end_offset = s_indice.end_offset;
indice.start_composition = s_indice.start_composition - aMediaTime;
indice.end_composition = s_indice.end_composition - aMediaTime;
indice.sync = s_indice.sync;
// FIXME: Make this infallible after bug 968520 is done.
MOZ_ALWAYS_TRUE(aDest.AppendElement(indice, mozilla::fallible));
}
return true;
}
// OTS drops the OT Layout tables when decoding a WOFF file, so retrieve them
// separately and cache them (unchecked) in the font entry; harfbuzz will
// sanitize them when it needs to use them.
static void
PreloadTableFromWOFF(const PRUint8* aFontData, PRUint32 aLength,
PRUint32 aTableTag, gfxFontEntry* aFontEntry)
{
PRUint32 status = eWOFF_ok;
PRUint32 len = woffGetTableSize(aFontData, aLength, aTableTag, &status);
if (WOFF_SUCCESS(status) && len > 0) {
FallibleTArray<PRUint8> buffer;
if (!buffer.AppendElements(len)) {
NS_WARNING("failed to cache font table - out of memory?");
return;
}
woffGetTableToBuffer(aFontData, aLength, aTableTag,
buffer.Elements(), buffer.Length(),
&len, &status);
if (WOFF_FAILURE(status)) {
NS_WARNING("failed to cache font table - WOFF decoding error?");
return;
}
aFontEntry->PreloadFontTable(aTableTag, buffer);
}
}
/* static */ bool
SharedMessagePortMessage::FromMessagesToSharedParent(
nsTArray<ClonedMessageData>& aArray,
FallibleTArray<RefPtr<SharedMessagePortMessage>>& aData)
{
MOZ_ASSERT(aData.IsEmpty());
if (NS_WARN_IF(!aData.SetCapacity(aArray.Length(), mozilla::fallible))) {
return false;
}
for (auto& message : aArray) {
RefPtr<SharedMessagePortMessage> data = new SharedMessagePortMessage();
data->StealFromClonedMessageDataForBackgroundParent(message);
if (!aData.AppendElement(data, mozilla::fallible)) {
return false;
}
}
return true;
}
/* static */ bool
SharedMessagePortMessage::FromSharedToMessagesParent(
MessagePortParent* aActor,
const nsTArray<RefPtr<SharedMessagePortMessage>>& aData,
FallibleTArray<ClonedMessageData>& aArray)
{
MOZ_ASSERT(aArray.IsEmpty());
if (NS_WARN_IF(!aArray.SetCapacity(aData.Length(), mozilla::fallible))) {
return false;
}
PBackgroundParent* backgroundManager = aActor->Manager();
MOZ_ASSERT(backgroundManager);
for (auto& data : aData) {
ClonedMessageData* message = aArray.AppendElement(mozilla::fallible);
data->BuildClonedMessageDataForBackgroundParent(backgroundManager,
*message);
}
return true;
}
nsresult
FT2FontEntry::GetFontTable(PRUint32 aTableTag,
FallibleTArray<PRUint8>& aBuffer)
{
// Ensure existence of mFTFace
CairoFontFace();
NS_ENSURE_TRUE(mFTFace, NS_ERROR_FAILURE);
FT_Error status;
FT_ULong len = 0;
status = FT_Load_Sfnt_Table(mFTFace, aTableTag, 0, nsnull, &len);
NS_ENSURE_TRUE(status == 0, NS_ERROR_FAILURE);
NS_ENSURE_TRUE(len != 0, NS_ERROR_FAILURE);
if (!aBuffer.SetLength(len)) {
return NS_ERROR_OUT_OF_MEMORY;
}
PRUint8 *buf = aBuffer.Elements();
status = FT_Load_Sfnt_Table(mFTFace, aTableTag, 0, buf, &len);
NS_ENSURE_TRUE(status == 0, NS_ERROR_FAILURE);
return NS_OK;
}
