// static already_AddRefed<HTMLImageElement> HTMLImageElement::Image(const GlobalObject& aGlobal, const Optional<uint32_t>& aWidth, const Optional<uint32_t>& aHeight, ErrorResult& aError) { nsCOMPtr<nsPIDOMWindowInner> win = do_QueryInterface(aGlobal.GetAsSupports()); nsIDocument* doc; if (!win || !(doc = win->GetExtantDoc())) { aError.Throw(NS_ERROR_FAILURE); return nullptr; } already_AddRefed<mozilla::dom::NodeInfo> nodeInfo = doc->NodeInfoManager()->GetNodeInfo(nsGkAtoms::img, nullptr, kNameSpaceID_XHTML, nsIDOMNode::ELEMENT_NODE); RefPtr<HTMLImageElement> img = new HTMLImageElement(nodeInfo); if (aWidth.WasPassed()) { img->SetWidth(aWidth.Value(), aError); if (aError.Failed()) { return nullptr; } if (aHeight.WasPassed()) { img->SetHeight(aHeight.Value(), aError); if (aError.Failed()) { return nullptr; } } } return img.forget(); }
int32_t WorkerGlobalScope::SetInterval(JSContext* aCx, Function& aHandler, const Optional<int32_t>& aTimeout, const Sequence<JS::Value>& aArguments, ErrorResult& aRv) { mWorkerPrivate->AssertIsOnWorkerThread(); bool isInterval = aTimeout.WasPassed(); int32_t timeout = aTimeout.WasPassed() ? aTimeout.Value() : 0; return mWorkerPrivate->SetTimeout(aCx, &aHandler, EmptyString(), timeout, aArguments, isInterval, aRv); }
void nsPerformance::ClearEntries(const Optional<nsAString>& aEntryName, const nsAString& aEntryType) { for (uint32_t i = 0; i < mEntries.Length();) { if ((!aEntryName.WasPassed() || mEntries[i]->GetName().Equals(aEntryName.Value())) && (aEntryType.IsEmpty() || mEntries[i]->GetEntryType().Equals(aEntryType))) { mEntries.RemoveElementAt(i); } else { ++i; } } }
already_AddRefed<Promise> Promise::Then(const Optional<OwningNonNull<AnyCallback> >& aResolveCallback, const Optional<OwningNonNull<AnyCallback> >& aRejectCallback) { nsRefPtr<Promise> promise = new Promise(GetParentObject()); nsRefPtr<PromiseCallback> resolveCb = PromiseCallback::Factory(promise->mResolver, aResolveCallback.WasPassed() ? &aResolveCallback.Value() : nullptr, PromiseCallback::Resolve); nsRefPtr<PromiseCallback> rejectCb = PromiseCallback::Factory(promise->mResolver, aRejectCallback.WasPassed() ? &aRejectCallback.Value() : nullptr, PromiseCallback::Reject); AppendCallbacks(resolveCb, rejectCb); return promise.forget(); }
void MIDIOutput::Send(const Sequence<uint8_t>& aData, const Optional<double>& aTimestamp, ErrorResult& aRv) { if (mPort->DeviceState() == MIDIPortDeviceState::Disconnected) { aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); return; } // The timestamp passed to us is a DOMHighResTimestamp, which is in relation // to the start of navigation timing. This needs to be turned into a // TimeStamp before it hits the platform specific MIDI service. // // If timestamp is either not set or zero, set timestamp to now and send the // message ASAP. TimeStamp timestamp; if (aTimestamp.WasPassed() && aTimestamp.Value() != 0) { nsCOMPtr<nsIDocument> doc = GetOwner()->GetDoc(); if (!doc) { aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); return; } TimeDuration ts_diff = TimeDuration::FromMilliseconds(aTimestamp.Value()); timestamp = GetOwner()->GetPerformance()->GetDOMTiming()->GetNavigationStartTimeStamp() + ts_diff; } else { timestamp = TimeStamp::Now(); } nsTArray<MIDIMessage> msgArray; MIDIUtils::ParseMessages(aData, timestamp, msgArray); // Our translation of the spec is that invalid messages in a multi-message // sequence will be thrown out, but that valid messages will still be used. if (msgArray.IsEmpty()) { aRv.Throw(NS_ERROR_DOM_TYPE_ERR); return; } // TODO Move this check back to parse message so we don't have to iterate // twice. if (!SysexEnabled()) { for (auto& msg : msgArray) { if (MIDIUtils::IsSysexMessage(msg)) { aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR); return; } } } mPort->SendSend(msgArray); }
int32_t WorkerGlobalScope::SetInterval(JSContext* /* unused */, const nsAString& aHandler, const Optional<int32_t>& aTimeout, const Sequence<JS::Value>& /* unused */, ErrorResult& aRv) { mWorkerPrivate->AssertIsOnWorkerThread(); Sequence<JS::Value> dummy; int32_t timeout = aTimeout.WasPassed() ? aTimeout.Value() : 0; return mWorkerPrivate->SetTimeout(GetCurrentThreadJSContext(), nullptr, aHandler, timeout, dummy, !!timeout, aRv); }
void nsDOMCameraControl::GetPreviewStreamVideoMode(JSContext* aCx, JS::Handle<JS::Value> aOptions, nsICameraPreviewStreamCallback* onSuccess, const Optional<nsICameraErrorCallback*>& onError, ErrorResult& aRv) { mozilla::idl::CameraRecorderOptions options; aRv = options.Init(aCx, aOptions.address()); if (aRv.Failed()) { return; } aRv = mCameraControl->GetPreviewStreamVideoMode(&options, onSuccess, onError.WasPassed() ? onError.Value() : nullptr); }
void nsPerformance::GetEntriesByName(const nsAString& name, const Optional<nsAString>& entryType, nsTArray<nsRefPtr<PerformanceEntry> >& retval) { MOZ_ASSERT(NS_IsMainThread()); retval.Clear(); uint32_t count = mEntries.Length(); for (uint32_t i = 0 ; i < count; i++) { if (mEntries[i]->GetName().Equals(name) && (!entryType.WasPassed() || mEntries[i]->GetEntryType().Equals(entryType.Value()))) { retval.AppendElement(mEntries[i]); } } }
void DataTransfer::ClearData(const Optional<nsAString>& aFormat, ErrorResult& aRv) { if (mReadOnly) { aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR); return; } if (mItems.Length() == 0) { return; } if (aFormat.WasPassed()) { MozClearDataAtHelper(aFormat.Value(), 0, aRv); } else { MozClearDataAtHelper(EmptyString(), 0, aRv); } }
int32_t WorkerGlobalScope::SetInterval(JSContext* aCx, const nsAString& aHandler, const Optional<int32_t>& aTimeout, const Sequence<JS::Value>& /* unused */, ErrorResult& aRv) { mWorkerPrivate->AssertIsOnWorkerThread(); Sequence<JS::Value> dummy; bool isInterval = aTimeout.WasPassed(); int32_t timeout = aTimeout.WasPassed() ? aTimeout.Value() : 0; nsCOMPtr<nsIScriptTimeoutHandler> handler = NS_CreateJSTimeoutHandler(aCx, mWorkerPrivate, aHandler); return mWorkerPrivate->SetTimeout(aCx, handler, timeout, isInterval, aRv); }
already_AddRefed<WebSocket> FlyWebPublishedServer::OnWebSocketAccept(InternalRequest* aConnectRequest, const Optional<nsAString>& aProtocol, ErrorResult& aRv) { MOZ_ASSERT(aConnectRequest); LOG_I("FlyWebPublishedServer::OnWebSocketAccept(%p)", this); nsCOMPtr<nsITransportProvider> provider = OnWebSocketAcceptInternal(aConnectRequest, aProtocol, aRv); if (aRv.Failed()) { return nullptr; } MOZ_ASSERT(provider); nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(GetOwner()); AutoJSContext cx; GlobalObject global(cx, nsGlobalWindow::Cast(window)->FastGetGlobalJSObject()); nsAutoCString extensions, negotiatedExtensions; aConnectRequest->Headers()-> GetFirst(NS_LITERAL_CSTRING("Sec-WebSocket-Extensions"), extensions, aRv); mozilla::net::ProcessServerWebSocketExtensions(extensions, negotiatedExtensions); nsCString url; aConnectRequest->GetURL(url); Sequence<nsString> protocols; if (aProtocol.WasPassed() && !protocols.AppendElement(aProtocol.Value(), fallible)) { aRv.Throw(NS_ERROR_OUT_OF_MEMORY); return nullptr; } return WebSocket::ConstructorCommon(global, NS_ConvertUTF8toUTF16(url), protocols, provider, negotiatedExtensions, aRv); }
// Methods. void nsDOMCameraControl::StartRecording(const CameraStartRecordingOptions& aOptions, nsDOMDeviceStorage& aStorageArea, const nsAString& aFilename, CameraStartRecordingCallback& aOnSuccess, const Optional<OwningNonNull<CameraErrorCallback> >& aOnError, ErrorResult& aRv) { MOZ_ASSERT(mCameraControl); NotifyRecordingStatusChange(NS_LITERAL_STRING("starting")); #ifdef MOZ_B2G if (!mAudioChannelAgent) { mAudioChannelAgent = do_CreateInstance("@mozilla.org/audiochannelagent;1"); if (mAudioChannelAgent) { // Camera app will stop recording when it falls to the background, so no callback is necessary. mAudioChannelAgent->Init(mWindow, AUDIO_CHANNEL_CONTENT, nullptr); // Video recording doesn't output any sound, so it's not necessary to check canPlay. int32_t canPlay; mAudioChannelAgent->StartPlaying(&canPlay); } } #endif nsCOMPtr<nsIDOMDOMRequest> request; mDSFileDescriptor = new DeviceStorageFileDescriptor(); aRv = aStorageArea.CreateFileDescriptor(aFilename, mDSFileDescriptor.get(), getter_AddRefs(request)); if (aRv.Failed()) { return; } mOptions = aOptions; mStartRecordingOnSuccessCb = &aOnSuccess; mStartRecordingOnErrorCb = nullptr; if (aOnError.WasPassed()) { mStartRecordingOnErrorCb = &aOnError.Value(); } nsCOMPtr<nsIDOMEventListener> listener = new StartRecordingHelper(this); request->AddEventListener(NS_LITERAL_STRING("success"), listener, false); request->AddEventListener(NS_LITERAL_STRING("error"), listener, false); }
void nsDOMCameraControl::StartRecording(JSContext* aCx, JS::Handle<JS::Value> aOptions, nsDOMDeviceStorage& storageArea, const nsAString& filename, nsICameraStartRecordingCallback* onSuccess, const Optional<nsICameraErrorCallback*>& onError, ErrorResult& aRv) { MOZ_ASSERT(onSuccess, "no onSuccess handler passed"); mozilla::idl::CameraStartRecordingOptions options; // Default values, until the dictionary parser can handle them. options.rotation = 0; options.maxFileSizeBytes = 0; options.maxVideoLengthMs = 0; aRv = options.Init(aCx, aOptions.address()); if (aRv.Failed()) { return; } aRv = NotifyRecordingStatusChange(NS_LITERAL_STRING("starting")); #ifdef MOZ_B2G if (!mAudioChannelAgent) { mAudioChannelAgent = do_CreateInstance("@mozilla.org/audiochannelagent;1"); if (mAudioChannelAgent) { // Camera app will stop recording when it falls to the background, so no callback is necessary. mAudioChannelAgent->Init(AUDIO_CHANNEL_CONTENT, nullptr); // Video recording doesn't output any sound, so it's not necessary to check canPlay. int32_t canPlay; mAudioChannelAgent->StartPlaying(&canPlay); } } #endif nsCOMPtr<nsIFile> folder; aRv = storageArea.GetRootDirectoryForFile(filename, getter_AddRefs(folder)); if (aRv.Failed()) { return; } aRv = mCameraControl->StartRecording(&options, folder, filename, onSuccess, onError.WasPassed() ? onError.Value() : nullptr); }
// Setter for weighted regions: { top, bottom, left, right, weight } nsresult nsDOMCameraControl::Set(uint32_t aKey, const Optional<Sequence<CameraRegion> >& aValue, uint32_t aLimit) { if (aLimit == 0) { DOM_CAMERA_LOGI("%s:%d : aLimit = 0, nothing to do\n", __func__, __LINE__); return NS_OK; } nsTArray<ICameraControl::Region> regionArray; if (aValue.WasPassed()) { const Sequence<CameraRegion>& regions = aValue.Value(); uint32_t length = regions.Length(); DOM_CAMERA_LOGI("%s:%d : got %d regions (limited to %d)\n", __func__, __LINE__, length, aLimit); if (length > aLimit) { length = aLimit; } // aLimit supplied by camera library provides sane ceiling (i.e. <10) regionArray.SetCapacity(length); for (uint32_t i = 0; i < length; ++i) { ICameraControl::Region* r = regionArray.AppendElement(); const CameraRegion ®ion = regions[i]; r->top = region.mTop; r->left = region.mLeft; r->bottom = region.mBottom; r->right = region.mRight; r->weight = region.mWeight; DOM_CAMERA_LOGI("region %d: top=%d, left=%d, bottom=%d, right=%d, weight=%u\n", i, r->top, r->left, r->bottom, r->right, r->weight ); } } else { DOM_CAMERA_LOGI("%s:%d : clear regions\n", __func__, __LINE__); } return mCameraControl->Set(aKey, regionArray); }
void ServiceWorkerClient::PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage, const Optional<Sequence<JS::Value>>& aTransferable, ErrorResult& aRv) { WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); MOZ_ASSERT(workerPrivate); workerPrivate->AssertIsOnWorkerThread(); JS::Rooted<JS::Value> transferable(aCx, JS::UndefinedValue()); if (aTransferable.WasPassed()) { const Sequence<JS::Value>& realTransferable = aTransferable.Value(); JS::HandleValueArray elements = JS::HandleValueArray::fromMarkedLocation(realTransferable.Length(), realTransferable.Elements()); JSObject* array = JS_NewArrayObject(aCx, elements); if (!array) { aRv.Throw(NS_ERROR_OUT_OF_MEMORY); return; } transferable.setObject(*array); } const JSStructuredCloneCallbacks* callbacks = WorkerStructuredCloneCallbacks(false); WorkerStructuredCloneClosure closure; JSAutoStructuredCloneBuffer buffer; if (!buffer.write(aCx, aMessage, transferable, callbacks, &closure)) { aRv.Throw(NS_ERROR_DOM_DATA_CLONE_ERR); return; } nsRefPtr<ServiceWorkerClientPostMessageRunnable> runnable = new ServiceWorkerClientPostMessageRunnable(mWindowId, Move(buffer), closure); nsresult rv = NS_DispatchToMainThread(runnable); if (NS_FAILED(rv)) { aRv.Throw(NS_ERROR_FAILURE); } }
already_AddRefed<IDBRequest> IDBDatabase::CreateMutableFile(JSContext* aCx, const nsAString& aName, const Optional<nsAString>& aType, ErrorResult& aRv) { AssertIsOnOwningThread(); if (QuotaManager::IsShuttingDown()) { IDB_REPORT_INTERNAL_ERR(); aRv.Throw(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR); return nullptr; } if (mClosed || mFileHandleDisabled) { aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR); return nullptr; } nsString type; if (aType.WasPassed()) { type = aType.Value(); } CreateFileParams params(nsString(aName), type); RefPtr<IDBRequest> request = IDBRequest::Create(aCx, this, nullptr); MOZ_ASSERT(request); BackgroundDatabaseRequestChild* actor = new BackgroundDatabaseRequestChild(this, request); IDB_LOG_MARK("IndexedDB %s: Child Request[%llu]: " "database(%s).createMutableFile(%s)", "IndexedDB %s: C R[%llu]: IDBDatabase.createMutableFile()", IDB_LOG_ID_STRING(), request->LoggingSerialNumber(), IDB_LOG_STRINGIFY(this), NS_ConvertUTF16toUTF8(aName).get()); mBackgroundActor->SendPBackgroundIDBDatabaseRequestConstructor(actor, params); return request.forget(); }
void SpeechRecognition::Start(const Optional<NonNull<DOMMediaStream>>& aStream, CallerType aCallerType, ErrorResult& aRv) { if (mCurrentState != STATE_IDLE) { aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); return; } if (!SetRecognitionService(aRv)) { return; } if (!ValidateAndSetGrammarList(aRv)) { return; } nsresult rv; rv = mRecognitionService->Initialize(this); if (NS_WARN_IF(NS_FAILED(rv))) { return; } MediaStreamConstraints constraints; constraints.mAudio.SetAsBoolean() = true; if (aStream.WasPassed()) { StartRecording(&aStream.Value()); } else { AutoNoJSAPI(); MediaManager* manager = MediaManager::Get(); manager->GetUserMedia(GetOwner(), constraints, new GetUserMediaSuccessCallback(this), new GetUserMediaErrorCallback(this), aCallerType); } RefPtr<SpeechEvent> event = new SpeechEvent(this, EVENT_START); NS_DispatchToMainThread(event); }
void WorkletGlobalScope::Dump(const Optional<nsAString>& aString) const { if (!nsContentUtils::DOMWindowDumpEnabled()) { return; } if (!aString.WasPassed()) { return; } NS_ConvertUTF16toUTF8 str(aString.Value()); #ifdef ANDROID __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", str.get()); #endif fputs(str.get(), stdout); fflush(stdout); }
void DataTransfer::ClearData(const Optional<nsAString>& aFormat, nsIPrincipal& aSubjectPrincipal, ErrorResult& aRv) { if (IsReadOnly()) { aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR); return; } if (MozItemCount() == 0) { return; } if (aFormat.WasPassed()) { MozClearDataAtHelper(aFormat.Value(), 0, aSubjectPrincipal, aRv); } else { MozClearDataAtHelper(EmptyString(), 0, aSubjectPrincipal, aRv); } }
int32_t WorkerGlobalScope::SetInterval(JSContext* aCx, Function& aHandler, const Optional<int32_t>& aTimeout, const Sequence<JS::Value>& aArguments, ErrorResult& aRv) { mWorkerPrivate->AssertIsOnWorkerThread(); bool isInterval = aTimeout.WasPassed(); int32_t timeout = aTimeout.WasPassed() ? aTimeout.Value() : 0; nsCOMPtr<nsIScriptTimeoutHandler> handler = NS_CreateJSTimeoutHandler(aCx, mWorkerPrivate, aHandler, aArguments, aRv); if (NS_WARN_IF(aRv.Failed())) { return 0; } return mWorkerPrivate->SetTimeout(aCx, handler, timeout, isInterval, aRv); }
void MediaRecorder::Start(const Optional<int32_t>& aTimeSlice, ErrorResult& aResult) { LOG(PR_LOG_DEBUG, ("MediaRecorder.Start %p", this)); if (mState != RecordingState::Inactive) { aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); return; } if (mStream->GetStream()->IsFinished() || mStream->GetStream()->IsDestroyed()) { aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); return; } if (!mStream->GetPrincipal()) { aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); return; } if (!CheckPrincipal()) { aResult.Throw(NS_ERROR_DOM_SECURITY_ERR); return; } int32_t timeSlice = 0; if (aTimeSlice.WasPassed()) { if (aTimeSlice.Value() < 0) { aResult.Throw(NS_ERROR_INVALID_ARG); return; } timeSlice = aTimeSlice.Value(); } mState = RecordingState::Recording; // Start a session mSessions.AppendElement(); mSessions.LastElement() = new Session(this, timeSlice); mSessions.LastElement()->Start(); }
void WorkerGlobalScope::Dump(const Optional<nsAString>& aString) const { mWorkerPrivate->AssertIsOnWorkerThread(); if (!aString.WasPassed()) { return; } if (!mWorkerPrivate->DumpEnabled()) { return; } NS_ConvertUTF16toUTF8 str(aString.Value()); #ifdef ANDROID __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", str.get()); #endif fputs(str.get(), stdout); fflush(stdout); }
void ServiceWorkerClient::PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage, const Optional<Sequence<JS::Value>>& aTransferable, ErrorResult& aRv) { WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate(); MOZ_ASSERT(workerPrivate); workerPrivate->AssertIsOnWorkerThread(); JS::Rooted<JS::Value> transferable(aCx, JS::UndefinedValue()); if (aTransferable.WasPassed()) { const Sequence<JS::Value>& realTransferable = aTransferable.Value(); JS::HandleValueArray elements = JS::HandleValueArray::fromMarkedLocation(realTransferable.Length(), realTransferable.Elements()); JSObject* array = JS_NewArrayObject(aCx, elements); if (!array) { aRv.Throw(NS_ERROR_OUT_OF_MEMORY); return; } transferable.setObject(*array); } RefPtr<ServiceWorkerClientPostMessageRunnable> runnable = new ServiceWorkerClientPostMessageRunnable(mWindowId); runnable->Write(aCx, aMessage, transferable, aRv); if (NS_WARN_IF(aRv.Failed())) { return; } aRv = NS_DispatchToMainThread(runnable); if (NS_WARN_IF(aRv.Failed())) { return; } }
already_AddRefed<DOMRequest> MobileMessageManager::GetSmscAddress(const Optional<uint32_t>& aServiceId, ErrorResult& aRv) { nsCOMPtr<nsISmsService> smsService = do_GetService(SMS_SERVICE_CONTRACTID); if (!smsService) { aRv.Throw(NS_ERROR_FAILURE); return nullptr; } // Use the default one unless |aSendParams.serviceId| is available. uint32_t serviceId; nsresult rv; if (aServiceId.WasPassed()) { serviceId = aServiceId.Value(); } else { rv = smsService->GetSmsDefaultServiceId(&serviceId); if (NS_FAILED(rv)) { aRv.Throw(rv); return nullptr; } } nsCOMPtr<nsPIDOMWindow> window = GetOwner(); if (!window) { aRv.Throw(NS_ERROR_FAILURE); return nullptr; } nsRefPtr<DOMRequest> request = new DOMRequest(window); nsCOMPtr<nsIMobileMessageCallback> msgCallback = new MobileMessageCallback(request); rv = smsService->GetSmscAddress(serviceId, msgCallback); if (NS_FAILED(rv)) { aRv.Throw(rv); return nullptr; } return request.forget(); }
already_AddRefed<nsITransportProvider> FlyWebPublishedServerChild::OnWebSocketAcceptInternal(InternalRequest* aRequest, const Optional<nsAString>& aProtocol, ErrorResult& aRv) { LOG_I("FlyWebPublishedServerChild::OnWebSocketAcceptInternal(%p)", this); if (!mActorExists) { LOG_I("FlyWebPublishedServerChild::OnWebSocketAcceptInternal(%p) - No actor!", this); return nullptr; } uint64_t id = mPendingRequests.Get(aRequest); MOZ_ASSERT(id); mPendingRequests.Remove(aRequest); RefPtr<TransportProviderChild> provider; mPendingTransportProviders.Remove(id, getter_AddRefs(provider)); nsString protocol; if (aProtocol.WasPassed()) { protocol = aProtocol.Value(); nsAutoCString reqProtocols; aRequest->Headers()-> GetFirst(NS_LITERAL_CSTRING("Sec-WebSocket-Protocol"), reqProtocols, aRv); if (!ContainsToken(reqProtocols, NS_ConvertUTF16toUTF8(protocol))) { // Should throw a better error here aRv.Throw(NS_ERROR_FAILURE); return nullptr; } } else { protocol.SetIsVoid(true); } Unused << SendWebSocketAccept(protocol, id); return provider.forget(); }
void nsDOMCameraControl::AutoFocus(CameraAutoFocusCallback& aOnSuccess, const Optional<OwningNonNull<CameraErrorCallback> >& aOnError, ErrorResult& aRv) { MOZ_ASSERT(mCameraControl); nsRefPtr<CameraErrorCallback> ecb = mAutoFocusOnErrorCb.forget(); if (ecb) { // There is already a call to AutoFocus() in progress, cancel it and // invoke the error callback (if one was passed in). NS_DispatchToMainThread(new ImmediateErrorCallback(ecb, NS_LITERAL_STRING("AutoFocusInterrupted"))); } mAutoFocusOnSuccessCb = &aOnSuccess; mAutoFocusOnErrorCb = nullptr; if (aOnError.WasPassed()) { mAutoFocusOnErrorCb = &aOnError.Value(); } aRv = mCameraControl->AutoFocus(); }
void WorkerDebuggerGlobalScope::LoadSubScript(JSContext* aCx, const nsAString& aURL, const Optional<JS::Handle<JSObject*>>& aSandbox, ErrorResult& aRv) { mWorkerPrivate->AssertIsOnWorkerThread(); Maybe<JSAutoCompartment> ac; if (aSandbox.WasPassed()) { JS::Rooted<JSObject*> sandbox(aCx, js::CheckedUnwrap(aSandbox.Value())); if (!IsDebuggerSandbox(sandbox)) { aRv.Throw(NS_ERROR_INVALID_ARG); return; } ac.emplace(aCx, sandbox); } nsTArray<nsString> urls; urls.AppendElement(aURL); workerinternals::Load(mWorkerPrivate, urls, DebuggerScript, aRv); }
void WorkerGlobalScope::Dump(const Optional<nsAString>& aString) const { mWorkerPrivate->AssertIsOnWorkerThread(); if (!aString.WasPassed()) { return; } #if !(defined(DEBUG) || defined(MOZ_ENABLE_JS_DUMP)) if (!DOMPrefs::DumpEnabled()) { return; } #endif NS_ConvertUTF16toUTF8 str(aString.Value()); MOZ_LOG(nsContentUtils::DOMDumpLog(), LogLevel::Debug, ("[Worker.Dump] %s", str.get())); #ifdef ANDROID __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", str.get()); #endif fputs(str.get(), stdout); fflush(stdout); }
void WorkerDebuggerGlobalScope::LoadSubScript( JSContext* aCx, const nsAString& aURL, const Optional<JS::Handle<JSObject*>>& aSandbox, ErrorResult& aRv) { mWorkerPrivate->AssertIsOnWorkerThread(); Maybe<JSAutoRealm> ar; if (aSandbox.WasPassed()) { // We only care about worker debugger sandbox objects here, so // CheckedUnwrapStatic is fine. JS::Rooted<JSObject*> sandbox(aCx, js::CheckedUnwrapStatic(aSandbox.Value())); if (!sandbox || !IsWorkerDebuggerSandbox(sandbox)) { aRv.Throw(NS_ERROR_INVALID_ARG); return; } ar.emplace(aCx, sandbox); } nsTArray<nsString> urls; urls.AppendElement(aURL); workerinternals::Load(mWorkerPrivate, urls, DebuggerScript, aRv); }
void AudioContext::DecodeAudioData(const ArrayBuffer& aBuffer, DecodeSuccessCallback& aSuccessCallback, const Optional<OwningNonNull<DecodeErrorCallback> >& aFailureCallback) { // Sniff the content of the media. // Failed type sniffing will be handled by AsyncDecodeMedia. nsAutoCString contentType; NS_SniffContent(NS_DATA_SNIFFER_CATEGORY, nullptr, aBuffer.Data(), aBuffer.Length(), contentType); nsCOMPtr<DecodeErrorCallback> failureCallback; if (aFailureCallback.WasPassed()) { failureCallback = &aFailureCallback.Value(); } nsRefPtr<WebAudioDecodeJob> job( new WebAudioDecodeJob(contentType, this, aBuffer, &aSuccessCallback, failureCallback)); mDecoder.AsyncDecodeMedia(contentType.get(), aBuffer.Data(), aBuffer.Length(), *job); // Transfer the ownership to mDecodeJobs mDecodeJobs.AppendElement(job.forget()); }