cubeb* GetCubebContextUnlocked()
{
sMutex.AssertCurrentThreadOwns();
if (sCubebState != CubebState::Uninitialized) {
// If we have already passed the initialization point (below), just return
// the current context, which may be null (e.g., after error or shutdown.)
return sCubebContext;
}
if (!sBrandName && NS_IsMainThread()) {
InitBrandName();
} else {
NS_WARNING_ASSERTION(
sBrandName, "Did not initialize sbrandName, and not on the main thread?");
}
int rv = cubeb_init(&sCubebContext, sBrandName);
NS_WARNING_ASSERTION(rv == CUBEB_OK, "Could not get a cubeb context.");
sCubebState = (rv == CUBEB_OK) ? CubebState::Initialized : CubebState::Uninitialized;
if (MOZ_LOG_TEST(gCubebLog, LogLevel::Verbose)) {
cubeb_set_log_callback(CUBEB_LOG_VERBOSE, CubebLogCallback);
} else if (MOZ_LOG_TEST(gCubebLog, LogLevel::Error)) {
cubeb_set_log_callback(CUBEB_LOG_NORMAL, CubebLogCallback);
}
return sCubebContext;
}
void
UDPSocket::LeaveMulticastGroup(const nsAString& aMulticastGroupAddress,
ErrorResult& aRv)
{
if (mReadyState == SocketReadyState::Closed) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
if (mReadyState == SocketReadyState::Opening) {
MulticastCommand leaveCommand(MulticastCommand::Leave, aMulticastGroupAddress);
mPendingMcastCommands.AppendElement(leaveCommand);
return;
}
MOZ_ASSERT(mSocket || mSocketChild);
nsCString address = NS_ConvertUTF16toUTF8(aMulticastGroupAddress);
if (mSocket) {
MOZ_ASSERT(!mSocketChild);
aRv = mSocket->LeaveMulticast(address, EmptyCString());
NS_WARNING_ASSERTION(!aRv.Failed(), "mSocket->LeaveMulticast failed");
return;
}
MOZ_ASSERT(mSocketChild);
aRv = mSocketChild->LeaveMulticast(address, EmptyCString());
NS_WARNING_ASSERTION(!aRv.Failed(), "mSocketChild->LeaveMulticast failed");
}
void InitBrandName()
{
if (sBrandName) {
return;
}
nsXPIDLString brandName;
nsCOMPtr<nsIStringBundleService> stringBundleService =
mozilla::services::GetStringBundleService();
if (stringBundleService) {
nsCOMPtr<nsIStringBundle> brandBundle;
nsresult rv = stringBundleService->CreateBundle(kBrandBundleURL,
getter_AddRefs(brandBundle));
if (NS_SUCCEEDED(rv)) {
rv = brandBundle->GetStringFromName(u"brandShortName",
getter_Copies(brandName));
NS_WARNING_ASSERTION(
NS_SUCCEEDED(rv), "Could not get the program name for a cubeb stream.");
}
}
/* cubeb expects a c-string. */
const char* ascii = NS_LossyConvertUTF16toASCII(brandName).get();
sBrandName = new char[brandName.Length() + 1];
PodCopy(sBrandName.get(), ascii, brandName.Length());
sBrandName[brandName.Length()] = 0;
}
void
nsPicoService::RegisterVoices()
{
nsSynthVoiceRegistry* registry = nsSynthVoiceRegistry::GetInstance();
for (auto iter = mVoices.Iter(); !iter.Done(); iter.Next()) {
const nsAString& uri = iter.Key();
RefPtr<PicoVoice>& voice = iter.Data();
// If we are missing either a language or a voice resource, it is invalid.
if (voice->mTaFile.IsEmpty() || voice->mSgFile.IsEmpty()) {
iter.Remove();
continue;
}
nsAutoString name;
name.AssignLiteral("Pico ");
name.Append(voice->mLanguage);
// This service is multi-threaded and can handle more than one utterance at a
// time before previous utterances end. So, aQueuesUtterances == false
DebugOnly<nsresult> rv =
registry->AddVoice(this, uri, name, voice->mLanguage, true, false);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Failed to add voice");
}
mInitialized = true;
}
void
DeviceStorageFileSystem::GetDirectoryName(nsIFile* aFile, nsAString& aRetval,
ErrorResult& aRv) const
{
AssertIsOnOwningThread();
MOZ_ASSERT(aFile);
nsCOMPtr<nsIFile> rootPath;
aRv = NS_NewLocalFile(LocalOrDeviceStorageRootPath(), false,
getter_AddRefs(rootPath));
if (NS_WARN_IF(aRv.Failed())) {
return;
}
bool equal = false;
aRv = aFile->Equals(rootPath, &equal);
if (NS_WARN_IF(aRv.Failed())) {
return;
}
if (equal) {
aRetval = mStorageName;
return;
}
FileSystemBase::GetDirectoryName(aFile, aRetval, aRv);
NS_WARNING_ASSERTION(!aRv.Failed(), "GetDirectoryName failed");
}
void
AudioStream::GetUnprocessed(AudioBufferWriter& aWriter)
{
mMonitor.AssertCurrentThreadOwns();
// Flush the timestretcher pipeline, if we were playing using a playback rate
// other than 1.0.
if (mTimeStretcher && mTimeStretcher->numSamples()) {
auto timeStretcher = mTimeStretcher;
aWriter.Write([timeStretcher] (AudioDataValue* aPtr, uint32_t aFrames) {
return timeStretcher->receiveSamples(aPtr, aFrames);
}, aWriter.Available());
// TODO: There might be still unprocessed samples in the stretcher.
// We should either remove or flush them so they won't be in the output
// next time we switch a playback rate other than 1.0.
NS_WARNING_ASSERTION(
mTimeStretcher->numUnprocessedSamples() == 0, "no samples");
}
while (aWriter.Available() > 0) {
UniquePtr<Chunk> c = mDataSource.PopFrames(aWriter.Available());
if (c->Frames() == 0) {
break;
}
MOZ_ASSERT(c->Frames() <= aWriter.Available());
if (IsValidAudioFormat(c.get())) {
aWriter.Write(c->Data(), c->Frames());
} else {
// Write silence if invalid format.
aWriter.WriteZeros(c->Frames());
}
}
}
LazyIdleThread::Release()
{
nsrefcnt count = --mRefCnt;
NS_LOG_RELEASE(this, count, "LazyIdleThread");
if (!count) {
// Stabilize refcount.
mRefCnt = 1;
nsCOMPtr<nsIRunnable> runnable =
NewNonOwningRunnableMethod(this, &LazyIdleThread::SelfDestruct);
NS_WARNING_ASSERTION(runnable, "Couldn't make runnable!");
if (NS_FAILED(NS_DispatchToCurrentThread(runnable))) {
MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
// The only way this could fail is if we're in shutdown, and in that case
// threads should have been joined already. Deleting here isn't dangerous
// anymore because we won't spin the event loop waiting to join the
// thread.
SelfDestruct();
}
}
return count;
}
NS_IMETHOD Run() override
{
ErrorResult rv;
mCallback->Call(mStringData, rv);
NS_WARNING_ASSERTION(!rv.Failed(), "callback failed");
return rv.StealNSResult();
}
void
nsSpeechTask::Cancel()
{
MOZ_ASSERT(XRE_IsParentProcess());
LOG(LogLevel::Debug, ("nsSpeechTask::Cancel"));
if (mCallback) {
DebugOnly<nsresult> rv = mCallback->OnCancel();
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
"Unable to call onCancel() callback");
}
if (mStream) {
mStream->Suspend();
}
if (!mInited) {
mPreCanceled = true;
}
if (!mIndirectAudio) {
DispatchEndInner(GetCurrentTime(), GetCurrentCharOffset());
}
}
void
DelayBuffer::UpdateUpmixChannels(int aNewReadChunk, uint32_t aChannelCount,
ChannelInterpretation aChannelInterpretation)
{
if (aNewReadChunk == mLastReadChunk) {
MOZ_ASSERT(mUpmixChannels.Length() == aChannelCount);
return;
}
NS_WARNING_ASSERTION(mHaveWrittenBlock || aNewReadChunk != mCurrentChunk,
"Smoothing is making feedback delay too small.");
mLastReadChunk = aNewReadChunk;
mUpmixChannels = mChunks[aNewReadChunk].ChannelData<float>();
MOZ_ASSERT(mUpmixChannels.Length() <= aChannelCount);
if (mUpmixChannels.Length() < aChannelCount) {
if (aChannelInterpretation == ChannelInterpretation::Speakers) {
AudioChannelsUpMix(&mUpmixChannels,
aChannelCount, SilentChannel::ZeroChannel<float>());
MOZ_ASSERT(mUpmixChannels.Length() == aChannelCount,
"We called GetAudioChannelsSuperset to avoid this");
} else {
// Fill up the remaining channels with zeros
for (uint32_t channel = mUpmixChannels.Length();
channel < aChannelCount; ++channel) {
mUpmixChannels.AppendElement(SilentChannel::ZeroChannel<float>());
}
}
}
}
NS_IMETHODIMP
InsertNodeTransaction::DoTransaction()
{
if (NS_WARN_IF(!mEditorBase) ||
NS_WARN_IF(!mContentToInsert) ||
NS_WARN_IF(!mPointToInsert.IsSet())) {
return NS_ERROR_NOT_INITIALIZED;
}
if (!mPointToInsert.IsSetAndValid()) {
// It seems that DOM tree has been changed after first DoTransaction()
// and current RedoTranaction() call.
if (mPointToInsert.GetChild()) {
EditorDOMPoint newPointToInsert(mPointToInsert.GetChild());
if (!newPointToInsert.IsSet()) {
// The insertion point has been removed from the DOM tree.
// In this case, we should append the node to the container instead.
newPointToInsert.SetToEndOf(mPointToInsert.GetContainer());
if (NS_WARN_IF(!newPointToInsert.IsSet())) {
return NS_ERROR_FAILURE;
}
}
mPointToInsert = newPointToInsert;
} else {
mPointToInsert.SetToEndOf(mPointToInsert.GetContainer());
if (NS_WARN_IF(!mPointToInsert.IsSet())) {
return NS_ERROR_FAILURE;
}
}
}
mEditorBase->MarkNodeDirty(GetAsDOMNode(mContentToInsert));
ErrorResult error;
mPointToInsert.GetContainer()->InsertBefore(*mContentToInsert,
mPointToInsert.GetChild(),
error);
error.WouldReportJSException();
if (NS_WARN_IF(error.Failed())) {
return error.StealNSResult();
}
// Only set selection to insertion point if editor gives permission
if (mEditorBase->GetShouldTxnSetSelection()) {
RefPtr<Selection> selection = mEditorBase->GetSelection();
if (NS_WARN_IF(!selection)) {
return NS_ERROR_FAILURE;
}
// Place the selection just after the inserted element
EditorRawDOMPoint afterInsertedNode(mContentToInsert);
DebugOnly<bool> advanced = afterInsertedNode.AdvanceOffset();
NS_WARNING_ASSERTION(advanced,
"Failed to advance offset after the inserted node");
selection->Collapse(afterInsertedNode, error);
if (NS_WARN_IF(error.Failed())) {
error.SuppressException();
}
}
return NS_OK;
}
NS_IMETHODIMP
InsertPlaintextCommand::DoCommandParams(const char* aCommandName,
nsICommandParams* aParams,
nsISupports* aCommandRefCon) {
if (NS_WARN_IF(!aParams)) {
return NS_ERROR_INVALID_ARG;
}
nsCOMPtr<nsIEditor> editor = do_QueryInterface(aCommandRefCon);
if (NS_WARN_IF(!editor)) {
return NS_ERROR_FAILURE;
}
// Get text to insert from command params
nsAutoString text;
nsresult rv = aParams->AsCommandParams()->GetString(STATE_DATA, text);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
TextEditor* textEditor = editor->AsTextEditor();
MOZ_ASSERT(textEditor);
// XXX InsertTextAsAction() is not same as OnInputText(). However, other
// commands to insert line break or paragraph separator use OnInput*().
// According to the semantics of those methods, using *AsAction() is
// better, however, this may not cause two or more placeholder
// transactions to the top transaction since its name may not be
// nsGkAtoms::TypingTxnName.
rv = textEditor->InsertTextAsAction(text);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Failed to insert the text");
return NS_OK;
}
void
FileSystemTaskParentBase::Start()
{
AssertIsOnBackgroundThread();
mFileSystem->AssertIsOnOwningThread();
DebugOnly<nsresult> rv = DispatchToIOThread(this);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "DispatchToIOThread failed");
}
void
FileSystemFileEntry::GetFile(FileCallback& aSuccessCallback,
const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback) const
{
RefPtr<FileCallbackRunnable> runnable =
new FileCallbackRunnable(&aSuccessCallback, mFile);
DebugOnly<nsresult> rv = NS_DispatchToMainThread(runnable);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NS_DispatchToMainThread failed");
}
mozilla::ipc::IPCResult
GamepadEventChannelChild::RecvGamepadUpdate(
const GamepadChangeEvent& aGamepadEvent)
{
DebugOnly<nsresult> rv =
NS_DispatchToMainThread(new GamepadUpdateRunnable(aGamepadEvent));
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NS_DispatchToMainThread failed");
return IPC_OK();
}
/* static */ void
PeerIdentity::GetNormalizedHost(const nsCOMPtr<nsIIDNService>& aIdnService,
const nsAString& aHost,
nsACString& aNormalizedHost)
{
const nsCString chost = NS_ConvertUTF16toUTF8(aHost);
DebugOnly<nsresult> rv = aIdnService->ConvertUTF8toACE(chost, aNormalizedHost);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
"Failed to convert UTF-8 host to ASCII");
}
void
FileSystemBase::GetDirectoryName(nsIFile* aFile, nsAString& aRetval,
ErrorResult& aRv) const
{
AssertIsOnOwningThread();
MOZ_ASSERT(aFile);
aRv = aFile->GetLeafName(aRetval);
NS_WARNING_ASSERTION(!aRv.Failed(), "GetLeafName failed");
}
bool
SpeechSynthesisVoice::LocalService() const
{
bool isLocal;
DebugOnly<nsresult> rv =
nsSynthVoiceRegistry::GetInstance()->IsLocalVoice(mUri, &isLocal);
NS_WARNING_ASSERTION(
NS_SUCCEEDED(rv), "Failed to get SpeechSynthesisVoice.localService");
return isLocal;
}
bool
SpeechSynthesisVoice::Default() const
{
bool isDefault;
DebugOnly<nsresult> rv =
nsSynthVoiceRegistry::GetInstance()->IsDefaultVoice(mUri, &isDefault);
NS_WARNING_ASSERTION(
NS_SUCCEEDED(rv), "Failed to get SpeechSynthesisVoice.default");
return isDefault;
}
void
CreateDirectoryTaskChild::SetSuccessRequestResult(const FileSystemResponseValue& aValue,
ErrorResult& aRv)
{
MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread!");
const FileSystemDirectoryResponse& r =
aValue.get_FileSystemDirectoryResponse();
aRv = NS_NewNativeLocalFile(NS_ConvertUTF16toUTF8(r.realPath()), true,
getter_AddRefs(mTargetPath));
NS_WARNING_ASSERTION(!aRv.Failed(), "NS_NewNativeLocalFile failed");
}
void
GetEntryHelper::Error(nsresult aError)
{
MOZ_ASSERT(NS_FAILED(aError));
if (mErrorCallback) {
RefPtr<ErrorCallbackRunnable> runnable =
new ErrorCallbackRunnable(mParentEntry->GetParentObject(),
mErrorCallback, aError);
DebugOnly<nsresult> rv = NS_DispatchToMainThread(runnable);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NS_DispatchToMainThread failed");
}
}
void
nsSMILCompositor::UpdateCachedBaseValue(const nsSMILValue& aBaseValue)
{
if (!mCachedBaseValue) {
// We don't have last sample's base value cached. Assume it's changed.
mCachedBaseValue = new nsSMILValue(aBaseValue);
NS_WARNING_ASSERTION(mCachedBaseValue, "failed to cache base value (OOM?)");
mForceCompositing = true;
} else if (*mCachedBaseValue != aBaseValue) {
// Base value has changed since last sample.
*mCachedBaseValue = aBaseValue;
mForceCompositing = true;
}
}
NS_IMETHODIMP
nsScriptErrorBase::GetIsFromPrivateWindow(bool* aIsFromPrivateWindow)
{
NS_WARNING_ASSERTION(NS_IsMainThread() || mInitializedOnMainThread,
"This can't be safely determined off the main thread, "
"returning an inaccurate value!");
if (!mInitializedOnMainThread && NS_IsMainThread()) {
InitializeOnMainThread();
}
*aIsFromPrivateWindow = mIsFromPrivateWindow;
return NS_OK;
}
/* static */ void
FileSystemEntryCallbackHelper::Call(const Optional<OwningNonNull<FileSystemEntryCallback>>& aEntryCallback,
FileSystemEntry* aEntry)
{
MOZ_ASSERT(aEntry);
if (aEntryCallback.WasPassed()) {
RefPtr<EntryCallbackRunnable> runnable =
new EntryCallbackRunnable(&aEntryCallback.Value(), aEntry);
DebugOnly<nsresult> rv = NS_DispatchToMainThread(runnable);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NS_DispatchToMainThread failed");
}
}
NS_IMETHODIMP
LocalStoreImpl::Flush()
{
nsCOMPtr<nsIRDFRemoteDataSource> remote = do_QueryInterface(mInner);
// FIXME Bug 340242: Temporarily make this a warning rather than an
// assertion until we sort out the ordering of how we write
// everything to the localstore, flush it, and disconnect it when
// we're getting profile-change notifications.
NS_WARNING_ASSERTION(remote != nullptr, "not an nsIRDFRemoteDataSource");
if (! remote)
return NS_ERROR_UNEXPECTED;
return remote->Flush();
}
void
URL::URLSearchParamsUpdated(URLSearchParams* aSearchParams)
{
MOZ_ASSERT(mSearchParams);
MOZ_ASSERT(mSearchParams == aSearchParams);
nsAutoString search;
mSearchParams->Serialize(search);
ErrorResult rv;
SetSearchInternal(search, rv);
NS_WARNING_ASSERTION(!rv.Failed(), "SetSearchInternal failed");
rv.SuppressException();
}
NS_IMETHODIMP
nsScriptErrorBase::GetOuterWindowID(uint64_t* aOuterWindowID)
{
NS_WARNING_ASSERTION(NS_IsMainThread() || mInitializedOnMainThread,
"This can't be safely determined off the main thread, "
"returning an inaccurate value!");
if (!mInitializedOnMainThread && NS_IsMainThread()) {
InitializeOnMainThread();
}
*aOuterWindowID = mOuterWindowID;
return NS_OK;
}
nsresult
convertResultCode(int aSQLiteResultCode)
{
// Drop off the extended result bits of the result code.
int rc = aSQLiteResultCode & 0xFF;
switch (rc) {
case SQLITE_OK:
case SQLITE_ROW:
case SQLITE_DONE:
return NS_OK;
case SQLITE_CORRUPT:
case SQLITE_NOTADB:
return NS_ERROR_FILE_CORRUPTED;
case SQLITE_PERM:
case SQLITE_CANTOPEN:
return NS_ERROR_FILE_ACCESS_DENIED;
case SQLITE_BUSY:
return NS_ERROR_STORAGE_BUSY;
case SQLITE_LOCKED:
return NS_ERROR_FILE_IS_LOCKED;
case SQLITE_READONLY:
return NS_ERROR_FILE_READ_ONLY;
case SQLITE_IOERR:
return NS_ERROR_STORAGE_IOERR;
case SQLITE_FULL:
case SQLITE_TOOBIG:
return NS_ERROR_FILE_NO_DEVICE_SPACE;
case SQLITE_NOMEM:
return NS_ERROR_OUT_OF_MEMORY;
case SQLITE_MISUSE:
return NS_ERROR_UNEXPECTED;
case SQLITE_ABORT:
case SQLITE_INTERRUPT:
return NS_ERROR_ABORT;
case SQLITE_CONSTRAINT:
return NS_ERROR_STORAGE_CONSTRAINT;
}
// generic error
#ifdef DEBUG
nsAutoCString message;
message.AppendLiteral("SQLite returned error code ");
message.AppendInt(rc);
message.AppendLiteral(" , Storage will convert it to NS_ERROR_FAILURE");
NS_WARNING_ASSERTION(rc == SQLITE_ERROR, message.get());
#endif
return NS_ERROR_FAILURE;
}
/* static */ void
ErrorCallbackHelper::Call(nsIGlobalObject* aGlobal,
const Optional<OwningNonNull<ErrorCallback>>& aErrorCallback,
nsresult aError)
{
MOZ_ASSERT(aGlobal);
MOZ_ASSERT(NS_FAILED(aError));
if (aErrorCallback.WasPassed()) {
RefPtr<ErrorCallbackRunnable> runnable =
new ErrorCallbackRunnable(aGlobal, &aErrorCallback.Value(), aError);
DebugOnly<nsresult> rv = NS_DispatchToMainThread(runnable);
NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NS_DispatchToMainThread failed");
}
}
ScopedXErrorHandler::ScopedXErrorHandler(bool aAllowOffMainThread)
{
if (!aAllowOffMainThread) {
// Off main thread usage is not safe in general, but OMTC GL layers uses this
// with the main thread blocked, which makes it safe.
NS_WARNING_ASSERTION(
NS_IsMainThread(),
"ScopedXErrorHandler being called off main thread, may cause issues");
}
// let sXErrorPtr point to this object's mXError object, but don't reset this mXError object!
// think of the case of nested ScopedXErrorHandler's.
mOldXErrorPtr = sXErrorPtr;
sXErrorPtr = &mXError;
mOldErrorHandler = XSetErrorHandler(ErrorHandler);
}
