1 From: various contributors

     2 Subject: replace gconf backend with more complete mapping for lockdown feature

     3 

     4 diff --git a/extensions/pref/Makefile.in b/extensions/pref/Makefile.in

     5 --- a/extensions/pref/Makefile.in

     6 +++ b/extensions/pref/Makefile.in

     7 @@ -40,13 +40,13 @@ DEPTH            = ../..

     8  topsrcdir        = @top_srcdir@

     9  srcdir           = @srcdir@

    10  VPATH            = @srcdir@

    11  

    12  include $(DEPTH)/config/autoconf.mk

    13  

    14  DIRS             = autoconfig

    15  

    16 -ifdef MOZ_ENABLE_GTK2

    17 +ifdef MOZ_ENABLE_GCONF

    18  DIRS		+= system-pref

    19  endif

    20  

    21  include $(topsrcdir)/config/rules.mk

    22 diff --git a/extensions/pref/system-pref/src/Makefile.in b/extensions/pref/system-pref/src/Makefile.in

    23 --- a/extensions/pref/system-pref/src/Makefile.in

    24 +++ b/extensions/pref/system-pref/src/Makefile.in

    25 @@ -38,47 +38,41 @@

    26  DEPTH = ../../../..

    27  topsrcdir = @top_srcdir@

    28  srcdir = @srcdir@

    29  VPATH = @srcdir@

    30  

    31  include $(DEPTH)/config/autoconf.mk

    32  

    33  MODULE = system-pref

    34 -LIBRARY_NAME = system-pref_s

    35 +LIBRARY_NAME = system-pref

    36  ifneq ($(OS_ARCH),WINNT)

    37  SHORT_LIBNAME = syspref

    38  endif

    39  

    40  # We want to force the creation of a static lib.

    41 -FORCE_STATIC_LIB = 1

    42 -LIBXUL_LIBRARY = 1

    43 +#FORCE_STATIC_LIB = 1

    44 +LIBXUL_LIBRARY   = 1

    45 +MODULE_NAME      = nsSystemPrefModule

    46 +IS_COMPONENT     = 1

    47 +EXPORT_LIBRARY   = 1

    48  

    49  REQUIRES        = xpcom \

    50  		  string \

    51  		  embedcomponents \

    52  		  pref \

    53  		  $(NULL)

    54  

    55 -ifdef MOZ_ENABLE_GTK2

    56 -DIRS		= gconf

    57 -endif

    58 +CPPSRCS =   \

    59 +  nsSystemPref.cpp	   \

    60 +  nsSystemPrefFactory.cpp  \

    61 +  $(NULL)

    62  

    63  EXTRA_DSO_LDOPTS = \

    64 -		-L$(DIST)/bin \

    65  		$(MOZ_COMPONENT_LIBS) \

    66  		$(NULL)

    67  

    68 -CPPSRCS =   \

    69 -  nsSystemPref.cpp	   \

    70 -  $(NULL)

    71 -

    72  EXPORTS		= \

    73 -		nsSystemPrefLog.h \

    74 +		nsISystemPrefService.h \

    75  		$(NULL)

    76  

    77  include $(topsrcdir)/config/rules.mk

    78  

    79 -ifdef MOZ_ENABLE_GTK2

    80 -INCLUDES	+= \

    81 -		-I$(srcdir)/gconf \

    82 -		$(NULL)

    83 -endif

    84 diff --git a/extensions/pref/system-pref/src/gconf/Makefile.in b/extensions/pref/system-pref/src/gconf/Makefile.in

    85 --- a/extensions/pref/system-pref/src/gconf/Makefile.in

    86 +++ b/extensions/pref/system-pref/src/gconf/Makefile.in

    87 @@ -37,50 +37,37 @@

    88  

    89  DEPTH = ../../../../..

    90  topsrcdir = @top_srcdir@

    91  srcdir = @srcdir@

    92  VPATH = @srcdir@

    93  

    94  include $(DEPTH)/config/autoconf.mk

    95  

    96 -MODULE = system-pref

    97 -LIBRARY_NAME = system-pref

    98 -LIBXUL_LIBRARY = 1

    99 +MODULE = system-pref-gconf

   100 +LIBRARY_NAME = system-pref-gconf

   101 +IS_COMPONENT = 1

   102 +MODULE_NAME = nsSystemPrefServiceModule

   103 +FORCE_SHARED_LIB = 1

   104  

   105  REQUIRES        = pref \

   106  		  string \

   107  		  xpcom \

   108 -		  embedcomponents \

   109 +		  necko \

   110  		  $(NULL)

   111  

   112  CPPSRCS =   \

   113  	nsSystemPrefService.cpp       \

   114 -	nsSystemPrefFactory.cpp \

   115  	$(NULL)

   116  

   117 -SHARED_LIBRARY_LIBS = ../libsystem-pref_s.a

   118 +OS_INCLUDES += $(MOZ_GCONF_CFLAGS)

   119 +

   120  

   121  EXTRA_DSO_LDOPTS = \

   122 -		-L$(DIST)/bin \

   123 -		$(MOZ_COMPONENT_LIBS) \

   124 -		$(MOZ_GTK2_LIBS) \

   125 +		$(XPCOM_GLUE_LDOPTS) \

   126 +		$(MOZ_GCONF_LIBS)    \

   127 +		$(NSPR_LIBS) \

   128  		$(NULL)

   129  

   130 -EXPORT_LIBRARY = 1

   131 -IS_COMPONENT = 1

   132 -MODULE_NAME	= nsSystemPrefModule

   133 -

   134 -EXPORTS		= \

   135 -		nsSystemPrefService.h \

   136 -		$(NULL)

   137  

   138  include $(topsrcdir)/config/rules.mk

   139  

   140 -CFLAGS		+= $(MOZ_GTK2_CFLAGS)

   141 -CXXFLAGS	+= $(MOZ_GTK2_CFLAGS)

   142 -

   143 -LOCAL_INCLUDES = -I$(srcdir)/..

   144 -

   145 -export::

   146 -	$(INSTALL) $(srcdir)/../nsSystemPrefFactory.cpp .

   147 -

   148  GARBAGE += nsSystemPrefFactory.cpp

   149 diff --git a/extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp b/extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp

   150 --- a/extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp

   151 +++ b/extensions/pref/system-pref/src/gconf/nsSystemPrefService.cpp

   152 @@ -18,17 +18,19 @@

   153   * The Original Code is mozilla.org code.

   154   *

   155   * The Initial Developer of the Original Code is Sun Microsystems, Inc.

   156   * Portions created by Sun Microsystems are Copyright (C) 2003 Sun

   157   * Microsystems, Inc. All Rights Reserved.

   158   *

   159   * Original Author: Bolian Yin (bolian.yin@sun.com)

   160   *

   161 - * Contributor(s):

   162 + * Contributor(s): Robert O'Callahan/Novell (rocallahan@novell.com)

   163 + *                 Hubert Figuiere (hfiguiere@novell.com)

   164 + *                 Wolfgang Rosenauer (wr@rosenauer.org)

   165   *

   166   * Alternatively, the contents of this file may be used under the terms of

   167   * either the GNU General Public License Version 2 or later (the "GPL"), or

   168   * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

   169   * in which case the provisions of the GPL or the LGPL are applicable instead

   170   * of those above. If you wish to allow use of your version of this file only

   171   * under the terms of either the GPL or the LGPL, and not to allow others to

   172   * use your version of this file under the terms of the NPL, indicate your

   173 @@ -36,299 +38,1300 @@

   174   * and other provisions required by the GPL or the LGPL. If you do not delete

   175   * the provisions above, a recipient may use your version of this file under

   176   * the terms of any one of the NPL, the GPL or the LGPL.

   177   *

   178   * ***** END LICENSE BLOCK ***** */

   179  

   180  #include <glib.h>

   181  #include <glib-object.h>

   182 +#include <gconf/gconf-client.h>

   183  

   184  #include "plstr.h"

   185  #include "nsCOMPtr.h"

   186 -#include "nsIPrefBranch.h"

   187 -#include "nsIPrefService.h"

   188 +#include "nsIPref.h"

   189  #include "nsIServiceManager.h"

   190  #include "nsIObserver.h"

   191  #include "nsWeakReference.h"

   192 +#include "nsIPrefBranch2.h"

   193 +#include "nsDataHashtable.h"

   194 +#include "nsHashKeys.h"

   195 +#include "nsICategoryManager.h"

   196 +#include "nsIGenericFactory.h"

   197 +#include "nsStringAPI.h"

   198 +#include "nsIPermissionManager.h"

   199 +#include "../nsSystemPref.h"

   200  

   201 -#include "nsString.h"

   202 -#include "nsSystemPrefLog.h"

   203 -#include "nsSystemPrefService.h"

   204 +#define NS_SYSTEMPREF_SERVICE_CID                  \

   205 +  { /* {3724e748-b088-4bf8-9298-aad426b66293} */       \

   206 +    0x3724e748,                                        \

   207 +    0xb088,                                            \

   208 +    0x4bf8,                                            \

   209 +        { 0x92, 0x98, 0xaa, 0xd4, 0x26, 0xb6, 0x62, 0x93 } \

   210 +  }

   211  

   212 -/*************************************************************************

   213 - * The strange thing here is that we load the gconf library manually and 

   214 - * search the function pointers we need. If that process fails, no gconf

   215 - * support is available in mozilla. The aim is to make mozilla independent

   216 - * on gconf, in both compile time and run time.

   217 - ************************************************************************/

   218 +#define NS_SYSTEMPREF_SERVICE_CLASSNAME "System Preferences Platform Service"

   219  

   220 -//gconf types

   221 -extern "C" {

   222 +NS_DEFINE_STATIC_IID_ACCESSOR(nsISystemPrefService, NS_ISYSTEMPREFSERVICE_IID)

   223  

   224 -    typedef enum {

   225 -        GCONF_VALUE_INVALID,

   226 -        GCONF_VALUE_STRING,

   227 -        GCONF_VALUE_INT,

   228 -        GCONF_VALUE_FLOAT,

   229 -        GCONF_VALUE_BOOL,

   230 -        GCONF_VALUE_SCHEMA,

   231 +/**

   232 + * We can link directly to the gconf library. If it's not available,

   233 + * this component just won't load and no system prefs will be offered.

   234 + */

   235  

   236 -        GCONF_VALUE_LIST,

   237 -        GCONF_VALUE_PAIR

   238 +#define NUM_ELEM(a) (sizeof(a)/sizeof(a[0]))

   239  

   240 -    }GConfValueType;

   241 +class nsSystemPrefService;

   242  

   243 -    typedef struct {

   244 -        GConfValueType type;

   245 -    }GConfValue;

   246 +/**

   247 + * List the preferences that have a simple mapping between Moz and gconf.

   248 + * These preferences have the same meaning and their values are

   249 + * automatically converted.

   250 + */

   251 +struct SimplePrefMapping {

   252 +    const char *mozPrefName;

   253 +    const char *gconfPrefName;

   254 +    /**

   255 +     * If this is PR_FALSE, then we never allow Mozilla to change

   256 +     * this setting. The Mozilla pref will always be locked.

   257 +     * If this is PR_TRUE then Mozilla will be allowed to change

   258 +     * the setting --- but only if it is writable in gconf.

   259 +     */

   260 +    PRBool allowWritesFromMozilla;

   261 +};

   262 +typedef nsresult (* ComplexGConfPrefChanged)(nsSystemPrefService* aPrefService,

   263 +                                             GConfClient* aClient);

   264 +typedef nsresult (* ComplexMozPrefChanged)(nsSystemPrefService* aPrefService,

   265 +                                           GConfClient* aClient);

   266 +struct ComplexGConfPrefMapping {

   267 +    const char* gconfPrefName;

   268 +    ComplexGConfPrefChanged callback;

   269 +};

   270  

   271 -    typedef void * (*GConfClientGetDefaultType) (void);

   272 -    typedef PRBool (*GConfClientGetBoolType) (void *client, const gchar *key,

   273 -                                              GError **err);

   274 -    typedef gchar* (*GConfClientGetStringType) (void *client, const gchar *key,

   275 -                                                GError **err);

   276 -    typedef PRInt32 (*GConfClientGetIntType) (void *client, const gchar *key,

   277 -                                              GError **err);

   278 -    typedef GSList* (*GConfClientGetListType) (void *client, const gchar *key,

   279 -                                               GConfValueType list_type,

   280 -                                               GError **err);

   281 -    typedef  void (*GConfClientNotifyFuncType) (void* client, guint cnxn_id,

   282 -                                                void *entry, 

   283 -                                                gpointer user_data);

   284 -    typedef guint (*GConfClientNotifyAddType) (void* client,

   285 -                                               const gchar* namespace_section,

   286 -                                               GConfClientNotifyFuncType func,

   287 -                                               gpointer user_data,

   288 -                                               GFreeFunc destroy_notify,

   289 -                                               GError** err);

   290 -    typedef void (*GConfClientNotifyRemoveType) (void *client,

   291 -                                                 guint cnxn);

   292 -    typedef void (*GConfClientAddDirType) (void *client,

   293 -                                           const gchar *dir,

   294 -                                           guint8 preload,

   295 -                                           GError **err);

   296 -    typedef void (*GConfClientRemoveDirType) (void *client,

   297 -                                              const gchar *dir,

   298 -                                              GError **err);

   299 +struct ComplexMozPrefMapping {

   300 +    const char* mozPrefName;

   301 +    ComplexMozPrefChanged callback;

   302 +};

   303  

   304 -    typedef const char* (*GConfEntryGetKeyType) (const void *entry);

   305 -    typedef GConfValue* (*GConfEntryGetValueType) (const void *entry);

   306 +class nsSystemPrefService : public nsISystemPrefService, nsIPrefBranch

   307 + {

   308 + public:

   309 +    NS_DECL_ISUPPORTS

   310 +    NS_DECL_NSIPREFBRANCH

   311  

   312 -    typedef const char* (*GConfValueGetStringType) (const GConfValue *value);

   313 -    typedef PRInt32 (*GConfValueGetIntType) (const GConfValue *value);

   314 -    typedef PRBool (*GConfValueGetBoolType) (const GConfValue *value);

   315 +    nsresult Init();

   316  

   317 -    

   318 -    static void gconf_key_listener (void* client, guint cnxn_id,

   319 -                                    void *entry, gpointer user_data);

   320 -}

   321 +    virtual nsresult LoadSystemPreferences(nsISystemPref* aPrefs);

   322 +    virtual nsresult NotifyMozillaPrefChanged(const char* aPrefName);

   323 +    virtual nsresult NotifyUnloadSystemPreferences();

   324  

   325 -struct GConfCallbackData

   326 -{

   327 -    GConfProxy *proxy;

   328 -    void * userData;

   329 -    PRUint32 atom;

   330 -    PRUint32 notifyId;

   331 -};

   332 -//////////////////////////////////////////////////////////////////////

   333 -// GConPrxoy is a thin wrapper for easy use of gconf funcs. It loads the

   334 -// gconf library and initializes the func pointers for later use.

   335 -//////////////////////////////////////////////////////////////////////

   336 -class GConfProxy

   337 -{

   338 -public:

   339 -    GConfProxy(nsSystemPrefService* aSysPrefService);

   340 -    ~GConfProxy();

   341 -    PRBool Init();

   342 +    nsSystemPrefService();

   343 +    virtual ~nsSystemPrefService();

   344  

   345 -    nsresult GetBoolPref(const char *aMozKey, PRBool *retval);

   346 -    nsresult GetCharPref(const char *aMozKey, char **retval);

   347 -    nsresult GetIntPref(const char *aMozKey, PRInt32 *retval);

   348 -

   349 -    nsresult NotifyAdd (PRUint32 aAtom, void *aUserData);

   350 -    nsresult NotifyRemove (PRUint32 aAtom, const void *aUserData);

   351 -

   352 -    nsresult GetAtomForMozKey(const char *aMozKey, PRUint32 *aAtom) {

   353 -        return GetAtom(aMozKey, 0, aAtom); 

   354 +    nsISystemPref* GetPrefs() { return mPref; }

   355 +    SimplePrefMapping* GetSimpleCallbackData(PRUint32 aKey) {

   356 +      SimplePrefMapping* result = nsnull;

   357 +      mGConfSimpleCallbacks.Get(aKey, &result);

   358 +      return result;

   359      }

   360 -    const char *GetMozKey(PRUint32 aAtom) {

   361 -        return GetKey(aAtom, 0); 

   362 -    }

   363 -

   364 -    void OnNotify(void *aClient, void * aEntry, PRUint32 aNotifyId,

   365 -                  GConfCallbackData *aData);

   366 +    ComplexGConfPrefMapping* GetComplexCallbackData(PRUint32 aKey) {

   367 +      ComplexGConfPrefMapping* result = nsnull;

   368 +      mGConfComplexCallbacks.Get(aKey, &result);

   369 +      return result;

   370 +     }

   371  

   372  private:

   373 -    void *mGConfClient;

   374 -    PRLibrary *mGConfLib;

   375 -    PRBool mInitialized;

   376 -    nsSystemPrefService *mSysPrefService;

   377 +    nsISystemPref* mPref;

   378 +    nsDataHashtable<nsUint32HashKey, SimplePrefMapping*> mGConfSimpleCallbacks;

   379 +    nsDataHashtable<nsUint32HashKey, ComplexGConfPrefMapping*> mGConfComplexCallbacks;

   380 +    // This is set to PR_FALSE temporarily to stop listening to gconf

   381 +    // change notifications (while we change gconf values)

   382 +    PRPackedBool mListenToGConf;

   383  

   384 -    //listeners

   385 -    nsAutoVoidArray *mObservers;

   386 -

   387 -    void InitFuncPtrs();

   388 -    //gconf public func ptrs

   389 -

   390 -    //gconf client funcs

   391 -    GConfClientGetDefaultType GConfClientGetDefault;

   392 -    GConfClientGetBoolType GConfClientGetBool;

   393 -    GConfClientGetStringType GConfClientGetString;

   394 -    GConfClientGetIntType GConfClientGetInt;

   395 -    GConfClientGetListType GConfClientGetList;

   396 -    GConfClientNotifyAddType GConfClientNotifyAdd;

   397 -    GConfClientNotifyRemoveType GConfClientNotifyRemove;

   398 -    GConfClientAddDirType GConfClientAddDir;

   399 -    GConfClientRemoveDirType GConfClientRemoveDir;

   400 -

   401 -    //gconf entry funcs

   402 -    GConfEntryGetValueType GConfEntryGetValue;

   403 -    GConfEntryGetKeyType GConfEntryGetKey;

   404 -

   405 -    //gconf value funcs

   406 -    GConfValueGetBoolType GConfValueGetBool;

   407 -    GConfValueGetStringType GConfValueGetString;

   408 -    GConfValueGetIntType GConfValueGetInt;

   409 -

   410 -    //pref name translating stuff

   411 -    nsresult GetAtom(const char *aKey, PRUint8 aNameType, PRUint32 *aAtom);

   412 -    nsresult GetAtomForGConfKey(const char *aGConfKey, PRUint32 *aAtom) \

   413 -    {return GetAtom(aGConfKey, 1, aAtom);}

   414 -    const char *GetKey(PRUint32 aAtom, PRUint8 aNameType);

   415 -    const char *GetGConfKey(PRUint32 aAtom) \

   416 -    {return GetKey(aAtom, 1); }

   417 -    inline const char *MozKey2GConfKey(const char *aMozKey);

   418 -

   419 -    //const strings

   420 -    static const char sPrefGConfKey[];

   421 -    static const char sDefaultLibName1[];

   422 -    static const char sDefaultLibName2[];

   423 +    GConfValue* GConfGet(const char *aPrefName);

   424  };

   425  

   426 -struct SysPrefCallbackData {

   427 -    nsISupports *observer;

   428 -    PRBool bIsWeakRef;

   429 -    PRUint32 prefAtom;

   430 -};

   431 -

   432 -PRBool

   433 -sysPrefDeleteObserver(void *aElement, void *aData) {

   434 -    SysPrefCallbackData *pElement =

   435 -        static_cast<SysPrefCallbackData *>(aElement);

   436 -    NS_RELEASE(pElement->observer);

   437 -    nsMemory::Free(pElement);

   438 -    return PR_TRUE;

   439 -}

   440 -

   441 -NS_IMPL_ISUPPORTS2(nsSystemPrefService, nsIPrefBranch, nsIPrefBranch2)

   442 -

   443 -/* public */

   444  nsSystemPrefService::nsSystemPrefService()

   445 -    :mInitialized(PR_FALSE),

   446 -     mGConf(nsnull),

   447 -     mObservers(nsnull)

   448 +   : mPref(nsnull), mListenToGConf(PR_TRUE)

   449  {

   450 +   mGConfSimpleCallbacks.Init();

   451 +   mGConfComplexCallbacks.Init();

   452  }

   453  

   454  nsSystemPrefService::~nsSystemPrefService()

   455  {

   456 -    mInitialized = PR_FALSE;

   457 -

   458 -    if (mGConf)

   459 -        delete mGConf;

   460 -    if (mObservers) {

   461 -        (void)mObservers->EnumerateForwards(sysPrefDeleteObserver, nsnull);

   462 -        delete mObservers;

   463 -    }

   464 +   NotifyUnloadSystemPreferences();

   465  }

   466  

   467  nsresult

   468  nsSystemPrefService::Init()

   469  {

   470 -    if (!gSysPrefLog) {

   471 -        gSysPrefLog = PR_NewLogModule("Syspref");

   472 -        if (!gSysPrefLog) return NS_ERROR_OUT_OF_MEMORY;

   473 +    return NS_OK;

   474 +}

   475 +

   476 +NS_IMPL_ISUPPORTS2(nsSystemPrefService, 

   477 +                   nsISystemPrefService, 

   478 +                   nsIPrefBranch)

   479 +

   480 +static GConfClient* GetGConf() {

   481 +    return gconf_client_get_default();

   482 +}

   483 +

   484 +static PRBool VerifyMatchingTypes(nsISystemPref* aPrefs,

   485 +                                  const char* aMozPref, GConfValue* aVal)

   486 +{

   487 +    nsCOMPtr<nsIPrefBranch2> prefBranch = aPrefs->GetPrefUserBranch();

   488 +    PRInt32 type;

   489 +    nsresult rv = prefBranch->GetPrefType(aMozPref, &type);

   490 +    if (NS_FAILED(rv)) {

   491 +        // pref probably doesn't exist. Let gconf set it.

   492 +        return PR_TRUE;

   493      }

   494  

   495 -    SYSPREF_LOG(("Init SystemPref Service\n"));

   496 -    if (mInitialized)

   497 +    PRBool ok;

   498 +    switch (aVal->type) {

   499 +    case GCONF_VALUE_STRING:

   500 +        ok = type == nsIPrefBranch2::PREF_STRING;

   501 +        break;

   502 +    case GCONF_VALUE_INT:

   503 +        ok = type == nsIPrefBranch2::PREF_INT;

   504 +        break;

   505 +    case GCONF_VALUE_BOOL:

   506 +        ok = type == nsIPrefBranch2::PREF_BOOL;

   507 +        break;

   508 +    default:

   509 +        NS_ERROR("Unhandled gconf preference type");

   510 +        return PR_FALSE;

   511 +    }

   512 +

   513 +    NS_ASSERTION(ok, "Mismatched gconf/Mozilla pref types");

   514 +    return ok;

   515 +}

   516 +

   517 +/**

   518 + * Map a gconf pref value into the corresponding Mozilla pref.

   519 + */

   520 +static nsresult ApplySimpleMapping(SimplePrefMapping* aMap,

   521 +                                   nsISystemPref* aPrefs,

   522 +                                   GConfClient* aClient)

   523 +{

   524 +    GConfValue* val = gconf_client_get(aClient, aMap->gconfPrefName, nsnull);

   525 +    if (!val) {

   526 +        // No gconf key, so there's really nothing to do

   527 +        return NS_OK;

   528 +    }

   529 +

   530 +    VerifyMatchingTypes(aPrefs, aMap->mozPrefName, val);

   531 +

   532 +    PRBool locked = !aMap->allowWritesFromMozilla ||

   533 +        !gconf_client_key_is_writable(aClient, aMap->gconfPrefName, nsnull);

   534 +    nsresult rv;

   535 +    switch (val->type) {

   536 +    case GCONF_VALUE_STRING: {

   537 +        const char* str = gconf_value_get_string(val);

   538 +        rv = aPrefs->SetOverridingMozillaStringPref(aMap->mozPrefName, str, locked);

   539 +        // XXX do we need to free 'str' here?

   540 +        break;

   541 +    }

   542 +    case GCONF_VALUE_INT:

   543 +        rv = aPrefs->SetOverridingMozillaIntPref(aMap->mozPrefName,

   544 +                                                 gconf_value_get_int(val), locked);

   545 +        break;

   546 +    case GCONF_VALUE_BOOL:

   547 +        rv = aPrefs->SetOverridingMozillaBoolPref(aMap->mozPrefName,

   548 +                                                  gconf_value_get_bool(val), locked);

   549 +        break;

   550 +    default:

   551 +        NS_ERROR("Unusable gconf value type");

   552 +        rv = NS_ERROR_FAILURE;

   553 +        break;

   554 +    }

   555 +

   556 +    gconf_value_free(val);

   557 +    return rv;

   558 +}

   559 +

   560 +/**

   561 + * Map a Mozilla pref into the corresponding gconf pref, if

   562 + * that's allowed.

   563 + */

   564 +static nsresult ReverseApplySimpleMapping(SimplePrefMapping* aMap,

   565 +                                          nsISystemPref* aPrefs,

   566 +                                          GConfClient* aClient)

   567 +{

   568 +    // Verify that the gconf key has the right type, if it exists

   569 +    GConfValue* val = gconf_client_get(aClient, aMap->gconfPrefName, nsnull);

   570 +    if (val) {

   571 +        VerifyMatchingTypes(aPrefs, aMap->mozPrefName, val);

   572 +        gconf_value_free(val);

   573 +    }

   574 +

   575 +    PRBool writable = aMap->allowWritesFromMozilla &&

   576 +        gconf_client_key_is_writable(aClient, aMap->gconfPrefName, nsnull);

   577 +    if (!writable) {

   578 +        NS_ERROR("Gconf key is not writable");

   579          return NS_ERROR_FAILURE;

   580 +    }

   581  

   582 -    if (!mGConf) {

   583 -        mGConf = new GConfProxy(this);

   584 -        if (!mGConf->Init()) {

   585 -            delete mGConf;

   586 -            mGConf = nsnull;

   587 +    nsCOMPtr<nsIPrefBranch2> prefBranch = aPrefs->GetPrefUserBranch();

   588 +    PRInt32 type;

   589 +    nsresult rv = prefBranch->GetPrefType(aMap->mozPrefName, &type);

   590 +    if (NS_FAILED(rv)) {

   591 +        NS_ERROR("Writing back a pref that doesn't exist?");

   592 +        return rv;

   593 +    }

   594 +

   595 +    switch (type) {

   596 +    case nsIPrefBranch2::PREF_STRING:

   597 +        {

   598 +            char* result;

   599 +            rv = prefBranch->GetCharPref(aMap->mozPrefName, &result);

   600 +            if (NS_FAILED(rv))

   601 +                return rv;

   602 +

   603 +            gconf_client_set_string(aClient, aMap->gconfPrefName, result, nsnull);

   604 +            nsMemory::Free(result);

   605 +        }

   606 +        break;

   607 +    case nsIPrefBranch2::PREF_INT:

   608 +        {

   609 +            PRInt32 result;

   610 +            rv = prefBranch->GetIntPref(aMap->mozPrefName, &result);

   611 +            if (NS_FAILED(rv))

   612 +                return rv;

   613 +

   614 +            gconf_client_set_int(aClient, aMap->gconfPrefName, result, nsnull);

   615 +        }

   616 +        break;

   617 +    case nsIPrefBranch2::PREF_BOOL:

   618 +        {

   619 +            PRBool result;

   620 +            rv = prefBranch->GetBoolPref(aMap->mozPrefName, &result);

   621 +            if (NS_FAILED(rv))

   622 +                return rv;

   623 +

   624 +            gconf_client_set_bool(aClient, aMap->gconfPrefName, result, nsnull);

   625 +        }

   626 +        break;

   627 +    default:

   628 +        NS_ERROR("Unhandled gconf preference type");

   629 +        return NS_ERROR_FAILURE;

   630 +    }

   631 +

   632 +    return NS_OK;

   633 +}

   634 +

   635 +/* BEGIN preference mapping definition area

   636 + *

   637 + * There are a few rules that our preference maps have to obey:

   638 + *

   639 + * 1) Each mapping defines a relationship R between a set of GConf preferences and

   640 + * a set of Mozilla preferences that must *always* be true. Thus, when a Mozilla

   641 + * pref changes or a gconf pref changes, we may need to change something on the

   642 + * other side to preserve R. If a GConf preference is read-only, then we may

   643 + * need to lock one or more Mozilla preferences to avoid a situation where the

   644 + * Mozilla preference changes and we can't update the GConf preference to

   645 + * ensure R continues to hold.

   646 + *

   647 + * 2) If an unlocked Mozilla preference is changed, then we can only

   648 + * preserve R by changing GConf preferences; we are not allowed to

   649 + * change Mozilla preferences.

   650 + *

   651 + * 3) If a GConf preference is changed, then we can only preserve R by

   652 + * changing Moozilla preferences; we are nt allowed to change GConf

   653 + * preferences.

   654 + *

   655 + * For "simple" mappings, the relationship R is just of the form

   656 + * "GConf preference 'A' is equal to Mozilla preference 'B'". R is

   657 + * preserved by setting A to B when B changes, and by setting B to A

   658 + * when A changes. If A is read-only then we lock B (or we may just

   659 + * decide to lock B for other reasons). Thus rules 1-3 are satisfied.

   660 + *

   661 + * For "complex" mappings we have more complicated

   662 + * relationships. These are documented below.

   663 + */

   664 +

   665 +static SimplePrefMapping sSimplePrefMappings[] = {

   666 +    // GNOME accessibility setting; never allow this to be set by Firefox

   667 +    {"config.use_system_prefs.accessibility",

   668 +     "/desktop/gnome/interface/accessibility", PR_FALSE},

   669 +

   670 +    // GConf Firefox preferences; allow these to be set through the Firefox UI

   671 +    {"security.enable_java", "/apps/firefox/web/java_enabled", PR_TRUE},

   672 +    {"javascript.enabled", "/apps/firefox/web/javascript_enabled", PR_TRUE},

   673 +    {"browser.startup.homepage", "/apps/firefox/general/homepage_url", PR_TRUE},

   674 +    {"browser.cache.disk.capacity", "/apps/firefox/web/cache_size", PR_TRUE},

   675 +    {"network.cookie.lifetimePolicy", "/apps/firefox/web/cookie_accept", PR_TRUE},

   676 +

   677 +    // UI lockdown settings; never allow these to be set by Firefox. There is no

   678 +    // Firefox UI for these but they could otherwise be set via about:config.

   679 +    {"config.lockdown.printing", "/desktop/gnome/lockdown/disable_printing", PR_FALSE},

   680 +    {"config.lockdown.printsetup", "/desktop/gnome/lockdown/disable_print_setup", PR_FALSE},

   681 +    {"config.lockdown.savepage", "/desktop/gnome/lockdown/disable_save_to_disk", PR_FALSE},

   682 +    {"config.lockdown.history", "/apps/firefox/lockdown/disable_history", PR_FALSE},

   683 +    {"config.lockdown.toolbarediting", "/apps/firefox/lockdown/disable_toolbar_editing", PR_FALSE},

   684 +    {"config.lockdown.urlbar", "/apps/firefox/lockdown/disable_url_bar", PR_FALSE},

   685 +    {"config.lockdown.bookmark", "/apps/firefox/lockdown/disable_bookmark_editing", PR_FALSE},

   686 +    {"config.lockdown.disable_themes", "/apps/firefox/lockdown/disable_themes", PR_FALSE},

   687 +    {"config.lockdown.disable_extensions", "/apps/firefox/lockdown/disable_extensions", PR_FALSE},

   688 +    {"config.lockdown.searchbar", "/apps/firefox/lockdown/disable_searchbar", PR_FALSE},

   689 +    {"config.lockdown.hidebookmark", "/apps/firefox/lockdown/hide_bookmark", PR_FALSE},

   690 +    {"config.lockdown.showsavedpasswords", "/apps/firefox/lockdown/disable_show_passwords", PR_FALSE},

   691 +};

   692 +

   693 +static nsresult ApplyListPref(nsSystemPrefService* aPrefService,

   694 +                             GConfClient* aClient,

   695 +                             const char* aGConfKey, const char* aMozKey,

   696 +                             char aSeparator)

   697 +{

   698 +    GSList* list = gconf_client_get_list(aClient, aGConfKey,

   699 +                                         GCONF_VALUE_STRING, nsnull);

   700 +    nsCAutoString str;

   701 +    for (GSList* l = list; l; l = l->next) {

   702 +        str.Append((const char*)l->data);

   703 +        if (l->next) {

   704 +            str.Append(aSeparator);

   705 +        }

   706 +    }

   707 +    PRBool lock = !gconf_client_key_is_writable(aClient, aGConfKey, nsnull);

   708 +    nsresult rv = aPrefService->GetPrefs()->

   709 +        SetOverridingMozillaStringPref(aMozKey, str.get(), lock);

   710 +    // XXX does this free the strings? Should it?

   711 +    g_slist_free(list);

   712 +    return rv;

   713 +}

   714 +static nsresult ReverseApplyListPref(nsSystemPrefService* aPrefService,

   715 +                                    GConfClient* aClient,

   716 +                                    const char* aGConfKey, const char* aMozKey,

   717 +                                    char aSeparator)

   718 +{

   719 +    char* data = nsnull;

   720 +    nsCOMPtr<nsIPrefBranch2> prefs =

   721 +        aPrefService->GetPrefs()->GetPrefUserBranch();

   722 +    prefs->GetCharPref(aMozKey, &data);

   723 +    if (!data)

   724 +        return NS_ERROR_FAILURE;

   725 +    nsresult rv = NS_OK;

   726 +    GSList* list = nsnull;

   727 +    PRInt32 i = 0;

   728 +    while (data[i]) {

   729 +        const char* nextComma = strchr(data+i, ',');

   730 +        PRInt32 tokLen = nextComma ? nextComma - (data+i) : strlen(data+i);

   731 +        char* tok = strndup(data+i, tokLen);

   732 +        if (!tok)

   733 +            break;

   734 +        GSList* newList = g_slist_append(list, tok);

   735 +        if (!newList) {

   736 +            rv = NS_ERROR_OUT_OF_MEMORY;

   737 +            break;

   738 +        }

   739 +        list = newList;

   740 +        if (!nextComma)

   741 +            break;

   742 +        i = nextComma + 1 - data;

   743 +    }

   744 +    nsMemory::Free(data);

   745 +    if (NS_SUCCEEDED(rv)) {

   746 +        if (gconf_client_key_is_writable(aClient, aGConfKey, nsnull))

   747 +            gconf_client_set_list(aClient, aGConfKey, GCONF_VALUE_STRING, list, nsnull);

   748 +        else

   749 +            NS_ERROR("Gconf key is not writable");

   750 +    }

   751 +    for (GSList* l = list; l; l = l->next) {

   752 +        free(l->data);

   753 +    }

   754 +    g_slist_free(list);

   755 +    return rv;

   756 +}

   757 +

   758 +/**

   759 + * The relationship R is

   760 + * "network.negotiate-auth.trusted-uris" is the comma-separated concatenation

   761 + * of the elements of the list "/apps/firefox/general/trusted_URIs"

   762 + */

   763 +static const char GConfKey_TrustedURIs[] = "/apps/firefox/general/trusted_URIs";

   764 +static const char MozKey_TrustedURIs[] = "network.negotiate-auth.trusted-uris";

   765 +static nsresult ApplyTrustedURIs(nsSystemPrefService* aPrefService,

   766 +                                GConfClient* aClient)

   767 +{

   768 +    return ApplyListPref(aPrefService, aClient,

   769 +                        GConfKey_TrustedURIs, MozKey_TrustedURIs, ',');

   770 +}

   771 +static nsresult ReverseApplyTrustedURIs(nsSystemPrefService* aPrefService,

   772 +                                       GConfClient* aClient)

   773 +{

   774 +    return ReverseApplyListPref(aPrefService, aClient,

   775 +                               GConfKey_TrustedURIs, MozKey_TrustedURIs, ',');

   776 +}

   777 +

   778 +/**

   779 + * The relationship R is

   780 + * "network.negotiate-auth.delegation-uris" is the comma-separated concatenation

   781 + * of the elements of the list "/apps/firefox/general/delegation_URIs"

   782 + */

   783 +static const char GConfKey_DelegationURIs[] = "/apps/firefox/general/delegation_URIs";

   784 +static const char MozKey_DelegationURIs[] = "network.negotiate-auth.delegation-uris";

   785 +static nsresult ApplyDelegationURIs(nsSystemPrefService* aPrefService,

   786 +                                   GConfClient* aClient)

   787 +{

   788 +    return ApplyListPref(aPrefService, aClient,

   789 +                        GConfKey_DelegationURIs, MozKey_DelegationURIs, ',');

   790 +}

   791 +static nsresult ReverseApplyDelegationURIs(nsSystemPrefService* aPrefService,

   792 +                                          GConfClient* aClient)

   793 +{

   794 +    return ReverseApplyListPref(aPrefService, aClient,

   795 +                               GConfKey_DelegationURIs, MozKey_DelegationURIs, ',');

   796 +}

   797 +

   798 +

   799 +/**

   800 + * The relationship R is

   801 + * If "/apps/firefox/web/download_defaultfolder" is the empty string, then

   802 + * "browser.download.useDownloadDir" is false;

   803 + * otherwise "browser.download.useDownloadDir" is true and "browser.download.folderList"

   804 + * is (0 if "/apps/firefox/web/download_defaultfolder" is "Desktop";

   805 + *     1 if "/apps/firefox/web/download_defaultfolder" is "My Downloads";

   806 + *     3 if "/apps/firefox/web/download_defaultfolder" is "Home";

   807 + *     otherwise 2 and "browser.download.dir" = "/apps/firefox/web/download_defaultfolder")

   808 + */

   809 +static const char GConfKey_DownloadFolder[] = "/apps/firefox/web/download_defaultfolder";

   810 +static const char MozKey_UseDownloadDir[] = "browser.download.useDownloadDir";

   811 +static const char MozKey_DownloadDirType[] = "browser.download.folderList";

   812 +static const char MozKey_DownloadDirExplicit[] = "browser.download.dir";

   813 +static nsresult ApplyDownloadFolder(nsSystemPrefService* aPrefService,

   814 +                                    GConfClient* aClient)

   815 +{

   816 +    char* str = gconf_client_get_string(aClient, GConfKey_DownloadFolder, nsnull);

   817 +    if (!str)

   818 +        return NS_ERROR_FAILURE;

   819 +    PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_DownloadFolder, nsnull);

   820 +    nsresult rv = aPrefService->GetPrefs()->

   821 +        SetOverridingMozillaBoolPref(MozKey_UseDownloadDir, *str != 0, lock);

   822 +    if (NS_FAILED(rv)) {

   823 +        g_free(str);

   824 +        return rv;

   825 +    }

   826 +    PRInt32 dirType = 0;

   827 +    if (!strcmp(str, "Desktop")) {

   828 +        dirType = 0;

   829 +    } else if (!strcmp(str, "My Downloads")) {

   830 +        dirType = 1;

   831 +    } else if (!strcmp(str, "Home")) {

   832 +        dirType = 3;

   833 +    } else {

   834 +        dirType = 2;

   835 +    }

   836 +    // Always set all three Mozilla preferences. This is simpler and avoids

   837 +    // problems; e.g., if the gconf value changes from "/home/rocallahan" to "Desktop"

   838 +    // we might leave MozKey_DownloadDirType accidentally locked.

   839 +    rv = aPrefService->GetPrefs()->

   840 +        SetOverridingMozillaIntPref(MozKey_DownloadDirType, dirType, lock);

   841 +    if (NS_SUCCEEDED(rv)) {

   842 +        rv = aPrefService->GetPrefs()->

   843 +            SetOverridingMozillaStringPref(MozKey_DownloadDirExplicit, str, lock);

   844 +    }

   845 +    g_free(str);

   846 +    return rv;

   847 +}

   848 +

   849 +static nsresult ReverseApplyDownloadFolder(nsSystemPrefService* aPrefService,

   850 +                                           GConfClient* aClient)

   851 +{

   852 +    PRBool useDownloadDir = PR_FALSE;

   853 +    const char* result;

   854 +    char* explicitStr = nsnull;

   855 +    nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();

   856 +    prefs->GetBoolPref(MozKey_UseDownloadDir, &useDownloadDir);

   857 +    if (!useDownloadDir) {

   858 +        result = "";

   859 +    } else {

   860 +        PRInt32 type = -1;

   861 +        prefs->GetIntPref(MozKey_DownloadDirType, &type);

   862 +        if (type < 0)

   863 +            return NS_ERROR_FAILURE;

   864 +        switch (type) {

   865 +        case 0: result = "Desktop"; break;

   866 +        case 1: result = "Downloads"; break;

   867 +        case 2:

   868 +            prefs->GetCharPref(MozKey_DownloadDirExplicit, &explicitStr);

   869 +            result = explicitStr;

   870 +            break;

   871 +        case 3: result = "Home"; break;

   872 +        default:

   873 +            NS_ERROR("Unknown download dir type");

   874              return NS_ERROR_FAILURE;

   875          }

   876      }

   877 +    if (!result)

   878 +        return NS_ERROR_FAILURE;

   879 +    if (gconf_client_key_is_writable(aClient, GConfKey_DownloadFolder, nsnull))

   880 +        gconf_client_set_string(aClient, GConfKey_DownloadFolder,

   881 +                                result, nsnull);

   882 +    else

   883 +        NS_ERROR("Gconf key is not writable");

   884 +    nsMemory::Free(explicitStr);

   885 +    return NS_OK;

   886 +}

   887  

   888 -    mInitialized = PR_TRUE;

   889 +/**

   890 + * The relationship R is

   891 + * "/apps/firefox/web/disable_cookies" is true if and only if

   892 + * "network.cookie.cookieBehavior" is 2 ('dontUse')

   893 + */

   894 +static const char GConfKey_DisableCookies[] = "/apps/firefox/web/disable_cookies";

   895 +static const char MozKey_CookieBehavior[] = "network.cookie.cookieBehavior";

   896 +static const char MozKey_CookieExceptions[] = "network.cookie.honorExceptions";

   897 +static const char MozKey_CookieViewExceptions[] = "pref.privacy.disable_button.cookie_exceptions";

   898 +static nsresult ApplyDisableCookies(nsSystemPrefService* aPrefService,

   899 +                                    GConfClient* aClient)

   900 +{

   901 +    gboolean disable = gconf_client_get_bool(aClient, GConfKey_DisableCookies, nsnull);

   902 +    PRInt32 behavior = -1;

   903 +    nsCOMPtr<nsIPrefBranch2> prefs =

   904 +        aPrefService->GetPrefs()->GetPrefUserBranch();

   905 +    prefs->GetIntPref(MozKey_CookieBehavior, &behavior);

   906 +    if (behavior < 0)

   907 +        return NS_ERROR_FAILURE;

   908 +    if (disable) {

   909 +        behavior = 2;

   910 +    } else {

   911 +        if (behavior == 2) {

   912 +            behavior = 0;

   913 +        }

   914 +    }

   915 +    PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_DisableCookies, nsnull);

   916 +    nsresult rv = aPrefService->GetPrefs()->

   917 +        SetOverridingMozillaBoolPref(MozKey_CookieExceptions, !lock, lock);

   918 +    if (NS_FAILED(rv))

   919 +      return rv;

   920 +    rv = aPrefService->GetPrefs()->

   921 +        SetOverridingMozillaBoolPref(MozKey_CookieViewExceptions, lock, lock);

   922 +    if (NS_FAILED(rv))

   923 +      return rv;

   924 +    return aPrefService->GetPrefs()->

   925 +        SetOverridingMozillaIntPref(MozKey_CookieBehavior, behavior, lock);

   926 +}

   927 +static nsresult ReverseApplyDisableCookies(nsSystemPrefService* aPrefService,

   928 +                                           GConfClient* aClient)

   929 +{

   930 +    PRInt32 behavior = -1;

   931 +    nsCOMPtr<nsIPrefBranch2> prefs =

   932 +        aPrefService->GetPrefs()->GetPrefUserBranch();

   933 +    prefs->GetIntPref(MozKey_CookieBehavior, &behavior);

   934 +    if (behavior < 0)

   935 +        return NS_ERROR_FAILURE;

   936 +    if (gconf_client_key_is_writable(aClient, GConfKey_DisableCookies, nsnull))

   937 +        gconf_client_set_bool(aClient, GConfKey_DisableCookies, behavior == 2, nsnull);

   938 +    else

   939 +        NS_ERROR("Gconf key is not writable");

   940      return NS_OK;

   941  }

   942  

   943 +static char const* windowOpenFeatures[] = {

   944 +    "dom.disable_window_open_feature.close",

   945 +    "dom.disable_window_open_feature.directories",

   946 +    "dom.disable_window_open_feature.location",

   947 +    "dom.disable_window_open_feature.menubar",

   948 +    "dom.disable_window_open_feature.minimizable",

   949 +    "dom.disable_window_open_feature.personalbar",

   950 +    "dom.disable_window_open_feature.resizable",

   951 +    "dom.disable_window_open_feature.scrollbars",

   952 +    "dom.disable_window_open_feature.status",

   953 +    "dom.disable_window_open_feature.titlebar",

   954 +    "dom.disable_window_open_feature.toolbar"

   955 +};

   956 +/**

   957 + * The relationship R is

   958 + * "/apps/firefox/lockdown/disable_javascript_chrome" is true if and only if

   959 + * all of windowOpenFeatures are true

   960 + */

   961 +static const char GConfKey_DisableJSChrome[] =

   962 +    "/apps/firefox/lockdown/disable_javascript_chrome";

   963 +static nsresult ApplyWindowOpen(nsSystemPrefService* aPrefService,

   964 +                                GConfClient* aClient)

   965 +{

   966 +    gboolean disable = gconf_client_get_bool(aClient, GConfKey_DisableJSChrome, nsnull);

   967 +    PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_DisableJSChrome, nsnull);

   968 +    PRBool curValues[NUM_ELEM(windowOpenFeatures)];

   969 +    PRUint32 i;

   970 +    nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();

   971 +    PRBool allDisabled = PR_TRUE;

   972 +    for (i = 0; i < NUM_ELEM(windowOpenFeatures); ++i) {

   973 +        nsresult rv = prefs->GetBoolPref(windowOpenFeatures[i], &curValues[i]);

   974 +        if (NS_FAILED(rv))

   975 +            return rv;

   976 +        if (!curValues[i]) {

   977 +            allDisabled = PR_FALSE;

   978 +        }

   979 +    }

   980 +    for (i = 0; i < NUM_ELEM(windowOpenFeatures); ++i) {

   981 +        PRBool newVal = curValues[i];

   982 +        if (disable) {

   983 +            newVal = PR_TRUE;

   984 +        } else if (allDisabled) {

   985 +            // If all disable-window-open-feature prefs are currently

   986 +            // PR_TRUE, then we need to set at least one of them to

   987 +            // PR_FALSE. Set all of them to PR_FALSE.

   988 +            newVal = PR_FALSE;

   989 +        } // If at least one disable-window-open-feature pref is

   990 +          // currently PR_FALSE, then we don't need to change anything

   991 +          // when the gconf pref says don't disable

   992 +        nsresult rv = aPrefService->GetPrefs()->

   993 +            SetOverridingMozillaBoolPref(windowOpenFeatures[i], newVal, lock);

   994 +        if (NS_FAILED(rv))

   995 +            return rv;

   996 +    }

   997 +    return NS_OK;

   998 +}

   999 +

  1000 +static nsresult ReverseApplyWindowOpen(nsSystemPrefService* aPrefService,

  1001 +                                       GConfClient* aClient)

  1002 +{

  1003 +    nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();

  1004 +    PRBool allDisabled = PR_TRUE;

  1005 +    PRBool curValues[NUM_ELEM(windowOpenFeatures)];

  1006 +    for (PRUint32 i = 0; i < NUM_ELEM(windowOpenFeatures); ++i) {

  1007 +        nsresult rv = prefs->GetBoolPref(windowOpenFeatures[i], &curValues[i]);

  1008 +        if (NS_FAILED(rv))

  1009 +            return rv;

  1010 +        if (!curValues[i]) {

  1011 +            allDisabled = PR_FALSE;

  1012 +        }

  1013 +    }

  1014 +    if (gconf_client_key_is_writable(aClient, GConfKey_DisableJSChrome, nsnull))

  1015 +        gconf_client_set_bool(aClient, GConfKey_DisableJSChrome, allDisabled, nsnull);

  1016 +    else

  1017 +        NS_ERROR("Gconf key is not writable");

  1018 +    return NS_OK;

  1019 +}

  1020 +

  1021 +/**

  1022 + * The relationship R is

  1023 + * If "/apps/firefox/lockdown/disable_unsafe_protocol" is true then

  1024 + * -- "network.protocol-handler.blocked-default" is true

  1025 + * -- "network.protocol-handler.blocked.XYZ" is false if and only if

  1026 + * XYZ is a builtin non-disablable protocol or in

  1027 + * "/apps/firefox/lockdown/additional_safe_protocols"

  1028 + * AND if "/apps/firefox/lockdown/disable_unsafe_protocol" is false then

  1029 + * -- "network.protocol-handler.blocked-default" is false

  1030 + * -- if "network.protocol-handler.blocked.XYZ" exists then it is false

  1031 + */

  1032 +static const char GConfKey_DisableUnsafeProtocols[] =

  1033 +    "/apps/firefox/lockdown/disable_unsafe_protocol";

  1034 +static const char GConfKey_AdditionalSafeProtocols[] =

  1035 +    "/apps/firefox/lockdown/additional_safe_protocols";

  1036 +static const char MozKey_BlockedDefault[] =

  1037 +    "network.protocol-handler.blocked-default";

  1038 +static const char MozKey_BlockedPrefix[] =

  1039 +    "network.protocol-handler.blocked.";

  1040 +static const char* nonDisablableBuiltinProtocols[] =

  1041 +    { "about", "data", "jar", "keyword", "resource", "viewsource",

  1042 +      "chrome", "moz-icon", "javascript", "file" };

  1043 +static PRBool FindString(const char** aList, PRInt32 aCount,

  1044 +                         const char* aStr)

  1045 +{

  1046 +    for (PRInt32 i = 0; i < aCount; ++i) {

  1047 +        if (!strcmp(aStr, aList[i]))

  1048 +            return PR_TRUE;

  1049 +    }

  1050 +    return PR_FALSE;

  1051 +}

  1052 +typedef nsDataHashtable<nsCStringHashKey,int> StringSet;

  1053 +/** Collect the set of protocol names that we want to set preferences for */

  1054 +static nsresult AddAllProtocols(nsSystemPrefService* aPrefService,

  1055 +                                const char* aSafeProtocols,

  1056 +                                StringSet* aProtocolSet,

  1057 +                                StringSet* aSafeSet)

  1058 +{

  1059 +    nsCOMPtr<nsIPrefBranch2> prefs = aPrefService->GetPrefs()->GetPrefUserBranch();

  1060 +    PRUint32 childCount;

  1061 +    char **childArray = nsnull;

  1062 +    nsresult rv = prefs->GetChildList(MozKey_BlockedPrefix, &childCount, &childArray);

  1063 +    if (NS_FAILED(rv))

  1064 +        return rv;

  1065 +    PRUint32 i;

  1066 +    for (i = 0; i < childCount; ++i) {

  1067 +        nsDependentCString tmp(childArray[i] + NUM_ELEM(MozKey_BlockedPrefix)-1);

  1068 +        aProtocolSet->Put(tmp, 1); // copies

  1069 +    }

  1070 +    for (i = 0; i < NUM_ELEM(nonDisablableBuiltinProtocols); ++i) {

  1071 +        nsDependentCString tmp(nonDisablableBuiltinProtocols[i]);

  1072 +        aProtocolSet->Put(tmp, 1);

  1073 +    }

  1074 +    i = 0;

  1075 +    while (aSafeProtocols[i]) {

  1076 +        const char* nextComma = strchr(aSafeProtocols+i, ',');

  1077 +        PRUint32 tokLen = nextComma ? nextComma - (aSafeProtocols+i)

  1078 +            : strlen(aSafeProtocols+i);

  1079 +        nsCAutoString tok(aSafeProtocols+i, tokLen);

  1080 +        aProtocolSet->Put(tok, 1);

  1081 +        aSafeSet->Put(tok, 1);

  1082 +        if (nextComma) {

  1083 +            i = nextComma - aSafeProtocols + 1;

  1084 +        } else {

  1085 +            break;

  1086 +        }

  1087 +    }

  1088 +    NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(childCount, childArray);

  1089 +    return NS_OK;

  1090 +}

  1091 +

  1092 +struct ProtocolPrefClosure {

  1093 +    StringSet safeProtocolSet;

  1094 +    nsIPrefBranch2* prefs;

  1095 +    nsISystemPref* prefSetter;

  1096 +    PRPackedBool disableUnsafe;

  1097 +    PRPackedBool lock;

  1098 +};

  1099 +

  1100 +static PLDHashOperator PR_CALLBACK SetProtocolPref(const nsACString& aKey,

  1101 +                                                   int aItem,

  1102 +                                                   void* aClosure)

  1103 +{

  1104 +    ProtocolPrefClosure* closure = static_cast<ProtocolPrefClosure*>(aClosure);

  1105 +    const nsCString& protocol = PromiseFlatCString(aKey);

  1106 +    PRBool blockProtocol = PR_FALSE;

  1107 +    if (closure->disableUnsafe &&

  1108 +        !FindString(nonDisablableBuiltinProtocols,

  1109 +                    NUM_ELEM(nonDisablableBuiltinProtocols), protocol.get()) &&

  1110 +        !closure->safeProtocolSet.Get(aKey, nsnull)) {

  1111 +        blockProtocol = PR_TRUE;

  1112 +    }

  1113 +

  1114 +    nsCAutoString prefName;

  1115 +    prefName.Append(MozKey_BlockedPrefix);

  1116 +    prefName.Append(protocol);

  1117 +    closure->prefSetter->SetOverridingMozillaBoolPref(prefName.get(), blockProtocol,

  1118 +                                                      closure->lock);

  1119 +    return PL_DHASH_NEXT;

  1120 +}

  1121 +static nsresult ApplyUnsafeProtocols(nsSystemPrefService* aPrefService,

  1122 +                                     GConfClient* aClient)

  1123 +{

  1124 +    PRBool lock = !gconf_client_key_is_writable(aClient, GConfKey_DisableUnsafeProtocols, nsnull)

  1125 +        || !gconf_client_key_is_writable(aClient, GConfKey_AdditionalSafeProtocols, nsnull);

  1126 +    gboolean disable = gconf_client_get_bool(aClient, GConfKey_DisableUnsafeProtocols, nsnull);

  1127 +    char* protocols = gconf_client_get_string(aClient, GConfKey_AdditionalSafeProtocols, nsnull);

  1128 +    if (!protocols)

  1129 +        return NS_ERROR_FAILURE;

  1130 +    nsresult rv = aPrefService->GetPrefs()->

  1131 +        SetOverridingMozillaBoolPref(MozKey_BlockedDefault, disable, lock);

  1132 +    StringSet protocolSet;

  1133 +    ProtocolPrefClosure closure;

  1134 +    protocolSet.Init();

  1135 +    closure.safeProtocolSet.Init();