dom/quota/QuotaObject.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=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_quotaobject_h__
   8 #define mozilla_dom_quota_quotaobject_h__
   9
  10 #include "mozilla/dom/quota/QuotaCommon.h"
  11
  12 #include "nsDataHashtable.h"
  13
  14 #include "PersistenceType.h"
  15
  16 BEGIN_QUOTA_NAMESPACE
  17
  18 class GroupInfo;
  19 class GroupInfoPair;
  20 class OriginInfo;
  21 class QuotaManager;
  22
  23 class QuotaObject
  24 {
  25   friend class OriginInfo;
  26   friend class QuotaManager;
  27
  28 public:
  29   void
  30   AddRef();
  31
  32   void
  33   Release();
  34
  35   void
  36   UpdateSize(int64_t aSize);
  37
  38   bool
  39   MaybeAllocateMoreSpace(int64_t aOffset, int32_t aCount);
  40
  41 private:
  42   QuotaObject(OriginInfo* aOriginInfo, const nsAString& aPath, int64_t aSize)
  43   : mOriginInfo(aOriginInfo), mPath(aPath), mSize(aSize)
  44   {
  45     MOZ_COUNT_CTOR(QuotaObject);
  46   }
  47
  48   ~QuotaObject()
  49   {
  50     MOZ_COUNT_DTOR(QuotaObject);
  51   }
  52
  53   mozilla::ThreadSafeAutoRefCnt mRefCnt;
  54
  55   OriginInfo* mOriginInfo;
  56   nsString mPath;
  57   int64_t mSize;
  58 };
  59
  60 class OriginInfo
  61 {
  62   friend class GroupInfo;
  63   friend class QuotaManager;
  64   friend class QuotaObject;
  65
  66 public:
  67   OriginInfo(GroupInfo* aGroupInfo, const nsACString& aOrigin, uint64_t aLimit,
  68              uint64_t aUsage, int64_t aAccessTime)
  69   : mGroupInfo(aGroupInfo), mOrigin(aOrigin), mLimit(aLimit), mUsage(aUsage),
  70     mAccessTime(aAccessTime)
  71   {
  72     MOZ_COUNT_CTOR(OriginInfo);
  73   }
  74
  75   ~OriginInfo()
  76   {
  77     MOZ_COUNT_DTOR(OriginInfo);
  78   }
  79
  80   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(OriginInfo)
  81
  82   int64_t
  83   AccessTime() const
  84   {
  85     return mAccessTime;
  86   }
  87
  88 private:
  89   void
  90   LockedDecreaseUsage(int64_t aSize);
  91
  92   void
  93   LockedUpdateAccessTime(int64_t aAccessTime)
  94   {
  95     AssertCurrentThreadOwnsQuotaMutex();
  96
  97     mAccessTime = aAccessTime;
  98   }
  99
 100   void
 101   LockedClearOriginInfos()
 102   {
 103     AssertCurrentThreadOwnsQuotaMutex();
 104
 105     mQuotaObjects.EnumerateRead(ClearOriginInfoCallback, nullptr);
 106   }
 107
 108   static PLDHashOperator
 109   ClearOriginInfoCallback(const nsAString& aKey,
 110                           QuotaObject* aValue, void* aUserArg);
 111
 112   nsDataHashtable<nsStringHashKey, QuotaObject*> mQuotaObjects;
 113
 114   GroupInfo* mGroupInfo;
 115   nsCString mOrigin;
 116   uint64_t mLimit;
 117   uint64_t mUsage;
 118   int64_t mAccessTime;
 119 };
 120
 121 class OriginInfoLRUComparator
 122 {
 123 public:
 124   bool
 125   Equals(const OriginInfo* a, const OriginInfo* b) const
 126   {
 127     return
 128       a && b ? a->AccessTime() == b->AccessTime() : !a && !b ? true : false;
 129   }
 130
 131   bool
 132   LessThan(const OriginInfo* a, const OriginInfo* b) const
 133   {
 134     return a && b ? a->AccessTime() < b->AccessTime() : b ? true : false;
 135   }
 136 };
 137
 138 class GroupInfo
 139 {
 140   friend class GroupInfoPair;
 141   friend class OriginInfo;
 142   friend class QuotaManager;
 143   friend class QuotaObject;
 144
 145 public:
 146   GroupInfo(PersistenceType aPersistenceType, const nsACString& aGroup)
 147   : mPersistenceType(aPersistenceType), mGroup(aGroup), mUsage(0)
 148   {
 149     MOZ_COUNT_CTOR(GroupInfo);
 150   }
 151
 152   ~GroupInfo()
 153   {
 154     MOZ_COUNT_DTOR(GroupInfo);
 155   }
 156
 157   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GroupInfo)
 158
 159   bool
 160   IsForPersistentStorage() const
 161   {
 162     return mPersistenceType == PERSISTENCE_TYPE_PERSISTENT;
 163   }
 164
 165   bool
 166   IsForTemporaryStorage() const
 167   {
 168     return mPersistenceType == PERSISTENCE_TYPE_TEMPORARY;
 169   }
 170
 171 private:
 172   already_AddRefed<OriginInfo>
 173   LockedGetOriginInfo(const nsACString& aOrigin);
 174
 175   void
 176   LockedAddOriginInfo(OriginInfo* aOriginInfo);
 177
 178   void
 179   LockedRemoveOriginInfo(const nsACString& aOrigin);
 180
 181   void
 182   LockedRemoveOriginInfos();
 183
 184   void
 185   LockedRemoveOriginInfosForPattern(const nsACString& aPattern);
 186
 187   bool
 188   LockedHasOriginInfos()
 189   {
 190     AssertCurrentThreadOwnsQuotaMutex();
 191
 192     return !mOriginInfos.IsEmpty();
 193   }
 194
 195   nsTArray<nsRefPtr<OriginInfo> > mOriginInfos;
 196
 197   PersistenceType mPersistenceType;
 198   nsCString mGroup;
 199   uint64_t mUsage;
 200 };
 201
 202 class GroupInfoPair
 203 {
 204   friend class QuotaManager;
 205
 206 public:
 207   GroupInfoPair()
 208   {
 209     MOZ_COUNT_CTOR(GroupInfoPair);
 210   }
 211
 212   ~GroupInfoPair()
 213   {
 214     MOZ_COUNT_DTOR(GroupInfoPair);
 215   }
 216
 217 private:
 218   already_AddRefed<GroupInfo>
 219   LockedGetGroupInfo(PersistenceType aPersistenceType)
 220   {
 221     AssertCurrentThreadOwnsQuotaMutex();
 222
 223     nsRefPtr<GroupInfo> groupInfo =
 224       GetGroupInfoForPersistenceType(aPersistenceType);
 225     return groupInfo.forget();
 226   }
 227
 228   void
 229   LockedSetGroupInfo(GroupInfo* aGroupInfo)
 230   {
 231     AssertCurrentThreadOwnsQuotaMutex();
 232
 233     nsRefPtr<GroupInfo>& groupInfo =
 234       GetGroupInfoForPersistenceType(aGroupInfo->mPersistenceType);
 235     groupInfo = aGroupInfo;
 236   }
 237
 238   void
 239   LockedClearGroupInfo(PersistenceType aPersistenceType)
 240   {
 241     AssertCurrentThreadOwnsQuotaMutex();
 242
 243     nsRefPtr<GroupInfo>& groupInfo =
 244       GetGroupInfoForPersistenceType(aPersistenceType);
 245     groupInfo = nullptr;
 246   }
 247
 248   bool
 249   LockedHasGroupInfos()
 250   {
 251     AssertCurrentThreadOwnsQuotaMutex();
 252
 253     return mPersistentStorageGroupInfo || mTemporaryStorageGroupInfo;
 254   }
 255
 256   nsRefPtr<GroupInfo>&
 257   GetGroupInfoForPersistenceType(PersistenceType aPersistenceType);
 258
 259   nsRefPtr<GroupInfo> mPersistentStorageGroupInfo;
 260   nsRefPtr<GroupInfo> mTemporaryStorageGroupInfo;
 261 };
 262
 263 END_QUOTA_NAMESPACE
 264
 265 #endif // mozilla_dom_quota_quotaobject_h__