The Tor Browser: comparison dom/src/storage/DOMStorageCache.h

--1:000000000000
+:861b574405b5
+/* -*- 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 nsDOMStorageCache_h___
+#define nsDOMStorageCache_h___
+#include "nsIURI.h"
+#include "nsIPrincipal.h"
+#include "nsITimer.h"
+#include "nsString.h"
+#include "nsDataHashtable.h"
+#include "nsHashKeys.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/Telemetry.h"
+#include "nsAutoPtr.h"
+namespace mozilla {
+namespace dom {
+class DOMStorage;
+class DOMStorageUsage;
+class DOMStorageManager;
+class DOMStorageDBBridge;
+// Interface class on which only the database or IPC may call.
+// Used to populate the cache with DB data.
+class DOMStorageCacheBridge
+{
+public:
+NS_IMETHOD_(MozExternalRefCountType) AddRef(void);
+NS_IMETHOD_(void) Release(void);
+virtual ~DOMStorageCacheBridge() {}
+// The scope (origin) in the database usage format (reversed)
+virtual const nsCString& Scope() const = 0;
+// Whether the cache is already fully loaded
+virtual bool Loaded() = 0;
+// How many items has so far been loaded into the cache, used
+// for optimization purposes
+virtual uint32_t LoadedCount() = 0;
+// Called by the database to load a key and its value to the cache
+virtual bool LoadItem(const nsAString& aKey, const nsString& aValue) = 0;
+// Called by the database after all keys and values has been loaded
+// to this cache
+virtual void LoadDone(nsresult aRv) = 0;
+// Use to synchronously wait until the cache gets fully loaded with data,
+// this method exits after LoadDone has been called
+virtual void LoadWait() = 0;
+protected:
+ThreadSafeAutoRefCnt mRefCnt;
+NS_DECL_OWNINGTHREAD
+};
+// Implementation of scope cache that is responsible for preloading data
+// for persistent storage (localStorage) and hold data for non-private,
+// private and session-only cookie modes.  It is also responsible for
+// persisting data changes using the database, works as a write-back cache.
+class DOMStorageCache : public DOMStorageCacheBridge
+{
+public:
+NS_IMETHOD_(void) Release(void);
+DOMStorageCache(const nsACString* aScope);
+virtual ~DOMStorageCache();
+void Init(DOMStorageManager* aManager, bool aPersistent,
+nsIURI* aFirstPartyIsolationURI, nsIPrincipal* aPrincipal,
+const nsACString& aQuotaScope);
+// Copies all data from the other storage.
+void CloneFrom(const DOMStorageCache* aThat);
+// Starts async preload of this cache if it persistent and not loaded.
+void Preload();
+// Keeps the cache alive (i.e. present in the manager's hash table) for a time.
+void KeepAlive();
+// The set of methods that are invoked by DOM storage web API.
+// We are passing the DOMStorage object just to let the cache
+// read properties like mPrivate and mSessionOnly.
+// Get* methods return error when load from the database has failed.
+nsresult GetLength(const DOMStorage* aStorage, uint32_t* aRetval);
+nsresult GetKey(const DOMStorage* aStorage, uint32_t index, nsAString& aRetval);
+nsresult GetItem(const DOMStorage* aStorage, const nsAString& aKey, nsAString& aRetval);
+nsresult SetItem(const DOMStorage* aStorage, const nsAString& aKey, const nsString& aValue, nsString& aOld);
+nsresult RemoveItem(const DOMStorage* aStorage, const nsAString& aKey, nsString& aOld);
+nsresult Clear(const DOMStorage* aStorage);
+nsTArray<nsString>* GetKeys(const DOMStorage* aStorage);
+nsIURI* FirstPartyIsolationURI() const { return mFirstPartyIsolationURI; }
+// Whether the principal equals principal the cache was created for
+bool CheckPrincipal(nsIPrincipal* aPrincipal) const;
+nsIPrincipal* Principal() const { return mPrincipal; }
+// Starts the database engine thread or the IPC bridge
+static DOMStorageDBBridge* StartDatabase();
+static DOMStorageDBBridge* GetDatabase();
+// Stops the thread and flushes all uncommited data
+static nsresult StopDatabase();
+// DOMStorageCacheBridge
+virtual const nsCString& Scope() const { return mScope; }
+virtual bool Loaded() { return mLoaded; }
+virtual uint32_t LoadedCount();
+virtual bool LoadItem(const nsAString& aKey, const nsString& aValue);
+virtual void LoadDone(nsresult aRv);
+virtual void LoadWait();
+// Cache keeps 3 sets of data: regular, private and session-only.
+// This class keeps keys and values for a set and also caches
+// size of the data for quick per-origin quota checking.
+class Data
+{
+public:
+Data() : mOriginQuotaUsage(0) {}
+int64_t mOriginQuotaUsage;
+nsDataHashtable<nsStringHashKey, nsString> mKeys;
+};
+public:
+// Number of data sets we keep: default, private, session
+static const uint32_t kDataSetCount = 3;
+private:
+// API to clear the cache data, this is invoked by chrome operations
+// like cookie deletion.
+friend class DOMStorageManager;
+static const uint32_t kUnloadDefault = 1 << 0;
+static const uint32_t kUnloadPrivate = 1 << 1;
+static const uint32_t kUnloadSession = 1 << 2;
+static const uint32_t kUnloadComplete =
+kUnloadDefault | kUnloadPrivate | kUnloadSession;
+#ifdef DOM_STORAGE_TESTS
+static const uint32_t kTestReload    = 1 << 15;
+#endif
+void UnloadItems(uint32_t aUnloadFlags);
+private:
+// Synchronously blocks until the cache is fully loaded from the database
+void WaitForPreload(mozilla::Telemetry::ID aTelemetryID);
+// Helper to get one of the 3 data sets (regular, private, session)
+Data& DataSet(const DOMStorage* aStorage);
+// Whether the storage change is about to persist
+bool Persist(const DOMStorage* aStorage) const;
+// Changes the quota usage on the given data set if it fits the quota.
+// If not, then false is returned and no change to the set must be done.
+bool ProcessUsageDelta(uint32_t aGetDataSetIndex, const int64_t aDelta);
+bool ProcessUsageDelta(const DOMStorage* aStorage, const int64_t aDelta);
+private:
+// When a cache is reponsible for its life time (in case of localStorage data
+// cache) we need to refer our manager since removal of the cache from the hash
+// table is handled in the destructor by call to the manager.
+// Cache could potentially overlive the manager, hence the hard ref.
+nsRefPtr<DOMStorageManager> mManager;
+// Reference to the usage counter object we check on for eTLD+1 quota limit.
+// Obtained from the manager during initialization (Init method).
+nsRefPtr<DOMStorageUsage> mUsage;
+// Timer that holds this cache alive for a while after it has been preloaded.
+nsCOMPtr<nsITimer> mKeepAliveTimer;
+// The first party URI associated with this cache.
+nsCOMPtr<nsIURI> mFirstPartyIsolationURI;
+// Principal the cache has been initially created for, this is used only
+// for sessionStorage access checks since sessionStorage objects are strictly
+// scoped by a principal.  localStorage objects on the other hand are scoped by
+// origin only.
+nsCOMPtr<nsIPrincipal> mPrincipal;
+// The scope this cache belongs to in the "DB format", i.e. reversed
+nsCString mScope;
+// The eTLD+1 scope used to count quota usage.
+nsCString mQuotaScope;
+// Non-private Browsing, Private Browsing and Session Only sets.
+Data mData[kDataSetCount];
+// This monitor is used to wait for full load of data.
+mozilla::Monitor mMonitor;
+// Flag that is initially false.  When the cache is about to work with
+// the database (i.e. it is persistent) this flags is set to true after
+// all keys and coresponding values are loaded from the database.
+// This flag never goes from true back to false.
+bool mLoaded;
+// Result of load from the database.  Valid after mLoaded flag has been set.
+nsresult mLoadResult;
+// Init() method has been called
+bool mInitialized : 1;
+// This cache is about to be bound with the database (i.e. it has
+// to load from the DB first and has to persist when modifying the
+// default data set.)
+bool mPersistent : 1;
+// - False when the session-only data set was never used.
+// - True after access to session-only data has been made for the first time.
+// We also fill session-only data set with the default one at that moment.
+// Drops back to false when session-only data are cleared from chrome.
+bool mSessionOnlyDataSetActive : 1;
+// Whether we have already captured state of the cache preload on our first access.
+bool mPreloadTelemetryRecorded : 1;
+// DOMStorageDBThread on the parent or single process,
+// DOMStorageDBChild on the child process.
+static DOMStorageDBBridge* sDatabase;
+// False until we shut the database down.
+static bool sDatabaseDown;
+};
+// DOMStorageUsage
+// Infrastructure to manage and check eTLD+1 quota
+class DOMStorageUsageBridge
+{
+public:
+NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DOMStorageUsageBridge)
+virtual const nsCString& Scope() = 0;
+virtual void LoadUsage(const int64_t aUsage) = 0;
+protected:
+// Protected destructor, to discourage deletion outside of Release():
+virtual ~DOMStorageUsageBridge() {}
+};
+class DOMStorageUsage : public DOMStorageUsageBridge
+{
+public:
+DOMStorageUsage(const nsACString& aScope);
+bool CheckAndSetETLD1UsageDelta(uint32_t aDataSetIndex, int64_t aUsageDelta);
+private:
+virtual const nsCString& Scope() { return mScope; }
+virtual void LoadUsage(const int64_t aUsage);
+nsCString mScope;
+int64_t mUsage[DOMStorageCache::kDataSetCount];
+};
+} // ::dom
+} // ::mozilla
+#endif

The Tor Browser / file comparison

comparison: dom/src/storage/DOMStorageCache.h

dom/src/storage/DOMStorageCache.h