The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #ifndef nsPrefBranch_h

 #define nsPrefBranch_h

 #include "nsCOMPtr.h"

 #include "nsIObserver.h"

 #include "nsIPrefBranch.h"

 #include "nsIPrefBranchInternal.h"

 #include "nsIPrefLocalizedString.h"

 #include "nsXPCOM.h"

 #include "nsISupportsPrimitives.h"

 #include "nsIRelativeFilePref.h"

 #include "nsIFile.h"

 #include "nsString.h"

 #include "nsTArray.h"

 #include "nsWeakReference.h"

 #include "nsClassHashtable.h"

 #include "nsCRT.h"

 #include "nsISupportsImpl.h"

 #include "mozilla/HashFunctions.h"

 #include "mozilla/MemoryReporting.h"

 namespace mozilla {

 class PreferenceServiceReporter;

 } // namespace mozilla;

 class nsPrefBranch;

 class PrefCallback : public PLDHashEntryHdr {

   friend class mozilla::PreferenceServiceReporter;

   public:

     typedef PrefCallback* KeyType;

     typedef const PrefCallback* KeyTypePointer;

     static const PrefCallback* KeyToPointer(PrefCallback *aKey)

     {

       return aKey;

     }

     static PLDHashNumber HashKey(const PrefCallback *aKey)

     {

       uint32_t hash = mozilla::HashString(aKey->mDomain);

       return mozilla::AddToHash(hash, aKey->mCanonical);

     }

   public:

     // Create a PrefCallback with a strong reference to its observer.

     PrefCallback(const char *aDomain, nsIObserver *aObserver,

                  nsPrefBranch *aBranch)

       : mDomain(aDomain),

         mBranch(aBranch),

         mWeakRef(nullptr),

         mStrongRef(aObserver)

     {

       MOZ_COUNT_CTOR(PrefCallback);

       nsCOMPtr<nsISupports> canonical = do_QueryInterface(aObserver);

       mCanonical = canonical;

     }

     // Create a PrefCallback with a weak reference to its observer.

     PrefCallback(const char *aDomain,

                  nsISupportsWeakReference *aObserver,

                  nsPrefBranch *aBranch)

       : mDomain(aDomain),

         mBranch(aBranch),

         mWeakRef(do_GetWeakReference(aObserver)),

         mStrongRef(nullptr)

     {

       MOZ_COUNT_CTOR(PrefCallback);

       nsCOMPtr<nsISupports> canonical = do_QueryInterface(aObserver);

       mCanonical = canonical;

     }

     // Copy constructor needs to be explicit or the linker complains.

     PrefCallback(const PrefCallback *&aCopy)

       : mDomain(aCopy->mDomain),

         mBranch(aCopy->mBranch),

         mWeakRef(aCopy->mWeakRef),

         mStrongRef(aCopy->mStrongRef),

         mCanonical(aCopy->mCanonical)

     {

       MOZ_COUNT_CTOR(PrefCallback);

     }

     ~PrefCallback()

     {

       MOZ_COUNT_DTOR(PrefCallback);

     }

     bool KeyEquals(const PrefCallback *aKey) const

     {

       // We want to be able to look up a weakly-referencing PrefCallback after

       // its observer has died so we can remove it from the table.  Once the

       // callback's observer dies, its canonical pointer is stale -- in

       // particular, we may have allocated a new observer in the same spot in

       // memory!  So we can't just compare canonical pointers to determine

       // whether aKey refers to the same observer as this.

       //

       // Our workaround is based on the way we use this hashtable: When we ask

       // the hashtable to remove a PrefCallback whose weak reference has

       // expired, we use as the key for removal the same object as was inserted

       // into the hashtable.  Thus we can say that if one of the keys' weak

       // references has expired, the two keys are equal iff they're the same

       // object.

       if (IsExpired() || aKey->IsExpired())

         return this == aKey;

       if (mCanonical != aKey->mCanonical)

         return false;

       return mDomain.Equals(aKey->mDomain);

     }

     PrefCallback *GetKey() const

     {

       return const_cast<PrefCallback*>(this);

     }

     // Get a reference to the callback's observer, or null if the observer was

     // weakly referenced and has been destroyed.

     already_AddRefed<nsIObserver> GetObserver() const

     {

       if (!IsWeak()) {

         nsCOMPtr<nsIObserver> copy = mStrongRef;

         return copy.forget();

       }

       nsCOMPtr<nsIObserver> observer = do_QueryReferent(mWeakRef);

       return observer.forget();

     }

     const nsCString& GetDomain() const

     {

       return mDomain;

     }

     nsPrefBranch* GetPrefBranch() const

     {

       return mBranch;

     }

     // Has this callback's weak reference died?

     bool IsExpired() const

     {

       if (!IsWeak())

         return false;

       nsCOMPtr<nsIObserver> observer(do_QueryReferent(mWeakRef));

       return !observer;

     }

     enum { ALLOW_MEMMOVE = true };

   private:

     nsCString             mDomain;

     nsPrefBranch         *mBranch;

     // Exactly one of mWeakRef and mStrongRef should be non-null.

     nsWeakPtr             mWeakRef;

     nsCOMPtr<nsIObserver> mStrongRef;

     // We need a canonical nsISupports pointer, per bug 578392.

     nsISupports          *mCanonical;

     bool IsWeak() const

     {

       return !!mWeakRef;

     }

 };

 class nsPrefBranch : public nsIPrefBranchInternal,

                      public nsIObserver,

                      public nsSupportsWeakReference

 {

   friend class mozilla::PreferenceServiceReporter;

 public:

   NS_DECL_ISUPPORTS

   NS_DECL_NSIPREFBRANCH

   NS_DECL_NSIPREFBRANCH2

   NS_DECL_NSIOBSERVER

   nsPrefBranch(const char *aPrefRoot, bool aDefaultBranch);

   virtual ~nsPrefBranch();

   int32_t GetRootLength() { return mPrefRootLength; }

   nsresult RemoveObserverFromMap(const char *aDomain, nsISupports *aObserver);

   static void NotifyObserver(const char *newpref, void *data);

   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);

 protected:

   nsPrefBranch()    /* disallow use of this constructer */

     { }

   nsresult   GetDefaultFromPropertiesFile(const char *aPrefName, char16_t **return_buf);

   // As SetCharPref, but without any check on the length of |aValue|

   nsresult   SetCharPrefInternal(const char *aPrefName, const char *aValue);

   // Reject strings that are more than 1Mb, warn if strings are more than 16kb

   nsresult   CheckSanityOfStringLength(const char* aPrefName, const nsAString& aValue);

   nsresult   CheckSanityOfStringLength(const char* aPrefName, const char* aValue);

   nsresult   CheckSanityOfStringLength(const char* aPrefName, const uint32_t aLength);

   void RemoveExpiredCallback(PrefCallback *aCallback);

   const char *getPrefName(const char *aPrefName);

   void       freeObserverList(void);

   friend PLDHashOperator

     FreeObserverFunc(PrefCallback *aKey,

                      nsAutoPtr<PrefCallback> &aCallback,

                      void *aArgs);

 private:

   int32_t               mPrefRootLength;

   nsCString             mPrefRoot;

   bool                  mIsDefault;

   bool                  mFreeingObserverList;

   nsClassHashtable<PrefCallback, PrefCallback> mObservers;

 };

 class nsPrefLocalizedString : public nsIPrefLocalizedString,

                               public nsISupportsString

 {

 public:

   nsPrefLocalizedString();

   virtual ~nsPrefLocalizedString();

   NS_DECL_ISUPPORTS

   NS_FORWARD_NSISUPPORTSSTRING(mUnicodeString->)

   NS_FORWARD_NSISUPPORTSPRIMITIVE(mUnicodeString->)

   nsresult Init();

 private:

   NS_IMETHOD GetData(char16_t**);

   NS_IMETHOD SetData(const char16_t* aData);

   NS_IMETHOD SetDataWithLength(uint32_t aLength, const char16_t *aData);

   nsCOMPtr<nsISupportsString> mUnicodeString;

 };

 class nsRelativeFilePref : public nsIRelativeFilePref

 {

 public:

   NS_DECL_ISUPPORTS

   NS_DECL_NSIRELATIVEFILEPREF

                 nsRelativeFilePref();

   virtual       ~nsRelativeFilePref();

 private:

   nsCOMPtr<nsIFile> mFile;

   nsCString mRelativeToKey;

 };

 #endif