summaryrefslogtreecommitdiffstats
path: root/dom/storage/DOMStorageIPC.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/storage/DOMStorageIPC.h')
-rw-r--r--dom/storage/DOMStorageIPC.h218
1 files changed, 218 insertions, 0 deletions
diff --git a/dom/storage/DOMStorageIPC.h b/dom/storage/DOMStorageIPC.h
new file mode 100644
index 000000000..b3508a588
--- /dev/null
+++ b/dom/storage/DOMStorageIPC.h
@@ -0,0 +1,218 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 nsDOMStorageIPC_h___
+#define nsDOMStorageIPC_h___
+
+#include "mozilla/dom/PStorageChild.h"
+#include "mozilla/dom/PStorageParent.h"
+#include "DOMStorageDBThread.h"
+#include "DOMStorageCache.h"
+#include "DOMStorageObserver.h"
+#include "mozilla/Mutex.h"
+#include "nsAutoPtr.h"
+
+namespace mozilla {
+
+class OriginAttributesPattern;
+
+namespace dom {
+
+class DOMLocalStorageManager;
+
+// Child side of the IPC protocol, exposes as DB interface but
+// is responsible to send all requests to the parent process
+// and expects asynchronous answers. Those are then transparently
+// forwarded back to consumers on the child process.
+class DOMStorageDBChild final : public DOMStorageDBBridge
+ , public PStorageChild
+{
+ virtual ~DOMStorageDBChild();
+
+public:
+ explicit DOMStorageDBChild(DOMLocalStorageManager* aManager);
+
+ NS_IMETHOD_(MozExternalRefCountType) AddRef(void);
+ NS_IMETHOD_(MozExternalRefCountType) Release(void);
+
+ void AddIPDLReference();
+ void ReleaseIPDLReference();
+
+ virtual nsresult Init();
+ virtual nsresult Shutdown();
+
+ virtual void AsyncPreload(DOMStorageCacheBridge* aCache, bool aPriority = false);
+ virtual void AsyncGetUsage(DOMStorageUsageBridge* aUsage);
+
+ virtual void SyncPreload(DOMStorageCacheBridge* aCache, bool aForceSync = false);
+
+ virtual nsresult AsyncAddItem(DOMStorageCacheBridge* aCache, const nsAString& aKey, const nsAString& aValue);
+ virtual nsresult AsyncUpdateItem(DOMStorageCacheBridge* aCache, const nsAString& aKey, const nsAString& aValue);
+ virtual nsresult AsyncRemoveItem(DOMStorageCacheBridge* aCache, const nsAString& aKey);
+ virtual nsresult AsyncClear(DOMStorageCacheBridge* aCache);
+
+ virtual void AsyncClearAll()
+ {
+ if (mOriginsHavingData) {
+ mOriginsHavingData->Clear(); /* NO-OP on the child process otherwise */
+ }
+ }
+
+ virtual void AsyncClearMatchingOrigin(const nsACString& aOriginNoSuffix)
+ { /* NO-OP on the child process */ }
+
+ virtual void AsyncClearMatchingOriginAttributes(const OriginAttributesPattern& aPattern)
+ { /* NO-OP on the child process */ }
+
+ virtual void AsyncFlush()
+ { SendAsyncFlush(); }
+
+ virtual bool ShouldPreloadOrigin(const nsACString& aOriginNoSuffix);
+ virtual void GetOriginsHavingData(InfallibleTArray<nsCString>* aOrigins)
+ { NS_NOTREACHED("Not implemented for child process"); }
+
+private:
+ bool RecvObserve(const nsCString& aTopic,
+ const nsString& aOriginAttributesPattern,
+ const nsCString& aOriginScope);
+ bool RecvLoadItem(const nsCString& aOriginSuffix,
+ const nsCString& aOriginNoSuffix,
+ const nsString& aKey,
+ const nsString& aValue);
+ bool RecvLoadDone(const nsCString& aOriginSuffix,
+ const nsCString& aOriginNoSuffix,
+ const nsresult& aRv);
+ bool RecvOriginsHavingData(nsTArray<nsCString>&& aOrigins);
+ bool RecvLoadUsage(const nsCString& aOriginNoSuffix,
+ const int64_t& aUsage);
+ bool RecvError(const nsresult& aRv);
+
+ nsTHashtable<nsCStringHashKey>& OriginsHavingData();
+
+ ThreadSafeAutoRefCnt mRefCnt;
+ NS_DECL_OWNINGTHREAD
+
+ // Held to get caches to forward answers to.
+ RefPtr<DOMLocalStorageManager> mManager;
+
+ // Origins having data hash, for optimization purposes only
+ nsAutoPtr<nsTHashtable<nsCStringHashKey>> mOriginsHavingData;
+
+ // List of caches waiting for preload. This ensures the contract that
+ // AsyncPreload call references the cache for time of the preload.
+ nsTHashtable<nsRefPtrHashKey<DOMStorageCacheBridge>> mLoadingCaches;
+
+ // Status of the remote database
+ nsresult mStatus;
+
+ bool mIPCOpen;
+};
+
+
+// Receives async requests from child processes and is responsible
+// to send back responses from the DB thread. Exposes as a fake
+// DOMStorageCache consumer.
+// Also responsible for forwardning all chrome operation notifications
+// such as cookie cleaning etc to the child process.
+class DOMStorageDBParent final : public PStorageParent
+ , public DOMStorageObserverSink
+{
+ virtual ~DOMStorageDBParent();
+
+public:
+ DOMStorageDBParent();
+
+ NS_IMETHOD_(MozExternalRefCountType) AddRef(void);
+ NS_IMETHOD_(MozExternalRefCountType) Release(void);
+
+ void AddIPDLReference();
+ void ReleaseIPDLReference();
+
+ bool IPCOpen() { return mIPCOpen; }
+
+public:
+ // Fake cache class receiving async callbacks from DB thread, sending
+ // them back to appropriate cache object on the child process.
+ class CacheParentBridge : public DOMStorageCacheBridge {
+ public:
+ CacheParentBridge(DOMStorageDBParent* aParentDB,
+ const nsACString& aOriginSuffix,
+ const nsACString& aOriginNoSuffix)
+ : mParent(aParentDB)
+ , mOriginSuffix(aOriginSuffix), mOriginNoSuffix(aOriginNoSuffix)
+ , mLoaded(false), mLoadedCount(0) {}
+ virtual ~CacheParentBridge() {}
+
+ // DOMStorageCacheBridge
+ virtual const nsCString Origin() const;
+ virtual const nsCString& OriginNoSuffix() const
+ { return mOriginNoSuffix; }
+ virtual const nsCString& OriginSuffix() const
+ { return mOriginSuffix; }
+ virtual bool Loaded()
+ { return mLoaded; }
+ virtual uint32_t LoadedCount()
+ { return mLoadedCount; }
+
+ virtual bool LoadItem(const nsAString& aKey, const nsString& aValue);
+ virtual void LoadDone(nsresult aRv);
+ virtual void LoadWait();
+
+ private:
+ RefPtr<DOMStorageDBParent> mParent;
+ nsCString mOriginSuffix, mOriginNoSuffix;
+ bool mLoaded;
+ uint32_t mLoadedCount;
+ };
+
+ // Fake usage class receiving async callbacks from DB thread
+ class UsageParentBridge : public DOMStorageUsageBridge
+ {
+ public:
+ UsageParentBridge(DOMStorageDBParent* aParentDB, const nsACString& aOriginScope)
+ : mParent(aParentDB), mOriginScope(aOriginScope) {}
+ virtual ~UsageParentBridge() {}
+
+ // DOMStorageUsageBridge
+ virtual const nsCString& OriginScope() { return mOriginScope; }
+ virtual void LoadUsage(const int64_t usage);
+
+ private:
+ RefPtr<DOMStorageDBParent> mParent;
+ nsCString mOriginScope;
+ };
+
+private:
+ // IPC
+ virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+ bool RecvAsyncPreload(const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix, const bool& aPriority) override;
+ bool RecvPreload(const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix, const uint32_t& aAlreadyLoadedCount,
+ InfallibleTArray<nsString>* aKeys, InfallibleTArray<nsString>* aValues,
+ nsresult* aRv) override;
+ bool RecvAsyncGetUsage(const nsCString& aOriginNoSuffix) override;
+ bool RecvAsyncAddItem(const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix, const nsString& aKey, const nsString& aValue) override;
+ bool RecvAsyncUpdateItem(const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix, const nsString& aKey, const nsString& aValue) override;
+ bool RecvAsyncRemoveItem(const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix, const nsString& aKey) override;
+ bool RecvAsyncClear(const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix) override;
+ bool RecvAsyncFlush() override;
+
+ // DOMStorageObserverSink
+ virtual nsresult Observe(const char* aTopic, const nsAString& aOriginAttrPattern, const nsACString& aOriginScope) override;
+
+private:
+ CacheParentBridge* NewCache(const nsACString& aOriginSuffix, const nsACString& aOriginNoSuffix);
+
+ ThreadSafeAutoRefCnt mRefCnt;
+ NS_DECL_OWNINGTHREAD
+
+ // True when IPC channel is open and Send*() methods are OK to use.
+ bool mIPCOpen;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif