void
ImportLoader::Open()
{
AutoError ae(this, false);
nsCOMPtr<nsILoadGroup> loadGroup =
mImportParent->MasterDocument()->GetDocumentLoadGroup();
nsCOMPtr<nsIChannel> channel;
nsresult rv = NS_NewChannel(getter_AddRefs(channel),
mURI,
mImportParent,
nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS,
nsIContentPolicy::TYPE_SUBDOCUMENT,
loadGroup,
nullptr, // aCallbacks
nsIRequest::LOAD_BACKGROUND);
NS_ENSURE_SUCCESS_VOID(rv);
rv = channel->AsyncOpen2(this);
NS_ENSURE_SUCCESS_VOID(rv);
BlockScripts();
ae.Pass();
}
void
SpeechRecognition::Start(ErrorResult& aRv)
{
if (!mCurrentState == STATE_IDLE) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
nsAutoCString speechRecognitionServiceCID;
GetRecognitionServiceCID(speechRecognitionServiceCID);
nsresult rv;
mRecognitionService = do_GetService(speechRecognitionServiceCID.get(), &rv);
NS_ENSURE_SUCCESS_VOID(rv);
rv = mRecognitionService->Initialize(this->asWeakPtr());
NS_ENSURE_SUCCESS_VOID(rv);
AutoSafeJSContext cx;
MediaStreamConstraints constraints;
constraints.mAudio.SetAsBoolean() = true;
if (!mTestConfig.mFakeFSMEvents) {
MediaManager* manager = MediaManager::Get();
manager->GetUserMedia(cx,
false,
GetOwner(),
constraints,
new GetUserMediaSuccessCallback(this),
new GetUserMediaErrorCallback(this));
}
nsRefPtr<SpeechEvent> event = new SpeechEvent(this, EVENT_START);
NS_DispatchToMainThread(event);
}
void
SpeechRecognition::Start(const Optional<NonNull<DOMMediaStream>>& aStream, ErrorResult& aRv)
{
if (mCurrentState != STATE_IDLE) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
nsAutoCString speechRecognitionServiceCID;
GetRecognitionServiceCID(speechRecognitionServiceCID);
nsresult rv;
mRecognitionService = do_GetService(speechRecognitionServiceCID.get(), &rv);
NS_ENSURE_SUCCESS_VOID(rv);
rv = mRecognitionService->Initialize(this);
NS_ENSURE_SUCCESS_VOID(rv);
MediaStreamConstraints constraints;
constraints.mAudio.SetAsBoolean() = true;
if (aStream.WasPassed()) {
StartRecording(&aStream.Value());
} else {
MediaManager* manager = MediaManager::Get();
manager->GetUserMedia(false,
GetOwner(),
constraints,
new GetUserMediaSuccessCallback(this),
new GetUserMediaErrorCallback(this));
}
nsRefPtr<SpeechEvent> event = new SpeechEvent(this, EVENT_START);
NS_DispatchToMainThread(event);
}
void
nsNNTPNewsgroupList::SetProgressStatus(const char16_t *aMessage)
{
if (!m_runningURL)
return;
nsCOMPtr <nsIMsgMailNewsUrl> mailnewsUrl = do_QueryInterface(m_runningURL);
if (mailnewsUrl) {
nsCOMPtr <nsIMsgStatusFeedback> feedback;
mailnewsUrl->GetStatusFeedback(getter_AddRefs(feedback));
if (feedback) {
// prepending the account name to the status message.
nsresult rv;
nsCOMPtr <nsIMsgIncomingServer> server;
rv = mailnewsUrl->GetServer(getter_AddRefs(server));
NS_ENSURE_SUCCESS_VOID(rv);
nsString accountName;
server->GetPrettyName(accountName);
nsString statusMessage;
nsCOMPtr<nsIStringBundleService> sbs =
mozilla::services::GetStringBundleService();
nsCOMPtr<nsIStringBundle> bundle;
rv = sbs->CreateBundle(MSGS_URL,
getter_AddRefs(bundle));
NS_ENSURE_SUCCESS_VOID(rv);
const char16_t *params[] = { accountName.get(), aMessage };
bundle->FormatStringFromName(MOZ_UTF16("statusMessage"),
params, 2, getter_Copies(statusMessage));
feedback->ShowStatusString(statusMessage);
}
}
}
HttpServer::Connection::Connection(nsISocketTransport* aTransport,
HttpServer* aServer,
nsresult& rv)
: mServer(aServer)
, mTransport(aTransport)
, mState(eRequestLine)
, mPendingReqVersion()
, mRemainingBodySize()
, mCloseAfterRequest(false)
{
nsCOMPtr<nsIInputStream> input;
rv = mTransport->OpenInputStream(0, 0, 0, getter_AddRefs(input));
NS_ENSURE_SUCCESS_VOID(rv);
mInput = do_QueryInterface(input);
nsCOMPtr<nsIOutputStream> output;
rv = mTransport->OpenOutputStream(0, 0, 0, getter_AddRefs(output));
NS_ENSURE_SUCCESS_VOID(rv);
mOutput = do_QueryInterface(output);
if (mServer->mHttps) {
SetSecurityObserver(true);
} else {
mInput->AsyncWait(this, 0, 0, GetCurrentThreadEventTarget());
}
}
void
BluetoothDevice::SetPropertyByValue(const BluetoothNamedValue& aValue)
{
const nsString& name = aValue.name();
const BluetoothValue& value = aValue.value();
if (name.EqualsLiteral("Name")) {
mName = value.get_nsString();
} else if (name.EqualsLiteral("Path")) {
MOZ_ASSERT(value.get_nsString().Length() > 0);
mPath = value.get_nsString();
} else if (name.EqualsLiteral("Address")) {
mAddress = value.get_nsString();
} else if (name.EqualsLiteral("Class")) {
mClass = value.get_uint32_t();
} else if (name.EqualsLiteral("Icon")) {
mIcon = value.get_nsString();
} else if (name.EqualsLiteral("Connected")) {
mConnected = value.get_bool();
} else if (name.EqualsLiteral("Paired")) {
mPaired = value.get_bool();
} else if (name.EqualsLiteral("UUIDs")) {
mUuids = value.get_ArrayOfnsString();
nsresult rv;
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
NS_ENSURE_SUCCESS_VOID(rv);
NS_ENSURE_TRUE_VOID(sc);
AutoPushJSContext cx(sc->GetNativeContext());
JS::Rooted<JSObject*> uuids(cx);
if (NS_FAILED(nsTArrayToJSArray(cx, mUuids, uuids.address()))) {
BT_WARNING("Cannot set JS UUIDs object!");
return;
}
mJsUuids = uuids;
Root();
} else if (name.EqualsLiteral("Services")) {
mServices = value.get_ArrayOfnsString();
nsresult rv;
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
NS_ENSURE_SUCCESS_VOID(rv);
NS_ENSURE_TRUE_VOID(sc);
AutoPushJSContext cx(sc->GetNativeContext());
JS::Rooted<JSObject*> services(cx);
if (NS_FAILED(nsTArrayToJSArray(cx, mServices, services.address()))) {
BT_WARNING("Cannot set JS Services object!");
return;
}
mJsServices = services;
Root();
} else {
nsCString warningMsg;
warningMsg.AssignLiteral("Not handling device property: ");
warningMsg.Append(NS_ConvertUTF16toUTF8(name));
BT_WARNING(warningMsg.get());
}
}
void MailEwsSubscriptionCallback:: MoveItem(const char * oldParentFolderId,
const char * parentFolderId,
const char * oldItemId,
const char * itemId){
mailews_logger << "Move Item:"
<< oldParentFolderId
<< "," << parentFolderId
<< "," << oldItemId
<< "," << itemId
<< std::endl;
nsCOMPtr<IMailEwsMsgIncomingServer> ewsServer(do_QueryInterface(m_pIncomingServer));
nsCOMPtr<IMailEwsService> service;
nsresult rv = ewsServer-> GetService(getter_AddRefs(service));
NS_ENSURE_SUCCESS_VOID(rv);
nsCOMPtr<nsIMsgFolder> parentFolder;
bool calendarOrTask = false;
rv = GetFolderWithId(nsCString(parentFolderId),
getter_AddRefs(parentFolder),
calendarOrTask);
NS_ENSURE_SUCCESS_VOID(rv);
nsCOMPtr<nsIMsgFolder> oldParentFolder;
bool oldCalendarOrTask = false;
rv = GetFolderWithId(nsCString(oldParentFolderId),
getter_AddRefs(oldParentFolder),
oldCalendarOrTask);
NS_ENSURE_SUCCESS_VOID(rv);
if (parentFolder) {
rv = service->SyncItems(parentFolder, nullptr);
NS_ENSURE_SUCCESS_VOID(rv);
} else if (calendarOrTask) {
mailews_logger << "Refresh Calendar and Task"
<< std::endl;
ewsServer->RefreshCalendar();
} else {
mailews_logger << "Parent Folder Not found:"
<< parentFolderId
<< std::endl;
}
if (oldParentFolder) {
rv = service->SyncItems(oldParentFolder, nullptr);
NS_ENSURE_SUCCESS_VOID(rv);
} else if (oldCalendarOrTask) {
mailews_logger << "Refresh Calendar and Task"
<< std::endl;
ewsServer->RefreshCalendar();
} else {
mailews_logger << "Old Parent Folder Not found:"
<< parentFolderId
<< std::endl;
}
}
void
ImportLoader::Open()
{
AutoError ae(this, false);
// Imports should obey to the master documents CSP.
nsCOMPtr<nsIDocument> master = mImportParent->MasterDocument();
nsIPrincipal* principal = Principal();
int16_t shouldLoad = nsIContentPolicy::ACCEPT;
nsresult rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_SUBDOCUMENT,
mURI,
principal,
mImportParent,
NS_LITERAL_CSTRING("text/html"),
/* extra = */ nullptr,
&shouldLoad,
nsContentUtils::GetContentPolicy(),
nsContentUtils::GetSecurityManager());
if (NS_FAILED(rv) || NS_CP_REJECTED(shouldLoad)) {
NS_WARN_IF_FALSE(NS_CP_ACCEPTED(shouldLoad), "ImportLoader rejected by CSP");
return;
}
nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
rv = secMan->CheckLoadURIWithPrincipal(principal, mURI,
nsIScriptSecurityManager::STANDARD);
NS_ENSURE_SUCCESS_VOID(rv);
nsCOMPtr<nsILoadGroup> loadGroup = master->GetDocumentLoadGroup();
nsCOMPtr<nsIChannel> channel;
rv = NS_NewChannel(getter_AddRefs(channel),
mURI,
mImportParent,
nsILoadInfo::SEC_NORMAL,
nsIContentPolicy::TYPE_SUBDOCUMENT,
loadGroup,
nullptr, // aCallbacks
nsIRequest::LOAD_BACKGROUND);
NS_ENSURE_SUCCESS_VOID(rv);
// Init CORSListenerProxy and omit credentials.
nsRefPtr<nsCORSListenerProxy> corsListener =
new nsCORSListenerProxy(this, principal,
/* aWithCredentials */ false);
rv = corsListener->Init(channel, true);
NS_ENSURE_SUCCESS_VOID(rv);
rv = channel->AsyncOpen(corsListener, nullptr);
NS_ENSURE_SUCCESS_VOID(rv);
BlockScripts();
ae.Pass();
}
AudioDataDecoder(const AudioInfo& aConfig, MediaFormat::Param aFormat, MediaDataDecoderCallback* aCallback)
: MediaCodecDataDecoder(MediaData::Type::AUDIO_DATA, aConfig.mMimeType, aFormat, aCallback)
{
JNIEnv* env = GetJNIForThread();
jni::Object::LocalRef buffer(env);
NS_ENSURE_SUCCESS_VOID(aFormat->GetByteBuffer(NS_LITERAL_STRING("csd-0"), &buffer));
if (!buffer && aConfig.mCodecSpecificConfig->Length() >= 2) {
buffer = jni::Object::LocalRef::Adopt(env, env->NewDirectByteBuffer(aConfig.mCodecSpecificConfig->Elements(),
aConfig.mCodecSpecificConfig->Length()));
NS_ENSURE_SUCCESS_VOID(aFormat->SetByteBuffer(NS_LITERAL_STRING("csd-0"), buffer));
}
}
void SyncCalendarTask::DoSyncCalendar() {
nsresult rv = NS_OK;
mailews_logger << "start next round sync calendar items"
<< std::endl;
nsCOMPtr<IMailEwsMsgIncomingServer> ewsServer(do_QueryInterface(m_pIncomingServer, &rv));
NS_ENSURE_SUCCESS_VOID(rv);
nsCOMPtr<IMailEwsService> ewsService;
rv = ewsServer->GetService(getter_AddRefs(ewsService));
NS_ENSURE_SUCCESS_VOID(rv);
ewsService->SyncCalendar(m_pCalCallback, nullptr);
}
void
IMEContentObserver::ObserveEditableNode()
{
MOZ_ASSERT(mSelection);
MOZ_ASSERT(mRootContent);
mUpdatePreference = mWidget->GetIMEUpdatePreference();
if (mUpdatePreference.WantSelectionChange()) {
// add selection change listener
nsCOMPtr<nsISelectionPrivate> selPrivate(do_QueryInterface(mSelection));
NS_ENSURE_TRUE_VOID(selPrivate);
nsresult rv = selPrivate->AddSelectionListener(this);
NS_ENSURE_SUCCESS_VOID(rv);
}
if (mUpdatePreference.WantTextChange()) {
// add text change observer
mRootContent->AddMutationObserver(this);
}
if (mUpdatePreference.WantPositionChanged() && mDocShell) {
// Add scroll position listener and reflow observer to detect position and
// size changes
mDocShell->AddWeakScrollObserver(this);
mDocShell->AddWeakReflowObserver(this);
}
}
static
void
CopyHdrPropertiesWithSkipList(nsIMsgDBHdr *destHdr,
nsIMsgDBHdr *srcHdr,
const nsCString &skipList)
{
nsCOMPtr<nsIUTF8StringEnumerator> propertyEnumerator;
nsresult rv = srcHdr->GetPropertyEnumerator(getter_AddRefs(propertyEnumerator));
NS_ENSURE_SUCCESS_VOID(rv);
// We'll add spaces at beginning and end so we can search for space-name-space
nsCString dontPreserveEx(NS_LITERAL_CSTRING(" "));
dontPreserveEx.Append(skipList);
dontPreserveEx.AppendLiteral(" ");
nsAutoCString property;
nsCString sourceString;
bool hasMore;
while (NS_SUCCEEDED(propertyEnumerator->HasMore(&hasMore)) && hasMore)
{
propertyEnumerator->GetNext(property);
nsAutoCString propertyEx(NS_LITERAL_CSTRING(" "));
propertyEx.Append(property);
propertyEx.AppendLiteral(" ");
if (dontPreserveEx.Find(propertyEx) != -1) // -1 is not found
continue;
srcHdr->GetStringProperty(property.get(), getter_Copies(sourceString));
destHdr->SetStringProperty(property.get(), sourceString.get());
}
nsMsgLabelValue label = 0;
srcHdr->GetLabel(&label);
destHdr->SetLabel(label);
}
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 nsMsgBodyHandler::OpenLocalFolder()
{
nsCOMPtr <nsIInputStream> inputStream;
nsresult rv = m_scope->GetInputStream(m_msgHdr, getter_AddRefs(inputStream));
// Warn and return if GetInputStream fails
NS_ENSURE_SUCCESS_VOID(rv);
m_fileLineStream = do_QueryInterface(inputStream);
}
void
DataTransfer::FillInExternalCustomTypes(nsIVariant* aData, uint32_t aIndex,
nsIPrincipal* aPrincipal)
{
char* chrs;
uint32_t len = 0;
nsresult rv = aData->GetAsStringWithSize(&len, &chrs);
if (NS_FAILED(rv)) {
return;
}
nsAutoCString str;
str.Adopt(chrs, len);
nsCOMPtr<nsIInputStream> stringStream;
NS_NewCStringInputStream(getter_AddRefs(stringStream), str);
nsCOMPtr<nsIBinaryInputStream> stream =
do_CreateInstance("@mozilla.org/binaryinputstream;1");
if (!stream) {
return;
}
rv = stream->SetInputStream(stringStream);
NS_ENSURE_SUCCESS_VOID(rv);
uint32_t type;
do {
rv = stream->Read32(&type);
NS_ENSURE_SUCCESS_VOID(rv);
if (type == eCustomClipboardTypeId_String) {
uint32_t formatLength;
rv = stream->Read32(&formatLength);
NS_ENSURE_SUCCESS_VOID(rv);
char* formatBytes;
rv = stream->ReadBytes(formatLength, &formatBytes);
NS_ENSURE_SUCCESS_VOID(rv);
nsAutoString format;
format.Adopt(reinterpret_cast<char16_t*>(formatBytes),
formatLength / sizeof(char16_t));
uint32_t dataLength;
rv = stream->Read32(&dataLength);
NS_ENSURE_SUCCESS_VOID(rv);
char* dataBytes;
rv = stream->ReadBytes(dataLength, &dataBytes);
NS_ENSURE_SUCCESS_VOID(rv);
nsAutoString data;
data.Adopt(reinterpret_cast<char16_t*>(dataBytes),
dataLength / sizeof(char16_t));
RefPtr<nsVariantCC> variant = new nsVariantCC();
rv = variant->SetAsAString(data);
NS_ENSURE_SUCCESS_VOID(rv);
SetDataWithPrincipal(format, variant, aIndex, aPrincipal);
}
} while (type != eCustomClipboardTypeId_None);
}
void
InterceptedChannelContent::NotifyController()
{
nsresult rv = NS_NewPipe(getter_AddRefs(mSynthesizedInput),
getter_AddRefs(mResponseBody),
0, UINT32_MAX, true, true);
NS_ENSURE_SUCCESS_VOID(rv);
DoNotifyController();
}
// Get the current attributes of the mbox file, corrected for caching
void nsMsgBrkMBoxStore::GetMailboxModProperties(nsIMsgFolder *aFolder,
int64_t *aSize, uint32_t *aDate)
{
// We'll simply return 0 on errors.
*aDate = 0;
*aSize = 0;
nsCOMPtr<nsIFile> pathFile;
nsresult rv = aFolder->GetFilePath(getter_AddRefs(pathFile));
NS_ENSURE_SUCCESS_VOID(rv);
rv = pathFile->GetFileSize(aSize);
NS_ENSURE_SUCCESS_VOID(rv);
PRTime lastModTime;
rv = pathFile->GetLastModifiedTime(&lastModTime);
NS_ENSURE_SUCCESS_VOID(rv);
*aDate = (uint32_t) (lastModTime / PR_MSEC_PER_SEC);
}
void MailEwsSubscriptionCallback:: NewMail(const char * parentFolderId,
const char * itemId){
nsCOMPtr<IMailEwsMsgIncomingServer> ewsServer(do_QueryInterface(m_pIncomingServer));
nsCOMPtr<IMailEwsService> service;
nsresult rv = ewsServer-> GetService(getter_AddRefs(service));
NS_ENSURE_SUCCESS_VOID(rv);
nsCOMPtr<nsIMsgFolder> parentFolder;
bool calendarOrTaskFolder = false;
rv = GetFolderWithId(nsCString(parentFolderId),
getter_AddRefs(parentFolder),
calendarOrTaskFolder);
NS_ENSURE_SUCCESS_VOID(rv);
if (!parentFolder && !calendarOrTaskFolder) {
mailews_logger << "!!!!!!!New Mail in Unknown folder:"
<< parentFolderId
<< std::endl;
return;
}
if (parentFolder) {
nsString folderName;
rv = parentFolder->GetName(folderName);
nsCString utf7LeafName;
CopyUTF16toUTF8(folderName, utf7LeafName);
mailews_logger << "New Mail in folder:"
<< utf7LeafName.get()
<< std::endl;
rv = service->SyncItems(parentFolder, nullptr);
NS_ENSURE_SUCCESS_VOID(rv);
} else if (calendarOrTaskFolder) {
mailews_logger << "Refresh Calendar and Task"
<< std::endl;
ewsServer->RefreshCalendar();
}
}
AudioDataDecoder(const AudioInfo& aConfig, MediaFormat::Param aFormat,
MediaDataDecoderCallback* aCallback,
const nsString& aDrmStubId)
: MediaCodecDataDecoder(MediaData::Type::AUDIO_DATA, aConfig.mMimeType,
aFormat, aCallback, aDrmStubId)
{
JNIEnv* const env = jni::GetEnvForThread();
jni::ByteBuffer::LocalRef buffer(env);
NS_ENSURE_SUCCESS_VOID(aFormat->GetByteBuffer(NS_LITERAL_STRING("csd-0"),
&buffer));
if (!buffer && aConfig.mCodecSpecificConfig->Length() >= 2) {
buffer = jni::ByteBuffer::New(
aConfig.mCodecSpecificConfig->Elements(),
aConfig.mCodecSpecificConfig->Length());
NS_ENSURE_SUCCESS_VOID(aFormat->SetByteBuffer(NS_LITERAL_STRING("csd-0"),
buffer));
}
}
void
InitGonkMemoryPressureMonitoring()
{
// memoryPressureWatcher is held alive by the observer service.
nsRefPtr<MemoryPressureWatcher> memoryPressureWatcher =
new MemoryPressureWatcher();
NS_ENSURE_SUCCESS_VOID(memoryPressureWatcher->Init());
nsCOMPtr<nsIThread> thread;
NS_NewThread(getter_AddRefs(thread), memoryPressureWatcher);
}
void
WriteStumbleOnThread::Upload()
{
MOZ_ASSERT(!NS_IsMainThread());
bool b = sIsUploading.exchange(true);
if (b) {
return;
}
time_t seconds = time(0);
int day = seconds / (60 * 60 * 24);
if (sUploadFreqGuard.daySinceEpoch < day) {
sUploadFreqGuard.daySinceEpoch = day;
sUploadFreqGuard.attempts = 0;
}
sUploadFreqGuard.attempts++;
if (sUploadFreqGuard.attempts > MAX_UPLOAD_ATTEMPTS) {
STUMBLER_ERR("Too many upload attempts today");
return;
}
nsCOMPtr<nsIFile> tmpFile;
nsresult rv = nsDumpUtils::OpenTempFile(kOutputFileNameCompleted, getter_AddRefs(tmpFile),
kOutputDirName, nsDumpUtils::CREATE);
int64_t fileSize;
rv = tmpFile->GetFileSize(&fileSize);
if (NS_WARN_IF(NS_FAILED(rv))) {
STUMBLER_ERR("GetFileSize failed");
sIsUploading = false;
return;
}
STUMBLER_LOG("size : %lld", fileSize);
if (fileSize <= 0) {
sIsUploading = false;
return;
}
// prepare json into nsIInputStream
nsCOMPtr<nsIInputStream> inStream;
rv = NS_NewLocalFileInputStream(getter_AddRefs(inStream), tmpFile, -1, -1,
nsIFileInputStream::DEFER_OPEN);
NS_ENSURE_TRUE_VOID(inStream);
nsAutoCString bufStr;
rv = NS_ReadInputStreamToString(inStream, bufStr, fileSize);
NS_ENSURE_SUCCESS_VOID(rv);
nsCOMPtr<nsIRunnable> uploader = new UploadStumbleRunnable(bufStr);
NS_DispatchToMainThread(uploader);
}
void
InterceptedChannelChrome::NotifyController()
{
nsCOMPtr<nsIOutputStream> out;
// Intercepted responses should already be decoded.
mChannel->SetApplyConversion(false);
nsresult rv = mSynthesizedCacheEntry->OpenOutputStream(0, getter_AddRefs(mResponseBody));
NS_ENSURE_SUCCESS_VOID(rv);
DoNotifyController();
}
void
nsBrowserElement::InitBrowserElementAPI()
{
bool isMozBrowserOrApp;
nsCOMPtr<nsIFrameLoader> frameLoader = GetFrameLoader();
NS_ENSURE_TRUE_VOID(frameLoader);
nsresult rv = frameLoader->GetOwnerIsMozBrowserOrAppFrame(&isMozBrowserOrApp);
NS_ENSURE_SUCCESS_VOID(rv);
rv = frameLoader->GetOwnerIsWidget(&mOwnerIsWidget);
NS_ENSURE_SUCCESS_VOID(rv);
if (!isMozBrowserOrApp) {
return;
}
if (!mBrowserElementAPI) {
mBrowserElementAPI = do_CreateInstance("@mozilla.org/dom/browser-element-api;1");
if (NS_WARN_IF(!mBrowserElementAPI)) {
return;
}
}
mBrowserElementAPI->SetFrameLoader(frameLoader);
}
// Performs the necessary changes to set up the collector for the specified
// collected address book.
void
nsAbAddressCollector::SetUpAbFromPrefs(nsIPrefBranch *aPrefBranch)
{
nsCString abURI;
aPrefBranch->GetCharPref(PREF_MAIL_COLLECT_ADDRESSBOOK,
getter_Copies(abURI));
if (abURI.IsEmpty())
abURI.AssignLiteral(kPersonalAddressbookUri);
if (abURI == mABURI)
return;
mDirectory = nullptr;
mABURI = abURI;
nsresult rv;
nsCOMPtr<nsIAbManager> abManager(do_GetService(NS_ABMANAGER_CONTRACTID, &rv));
NS_ENSURE_SUCCESS_VOID(rv);
rv = abManager->GetDirectory(mABURI, getter_AddRefs(mDirectory));
NS_ENSURE_SUCCESS_VOID(rv);
bool readOnly;
rv = mDirectory->GetReadOnly(&readOnly);
NS_ENSURE_SUCCESS_VOID(rv);
// If the directory is read-only, we can't write to it, so just blank it out
// here, and warn because we shouldn't hit this (UI is wrong).
if (readOnly)
{
NS_ERROR("Address Collection book preferences is set to a read-only book. "
"Address collection will not take place.");
mDirectory = nullptr;
}
}
void ShutdownSocketTask::Run()
{
MOZ_ASSERT(!NS_IsMainThread());
// At this point, there should be no new events on the IO thread after this
// one with the possible exception of a SocketAcceptTask that
// ShutdownOnIOThread will cancel for us. We are now fully shut down, so we
// can send a message to the main thread that will delete mImpl safely knowing
// that no more tasks reference it.
mImpl->ShutdownOnIOThread();
nsRefPtr<nsIRunnable> t(new DeleteInstanceRunnable<UnixSocketImpl>(mImpl));
nsresult rv = NS_DispatchToMainThread(t);
NS_ENSURE_SUCCESS_VOID(rv);
}
void
DataTransfer::FillInExternalCustomTypes(nsIVariant* aData, uint32_t aIndex,
nsIPrincipal* aPrincipal)
{
char* chrs;
uint32_t len = 0;
nsresult rv = aData->GetAsStringWithSize(&len, &chrs);
if (NS_FAILED(rv)) {
return;
}
CheckedInt<int32_t> checkedLen(len);
if (!checkedLen.isValid()) {
return;
}
nsCOMPtr<nsIInputStream> stringStream;
NS_NewByteInputStream(getter_AddRefs(stringStream), chrs, checkedLen.value(),
NS_ASSIGNMENT_ADOPT);
nsCOMPtr<nsIObjectInputStream> stream =
NS_NewObjectInputStream(stringStream);
uint32_t type;
do {
rv = stream->Read32(&type);
NS_ENSURE_SUCCESS_VOID(rv);
if (type == eCustomClipboardTypeId_String) {
uint32_t formatLength;
rv = stream->Read32(&formatLength);
NS_ENSURE_SUCCESS_VOID(rv);
char* formatBytes;
rv = stream->ReadBytes(formatLength, &formatBytes);
NS_ENSURE_SUCCESS_VOID(rv);
nsAutoString format;
format.Adopt(reinterpret_cast<char16_t*>(formatBytes),
formatLength / sizeof(char16_t));
uint32_t dataLength;
rv = stream->Read32(&dataLength);
NS_ENSURE_SUCCESS_VOID(rv);
char* dataBytes;
rv = stream->ReadBytes(dataLength, &dataBytes);
NS_ENSURE_SUCCESS_VOID(rv);
nsAutoString data;
data.Adopt(reinterpret_cast<char16_t*>(dataBytes),
dataLength / sizeof(char16_t));
RefPtr<nsVariantCC> variant = new nsVariantCC();
rv = variant->SetAsAString(data);
NS_ENSURE_SUCCESS_VOID(rv);
SetDataWithPrincipal(format, variant, aIndex, aPrincipal);
}
} while (type != eCustomClipboardTypeId_None);
}
void
GeckoMediaPluginServiceParent::PluginTerminated(const nsRefPtr<GMPParent>& aPlugin)
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
if (aPlugin->IsMarkedForDeletion()) {
nsCString path8;
nsRefPtr<nsIFile> dir = aPlugin->GetDirectory();
nsresult rv = dir->GetNativePath(path8);
NS_ENSURE_SUCCESS_VOID(rv);
nsString path = NS_ConvertUTF8toUTF16(path8);
if (mPluginsWaitingForDeletion.Contains(path)) {
RemoveOnGMPThread(path, true /* delete */, true /* can defer */);
}
}
}
void nsFolderCompactState::ShowDoneStatus()
{
if (m_folder)
{
nsString statusString;
nsCOMPtr <nsIStringBundle> bundle;
nsresult rv = GetBaseStringBundle(getter_AddRefs(bundle));
NS_ENSURE_SUCCESS_VOID(rv);
nsAutoString expungedAmount;
FormatFileSize(m_totalExpungedBytes, true, expungedAmount);
const char16_t* params[] = { expungedAmount.get() };
rv = bundle->FormatStringFromName(u"compactingDone",
params, 1, getter_Copies(statusString));
if (!statusString.IsEmpty() && NS_SUCCEEDED(rv))
ShowStatusMsg(statusString);
}
}
void
IMEContentObserver::CharacterDataChanged(nsIDocument* aDocument,
nsIContent* aContent,
CharacterDataChangeInfo* aInfo)
{
NS_ASSERTION(aContent->IsNodeOfType(nsINode::eTEXT),
"character data changed for non-text node");
mEndOfAddedTextCache.Clear();
mStartOfRemovingTextRangeCache.Clear();
int64_t removedLength = mPreCharacterDataChangeLength;
mPreCharacterDataChangeLength = -1;
bool causedByComposition = IsEditorHandlingEventForComposition();
if (!mTextChangeData.IsValid() && causedByComposition &&
!mUpdatePreference.WantChangesCausedByComposition()) {
return;
}
MOZ_ASSERT(removedLength >= 0,
"mPreCharacterDataChangeLength should've been set by "
"CharacterDataWillChange()");
uint32_t offset = 0;
// get offsets of change and fire notification
nsresult rv =
ContentEventHandler::GetFlatTextOffsetOfRange(mRootContent, aContent,
aInfo->mChangeStart,
&offset,
LINE_BREAK_TYPE_NATIVE);
NS_ENSURE_SUCCESS_VOID(rv);
uint32_t newLength =
ContentEventHandler::GetNativeTextLength(aContent, aInfo->mChangeStart,
aInfo->mChangeStart +
aInfo->mReplaceLength);
uint32_t oldEnd = offset + static_cast<uint32_t>(removedLength);
uint32_t newEnd = offset + newLength;
TextChangeData data(offset, oldEnd, newEnd, causedByComposition);
MaybeNotifyIMEOfTextChange(data);
}
void
IDBTransaction::RollbackSavepoint()
{
NS_PRECONDITION(!NS_IsMainThread(), "Wrong thread!");
NS_PRECONDITION(mConnection, "No connection!");
NS_ASSERTION(mSavepointCount == 1, "Mismatch!");
mSavepointCount = 0;
nsCOMPtr<mozIStorageStatement> stmt = GetCachedStatement(NS_LITERAL_CSTRING(
"ROLLBACK TO SAVEPOINT " SAVEPOINT_NAME
));
NS_ENSURE_TRUE_VOID(stmt);
mozStorageStatementScoper scoper(stmt);
nsresult rv = stmt->Execute();
NS_ENSURE_SUCCESS_VOID(rv);
}
