From: various contributors
Subject: replace gconf backend with more complete mapping for lockdown feature
diff --git a/extensions/pref/Makefile.in b/extensions/pref/Makefile.in
--- a/extensions/pref/Makefile.in
+++ b/extensions/pref/Makefile.in
@@ -40,13 +40,13 @@ DEPTH = ../..
topsrcdir = @top_srcdir@
srcdir = @srcdir@
VPATH = @srcdir@
include $(DEPTH)/config/autoconf.mk
DIRS = autoconfig
-ifdef MOZ_ENABLE_GTK2
+ifdef MOZ_ENABLE_GCONF
DIRS += system-pref
endif
include $(topsrcdir)/config/rules.mk
diff --git a/extensions/pref/system-pref/src/Makefile.in b/extensions/pref/system-pref/src/Makefile.in
--- a/extensions/pref/system-pref/src/Makefile.in
+++ b/extensions/pref/system-pref/src/Makefile.in
@@ -38,47 +38,41 @@
DEPTH = ../../../..
topsrcdir = @top_srcdir@
srcdir = @srcdir@
VPATH = @srcdir@
include $(DEPTH)/config/autoconf.mk
MODULE = system-pref
-LIBRARY_NAME = system-pref_s
+LIBRARY_NAME = system-pref
ifneq ($(OS_ARCH),WINNT)
SHORT_LIBNAME = syspref
endif
# We want to force the creation of a static lib.
-FORCE_STATIC_LIB = 1
-LIBXUL_LIBRARY = 1
+#FORCE_STATIC_LIB = 1
+LIBXUL_LIBRARY = 1
+MODULE_NAME = nsSystemPrefModule
+IS_COMPONENT = 1
+EXPORT_LIBRARY = 1
REQUIRES = xpcom \
string \
embedcomponents \
pref \
$(NULL)
-ifdef MOZ_ENABLE_GTK2
-DIRS = gconf
-endif
+CPPSRCS = \
+ nsSystemPref.cpp \
+ nsSystemPrefFactory.cpp \
+ $(NULL)
EXTRA_DSO_LDOPTS = \
- -L$(DIST)/bin \
$(MOZ_COMPONENT_LIBS) \
$(NULL)
-CPPSRCS = \
- nsSystemPref.cpp \
- $(NULL)
-
EXPORTS = \
- nsSystemPrefLog.h \
+ nsISystemPrefService.h \
$(NULL)
include $(topsrcdir)/config/rules.mk
-ifdef MOZ_ENABLE_GTK2
-INCLUDES += \
- -I$(srcdir)/gconf \
- $(NULL)
-endif
diff --git a/extensions/pref/system-pref/src/gconf/Makefile.in b/extensions/pref/system-pref/src/gconf/Makefile.in
--- a/extensions/pref/system-pref/src/gconf/Makefile.in
+++ b/extensions/pref/system-pref/src/gconf/Makefile.in
@@ -37,50 +37,37 @@
DEPTH = ../../../../..
topsrcdir = @top_srcdir@
srcdir = @srcdir@
VPATH = @srcdir@
include $(DEPTH)/config/autoconf.mk
-MODULE = system-pref
-LIBRARY_NAME = system-pref
-LIBXUL_LIBRARY = 1
+MODULE = system-pref-gconf
+LIBRARY_NAME = system-pref-gconf
+IS_COMPONENT = 1
+MODULE_NAME = nsSystemPrefServiceModule
+FORCE_SHARED_LIB = 1
REQUIRES = pref \
string \
xpcom \
- embedcomponents \
+ necko \
$(NULL)
CPPSRCS = \
nsSystemPrefService.cpp \
- nsSystemPrefFactory.cpp \
$(NULL)
-SHARED_LIBRARY_LIBS = ../libsystem-pref_s.a
+OS_INCLUDES += $(MOZ_GCONF_CFLAGS)
+
EXTRA_DSO_LDOPTS = \
- -L$(DIST)/bin \
- $(MOZ_COMPONENT_LIBS) \
- $(MOZ_GTK2_LIBS) \
+ $(XPCOM_GLUE_LDOPTS) \
+ $(MOZ_GCONF_LIBS) \
+ $(NSPR_LIBS) \
$(NULL)
-EXPORT_LIBRARY = 1
-IS_COMPONENT = 1
-MODULE_NAME = nsSystemPrefModule
-
-EXPORTS = \
- nsSystemPrefService.h \
- $(NULL)
include $(topsrcdir)/config/rules.mk
-CFLAGS += $(MOZ_GTK2_CFLAGS)
-CXXFLAGS += $(MOZ_GTK2_CFLAGS)
-
-LOCAL_INCLUDES = -I$(srcdir)/..
-
-export::
- $(INSTALL) $(srcdir)/../nsSystemPrefFactory.cpp .
-
GARBAGE += nsSystemPrefFactory.cpp
diff --git a/extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp b/extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp
--- a/extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp
+++ b/extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp
@@ -18,17 +18,19 @@
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is Sun Microsystems, Inc.
* Portions created by Sun Microsystems are Copyright (C) 2003 Sun
* Microsystems, Inc. All Rights Reserved.
*
* Original Author: Bolian Yin (bolian.yin@sun.com)
*
- * Contributor(s):
+ * Contributor(s): Robert O'Callahan/Novell (rocallahan@novell.com)
+ * Hubert Figuiere (hfiguiere@novell.com)
+ * Wolfgang Rosenauer (wr@rosenauer.org)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
@@ -36,299 +38,1300 @@
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include <glib.h>
#include <glib-object.h>
+#include <gconf/gconf-client.h>
#include "plstr.h"
#include "nsCOMPtr.h"
-#include "nsIPrefBranch.h"
-#include "nsIPrefService.h"
+#include "nsIPref.h"
#include "nsIServiceManager.h"
#include "nsIObserver.h"
#include "nsWeakReference.h"
+#include "nsIPrefBranch2.h"
+#include "nsDataHashtable.h"
+#include "nsHashKeys.h"
+#include "nsICategoryManager.h"
+#include "nsIGenericFactory.h"
+#include "nsStringAPI.h"
+#include "nsIPermissionManager.h"
+#include "../nsSystemPref.h"
-#include "nsString.h"
-#include "nsSystemPrefLog.h"
-#include "nsSystemPrefService.h"
+#define NS_SYSTEMPREF_SERVICE_CID \
+ { /* {3724e748-b088-4bf8-9298-aad426b66293} */ \
+ 0x3724e748, \
+ 0xb088, \
+ 0x4bf8, \
+ { 0x92, 0x98, 0xaa, 0xd4, 0x26, 0xb6, 0x62, 0x93 } \
+ }
-/*************************************************************************
- * The strange thing here is that we load the gconf library manually and
- * search the function pointers we need. If that process fails, no gconf
- * support is available in mozilla. The aim is to make mozilla independent
- * on gconf, in both compile time and run time.
- ************************************************************************/
+#define NS_SYSTEMPREF_SERVICE_CLASSNAME "System Preferences Platform Service"
-//gconf types
-extern "C" {
+NS_DEFINE_STATIC_IID_ACCESSOR(nsISystemPrefService, NS_ISYSTEMPREFSERVICE_IID)
- typedef enum {
- GCONF_VALUE_INVALID,
- GCONF_VALUE_STRING,
- GCONF_VALUE_INT,
- GCONF_VALUE_FLOAT,
- GCONF_VALUE_BOOL,
- GCONF_VALUE_SCHEMA,
+/**
+ * We can link directly to the gconf library. If it's not available,
+ * this component just won't load and no system prefs will be offered.
+ */
- GCONF_VALUE_LIST,
- GCONF_VALUE_PAIR
+#define NUM_ELEM(a) (sizeof(a)/sizeof(a[0]))
- }GConfValueType;
+class nsSystemPrefService;
- typedef struct {
- GConfValueType type;
- }GConfValue;
+/**
+ * List the preferences that have a simple mapping between Moz and gconf.
+ * These preferences have the same meaning and their values are
+ * automatically converted.
+ */
+struct SimplePrefMapping {
+ const char *mozPrefName;
+ const char *gconfPrefName;
+ /**
+ * If this is PR_FALSE, then we never allow Mozilla to change
+ * this setting. The Mozilla pref will always be locked.
+ * If this is PR_TRUE then Mozilla will be allowed to change
+ * the setting --- but only if it is writable in gconf.
+ */
+ PRBool allowWritesFromMozilla;
+};
+typedef nsresult (* ComplexGConfPrefChanged)(nsSystemPrefService* aPrefService,
+ GConfClient* aClient);
+typedef nsresult (* ComplexMozPrefChanged)(nsSystemPrefService* aPrefService,
+ GConfClient* aClient);
+struct ComplexGConfPrefMapping {
+ const char* gconfPrefName;
+ ComplexGConfPrefChanged callback;
+};
- typedef void * (*GConfClientGetDefaultType) (void);
- typedef PRBool (*GConfClientGetBoolType) (void *client, const gchar *key,
- GError **err);
- typedef gchar* (*GConfClientGetStringType) (void *client, const gchar *key,
- GError **err);
- typedef PRInt32 (*GConfClientGetIntType) (void *client, const gchar *key,
- GError **err);
- typedef GSList* (*GConfClientGetListType) (void *client, const gchar *key,
- GConfValueType list_type,
- GError **err);
- typedef void (*GConfClientNotifyFuncType) (void* client, guint cnxn_id,
- void *entry,
- gpointer user_data);
- typedef guint (*GConfClientNotifyAddType) (void* client,
- const gchar* namespace_section,
- GConfClientNotifyFuncType func,
- gpointer user_data,
- GFreeFunc destroy_notify,
- GError** err);
- typedef void (*GConfClientNotifyRemoveType) (void *client,
- guint cnxn);
- typedef void (*GConfClientAddDirType) (void *client,
- const gchar *dir,
- guint8 preload,
- GError **err);
- typedef void (*GConfClientRemoveDirType) (void *client,
- const gchar *dir,
- GError **err);
+struct ComplexMozPrefMapping {
+ const char* mozPrefName;
+ ComplexMozPrefChanged callback;
+};
- typedef const char* (*GConfEntryGetKeyType) (const void *entry);
- typedef GConfValue* (*GConfEntryGetValueType) (const void *entry);
+class nsSystemPrefService : public nsISystemPrefService, nsIPrefBranch
+ {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIPREFBRANCH
- typedef const char* (*GConfValueGetStringType) (const GConfValue *value);
- typedef PRInt32 (*GConfValueGetIntType) (const GConfValue *value);
- typedef PRBool (*GConfValueGetBoolType) (const GConfValue *value);
+ nsresult Init();
-
- static void gconf_key_listener (void* client, guint cnxn_id,
- void *entry, gpointer user_data);
-}
+ virtual nsresult LoadSystemPreferences(nsISystemPref* aPrefs);
+ virtual nsresult NotifyMozillaPrefChanged(const char* aPrefName);
+ virtual nsresult NotifyUnloadSystemPreferences();
-struct GConfCallbackData
-{
- GConfProxy *proxy;
- void * userData;
- PRUint32 atom;
- PRUint32 notifyId;
-};
-//////////////////////////////////////////////////////////////////////
-// GConPrxoy is a thin wrapper for easy use of gconf funcs. It loads the
-// gconf library and initializes the func pointers for later use.
-//////////////////////////////////////////////////////////////////////
-class GConfProxy
-{
-public:
- GConfProxy(nsSystemPrefService* aSysPrefService);
- ~GConfProxy();
- PRBool Init();
+ nsSystemPrefService();
+ virtual ~nsSystemPrefService();
- nsresult GetBoolPref(const char *aMozKey, PRBool *retval);
- nsresult GetCharPref(const char *aMozKey, char **retval);
- nsresult GetIntPref(const char *aMozKey, PRInt32 *retval);
-
- nsresult NotifyAdd (PRUint32 aAtom, void *aUserData);
- nsresult NotifyRemove (PRUint32 aAtom, const void *aUserData);
-
- nsresult GetAtomForMozKey(const char *aMozKey, PRUint32 *aAtom) {
- return GetAtom(aMozKey, 0, aAtom);
+ nsISystemPref* GetPrefs() { return mPref; }
+ SimplePrefMapping* GetSimpleCallbackData(PRUint32 aKey) {
+ SimplePrefMapping* result = nsnull;
+ mGConfSimpleCallbacks.Get(aKey, &result);
+ return result;
}
- const char *GetMozKey(PRUint32 aAtom) {
- return GetKey(aAtom, 0);
- }
-
- void OnNotify(void *aClient, void * aEntry, PRUint32 aNotifyId,
- GConfCallbackData *aData);
+ ComplexGConfPrefMapping* GetComplexCallbackData(PRUint32 aKey) {
+ ComplexGConfPrefMapping* result = nsnull;
+ mGConfComplexCallbacks.Get(aKey, &result);
+ return result;
+ }
private:
- void *mGConfClient;
- PRLibrary *mGConfLib;
- PRBool mInitialized;
- nsSystemPrefService *mSysPrefService;
+ nsISystemPref* mPref;
+ nsDataHashtable<nsUint32HashKey, SimplePrefMapping*> mGConfSimpleCallbacks;
+ nsDataHashtable<nsUint32HashKey, ComplexGConfPrefMapping*> mGConfComplexCallbacks;
+ // This is set to PR_FALSE temporarily to stop listening to gconf
+ // change notifications (while we change gconf values)
+ PRPackedBool mListenToGConf;
- //listeners
- nsAutoVoidArray *mObservers;
-
- void InitFuncPtrs();
- //gconf public func ptrs
-
- //gconf client funcs
- GConfClientGetDefaultType GConfClientGetDefault;
- GConfClientGetBoolType GConfClientGetBool;
- GConfClientGetStringType GConfClientGetString;
- GConfClientGetIntType GConfClientGetInt;
- GConfClientGetListType GConfClientGetList;
- GConfClientNotifyAddType GConfClientNotifyAdd;
- GConfClientNotifyRemoveType GConfClientNotifyRemove;
- GConfClientAddDirType GConfClientAddDir;
- GConfClientRemoveDirType GConfClientRemoveDir;
-
- //gconf entry funcs
- GConfEntryGetValueType GConfEntryGetValue;
- GConfEntryGetKeyType GConfEntryGetKey;
-
- //gconf value funcs
- GConfValueGetBoolType GConfValueGetBool;
- GConfValueGetStringType GConfValueGetString;
- GConfValueGetIntType GConfValueGetInt;
-
- //pref name translating stuff
- nsresult GetAtom(const char *aKey, PRUint8 aNameType, PRUint32 *aAtom);
- nsresult GetAtomForGConfKey(const char *aGConfKey, PRUint32 *aAtom) \
- {return GetAtom(aGConfKey, 1, aAtom);}
- const char *GetKey(PRUint32 aAtom, PRUint8 aNameType);
- const char *GetGConfKey(PRUint32 aAtom) \
- {return GetKey(aAtom, 1); }
- inline const char *MozKey2GConfKey(const char *aMozKey);
-
- //const strings
- static const char sPrefGConfKey[];
- static const char sDefaultLibName1[];
- static const char sDefaultLibName2[];
+ GConfValue* GConfGet(const char *aPrefName);
};
-struct SysPrefCallbackData {
- nsISupports *observer;
- PRBool bIsWeakRef;
- PRUint32 prefAtom;
-};
-
-PRBool
-sysPrefDeleteObserver(void *aElement, void *aData) {
- SysPrefCallbackData *pElement =
- static_cast<SysPrefCallbackData *>(aElement);
- NS_RELEASE(pElement->observer);
- nsMemory::Free(pElement);
- return PR_TRUE;
-}
-
-NS_IMPL_ISUPPORTS2(nsSystemPrefService, nsIPrefBranch, nsIPrefBranch2)
-
-/* public */
nsSystemPrefService::nsSystemPrefService()
- :mInitialized(PR_FALSE),
- mGConf(nsnull),
- mObservers(nsnull)
+ : mPref(nsnull), mListenToGConf(PR_TRUE)
{
+ mGConfSimpleCallbacks.Init();
+ mGConfComplexCallbacks.Init();
}
nsSystemPrefService::~nsSystemPrefService()
{
- mInitialized = PR_FALSE;
-
- if (mGConf)
- delete mGConf;
- if (mObservers) {
- (void)mObservers->EnumerateForwards(sysPrefDeleteObserver, nsnull);
- delete mObservers;
- }
+ NotifyUnloadSystemPreferences();
}
nsresult
nsSystemPrefService::Init()
{
- if (!gSysPrefLog) {
- gSysPrefLog = PR_NewLogModule("Syspref");
- if (!gSysPrefLog) return NS_ERROR_OUT_OF_MEMORY;
+ return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS2(nsSystemPrefService,
+ nsISystemPrefService,
+ nsIPrefBranch)
+
+static GConfClient* GetGConf() {
+ return gconf_client_get_default();
+}
+
+static PRBool VerifyMatchingTypes(nsISystemPref* aPrefs,
+ const char* aMozPref, GConfValue* aVal)
+{
+ nsCOMPtr<nsIPrefBranch2> prefBranch = aPrefs->GetPrefUserBranch();
+ PRInt32 type;
+ nsresult rv = prefBranch->GetPrefType(aMozPref, &type);
+ if (NS_FAILED(rv)) {
+ // pref probably doesn't exist. Let gconf set it.
+ return PR_TRUE;
}
- SYSPREF_LOG(("Init SystemPref Service\n"));
- if (mInitialized)
+ PRBool ok;
+ switch (aVal->type) {
+ case GCONF_VALUE_STRING:
+ ok = type == nsIPrefBranch2::PREF_STRING;
+ break;
+ case GCONF_VALUE_INT:
+ ok = type == nsIPrefBranch2::PREF_INT;
+ break;
+ case GCONF_VALUE_BOOL:
+ ok = type == nsIPrefBranch2::PREF_BOOL;
+ break;
+ default:
+ NS_ERROR("Unhandled gconf preference type");
+ return PR_FALSE;
+ }
+
+ NS_ASSERTION(ok, "Mismatched gconf/Mozilla pref types");
+ return ok;
+}
+
+/**
+ * Map a gconf pref value into the corresponding Mozilla pref.
+ */
+static nsresult ApplySimpleMapping(SimplePrefMapping* aMap,
+ nsISystemPref* aPrefs,
+ GConfClient* aClient)
+{
+ GConfValue* val = gconf_client_get(aClient, aMap->gconfPrefName, nsnull);
+ if (!val) {
+ // No gconf key, so there's really nothing to do
+ return NS_OK;
+ }
+
+ VerifyMatchingTypes(aPrefs, aMap->mozPrefName, val);
+
+ PRBool locked = !aMap->allowWritesFromMozilla ||
+ !gconf_client_key_is_writable(aClient, aMap->gconfPrefName, nsnull);
+ nsresult rv;
+ switch (val->type) {
+ case GCONF_VALUE_STRING: {
+ const char* str = gconf_value_get_string(val);
+ rv = aPrefs->SetOverridingMozillaStringPref(aMap->mozPrefName, str, locked);
+ // XXX do we need to free 'str' here?
+ break;
+ }
+ case GCONF_VALUE_INT:
+ rv = aPrefs->SetOverridingMozillaIntPref(aMap->mozPrefName,
+ gconf_value_get_int(val), locked);
+ break;
+ case GCONF_VALUE_BOOL:
+ rv = aPrefs->SetOverridingMozillaBoolPref(aMap->mozPrefName,
+ gconf_value_get_bool(val), locked);
+ break;
+ default:
+ NS_ERROR("Unusable gconf value type");
+ rv = NS_ERROR_FAILURE;
+ break;
+ }
+
+ gconf_value_free(val);
+ return rv;
+}
+
+/**
+ * Map a Mozilla pref into the corresponding gconf pref, if
+ * that's allowed.
+ */
+static nsresult ReverseApplySimpleMapping(SimplePrefMapping* aMap,
+ nsISystemPref* aPrefs,
+ GConfClient* aClient)
+{
+ // Verify that the gconf key has the right type, if it exists
+ GConfValue* val = gconf_client_get(aClient, aMap->gconfPrefName, nsnull);
+ if (val) {
+ VerifyMatchingTypes(aPrefs, aMap->mozPrefName, val);
+ gconf_value_free(val);
+ }
+
+ PRBool writable = aMap->allowWritesFromMozilla &&
+ gconf_client_key_is_writable(aClient, aMap->gconfPrefName, nsnull);
+ if (!writable) {
+ NS_ERROR("Gconf key is not writable");
return NS_ERROR_FAILURE;
+ }
- if (!mGConf) {
- mGConf = new GConfProxy(this);
- if (!mGConf->Init()) {
- delete mGConf;
- mGConf = nsnull;
+ nsCOMPtr<nsIPrefBranch2> prefBranch = aPrefs->GetPrefUserBranch();
+ PRInt32 type;
+ nsresult rv = prefBranch->GetPrefType(aMap->mozPrefName, &type);
+ if (NS_FAILED(rv)) {
+ NS_ERROR("Writing back a pref that doesn't exist?");
+ return rv;
+ }
+
+ switch (type) {
+ case nsIPrefBranch2::PREF_STRING:
+ {
+ char* result;
+ rv = prefBranch->GetCharPref(aMap->mozPrefName, &result);
+ if (NS_FAILED(rv))
+ return rv;
+
+ gconf_client_set_string(aClient, aMap->gconfPrefName, result, nsnull);
+ nsMemory::Free(result);
+ }
+ break;
+ case nsIPrefBranch2::PREF_INT:
+ {
+ PRInt32 result;
+ rv = prefBranch->GetIntPref(aMap->mozPrefName, &result);
+ if (NS_FAILED(rv))
+ return rv;
+
+ gconf_client_set_int(aClient, aMap->gconfPrefName, result, nsnull);
+ }
+ break;
+ case nsIPrefBranch2::PREF_BOOL:
+ {
+ PRBool result;
+ rv = prefBranch->GetBoolPref(aMap->mozPrefName, &result);
+ if (NS_FAILED(rv))
+ return rv;
+
+ gconf_client_set_bool(aClient, aMap->gconfPrefName, result, nsnull);
+ }
+ break;
+ default:
+ NS_ERROR("Unhandled gconf preference type");
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+/* BEGIN preference mapping definition area
+ *
+ * There are a few rules that our preference maps have to obey:
+ *
+ * 1) Each mapping defines a relationship R between a set of GConf preferences and
+ * a set of Mozilla preferences that must *always* be true. Thus, when a Mozilla
+ * pref changes or a gconf pref changes, we may need to change something on the
+ * other side to preserve R. If a GConf preference is read-only, then we may
+ * need to lock one or more Mozilla preferences to avoid a situation where the
+ * Mozilla preference changes and we can't update the GConf preference to
+ * ensure R continues to hold.
+ *
+ * 2) If an unlocked Mozilla preference is changed, then we can only
+ * preserve R by changing GConf preferences; we are not allowed to
+ * change Mozilla preferences.
+ *
+ * 3) If a GConf preference is changed, then we can only preserve R by
+ * changing Moozilla preferences; we are nt allowed to change GConf
+ * preferences.
+ *
+ * For "simple" mappings, the relationship R is just of the form
+ * "GConf preference 'A' is equal to Mozilla preference 'B'". R is
+ * preserved by setting A to B when B changes, and by setting B to A
+ * when A changes. If A is read-only then we lock B (or we may just
+ * decide to lock B for other reasons). Thus rules 1-3 are satisfied.
+ *
+ * For "complex" mappings we have more complicated
+ * relationships. These are documented below.
+ */
+
+static SimplePrefMapping sSimplePrefMappings[] = {
+ // GNOME accessibility setting; never allow this to be set by Firefox
+ {"config.use_system_prefs.accessibility",
+ "/desktop/gnome/interface/accessibility", PR_FALSE},
+
+ // GConf Firefox preferences; allow these to be set through the Firefox UI
+ {"security.enable_java", "/apps/firefox/web/java_enabled", PR_TRUE},
+ {"javascript.enabled", "/apps/firefox/web/javascript_enabled", PR_TRUE},
+ {"browser.startup.homepage", "/apps/firefox/general/homepage_url", PR_TRUE},
+ {"browser.cache.disk.capacity", "/apps/firefox/web/cache_size", PR_TRUE},
+ {"network.cookie.lifetimePolicy", "/apps/firefox/web/cookie_accept", PR_TRUE},
+
+ // UI lockdown settings; never allow these to be set by Firefox. There is no
+ // Firefox UI for these but they could otherwise be set via about:config.
+ {"config.lockdown.printing", "/desktop/gnome/lockdown/disable_printing", PR_FALSE},
+ {"config.lockdown.printsetup", "/desktop/gnome/lockdown/disable_print_setup", PR_FALSE},
+ {"config.lockdown.savepage", "/desktop/gnome/lockdown/disable_save_to_disk", PR_FALSE},
+ {"config.lockdown.history", "/apps/firefox/lockdown/disable_history", PR_FALSE},
+ {"config.lockdown.toolbarediting", "/apps/firefox/lockdown/disable_toolbar_editing", PR_FALSE},
+ {"config.lockdown.urlbar", "/apps/firefox/lockdown/disable_url_bar", PR_FALSE},
+ {"config.lockdown.bookmark", "/apps/firefox/lockdown/disable_bookmark_editing", PR_FALSE},
+ {"config.lockdown.disable_themes", "/apps/firefox/lockdown/disable_themes", PR_FALSE},
+ {"config.lockdown.disable_extensions", "/apps/firefox/lockdown/disable_extensions", PR_FALSE},
+ {"config.lockdown.searchbar", "/apps/firefox/lockdown/disable_searchbar", PR_FALSE},
+ {"config.lockdown.hidebookmark", "/apps/firefox/lockdown/hide_bookmark", PR_FALSE},
+ {"config.lockdown.showsavedpasswords", "/apps/firefox/lockdown/disable_show_passwords", PR_FALSE},
+};
+
+static nsresult ApplyListPref(nsSystemPrefService* aPrefService,
+ GConfClient* aClient,
+ const char* aGConfKey, const char* aMozKey,
+ char aSeparator)
+{
+ GSList* list = gconf_client_get_list(aClient, aGConfKey,
+ GCONF_VALUE_STRING, nsnull);
+ nsCAutoString str;
+ for (GSList* l = list; l; l = l->next) {
+ str.Append((const char*)l->data);
+ if (l->next) {
+ str.Append(aSeparator);
+ }
+ }
+ PRBool lock = !gconf_client_key_is_writable(aClient, aGConfKey, nsnull);
+ nsresult rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaStringPref(aMozKey, str.get(), lock);
+ // XXX does this free the strings? Should it?
+ g_slist_free(list);
+ return rv;
+}
+static nsresult ReverseApplyListPref(nsSystemPrefService* aPrefService,
+ GConfClient* aClient,
+ const char* aGConfKey, const char* aMozKey,
+ char aSeparator)
+{
+ char* data = nsnull;
+ nsCOMPtr<nsIPrefBranch2> prefs =
+ aPrefService->GetPrefs()->GetPrefUserBranch();
+ prefs->GetCharPref(aMozKey, &data);
+ if (!data)
+ return NS_ERROR_FAILURE;
+ nsresult rv = NS_OK;
+ GSList* list = nsnull;
+ PRInt32 i = 0;
+ while (data[i]) {
+ const char* nextComma = strchr(data+i, ',');
+ PRInt32 tokLen = nextComma ? nextComma - (data+i) : strlen(data+i);
+ char* tok = strndup(data+i, tokLen);
+ if (!tok)
+ break;
+ GSList* newList = g_slist_append(list, tok);
+ if (!newList) {
+ rv = NS_ERROR_OUT_OF_MEMORY;
+ break;
+ }
+ list = newList;
+ if (!nextComma)
+ break;
+ i = nextComma + 1 - data;
+ }
+ nsMemory::Free(data);
+ if (NS_SUCCEEDED(rv)) {
+ if (gconf_client_key_is_writable(aClient, aGConfKey, nsnull))
+ gconf_client_set_list(aClient, aGConfKey, GCONF_VALUE_STRING, list, nsnull);
+ else
+ NS_ERROR("Gconf key is not writable");
+ }
+ for (GSList* l = list; l; l = l->next) {
+ free(l->data);
+ }
+ g_slist_free(list);
+ return rv;
+}
+
+/**
+ * The relationship R is
+ * "network.negotiate-auth.trusted-uris" is the comma-separated concatenation
+ * of the elements of the list "/apps/firefox/general/trusted_URIs"
+ */
+static const char GConfKey_TrustedURIs[] = "/apps/firefox/general/trusted_URIs";
+static const char MozKey_TrustedURIs[] = "network.negotiate-auth.trusted-uris";
+static nsresult ApplyTrustedURIs(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ return ApplyListPref(aPrefService, aClient,
+ GConfKey_TrustedURIs, MozKey_TrustedURIs, ',');
+}
+static nsresult ReverseApplyTrustedURIs(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ return ReverseApplyListPref(aPrefService, aClient,
+ GConfKey_TrustedURIs, MozKey_TrustedURIs, ',');
+}
+
+/**
+ * The relationship R is
+ * "network.negotiate-auth.delegation-uris" is the comma-separated concatenation
+ * of the elements of the list "/apps/firefox/general/delegation_URIs"
+ */
+static const char GConfKey_DelegationURIs[] = "/apps/firefox/general/delegation_URIs";
+static const char MozKey_DelegationURIs[] = "network.negotiate-auth.delegation-uris";
+static nsresult ApplyDelegationURIs(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ return ApplyListPref(aPrefService, aClient,
+ GConfKey_DelegationURIs, MozKey_DelegationURIs, ',');
+}
+static nsresult ReverseApplyDelegationURIs(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ return ReverseApplyListPref(aPrefService, aClient,
+ GConfKey_DelegationURIs, MozKey_DelegationURIs, ',');
+}
+
+
+/**
+ * The relationship R is
+ * If "/apps/firefox/web/download_defaultfolder" is the empty string, then
+ * "browser.download.useDownloadDir" is false;
+ * otherwise "browser.download.useDownloadDir" is true and "browser.download.folderList"
+ * is (0 if "/apps/firefox/web/download_defaultfolder" is "Desktop";
+ * 1 if "/apps/firefox/web/download_defaultfolder" is "My Downloads";
+ * 3 if "/apps/firefox/web/download_defaultfolder" is "Home";
+ * otherwise 2 and "browser.download.dir" = "/apps/firefox/web/download_defaultfolder")
+ */
+static const char GConfKey_DownloadFolder[] = "/apps/firefox/web/download_defaultfolder";
+static const char MozKey_UseDownloadDir[] = "browser.download.useDownloadDir";
+static const char MozKey_DownloadDirType[] = "browser.download.folderList";
+static const char MozKey_DownloadDirExplicit[] = "browser.download.dir";
+static nsresult ApplyDownloadFolder(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ char* str = gconf_client_get_string(aClient, GConfKey_DownloadFolder, nsnull);
+ if (!str)
+ return NS_ERROR_FAILURE;
+ PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_DownloadFolder, nsnull);
+ nsresult rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(MozKey_UseDownloadDir, *str != 0, lock);
+ if (NS_FAILED(rv)) {
+ g_free(str);
+ return rv;
+ }
+ PRInt32 dirType = 0;
+ if (!strcmp(str, "Desktop")) {
+ dirType = 0;
+ } else if (!strcmp(str, "My Downloads")) {
+ dirType = 1;
+ } else if (!strcmp(str, "Home")) {
+ dirType = 3;
+ } else {
+ dirType = 2;
+ }
+ // Always set all three Mozilla preferences. This is simpler and avoids
+ // problems; e.g., if the gconf value changes from "/home/rocallahan" to "Desktop"
+ // we might leave MozKey_DownloadDirType accidentally locked.
+ rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaIntPref(MozKey_DownloadDirType, dirType, lock);
+ if (NS_SUCCEEDED(rv)) {
+ rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaStringPref(MozKey_DownloadDirExplicit, str, lock);
+ }
+ g_free(str);
+ return rv;
+}
+
+static nsresult ReverseApplyDownloadFolder(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ PRBool useDownloadDir = PR_FALSE;
+ const char* result;
+ char* explicitStr = nsnull;
+ nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();
+ prefs->GetBoolPref(MozKey_UseDownloadDir, &useDownloadDir);
+ if (!useDownloadDir) {
+ result = "";
+ } else {
+ PRInt32 type = -1;
+ prefs->GetIntPref(MozKey_DownloadDirType, &type);
+ if (type < 0)
+ return NS_ERROR_FAILURE;
+ switch (type) {
+ case 0: result = "Desktop"; break;
+ case 1: result = "Downloads"; break;
+ case 2:
+ prefs->GetCharPref(MozKey_DownloadDirExplicit, &explicitStr);
+ result = explicitStr;
+ break;
+ case 3: result = "Home"; break;
+ default:
+ NS_ERROR("Unknown download dir type");
return NS_ERROR_FAILURE;
}
}
+ if (!result)
+ return NS_ERROR_FAILURE;
+ if (gconf_client_key_is_writable(aClient, GConfKey_DownloadFolder, nsnull))
+ gconf_client_set_string(aClient, GConfKey_DownloadFolder,
+ result, nsnull);
+ else
+ NS_ERROR("Gconf key is not writable");
+ nsMemory::Free(explicitStr);
+ return NS_OK;
+}
- mInitialized = PR_TRUE;
+/**
+ * The relationship R is
+ * "/apps/firefox/web/disable_cookies" is true if and only if
+ * "network.cookie.cookieBehavior" is 2 ('dontUse')
+ */
+static const char GConfKey_DisableCookies[] = "/apps/firefox/web/disable_cookies";
+static const char MozKey_CookieBehavior[] = "network.cookie.cookieBehavior";
+static const char MozKey_CookieExceptions[] = "network.cookie.honorExceptions";
+static const char MozKey_CookieViewExceptions[] = "pref.privacy.disable_button.cookie_exceptions";
+static nsresult ApplyDisableCookies(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ gboolean disable = gconf_client_get_bool(aClient, GConfKey_DisableCookies, nsnull);
+ PRInt32 behavior = -1;
+ nsCOMPtr<nsIPrefBranch2> prefs =
+ aPrefService->GetPrefs()->GetPrefUserBranch();
+ prefs->GetIntPref(MozKey_CookieBehavior, &behavior);
+ if (behavior < 0)
+ return NS_ERROR_FAILURE;
+ if (disable) {
+ behavior = 2;
+ } else {
+ if (behavior == 2) {
+ behavior = 0;
+ }
+ }
+ PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_DisableCookies, nsnull);
+ nsresult rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(MozKey_CookieExceptions, !lock, lock);
+ if (NS_FAILED(rv))
+ return rv;
+ rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(MozKey_CookieViewExceptions, lock, lock);
+ if (NS_FAILED(rv))
+ return rv;
+ return aPrefService->GetPrefs()->
+ SetOverridingMozillaIntPref(MozKey_CookieBehavior, behavior, lock);
+}
+static nsresult ReverseApplyDisableCookies(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ PRInt32 behavior = -1;
+ nsCOMPtr<nsIPrefBranch2> prefs =
+ aPrefService->GetPrefs()->GetPrefUserBranch();
+ prefs->GetIntPref(MozKey_CookieBehavior, &behavior);
+ if (behavior < 0)
+ return NS_ERROR_FAILURE;
+ if (gconf_client_key_is_writable(aClient, GConfKey_DisableCookies, nsnull))
+ gconf_client_set_bool(aClient, GConfKey_DisableCookies, behavior == 2, nsnull);
+ else
+ NS_ERROR("Gconf key is not writable");
return NS_OK;
}
+static char const* windowOpenFeatures[] = {
+ "dom.disable_window_open_feature.close",
+ "dom.disable_window_open_feature.directories",
+ "dom.disable_window_open_feature.location",
+ "dom.disable_window_open_feature.menubar",
+ "dom.disable_window_open_feature.minimizable",
+ "dom.disable_window_open_feature.personalbar",
+ "dom.disable_window_open_feature.resizable",
+ "dom.disable_window_open_feature.scrollbars",
+ "dom.disable_window_open_feature.status",
+ "dom.disable_window_open_feature.titlebar",
+ "dom.disable_window_open_feature.toolbar"
+};
+/**
+ * The relationship R is
+ * "/apps/firefox/lockdown/disable_javascript_chrome" is true if and only if
+ * all of windowOpenFeatures are true
+ */
+static const char GConfKey_DisableJSChrome[] =
+ "/apps/firefox/lockdown/disable_javascript_chrome";
+static nsresult ApplyWindowOpen(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ gboolean disable = gconf_client_get_bool(aClient, GConfKey_DisableJSChrome, nsnull);
+ PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_DisableJSChrome, nsnull);
+ PRBool curValues[NUM_ELEM(windowOpenFeatures)];
+ PRUint32 i;
+ nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();
+ PRBool allDisabled = PR_TRUE;
+ for (i = 0; i < NUM_ELEM(windowOpenFeatures); ++i) {
+ nsresult rv = prefs->GetBoolPref(windowOpenFeatures[i], &curValues[i]);
+ if (NS_FAILED(rv))
+ return rv;
+ if (!curValues[i]) {
+ allDisabled = PR_FALSE;
+ }
+ }
+ for (i = 0; i < NUM_ELEM(windowOpenFeatures); ++i) {
+ PRBool newVal = curValues[i];
+ if (disable) {
+ newVal = PR_TRUE;
+ } else if (allDisabled) {
+ // If all disable-window-open-feature prefs are currently
+ // PR_TRUE, then we need to set at least one of them to
+ // PR_FALSE. Set all of them to PR_FALSE.
+ newVal = PR_FALSE;
+ } // If at least one disable-window-open-feature pref is
+ // currently PR_FALSE, then we don't need to change anything
+ // when the gconf pref says don't disable
+ nsresult rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(windowOpenFeatures[i], newVal, lock);
+ if (NS_FAILED(rv))
+ return rv;
+ }
+ return NS_OK;
+}
+
+static nsresult ReverseApplyWindowOpen(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();
+ PRBool allDisabled = PR_TRUE;
+ PRBool curValues[NUM_ELEM(windowOpenFeatures)];
+ for (PRUint32 i = 0; i < NUM_ELEM(windowOpenFeatures); ++i) {
+ nsresult rv = prefs->GetBoolPref(windowOpenFeatures[i], &curValues[i]);
+ if (NS_FAILED(rv))
+ return rv;
+ if (!curValues[i]) {
+ allDisabled = PR_FALSE;
+ }
+ }
+ if (gconf_client_key_is_writable(aClient, GConfKey_DisableJSChrome, nsnull))
+ gconf_client_set_bool(aClient, GConfKey_DisableJSChrome, allDisabled, nsnull);
+ else
+ NS_ERROR("Gconf key is not writable");
+ return NS_OK;
+}
+
+/**
+ * The relationship R is
+ * If "/apps/firefox/lockdown/disable_unsafe_protocol" is true then
+ * -- "network.protocol-handler.blocked-default" is true
+ * -- "network.protocol-handler.blocked.XYZ" is false if and only if
+ * XYZ is a builtin non-disablable protocol or in
+ * "/apps/firefox/lockdown/additional_safe_protocols"
+ * AND if "/apps/firefox/lockdown/disable_unsafe_protocol" is false then
+ * -- "network.protocol-handler.blocked-default" is false
+ * -- if "network.protocol-handler.blocked.XYZ" exists then it is false
+ */
+static const char GConfKey_DisableUnsafeProtocols[] =
+ "/apps/firefox/lockdown/disable_unsafe_protocol";
+static const char GConfKey_AdditionalSafeProtocols[] =
+ "/apps/firefox/lockdown/additional_safe_protocols";
+static const char MozKey_BlockedDefault[] =
+ "network.protocol-handler.blocked-default";
+static const char MozKey_BlockedPrefix[] =
+ "network.protocol-handler.blocked.";
+static const char* nonDisablableBuiltinProtocols[] =
+ { "about", "data", "jar", "keyword", "resource", "viewsource",
+ "chrome", "moz-icon", "javascript", "file" };
+static PRBool FindString(const char** aList, PRInt32 aCount,
+ const char* aStr)
+{
+ for (PRInt32 i = 0; i < aCount; ++i) {
+ if (!strcmp(aStr, aList[i]))
+ return PR_TRUE;
+ }
+ return PR_FALSE;
+}
+typedef nsDataHashtable<nsCStringHashKey,int> StringSet;
+/** Collect the set of protocol names that we want to set preferences for */
+static nsresult AddAllProtocols(nsSystemPrefService* aPrefService,
+ const char* aSafeProtocols,
+ StringSet* aProtocolSet,
+ StringSet* aSafeSet)
+{
+ nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();
+ PRUint32 childCount;
+ char **childArray = nsnull;
+ nsresult rv = prefs->GetChildList(MozKey_BlockedPrefix, &childCount, &childArray);
+ if (NS_FAILED(rv))
+ return rv;
+ PRUint32 i;
+ for (i = 0; i < childCount; ++i) {
+ nsDependentCString tmp(childArray[i] + NUM_ELEM(MozKey_BlockedPrefix)-1);
+ aProtocolSet->Put(tmp, 1); // copies
+ }
+ for (i = 0; i < NUM_ELEM(nonDisablableBuiltinProtocols); ++i) {
+ nsDependentCString tmp(nonDisablableBuiltinProtocols[i]);
+ aProtocolSet->Put(tmp, 1);
+ }
+ i = 0;
+ while (aSafeProtocols[i]) {
+ const char* nextComma = strchr(aSafeProtocols+i, ',');
+ PRUint32 tokLen = nextComma ? nextComma - (aSafeProtocols+i)
+ : strlen(aSafeProtocols+i);
+ nsCAutoString tok(aSafeProtocols+i, tokLen);
+ aProtocolSet->Put(tok, 1);
+ aSafeSet->Put(tok, 1);
+ if (nextComma) {
+ i = nextComma - aSafeProtocols + 1;
+ } else {
+ break;
+ }
+ }
+ NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(childCount, childArray);
+ return NS_OK;
+}
+
+struct ProtocolPrefClosure {
+ StringSet safeProtocolSet;
+ nsIPrefBranch2* prefs;
+ nsISystemPref* prefSetter;
+ PRPackedBool disableUnsafe;
+ PRPackedBool lock;
+};
+
+static PLDHashOperator PR_CALLBACK SetProtocolPref(const nsACString& aKey,
+ int aItem,
+ void* aClosure)
+{
+ ProtocolPrefClosure* closure = static_cast<ProtocolPrefClosure*>(aClosure);
+ const nsCString& protocol = PromiseFlatCString(aKey);
+ PRBool blockProtocol = PR_FALSE;
+ if (closure->disableUnsafe &&
+ !FindString(nonDisablableBuiltinProtocols,
+ NUM_ELEM(nonDisablableBuiltinProtocols), protocol.get()) &&
+ !closure->safeProtocolSet.Get(aKey, nsnull)) {
+ blockProtocol = PR_TRUE;
+ }
+
+ nsCAutoString prefName;
+ prefName.Append(MozKey_BlockedPrefix);
+ prefName.Append(protocol);
+ closure->prefSetter->SetOverridingMozillaBoolPref(prefName.get(), blockProtocol,
+ closure->lock);
+ return PL_DHASH_NEXT;
+}
+static nsresult ApplyUnsafeProtocols(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_DisableUnsafeProtocols, nsnull)
+ || !gconf_client_key_is_writable(aClient, GConfKey_AdditionalSafeProtocols, nsnull);
+ gboolean disable = gconf_client_get_bool(aClient, GConfKey_DisableUnsafeProtocols, nsnull);
+ char* protocols = gconf_client_get_string(aClient, GConfKey_AdditionalSafeProtocols, nsnull);
+ if (!protocols)
+ return NS_ERROR_FAILURE;
+ nsresult rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(MozKey_BlockedDefault, disable, lock);
+ StringSet protocolSet;
+ ProtocolPrefClosure closure;
+ protocolSet.Init();
+ closure.safeProtocolSet.Init();
+ if (NS_SUCCEEDED(rv)) {
+ rv = AddAllProtocols(aPrefService, protocols, &protocolSet,
+ &closure.safeProtocolSet);
+ }
+ if (NS_SUCCEEDED(rv)) {
+ closure.disableUnsafe = disable;
+ closure.lock = lock;
+ closure.prefSetter = aPrefService->GetPrefs();
+ nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();
+ closure.prefs = prefs;
+ protocolSet.EnumerateRead(SetProtocolPref, &closure);
+ }
+ g_free(protocols);
+ return rv;
+}
+
+static nsresult ReverseApplyUnsafeProtocols(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();
+ PRBool blockedDefault;
+ nsresult rv = prefs->GetBoolPref(MozKey_BlockedDefault, &blockedDefault);
+ if (NS_FAILED(rv))
+ return rv;
+ nsCAutoString enabledProtocols;
+ PRUint32 childCount;
+ char **childArray = nsnull;
+ rv = prefs->GetChildList(MozKey_BlockedPrefix, &childCount, &childArray);
+ if (NS_FAILED(rv))
+ return rv;
+ for (PRUint32 i = 0; i < childCount; ++i) {
+ PRBool val = PR_FALSE;
+ prefs->GetBoolPref(childArray[i], &val);
+ if (val) {
+ if (enabledProtocols.Length() > 0) {
+ enabledProtocols.Append(',');
+ }
+ enabledProtocols.Append(childArray[i] + NUM_ELEM(MozKey_BlockedPrefix)-1);
+ }
+ }
+ NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(childCount, childArray);
+ if (gconf_client_key_is_writable(aClient, GConfKey_DisableUnsafeProtocols, nsnull) &&
+ gconf_client_key_is_writable(aClient, GConfKey_AdditionalSafeProtocols, nsnull)) {
+ gconf_client_set_bool(aClient, GConfKey_DisableUnsafeProtocols, blockedDefault, nsnull);
+ gconf_client_set_string(aClient, GConfKey_AdditionalSafeProtocols,
+ enabledProtocols.get(), nsnull);
+ } else {
+ NS_ERROR("Gconf key is not writable");
+ }
+ return NS_OK;
+}
+
+/**
+ * Set config.lockdown.setwallpaper if and only if
+ * /desktop/gnome/background/picture_filename is write-only. Always
+ * lock it.
+ */
+static const char MozKey_LockdownWallpaper[] = "config.lockdown.setwallpaper";
+static const char GConfKey_WallpaperSetting[] =
+ "/desktop/gnome/background/picture_filename";
+static nsresult ApplyWallpaper(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ PRBool canSetWallpaper =
+ gconf_client_key_is_writable(aClient, GConfKey_WallpaperSetting, nsnull);
+ return aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(MozKey_LockdownWallpaper,
+ !canSetWallpaper, PR_TRUE);
+}
+// No ReverseApplyWallpaper because this Mozilla pref can never be
+// modified
+
+/**
+ * The relationship R is
+ * "signon.rememberSignons" is true if and only if "/apps/firefox/web/disable_save_password"
+ * is false.
+ */
+static const char MozKey_RememberSignons[] = "signon.rememberSignons";
+static const char GConfKey_DisableSavePassword[] = "/apps/firefox/web/disable_save_password";
+static nsresult ApplyDisableSavePassword(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_DisableSavePassword, nsnull);
+ gboolean disable = gconf_client_get_bool(aClient, GConfKey_DisableSavePassword, nsnull);
+ return aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(MozKey_RememberSignons, !disable, lock);
+}
+
+static nsresult ReverseApplyDisableSavePassword(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();
+ PRBool remember;
+ nsresult rv = prefs->GetBoolPref(MozKey_RememberSignons, &remember);
+ if (NS_FAILED(rv))
+ return rv;
+ gconf_client_set_bool(aClient, GConfKey_DisableSavePassword, !remember, nsnull);
+ return NS_OK;
+}
+
+/**
+ * The relationship R is
+ * "permissions.default.image" is 1 (nsIPermissionManager::ALLOW_ACTION) if and only if
+ * "/apps/firefox/web/images_load" is 0, AND
+ * "permissions.default.image" is 2 (nsIPermissionManager::DENY_ACTION) if and only if
+ * "/apps/firefox/web/images_load" is 2, AND
+ * "permissions.default.image" is 3 if and only if "/apps/firefox/web/images_load" is 1
+ *
+ * Also, we set pref.advanced.images.disable_button.view_image iff
+ * /apps/firefox/web/images_load is read-only
+ * And we set permissions.default.honorExceptions iff
+ * /apps/firefox/web/images_load is not read-only
+ */
+static const char MozKey_ImagePermissions[] = "permissions.default.image";
+static const char MozKey_ImageExceptions[] = "permissions.honorExceptions.image";
+static const char MozKey_ImageViewExceptions[] = "pref.advanced.images.disable_button.view_image";
+static const char GConfKey_LoadImages[] = "/apps/firefox/web/images_load";
+static nsresult ApplyLoadImages(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_LoadImages, nsnull);
+ // 0 == accept, 1 == no-foreign, 2 == reject
+ gint setting = gconf_client_get_int(aClient, GConfKey_LoadImages, nsnull);
+ PRInt32 pref;
+ switch (setting) {
+ case 0: pref = nsIPermissionManager::ALLOW_ACTION; break;
+ case 2: pref = nsIPermissionManager::DENY_ACTION; break;
+ case 1: pref = 3; break;
+ default: return NS_ERROR_FAILURE;
+ }
+ nsresult rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(MozKey_ImageExceptions, !lock, lock);
+ if (NS_FAILED(rv))
+ return rv;
+ rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(MozKey_ImageViewExceptions, lock, lock);
+ if (NS_FAILED(rv))
+ return rv;
+ return aPrefService->GetPrefs()->
+ SetOverridingMozillaIntPref(MozKey_ImagePermissions, pref, lock);
+}
+
+static nsresult ReverseApplyLoadImages(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();
+ PRInt32 pref;
+ nsresult rv = prefs->GetIntPref(MozKey_ImagePermissions, &pref);
+ if (NS_FAILED(rv))
+ return rv;
+ gint setting;
+ switch (pref) {
+ case nsIPermissionManager::ALLOW_ACTION: setting = 0; break;
+ case nsIPermissionManager::DENY_ACTION: setting = 2; break;
+ case 3: setting = 1; break;
+ default: return NS_ERROR_FAILURE;
+ }
+ if (gconf_client_key_is_writable(aClient, GConfKey_LoadImages, nsnull))
+ gconf_client_set_int(aClient, GConfKey_LoadImages, setting, nsnull);
+ else
+ NS_ERROR("Gconf key is not writable");
+ return NS_OK;
+}
+
+/**
+ * The relationship R is
+ * "/apps/firefox/web/disable_popups" is true if and only if
+ * "dom.disable_open_during_load" is true
+ * AND if "/apps/firefox/web/disable_popups" is true then
+ * "privacy.popups.showBrowserMessage" is false.
+ */
+static const char MozKey_DisablePopups[] = "dom.disable_open_during_load";
+static const char MozKey_DisableBrowserPopupMessage[] = "privacy.popups.showBrowserMessage";
+static const char GConfKey_DisablePopups[] = "/apps/firefox/web/disable_popups";
+static nsresult ApplyDisablePopups(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_DisablePopups, nsnull);
+ gboolean disable = gconf_client_get_bool(aClient, GConfKey_DisablePopups, nsnull);
+ nsresult rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(MozKey_DisablePopups, disable, lock);
+ if (NS_SUCCEEDED(rv)) {
+ if (disable) {
+ rv = aPrefService->GetPrefs()->
+ SetOverridingMozillaBoolPref(MozKey_DisableBrowserPopupMessage, PR_TRUE, lock);
+ } else {
+ rv = aPrefService->GetPrefs()->
+ StopOverridingMozillaPref(MozKey_DisableBrowserPopupMessage);
+ }
+ }
+ return rv;
+}
+
+static nsresult ReverseApplyDisablePopups(nsSystemPrefService* aPrefService,
+ GConfClient* aClient)
+{
+ nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();
+ PRBool disabled;
+ nsresult rv = prefs->GetBoolPref(MozKey_DisablePopups, &disabled);
+ if (NS_FAILED(rv))
+ return rv;
+ if (gconf_client_key_is_writable(aClient, GConfKey_DisablePopups, nsnull))
+ gconf_client_set_bool(aClient, GConfKey_DisablePopups, disabled, nsnull);
+ else
+ NS_ERROR("Gconf key is not writable");
+ return NS_OK;
+}
+
+static ComplexGConfPrefMapping sComplexGConfPrefMappings[] = {
+ {GConfKey_TrustedURIs, ApplyTrustedURIs},
+ {GConfKey_DelegationURIs, ApplyDelegationURIs},
+ {GConfKey_DownloadFolder, ApplyDownloadFolder},
+ {GConfKey_DisableCookies, ApplyDisableCookies},
+ {GConfKey_DisableJSChrome, ApplyWindowOpen},
+ {GConfKey_DisableUnsafeProtocols, ApplyUnsafeProtocols},
+ {GConfKey_AdditionalSafeProtocols, ApplyUnsafeProtocols},
+ {GConfKey_WallpaperSetting, ApplyWallpaper},
+ {GConfKey_DisableSavePassword, ApplyDisableSavePassword},
+ {GConfKey_LoadImages, ApplyLoadImages},
+ {GConfKey_DisablePopups, ApplyDisablePopups}
+};
+static ComplexMozPrefMapping sComplexMozPrefMappings[] = {
+ {MozKey_TrustedURIs, ReverseApplyTrustedURIs},
+ {MozKey_DelegationURIs, ReverseApplyDelegationURIs},
+ {MozKey_UseDownloadDir, ReverseApplyDownloadFolder},
+ {MozKey_DownloadDirType, ReverseApplyDownloadFolder},
+ {MozKey_DownloadDirExplicit, ReverseApplyDownloadFolder},
+ {MozKey_CookieBehavior, ReverseApplyDisableCookies},
+ {MozKey_RememberSignons, ReverseApplyDisableSavePassword},
+ {MozKey_ImagePermissions, ReverseApplyLoadImages},
+ {MozKey_DisablePopups, ReverseApplyDisablePopups}
+};
+// The unsafe protocol preferences are handled specially because
+// they affect an unknown number of Mozilla preferences
+// Window opener permissions are also handled specially so we don't have to
+// repeat the windowOpenFeatures list.
+
+/* END preference mapping definition area */
+
+static PR_CALLBACK void GConfSimpleNotification(GConfClient* client,
+ guint cnxn_id,
+ GConfEntry *entry,
+ gpointer user_data)
+{
+ nsSystemPrefService* service = static_cast<nsSystemPrefService*>(user_data);
+ SimplePrefMapping* map = static_cast<SimplePrefMapping*>(
+ service->GetSimpleCallbackData(cnxn_id));
+ NS_ASSERTION(map, "Can't find mapping for callback");
+ if (!map)
+ return;
+
+ ApplySimpleMapping(map, service->GetPrefs(), client);
+}
+
+static PR_CALLBACK void GConfComplexNotification(GConfClient* client,
+ guint cnxn_id,
+ GConfEntry *entry,
+ gpointer user_data)
+{
+ nsSystemPrefService* service = static_cast<nsSystemPrefService*>(user_data);
+ ComplexGConfPrefMapping* map = static_cast<ComplexGConfPrefMapping*>(
+ service->GetComplexCallbackData(cnxn_id));
+ NS_ASSERTION(map, "Can't find mapping for callback");
+ if (!map)
+ return;
+
+ map->callback(service, GetGConf());
+}
+
+nsresult nsSystemPrefService::LoadSystemPreferences(nsISystemPref* aPrefs)
+{
+ mPref = aPrefs;
+
+ GConfClient* client = GetGConf();
+ PRUint32 i;
+ // Register simple mappings and callbacks
+ for (i = 0; i < NUM_ELEM(sSimplePrefMappings); ++i) {
+ guint cx = gconf_client_notify_add(client,
+ sSimplePrefMappings[i].gconfPrefName,
+ GConfSimpleNotification, this,
+ nsnull, nsnull);
+ mGConfSimpleCallbacks.Put(cx, &sSimplePrefMappings[i]);
+ nsresult rv = ApplySimpleMapping(&sSimplePrefMappings[i], aPrefs, client);
+ if (NS_FAILED(rv))
+ return rv;
+ }
+
+ // Update Mozilla settings with any gconf settings that have
+ // changed from the default. Do it before we register our
+ // Mozilla notifications.
+ ComplexGConfPrefChanged lastCallback = nsnull;
+ for (i = 0; i < NUM_ELEM(sComplexGConfPrefMappings); ++i) {
+ guint cx = gconf_client_notify_add(client,
+ sComplexGConfPrefMappings[i].gconfPrefName,
+ GConfComplexNotification, this,
+ nsnull, nsnull);
+ mGConfComplexCallbacks.Put(cx, &sComplexGConfPrefMappings[i]);
+ ComplexGConfPrefChanged cb = sComplexGConfPrefMappings[i].callback;
+ if (cb != lastCallback) {
+ cb(this, client);
+ lastCallback = cb;
+ }
+ }
+
+ nsCOMPtr<nsIPrefBranch2> userPrefs = aPrefs->GetPrefUserBranch();
+
+ // Update gconf settings with any Mozilla settings that have
+ // changed from the default.
+ for (i = 0; i < NUM_ELEM(sSimplePrefMappings); ++i) {
+ gconf_client_add_dir(client, sSimplePrefMappings[i].gconfPrefName,
+ GCONF_CLIENT_PRELOAD_NONE, nsnull);
+
+ PRBool hasUserPref = PR_FALSE;
+ nsresult rv =
+ userPrefs->PrefHasUserValue(sSimplePrefMappings[i].mozPrefName,
+ &hasUserPref);
+ if (NS_FAILED(rv))
+ return rv;
+ if (hasUserPref && sSimplePrefMappings[i].allowWritesFromMozilla) {
+ rv = ReverseApplySimpleMapping(&sSimplePrefMappings[i],
+ aPrefs, client);
+ if (NS_FAILED(rv))
+ return rv;
+ }
+ }
+ for (i = 0; i < NUM_ELEM(sComplexGConfPrefMappings); ++i) {
+ gconf_client_add_dir(client, sComplexGConfPrefMappings[i].gconfPrefName,
+ GCONF_CLIENT_PRELOAD_NONE, nsnull);
+ }
+ ComplexMozPrefChanged lastMozCallback = nsnull;
+ for (i = 0; i < NUM_ELEM(sComplexMozPrefMappings); ++i) {
+ PRBool hasUserPref = PR_FALSE;
+ nsresult rv =
+ userPrefs->PrefHasUserValue(sComplexMozPrefMappings[i].mozPrefName,
+ &hasUserPref);
+ if (NS_FAILED(rv))
+ return rv;
+ if (hasUserPref) {
+ ComplexMozPrefChanged cb = sComplexMozPrefMappings[i].callback;
+ if (cb != lastMozCallback) {
+ cb(this, client);
+ lastMozCallback = cb;
+ }
+ }
+ }
+
+ ApplyUnsafeProtocols(this, client);
+
+ return NS_OK;
+}
+
+nsresult nsSystemPrefService::NotifyMozillaPrefChanged(const char* aPrefName)
+{
+ PRUint32 i;
+ GConfClient* client = GetGConf();
+
+ for (i = 0; i < NUM_ELEM(sSimplePrefMappings); ++i) {
+ if (!strcmp(aPrefName, sSimplePrefMappings[i].mozPrefName)) {
+ ReverseApplySimpleMapping(&sSimplePrefMappings[i],
+ mPref, client);
+ }
+ }
+
+ for (i = 0; i < NUM_ELEM(sComplexMozPrefMappings); ++i) {
+ if (!strcmp(aPrefName, sComplexMozPrefMappings[i].mozPrefName)) {
+ sComplexMozPrefMappings[i].callback(this, client);
+ }
+ }
+
+ for (i = 0; i < NUM_ELEM(windowOpenFeatures); ++i) {
+ if (!strcmp(aPrefName, windowOpenFeatures[i])) {
+ ReverseApplyWindowOpen(this, client);
+ }
+ }
+
+ ReverseApplyUnsafeProtocols(this, client);
+
+ return NS_OK;
+}
+
+static PLDHashOperator PR_CALLBACK UnregisterSimple(const PRUint32& aKey,
+ SimplePrefMapping* aData,
+ void* aClosure)
+{
+ GConfClient* client = GetGConf();
+ gconf_client_notify_remove(client, aKey);
+ gconf_client_remove_dir(client, aData->gconfPrefName, nsnull);
+ return PL_DHASH_NEXT;
+}
+
+static PLDHashOperator PR_CALLBACK UnregisterComplex(const PRUint32& aKey,
+ ComplexGConfPrefMapping* aData,
+ void* aClosure)
+{
+ GConfClient* client = GetGConf();
+ gconf_client_notify_remove(client, aKey);
+ gconf_client_remove_dir(client, aData->gconfPrefName, nsnull);
+ return PL_DHASH_NEXT;
+}
+
+nsresult nsSystemPrefService::NotifyUnloadSystemPreferences()
+{
+ // Unregister callbacks
+ mGConfSimpleCallbacks.EnumerateRead(UnregisterSimple, this);
+ mGConfSimpleCallbacks.Clear();
+ mGConfComplexCallbacks.EnumerateRead(UnregisterComplex, this);
+ mGConfComplexCallbacks.Clear();
+
+ return NS_OK;
+}
+
+// PrefBranch interfaces
+
+GConfValue* nsSystemPrefService::GConfGet(const char *aPrefName)
+{
+ PRUint32 i;
+ PRBool found = PR_FALSE;
+ GConfValue *val = NULL;
+ GConfClient* client = GetGConf();
+ NS_ASSERTION(client, "Could not get default GConf client");
+ if (!client) {
+ return NULL;
+ }
+ for (i = 0; i < NUM_ELEM(sSimplePrefMappings); ++i) {
+ if (!strcmp(aPrefName, sSimplePrefMappings[i].mozPrefName)) {
+ found = PR_TRUE;
+ break;
+ }
+ }
+ if (found) {
+ val = gconf_client_get(client,
+ sSimplePrefMappings[i].gconfPrefName,
+ NULL);
+ }
+ return val;
+}
+
/* readonly attribute string root; */
NS_IMETHODIMP nsSystemPrefService::GetRoot(char * *aRoot)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* long getPrefType (in string aPrefName); */
NS_IMETHODIMP nsSystemPrefService::GetPrefType(const char *aPrefName, PRInt32 *_retval)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* boolean getBoolPref (in string aPrefName); */
NS_IMETHODIMP nsSystemPrefService::GetBoolPref(const char *aPrefName, PRBool *_retval)
{
- return mInitialized ?
- mGConf->GetBoolPref(aPrefName, _retval) : NS_ERROR_FAILURE;
+ GConfValue *val = GConfGet(aPrefName);
+ if (val) {
+ *_retval = (PRBool)(gconf_value_get_bool(val));
+ return NS_OK;
+ }
+ return NS_ERROR_FAILURE;
}
/* void setBoolPref (in string aPrefName, in long aValue); */
NS_IMETHODIMP nsSystemPrefService::SetBoolPref(const char *aPrefName, PRInt32 aValue)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* string getCharPref (in string aPrefName); */
NS_IMETHODIMP nsSystemPrefService::GetCharPref(const char *aPrefName, char **_retval)
{
- return mInitialized ?
- mGConf->GetCharPref(aPrefName, _retval) : NS_ERROR_FAILURE;
+ GConfValue *val = GConfGet(aPrefName);
+ if (val) {
+ *_retval = (char*)(gconf_value_get_string(val));
+ return *_retval ? NS_OK : NS_ERROR_FAILURE;
+ }
+ return NS_ERROR_FAILURE;
}
/* void setCharPref (in string aPrefName, in string aValue); */
NS_IMETHODIMP nsSystemPrefService::SetCharPref(const char *aPrefName, const char *aValue)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* long getIntPref (in string aPrefName); */
NS_IMETHODIMP nsSystemPrefService::GetIntPref(const char *aPrefName, PRInt32 *_retval)
{
- return mInitialized ?
- mGConf->GetIntPref(aPrefName, _retval) : NS_ERROR_FAILURE;
+ GConfValue *val = GConfGet(aPrefName);
+ if (val) {
+ *_retval = (PRInt32)(gconf_value_get_int(val));
+ return NS_OK;
+ }
+ return NS_ERROR_FAILURE;
}
/* void setIntPref (in string aPrefName, in long aValue); */
NS_IMETHODIMP nsSystemPrefService::SetIntPref(const char *aPrefName, PRInt32 aValue)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
-/* void getComplexValue (in string aPrefName, in nsIIDRef aType, [iid_is (aType), retval] out nsQIResult aValue); */
+/* void getComplexValue (in string aPrefName, in nsIIDRef aType, [iid_is
+ * (aType), retval] out nsQIResult aValue); */
NS_IMETHODIMP nsSystemPrefService::GetComplexValue(const char *aPrefName, const nsIID & aType, void * *aValue)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
-
-/* void setComplexValue (in string aPrefName, in nsIIDRef aType, in nsISupports aValue); */
+/* void setComplexValue (in string aPrefName, in nsIIDRef aType, in
+ * nsISupports aValue); */
NS_IMETHODIMP nsSystemPrefService::SetComplexValue(const char *aPrefName, const nsIID & aType, nsISupports *aValue)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void clearUserPref (in string aPrefName); */
NS_IMETHODIMP nsSystemPrefService::ClearUserPref(const char *aPrefName)
{
@@ -360,557 +1363,36 @@ NS_IMETHODIMP nsSystemPrefService::Unloc
}
/* void deleteBranch (in string aStartingAt); */
NS_IMETHODIMP nsSystemPrefService::DeleteBranch(const char *aStartingAt)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
-/* void getChildList (in string aStartingAt, out unsigned long aCount, [array, size_is (aCount), retval] out string aChildArray); */
+/* void getChildList (in string aStartingAt, out unsigned long aCount, [array,
+ * size_is (aCount), retval] out string aChildArray); */
NS_IMETHODIMP nsSystemPrefService::GetChildList(const char *aStartingAt, PRUint32 *aCount, char ***aChildArray)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void resetBranch (in string aStartingAt); */
NS_IMETHODIMP nsSystemPrefService::ResetBranch(const char *aStartingAt)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
-/* void addObserver (in string aDomain, in nsIObserver aObserver, in boolean aHoldWeak); */
-NS_IMETHODIMP nsSystemPrefService::AddObserver(const char *aDomain, nsIObserver *aObserver, PRBool aHoldWeak)
-{
- nsresult rv;
- NS_ENSURE_ARG_POINTER(aDomain);
- NS_ENSURE_ARG_POINTER(aObserver);
+// Factory stuff
- NS_ENSURE_TRUE(mInitialized, NS_ERROR_FAILURE);
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsSystemPrefService, Init)
- PRUint32 prefAtom;
- // make sure the pref name is supported
- rv = mGConf->GetAtomForMozKey(aDomain, &prefAtom);
- NS_ENSURE_SUCCESS(rv, rv);
-
- if (!mObservers) {
- mObservers = new nsAutoVoidArray();
- if (mObservers == nsnull)
- return NS_ERROR_OUT_OF_MEMORY;
- }
-
- SysPrefCallbackData *pCallbackData = (SysPrefCallbackData *)
- nsMemory::Alloc(sizeof(SysPrefCallbackData));
- if (pCallbackData == nsnull)
- return NS_ERROR_OUT_OF_MEMORY;
-
- pCallbackData->bIsWeakRef = aHoldWeak;
- pCallbackData->prefAtom = prefAtom;
- // hold a weak reference to the observer if so requested
- nsCOMPtr<nsISupports> observerRef;
- if (aHoldWeak) {
- nsCOMPtr<nsISupportsWeakReference> weakRefFactory =
- do_QueryInterface(aObserver);
- if (!weakRefFactory) {
- // the caller didn't give us a object that supports weak reference.
- // ... tell them
- nsMemory::Free(pCallbackData);
- return NS_ERROR_INVALID_ARG;
- }
- nsCOMPtr<nsIWeakReference> tmp = do_GetWeakReference(weakRefFactory);
- observerRef = tmp;
- } else {
- observerRef = aObserver;
- }
-
- rv = mGConf->NotifyAdd(prefAtom, pCallbackData);
- if (NS_FAILED(rv)) {
- nsMemory::Free(pCallbackData);
- return rv;
- }
-
- pCallbackData->observer = observerRef;
- NS_ADDREF(pCallbackData->observer);
-
- mObservers->AppendElement(pCallbackData);
- return NS_OK;
-}
-
-/* void removeObserver (in string aDomain, in nsIObserver aObserver); */
-NS_IMETHODIMP nsSystemPrefService::RemoveObserver(const char *aDomain, nsIObserver *aObserver)
-{
- nsresult rv;
-
- NS_ENSURE_ARG_POINTER(aDomain);
- NS_ENSURE_ARG_POINTER(aObserver);
- NS_ENSURE_TRUE(mInitialized, NS_ERROR_FAILURE);
-
- if (!mObservers)
- return NS_OK;
-
- PRUint32 prefAtom;
- // make sure the pref name is supported
- rv = mGConf->GetAtomForMozKey(aDomain, &prefAtom);
- NS_ENSURE_SUCCESS(rv, rv);
-
- // need to find the index of observer, so we can remove it
- PRIntn count = mObservers->Count();
- if (count <= 0)
- return NS_OK;
-
- PRIntn i;
- SysPrefCallbackData *pCallbackData;
- for (i = 0; i < count; ++i) {
- pCallbackData = (SysPrefCallbackData *)mObservers->ElementAt(i);
- if (pCallbackData) {
- nsCOMPtr<nsISupports> observerRef;
- if (pCallbackData->bIsWeakRef) {
- nsCOMPtr<nsISupportsWeakReference> weakRefFactory =
- do_QueryInterface(aObserver);
- if (weakRefFactory) {
- nsCOMPtr<nsIWeakReference> tmp =
- do_GetWeakReference(aObserver);
- observerRef = tmp;
- }
- }
- if (!observerRef)
- observerRef = aObserver;
-
- if (pCallbackData->observer == observerRef &&
- pCallbackData->prefAtom == prefAtom) {
- rv = mGConf->NotifyRemove(prefAtom, pCallbackData);
- if (NS_SUCCEEDED(rv)) {
- mObservers->RemoveElementAt(i);
- NS_RELEASE(pCallbackData->observer);
- nsMemory::Free(pCallbackData);
- }
- return rv;
- }
- }
- }
- return NS_OK;
-}
-
-void
-nsSystemPrefService::OnPrefChange(PRUint32 aPrefAtom, void *aData)
-{
- if (!mInitialized)
- return;
-
- SysPrefCallbackData *pData = (SysPrefCallbackData *)aData;
- if (pData->prefAtom != aPrefAtom)
- return;
-
- nsCOMPtr<nsIObserver> observer;
- if (pData->bIsWeakRef) {
- nsCOMPtr<nsIWeakReference> weakRef =
- do_QueryInterface(pData->observer);
- if(weakRef)
- observer = do_QueryReferent(weakRef);
- if (!observer) {
- // this weak referenced observer went away, remove it from the list
- nsresult rv = mGConf->NotifyRemove(aPrefAtom, pData);
- if (NS_SUCCEEDED(rv)) {
- mObservers->RemoveElement(pData);
- NS_RELEASE(pData->observer);
- nsMemory::Free(pData);
- }
- return;
- }
- }
- else
- observer = do_QueryInterface(pData->observer);
-
- if (observer)
- observer->Observe(static_cast<nsIPrefBranch *>(this),
- NS_SYSTEMPREF_PREFCHANGE_TOPIC_ID,
- NS_ConvertUTF8toUTF16(mGConf->GetMozKey(aPrefAtom)).
- get());
-}
-
-/*************************************************************
- * GConfProxy
- *
- ************************************************************/
-
-struct GConfFuncListType {
- const char *FuncName;
- PRFuncPtr FuncPtr;
+static const nsModuleComponentInfo components[] = {
+ { NS_SYSTEMPREF_SERVICE_CLASSNAME,
+ NS_SYSTEMPREF_SERVICE_CID,
+ NS_SYSTEMPREF_SERVICE_CONTRACTID,
+ nsSystemPrefServiceConstructor,
+ },
};
-struct PrefNamePair {
- const char *mozPrefName;
- const char *gconfPrefName;
-};
+NS_IMPL_NSGETMODULE(nsSystemPrefServiceModule, components)
-const char
-GConfProxy::sPrefGConfKey[] = "accessibility.unix.gconf2.shared-library";
-const char GConfProxy::sDefaultLibName1[] = "libgconf-2.so.4";
-const char GConfProxy::sDefaultLibName2[] = "libgconf-2.so";
-
-#define GCONF_FUNCS_POINTER_BEGIN \
- static GConfFuncListType sGConfFuncList[] = {
-#define GCONF_FUNCS_POINTER_ADD(func_name) \
- {func_name, nsnull},
-#define GCONF_FUNCS_POINTER_END \
- {nsnull, nsnull}, };
-
-GCONF_FUNCS_POINTER_BEGIN
- GCONF_FUNCS_POINTER_ADD("gconf_client_get_default") // 0
- GCONF_FUNCS_POINTER_ADD("gconf_client_get_bool") // 1
- GCONF_FUNCS_POINTER_ADD("gconf_client_get_string") //2
- GCONF_FUNCS_POINTER_ADD("gconf_client_get_int") //3
- GCONF_FUNCS_POINTER_ADD("gconf_client_notify_add") //4
- GCONF_FUNCS_POINTER_ADD("gconf_client_notify_remove") //5
- GCONF_FUNCS_POINTER_ADD("gconf_client_add_dir") //6
- GCONF_FUNCS_POINTER_ADD("gconf_client_remove_dir") //7
- GCONF_FUNCS_POINTER_ADD("gconf_entry_get_value") //8
- GCONF_FUNCS_POINTER_ADD("gconf_entry_get_key") //9
- GCONF_FUNCS_POINTER_ADD("gconf_value_get_bool") //10
- GCONF_FUNCS_POINTER_ADD("gconf_value_get_string") //11
- GCONF_FUNCS_POINTER_ADD("gconf_value_get_int") //12
- GCONF_FUNCS_POINTER_ADD("gconf_client_get_list") //13
-GCONF_FUNCS_POINTER_END
-
-/////////////////////////////////////////////////////////////////////////////
-// the list is the mapping table, between mozilla prefs and gconf prefs
-// It is expected to include all the pref pairs that are related in mozilla
-// and gconf.
-//
-// Note: the prefs listed here are not neccessarily be read from gconf, they
-// are the prefs that could be read from gconf. Mozilla has another
-// list (see sSysPrefList in nsSystemPref.cpp) that decide which prefs
-// are really read.
-//////////////////////////////////////////////////////////////////////////////
-
-static const PrefNamePair sPrefNameMapping[] = {
-#include "gconf_pref_list.inc"
- {nsnull, nsnull},
-};
-
-PRBool
-gconfDeleteObserver(void *aElement, void *aData) {
- nsMemory::Free(aElement);
- return PR_TRUE;
-}
-
-GConfProxy::GConfProxy(nsSystemPrefService *aSysPrefService):
- mGConfClient(nsnull),
- mGConfLib(nsnull),
- mInitialized(PR_FALSE),
- mSysPrefService(aSysPrefService),
- mObservers(nsnull)
-{
-}
-
-GConfProxy::~GConfProxy()
-{
- if (mGConfClient)
- g_object_unref(G_OBJECT(mGConfClient));
-
- if (mObservers) {
- (void)mObservers->EnumerateForwards(gconfDeleteObserver, nsnull);
- delete mObservers;
- }
-
- // bug 379666: can't unload GConf-2 since it registers atexit handlers
- //PR_UnloadLibrary(mGConfLib);
-}
-
-PRBool
-GConfProxy::Init()
-{
- SYSPREF_LOG(("GConfProxy:: Init GConfProxy\n"));
- if (!mSysPrefService)
- return PR_FALSE;
- if (mInitialized)
- return PR_TRUE;
-
- nsCOMPtr<nsIPrefBranch> pref = do_GetService(NS_PREFSERVICE_CONTRACTID);
-
- if (!pref)
- return PR_FALSE;
-
- nsXPIDLCString gconfLibName;
- nsresult rv;
-
- //check if gconf-2 library is given in prefs
- rv = pref->GetCharPref(sPrefGConfKey, getter_Copies(gconfLibName));
- if (NS_SUCCEEDED(rv)) {
- //use the library name in the preference
- SYSPREF_LOG(("GConf library in prefs is %s\n", gconfLibName.get()));
- mGConfLib = PR_LoadLibrary(gconfLibName.get());
- }
- else {
- SYSPREF_LOG(("GConf library not specified in prefs, try the default: "
- "%s and %s\n", sDefaultLibName1, sDefaultLibName2));
- mGConfLib = PR_LoadLibrary(sDefaultLibName1);
- if (!mGConfLib)
- mGConfLib = PR_LoadLibrary(sDefaultLibName2);
- }
-
- if (!mGConfLib) {
- SYSPREF_LOG(("Fail to load GConf library\n"));
- return PR_FALSE;
- }
-
- //check every func we need in the gconf library
- GConfFuncListType *funcList;
- PRFuncPtr func;
- for (funcList = sGConfFuncList; funcList->FuncName; ++funcList) {
- func = PR_FindFunctionSymbol(mGConfLib, funcList->FuncName);
- if (!func) {
- SYSPREF_LOG(("Check GConf Func Error: %s", funcList->FuncName));
- goto init_failed_unload;
- }
- funcList->FuncPtr = func;
- }
-
- InitFuncPtrs();
-
- mGConfClient = GConfClientGetDefault();
-
- // Don't unload past this point, since GConf's initialization of ORBit
- // causes atexit handlers to be registered.
-
- if (!mGConfClient) {
- SYSPREF_LOG(("Fail to Get default gconf client\n"));
- goto init_failed;
- }
- mInitialized = PR_TRUE;
- return PR_TRUE;
-
- init_failed_unload:
- PR_UnloadLibrary(mGConfLib);
- init_failed:
- mGConfLib = nsnull;
- return PR_FALSE;
-}
-
-nsresult
-GConfProxy::GetBoolPref(const char *aMozKey, PRBool *retval)
-{
- NS_ENSURE_TRUE(mInitialized, NS_ERROR_FAILURE);
- *retval = GConfClientGetBool(mGConfClient, MozKey2GConfKey(aMozKey), NULL);
- return NS_OK;
-}
-
-nsresult
-GConfProxy::GetCharPref(const char *aMozKey, char **retval)
-{
- NS_ENSURE_TRUE(mInitialized, NS_ERROR_FAILURE);
-
- const gchar *gconfkey = MozKey2GConfKey(aMozKey);
-
- if (!strcmp (aMozKey, "network.proxy.no_proxies_on")) {
- GSList *s;
- nsCString noproxy;
- GSList *gslist = GConfClientGetList(mGConfClient, gconfkey,
- GCONF_VALUE_STRING, NULL);
-
- for (s = gslist; s; s = g_slist_next(s)) {
- noproxy += (char *)s->data;
- noproxy += ", ";
- g_free ((char *)s->data);
- }
- g_slist_free (gslist);
-
- *retval = PL_strdup(noproxy.get());
- } else {
- gchar *str = GConfClientGetString(mGConfClient, gconfkey, NULL);
- if (str) {
- *retval = PL_strdup(str);
- g_free (str);
- }
- }
-
- return NS_OK;
-}
-
-nsresult
-GConfProxy::GetIntPref(const char *aMozKey, PRInt32 *retval)
-{
- NS_ENSURE_TRUE(mInitialized, NS_ERROR_FAILURE);
- if (strcmp (aMozKey, "network.proxy.type") == 0) {
- gchar *str;
-
- str = GConfClientGetString(mGConfClient,
- MozKey2GConfKey (aMozKey), NULL);
-
- if (str) {
- if (strcmp (str, "manual") == 0)
- *retval = 1;
- else if (strcmp (str, "auto") == 0)
- *retval = 2;
- else
- *retval = 0;
-
- g_free (str);
- } else
- *retval = 0;
- } else {
- *retval = GConfClientGetInt(mGConfClient,
- MozKey2GConfKey(aMozKey), NULL);
- }
-
- return NS_OK;
-}
-
-nsresult
-GConfProxy::NotifyAdd (PRUint32 aAtom, void *aUserData)
-{
- NS_ENSURE_TRUE(mInitialized, NS_ERROR_FAILURE);
-
- const char *gconfKey = GetGConfKey(aAtom);
- if (!gconfKey)
- return NS_ERROR_FAILURE;
-
- if (!mObservers) {
- mObservers = new nsAutoVoidArray();
- if (mObservers == nsnull)
- return NS_ERROR_OUT_OF_MEMORY;
- }
-
- GConfCallbackData *pData = (GConfCallbackData *)
- nsMemory::Alloc(sizeof(GConfCallbackData));
- NS_ENSURE_TRUE(pData, NS_ERROR_OUT_OF_MEMORY);
-
- pData->proxy = this;
- pData->userData = aUserData;
- pData->atom = aAtom;
- mObservers->AppendElement(pData);
-
- GConfClientAddDir(mGConfClient, gconfKey,
- 0, // GCONF_CLIENT_PRELOAD_NONE, don't preload anything
- NULL);
-
- pData->notifyId = GConfClientNotifyAdd(mGConfClient, gconfKey,
- gconf_key_listener, pData,
- NULL, NULL);
- return NS_OK;
-}
-
-nsresult
-GConfProxy::NotifyRemove (PRUint32 aAtom, const void *aUserData)
-{
- NS_ENSURE_TRUE(mInitialized, NS_ERROR_FAILURE);
-
- PRIntn count = mObservers->Count();
- if (count <= 0)
- return NS_OK;
-
- PRIntn i;
- GConfCallbackData *pData;
- for (i = 0; i < count; ++i) {
- pData = (GConfCallbackData *)mObservers->ElementAt(i);
- if (pData && pData->atom == aAtom && pData->userData == aUserData) {
- GConfClientNotifyRemove(mGConfClient, pData->notifyId);
- GConfClientRemoveDir(mGConfClient,
- GetGConfKey(pData->atom), NULL);
- mObservers->RemoveElementAt(i);
- nsMemory::Free(pData);
- break;
- }
- }
- return NS_OK;
-}
-
-void
-GConfProxy::InitFuncPtrs()
-{
- //gconf client funcs
- GConfClientGetDefault =
- (GConfClientGetDefaultType) sGConfFuncList[0].FuncPtr;
- GConfClientGetBool =
- (GConfClientGetBoolType) sGConfFuncList[1].FuncPtr;
- GConfClientGetString =
- (GConfClientGetStringType) sGConfFuncList[2].FuncPtr;
- GConfClientGetInt =
- (GConfClientGetIntType) sGConfFuncList[3].FuncPtr;
- GConfClientNotifyAdd =
- (GConfClientNotifyAddType) sGConfFuncList[4].FuncPtr;
- GConfClientNotifyRemove =
- (GConfClientNotifyRemoveType) sGConfFuncList[5].FuncPtr;
- GConfClientAddDir =
- (GConfClientAddDirType) sGConfFuncList[6].FuncPtr;
- GConfClientRemoveDir =
- (GConfClientRemoveDirType) sGConfFuncList[7].FuncPtr;
-
- //gconf entry funcs
- GConfEntryGetValue = (GConfEntryGetValueType) sGConfFuncList[8].FuncPtr;
- GConfEntryGetKey = (GConfEntryGetKeyType) sGConfFuncList[9].FuncPtr;
-
- //gconf value funcs
- GConfValueGetBool = (GConfValueGetBoolType) sGConfFuncList[10].FuncPtr;
- GConfValueGetString = (GConfValueGetStringType) sGConfFuncList[11].FuncPtr;
- GConfValueGetInt = (GConfValueGetIntType) sGConfFuncList[12].FuncPtr;
-
- //gconf client list func
- GConfClientGetList =
- (GConfClientGetListType) sGConfFuncList[13].FuncPtr;
-}
-
-void
-GConfProxy::OnNotify(void *aClient, void * aEntry, PRUint32 aNotifyId,
- GConfCallbackData *aData)
-{
- if (!mInitialized || !aEntry || (mGConfClient != aClient) || !aData)
- return;
-
- if (GConfEntryGetValue(aEntry) == NULL)
- return;
-
- PRUint32 prefAtom;
- nsresult rv = GetAtomForGConfKey(GConfEntryGetKey(aEntry), &prefAtom);
- if (NS_FAILED(rv))
- return;
-
- mSysPrefService->OnPrefChange(prefAtom, aData->userData);
-}
-
-nsresult
-GConfProxy::GetAtom(const char *aKey, PRUint8 aNameType, PRUint32 *aAtom)
-{
- if (!aKey)
- return NS_ERROR_FAILURE;
- PRUint32 prefSize = sizeof(sPrefNameMapping) / sizeof(sPrefNameMapping[0]);
- for (PRUint32 index = 0; index < prefSize; ++index) {
- if (!strcmp((aNameType == 0) ? sPrefNameMapping[index].mozPrefName :
- sPrefNameMapping[index].gconfPrefName, aKey)) {
- *aAtom = index;
- return NS_OK;
- }
- }
- return NS_ERROR_FAILURE;
-}
-
-const char *
-GConfProxy::GetKey(PRUint32 aAtom, PRUint8 aNameType)
-{
- PRUint32 mapSize = sizeof(sPrefNameMapping) / sizeof(sPrefNameMapping[0]);
- if (aAtom >= 0 && aAtom < mapSize)
- return (aNameType == 0) ? sPrefNameMapping[aAtom].mozPrefName :
- sPrefNameMapping[aAtom].gconfPrefName;
- return NULL;
-}
-
-inline const char *
-GConfProxy::MozKey2GConfKey(const char *aMozKey)
-{
- PRUint32 atom;
- nsresult rv = GetAtomForMozKey(aMozKey, &atom);
- if (NS_SUCCEEDED(rv))
- return GetGConfKey(atom);
- return NULL;
-}
-
-/* static */
-void gconf_key_listener (void* client, guint cnxn_id,
- void *entry, gpointer user_data)
-{
- SYSPREF_LOG(("...SYSPREF_LOG...key listener get called \n"));
- if (!user_data)
- return;
- GConfCallbackData *pData = reinterpret_cast<GConfCallbackData *>
- (user_data);
- pData->proxy->OnNotify(client, entry, cnxn_id, pData);
-}
diff --git a/extensions/pref/system-pref/src/nsISystemPrefService.h b/extensions/pref/system-pref/src/nsISystemPrefService.h
new file mode 100644
--- /dev/null
+++ b/extensions/pref/system-pref/src/nsISystemPrefService.h
@@ -0,0 +1,107 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Novell
+ * Portions created by Novell are Copyright (C) 2005 Novell,
+ * All Rights Reserved.
+ *
+ * Original Author: Robert O'Callahan (rocallahan@novell.com)
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the NPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the NPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef nsISystemPrefService_h__
+#define nsISystemPrefService_h__
+
+#include "nsCOMPtr.h"
+#include "nsIPrefBranchInternal.h"
+
+#define NS_SYSTEMPREF_SERVICE_CONTRACTID "@mozilla.org/system-preference-service;1"
+
+#define NS_ISYSTEMPREFSERVICE_IID \
+{ 0x006e1cfd, 0xd66a, 0x40b9, \
+ { 0x84, 0xa1, 0x84, 0xf3, 0xe6, 0xa2, 0xca, 0xbc } }
+
+class nsISystemPref {
+public:
+ /**
+ * Call one of these three methods to override a Mozilla
+ * preference with a system value. You can call it multiple
+ * times to change the value of a given preference to track
+ * the underlying system value.
+ *
+ * If aLocked is true then we set the default preference and
+ * lock it so the user value is ignored. If aLocked is false
+ * then we unlock the Mozilla preference and set the Mozilla
+ * user value.
+ */
+ virtual nsresult SetOverridingMozillaBoolPref(const char* aPrefName,
+ PRBool aValue, PRBool aLocked,
+ PRBool aPresent = PR_TRUE) = 0;
+ virtual nsresult SetOverridingMozillaIntPref(const char* aPrefName,
+ PRInt32 aValue, PRBool aLocked,
+ PRBool aPresent = PR_TRUE) = 0;
+ virtual nsresult SetOverridingMozillaStringPref(const char* aPrefName,
+ const char* aValue, PRBool aLocked,
+ PRBool aPresent = PR_TRUE) = 0;
+ virtual nsresult StopOverridingMozillaPref(const char* aPrefName) = 0;
+ virtual already_AddRefed<nsIPrefBranch2> GetPrefUserBranch() = 0;
+ virtual already_AddRefed<nsIPrefBranch> GetPrefDefaultBranch() = 0;
+};
+
+class nsISystemPrefService : public nsISupports {
+public:
+ NS_DECLARE_STATIC_IID_ACCESSOR(NS_ISYSTEMPREFSERVICE_IID)
+
+ /**
+ * Load the system prefs from the store into their corresponding
+ * Mozilla prefs, calling SetOverridingMozillaPref on each
+ * such pref.
+ */
+ virtual nsresult LoadSystemPreferences(nsISystemPref* aPrefs) = 0;
+
+ /**
+ * Notify that a Mozilla user pref that is being overridden by the
+ * store has changed. The new value of the Mozilla pref should be
+ * written back to the store.
+ */
+ virtual nsresult NotifyMozillaPrefChanged(const char* aPrefName) = 0;
+
+ /**
+ * Notify that we're about to stop using the system prefs. After
+ * this, nsSystemPref will automatically stop overriding all
+ * Mozilla prefs that are being overridden.
+ */
+ virtual nsresult NotifyUnloadSystemPreferences() = 0;
+};
+
+#endif
diff --git a/extensions/pref/system-pref/src/nsSystemPref.cpp b/extensions/pref/system-pref/src/nsSystemPref.cpp
--- a/extensions/pref/system-pref/src/nsSystemPref.cpp
+++ b/extensions/pref/system-pref/src/nsSystemPref.cpp
@@ -19,16 +19,17 @@
*
* The Initial Developer of the Original Code is Sun Microsystems, Inc.
* Portions created by Sun Microsystems are Copyright (C) 2003 Sun
* Microsystems, Inc. All Rights Reserved.
*
* Original Author: Bolian Yin (bolian.yin@sun.com)
*
* Contributor(s):
+ * Robert O'Callahan (rocallahan@novell.com)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
@@ -36,76 +37,72 @@
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsSystemPref.h"
#include "nsIObserverService.h"
+#include "nsIAppStartupNotifier.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsICategoryManager.h"
+#include "nsIServiceManager.h"
#include "nsSystemPrefLog.h"
-#include "nsSystemPrefService.h"
#include "nsString.h"
-const char sSysPrefString[] = "config.use_system_prefs";
-union MozPrefValue {
- char * stringVal;
- PRInt32 intVal;
- PRBool boolVal;
-};
+#include <stdlib.h>
struct SysPrefItem {
- const char *prefName; // mozilla pref string name
- MozPrefValue defaultValue; // store the mozilla default value
- PRBool isLocked; // store the mozilla lock status
+ // Saved values on both branches
+ PRInt32 savedUserValueScalar;
+ char* savedUserValueString;
+ PRInt32 savedDefaultValueScalar;
+ char* savedDefaultValueString;
+ // When this is true, then the value was locked originally
+ PRPackedBool savedLocked;
+ // When this is true, then there was a user value
+ PRPackedBool savedUserPresent;
+ PRPackedBool ignore;
+
SysPrefItem() {
- prefName = nsnull;
- defaultValue.intVal = 0;
- defaultValue.stringVal = nsnull;
- defaultValue.boolVal = PR_FALSE;
- isLocked = PR_FALSE;
+ savedUserValueScalar = 0;
+ savedUserValueString = nsnull;
+ savedDefaultValueScalar = 0;
+ savedDefaultValueString = nsnull;
+ savedUserPresent = PR_FALSE;
+ savedLocked = PR_FALSE;
+ ignore = PR_FALSE;
}
- void SetPrefName(const char *aPrefName) {
- prefName = aPrefName;
+
+ virtual ~SysPrefItem() {
+ nsMemory::Free(savedUserValueString);
+ nsMemory::Free(savedDefaultValueString);
}
};
-// all prefs that mozilla need to read from host system if they are available
-static const char *sSysPrefList[] = {
- "network.proxy.http",
- "network.proxy.http_port",
- "network.proxy.ftp",
- "network.proxy.ftp_port",
- "network.proxy.ssl",
- "network.proxy.ssl_port",
- "network.proxy.socks",
- "network.proxy.socks_port",
- "network.proxy.no_proxies_on",
- "network.proxy.autoconfig_url",
- "network.proxy.type",
- "config.use_system_prefs.accessibility",
-};
+NS_DEFINE_STATIC_IID_ACCESSOR(nsISystemPrefService, NS_ISYSTEMPREFSERVICE_IID)
+
+static const char sSysPrefString[] = "config.use_system_prefs";
PRLogModuleInfo *gSysPrefLog = NULL;
NS_IMPL_ISUPPORTS2(nsSystemPref, nsIObserver, nsISupportsWeakReference)
-nsSystemPref::nsSystemPref():
- mSysPrefService(nsnull),
- mEnabled(PR_FALSE),
- mSysPrefs(nsnull)
+nsSystemPref::nsSystemPref() : mIgnorePrefSetting(PR_FALSE)
{
+ mSavedPrefs.Init();
+ mCachedUserPrefBranch = nsnull;
+ mCachedDefaultPrefBranch = nsnull;
}
nsSystemPref::~nsSystemPref()
{
- mSysPrefService = nsnull;
- mEnabled = PR_FALSE;
- delete [] mSysPrefs;
}
///////////////////////////////////////////////////////////////////////////////
// nsSystemPref::Init
// Setup log and listen on NS_PREFSERVICE_READ_TOPIC_ID from pref service
///////////////////////////////////////////////////////////////////////////////
nsresult
nsSystemPref::Init(void)
@@ -126,349 +123,519 @@ nsSystemPref::Init(void)
PR_FALSE);
rv = observerService->AddObserver(this, "profile-before-change",
PR_FALSE);
SYSPREF_LOG(("Add Observer for %s\n", NS_PREFSERVICE_READ_TOPIC_ID));
}
return(rv);
}
+already_AddRefed<nsIPrefBranch2>
+nsSystemPref::GetPrefUserBranch()
+{
+ if (mCachedUserPrefBranch) {
+ NS_ADDREF(mCachedUserPrefBranch);
+ return mCachedUserPrefBranch;
+ }
+
+ nsresult rv;
+ nsCOMPtr<nsIPrefService> prefService =
+ do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+ if (NS_FAILED(rv))
+ return nsnull;
+ nsCOMPtr<nsIPrefBranch> prefBranch;
+ rv = prefService->GetBranch(nsnull, getter_AddRefs(prefBranch));
+ if (NS_FAILED(rv))
+ return nsnull;
+ nsCOMPtr<nsIPrefBranch2> pb2(do_QueryInterface(prefBranch));
+ if (!pb2)
+ return nsnull;
+
+ nsIPrefBranch2* result = nsnull;
+ pb2.swap(result);
+ return result;
+}
+
+already_AddRefed<nsIPrefBranch>
+nsSystemPref::GetPrefDefaultBranch()
+{
+ if (mCachedDefaultPrefBranch) {
+ NS_ADDREF(mCachedDefaultPrefBranch);
+ return mCachedDefaultPrefBranch;
+ }
+
+ nsresult rv;
+ nsCOMPtr<nsIPrefService> prefService =
+ do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+ if (NS_FAILED(rv))
+ return nsnull;
+ nsCOMPtr<nsIPrefBranch> prefBranch;
+ rv = prefService->GetDefaultBranch(nsnull, getter_AddRefs(prefBranch));
+ if (NS_FAILED(rv))
+ return nsnull;
+ nsIPrefBranch* pb = nsnull;
+ prefBranch.swap(pb);
+ return pb;
+}
+
///////////////////////////////////////////////////////////////////////////////
// nsSystemPref::Observe
// Observe notifications from mozilla pref system and system prefs (if enabled)
///////////////////////////////////////////////////////////////////////////////
NS_IMETHODIMP
nsSystemPref::Observe(nsISupports *aSubject,
const char *aTopic,
const PRUnichar *aData)
{
nsresult rv = NS_OK;
if (!aTopic)
return NS_OK;
- // if we are notified by pref service
- // check the system pref settings
+ nsCOMPtr<nsIPrefBranch2> userBranch = GetPrefUserBranch();
+ nsCOMPtr<nsIPrefBranch> defaultBranch = GetPrefDefaultBranch();
+
+ // Check the default branch first. If system prefs are enabled
+ // by default, then don't check the user prefs; we don't want
+ // to allow users to change the default.
+ PRBool defaultEnabled;
+ rv = defaultBranch->GetBoolPref(sSysPrefString, &defaultEnabled);
+ if (NS_FAILED(rv)) {
+ SYSPREF_LOG(("...Failed to Get %s\n", sSysPrefString));
+ return rv;
+ }
+ PRBool enabled = defaultEnabled;
+ if (!enabled) {
+ rv = userBranch->GetBoolPref(sSysPrefString, &enabled);
+
+ if (NS_FAILED(rv)) {
+ SYSPREF_LOG(("...Failed to Get %s\n", sSysPrefString));
+ return rv;
+ }
+ }
if (!nsCRT::strcmp(aTopic, NS_PREFSERVICE_READ_TOPIC_ID)) {
+ // The prefs have just loaded. This is the first thing that
+ // happens to us.
SYSPREF_LOG(("Observed: %s\n", aTopic));
+
- nsCOMPtr<nsIPrefBranch2> prefBranch =
- do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+ // listen on changes to use_system_pref. It's OK to
+ // hold a strong reference because we don't keep a reference
+ // to the pref branch.
+ rv = userBranch->AddObserver(sSysPrefString, this, PR_TRUE);
+
+ if (NS_FAILED(rv)) {
+ SYSPREF_LOG(("...Failed to add observer for %s\n", sSysPrefString));
+ return rv;
+ }
+ NS_ASSERTION(!mSysPrefService, "Should not be already enabled");
+ if (!enabled) {
+ // Don't load the system pref service if the preference is
+ // not set.
+ return NS_OK;
+ }
+
+ SYSPREF_LOG(("%s is enabled\n", sSysPrefString));
+
+ rv = LoadSystemPrefs();
if (NS_FAILED(rv))
return rv;
- rv = prefBranch->GetBoolPref(sSysPrefString, &mEnabled);
- if (NS_FAILED(rv)) {
- SYSPREF_LOG(("...FAil to Get %s\n", sSysPrefString));
- return rv;
- }
-
- // if there is no system pref service, assume nothing happen to us
- mSysPrefService = do_GetService(NS_SYSTEMPREF_SERVICE_CONTRACTID, &rv);
- if (NS_FAILED(rv) || !mSysPrefService) {
- SYSPREF_LOG(("...No System Pref Service\n"));
- return NS_OK;
- }
-
- // listen on its changes
- rv = prefBranch->AddObserver(sSysPrefString, this, PR_TRUE);
- if (NS_FAILED(rv)) {
- SYSPREF_LOG(("...FAil to add observer for %s\n", sSysPrefString));
- return rv;
- }
-
- if (!mEnabled) {
- SYSPREF_LOG(("%s is disabled\n", sSysPrefString));
- return NS_OK;
- }
- SYSPREF_LOG(("%s is enabled\n", sSysPrefString));
- rv = UseSystemPrefs();
-
- }
- // sSysPrefString value was changed, update ...
- else if (!nsCRT::strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) &&
- NS_ConvertUTF8toUTF16(sSysPrefString).Equals(aData)) {
- SYSPREF_LOG(("++++++ Notify: topic=%s data=%s\n",
- aTopic, NS_ConvertUTF16toUTF8(aData).get()));
-
- nsCOMPtr<nsIPrefBranch> prefBranch =
- do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
- if (NS_FAILED(rv))
- return rv;
-
- PRBool enabled = mEnabled;
- rv = prefBranch->GetBoolPref(sSysPrefString, &mEnabled);
- if (enabled != mEnabled) {
- if (mEnabled)
- //read prefs from system
- rv = UseSystemPrefs();
- else
- //roll back to mozilla prefs
- rv = UseMozillaPrefs();
+ // Lock config.use_system_prefs so the user can't undo
+ // it. But only do this if it was set by in the default prefs;
+ // if it was not set by default, then locking it would actually
+ // unset the value! And the user should be allowed to turn off
+ // something they set themselves.
+ if (NS_SUCCEEDED(rv) && defaultEnabled) {
+ userBranch->LockPref(sSysPrefString);
}
}
- // if the system pref notify us that some pref has been changed by user
- // outside mozilla. We need to read it again.
- else if (!nsCRT::strcmp(aTopic, NS_SYSTEMPREF_PREFCHANGE_TOPIC_ID) &&
- aData) {
- NS_ASSERTION(mEnabled == PR_TRUE, "Should not listen when disabled");
- SYSPREF_LOG(("====== System Pref Notify topic=%s data=%s\n",
- aTopic, (char*)aData));
- rv = ReadSystemPref(NS_LossyConvertUTF16toASCII(aData).get());
+ if (!nsCRT::strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID) &&
+ nsDependentString(aData).EqualsASCII(sSysPrefString)) {
+ // sSysPrefString value was changed, update...
+ SYSPREF_LOG(("++++++ Notify: topic=%s data=%s\n",
+ aTopic, NS_ConvertUTF16toUTF8(aData).get()));
+ if (mSysPrefService && !enabled)
+ return RestoreMozillaPrefs();
+ if (!mSysPrefService && enabled) {
+ // Don't lock it. If the user enabled use_system_prefs,
+ // they should be allowed to unlock it.
+ return LoadSystemPrefs();
+ }
+
+ // didn't change?
return NS_OK;
- } else if (!nsCRT::strcmp(aTopic,"profile-before-change")) {
- //roll back to mozilla prefs
- if (mEnabled)
- UseMozillaPrefs();
- mEnabled = PR_FALSE;
- mSysPrefService = nsnull;
- delete [] mSysPrefs;
- mSysPrefs = nsnull;
- } else
- SYSPREF_LOG(("Not needed topic Received %s\n", aTopic));
+ }
+
+ if (!nsCRT::strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
+ // some other pref changed, tell the backend if there is one
+ if (mSysPrefService && !mIgnorePrefSetting) {
+ NS_LossyConvertUTF16toASCII tmp(aData);
+#ifdef DEBUG
+ PRBool isLocked;
+ userBranch->PrefIsLocked(tmp.get(), &isLocked);
+ NS_ASSERTION(!isLocked, "Locked pref is changing?");
+#endif
+ SysPrefItem* item;
+ if (!mSavedPrefs.Get(tmp, &item)) {
+ NS_ERROR("Notified about pref change that we didn't ask about?");
+ } else {
+ if (!item->ignore) {
+ mSysPrefService->NotifyMozillaPrefChanged(tmp.get());
+ }
+ }
+ }
+ return NS_OK;
+ }
+
+ if (!nsCRT::strcmp(aTopic,"profile-before-change"))
+ return RestoreMozillaPrefs();
+
+ SYSPREF_LOG(("Not needed topic Received %s\n", aTopic));
+
return rv;
}
-/* private */
+nsresult
+nsSystemPref::SetOverridingMozillaBoolPref(const char* aPrefName,
+ PRBool aValue, PRBool aLock, PRBool aPresent)
+{
+ return OverridePref(aPrefName, nsIPrefBranch::PREF_BOOL,
+ (void*)aValue, aLock, aPresent);
+}
-////////////////////////////////////////////////////////////////
-// nsSystemPref::UseSystemPrefs
-// Read all the prefs in the table from system, listen for their
-// changes in system pref service.
-////////////////////////////////////////////////////////////////
nsresult
-nsSystemPref::UseSystemPrefs()
+nsSystemPref::SetOverridingMozillaIntPref(const char* aPrefName,
+ PRInt32 aValue, PRBool aLock, PRBool aPresent)
{
- SYSPREF_LOG(("\n====Now Use system prefs==\n"));
- nsresult rv = NS_OK;
- if (!mSysPrefService) {
+ return OverridePref(aPrefName, nsIPrefBranch::PREF_INT,
+ (void*)aValue, aLock, aPresent);
+}
+
+
+nsresult
+nsSystemPref::SetOverridingMozillaStringPref(const char* aPrefName,
+ const char* aValue, PRBool aLock, PRBool aPresent)
+{
+ return OverridePref(aPrefName, nsIPrefBranch::PREF_STRING,
+ (void*)aValue, aLock, aPresent);
+}
+
+static nsresult RestorePrefValue(PRInt32 aPrefType,
+ const char* aPrefName,
+ SysPrefItem* aItem,
+ nsIPrefBranch* aUser,
+ nsIPrefBranch* aDefault)
+{
+ switch (aPrefType) {
+
+ case nsIPrefBranch::PREF_STRING:
+ aDefault->SetCharPref(aPrefName,
+ aItem->savedDefaultValueString);
+ if (aItem->savedUserPresent) {
+ aUser->SetCharPref(aPrefName, aItem->savedUserValueString);
+ }
+ break;
+ case nsIPrefBranch::PREF_INT:
+ aDefault->SetBoolPref(aPrefName, aItem->savedDefaultValueScalar);
+ if (aItem->savedUserPresent) {
+ aUser->SetBoolPref(aPrefName, aItem->savedUserValueScalar);
+ }
+ break;
+ case nsIPrefBranch::PREF_BOOL:
+ aDefault->SetBoolPref(aPrefName, aItem->savedDefaultValueScalar);
+ if (aItem->savedUserPresent) {
+ aUser->SetBoolPref(aPrefName, aItem->savedUserValueScalar);
+ }
+ break;
+ default:
+ NS_ERROR("Unknown preference type");
return NS_ERROR_FAILURE;
}
- PRIntn sysPrefCount= sizeof(sSysPrefList) / sizeof(sSysPrefList[0]);
-
- if (!mSysPrefs) {
- mSysPrefs = new SysPrefItem[sysPrefCount];
- if (!mSysPrefs)
- return NS_ERROR_OUT_OF_MEMORY;
- for (PRIntn index = 0; index < sysPrefCount; ++index)
- mSysPrefs[index].SetPrefName(sSysPrefList[index]);
+ if (!aItem->savedUserPresent) {
+ aUser->DeleteBranch(aPrefName);
}
- for (PRIntn index = 0; index < sysPrefCount; ++index) {
- // save mozilla prefs
- SaveMozDefaultPref(mSysPrefs[index].prefName,
- &mSysPrefs[index].defaultValue,
- &mSysPrefs[index].isLocked);
+ return NS_OK;
+}
- // get the system prefs
- ReadSystemPref(mSysPrefs[index].prefName);
- SYSPREF_LOG(("Add Listener on %s\n", mSysPrefs[index].prefName));
- mSysPrefService->AddObserver(mSysPrefs[index].prefName,
- this, PR_TRUE);
+static PLDHashOperator PR_CALLBACK RestorePref(const nsACString& aKey,
+ SysPrefItem* aItem,
+ void* aClosure)
+{
+ nsSystemPref* prefs = static_cast<nsSystemPref*>(aClosure);
+ nsCOMPtr<nsIPrefBranch2> userBranch = prefs->GetPrefUserBranch();
+ const nsCString& prefName = PromiseFlatCString(aKey);
+
+ PRInt32 prefType = nsIPrefBranch::PREF_INVALID;
+ nsresult rv = userBranch->GetPrefType(prefName.get(), &prefType);
+ if (NS_FAILED(rv))
+ return PL_DHASH_NEXT;
+ PRBool isLocked;
+ userBranch->PrefIsLocked(prefName.get(), &isLocked);
+ if (NS_FAILED(rv))
+ return PL_DHASH_NEXT;
+
+
+ // Remove our observer before we change the value
+ userBranch->RemoveObserver(prefName.get(), prefs);
+ // Remember to ignore this item. Because some prefs start with "config.use_system_prefs",
+ // which we always observe, even after we remove the observer, changes to the pref will
+ // still be observed by us. We must ignore them.
+ aItem->ignore = PR_TRUE;
+
+
+ // Unlock the pref so we can set it
+ if (isLocked) {
+ userBranch->UnlockPref(prefName.get());
}
+
+ nsCOMPtr<nsIPrefBranch> defaultBranch = prefs->GetPrefDefaultBranch();
+
+ RestorePrefValue(prefType, prefName.get(), aItem,
+ userBranch, defaultBranch);
+
+ if (aItem->savedLocked) {
+ userBranch->LockPref(prefName.get());
+ }
+
+ return PL_DHASH_NEXT;
+}
+
+nsresult
+nsSystemPref::StopOverridingMozillaPref(const char* aPrefName)
+{
+ SysPrefItem* item;
+ nsDependentCString prefNameStr(aPrefName);
+ if (!mSavedPrefs.Get(prefNameStr, &item))
+ return NS_OK;
+
+ RestorePref(prefNameStr, item, this);
+ mSavedPrefs.Remove(prefNameStr);
+ delete item;
+ return NS_OK;
+}
+
+/* private */
+
+nsresult
+nsSystemPref::OverridePref(const char* aPrefName, PRInt32 aType,
+ void* aValue, PRBool aLock, PRBool aPresent)
+{
+ nsCOMPtr<nsIPrefBranch2> userBranch = GetPrefUserBranch();
+ nsCOMPtr<nsIPrefBranch> defaultBranch = GetPrefDefaultBranch();
+
+ PRInt32 prefType = nsIPrefBranch::PREF_INVALID;
+ nsresult rv = userBranch->GetPrefType(aPrefName, &prefType);
+ PRBool isLocked;
+ rv = userBranch->PrefIsLocked(aPrefName, &isLocked);
+ if (NS_FAILED(rv))
+ return rv;
+ PRBool hasUserValue;
+ rv = userBranch->PrefHasUserValue(aPrefName, &hasUserValue);
+ if (NS_FAILED(rv))
+ return rv;
+ if (prefType == 0) {
+ // Preference does not exist. Allow the system prefs to
+ // set it.
+ } else {
+ NS_ASSERTION(aType == prefType,
+ "System pref engine passed incorrect type for Mozilla pref");
+ if (aType != prefType)
+ return NS_ERROR_FAILURE;
+ }
+
+ if (prefType != 0) {
+ nsDependentCString prefNameStr(aPrefName);
+ SysPrefItem* item = nsnull;
+ if (!mSavedPrefs.Get(prefNameStr, &item)) {
+ // Need to save the existing value away
+ item = new SysPrefItem();
+ if (!item)
+ return NS_ERROR_OUT_OF_MEMORY;
+
+ item->savedLocked = isLocked;
+ item->savedUserPresent = hasUserValue;
+
+ switch (prefType) {
+ case nsIPrefBranch::PREF_STRING:
+ if (hasUserValue) {
+ userBranch->GetCharPref(aPrefName, &item->savedUserValueString);
+ }
+ defaultBranch->GetCharPref(aPrefName, &item->savedDefaultValueString);
+ break;
+ case nsIPrefBranch::PREF_INT:
+ if (hasUserValue) {
+ userBranch->GetIntPref(aPrefName, &item->savedUserValueScalar);
+ }
+ defaultBranch->GetIntPref(aPrefName, &item->savedDefaultValueScalar);
+ break;
+ case nsIPrefBranch::PREF_BOOL:
+ if (hasUserValue) {
+ userBranch->GetBoolPref(aPrefName, &item->savedUserValueScalar);
+ }
+ defaultBranch->GetBoolPref(aPrefName, &item->savedDefaultValueScalar);
+ break;
+ default:
+ NS_ERROR("Unknown preference type");
+ delete item;
+ return NS_ERROR_FAILURE;
+ }
+
+ mSavedPrefs.Put(prefNameStr, item);
+
+ // Watch the user value in case it changes on the Mozilla side
+ // If 'aLock' is true then it shouldn't change and we don't
+ // need the observer, but don't bother optimizing for that.
+ userBranch->AddObserver(aPrefName, this, PR_TRUE);
+ } else {
+ if (isLocked != aLock) {
+ // restore pref value on user and default branches
+ RestorePrefValue(prefType, aPrefName, item,
+ userBranch, defaultBranch);
+ }
+ }
+ }
+
+ // We need to ignore pref changes due to our own calls here
+ mIgnorePrefSetting = PR_TRUE;
+
+ // Unlock it if it's locked, so we can set it
+ if (isLocked) {
+ rv = userBranch->UnlockPref(aPrefName);
+ if (NS_FAILED(rv))
+ return rv;
+ }
+
+ // Set the pref on the default branch if we're locking it, because
+ // only the default branch gets used when the pref is locked.
+ // Set the pref on the user branch if we're not locking it, because
+ // that's where the user change will go.
+ nsIPrefBranch* settingBranch =
+ aLock ? defaultBranch.get() : static_cast<nsIPrefBranch*>(userBranch.get());
+
+ if (!aPresent) {
+ rv = settingBranch->DeleteBranch(aPrefName);
+ } else {
+ switch (aType) {
+ case nsIPrefBranch::PREF_STRING:
+ rv = settingBranch->SetCharPref(aPrefName, (const char*)aValue);
+ break;
+ case nsIPrefBranch::PREF_INT:
+ rv = settingBranch->SetIntPref(aPrefName, (PRInt32)(NS_PTR_TO_INT32(aValue)));
+ break;
+ case nsIPrefBranch::PREF_BOOL:
+ rv = settingBranch->SetBoolPref(aPrefName, (PRBool)(NS_PTR_TO_INT32(aValue)));
+ break;
+ default:
+ NS_ERROR("Unknown preference type");
+ mIgnorePrefSetting = PR_FALSE;
+ return NS_ERROR_FAILURE;
+ }
+ }
+
+ if (NS_FAILED(rv))
+ return rv;
+ if (aLock) {
+ rv = userBranch->LockPref(aPrefName);
+ }
+
+ mIgnorePrefSetting = PR_FALSE;
return rv;
}
-//////////////////////////////////////////////////////////////////////
-// nsSystemPref::ReadSystemPref
-// Read a pref value from system pref service, and lock it in mozilla.
-//////////////////////////////////////////////////////////////////////
+
nsresult
-nsSystemPref::ReadSystemPref(const char *aPrefName)
+nsSystemPref::FixupLockdownPrefs()
{
- if (!mSysPrefService)
- return NS_ERROR_FAILURE;
- nsresult rv;
-
- nsCOMPtr<nsIPrefBranch> prefBranch
- (do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
+ nsCOMPtr<nsIPrefBranch2> userPrefs = GetPrefUserBranch();
+ nsCOMPtr<nsIPrefBranch2> defaultPrefs = GetPrefUserBranch();
+ PRUint32 childCount;
+ char **childArray = nsnull;
+ nsresult rv = userPrefs->GetChildList("config.lockdown.",
+ &childCount, &childArray);
if (NS_FAILED(rv))
return rv;
-
- SYSPREF_LOG(("about to read aPrefName %s\n", aPrefName));
-
- prefBranch->UnlockPref(aPrefName);
-
- PRInt32 prefType = nsIPrefBranch::PREF_INVALID;
- nsXPIDLCString strValue;
- PRInt32 intValue = 0;
- PRBool boolValue = PR_FALSE;
-
- rv = prefBranch->GetPrefType(aPrefName, &prefType);
- if (NS_FAILED(rv))
- return rv;
- switch (prefType) {
- case nsIPrefBranch::PREF_STRING:
- mSysPrefService->GetCharPref(aPrefName, getter_Copies(strValue));
- SYSPREF_LOG(("system value is %s\n", strValue.get()));
-
- prefBranch->SetCharPref(aPrefName, strValue.get());
- break;
- case nsIPrefBranch::PREF_INT:
- mSysPrefService->GetIntPref(aPrefName, &intValue);
- SYSPREF_LOG(("system value is %d\n", intValue));
-
- prefBranch->SetIntPref(aPrefName, intValue);
- break;
- case nsIPrefBranch::PREF_BOOL:
- mSysPrefService->GetBoolPref(aPrefName, &boolValue);
- SYSPREF_LOG(("system value is %s\n", boolValue ? "TRUE" : "FALSE"));
-
- prefBranch->SetBoolPref(aPrefName, boolValue);
- break;
- default:
- SYSPREF_LOG(("Fail to system value for it\n"));
- return NS_ERROR_FAILURE;
+ for (PRUint32 i = 0; i < childCount; ++i) {
+ PRInt32 type;
+ rv = defaultPrefs->GetPrefType(childArray[i], &type);
+ if (NS_FAILED(rv))
+ return rv;
+ NS_ASSERTION(type == nsIPrefBranch2::PREF_BOOL,
+ "All config.lockdown.* prefs should be boolean");
+ if (type == nsIPrefBranch2::PREF_BOOL) {
+ rv = defaultPrefs->SetBoolPref(childArray[i], PR_FALSE);
+ if (NS_FAILED(rv))
+ return rv;
+ }
}
- prefBranch->LockPref(aPrefName);
+ NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(childCount, childArray);
return NS_OK;
}
-//////////////////////////////////////////////////////////////////////
-// nsSystemPref::UseMozillaPrefs
-// Restore mozilla default prefs, remove system pref listeners
-/////////////////////////////////////////////////////////////////////
+
nsresult
-nsSystemPref::UseMozillaPrefs()
+nsSystemPref::LoadSystemPrefs()
{
- nsresult rv = NS_OK;
- SYSPREF_LOG(("\n====Now rollback to Mozilla prefs==\n"));
+ SYSPREF_LOG(("\n====Now Use system prefs==\n"));
+ NS_ASSERTION(!mSysPrefService,
+ "Shouldn't have the pref service here");
+ nsresult rv;
+ mSysPrefService = do_GetService(NS_SYSTEMPREF_SERVICE_CONTRACTID, &rv);
+ if (NS_FAILED(rv) || !mSysPrefService) {
+ FixupLockdownPrefs();
+ SYSPREF_LOG(("...No System Pref Service\n"));
+ return NS_OK;
+ }
- // if we did not use system prefs, do nothing
- if (!mSysPrefService)
- return NS_OK;
+ // Cache the pref-branch while we load up the system prefs.
+ NS_ASSERTION(!mCachedUserPrefBranch,
+ "Shouldn't have a cache here");
+ nsCOMPtr<nsIPrefBranch2> userBranch = GetPrefUserBranch();
+ nsCOMPtr<nsIPrefBranch> defaultBranch = GetPrefDefaultBranch();
+ mCachedDefaultPrefBranch = defaultBranch;
+ mCachedUserPrefBranch = userBranch;
+ rv = mSysPrefService->LoadSystemPreferences(this);
+ mCachedDefaultPrefBranch = nsnull;
+ mCachedUserPrefBranch = nsnull;
- PRIntn sysPrefCount= sizeof(sSysPrefList) / sizeof(sSysPrefList[0]);
- for (PRIntn index = 0; index < sysPrefCount; ++index) {
- // restore mozilla default value and free string memory if needed
- RestoreMozDefaultPref(mSysPrefs[index].prefName,
- &mSysPrefs[index].defaultValue,
- mSysPrefs[index].isLocked);
- SYSPREF_LOG(("stop listening on %s\n", mSysPrefs[index].prefName));
- mSysPrefService->RemoveObserver(mSysPrefs[index].prefName,
- this);
+ if (NS_FAILED(rv)) {
+ // Restore all modified preferences to their original values
+ mSavedPrefs.EnumerateRead(RestorePref, this);
+ mSavedPrefs.Clear();
+ mSysPrefService = nsnull;
}
+
return rv;
}
-////////////////////////////////////////////////////////////////////////////
-// nsSystemPref::RestoreMozDefaultPref
-// Save the saved mozilla default value.
-// It is also responsible for allocate the string memory when needed, because
-// this method know what type of value is stored.
-/////////////////////////////////////////////////////////////////////////////
+
nsresult
-nsSystemPref::SaveMozDefaultPref(const char *aPrefName,
- MozPrefValue *aPrefValue,
- PRBool *aLocked)
+nsSystemPref::RestoreMozillaPrefs()
{
- NS_ENSURE_ARG_POINTER(aPrefName);
- NS_ENSURE_ARG_POINTER(aPrefValue);
- NS_ENSURE_ARG_POINTER(aLocked);
+ SYSPREF_LOG(("\n====Now rollback to Mozilla prefs==\n"));
- nsresult rv;
+ NS_ASSERTION(mSysPrefService,
+ "Should have the pref service here");
+ if (!mSysPrefService)
+ return NS_ERROR_FAILURE;
- nsCOMPtr<nsIPrefBranch> prefBranch =
- do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
- if (NS_FAILED(rv))
- return rv;
+ nsCOMPtr<nsIPrefBranch2> userBranch = GetPrefUserBranch();
+ nsCOMPtr<nsIPrefBranch> defaultBranch = GetPrefDefaultBranch();
+ mCachedDefaultPrefBranch = defaultBranch;
+ mCachedUserPrefBranch = userBranch;
- SYSPREF_LOG(("Save Mozilla value for %s\n", aPrefName));
+ mSysPrefService->NotifyUnloadSystemPreferences();
+ // Restore all modified preferences to their original values
+ mSavedPrefs.EnumerateRead(RestorePref, this);
+ mSavedPrefs.Clear();
- PRInt32 prefType = nsIPrefBranch::PREF_INVALID;
- nsXPIDLCString strValue;
+ mCachedDefaultPrefBranch = nsnull;
+ mCachedUserPrefBranch = nsnull;
+
+ mSysPrefService = nsnull;
- rv = prefBranch->GetPrefType(aPrefName, &prefType);
- if (NS_FAILED(rv))
- return rv;
- switch (prefType) {
- case nsIPrefBranch::PREF_STRING:
- prefBranch->GetCharPref(aPrefName,
- getter_Copies(strValue));
- SYSPREF_LOG(("Mozilla value is %s", strValue.get()));
+ FixupLockdownPrefs();
- if (aPrefValue->stringVal)
- PL_strfree(aPrefValue->stringVal);
- aPrefValue->stringVal = PL_strdup(strValue.get());
- break;
- case nsIPrefBranch::PREF_INT:
- prefBranch->GetIntPref(aPrefName, &aPrefValue->intVal);
- SYSPREF_LOG(("Mozilla value is %d\n", aPrefValue->intVal));
-
- break;
- case nsIPrefBranch::PREF_BOOL:
- prefBranch->GetBoolPref(aPrefName, &aPrefValue->boolVal);
- SYSPREF_LOG(("Mozilla value is %s\n",
- aPrefValue->boolVal ? "TRUE" : "FALSE"));
-
- break;
- default:
- SYSPREF_LOG(("Fail to Read Mozilla value for it\n"));
- return NS_ERROR_FAILURE;
- }
- rv = prefBranch->PrefIsLocked(aPrefName, aLocked);
- SYSPREF_LOG((" (%s).\n", aLocked ? "Locked" : "NOT Locked"));
- return rv;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// nsSystemPref::RestoreMozDefaultPref
-// Restore the saved mozilla default value to pref service.
-// It is also responsible for free the string memory when needed, because
-// this method know what type of value is stored.
-/////////////////////////////////////////////////////////////////////////////
-nsresult
-nsSystemPref::RestoreMozDefaultPref(const char *aPrefName,
- MozPrefValue *aPrefValue,
- PRBool aLocked)
-{
- NS_ENSURE_ARG_POINTER(aPrefName);
-
- nsresult rv;
-
- nsCOMPtr<nsIPrefBranch> prefBranch =
- do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
- if (NS_FAILED(rv))
- return rv;
-
- SYSPREF_LOG(("Restore Mozilla value for %s\n", aPrefName));
-
- PRInt32 prefType = nsIPrefBranch::PREF_INVALID;
- rv = prefBranch->GetPrefType(aPrefName, &prefType);
- if (NS_FAILED(rv))
- return rv;
-
- // unlock, if it is locked
- prefBranch->UnlockPref(aPrefName);
-
- switch (prefType) {
- case nsIPrefBranch::PREF_STRING:
- prefBranch->SetCharPref(aPrefName,
- aPrefValue->stringVal);
- SYSPREF_LOG(("Mozilla value is %s\n", aPrefValue->stringVal));
-
- PL_strfree(aPrefValue->stringVal);
- aPrefValue->stringVal = nsnull;
-
- break;
- case nsIPrefBranch::PREF_INT:
- prefBranch->SetIntPref(aPrefName, aPrefValue->intVal);
- SYSPREF_LOG(("Mozilla value is %d\n", aPrefValue->intVal));
-
- break;
- case nsIPrefBranch::PREF_BOOL:
- prefBranch->SetBoolPref(aPrefName, aPrefValue->boolVal);
- SYSPREF_LOG(("Mozilla value is %s\n",
- aPrefValue->boolVal ? "TRUE" : "FALSE"));
-
- break;
- default:
- SYSPREF_LOG(("Fail to Restore Mozilla value for it\n"));
- return NS_ERROR_FAILURE;
- }
-
- // restore its old lock status
- if (aLocked)
- prefBranch->LockPref(aPrefName);
return NS_OK;
}
diff --git a/extensions/pref/system-pref/src/nsSystemPref.h b/extensions/pref/system-pref/src/nsSystemPref.h
--- a/extensions/pref/system-pref/src/nsSystemPref.h
+++ b/extensions/pref/system-pref/src/nsSystemPref.h
@@ -18,17 +18,17 @@
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is Sun Microsystems, Inc.
* Portions created by Sun Microsystems are Copyright (C) 2003 Sun
* Microsystems, Inc. All Rights Reserved.
*
* Original Author: Bolian Yin (bolian.yin@sun.com)
*
- * Contributor(s):
+ * Contributor(s): Robert O'Callahan/Novell (rocallahan@novell.com)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
@@ -40,71 +40,101 @@
* ***** END LICENSE BLOCK ***** */
#ifndef __SYSTEM_PREF_H__
#define __SYSTEM_PREF_H__
#include "nsCOMPtr.h"
#include "nsXPCOM.h"
#include "nsCRT.h"
-#include "nsIAppStartupNotifier.h"
-#include "nsICategoryManager.h"
-#include "nsIServiceManager.h"
#include "nsWeakReference.h"
-#include "nsIPrefService.h"
-#include "nsIPrefBranch2.h"
+#include "nsClassHashtable.h"
+#include "nsHashKeys.h"
+#include "nsMemory.h"
-#include <nsIObserver.h>
+#include "nsISystemPrefService.h"
+#include "nsIObserver.h"
-union MozPrefValue;
struct SysPrefItem;
//////////////////////////////////////////////////////////////////////////
//
// nsSystemPref, as an extension of mozilla pref service, reads some mozilla
// prefs from host system when the feature is enabled ("config.system-pref").
//
-// nsSystemPref listens on NS_PREFSERVICE_READ_TOPIC_ID. When notified,
-// nsSystemPref will start the nsSystemPrefService (platform specific) to
-// read all the interested prefs (listed in sSysPrefList table) from system
-// and lock these prefs from user's modification.
+// nsSystemPref listens on NS_PREFSERVICE_READ_TOPIC_ID. When
+// notified, nsSystemPref will start the nsSystemPrefService (platform
+// specific) and tell it to override Mozilla prefs with its own
+// settings.
//
-// This feature will make mozilla integrated better into host platforms. If
-// users want to change the prefs read from system, the system provided pref
-// editor (i.e. gconf-editor in gnome) should be used.
+// When overriding a Mozilla preference the prefservice can request the
+// pref be locked or unlocked. If the pref is locked then we set the default
+// value and lock it in Mozilla so the user value is ignored and the user cannot
+// change the value. If the pref is unlocked then we set the user value
+// and unlock it in Mozilla so the user can change it. If the user changes it,
+// then the prefservice is notified so it can copy the value back to its
+// underlying store.
+//
+// We detect changes to Mozilla prefs by observing pref changes in the
+// user branch.
+//
+// For testing purposes, if the user toggles on
+// config.use_system_prefs then we save the current preferences before
+// overriding them from gconf, and if the user toggles off
+// config.use_system_prefs *in the same session* then we restore the
+// preferences. If the user exits without turning off use_system_prefs
+// then the saved values are lost and the new values are permanent.
+//
//////////////////////////////////////////////////////////////////////////
class nsSystemPref : public nsIObserver,
- public nsSupportsWeakReference
+ public nsSupportsWeakReference,
+ public nsISystemPref
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
nsSystemPref();
virtual ~nsSystemPref();
nsresult Init(void);
+ // nsISystemPref
+ virtual nsresult SetOverridingMozillaBoolPref(const char* aPrefName,
+ PRBool aValue, PRBool aLocked,
+ PRBool aPresent = PR_TRUE);
+ virtual nsresult SetOverridingMozillaIntPref(const char* aPrefName,
+ PRInt32 aValue, PRBool aLocked,
+ PRBool aPresent = PR_TRUE);
+ virtual nsresult SetOverridingMozillaStringPref(const char* aPrefName,
+ const char* aValue, PRBool aLocked,
+ PRBool aPresent = PR_TRUE);
+ virtual nsresult StopOverridingMozillaPref(const char* aPrefName);
+ virtual already_AddRefed<nsIPrefBranch2> GetPrefUserBranch();
+ virtual already_AddRefed<nsIPrefBranch> GetPrefDefaultBranch();
+
private:
- // funcs used to load system prefs and save mozilla default prefs
- nsresult UseSystemPrefs();
- nsresult ReadSystemPref(const char *aPrefName);
- nsresult SaveMozDefaultPref(const char *aPrefName,
- MozPrefValue *aPrefVal,
- PRBool *aLocked);
+ // If we don't load the system prefs for any reason, then
+ // set all config.lockdown.* preferences to PR_FALSE so that
+ // residual lockdown settings are removed.
+ nsresult FixupLockdownPrefs();
- // funcs used to load mozilla default prefs
- nsresult UseMozillaPrefs();
- nsresult RestoreMozDefaultPref(const char *aPrefName,
- MozPrefValue *aPrefVal,
- PRBool aLocked);
+ nsresult LoadSystemPrefs();
- nsCOMPtr<nsIPrefBranch2> mSysPrefService;
- PRBool mEnabled; // system pref is enabled or not
- SysPrefItem *mSysPrefs;
+ nsresult RestoreMozillaPrefs();
+
+ nsresult OverridePref(const char* aPrefName, PRInt32 aType,
+ void* aValue, PRBool aLock, PRBool aPresent);
+
+ nsCOMPtr<nsISystemPrefService> mSysPrefService;
+ nsClassHashtable<nsCStringHashKey,SysPrefItem> mSavedPrefs;
+ // weak pointers to cached prefbranches
+ nsIPrefBranch2* mCachedUserPrefBranch;
+ nsIPrefBranch* mCachedDefaultPrefBranch;
+ PRPackedBool mIgnorePrefSetting;
};
#define NS_SYSTEMPREF_CID \
{ /* {549abb24-7c9d-4aba-915e-7ce0b716b32f} */ \
0x549abb24, \
0x7c9d, \
0x4aba, \
{ 0x91, 0x5e, 0x7c, 0xe0, 0xb7, 0x16, 0xb3, 0x2f } \
diff --git a/extensions/pref/system-pref/src/nsSystemPrefFactory.cpp b/extensions/pref/system-pref/src/nsSystemPrefFactory.cpp
--- a/extensions/pref/system-pref/src/nsSystemPrefFactory.cpp
+++ b/extensions/pref/system-pref/src/nsSystemPrefFactory.cpp
@@ -37,20 +37,20 @@
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsICategoryManager.h"
#include "nsIGenericFactory.h"
#include "nsSystemPref.h"
-#include "nsSystemPrefService.h"
+#include "nsIServiceManager.h"
+#include "nsIAppStartupNotifier.h"
NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsSystemPref, Init)
-NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsSystemPrefService, Init)
// Registering nsSystemPref module as part of the app-startup category to get
// it instantiated.
static NS_METHOD
RegisterSystemPref(nsIComponentManager *aCompMgr,
nsIFile *aPath,
const char *registryLocation,
@@ -91,16 +91,11 @@ UnRegisterSystemPref(nsIComponentManager
static const nsModuleComponentInfo components[] = {
{ NS_SYSTEMPREF_CLASSNAME,
NS_SYSTEMPREF_CID,
NS_SYSTEMPREF_CONTRACTID,
nsSystemPrefConstructor,
RegisterSystemPref,
UnRegisterSystemPref,
},
- { NS_SYSTEMPREF_SERVICE_CLASSNAME,
- NS_SYSTEMPREF_SERVICE_CID,
- NS_SYSTEMPREF_SERVICE_CONTRACTID,
- nsSystemPrefServiceConstructor,
- },
};
NS_IMPL_NSGETMODULE(nsSystemPrefModule, components)
diff --git a/toolkit/library/Makefile.in b/toolkit/library/Makefile.in
--- a/toolkit/library/Makefile.in
+++ b/toolkit/library/Makefile.in
@@ -225,16 +225,20 @@ endif
ifdef MOZ_ENABLE_LIBCONIC
EXTRA_DSO_LDOPTS += $(LIBCONIC_LIBS)
endif
ifdef MOZ_ENABLE_DBUS
EXTRA_DSO_LDOPTS += $(MOZ_DBUS_GLIB_LIBS)
endif
+ifdef MOZ_ENABLE_GCONF
+EXTRA_DSO_LDOPTS += $(MOZ_GCONF_LIBS)
+endif
+
ifeq (gtk2,$(MOZ_WIDGET_TOOLKIT))
EXTRA_DSO_LDOPTS += $(XLDFLAGS) $(XLIBS) $(XEXT_LIBS) $(XCOMPOSITE_LIBS) $(MOZ_PANGO_LIBS) $(MOZ_GTK2_LIBS) $(XT_LIBS) -lgthread-2.0
EXTRA_DSO_LDOPTS += $(FT2_LIBS)
endif
ifeq (qt,$(MOZ_WIDGET_TOOLKIT))
EXTRA_DSO_LDOPTS += $(XLDFLAGS) $(XLIBS) $(XT_LIBS) $(MOZ_QT_LIBS) -lgthread-2.0
EXTRA_DSO_LDOPTS += $(FT2_LIBS)
diff --git a/toolkit/toolkit-tiers.mk b/toolkit/toolkit-tiers.mk
--- a/toolkit/toolkit-tiers.mk
+++ b/toolkit/toolkit-tiers.mk
@@ -254,16 +254,23 @@ endif
ifdef MOZ_ENABLE_LIBXUL
tier_toolkit_dirs += xpcom/stub
endif
ifdef NS_TRACE_MALLOC
tier_toolkit_dirs += tools/trace-malloc
endif
+# gconf module is external
+ifdef MOZ_PREF_EXTENSIONS
+ifdef MOZ_ENABLE_GCONF
+tier_toolkit_dirs += extensions/pref/system-pref/src/gconf
+endif
+endif
+
ifdef MOZ_ENABLE_GNOME_COMPONENT
tier_toolkit_dirs += toolkit/system/gnome
endif
ifndef MOZ_ENABLE_LIBCONIC
# if libconic is present, it will do its own network monitoring
ifdef MOZ_ENABLE_DBUS
tier_toolkit_dirs += toolkit/system/dbus