diff -r 000000000000 -r 6474c204b198 dom/src/storage/DOMStorageManager.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/src/storage/DOMStorageManager.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,142 @@
+/* -*- 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 nsDOMStorageManager_h__
+#define nsDOMStorageManager_h__
+
+#include "nsIDOMStorageManager.h"
+#include "DOMStorageObserver.h"
+
+#include "nsPIDOMStorage.h"
+#include "DOMStorageCache.h"
+
+#include "nsTHashtable.h"
+#include "nsDataHashtable.h"
+#include "nsHashKeys.h"
+
+namespace mozilla {
+namespace dom {
+
+const nsPIDOMStorage::StorageType SessionStorage = nsPIDOMStorage::SessionStorage;
+const nsPIDOMStorage::StorageType LocalStorage = nsPIDOMStorage::LocalStorage;
+
+class DOMStorage;
+
+class DOMStorageManager : public nsIDOMStorageManager
+                        , public DOMStorageObserverSink
+{
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIDOMSTORAGEMANAGER
+
+public:
+  virtual nsPIDOMStorage::StorageType Type() { return mType; }
+
+  // Reads the preference for DOM storage quota
+  static uint32_t GetQuota();
+  // Gets (but not ensures) cache for the given scope
+  DOMStorageCache* GetCache(const nsACString& aScope) const;
+  // Returns object keeping usage cache for the scope.
+  already_AddRefed<DOMStorageUsage> GetScopeUsage(const nsACString& aScope);
+
+protected:
+  DOMStorageManager(nsPIDOMStorage::StorageType aType);
+  virtual ~DOMStorageManager();
+
+private:
+  // DOMStorageObserverSink, handler to various chrome clearing notification
+  virtual nsresult Observe(const char* aTopic, const nsACString& aScopePrefix);
+
+  // Since nsTHashtable doesn't like multiple inheritance, we have to aggregate
+  // DOMStorageCache into the entry.
+  class DOMStorageCacheHashKey : public nsCStringHashKey
+  {
+  public:
+    DOMStorageCacheHashKey(const nsACString* aKey)
+      : nsCStringHashKey(aKey)
+      , mCache(new DOMStorageCache(aKey))
+    {}
+
+    DOMStorageCacheHashKey(const DOMStorageCacheHashKey& aOther)
+      : nsCStringHashKey(aOther)
+    {
+      NS_ERROR("Shouldn't be called");
+    }
+
+    DOMStorageCache* cache() { return mCache; }
+    // Keep the cache referenced forever, used for sessionStorage.
+    void HardRef() { mCacheRef = mCache; }
+
+  private:
+    // weak ref only since cache references its manager.
+    DOMStorageCache* mCache;
+    // hard ref when this is sessionStorage to keep it alive forever.
+    nsRefPtr<DOMStorageCache> mCacheRef;
+  };
+
+  // Ensures cache for a scope, when it doesn't exist it is created and initalized,
+  // this also starts preload of persistent data.
+  already_AddRefed<DOMStorageCache> PutCache(const nsACString& aScope,
+                                             nsIURI* aFirstPartyIsolationURI,
+                                             nsIPrincipal* aPrincipal);
+
+  // Helper for creation of DOM storage objects
+  nsresult GetStorageInternal(bool aCreate,
+                              nsIURI* aFirstPartyIsolationURI,
+                              nsIPrincipal* aPrincipal,
+                              const nsAString& aDocumentURI,
+                              bool aPrivate,
+                              nsIDOMStorage** aRetval);
+
+  // Scope->cache map
+  nsTHashtable<DOMStorageCacheHashKey> mCaches;
+  const nsPIDOMStorage::StorageType mType;
+
+  // If mLowDiskSpace is true it indicates a low device storage situation and
+  // so no localStorage writes are allowed. sessionStorage writes are still
+  // allowed.
+  bool mLowDiskSpace;
+  bool IsLowDiskSpace() const { return mLowDiskSpace; };
+
+  static PLDHashOperator ClearCacheEnumerator(DOMStorageCacheHashKey* aCache,
+                                              void* aClosure);
+
+protected:
+  // Keeps usage cache objects for eTLD+1 scopes we have touched.
+  nsDataHashtable<nsCStringHashKey, nsRefPtr<DOMStorageUsage> > mUsages;
+
+  friend class DOMStorageCache;
+  // Releases cache since it is no longer referrered by any DOMStorage object.
+  virtual void DropCache(DOMStorageCache* aCache);
+};
+
+// Derived classes to allow two different contract ids, one for localStorage and
+// one for sessionStorage management.  localStorage manager is used as service
+// scoped to the application while sessionStorage managers are instantiated by each
+// top doc shell in the application since sessionStorages are isolated per top level
+// browsing context.  The code may easily by shared by both.
+
+class DOMLocalStorageManager MOZ_FINAL : public DOMStorageManager
+{
+public:
+  DOMLocalStorageManager();
+  virtual ~DOMLocalStorageManager();
+
+  // Global getter of localStorage manager service
+  static DOMLocalStorageManager* Self() { return sSelf; }
+
+private:
+  static DOMLocalStorageManager* sSelf;
+};
+
+class DOMSessionStorageManager MOZ_FINAL : public DOMStorageManager
+{
+public:
+  DOMSessionStorageManager();
+};
+
+} // ::dom
+} // ::mozilla
+
+#endif /* nsDOMStorageManager_h__ */