dom/quota/Client.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_quota_client_h__
   8 #define mozilla_dom_quota_client_h__
   9
  10 #include "ErrorList.h"
  11 #include "mozilla/Atomics.h"
  12 #include "mozilla/Result.h"
  13 #include "mozilla/dom/ipc/IdType.h"
  14 #include "mozilla/dom/quota/PersistenceType.h"
  15 #include "nsHashKeys.h"
  16 #include "nsISupports.h"
  17 #include "nsStringFwd.h"
  18 #include "nsTHashSet.h"
  19
  20 // XXX Remove this dependency.
  21 #include "mozilla/dom/LocalStorageCommon.h"
  22
  23 class nsIFile;
  24
  25 #define IDB_DIRECTORY_NAME "idb"
  26 #define DOMCACHE_DIRECTORY_NAME "cache"
  27 #define SDB_DIRECTORY_NAME "sdb"
  28 #define FILESYSTEM_DIRECTORY_NAME "fs"
  29 #define LS_DIRECTORY_NAME "ls"
  30
  31 // Deprecated
  32 #define ASMJSCACHE_DIRECTORY_NAME "asmjs"
  33
  34 namespace mozilla::dom {
  35 template <typename T>
  36 struct Nullable;
  37 }
  38
  39 namespace mozilla::dom::quota {
  40
  41 struct OriginMetadata;
  42 class OriginScope;
  43 class QuotaManager;
  44 class UsageInfo;
  45
  46 // An abstract interface for quota manager clients.
  47 // Each storage API must provide an implementation of this interface in order
  48 // to participate in centralized quota and storage handling.
  49 class Client {
  50  public:
  51   using AtomicBool = Atomic<bool>;
  52
  53   enum Type {
  54     IDB = 0,
  55     // APPCACHE,
  56     DOMCACHE,
  57     SDB,
  58     FILESYSTEM,
  59     LS,
  60     TYPE_MAX
  61   };
  62
  63   class DirectoryLockIdTable final {
  64     nsTHashSet<uint64_t> mIds;
  65
  66    public:
  67     void Put(const int64_t aId) { mIds.Insert(aId); }
  68
  69     bool Has(const int64_t aId) const { return mIds.Contains(aId); }
  70
  71     bool Filled() const { return mIds.Count(); }
  72   };
  73
  74   static Type TypeMax() {
  75     if (NextGenLocalStorageEnabled()) {
  76       return TYPE_MAX;
  77     }
  78     return LS;
  79   }
  80
  81   static bool IsValidType(Type aType);
  82
  83   static bool TypeToText(Type aType, nsAString& aText, const fallible_t&);
  84
  85   // TODO: Rename other similar methods to use String/CString instead of Text.
  86   static nsAutoString TypeToString(Type aType);
  87
  88   static nsAutoCString TypeToText(Type aType);
  89
  90   static bool TypeFromText(const nsAString& aText, Type& aType,
  91                            const fallible_t&);
  92
  93   static Type TypeFromText(const nsACString& aText);
  94
  95   static char TypeToPrefix(Type aType);
  96
  97   static bool TypeFromPrefix(char aPrefix, Type& aType, const fallible_t&);
  98
  99   static bool IsDeprecatedClient(const nsAString& aText) {
 100     return aText.EqualsLiteral(ASMJSCACHE_DIRECTORY_NAME);
 101   }
 102
 103   template <typename T>
 104   static bool IsLockForObjectContainedInLockTable(
 105       const T& aObject, const DirectoryLockIdTable& aIds);
 106
 107   template <typename T>
 108   static bool IsLockForObjectAcquiredAndContainedInLockTable(
 109       const T& aObject, const DirectoryLockIdTable& aIds);
 110
 111   NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
 112
 113   virtual Type GetType() = 0;
 114
 115   // Methods which are called on the IO thread.
 116   virtual nsresult UpgradeStorageFrom1_0To2_0(nsIFile* aDirectory) {
 117     return NS_OK;
 118   }
 119
 120   virtual nsresult UpgradeStorageFrom2_0To2_1(nsIFile* aDirectory) {
 121     return NS_OK;
 122   }
 123
 124   virtual nsresult UpgradeStorageFrom2_1To2_2(nsIFile* aDirectory) {
 125     return NS_OK;
 126   }
 127
 128   virtual Result<UsageInfo, nsresult> InitOrigin(
 129       PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
 130       const AtomicBool& aCanceled) = 0;
 131
 132   virtual nsresult InitOriginWithoutTracking(
 133       PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
 134       const AtomicBool& aCanceled) = 0;
 135
 136   virtual Result<UsageInfo, nsresult> GetUsageForOrigin(
 137       PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
 138       const AtomicBool& aCanceled) = 0;
 139
 140   // This method is called when origins are about to be cleared
 141   // (except the case when clearing is triggered by the origin eviction).
 142   virtual nsresult AboutToClearOrigins(
 143       const Nullable<PersistenceType>& aPersistenceType,
 144       const OriginScope& aOriginScope) {
 145     return NS_OK;
 146   }
 147
 148   virtual void OnOriginClearCompleted(PersistenceType aPersistenceType,
 149                                       const nsACString& aOrigin) = 0;
 150
 151   virtual void OnRepositoryClearCompleted(PersistenceType aPersistenceType) = 0;
 152
 153   virtual void ReleaseIOThreadObjects() = 0;
 154
 155   // Methods which are called on the background thread.
 156   virtual void AbortOperationsForLocks(
 157       const DirectoryLockIdTable& aDirectoryLockIds) = 0;
 158
 159   virtual void AbortOperationsForProcess(ContentParentId aContentParentId) = 0;
 160
 161   virtual void AbortAllOperations() = 0;
 162
 163   virtual void StartIdleMaintenance() = 0;
 164
 165   virtual void StopIdleMaintenance() = 0;
 166
 167   // Both variants just check for QuotaManager::IsShuttingDown()
 168   // but assert to be on the right thread.
 169   // They must not be used for re-entrance checks.
 170   // Deprecated: This distinction is not needed anymore.
 171   // QuotaClients should call QuotaManager::IsShuttingDown instead.
 172   static bool IsShuttingDownOnBackgroundThread();
 173   static bool IsShuttingDownOnNonBackgroundThread();
 174
 175   // Returns true if there is work that needs to be waited for.
 176   bool InitiateShutdownWorkThreads();
 177   void FinalizeShutdownWorkThreads();
 178
 179   virtual nsCString GetShutdownStatus() const = 0;
 180   virtual bool IsShutdownCompleted() const = 0;
 181   virtual void ForceKillActors() = 0;
 182
 183  private:
 184   virtual void InitiateShutdown() = 0;
 185   virtual void FinalizeShutdown() = 0;
 186
 187  protected:
 188   virtual ~Client() = default;
 189 };
 190
 191 }  // namespace mozilla::dom::quota
 192
 193 #endif  // mozilla_dom_quota_client_h__