--- a/netwerk/base/nsIOService.cpp
+++ b/netwerk/base/nsIOService.cpp
@@ -196,16 +196,26 @@ nsIOService::nsIOService()
, mNetWon(0)
, mLastOfflineStateChange(PR_IntervalNow())
, mLastConnectivityChange(PR_IntervalNow())
, mLastNetworkLinkChange(PR_IntervalNow())
, mNetTearingDownStarted(0)
{
}
+static const char* gCallbackPrefs[] = {
+ PORT_PREF_PREFIX,
+ MANAGE_OFFLINE_STATUS_PREF,
+ NECKO_BUFFER_CACHE_COUNT_PREF,
+ NECKO_BUFFER_CACHE_SIZE_PREF,
+ NETWORK_NOTIFY_CHANGED_PREF,
+ NETWORK_CAPTIVE_PORTAL_PREF,
+ nullptr,
+};
+
nsresult
nsIOService::Init()
{
// XXX hack until xpidl supports error info directly (bug 13423)
nsCOMPtr<nsIErrorService> errorService = do_GetService(NS_ERRORSERVICE_CONTRACTID);
if (errorService) {
errorService->RegisterErrorStringBundle(NS_ERROR_MODULE_NETWORK, NECKO_MSGS_URL);
}
@@ -214,27 +224,20 @@ nsIOService::Init()
InitializeCaptivePortalService();
// setup our bad port list stuff
for(int i=0; gBadPortList[i]; i++)
mRestrictedPortList.AppendElement(gBadPortList[i]);
// Further modifications to the port list come from prefs
- nsCOMPtr<nsIPrefBranch> prefBranch;
- GetPrefBranch(getter_AddRefs(prefBranch));
- if (prefBranch) {
- prefBranch->AddObserver(PORT_PREF_PREFIX, this, true);
- prefBranch->AddObserver(MANAGE_OFFLINE_STATUS_PREF, this, true);
- prefBranch->AddObserver(NECKO_BUFFER_CACHE_COUNT_PREF, this, true);
- prefBranch->AddObserver(NECKO_BUFFER_CACHE_SIZE_PREF, this, true);
- prefBranch->AddObserver(NETWORK_NOTIFY_CHANGED_PREF, this, true);
- prefBranch->AddObserver(NETWORK_CAPTIVE_PORTAL_PREF, this, true);
- PrefsChanged(prefBranch);
- }
+ Preferences::RegisterPrefixCallbacks(
+ PREF_CHANGE_METHOD(nsIOService::PrefsChanged),
+ gCallbackPrefs, this);
+ PrefsChanged();
// Register for profile change notifications
nsCOMPtr<nsIObserverService> observerService = services::GetObserverService();
if (observerService) {
observerService->AddObserver(this, kProfileChangeNetTeardownTopic, true);
observerService->AddObserver(this, kProfileChangeNetRestoreTopic, true);
observerService->AddObserver(this, kProfileDoChange, true);
observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
@@ -1212,89 +1215,87 @@ nsIOService::AllowPort(int32_t inPort, c
*_retval = true;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
void
-nsIOService::PrefsChanged(nsIPrefBranch *prefs, const char *pref)
+nsIOService::PrefsChanged(const char *pref)
{
- if (!prefs) return;
-
// Look for extra ports to block
if (!pref || strcmp(pref, PORT_PREF("banned")) == 0)
- ParsePortList(prefs, PORT_PREF("banned"), false);
+ ParsePortList(PORT_PREF("banned"), false);
// ...as well as previous blocks to remove.
if (!pref || strcmp(pref, PORT_PREF("banned.override")) == 0)
- ParsePortList(prefs, PORT_PREF("banned.override"), true);
+ ParsePortList(PORT_PREF("banned.override"), true);
if (!pref || strcmp(pref, MANAGE_OFFLINE_STATUS_PREF) == 0) {
bool manage;
if (mNetworkLinkServiceInitialized &&
- NS_SUCCEEDED(prefs->GetBoolPref(MANAGE_OFFLINE_STATUS_PREF,
- &manage))) {
+ NS_SUCCEEDED(Preferences::GetBool(MANAGE_OFFLINE_STATUS_PREF,
+ &manage))) {
LOG(("nsIOService::PrefsChanged ManageOfflineStatus manage=%d\n", manage));
SetManageOfflineStatus(manage);
}
}
if (!pref || strcmp(pref, NECKO_BUFFER_CACHE_COUNT_PREF) == 0) {
int32_t count;
- if (NS_SUCCEEDED(prefs->GetIntPref(NECKO_BUFFER_CACHE_COUNT_PREF,
- &count)))
+ if (NS_SUCCEEDED(Preferences::GetInt(NECKO_BUFFER_CACHE_COUNT_PREF,
+ &count)))
/* check for bogus values and default if we find such a value */
if (count > 0)
gDefaultSegmentCount = count;
}
if (!pref || strcmp(pref, NECKO_BUFFER_CACHE_SIZE_PREF) == 0) {
int32_t size;
- if (NS_SUCCEEDED(prefs->GetIntPref(NECKO_BUFFER_CACHE_SIZE_PREF,
- &size)))
+ if (NS_SUCCEEDED(Preferences::GetInt(NECKO_BUFFER_CACHE_SIZE_PREF,
+ &size)))
/* check for bogus values and default if we find such a value
* the upper limit here is arbitrary. having a 1mb segment size
* is pretty crazy. if you remove this, consider adding some
* integer rollover test.
*/
if (size > 0 && size < 1024*1024)
gDefaultSegmentSize = size;
NS_WARNING_ASSERTION(!(size & (size - 1)),
"network segment size is not a power of 2!");
}
if (!pref || strcmp(pref, NETWORK_NOTIFY_CHANGED_PREF) == 0) {
bool allow;
- nsresult rv = prefs->GetBoolPref(NETWORK_NOTIFY_CHANGED_PREF, &allow);
+ nsresult rv = Preferences::GetBool(NETWORK_NOTIFY_CHANGED_PREF, &allow);
if (NS_SUCCEEDED(rv)) {
mNetworkNotifyChanged = allow;
}
}
if (!pref || strcmp(pref, NETWORK_CAPTIVE_PORTAL_PREF) == 0) {
- nsresult rv = prefs->GetBoolPref(NETWORK_CAPTIVE_PORTAL_PREF, &gCaptivePortalEnabled);
+ nsresult rv = Preferences::GetBool(NETWORK_CAPTIVE_PORTAL_PREF, &gCaptivePortalEnabled);
if (NS_SUCCEEDED(rv) && mCaptivePortalService) {
if (gCaptivePortalEnabled) {
static_cast<CaptivePortalService*>(mCaptivePortalService.get())->Start();
} else {
static_cast<CaptivePortalService*>(mCaptivePortalService.get())->Stop();
}
}
}
}
void
-nsIOService::ParsePortList(nsIPrefBranch *prefBranch, const char *pref, bool remove)
+nsIOService::ParsePortList(const char *pref, bool remove)
{
nsAutoCString portList;
// Get a pref string and chop it up into a list of ports.
- prefBranch->GetCharPref(pref, portList);
+ Preferences::GetCString(pref, portList);
if (!portList.IsVoid()) {
nsTArray<nsCString> portListArray;
ParseString(portList, ',', portListArray);
uint32_t index;
for (index=0; index < portListArray.Length(); index++) {
portListArray[index].StripWhitespace();
int32_t portBegin, portEnd;
@@ -1319,23 +1320,16 @@ nsIOService::ParsePortList(nsIPrefBranch
mRestrictedPortList.AppendElement(port);
}
}
}
}
}
-void
-nsIOService::GetPrefBranch(nsIPrefBranch **result)
-{
- *result = nullptr;
- CallGetService(NS_PREFSERVICE_CONTRACTID, result);
-}
-
class nsWakeupNotifier : public Runnable
{
public:
explicit nsWakeupNotifier(nsIIOServiceInternal* ioService)
: Runnable("net::nsWakeupNotifier")
, mIOService(ioService)
{
}
@@ -1376,21 +1370,17 @@ nsIOService::SetHttpHandlerAlreadyShutin
}
// nsIObserver interface
NS_IMETHODIMP
nsIOService::Observe(nsISupports *subject,
const char *topic,
const char16_t *data)
{
- if (!strcmp(topic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
- nsCOMPtr<nsIPrefBranch> prefBranch = do_QueryInterface(subject);
- if (prefBranch)
- PrefsChanged(prefBranch, NS_ConvertUTF16toUTF8(data).get());
- } else if (!strcmp(topic, kProfileChangeNetTeardownTopic)) {
+ if (!strcmp(topic, kProfileChangeNetTeardownTopic)) {
if (!mHttpHandlerAlreadyShutingDown) {
mNetTearingDownStarted = PR_IntervalNow();
}
mHttpHandlerAlreadyShutingDown = false;
if (!mOffline) {
mOfflineForProfileChange = true;
SetOffline(true);
}
@@ -1403,19 +1393,17 @@ nsIOService::Observe(nsISupports *subjec
if (data && NS_LITERAL_STRING("startup").Equals(data)) {
// Lazy initialization of network link service (see bug 620472)
InitializeNetworkLinkService();
// Set up the initilization flag regardless the actuall result.
// If we fail here, we will fail always on.
mNetworkLinkServiceInitialized = true;
// And now reflect the preference setting
- nsCOMPtr<nsIPrefBranch> prefBranch;
- GetPrefBranch(getter_AddRefs(prefBranch));
- PrefsChanged(prefBranch, MANAGE_OFFLINE_STATUS_PREF);
+ PrefsChanged(MANAGE_OFFLINE_STATUS_PREF);
// Bug 870460 - Read cookie database at an early-as-possible time
// off main thread. Hence, we have more chance to finish db query
// before something calls into the cookie service.
nsCOMPtr<nsISupports> cookieServ = do_GetService(NS_COOKIESERVICE_CONTRACTID);
}
} else if (!strcmp(topic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
// Remember we passed XPCOM shutdown notification to prevent any