nsresult
MockMediaResource::GetCachedRanges(nsTArray<MediaByteRange>& aRanges)
{
aRanges.Clear();
aRanges.AppendElements(mRanges);
return NS_OK;
}
void
nsSVGTextContainerFrame::CopyRotateList(nsTArray<float> *parentList,
const SVGNumberList *selfList,
nsTArray<float> &dstList,
PRUint32 aOffset)
{
dstList.Clear();
PRUint32 strLength = GetNumberOfChars();
PRUint32 parentCount = 0;
if (parentList && parentList->Length() > aOffset) {
parentCount = NS_MIN(parentList->Length() - aOffset, strLength);
}
PRUint32 selfCount = NS_MIN(selfList ? selfList->Length() : 0, strLength);
PRUint32 count = NS_MAX(parentCount, selfCount);
if (count > 0) {
if (!dstList.SetLength(count))
return;
for (PRUint32 i = 0; i < selfCount; i++) {
dstList[i] = (*selfList)[i];
}
for (PRUint32 i = selfCount; i < parentCount; i++) {
dstList[i] = (*parentList)[aOffset + i];
}
} else if (parentList && !parentList->IsEmpty()) {
// rotate is applied to extra characters too
dstList.AppendElement((*parentList)[parentList->Length() - 1]);
}
}
nsresult nsDocShellEnumerator::BuildDocShellArray(nsTArray<nsWeakPtr>& inItemArray)
{
NS_ENSURE_TRUE(mRootItem, NS_ERROR_NOT_INITIALIZED);
inItemArray.Clear();
nsCOMPtr<nsIDocShellTreeItem> item = do_QueryReferent(mRootItem);
return BuildArrayRecursive(item, inItemArray);
}
void
FileDescriptorSetChild::ForgetFileDescriptors(
nsTArray<FileDescriptor>& aFileDescriptors)
{
aFileDescriptors.Clear();
mFileDescriptors.SwapElements(aFileDescriptors);
}
void
LayerManager::StopFrameTimeRecording(uint32_t aStartIndex,
nsTArray<float>& aFrameIntervals)
{
uint32_t bufferSize = mRecording.mIntervals.Length();
uint32_t length = mRecording.mNextIndex - aStartIndex;
if (mRecording.mIsPaused || length > bufferSize || aStartIndex < mRecording.mCurrentRunStartIndex) {
// aStartIndex is too old. Also if aStartIndex was issued before mRecordingNextIndex overflowed (uint32_t)
// and stopped after the overflow (would happen once every 828 days of constant 60fps).
length = 0;
}
if (!length) {
aFrameIntervals.Clear();
return; // empty recording, return empty arrays.
}
// Set length in advance to avoid possibly repeated reallocations
aFrameIntervals.SetLength(length);
uint32_t cyclicPos = aStartIndex % bufferSize;
for (uint32_t i = 0; i < length; i++, cyclicPos++) {
if (cyclicPos == bufferSize) {
cyclicPos = 0;
}
aFrameIntervals[i] = mRecording.mIntervals[cyclicPos];
}
}
void
nsSVGTextContainerFrame::CopyPositionList(nsTArray<float> *parentList,
SVGUserUnitList *selfList,
nsTArray<float> &dstList,
uint32_t aOffset)
{
dstList.Clear();
uint32_t strLength = GetNumberOfChars();
uint32_t parentCount = 0;
if (parentList && parentList->Length() > aOffset) {
parentCount = std::min(parentList->Length() - aOffset, strLength);
}
uint32_t selfCount = std::min(selfList->Length(), strLength);
uint32_t count = std::max(parentCount, selfCount);
if (!dstList.SetLength(count))
return;
for (uint32_t i = 0; i < selfCount; i++) {
dstList[i] = (*selfList)[i];
}
for (uint32_t i = selfCount; i < parentCount; i++) {
dstList[i] = (*parentList)[aOffset + i];
}
}
static void
FillPBufferAttribs_ByBits(nsTArray<EGLint>& aAttrs,
int redBits, int greenBits,
int blueBits, int alphaBits,
int depthBits, int stencilBits)
{
aAttrs.Clear();
#if defined(A1) || defined(A2)
#error The temp-macro names we want are already defined.
#endif
#define A1(_x) do { aAttrs.AppendElement(_x); } while (0)
#define A2(_x,_y) do { A1(_x); A1(_y); } while (0)
A2(LOCAL_EGL_RENDERABLE_TYPE, LOCAL_EGL_OPENGL_ES2_BIT);
A2(LOCAL_EGL_SURFACE_TYPE, LOCAL_EGL_PBUFFER_BIT);
A2(LOCAL_EGL_RED_SIZE, redBits);
A2(LOCAL_EGL_GREEN_SIZE, greenBits);
A2(LOCAL_EGL_BLUE_SIZE, blueBits);
A2(LOCAL_EGL_ALPHA_SIZE, alphaBits);
A2(LOCAL_EGL_DEPTH_SIZE, depthBits);
A2(LOCAL_EGL_STENCIL_SIZE, stencilBits);
A1(LOCAL_EGL_NONE);
#undef A1
#undef A2
}
void
PerformanceObserverEntryList::GetEntries(
const PerformanceEntryFilterOptions& aFilter,
nsTArray<RefPtr<PerformanceEntry>>& aRetval)
{
aRetval.Clear();
for (const RefPtr<PerformanceEntry>& entry : mEntries) {
if (aFilter.mInitiatorType.WasPassed()) {
const PerformanceResourceTiming* resourceEntry =
entry->ToResourceTiming();
if (!resourceEntry) {
continue;
}
nsAutoString initiatorType;
resourceEntry->GetInitiatorType(initiatorType);
if (!initiatorType.Equals(aFilter.mInitiatorType.Value())) {
continue;
}
}
if (aFilter.mName.WasPassed() &&
!entry->GetName().Equals(aFilter.mName.Value())) {
continue;
}
if (aFilter.mEntryType.WasPassed() &&
!entry->GetEntryType().Equals(aFilter.mEntryType.Value())) {
continue;
}
aRetval.AppendElement(entry);
}
}
// static
void IpcResourceUpdateQueue::ReleaseShmems(ipc::IProtocol* aShmAllocator,
nsTArray<ipc::Shmem>& aShms) {
for (auto& shm : aShms) {
aShmAllocator->DeallocShmem(shm);
}
aShms.Clear();
}
nsresult
nsGonkCameraControl::GetVideoSizes(nsTArray<CameraSize>& aVideoSizes)
{
aVideoSizes.Clear();
Vector<Size> sizes;
mParams.getSupportedVideoSizes(sizes);
if (sizes.size() == 0) {
DOM_CAMERA_LOGI("Camera doesn't support video independent of the preview\n");
mParams.getSupportedPreviewSizes(sizes);
}
if (sizes.size() == 0) {
DOM_CAMERA_LOGW("Camera doesn't report any supported video sizes at all\n");
return NS_OK;
}
for (size_t i = 0; i < sizes.size(); ++i) {
CameraSize size;
size.width = sizes[i].width;
size.height = sizes[i].height;
aVideoSizes.AppendElement(size);
}
return NS_OK;
}
void
JetpackActorCommon::RecList::copyTo(nsTArray<jsval>& dst) const
{
dst.Clear();
for (RecNode* node = mHead; node; node = node->down)
dst.AppendElement(node->value());
}
void
SpeechSynthesis::GetVoices(nsTArray< nsRefPtr<SpeechSynthesisVoice> >& aResult)
{
aResult.Clear();
uint32_t voiceCount = 0;
nsresult rv = nsSynthVoiceRegistry::GetInstance()->GetVoiceCount(&voiceCount);
NS_ENSURE_SUCCESS_VOID(rv);
for (uint32_t i = 0; i < voiceCount; i++) {
nsAutoString uri;
rv = nsSynthVoiceRegistry::GetInstance()->GetVoice(i, uri);
if (NS_FAILED(rv)) {
NS_WARNING("Failed to retrieve voice from registry");
continue;
}
SpeechSynthesisVoice* voice = mVoiceCache.GetWeak(uri);
if (!voice) {
voice = new SpeechSynthesisVoice(this, uri);
}
aResult.AppendElement(voice);
}
mVoiceCache.Clear();
for (uint32_t i = 0; i < aResult.Length(); i++) {
SpeechSynthesisVoice* voice = aResult[i];
mVoiceCache.Put(voice->mUri, voice);
}
}
void
nsSVGTextContainerFrame::CopyPositionList(nsTArray<float> *parentList,
SVGUserUnitList *selfList,
nsTArray<float> &dstList,
PRUint32 aOffset)
{
dstList.Clear();
PRUint32 strLength = GetNumberOfChars();
PRUint32 parentCount = 0;
if (parentList && parentList->Length() > aOffset) {
parentCount = NS_MIN(parentList->Length() - aOffset, strLength);
}
PRUint32 selfCount = NS_MIN(selfList->Length(), strLength);
PRUint32 count = NS_MAX(parentCount, selfCount);
if (!dstList.SetLength(count))
return;
for (PRUint32 i = 0; i < selfCount; i++) {
dstList[i] = (*selfList)[i];
}
for (PRUint32 i = selfCount; i < parentCount; i++) {
dstList[i] = (*parentList)[aOffset + i];
}
}
void IpcResourceUpdateQueue::Flush(
nsTArray<layers::OpUpdateResource>& aUpdates,
nsTArray<layers::RefCountedShmem>& aSmallAllocs,
nsTArray<ipc::Shmem>& aLargeAllocs) {
aUpdates.Clear();
mUpdates.SwapElements(aUpdates);
mWriter.Flush(aSmallAllocs, aLargeAllocs);
}
bool
DBusThread::TearDownData()
{
LOG("Removing DBus Sockets\n");
if (mControlFdW.get()) {
mControlFdW.dispose();
}
if (mControlFdR.get()) {
mControlFdR.dispose();
}
mPollData.Clear();
// DBusWatch pointers are maintained by DBus, so we won't leak by
// clearing.
mWatchData.Clear();
return true;
}
void
WindowsGamepadService::Cleanup()
{
if (mXInputPollTimer) {
mXInputPollTimer->Cancel();
}
mGamepads.Clear();
}
void
Service::getConnections(/* inout */ nsTArray<RefPtr<Connection> >& aConnections)
{
mRegistrationMutex.AssertNotCurrentThreadOwns();
MutexAutoLock mutex(mRegistrationMutex);
aConnections.Clear();
aConnections.AppendElements(mConnections);
}
void
VRSystemManagerOpenVR::GetControllers(nsTArray<RefPtr<VRControllerHost>>& aControllerResult)
{
aControllerResult.Clear();
for (uint32_t i = 0; i < mOpenVRController.Length(); ++i) {
aControllerResult.AppendElement(mOpenVRController[i]);
}
}
/* Fetch a list of printers handled by the PostsScript module */
void
nsPSPrinterList::GetPrinterList(nsTArray<nsCString>& aList)
{
aList.Clear();
// Query CUPS for a printer list. The default printer goes to the
// head of the output list; others are appended.
if (gCupsShim.IsInitialized()) {
cups_dest_t *dests;
int num_dests = (gCupsShim.mCupsGetDests)(&dests);
if (num_dests) {
for (int i = 0; i < num_dests; i++) {
nsAutoCString fullName(NS_CUPS_PRINTER);
fullName.Append(dests[i].name);
if (dests[i].instance != nullptr) {
fullName.Append("/");
fullName.Append(dests[i].instance);
}
if (dests[i].is_default)
aList.InsertElementAt(0, fullName);
else
aList.AppendElement(fullName);
}
}
(gCupsShim.mCupsFreeDests)(num_dests, dests);
}
// Build the "classic" list of printers -- those accessed by running
// an opaque command. This list always contains a printer named "default".
// In addition, we look for either an environment variable
// MOZILLA_POSTSCRIPT_PRINTER_LIST or a preference setting
// print.printer_list, which contains a space-separated list of printer
// names.
aList.AppendElement(
NS_LITERAL_CSTRING(NS_POSTSCRIPT_DRIVER_NAME "default"));
nsAutoCString list(PR_GetEnv("MOZILLA_POSTSCRIPT_PRINTER_LIST"));
if (list.IsEmpty()) {
list = Preferences::GetCString("print.printer_list");
}
if (!list.IsEmpty()) {
// For each printer (except "default" which was already added),
// construct a string "PostScript/<name>" and append it to the list.
char *state;
for (char *name = PL_strtok_r(list.BeginWriting(), " ", &state);
nullptr != name;
name = PL_strtok_r(nullptr, " ", &state)
) {
if (0 != strcmp(name, "default")) {
nsAutoCString fullName(NS_POSTSCRIPT_DRIVER_NAME);
fullName.Append(name);
aList.AppendElement(fullName);
}
}
}
}
void
nsGonkCameraControl::GetParameter(uint32_t aKey, nsTArray<CameraRegion>& aRegions)
{
aRegions.Clear();
const char* key = getKeyText(aKey);
if (!key) {
return;
}
RwAutoLockRead lock(mRwLock);
const char* value = mParams.get(key);
DOM_CAMERA_LOGI("key='%s' --> value='%s'\n", key, value);
if (!value) {
return;
}
const char* p = value;
uint32_t count = 1;
// count the number of regions in the string
while ((p = strstr(p, "),("))) {
++count;
p += 3;
}
aRegions.SetCapacity(count);
CameraRegion* r;
// parse all of the region sets
uint32_t i;
for (i = 0, p = value; p && i < count; ++i, p = strchr(p + 1, '(')) {
r = aRegions.AppendElement();
if (sscanf(p, "(%d,%d,%d,%d,%u)", &r->top, &r->left, &r->bottom, &r->right, &r->weight) != 5) {
DOM_CAMERA_LOGE("%s:%d : region tuple has bad format: '%s'\n", __func__, __LINE__, p);
goto GetParameter_error;
}
}
return;
GetParameter_error:
aRegions.Clear();
}
void
VRManager::GetVRControllerInfo(nsTArray<VRControllerInfo>& aControllerInfo)
{
aControllerInfo.Clear();
for (auto iter = mVRControllers.Iter(); !iter.Done(); iter.Next()) {
gfx::VRControllerHost* controller = iter.UserData();
aControllerInfo.AppendElement(VRControllerInfo(controller->GetControllerInfo()));
}
}
already_AddRefed<Layer> CreateLayerTree(
const char* aLayerTreeDescription,
nsIntRegion* aVisibleRegions,
const Matrix4x4* aTransforms,
nsRefPtr<LayerManager>& manager,
nsTArray<nsRefPtr<Layer> >& aLayersOut) {
aLayersOut.Clear();
manager = new TestLayerManager();
nsRefPtr<Layer> rootLayer = nullptr;
nsRefPtr<ContainerLayer> parentContainerLayer = nullptr;
nsRefPtr<Layer> lastLayer = nullptr;
int layerNumber = 0;
for (size_t i = 0; i < strlen(aLayerTreeDescription); i++) {
if (aLayerTreeDescription[i] == '(') {
if (!lastLayer) {
printf("Syntax error, likely '(' character isn't preceded by a container.\n");
MOZ_CRASH();
}
parentContainerLayer = lastLayer->AsContainerLayer();
if (!parentContainerLayer) {
printf("Layer before '(' must be a container.\n");
MOZ_CRASH();
}
} else if (aLayerTreeDescription[i] == ')') {
parentContainerLayer = parentContainerLayer->GetParent();
lastLayer = nullptr;
} else {
nsRefPtr<Layer> layer = CreateLayer(aLayerTreeDescription[i], manager.get());
if (aVisibleRegions) {
layer->SetVisibleRegion(aVisibleRegions[layerNumber]);
}
if (aTransforms) {
layer->SetBaseTransform(aTransforms[layerNumber]);
}
aLayersOut.AppendElement(layer);
layerNumber++;
if (rootLayer && !parentContainerLayer) {
MOZ_CRASH();
}
if (!rootLayer) {
rootLayer = layer;
}
if (parentContainerLayer) {
parentContainerLayer->InsertAfter(layer, parentContainerLayer->GetLastChild());
layer->SetParent(parentContainerLayer);
}
lastLayer = layer;
}
}
if (rootLayer) {
rootLayer->ComputeEffectiveTransforms(Matrix4x4());
}
return rootLayer.forget();
}
// static
void IpcResourceUpdateQueue::ReleaseShmems(
ipc::IProtocol* aShmAllocator, nsTArray<layers::RefCountedShmem>& aShms) {
for (auto& shm : aShms) {
if (RefCountedShm::IsValid(shm) && RefCountedShm::Release(shm) == 0) {
RefCountedShm::Dealloc(aShmAllocator, shm);
}
}
aShms.Clear();
}
/**
* Get any VR displays that have already been enumerated without
* activating any new devices.
*/
void
VRManager::GetVRDisplayInfo(nsTArray<VRDisplayInfo>& aDisplayInfo)
{
aDisplayInfo.Clear();
for (auto iter = mVRDisplays.Iter(); !iter.Done(); iter.Next()) {
gfx::VRDisplayHost* display = iter.UserData();
aDisplayInfo.AppendElement(VRDisplayInfo(display->GetDisplayInfo()));
}
}
void ExtractDisplayAddresses(const nsCOMArray<msgIAddressObject> &aHeader,
nsTArray<nsString> &displayAddrs) {
uint32_t count = aHeader.Length();
displayAddrs.SetLength(count);
for (uint32_t i = 0; i < count; i++) aHeader[i]->ToString(displayAddrs[i]);
if (count == 1 && displayAddrs[0].IsEmpty()) displayAddrs.Clear();
}
void WebCL_releaseVariantVector (nsTArray<nsIVariant*> & aVariants)
{
D_METHOD_START;
for (nsTArray<nsIVariant*>::index_type i = 0; i < aVariants.Length(); ++i)
{
if (aVariants[i])
NS_RELEASE (aVariants[i]);
}
aVariants.Clear ();
}
void ExtractAllAddresses(const nsCOMArray<msgIAddressObject> &aHeader,
nsTArray<nsString> &names,
nsTArray<nsString> &emails) {
uint32_t count = aHeader.Length();
// Prefill arrays before we start
names.SetLength(count);
emails.SetLength(count);
for (uint32_t i = 0; i < count; i++) {
aHeader[i]->GetName(names[i]);
aHeader[i]->GetEmail(emails[i]);
}
if (count == 1 && names[0].IsEmpty() && emails[0].IsEmpty()) {
names.Clear();
emails.Clear();
}
}
template<class T> nsresult
GonkCameraParameters::GetListAsArray(uint32_t aKey, nsTArray<T>& aArray)
{
const char* p;
nsresult rv = GetImpl(aKey, p);
if (NS_FAILED(rv)) {
return rv;
}
if (!p) {
DOM_CAMERA_LOGW("Camera parameter %d not available (value is null)\n", aKey);
return NS_ERROR_NOT_AVAILABLE;
}
if (*p == '\0') {
DOM_CAMERA_LOGW("Camera parameter %d not available (value is empty string)\n", aKey);
return NS_ERROR_NOT_AVAILABLE;
}
aArray.Clear();
const char* comma;
while (p) {
T* v = aArray.AppendElement();
if (!v) {
aArray.Clear();
return NS_ERROR_OUT_OF_MEMORY;
}
comma = strchr(p, ',');
if (comma != p) {
rv = ParseItem(p, comma, v);
if (NS_FAILED(rv)) {
aArray.Clear();
return rv;
}
p = comma;
}
if (p) {
++p;
}
}
return NS_OK;
}
template<class T> nsresult
GonkCameraParameters::GetListAsArray(uint32_t aKey, nsTArray<T>& aArray)
{
const char* p;
nsresult rv = GetImpl(aKey, p);
if (NS_FAILED(rv)) {
return rv;
}
aArray.Clear();
// If there is no value available, just return the empty array.
if (!p) {
DOM_CAMERA_LOGI("Camera parameter %d not available (value is null)\n", aKey);
return NS_OK;
}
if (*p == '\0') {
DOM_CAMERA_LOGI("Camera parameter %d not available (value is empty string)\n", aKey);
return NS_OK;
}
const char* comma;
while (p) {
// nsTArray::AppendElement() is infallible
T* v = aArray.AppendElement();
comma = strchr(p, ',');
if (comma != p) {
rv = ParseItem(p, comma, v);
if (NS_FAILED(rv)) {
aArray.Clear();
return rv;
}
p = comma;
}
if (p) {
++p;
}
}
return NS_OK;
}
bool
DatabaseInfo::GetObjectStoreNames(nsTArray<nsString>& aNames)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
aNames.Clear();
if (objectStoreHash) {
objectStoreHash->EnumerateRead(EnumerateObjectStoreNames, &aNames);
}
return true;
}