summaryrefslogtreecommitdiffstats
path: root/extensions/cookie/nsPermissionManager.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /extensions/cookie/nsPermissionManager.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'extensions/cookie/nsPermissionManager.h')
-rw-r--r--extensions/cookie/nsPermissionManager.h295
1 files changed, 295 insertions, 0 deletions
diff --git a/extensions/cookie/nsPermissionManager.h b/extensions/cookie/nsPermissionManager.h
new file mode 100644
index 000000000..4b21500b1
--- /dev/null
+++ b/extensions/cookie/nsPermissionManager.h
@@ -0,0 +1,295 @@
+/* -*- Mode: C++; tab-width: 8; 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 nsPermissionManager_h__
+#define nsPermissionManager_h__
+
+#include "nsIPermissionManager.h"
+#include "nsIObserver.h"
+#include "nsWeakReference.h"
+#include "nsCOMPtr.h"
+#include "nsIInputStream.h"
+#include "nsTHashtable.h"
+#include "nsTArray.h"
+#include "nsString.h"
+#include "nsPermission.h"
+#include "nsHashKeys.h"
+#include "nsCOMArray.h"
+#include "nsDataHashtable.h"
+
+namespace mozilla {
+class OriginAttributesPattern;
+}
+
+class nsIPermission;
+class mozIStorageConnection;
+class mozIStorageAsyncStatement;
+
+////////////////////////////////////////////////////////////////////////////////
+
+class nsPermissionManager final : public nsIPermissionManager,
+ public nsIObserver,
+ public nsSupportsWeakReference
+{
+public:
+ class PermissionEntry
+ {
+ public:
+ PermissionEntry(int64_t aID, uint32_t aType, uint32_t aPermission,
+ uint32_t aExpireType, int64_t aExpireTime,
+ int64_t aModificationTime)
+ : mID(aID)
+ , mType(aType)
+ , mPermission(aPermission)
+ , mExpireType(aExpireType)
+ , mExpireTime(aExpireTime)
+ , mModificationTime(aModificationTime)
+ , mNonSessionPermission(aPermission)
+ , mNonSessionExpireType(aExpireType)
+ , mNonSessionExpireTime(aExpireTime)
+ {}
+
+ int64_t mID;
+ uint32_t mType;
+ uint32_t mPermission;
+ uint32_t mExpireType;
+ int64_t mExpireTime;
+ int64_t mModificationTime;
+ uint32_t mNonSessionPermission;
+ uint32_t mNonSessionExpireType;
+ uint32_t mNonSessionExpireTime;
+ };
+
+ /**
+ * PermissionKey is the key used by PermissionHashKey hash table.
+ *
+ * NOTE: It could be implementing nsIHashable but there is no reason to worry
+ * with XPCOM interfaces while we don't need to.
+ */
+ class PermissionKey
+ {
+ public:
+ explicit PermissionKey(nsIPrincipal* aPrincipal);
+ explicit PermissionKey(const nsACString& aOrigin)
+ : mOrigin(aOrigin)
+ {
+ }
+
+ bool operator==(const PermissionKey& aKey) const {
+ return mOrigin.Equals(aKey.mOrigin);
+ }
+
+ PLDHashNumber GetHashCode() const {
+ return mozilla::HashString(mOrigin);
+ }
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PermissionKey)
+
+ nsCString mOrigin;
+
+ private:
+ // Default ctor shouldn't be used.
+ PermissionKey() = delete;
+
+ // Dtor shouldn't be used outside of the class.
+ ~PermissionKey() {};
+ };
+
+ class PermissionHashKey : public nsRefPtrHashKey<PermissionKey>
+ {
+ public:
+ explicit PermissionHashKey(const PermissionKey* aPermissionKey)
+ : nsRefPtrHashKey<PermissionKey>(aPermissionKey)
+ {}
+
+ PermissionHashKey(const PermissionHashKey& toCopy)
+ : nsRefPtrHashKey<PermissionKey>(toCopy)
+ , mPermissions(toCopy.mPermissions)
+ {}
+
+ bool KeyEquals(const PermissionKey* aKey) const
+ {
+ return *aKey == *GetKey();
+ }
+
+ static PLDHashNumber HashKey(const PermissionKey* aKey)
+ {
+ return aKey->GetHashCode();
+ }
+
+ // Force the hashtable to use the copy constructor when shuffling entries
+ // around, otherwise the Auto part of our AutoTArray won't be happy!
+ enum { ALLOW_MEMMOVE = false };
+
+ inline nsTArray<PermissionEntry> & GetPermissions()
+ {
+ return mPermissions;
+ }
+
+ inline int32_t GetPermissionIndex(uint32_t aType) const
+ {
+ for (uint32_t i = 0; i < mPermissions.Length(); ++i)
+ if (mPermissions[i].mType == aType)
+ return i;
+
+ return -1;
+ }
+
+ inline PermissionEntry GetPermission(uint32_t aType) const
+ {
+ for (uint32_t i = 0; i < mPermissions.Length(); ++i)
+ if (mPermissions[i].mType == aType)
+ return mPermissions[i];
+
+ // unknown permission... return relevant data
+ return PermissionEntry(-1, aType, nsIPermissionManager::UNKNOWN_ACTION,
+ nsIPermissionManager::EXPIRE_NEVER, 0, 0);
+ }
+
+ private:
+ AutoTArray<PermissionEntry, 1> mPermissions;
+ };
+
+ // nsISupports
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIPERMISSIONMANAGER
+ NS_DECL_NSIOBSERVER
+
+ nsPermissionManager();
+ static nsIPermissionManager* GetXPCOMSingleton();
+ nsresult Init();
+
+ // enums for AddInternal()
+ enum OperationType {
+ eOperationNone,
+ eOperationAdding,
+ eOperationRemoving,
+ eOperationChanging,
+ eOperationReplacingDefault
+ };
+
+ enum DBOperationType {
+ eNoDBOperation,
+ eWriteToDB
+ };
+
+ enum NotifyOperationType {
+ eDontNotify,
+ eNotify
+ };
+
+ // A special value for a permission ID that indicates the ID was loaded as
+ // a default value. These will never be written to the database, but may
+ // be overridden with an explicit permission (including UNKNOWN_ACTION)
+ static const int64_t cIDPermissionIsDefault = -1;
+
+ nsresult AddInternal(nsIPrincipal* aPrincipal,
+ const nsAFlatCString &aType,
+ uint32_t aPermission,
+ int64_t aID,
+ uint32_t aExpireType,
+ int64_t aExpireTime,
+ int64_t aModificationTime,
+ NotifyOperationType aNotifyOperation,
+ DBOperationType aDBOperation,
+ const bool aIgnoreSessionPermissions = false);
+
+ /**
+ * Initialize the "clear-origin-attributes-data" observing.
+ * Will create a nsPermissionManager instance if needed.
+ * That way, we can prevent have nsPermissionManager created at startup just
+ * to be able to clear data when an application is uninstalled.
+ */
+ static void ClearOriginDataObserverInit();
+
+ nsresult
+ RemovePermissionsWithAttributes(mozilla::OriginAttributesPattern& aAttrs);
+
+private:
+ virtual ~nsPermissionManager();
+
+ int32_t GetTypeIndex(const char *aTypeString,
+ bool aAdd);
+
+ PermissionHashKey* GetPermissionHashKey(nsIPrincipal* aPrincipal,
+ uint32_t aType,
+ bool aExactHostMatch);
+
+ nsresult CommonTestPermission(nsIPrincipal* aPrincipal,
+ const char *aType,
+ uint32_t *aPermission,
+ bool aExactHostMatch,
+ bool aIncludingSession);
+
+ nsresult OpenDatabase(nsIFile* permissionsFile);
+ nsresult InitDB(bool aRemoveFile);
+ nsresult CreateTable();
+ nsresult Import();
+ nsresult ImportDefaults();
+ nsresult _DoImport(nsIInputStream *inputStream, mozIStorageConnection *aConn);
+ nsresult Read();
+ void NotifyObserversWithPermission(nsIPrincipal* aPrincipal,
+ const nsCString &aType,
+ uint32_t aPermission,
+ uint32_t aExpireType,
+ int64_t aExpireTime,
+ const char16_t *aData);
+ void NotifyObservers(nsIPermission *aPermission, const char16_t *aData);
+
+ // Finalize all statements, close the DB and null it.
+ // if aRebuildOnSuccess, reinitialize database
+ void CloseDB(bool aRebuildOnSuccess = false);
+
+ nsresult RemoveAllInternal(bool aNotifyObservers);
+ nsresult RemoveAllFromMemory();
+ static void UpdateDB(OperationType aOp,
+ mozIStorageAsyncStatement* aStmt,
+ int64_t aID,
+ const nsACString& aOrigin,
+ const nsACString& aType,
+ uint32_t aPermission,
+ uint32_t aExpireType,
+ int64_t aExpireTime,
+ int64_t aModificationTime);
+
+ /**
+ * This method removes all permissions modified after the specified time.
+ */
+ nsresult
+ RemoveAllModifiedSince(int64_t aModificationTime);
+
+ /**
+ * Retrieve permissions from chrome process.
+ */
+ nsresult
+ FetchPermissions();
+
+ nsCOMPtr<mozIStorageConnection> mDBConn;
+ nsCOMPtr<mozIStorageAsyncStatement> mStmtInsert;
+ nsCOMPtr<mozIStorageAsyncStatement> mStmtDelete;
+ nsCOMPtr<mozIStorageAsyncStatement> mStmtUpdate;
+
+ bool mMemoryOnlyDB;
+
+ nsTHashtable<PermissionHashKey> mPermissionTable;
+ // a unique, monotonically increasing id used to identify each database entry
+ int64_t mLargestID;
+
+ // An array to store the strings identifying the different types.
+ nsTArray<nsCString> mTypeArray;
+
+ // Initially, |false|. Set to |true| once shutdown has started, to avoid
+ // reopening the database.
+ bool mIsShuttingDown;
+
+ friend class DeleteFromMozHostListener;
+ friend class CloseDatabaseListener;
+};
+
+// {4F6B5E00-0C36-11d5-A535-0010A401EB10}
+#define NS_PERMISSIONMANAGER_CID \
+{ 0x4f6b5e00, 0xc36, 0x11d5, { 0xa5, 0x35, 0x0, 0x10, 0xa4, 0x1, 0xeb, 0x10 } }
+
+#endif /* nsPermissionManager_h__ */