dom/storage/DOMStorageIPC.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef nsDOMStorageIPC_h___
   7 #define nsDOMStorageIPC_h___
   8
   9 #include "mozilla/dom/PStorageChild.h"
  10 #include "mozilla/dom/PStorageParent.h"
  11 #include "DOMStorageDBThread.h"
  12 #include "DOMStorageCache.h"
  13 #include "DOMStorageObserver.h"
  14 #include "mozilla/Mutex.h"
  15
  16 namespace mozilla {
  17 namespace dom {
  18
  19 class DOMLocalStorageManager;
  20
  21 // Child side of the IPC protocol, exposes as DB interface but
  22 // is responsible to send all requests to the parent process
  23 // and expects asynchronous answers. Those are then transparently
  24 // forwarded back to consumers on the child process.
  25 class DOMStorageDBChild MOZ_FINAL : public DOMStorageDBBridge
  26                                   , public PStorageChild
  27 {
  28   virtual ~DOMStorageDBChild();
  29
  30 public:
  31   explicit DOMStorageDBChild(DOMLocalStorageManager* aManager);
  32
  33   NS_IMETHOD_(MozExternalRefCountType) AddRef(void);
  34   NS_IMETHOD_(MozExternalRefCountType) Release(void);
  35
  36   void AddIPDLReference();
  37   void ReleaseIPDLReference();
  38
  39   virtual nsresult Init();
  40   virtual nsresult Shutdown();
  41
  42   virtual void AsyncPreload(DOMStorageCacheBridge* aCache, bool aPriority = false);
  43   virtual void AsyncGetUsage(DOMStorageUsageBridge* aUsage);
  44
  45   virtual void SyncPreload(DOMStorageCacheBridge* aCache, bool aForceSync = false);
  46
  47   virtual nsresult AsyncAddItem(DOMStorageCacheBridge* aCache, const nsAString& aKey, const nsAString& aValue);
  48   virtual nsresult AsyncUpdateItem(DOMStorageCacheBridge* aCache, const nsAString& aKey, const nsAString& aValue);
  49   virtual nsresult AsyncRemoveItem(DOMStorageCacheBridge* aCache, const nsAString& aKey);
  50   virtual nsresult AsyncClear(DOMStorageCacheBridge* aCache);
  51
  52   virtual void AsyncClearAll()
  53   {
  54     if (mScopesHavingData) {
  55       mScopesHavingData->Clear(); /* NO-OP on the child process otherwise */
  56     }
  57   }
  58
  59   virtual void AsyncClearMatchingScope(const nsACString& aScope)
  60     { /* NO-OP on the child process */ }
  61
  62   virtual void AsyncFlush()
  63     { SendAsyncFlush(); }
  64
  65   virtual bool ShouldPreloadScope(const nsACString& aScope);
  66   virtual void GetScopesHavingData(InfallibleTArray<nsCString>* aScopes)
  67     { NS_NOTREACHED("Not implemented for child process"); }
  68
  69 private:
  70   bool RecvObserve(const nsCString& aTopic,
  71                    const nsCString& aScopePrefix);
  72   bool RecvLoadItem(const nsCString& aScope,
  73                     const nsString& aKey,
  74                     const nsString& aValue);
  75   bool RecvLoadDone(const nsCString& aScope,
  76                     const nsresult& aRv);
  77   bool RecvScopesHavingData(const InfallibleTArray<nsCString>& aScopes);
  78   bool RecvLoadUsage(const nsCString& aScope,
  79                      const int64_t& aUsage);
  80   bool RecvError(const nsresult& aRv);
  81
  82   nsTHashtable<nsCStringHashKey>& ScopesHavingData();
  83
  84   ThreadSafeAutoRefCnt mRefCnt;
  85   NS_DECL_OWNINGTHREAD
  86
  87   // Held to get caches to forward answers to.
  88   nsRefPtr<DOMLocalStorageManager> mManager;
  89
  90   // Scopes having data hash, for optimization purposes only
  91   nsAutoPtr<nsTHashtable<nsCStringHashKey> > mScopesHavingData;
  92
  93   // List of caches waiting for preload.  This ensures the contract that
  94   // AsyncPreload call references the cache for time of the preload.
  95   nsTHashtable<nsRefPtrHashKey<DOMStorageCacheBridge> > mLoadingCaches;
  96
  97   // Status of the remote database
  98   nsresult mStatus;
  99
 100   bool mIPCOpen;
 101 };
 102
 103
 104 // Receives async requests from child processes and is responsible
 105 // to send back responses from the DB thread.  Exposes as a fake
 106 // DOMStorageCache consumer.
 107 // Also responsible for forwardning all chrome operation notifications
 108 // such as cookie cleaning etc to the child process.
 109 class DOMStorageDBParent MOZ_FINAL : public PStorageParent
 110                                    , public DOMStorageObserverSink
 111 {
 112   virtual ~DOMStorageDBParent();
 113
 114 public:
 115   DOMStorageDBParent();
 116
 117   virtual mozilla::ipc::IProtocol*
 118   CloneProtocol(Channel* aChannel,
 119                 mozilla::ipc::ProtocolCloneContext* aCtx) MOZ_OVERRIDE;
 120
 121   NS_IMETHOD_(MozExternalRefCountType) AddRef(void);
 122   NS_IMETHOD_(MozExternalRefCountType) Release(void);
 123
 124   void AddIPDLReference();
 125   void ReleaseIPDLReference();
 126
 127   bool IPCOpen() { return mIPCOpen; }
 128
 129 public:
 130   // Fake cache class receiving async callbacks from DB thread, sending
 131   // them back to appropriate cache object on the child process.
 132   class CacheParentBridge : public DOMStorageCacheBridge {
 133   public:
 134     CacheParentBridge(DOMStorageDBParent* aParentDB, const nsACString& aScope)
 135       : mParent(aParentDB), mScope(aScope), mLoaded(false), mLoadedCount(0) {}
 136     virtual ~CacheParentBridge() {}
 137
 138     // DOMStorageCacheBridge
 139     virtual const nsCString& Scope() const
 140       { return mScope; }
 141     virtual bool Loaded()
 142       { return mLoaded; }
 143     virtual uint32_t LoadedCount()
 144       { return mLoadedCount; }
 145
 146     virtual bool LoadItem(const nsAString& aKey, const nsString& aValue);
 147     virtual void LoadDone(nsresult aRv);
 148     virtual void LoadWait();
 149
 150   private:
 151     nsRefPtr<DOMStorageDBParent> mParent;
 152     nsCString mScope;
 153     bool mLoaded;
 154     uint32_t mLoadedCount;
 155   };
 156
 157   // Fake usage class receiving async callbacks from DB thread
 158   class UsageParentBridge : public DOMStorageUsageBridge
 159   {
 160   public:
 161     UsageParentBridge(DOMStorageDBParent* aParentDB, const nsACString& aScope)
 162       : mParent(aParentDB), mScope(aScope) {}
 163     virtual ~UsageParentBridge() {}
 164
 165     // DOMStorageUsageBridge
 166     virtual const nsCString& Scope() { return mScope; }
 167     virtual void LoadUsage(const int64_t usage);
 168
 169   private:
 170     nsRefPtr<DOMStorageDBParent> mParent;
 171     nsCString mScope;
 172   };
 173
 174 private:
 175   // IPC
 176   virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
 177   bool RecvAsyncPreload(const nsCString& aScope, const bool& aPriority);
 178   bool RecvPreload(const nsCString& aScope, const uint32_t& aAlreadyLoadedCount,
 179                    InfallibleTArray<nsString>* aKeys, InfallibleTArray<nsString>* aValues,
 180                    nsresult* aRv);
 181   bool RecvAsyncGetUsage(const nsCString& aScope);
 182   bool RecvAsyncAddItem(const nsCString& aScope, const nsString& aKey, const nsString& aValue);
 183   bool RecvAsyncUpdateItem(const nsCString& aScope, const nsString& aKey, const nsString& aValue);
 184   bool RecvAsyncRemoveItem(const nsCString& aScope, const nsString& aKey);
 185   bool RecvAsyncClear(const nsCString& aScope);
 186   bool RecvAsyncFlush();
 187
 188   // DOMStorageObserverSink
 189   virtual nsresult Observe(const char* aTopic, const nsACString& aScopePrefix);
 190
 191 private:
 192   CacheParentBridge* NewCache(const nsACString& aScope);
 193
 194   ThreadSafeAutoRefCnt mRefCnt;
 195   NS_DECL_OWNINGTHREAD
 196
 197         // True when IPC channel is open and Send*() methods are OK to use.
 198   bool mIPCOpen;
 199 };
 200
 201 } // ::dom
 202 } // ::mozilla
 203
 204 #endif