import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo

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