/*static*/ void AudioStream::InitLibrary() { #ifdef PR_LOGGING gAudioStreamLog = PR_NewLogModule("AudioStream"); #endif PrefChanged(PREF_VOLUME_SCALE, nullptr); Preferences::RegisterCallback(PrefChanged, PREF_VOLUME_SCALE); PrefChanged(PREF_CUBEB_LATENCY, nullptr); Preferences::RegisterCallback(PrefChanged, PREF_CUBEB_LATENCY); }
void AudioStream::InitLibrary() { #ifdef PR_LOGGING gAudioStreamLog = PR_NewLogModule("AudioStream"); #endif gAudioPrefsLock = new Mutex("AudioStream::gAudioPrefsLock"); PrefChanged(PREF_VOLUME_SCALE, nullptr); Preferences::RegisterCallback(PrefChanged, PREF_VOLUME_SCALE); #if defined(MOZ_CUBEB) PrefChanged(PREF_CUBEB_LATENCY, nullptr); Preferences::RegisterCallback(PrefChanged, PREF_CUBEB_LATENCY); #endif }
void InitLibrary() { PrefChanged(PREF_VOLUME_SCALE, nullptr); Preferences::RegisterCallback(PrefChanged, PREF_VOLUME_SCALE); PrefChanged(PREF_CUBEB_LATENCY_PLAYBACK, nullptr); PrefChanged(PREF_CUBEB_LATENCY_MSG, nullptr); Preferences::RegisterCallback(PrefChanged, PREF_CUBEB_LATENCY_PLAYBACK); Preferences::RegisterCallback(PrefChanged, PREF_CUBEB_LATENCY_MSG); Preferences::RegisterCallback(PrefChanged, PREF_CUBEB_LOG_LEVEL); #ifndef MOZ_WIDGET_ANDROID NS_DispatchToMainThread(NS_NewRunnableFunction(&InitBrandName)); #endif }
void Startup() { // The hang detector only runs in chrome processes. If you change this, // you must also deal with the threadsafety of AnnotateCrashReport in // non-chrome processes! if (GeckoProcessType_Default != XRE_GetProcessType()) return; MOZ_ASSERT(!gMonitor, "Hang monitor already initialized"); gMonitor = new Monitor("HangMonitor"); Preferences::RegisterCallback(PrefChanged, kHangMonitorPrefName, NULL); PrefChanged(NULL, NULL); #ifdef REPORT_CHROME_HANGS Preferences::RegisterCallback(PrefChanged, kTelemetryPrefName, NULL); winMainThreadHandle = OpenThread(THREAD_ALL_ACCESS, FALSE, GetCurrentThreadId()); if (!winMainThreadHandle) return; #endif // Don't actually start measuring hangs until we hit the main event loop. // This potentially misses a small class of really early startup hangs, // but avoids dealing with some xpcshell tests and other situations which // start XPCOM but don't ever start the event loop. Suspend(); gThread = PR_CreateThread(PR_USER_THREAD, ThreadMain, NULL, PR_PRIORITY_LOW, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0); }
void Startup() { if (GeckoProcessType_Default != XRE_GetProcessType() && GeckoProcessType_Content != XRE_GetProcessType()) { return; } MOZ_ASSERT(!gMonitor, "Hang monitor already initialized"); gMonitor = new Monitor("HangMonitor"); Preferences::RegisterCallback(PrefChanged, kHangMonitorPrefName, nullptr); PrefChanged(nullptr, nullptr); #ifdef REPORT_CHROME_HANGS Preferences::RegisterCallback(PrefChanged, kTelemetryPrefName, nullptr); winMainThreadHandle = OpenThread(THREAD_ALL_ACCESS, FALSE, GetCurrentThreadId()); if (!winMainThreadHandle) { return; } #endif // Don't actually start measuring hangs until we hit the main event loop. // This potentially misses a small class of really early startup hangs, // but avoids dealing with some xpcshell tests and other situations which // start XPCOM but don't ever start the event loop. Suspend(); gThread = PR_CreateThread(PR_USER_THREAD, ThreadMain, nullptr, PR_PRIORITY_LOW, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0); }
NS_IMETHODIMP nsContentBlocker::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData) { NS_ASSERTION(!strcmp(NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, aTopic), "unexpected topic - we only deal with pref changes!"); if (mPrefBranchInternal) PrefChanged(mPrefBranchInternal, NS_LossyConvertUTF16toASCII(aData).get()); return NS_OK; }
void Preferences::SetStringPref(const char* prefName, const char* value) { // sanity clause if (prefs == NULL) return; // add or replace if (prefs->HasString(prefName)) prefs->ReplaceString(prefName, value); else prefs->AddString(prefName, value); PrefChanged(prefName); }
void Preferences::SetBoolPref(const char* prefName, bool value) { // sanity clause if (prefs == NULL) return; // add or replace if (prefs->HasBool(prefName)) prefs->ReplaceBool(prefName, value); else prefs->AddBool(prefName, value); PrefChanged(prefName); }
void Preferences::SetRefPref(const char* prefName, const entry_ref* ref) { // sanity clause if (prefs == NULL) return; // add or replace if (prefs->HasRef(prefName)) prefs->ReplaceRef(prefName, ref); else prefs->AddRef(prefName, ref); PrefChanged(prefName); }
void Preferences::SetRectPref(const char* prefName, BRect rect) { // sanity clause if (prefs == NULL) return; // add or replace if (prefs->HasRect(prefName)) prefs->ReplaceRect(prefName, rect); else prefs->AddRect(prefName, rect); PrefChanged(prefName); }
NS_IMETHODIMP CookieServiceChild::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData) { NS_ASSERTION(strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) == 0, "not a pref change topic!"); nsCOMPtr<nsIPrefBranch> prefBranch = do_QueryInterface(aSubject); if (prefBranch) PrefChanged(prefBranch); return NS_OK; }
void Preferences::SetInt32Pref(const char* prefName, int32 value) { // sanity clause if (prefs == NULL) return; // add or replace if (prefs->HasInt32(prefName)) prefs->ReplaceInt32(prefName, value); else prefs->AddInt32(prefName, value); PrefChanged(prefName); }
NS_IMETHODIMP nsCookiePermission::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData) { nsCOMPtr<nsIPrefBranch> prefBranch = do_QueryInterface(aSubject); NS_ASSERTION(!nsCRT::strcmp(NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, aTopic), "unexpected topic - we only deal with pref changes!"); if (prefBranch) PrefChanged(prefBranch, NS_LossyConvertUTF16toASCII(aData).get()); return NS_OK; }
bool nsCookiePermission::Init() { // Initialize nsIPermissionManager and fetch relevant prefs. This is only // required for some methods on nsICookiePermission, so it should be done // lazily. nsresult rv; mPermMgr = do_GetService(NS_PERMISSIONMANAGER_CONTRACTID, &rv); if (NS_FAILED(rv)) return false; mThirdPartyUtil = do_GetService(THIRDPARTYUTIL_CONTRACTID, &rv); if (NS_FAILED(rv)) return false; // failure to access the pref service is non-fatal... nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID); if (prefBranch) { prefBranch->AddObserver(kCookiesLifetimePolicy, this, false); prefBranch->AddObserver(kCookiesLifetimeDays, this, false); prefBranch->AddObserver(kCookiesAlwaysAcceptSession, this, false); PrefChanged(prefBranch, nullptr); // migration code for original cookie prefs bool migrated; rv = prefBranch->GetBoolPref(kCookiesPrefsMigrated, &migrated); if (NS_FAILED(rv) || !migrated) { bool warnAboutCookies = false; prefBranch->GetBoolPref(kCookiesAskPermission, &warnAboutCookies); // if the user is using ask before accepting, we'll use that if (warnAboutCookies) prefBranch->SetIntPref(kCookiesLifetimePolicy, ASK_BEFORE_ACCEPT); bool lifetimeEnabled = false; prefBranch->GetBoolPref(kCookiesLifetimeEnabled, &lifetimeEnabled); // if they're limiting lifetime and not using the prompts, use the // appropriate limited lifetime pref if (lifetimeEnabled && !warnAboutCookies) { int32_t lifetimeBehavior; prefBranch->GetIntPref(kCookiesLifetimeBehavior, &lifetimeBehavior); if (lifetimeBehavior) prefBranch->SetIntPref(kCookiesLifetimePolicy, ACCEPT_FOR_N_DAYS); else prefBranch->SetIntPref(kCookiesLifetimePolicy, ACCEPT_SESSION); } prefBranch->SetBoolPref(kCookiesPrefsMigrated, true); } } return true; }
nsresult nsCookiePermission::Init() { nsresult rv; mPermMgr = do_GetService(NS_PERMISSIONMANAGER_CONTRACTID, &rv); if (NS_FAILED(rv)) return rv; // failure to access the pref service is non-fatal... nsCOMPtr<nsIPrefBranch2> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID); if (prefBranch) { prefBranch->AddObserver(kCookiesLifetimePolicy, this, PR_FALSE); prefBranch->AddObserver(kCookiesLifetimeDays, this, PR_FALSE); prefBranch->AddObserver(kCookiesAlwaysAcceptSession, this, PR_FALSE); #ifdef MOZ_MAIL_NEWS prefBranch->AddObserver(kCookiesDisabledForMailNews, this, PR_FALSE); #endif PrefChanged(prefBranch, nsnull); // migration code for original cookie prefs PRBool migrated; rv = prefBranch->GetBoolPref(kCookiesPrefsMigrated, &migrated); if (NS_FAILED(rv) || !migrated) { PRBool warnAboutCookies = PR_FALSE; prefBranch->GetBoolPref(kCookiesAskPermission, &warnAboutCookies); // if the user is using ask before accepting, we'll use that if (warnAboutCookies) prefBranch->SetIntPref(kCookiesLifetimePolicy, ASK_BEFORE_ACCEPT); PRBool lifetimeEnabled = PR_FALSE; prefBranch->GetBoolPref(kCookiesLifetimeEnabled, &lifetimeEnabled); // if they're limiting lifetime and not using the prompts, use the // appropriate limited lifetime pref if (lifetimeEnabled && !warnAboutCookies) { PRInt32 lifetimeBehavior; prefBranch->GetIntPref(kCookiesLifetimeBehavior, &lifetimeBehavior); if (lifetimeBehavior) prefBranch->SetIntPref(kCookiesLifetimePolicy, ACCEPT_FOR_N_DAYS); else prefBranch->SetIntPref(kCookiesLifetimePolicy, ACCEPT_SESSION); } prefBranch->SetBoolPref(kCookiesPrefsMigrated, PR_TRUE); } } return NS_OK; }
nsresult nsContentBlocker::Init() { nsresult rv; mPermissionManager = do_GetService(NS_PERMISSIONMANAGER_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIPrefService> prefService = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIPrefBranch> prefBranch; rv = prefService->GetBranch("permissions.default.", getter_AddRefs(prefBranch)); NS_ENSURE_SUCCESS(rv, rv); // Migrate old image blocker pref nsCOMPtr<nsIPrefBranch> oldPrefBranch; oldPrefBranch = do_QueryInterface(prefService); int32_t oldPref; rv = oldPrefBranch->GetIntPref("network.image.imageBehavior", &oldPref); if (NS_SUCCEEDED(rv) && oldPref) { int32_t newPref; switch (oldPref) { default: newPref = BEHAVIOR_ACCEPT; break; case 1: newPref = BEHAVIOR_NOFOREIGN; break; case 2: newPref = BEHAVIOR_REJECT; break; } prefBranch->SetIntPref("image", newPref); oldPrefBranch->ClearUserPref("network.image.imageBehavior"); } // The branch is not a copy of the prefservice, but a new object, because // it is a non-default branch. Adding obeservers to it will only work if // we make sure that the object doesn't die. So, keep a reference to it. mPrefBranchInternal = do_QueryInterface(prefBranch, &rv); NS_ENSURE_SUCCESS(rv, rv); rv = mPrefBranchInternal->AddObserver("", this, true); PrefChanged(prefBranch, nullptr); return rv; }
void Preferences::SetColorPref(const char* prefName, rgb_color color) { // sanity clause if (prefs == NULL) return; // convert to int32 (RGBA order) int32 value = (((uint32) color.red) << 24 | ((uint32) color.green) << 16 | ((uint32) color.blue) << 8 | color.alpha); // add or replace if (prefs->HasInt32(prefName)) prefs->ReplaceInt32(prefName, value); else prefs->AddInt32(prefName, value); PrefChanged(prefName); }