Add m-esr52 at 52.6.0

1 files changed, 546 insertions, 0 deletions

diff --git a/dom/quota/QuotaManager.h b/dom/quota/QuotaManager.h
new file mode 100644
index 000000000..206c3c665
--- /dev/null
+++ b/dom/quota/QuotaManager.h
@@ -0,0 +1,546 @@
+/* -*- 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 mozilla_dom_quota_quotamanager_h__
+#define mozilla_dom_quota_quotamanager_h__
+
+#include "QuotaCommon.h"
+
+#include "mozilla/dom/Nullable.h"
+#include "mozilla/dom/ipc/IdType.h"
+#include "mozilla/Mutex.h"
+
+#include "nsClassHashtable.h"
+#include "nsRefPtrHashtable.h"
+
+#include "Client.h"
+#include "PersistenceType.h"
+
+#include "prenv.h"
+
+#define QUOTA_MANAGER_CONTRACTID "@mozilla.org/dom/quota/manager;1"
+
+class mozIStorageConnection;
+class nsIEventTarget;
+class nsIPrincipal;
+class nsIThread;
+class nsITimer;
+class nsIURI;
+class nsPIDOMWindowOuter;
+class nsIRunnable;
+
+BEGIN_QUOTA_NAMESPACE
+
+class DirectoryLockImpl;
+class GroupInfo;
+class GroupInfoPair;
+class OriginInfo;
+class OriginScope;
+class QuotaObject;
+
+class NS_NO_VTABLE RefCountedObject
+{
+public:
+  NS_IMETHOD_(MozExternalRefCountType)
+  AddRef() = 0;
+
+  NS_IMETHOD_(MozExternalRefCountType)
+  Release() = 0;
+};
+
+class DirectoryLock
+  : public RefCountedObject
+{
+  friend class DirectoryLockImpl;
+
+private:
+  DirectoryLock()
+  { }
+
+  ~DirectoryLock()
+  { }
+};
+
+class NS_NO_VTABLE OpenDirectoryListener
+  : public RefCountedObject
+{
+public:
+  virtual void
+  DirectoryLockAcquired(DirectoryLock* aLock) = 0;
+
+  virtual void
+  DirectoryLockFailed() = 0;
+
+protected:
+  virtual ~OpenDirectoryListener()
+  { }
+};
+
+struct OriginParams
+{
+  OriginParams(PersistenceType aPersistenceType,
+               const nsACString& aOrigin,
+               bool aIsApp)
+  : mOrigin(aOrigin)
+  , mPersistenceType(aPersistenceType)
+  , mIsApp(aIsApp)
+  { }
+
+  nsCString mOrigin;
+  PersistenceType mPersistenceType;
+  bool mIsApp;
+};
+
+class QuotaManager final
+  : public BackgroundThreadObject
+{
+  friend class DirectoryLockImpl;
+  friend class GroupInfo;
+  friend class OriginInfo;
+  friend class QuotaObject;
+
+  typedef nsClassHashtable<nsCStringHashKey,
+                           nsTArray<DirectoryLockImpl*>> DirectoryLockTable;
+
+public:
+  class CreateRunnable;
+
+private:
+  class ShutdownRunnable;
+  class ShutdownObserver;
+
+public:
+  NS_INLINE_DECL_REFCOUNTING(QuotaManager)
+
+  static bool IsRunningXPCShellTests()
+  {
+    static bool kRunningXPCShellTests = !!PR_GetEnv("XPCSHELL_TEST_PROFILE_DIR");
+    return kRunningXPCShellTests;
+  }
+
+  static const char kReplaceChars[];
+
+  static void
+  GetOrCreate(nsIRunnable* aCallback);
+
+  // Returns a non-owning reference.
+  static QuotaManager*
+  Get();
+
+  // Returns true if we've begun the shutdown process.
+  static bool IsShuttingDown();
+
+  bool
+  IsOriginInitialized(const nsACString& aOrigin) const
+  {
+    AssertIsOnIOThread();
+
+    return mInitializedOrigins.Contains(aOrigin);
+  }
+
+  bool
+  IsTemporaryStorageInitialized() const
+  {
+    AssertIsOnIOThread();
+
+    return mTemporaryStorageInitialized;
+  }
+
+  void
+  InitQuotaForOrigin(PersistenceType aPersistenceType,
+                     const nsACString& aGroup,
+                     const nsACString& aOrigin,
+                     bool aIsApp,
+                     uint64_t aUsageBytes,
+                     int64_t aAccessTime);
+
+  void
+  DecreaseUsageForOrigin(PersistenceType aPersistenceType,
+                         const nsACString& aGroup,
+                         const nsACString& aOrigin,
+                         int64_t aSize);
+
+  void
+  UpdateOriginAccessTime(PersistenceType aPersistenceType,
+                         const nsACString& aGroup,
+                         const nsACString& aOrigin);
+
+  void
+  RemoveQuota();
+
+  void
+  RemoveQuotaForOrigin(PersistenceType aPersistenceType,
+                       const nsACString& aGroup,
+                       const nsACString& aOrigin)
+  {
+    MutexAutoLock lock(mQuotaMutex);
+    LockedRemoveQuotaForOrigin(aPersistenceType, aGroup, aOrigin);
+  }
+
+  already_AddRefed<QuotaObject>
+  GetQuotaObject(PersistenceType aPersistenceType,
+                 const nsACString& aGroup,
+                 const nsACString& aOrigin,
+                 nsIFile* aFile);
+
+  already_AddRefed<QuotaObject>
+  GetQuotaObject(PersistenceType aPersistenceType,
+                 const nsACString& aGroup,
+                 const nsACString& aOrigin,
+                 const nsAString& aPath);
+
+  // Called when a process is being shot down. Aborts any running operations
+  // for the given process.
+  void
+  AbortOperationsForProcess(ContentParentId aContentParentId);
+
+  nsresult
+  GetDirectoryForOrigin(PersistenceType aPersistenceType,
+                        const nsACString& aASCIIOrigin,
+                        nsIFile** aDirectory) const;
+
+  nsresult
+  RestoreDirectoryMetadata2(nsIFile* aDirectory, bool aPersistent);
+
+  nsresult
+  GetDirectoryMetadata2(nsIFile* aDirectory,
+                        int64_t* aTimestamp,
+                        nsACString& aSuffix,
+                        nsACString& aGroup,
+                        nsACString& aOrigin,
+                        bool* aIsApp);
+
+  nsresult
+  GetDirectoryMetadata2WithRestore(nsIFile* aDirectory,
+                                   bool aPersistent,
+                                   int64_t* aTimestamp,
+                                   nsACString& aSuffix,
+                                   nsACString& aGroup,
+                                   nsACString& aOrigin,
+                                   bool* aIsApp);
+
+  nsresult
+  GetDirectoryMetadata2(nsIFile* aDirectory, int64_t* aTimestamp);
+
+  nsresult
+  GetDirectoryMetadata2WithRestore(nsIFile* aDirectory,
+                                   bool aPersistent,
+                                   int64_t* aTimestamp);
+
+  // This is the main entry point into the QuotaManager API.
+  // Any storage API implementation (quota client) that participates in
+  // centralized quota and storage handling should call this method to get
+  // a directory lock which will protect client's files from being deleted
+  // while they are still in use.
+  // After a lock is acquired, client is notified via the open listener's
+  // method DirectoryLockAcquired. If the lock couldn't be acquired, client
+  // gets DirectoryLockFailed notification.
+  // A lock is a reference counted object and at the time DirectoryLockAcquired
+  // is called, quota manager holds just one strong reference to it which is
+  // then immediatelly cleared by quota manager. So it's up to client to add
+  // a new reference in order to keep the lock alive.
+  // Unlocking is simply done by dropping all references to the lock object.
+  // In other words, protection which the lock represents dies with the lock
+  // object itself.
+  void
+  OpenDirectory(PersistenceType aPersistenceType,
+                const nsACString& aGroup,
+                const nsACString& aOrigin,
+                bool aIsApp,
+                Client::Type aClientType,
+                bool aExclusive,
+                OpenDirectoryListener* aOpenListener);
+
+  // XXX RemoveMe once bug 1170279 gets fixed.
+  void
+  OpenDirectoryInternal(Nullable<PersistenceType> aPersistenceType,
+                        const OriginScope& aOriginScope,
+                        Nullable<Client::Type> aClientType,
+                        bool aExclusive,
+                        OpenDirectoryListener* aOpenListener);
+
+  // Collect inactive and the least recently used origins.
+  uint64_t
+  CollectOriginsForEviction(uint64_t aMinSizeToBeFreed,
+                            nsTArray<RefPtr<DirectoryLockImpl>>& aLocks);
+
+  nsresult
+  EnsureStorageIsInitialized();
+
+  nsresult
+  EnsureOriginIsInitialized(PersistenceType aPersistenceType,
+                            const nsACString& aSuffix,
+                            const nsACString& aGroup,
+                            const nsACString& aOrigin,
+                            bool aIsApp,
+                            nsIFile** aDirectory);
+
+  void
+  OriginClearCompleted(PersistenceType aPersistenceType,
+                       const nsACString& aOrigin,
+                       bool aIsApp);
+
+  void
+  ResetOrClearCompleted();
+
+  void
+  StartIdleMaintenance()
+  {
+    AssertIsOnOwningThread();
+
+    for (auto& client : mClients) {
+      client->StartIdleMaintenance();
+    }
+  }
+
+  void
+  StopIdleMaintenance()
+  {
+    AssertIsOnOwningThread();
+
+    for (auto& client : mClients) {
+      client->StopIdleMaintenance();
+    }
+  }
+
+  void
+  AssertCurrentThreadOwnsQuotaMutex()
+  {
+    mQuotaMutex.AssertCurrentThreadOwns();
+  }
+
+  nsIThread*
+  IOThread()
+  {
+    NS_ASSERTION(mIOThread, "This should never be null!");
+    return mIOThread;
+  }
+
+  Client*
+  GetClient(Client::Type aClientType);
+
+  const nsString&
+  GetBasePath() const
+  {
+    return mBasePath;
+  }
+
+  const nsString&
+  GetStoragePath() const
+  {
+    return mStoragePath;
+  }
+
+  const nsString&
+  GetStoragePath(PersistenceType aPersistenceType) const
+  {
+    if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
+      return mPermanentStoragePath;
+    }
+
+    if (aPersistenceType == PERSISTENCE_TYPE_TEMPORARY) {
+      return mTemporaryStoragePath;
+    }
+
+    MOZ_ASSERT(aPersistenceType == PERSISTENCE_TYPE_DEFAULT);
+
+    return mDefaultStoragePath;
+  }
+
+  uint64_t
+  GetGroupLimit() const;
+
+  void
+  GetGroupUsageAndLimit(const nsACString& aGroup,
+                        UsageInfo* aUsageInfo);
+
+  static void
+  GetStorageId(PersistenceType aPersistenceType,
+               const nsACString& aOrigin,
+               Client::Type aClientType,
+               nsACString& aDatabaseId);
+
+  static nsresult
+  GetInfoFromPrincipal(nsIPrincipal* aPrincipal,
+                       nsACString* aSuffix,
+                       nsACString* aGroup,
+                       nsACString* aOrigin,
+                       bool* aIsApp);
+
+  static nsresult
+  GetInfoFromWindow(nsPIDOMWindowOuter* aWindow,
+                    nsACString* aSuffix,
+                    nsACString* aGroup,
+                    nsACString* aOrigin,
+                    bool* aIsApp);
+
+  static void
+  GetInfoForChrome(nsACString* aSuffix,
+                   nsACString* aGroup,
+                   nsACString* aOrigin,
+                   bool* aIsApp);
+
+  static bool
+  IsOriginInternal(const nsACString& aOrigin);
+
+  static bool
+  IsFirstPromptRequired(PersistenceType aPersistenceType,
+                        const nsACString& aOrigin,
+                        bool aIsApp);
+
+  static bool
+  IsQuotaEnforced(PersistenceType aPersistenceType,
+                  const nsACString& aOrigin,
+                  bool aIsApp);
+
+  static void
+  ChromeOrigin(nsACString& aOrigin);
+
+private:
+  QuotaManager();
+
+  virtual ~QuotaManager();
+
+  nsresult
+  Init(const nsAString& aBaseDirPath);
+
+  void
+  Shutdown();
+
+  already_AddRefed<DirectoryLockImpl>
+  CreateDirectoryLock(Nullable<PersistenceType> aPersistenceType,
+                      const nsACString& aGroup,
+                      const OriginScope& aOriginScope,
+                      Nullable<bool> aIsApp,
+                      Nullable<Client::Type> aClientType,
+                      bool aExclusive,
+                      bool aInternal,
+                      OpenDirectoryListener* aOpenListener);
+
+  already_AddRefed<DirectoryLockImpl>
+  CreateDirectoryLockForEviction(PersistenceType aPersistenceType,
+                                 const nsACString& aGroup,
+                                 const nsACString& aOrigin,
+                                 bool aIsApp);
+
+  void
+  RegisterDirectoryLock(DirectoryLockImpl* aLock);
+
+  void
+  UnregisterDirectoryLock(DirectoryLockImpl* aLock);
+
+  void
+  RemovePendingDirectoryLock(DirectoryLockImpl* aLock);
+
+  uint64_t
+  LockedCollectOriginsForEviction(
+                                 uint64_t aMinSizeToBeFreed,
+                                 nsTArray<RefPtr<DirectoryLockImpl>>& aLocks);
+
+  void
+  LockedRemoveQuotaForOrigin(PersistenceType aPersistenceType,
+                             const nsACString& aGroup,
+                             const nsACString& aOrigin);
+
+  nsresult
+  MaybeUpgradeIndexedDBDirectory();
+
+  nsresult
+  MaybeUpgradePersistentStorageDirectory();
+
+  nsresult
+  MaybeRemoveOldDirectories();
+
+  nsresult
+  UpgradeStorageFrom0ToCurrent(mozIStorageConnection* aConnection);
+
+#if 0
+  nsresult
+  UpgradeStorageFrom1To2(mozIStorageConnection* aConnection);
+#endif
+
+  nsresult
+  InitializeRepository(PersistenceType aPersistenceType);
+
+  nsresult
+  InitializeOrigin(PersistenceType aPersistenceType,
+                   const nsACString& aGroup,
+                   const nsACString& aOrigin,
+                   bool aIsApp,
+                   int64_t aAccessTime,
+                   nsIFile* aDirectory);
+
+  void
+  CheckTemporaryStorageLimits();
+
+  void
+  DeleteFilesForOrigin(PersistenceType aPersistenceType,
+                       const nsACString& aOrigin);
+
+  void
+  FinalizeOriginEviction(nsTArray<RefPtr<DirectoryLockImpl>>& aLocks);
+
+  void
+  ReleaseIOThreadObjects()
+  {
+    AssertIsOnIOThread();
+
+    for (uint32_t index = 0; index < Client::TYPE_MAX; index++) {
+      mClients[index]->ReleaseIOThreadObjects();
+    }
+  }
+
+  DirectoryLockTable&
+  GetDirectoryLockTable(PersistenceType aPersistenceType);
+
+  static void
+  ShutdownTimerCallback(nsITimer* aTimer, void* aClosure);
+
+  mozilla::Mutex mQuotaMutex;
+
+  nsClassHashtable<nsCStringHashKey, GroupInfoPair> mGroupInfoPairs;
+
+  // Maintains a list of directory locks that are queued.
+  nsTArray<RefPtr<DirectoryLockImpl>> mPendingDirectoryLocks;
+
+  // Maintains a list of directory locks that are acquired or queued.
+  nsTArray<DirectoryLockImpl*> mDirectoryLocks;
+
+  // Directory lock tables that are used to update origin access time.
+  DirectoryLockTable mTemporaryDirectoryLockTable;
+  DirectoryLockTable mDefaultDirectoryLockTable;
+
+  // Thread on which IO is performed.
+  nsCOMPtr<nsIThread> mIOThread;
+
+  // A timer that gets activated at shutdown to ensure we close all storages.
+  nsCOMPtr<nsITimer> mShutdownTimer;
+
+  // A list of all successfully initialized origins. This list isn't protected
+  // by any mutex but it is only ever touched on the IO thread.
+  nsTArray<nsCString> mInitializedOrigins;
+
+  // This array is populated at initialization time and then never modified, so
+  // it can be iterated on any thread.
+  AutoTArray<RefPtr<Client>, Client::TYPE_MAX> mClients;
+
+  nsString mBasePath;
+  nsString mIndexedDBPath;
+  nsString mStoragePath;
+  nsString mPermanentStoragePath;
+  nsString mTemporaryStoragePath;
+  nsString mDefaultStoragePath;
+
+  uint64_t mTemporaryStorageLimit;
+  uint64_t mTemporaryStorageUsage;
+  bool mTemporaryStorageInitialized;
+
+  bool mStorageInitialized;
+};
+
+END_QUOTA_NAMESPACE
+
+#endif /* mozilla_dom_quota_quotamanager_h__ */