The Tor Browser: dom/quota/QuotaManager.cpp@129ffea94266 (annotated)

dom/quota/QuotaManager.cpp@129ffea94266 (annotated)

dom/quota/QuotaManager.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 #include "QuotaManager.h"
 #include "mozIApplicationClearPrivateDataParams.h"
 #include "nsIBinaryInputStream.h"
 #include "nsIBinaryOutputStream.h"
 #include "nsIFile.h"
 #include "nsIObserverService.h"
 #include "nsIOfflineStorage.h"
 #include "nsIPrincipal.h"
 #include "nsIQuotaRequest.h"
 #include "nsIRunnable.h"
 #include "nsISimpleEnumerator.h"
 #include "nsIScriptObjectPrincipal.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsITimer.h"
 #include "nsIURI.h"
 #include "nsIUsageCallback.h"
 #include <algorithm>
 #include "GeckoProfiler.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/CondVar.h"
 #include "mozilla/dom/asmjscache/AsmJSCache.h"
 #include "mozilla/dom/file/FileService.h"
 #include "mozilla/dom/indexedDB/Client.h"
 #include "mozilla/Mutex.h"
 #include "mozilla/LazyIdleThread.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/Services.h"
 #include "nsAppDirectoryServiceDefs.h"
 #include "nsComponentManagerUtils.h"
 #include "nsContentUtils.h"
 #include "nsCRTGlue.h"
 #include "nsDirectoryServiceUtils.h"
 #include "nsNetUtil.h"
 #include "nsScriptSecurityManager.h"
 #include "nsThreadUtils.h"
 #include "nsXULAppAPI.h"
 #include "xpcpublic.h"
 #include "AcquireListener.h"
 #include "CheckQuotaHelper.h"
 #include "OriginCollection.h"
 #include "OriginOrPatternString.h"
 #include "QuotaObject.h"
 #include "StorageMatcher.h"
 #include "UsageInfo.h"
 #include "Utilities.h"
 // The amount of time, in milliseconds, that our IO thread will stay alive
 // after the last event it processes.
 #define DEFAULT_THREAD_TIMEOUT_MS 30000
 // The amount of time, in milliseconds, that we will wait for active storage
 // transactions on shutdown before aborting them.
 #define DEFAULT_SHUTDOWN_TIMER_MS 30000
 // Preference that users can set to override DEFAULT_QUOTA_MB
 #define PREF_STORAGE_QUOTA "dom.indexedDB.warningQuota"
 // Preference that users can set to override temporary storage smart limit
 // calculation.
 #define PREF_FIXED_LIMIT "dom.quotaManager.temporaryStorage.fixedLimit"
 #define PREF_CHUNK_SIZE "dom.quotaManager.temporaryStorage.chunkSize"
 // Preference that is used to enable testing features
 #define PREF_TESTING_FEATURES "dom.quotaManager.testing"
 // profile-before-change, when we need to shut down quota manager
 #define PROFILE_BEFORE_CHANGE_OBSERVER_ID "profile-before-change"
 // The name of the file that we use to load/save the last access time of an
 // origin.
 #define METADATA_FILE_NAME ".metadata"
 #define PERMISSION_DEFAUT_PERSISTENT_STORAGE "default-persistent-storage"
 #define KB * 1024ULL
 #define MB * 1024ULL KB
 #define GB * 1024ULL MB
 USING_QUOTA_NAMESPACE
 using namespace mozilla::dom;
 using mozilla::dom::file::FileService;
 static_assert(
   static_cast<uint32_t>(StorageType::Persistent) ==
   static_cast<uint32_t>(PERSISTENCE_TYPE_PERSISTENT),
   "Enum values should match.");
 static_assert(
   static_cast<uint32_t>(StorageType::Temporary) ==
   static_cast<uint32_t>(PERSISTENCE_TYPE_TEMPORARY),
   "Enum values should match.");
 BEGIN_QUOTA_NAMESPACE
 // A struct that contains the information corresponding to a pending or
 // running operation that requires synchronization (e.g. opening a db,
 // clearing dbs for an origin, etc).
 struct SynchronizedOp
 {
   SynchronizedOp(const OriginOrPatternString& aOriginOrPattern,
                  Nullable<PersistenceType> aPersistenceType,
                  const nsACString& aId);
   ~SynchronizedOp();
   // Test whether this SynchronizedOp needs to wait for the given op.
   bool
   MustWaitFor(const SynchronizedOp& aOp);
   void
   DelayRunnable(nsIRunnable* aRunnable);
   void
   DispatchDelayedRunnables();
   const OriginOrPatternString mOriginOrPattern;
   Nullable<PersistenceType> mPersistenceType;
   nsCString mId;
   nsRefPtr<AcquireListener> mListener;
   nsTArray<nsCOMPtr<nsIRunnable> > mDelayedRunnables;
   ArrayCluster<nsIOfflineStorage*> mStorages;
 };
 class CollectOriginsHelper MOZ_FINAL : public nsRunnable
 {
 public:
   CollectOriginsHelper(mozilla::Mutex& aMutex, uint64_t aMinSizeToBeFreed);
   NS_IMETHOD
   Run();
   // Blocks the current thread until origins are collected on the main thread.
   // The returned value contains an aggregate size of those origins.
   int64_t
   BlockAndReturnOriginsForEviction(nsTArray<OriginInfo*>& aOriginInfos);
 private:
   ~CollectOriginsHelper()
   { }
   uint64_t mMinSizeToBeFreed;
   mozilla::Mutex& mMutex;
   mozilla::CondVar mCondVar;
   // The members below are protected by mMutex.
   nsTArray<OriginInfo*> mOriginInfos;
   uint64_t mSizeToBeFreed;
   bool mWaiting;
 };
 // Responsible for clearing the storage files for a particular origin on the
 // IO thread. Created when nsIQuotaManager::ClearStoragesForURI is called.
 // Runs three times, first on the main thread, next on the IO thread, and then
 // finally again on the main thread. While on the IO thread the runnable will
 // actually remove the origin's storage files and the directory that contains
 // them before dispatching itself back to the main thread. When back on the main
 // thread the runnable will notify the QuotaManager that the job has been
 // completed.
 class OriginClearRunnable MOZ_FINAL : public nsRunnable,
                                       public AcquireListener
 {
   enum CallbackState {
     // Not yet run.
     Pending = 0,
     // Running on the main thread in the callback for OpenAllowed.
     OpenAllowed,
     // Running on the IO thread.
     IO,
     // Running on the main thread after all work is done.
     Complete
   };
 public:
   NS_DECL_ISUPPORTS_INHERITED
   OriginClearRunnable(const OriginOrPatternString& aOriginOrPattern,
                       Nullable<PersistenceType> aPersistenceType)
   : mOriginOrPattern(aOriginOrPattern),
     mPersistenceType(aPersistenceType),
     mCallbackState(Pending)
   { }
   NS_IMETHOD
   Run();
   // AcquireListener override
   virtual nsresult
   OnExclusiveAccessAcquired() MOZ_OVERRIDE;
   void
   AdvanceState()
   {
     switch (mCallbackState) {
       case Pending:
         mCallbackState = OpenAllowed;
         return;
       case OpenAllowed:
         mCallbackState = IO;
         return;
       case IO:
         mCallbackState = Complete;
         return;
       default:
         NS_NOTREACHED("Can't advance past Complete!");
     }
   }
   static void
   InvalidateOpenedStorages(nsTArray<nsCOMPtr<nsIOfflineStorage> >& aStorages,
                            void* aClosure);
   void
   DeleteFiles(QuotaManager* aQuotaManager,
               PersistenceType aPersistenceType);
 private:
   OriginOrPatternString mOriginOrPattern;
   Nullable<PersistenceType> mPersistenceType;
   CallbackState mCallbackState;
 };
 // Responsible for calculating the amount of space taken up by storages of a
 // certain origin. Created when nsIQuotaManager::GetUsageForURI is called.
 // May be canceled with nsIQuotaRequest::Cancel. Runs three times, first
 // on the main thread, next on the IO thread, and then finally again on the main
 // thread. While on the IO thread the runnable will calculate the size of all
 // files in the origin's directory before dispatching itself back to the main
 // thread. When on the main thread the runnable will call the callback and then
 // notify the QuotaManager that the job has been completed.
 class AsyncUsageRunnable MOZ_FINAL : public UsageInfo,
                                      public nsRunnable,
                                      public nsIQuotaRequest
 {
   enum CallbackState {
     // Not yet run.
     Pending = 0,
     // Running on the main thread in the callback for OpenAllowed.
     OpenAllowed,
     // Running on the IO thread.
     IO,
     // Running on the main thread after all work is done.
     Complete,
     // Running on the main thread after skipping the work
     Shortcut
   };
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIQUOTAREQUEST
   AsyncUsageRunnable(uint32_t aAppId,
                      bool aInMozBrowserOnly,
                      const nsACString& aGroup,
                      const OriginOrPatternString& aOrigin,
                      nsIURI* aURI,
                      nsIUsageCallback* aCallback);
   NS_IMETHOD
   Run();
   void
   AdvanceState()
   {
     switch (mCallbackState) {
       case Pending:
         mCallbackState = OpenAllowed;
         return;
       case OpenAllowed:
         mCallbackState = IO;
         return;
       case IO:
         mCallbackState = Complete;
         return;
       default:
         NS_NOTREACHED("Can't advance past Complete!");
     }
   }
   nsresult
   TakeShortcut();
 private:
   // Run calls the RunInternal method and makes sure that we always dispatch
   // to the main thread in case of an error.
   inline nsresult
   RunInternal();
   nsresult
   AddToUsage(QuotaManager* aQuotaManager,
              PersistenceType aPersistenceType);
   nsCOMPtr<nsIURI> mURI;
   nsCOMPtr<nsIUsageCallback> mCallback;
   uint32_t mAppId;
   nsCString mGroup;
   OriginOrPatternString mOrigin;
   CallbackState mCallbackState;
   bool mInMozBrowserOnly;
 };
 class ResetOrClearRunnable MOZ_FINAL : public nsRunnable,
                                        public AcquireListener
 {
   enum CallbackState {
     // Not yet run.
     Pending = 0,
     // Running on the main thread in the callback for OpenAllowed.
     OpenAllowed,
     // Running on the IO thread.
     IO,
     // Running on the main thread after all work is done.
     Complete
   };
 public:
   NS_DECL_ISUPPORTS_INHERITED
   ResetOrClearRunnable(bool aClear)
   : mCallbackState(Pending),
     mClear(aClear)
   { }
   NS_IMETHOD
   Run();
   // AcquireListener override
   virtual nsresult
   OnExclusiveAccessAcquired() MOZ_OVERRIDE;
   void
   AdvanceState()
   {
     switch (mCallbackState) {
       case Pending:
         mCallbackState = OpenAllowed;
         return;
       case OpenAllowed:
         mCallbackState = IO;
         return;
       case IO:
         mCallbackState = Complete;
         return;
       default:
         NS_NOTREACHED("Can't advance past Complete!");
     }
   }
   static void
   InvalidateOpenedStorages(nsTArray<nsCOMPtr<nsIOfflineStorage> >& aStorages,
                            void* aClosure);
   void
   DeleteFiles(QuotaManager* aQuotaManager,
               PersistenceType aPersistenceType);
 private:
   CallbackState mCallbackState;
   bool mClear;
 };
 // Responsible for finalizing eviction of certian origins (storage files have
 // been already cleared, we just need to release IO thread only objects and
 // allow next synchronized ops for evicted origins). Created when
 // QuotaManager::FinalizeOriginEviction is called. Runs three times, first
 // on the main thread, next on the IO thread, and then finally again on the main
 // thread. While on the IO thread the runnable will release IO thread only
 // objects before dispatching itself back to the main thread. When back on the
 // main thread the runnable will call QuotaManager::AllowNextSynchronizedOp.
 // The runnable can also run in a shortened mode (runs only twice).
 class FinalizeOriginEvictionRunnable MOZ_FINAL : public nsRunnable
 {
   enum CallbackState {
     // Not yet run.
     Pending = 0,
     // Running on the main thread in the callback for OpenAllowed.
     OpenAllowed,
     // Running on the IO thread.
     IO,
     // Running on the main thread after IO work is done.
     Complete
   };
 public:
   FinalizeOriginEvictionRunnable(nsTArray<nsCString>& aOrigins)
   : mCallbackState(Pending)
   {
     mOrigins.SwapElements(aOrigins);
   }
   NS_IMETHOD
   Run();
   void
   AdvanceState()
   {
     switch (mCallbackState) {
       case Pending:
         mCallbackState = OpenAllowed;
         return;
       case OpenAllowed:
         mCallbackState = IO;
         return;
       case IO:
         mCallbackState = Complete;
         return;
       default:
         MOZ_ASSUME_UNREACHABLE("Can't advance past Complete!");
     }
   }
   nsresult
   Dispatch();
   nsresult
   RunImmediately();
 private:
   CallbackState mCallbackState;
   nsTArray<nsCString> mOrigins;
 };
 bool
 IsOnIOThread()
 {
   QuotaManager* quotaManager = QuotaManager::Get();
   NS_ASSERTION(quotaManager, "Must have a manager here!");
   bool currentThread;
   return NS_SUCCEEDED(quotaManager->IOThread()->
                       IsOnCurrentThread(&currentThread)) && currentThread;
 }
 void
 AssertIsOnIOThread()
 {
   NS_ASSERTION(IsOnIOThread(), "Running on the wrong thread!");
 }
 void
 AssertCurrentThreadOwnsQuotaMutex()
 {
 #ifdef DEBUG
   QuotaManager* quotaManager = QuotaManager::Get();
   NS_ASSERTION(quotaManager, "Must have a manager here!");
   quotaManager->AssertCurrentThreadOwnsQuotaMutex();
 #endif
 }
 END_QUOTA_NAMESPACE
 namespace {
 // Amount of space that storages may use by default in megabytes.
 static const int32_t  kDefaultQuotaMB =             50;
 QuotaManager* gInstance = nullptr;
 mozilla::Atomic<bool> gShutdown(false);
 int32_t gStorageQuotaMB = kDefaultQuotaMB;
 // Constants for temporary storage limit computing.
 static const int32_t kDefaultFixedLimitKB = -1;
 static const uint32_t kDefaultChunkSizeKB = 10 * 1024;
 int32_t gFixedLimitKB = kDefaultFixedLimitKB;
 uint32_t gChunkSizeKB = kDefaultChunkSizeKB;
 bool gTestingEnabled = false;
 // A callback runnable used by the TransactionPool when it's safe to proceed
 // with a SetVersion/DeleteDatabase/etc.
 class WaitForTransactionsToFinishRunnable MOZ_FINAL : public nsRunnable
 {
 public:
   WaitForTransactionsToFinishRunnable(SynchronizedOp* aOp)
   : mOp(aOp), mCountdown(1)
   {
     NS_ASSERTION(mOp, "Why don't we have a runnable?");
     NS_ASSERTION(mOp->mStorages.IsEmpty(), "We're here too early!");
     NS_ASSERTION(mOp->mListener,
                  "What are we supposed to do when we're done?");
     NS_ASSERTION(mCountdown, "Wrong countdown!");
   }
   NS_IMETHOD
   Run();
   void
   AddRun()
   {
     mCountdown++;
   }
 private:
   // The QuotaManager holds this alive.
   SynchronizedOp* mOp;
   uint32_t mCountdown;
 };
 class WaitForLockedFilesToFinishRunnable MOZ_FINAL : public nsRunnable
 {
 public:
   WaitForLockedFilesToFinishRunnable()
   : mBusy(true)
   { }
   NS_IMETHOD
   Run();
   bool
   IsBusy() const
   {
     return mBusy;
   }
 private:
   bool mBusy;
 };
 class SaveOriginAccessTimeRunnable MOZ_FINAL : public nsRunnable
 {
 public:
   SaveOriginAccessTimeRunnable(const nsACString& aOrigin, int64_t aTimestamp)
   : mOrigin(aOrigin), mTimestamp(aTimestamp)
   { }
   NS_IMETHOD
   Run();
 private:
   nsCString mOrigin;
   int64_t mTimestamp;
 };
 struct MOZ_STACK_CLASS RemoveQuotaInfo
 {
   RemoveQuotaInfo(PersistenceType aPersistenceType, const nsACString& aPattern)
   : persistenceType(aPersistenceType), pattern(aPattern)
   { }
   PersistenceType persistenceType;
   nsCString pattern;
 };
 struct MOZ_STACK_CLASS InactiveOriginsInfo
 {
   InactiveOriginsInfo(OriginCollection& aCollection,
                       nsTArray<OriginInfo*>& aOrigins)
   : collection(aCollection), origins(aOrigins)
   { }
   OriginCollection& collection;
   nsTArray<OriginInfo*>& origins;
 };
 bool
 IsMainProcess()
 {
   return XRE_GetProcessType() == GeckoProcessType_Default;
 }
 void
 SanitizeOriginString(nsCString& aOrigin)
 {
   // We want profiles to be platform-independent so we always need to replace
   // the same characters on every platform. Windows has the most extensive set
   // of illegal characters so we use its FILE_ILLEGAL_CHARACTERS and
   // FILE_PATH_SEPARATOR.
   static const char kReplaceChars[] = CONTROL_CHARACTERS "/:*?\"<>|\\";
 #ifdef XP_WIN
   NS_ASSERTION(!strcmp(kReplaceChars,
                        FILE_ILLEGAL_CHARACTERS FILE_PATH_SEPARATOR),
                "Illegal file characters have changed!");
 #endif
   aOrigin.ReplaceChar(kReplaceChars, '+');
 }
 nsresult
 EnsureDirectory(nsIFile* aDirectory, bool* aCreated)
 {
   AssertIsOnIOThread();
   nsresult rv = aDirectory->Create(nsIFile::DIRECTORY_TYPE, 0755);
   if (rv == NS_ERROR_FILE_ALREADY_EXISTS) {
     bool isDirectory;
     rv = aDirectory->IsDirectory(&isDirectory);
     NS_ENSURE_SUCCESS(rv, rv);
     NS_ENSURE_TRUE(isDirectory, NS_ERROR_UNEXPECTED);
     *aCreated = false;
   }
   else {
     NS_ENSURE_SUCCESS(rv, rv);
     *aCreated = true;
   }
   return NS_OK;
 }
 nsresult
 CreateDirectoryUpgradeStamp(nsIFile* aDirectory)
 {
   AssertIsOnIOThread();
   nsCOMPtr<nsIFile> metadataFile;
   nsresult rv = aDirectory->Clone(getter_AddRefs(metadataFile));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = metadataFile->Append(NS_LITERAL_STRING(METADATA_FILE_NAME));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = metadataFile->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 GetDirectoryMetadataStream(nsIFile* aDirectory, bool aUpdate,
                            nsIBinaryOutputStream** aStream)
 {
   AssertIsOnIOThread();
   nsCOMPtr<nsIFile> metadataFile;
   nsresult rv = aDirectory->Clone(getter_AddRefs(metadataFile));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = metadataFile->Append(NS_LITERAL_STRING(METADATA_FILE_NAME));
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsIOutputStream> outputStream;
   if (aUpdate) {
     bool exists;
     rv = metadataFile->Exists(&exists);
     NS_ENSURE_SUCCESS(rv, rv);
     if (!exists) {
       *aStream = nullptr;
       return NS_OK;
     }
     nsCOMPtr<nsIFileStream> stream;
     rv = NS_NewLocalFileStream(getter_AddRefs(stream), metadataFile);
     NS_ENSURE_SUCCESS(rv, rv);
     outputStream = do_QueryInterface(stream);
     NS_ENSURE_TRUE(outputStream, NS_ERROR_FAILURE);
   }
   else {
     rv = NS_NewLocalFileOutputStream(getter_AddRefs(outputStream),
                                      metadataFile);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   nsCOMPtr<nsIBinaryOutputStream> binaryStream =
     do_CreateInstance("@mozilla.org/binaryoutputstream;1");
   NS_ENSURE_TRUE(binaryStream, NS_ERROR_FAILURE);
   rv = binaryStream->SetOutputStream(outputStream);
   NS_ENSURE_SUCCESS(rv, rv);
   binaryStream.forget(aStream);
   return NS_OK;
 }
 nsresult
 CreateDirectoryMetadata(nsIFile* aDirectory, int64_t aTimestamp,
                         const nsACString& aGroup, const nsACString& aOrigin)
 {
   AssertIsOnIOThread();
   nsCOMPtr<nsIBinaryOutputStream> stream;
   nsresult rv =
     GetDirectoryMetadataStream(aDirectory, false, getter_AddRefs(stream));
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ASSERTION(stream, "This shouldn't be null!");
   rv = stream->Write64(aTimestamp);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = stream->WriteStringZ(PromiseFlatCString(aGroup).get());
   NS_ENSURE_SUCCESS(rv, rv);
   rv = stream->WriteStringZ(PromiseFlatCString(aOrigin).get());
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 GetDirectoryMetadata(nsIFile* aDirectory, int64_t* aTimestamp,
                      nsACString& aGroup, nsACString& aOrigin)
 {
   AssertIsOnIOThread();
   nsCOMPtr<nsIFile> metadataFile;
   nsresult rv = aDirectory->Clone(getter_AddRefs(metadataFile));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = metadataFile->Append(NS_LITERAL_STRING(METADATA_FILE_NAME));
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsIInputStream> stream;
   rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), metadataFile);
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsIInputStream> bufferedStream;
   rv = NS_NewBufferedInputStream(getter_AddRefs(bufferedStream), stream, 512);
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsIBinaryInputStream> binaryStream =
     do_CreateInstance("@mozilla.org/binaryinputstream;1");
   NS_ENSURE_TRUE(binaryStream, NS_ERROR_FAILURE);
   rv = binaryStream->SetInputStream(bufferedStream);
   NS_ENSURE_SUCCESS(rv, rv);
   uint64_t timestamp;
   rv = binaryStream->Read64(&timestamp);
   NS_ENSURE_SUCCESS(rv, rv);
   nsCString group;
   rv = binaryStream->ReadCString(group);
   NS_ENSURE_SUCCESS(rv, rv);
   nsCString origin;
   rv = binaryStream->ReadCString(origin);
   NS_ENSURE_SUCCESS(rv, rv);
   *aTimestamp = timestamp;
   aGroup = group;
   aOrigin = origin;
   return NS_OK;
 }
 nsresult
 MaybeUpgradeOriginDirectory(nsIFile* aDirectory)
 {
   AssertIsOnIOThread();
   NS_ASSERTION(aDirectory, "Null pointer!");
   nsCOMPtr<nsIFile> metadataFile;
   nsresult rv = aDirectory->Clone(getter_AddRefs(metadataFile));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = metadataFile->Append(NS_LITERAL_STRING(METADATA_FILE_NAME));
   NS_ENSURE_SUCCESS(rv, rv);
   bool exists;
   rv = metadataFile->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
   if (!exists) {
     // Directory structure upgrade needed.
     // Move all files to IDB specific directory.
     nsString idbDirectoryName;
     rv = Client::TypeToText(Client::IDB, idbDirectoryName);
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIFile> idbDirectory;
     rv = aDirectory->Clone(getter_AddRefs(idbDirectory));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = idbDirectory->Append(idbDirectoryName);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = idbDirectory->Create(nsIFile::DIRECTORY_TYPE, 0755);
     if (rv == NS_ERROR_FILE_ALREADY_EXISTS) {
       NS_WARNING("IDB directory already exists!");
       bool isDirectory;
       rv = idbDirectory->IsDirectory(&isDirectory);
       NS_ENSURE_SUCCESS(rv, rv);
       NS_ENSURE_TRUE(isDirectory, NS_ERROR_UNEXPECTED);
     }
     else {
       NS_ENSURE_SUCCESS(rv, rv);
     }
     nsCOMPtr<nsISimpleEnumerator> entries;
     rv = aDirectory->GetDirectoryEntries(getter_AddRefs(entries));
     NS_ENSURE_SUCCESS(rv, rv);
     bool hasMore;
     while (NS_SUCCEEDED((rv = entries->HasMoreElements(&hasMore))) && hasMore) {
       nsCOMPtr<nsISupports> entry;
       rv = entries->GetNext(getter_AddRefs(entry));
       NS_ENSURE_SUCCESS(rv, rv);
       nsCOMPtr<nsIFile> file = do_QueryInterface(entry);
       NS_ENSURE_TRUE(file, NS_NOINTERFACE);
       nsString leafName;
       rv = file->GetLeafName(leafName);
       NS_ENSURE_SUCCESS(rv, rv);
       if (!leafName.Equals(idbDirectoryName)) {
         rv = file->MoveTo(idbDirectory, EmptyString());
         NS_ENSURE_SUCCESS(rv, rv);
       }
     }
     rv = metadataFile->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   return NS_OK;
 }
 // This method computes and returns our best guess for the temporary storage
 // limit (in bytes), based on the amount of space users have free on their hard
 // drive and on given temporary storage usage (also in bytes).
 nsresult
 GetTemporaryStorageLimit(nsIFile* aDirectory, uint64_t aCurrentUsage,
                          uint64_t* aLimit)
 {
   // Check for free space on device where temporary storage directory lives.
   int64_t bytesAvailable;
   nsresult rv = aDirectory->GetDiskSpaceAvailable(&bytesAvailable);
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ASSERTION(bytesAvailable >= 0, "Negative bytes available?!");
   uint64_t availableKB =
     static_cast<uint64_t>((bytesAvailable + aCurrentUsage) / 1024);
   // Grow/shrink in gChunkSizeKB units, deliberately, so that in the common case
   // we don't shrink temporary storage and evict origin data every time we
   // initialize.
   availableKB = (availableKB / gChunkSizeKB) * gChunkSizeKB;
   // Allow temporary storage to consume up to half the available space.
   uint64_t resultKB = availableKB * .50;
   *aLimit = resultKB * 1024;
   return NS_OK;
 }
 } // anonymous namespace
 QuotaManager::QuotaManager()
 : mCurrentWindowIndex(BAD_TLS_INDEX),
   mQuotaMutex("QuotaManager.mQuotaMutex"),
   mTemporaryStorageLimit(0),
   mTemporaryStorageUsage(0),
   mTemporaryStorageInitialized(false),
   mStorageAreaInitialized(false)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(!gInstance, "More than one instance!");
 }
 QuotaManager::~QuotaManager()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(!gInstance || gInstance == this, "Different instances!");
   gInstance = nullptr;
 }
 // static
 QuotaManager*
 QuotaManager::GetOrCreate()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   if (IsShuttingDown()) {
     NS_ERROR("Calling GetOrCreate() after shutdown!");
     return nullptr;
   }
   if (!gInstance) {
     nsRefPtr<QuotaManager> instance(new QuotaManager());
     nsresult rv = instance->Init();
     NS_ENSURE_SUCCESS(rv, nullptr);
     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
     NS_ENSURE_TRUE(obs, nullptr);
     // We need this callback to know when to shut down all our threads.
     rv = obs->AddObserver(instance, PROFILE_BEFORE_CHANGE_OBSERVER_ID, false);
     NS_ENSURE_SUCCESS(rv, nullptr);
     // The observer service will hold our last reference, don't AddRef here.
     gInstance = instance;
   }
   return gInstance;
 }
 // static
 QuotaManager*
 QuotaManager::Get()
 {
   // Does not return an owning reference.
   return gInstance;
 }
 // static
 QuotaManager*
 QuotaManager::FactoryCreate()
 {
   // Returns a raw pointer that carries an owning reference! Lame, but the
   // singleton factory macros force this.
   QuotaManager* quotaManager = GetOrCreate();
   NS_IF_ADDREF(quotaManager);
   return quotaManager;
 }
 // static
 bool
 QuotaManager::IsShuttingDown()
 {
   return gShutdown;
 }
 nsresult
 QuotaManager::Init()
 {
   // We need a thread-local to hold the current window.
   NS_ASSERTION(mCurrentWindowIndex == BAD_TLS_INDEX, "Huh?");
   if (PR_NewThreadPrivateIndex(&mCurrentWindowIndex, nullptr) != PR_SUCCESS) {
     NS_ERROR("PR_NewThreadPrivateIndex failed, QuotaManager disabled");
     mCurrentWindowIndex = BAD_TLS_INDEX;
     return NS_ERROR_FAILURE;
   }
   nsresult rv;
   if (IsMainProcess()) {
     nsCOMPtr<nsIFile> baseDir;
     rv = NS_GetSpecialDirectory(NS_APP_INDEXEDDB_PARENT_DIR,
                                 getter_AddRefs(baseDir));
     if (NS_FAILED(rv)) {
       rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
                                   getter_AddRefs(baseDir));
     }
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIFile> indexedDBDir;
     rv = baseDir->Clone(getter_AddRefs(indexedDBDir));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = indexedDBDir->Append(NS_LITERAL_STRING("indexedDB"));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = indexedDBDir->GetPath(mIndexedDBPath);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = baseDir->Append(NS_LITERAL_STRING("storage"));
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIFile> persistentStorageDir;
     rv = baseDir->Clone(getter_AddRefs(persistentStorageDir));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = persistentStorageDir->Append(NS_LITERAL_STRING("persistent"));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = persistentStorageDir->GetPath(mPersistentStoragePath);
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIFile> temporaryStorageDir;
     rv = baseDir->Clone(getter_AddRefs(temporaryStorageDir));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = temporaryStorageDir->Append(NS_LITERAL_STRING("temporary"));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = temporaryStorageDir->GetPath(mTemporaryStoragePath);
     NS_ENSURE_SUCCESS(rv, rv);
     // Make a lazy thread for any IO we need (like clearing or enumerating the
     // contents of storage directories).
     mIOThread = new LazyIdleThread(DEFAULT_THREAD_TIMEOUT_MS,
                                    NS_LITERAL_CSTRING("Storage I/O"),
                                    LazyIdleThread::ManualShutdown);
     // Make a timer here to avoid potential failures later. We don't actually
     // initialize the timer until shutdown.
     mShutdownTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
     NS_ENSURE_TRUE(mShutdownTimer, NS_ERROR_FAILURE);
   }
   if (NS_FAILED(Preferences::AddIntVarCache(&gStorageQuotaMB,
                                             PREF_STORAGE_QUOTA,
                                             kDefaultQuotaMB))) {
     NS_WARNING("Unable to respond to quota pref changes!");
   }
   if (NS_FAILED(Preferences::AddIntVarCache(&gFixedLimitKB, PREF_FIXED_LIMIT,
                                             kDefaultFixedLimitKB)) ||
       NS_FAILED(Preferences::AddUintVarCache(&gChunkSizeKB,
                                              PREF_CHUNK_SIZE,
                                              kDefaultChunkSizeKB))) {
     NS_WARNING("Unable to respond to temp storage pref changes!");
   }
   if (NS_FAILED(Preferences::AddBoolVarCache(&gTestingEnabled,
                                              PREF_TESTING_FEATURES, false))) {
     NS_WARNING("Unable to respond to testing pref changes!");
   }
   static_assert(Client::IDB == 0 && Client::ASMJS == 1 && Client::TYPE_MAX == 2,
                 "Fix the registration!");
   NS_ASSERTION(mClients.Capacity() == Client::TYPE_MAX,
                "Should be using an auto array with correct capacity!");
   // Register IndexedDB
   mClients.AppendElement(new indexedDB::Client());
   mClients.AppendElement(asmjscache::CreateClient());
   return NS_OK;
 }
 void
 QuotaManager::InitQuotaForOrigin(PersistenceType aPersistenceType,
                                  const nsACString& aGroup,
                                  const nsACString& aOrigin,
                                  uint64_t aLimitBytes,
                                  uint64_t aUsageBytes,
                                  int64_t aAccessTime)
 {
   AssertIsOnIOThread();
   MOZ_ASSERT(aLimitBytes > 0 ||
              aPersistenceType == PERSISTENCE_TYPE_TEMPORARY);
   MOZ_ASSERT(aUsageBytes <= aLimitBytes ||
              aPersistenceType == PERSISTENCE_TYPE_TEMPORARY);
   MutexAutoLock lock(mQuotaMutex);
   GroupInfoPair* pair;
   if (!mGroupInfoPairs.Get(aGroup, &pair)) {
     pair = new GroupInfoPair();
     mGroupInfoPairs.Put(aGroup, pair);
     // The hashtable is now responsible to delete the GroupInfoPair.
   }
   nsRefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
   if (!groupInfo) {
     groupInfo = new GroupInfo(aPersistenceType, aGroup);
     pair->LockedSetGroupInfo(groupInfo);
   }
   nsRefPtr<OriginInfo> originInfo =
     new OriginInfo(groupInfo, aOrigin, aLimitBytes, aUsageBytes, aAccessTime);
   groupInfo->LockedAddOriginInfo(originInfo);
 }
 void
 QuotaManager::DecreaseUsageForOrigin(PersistenceType aPersistenceType,
                                      const nsACString& aGroup,
                                      const nsACString& aOrigin,
                                      int64_t aSize)
 {
   AssertIsOnIOThread();
   MutexAutoLock lock(mQuotaMutex);
   GroupInfoPair* pair;
   if (!mGroupInfoPairs.Get(aGroup, &pair)) {
     return;
   }
   nsRefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
   if (!groupInfo) {
     return;
   }
   nsRefPtr<OriginInfo> originInfo = groupInfo->LockedGetOriginInfo(aOrigin);
   if (originInfo) {
     originInfo->LockedDecreaseUsage(aSize);
   }
 }
 void
 QuotaManager::UpdateOriginAccessTime(PersistenceType aPersistenceType,
                                      const nsACString& aGroup,
                                      const nsACString& aOrigin)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   MutexAutoLock lock(mQuotaMutex);
   GroupInfoPair* pair;
   if (!mGroupInfoPairs.Get(aGroup, &pair)) {
     return;
   }
   nsRefPtr<GroupInfo> groupInfo =
     pair->LockedGetGroupInfo(PERSISTENCE_TYPE_TEMPORARY);
   if (!groupInfo) {
     return;
   }
   nsRefPtr<OriginInfo> originInfo = groupInfo->LockedGetOriginInfo(aOrigin);
   if (originInfo) {
     int64_t timestamp = PR_Now();
     originInfo->LockedUpdateAccessTime(timestamp);
     if (!groupInfo->IsForTemporaryStorage()) {
       return;
     }
     MutexAutoUnlock autoUnlock(mQuotaMutex);
     SaveOriginAccessTime(aOrigin, timestamp);
   }
 }
 // static
 PLDHashOperator
 QuotaManager::RemoveQuotaCallback(const nsACString& aKey,
                                   nsAutoPtr<GroupInfoPair>& aValue,
                                   void* aUserArg)
 {
   NS_ASSERTION(!aKey.IsEmpty(), "Empty key!");
   NS_ASSERTION(aValue, "Null pointer!");
   nsRefPtr<GroupInfo> groupInfo =
     aValue->LockedGetGroupInfo(PERSISTENCE_TYPE_TEMPORARY);
   if (groupInfo) {
     groupInfo->LockedRemoveOriginInfos();
   }
   return PL_DHASH_REMOVE;
 }
 void
 QuotaManager::RemoveQuota()
 {
   MutexAutoLock lock(mQuotaMutex);
   mGroupInfoPairs.Enumerate(RemoveQuotaCallback, nullptr);
   NS_ASSERTION(mTemporaryStorageUsage == 0, "Should be zero!");
 }
 // static
 PLDHashOperator
 QuotaManager::RemoveQuotaForPersistenceTypeCallback(
                                                const nsACString& aKey,
                                                nsAutoPtr<GroupInfoPair>& aValue,
                                                void* aUserArg)
 {
   NS_ASSERTION(!aKey.IsEmpty(), "Empty key!");
   NS_ASSERTION(aValue, "Null pointer!");
   NS_ASSERTION(aUserArg, "Null pointer!");
   PersistenceType& persistenceType = *static_cast<PersistenceType*>(aUserArg);
   if (persistenceType == PERSISTENCE_TYPE_TEMPORARY) {
     nsRefPtr<GroupInfo> groupInfo =
       aValue->LockedGetGroupInfo(persistenceType);
     if (groupInfo) {
       groupInfo->LockedRemoveOriginInfos();
     }
   }
   aValue->LockedClearGroupInfo(persistenceType);
   return aValue->LockedHasGroupInfos() ? PL_DHASH_NEXT : PL_DHASH_REMOVE;
 }
 void
 QuotaManager::RemoveQuotaForPersistenceType(PersistenceType aPersistenceType)
 {
   MutexAutoLock lock(mQuotaMutex);
   mGroupInfoPairs.Enumerate(RemoveQuotaForPersistenceTypeCallback,
                             &aPersistenceType);
   NS_ASSERTION(aPersistenceType == PERSISTENCE_TYPE_PERSISTENT ||
                mTemporaryStorageUsage == 0, "Should be zero!");
 }
 // static
 PLDHashOperator
 QuotaManager::RemoveQuotaForPatternCallback(const nsACString& aKey,
                                             nsAutoPtr<GroupInfoPair>& aValue,
                                             void* aUserArg)
 {
   NS_ASSERTION(!aKey.IsEmpty(), "Empty key!");
   NS_ASSERTION(aValue, "Null pointer!");
   NS_ASSERTION(aUserArg, "Null pointer!");
   RemoveQuotaInfo* info = static_cast<RemoveQuotaInfo*>(aUserArg);
   nsRefPtr<GroupInfo> groupInfo =
     aValue->LockedGetGroupInfo(info->persistenceType);
   if (groupInfo) {
     groupInfo->LockedRemoveOriginInfosForPattern(info->pattern);
     if (!groupInfo->LockedHasOriginInfos()) {
       aValue->LockedClearGroupInfo(info->persistenceType);
       if (!aValue->LockedHasGroupInfos()) {
         return PL_DHASH_REMOVE;
       }
     }
   }
   return PL_DHASH_NEXT;
 }
 void
 QuotaManager::RemoveQuotaForPattern(PersistenceType aPersistenceType,
                                     const nsACString& aPattern)
 {
   NS_ASSERTION(!aPattern.IsEmpty(), "Empty pattern!");
   RemoveQuotaInfo info(aPersistenceType, aPattern);
   MutexAutoLock lock(mQuotaMutex);
   mGroupInfoPairs.Enumerate(RemoveQuotaForPatternCallback, &info);
 }
 already_AddRefed<QuotaObject>
 QuotaManager::GetQuotaObject(PersistenceType aPersistenceType,
                              const nsACString& aGroup,
                              const nsACString& aOrigin,
                              nsIFile* aFile)
 {
   NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
   nsString path;
   nsresult rv = aFile->GetPath(path);
   NS_ENSURE_SUCCESS(rv, nullptr);
   int64_t fileSize;
   bool exists;
   rv = aFile->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, nullptr);
   if (exists) {
     rv = aFile->GetFileSize(&fileSize);
     NS_ENSURE_SUCCESS(rv, nullptr);
   }
   else {
     fileSize = 0;
   }
   nsRefPtr<QuotaObject> result;
   {
     MutexAutoLock lock(mQuotaMutex);
     GroupInfoPair* pair;
     if (!mGroupInfoPairs.Get(aGroup, &pair)) {
       return nullptr;
     }
     nsRefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
     if (!groupInfo) {
       return nullptr;
     }
     nsRefPtr<OriginInfo> originInfo = groupInfo->LockedGetOriginInfo(aOrigin);
     if (!originInfo) {
       return nullptr;
     }
     // We need this extra raw pointer because we can't assign to the smart
     // pointer directly since QuotaObject::AddRef would try to acquire the same
     // mutex.
     QuotaObject* quotaObject;
     if (!originInfo->mQuotaObjects.Get(path, &quotaObject)) {
       // Create a new QuotaObject.
       quotaObject = new QuotaObject(originInfo, path, fileSize);
       // Put it to the hashtable. The hashtable is not responsible to delete
       // the QuotaObject.
       originInfo->mQuotaObjects.Put(path, quotaObject);
     }
     // Addref the QuotaObject and move the ownership to the result. This must
     // happen before we unlock!
     result = quotaObject->LockedAddRef();
   }
   // The caller becomes the owner of the QuotaObject, that is, the caller is
   // is responsible to delete it when the last reference is removed.
   return result.forget();
 }
 already_AddRefed<QuotaObject>
 QuotaManager::GetQuotaObject(PersistenceType aPersistenceType,
                              const nsACString& aGroup,
                              const nsACString& aOrigin,
                              const nsAString& aPath)
 {
   nsresult rv;
   nsCOMPtr<nsIFile> file = do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, nullptr);
   rv = file->InitWithPath(aPath);
   NS_ENSURE_SUCCESS(rv, nullptr);
   return GetQuotaObject(aPersistenceType, aGroup, aOrigin, file);
 }
 bool
 QuotaManager::RegisterStorage(nsIOfflineStorage* aStorage)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aStorage, "Null pointer!");
   // Don't allow any new storages to be created after shutdown.
   if (IsShuttingDown()) {
     return false;
   }
   // Add this storage to its origin info if it exists, create it otherwise.
   const nsACString& origin = aStorage->Origin();
   ArrayCluster<nsIOfflineStorage*>* cluster;
   if (!mLiveStorages.Get(origin, &cluster)) {
     cluster = new ArrayCluster<nsIOfflineStorage*>();
     mLiveStorages.Put(origin, cluster);
     UpdateOriginAccessTime(aStorage->Type(), aStorage->Group(), origin);
   }
   (*cluster)[aStorage->GetClient()->GetType()].AppendElement(aStorage);
   return true;
 }
 void
 QuotaManager::UnregisterStorage(nsIOfflineStorage* aStorage)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aStorage, "Null pointer!");
   // Remove this storage from its origin array, maybe remove the array if it
   // is then empty.
   const nsACString& origin = aStorage->Origin();
   ArrayCluster<nsIOfflineStorage*>* cluster;
   if (mLiveStorages.Get(origin, &cluster) &&
       (*cluster)[aStorage->GetClient()->GetType()].RemoveElement(aStorage)) {
     if (cluster->IsEmpty()) {
       mLiveStorages.Remove(origin);
       UpdateOriginAccessTime(aStorage->Type(), aStorage->Group(), origin);
     }
     return;
   }
   NS_ERROR("Didn't know anything about this storage!");
 }
 void
 QuotaManager::OnStorageClosed(nsIOfflineStorage* aStorage)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aStorage, "Null pointer!");
   // Check through the list of SynchronizedOps to see if any are waiting for
   // this storage to close before proceeding.
   SynchronizedOp* op =
     FindSynchronizedOp(aStorage->Origin(),
                        Nullable<PersistenceType>(aStorage->Type()),
                        aStorage->Id());
   if (op) {
     Client::Type clientType = aStorage->GetClient()->GetType();
     // This storage is in the scope of this SynchronizedOp.  Remove it
     // from the list if necessary.
     if (op->mStorages[clientType].RemoveElement(aStorage)) {
       // Now set up the helper if there are no more live storages.
       NS_ASSERTION(op->mListener,
                    "How did we get rid of the listener before removing the "
                     "last storage?");
       if (op->mStorages[clientType].IsEmpty()) {
         // At this point, all storages are closed, so no new transactions
         // can be started.  There may, however, still be outstanding
         // transactions that have not completed.  We need to wait for those
         // before we dispatch the helper.
         if (NS_FAILED(RunSynchronizedOp(aStorage, op))) {
           NS_WARNING("Failed to run synchronized op!");
         }
       }
     }
   }
 }
 void
 QuotaManager::AbortCloseStoragesForWindow(nsPIDOMWindow* aWindow)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aWindow, "Null pointer!");
   FileService* service = FileService::Get();
   StorageMatcher<ArrayCluster<nsIOfflineStorage*> > liveStorages;
   liveStorages.Find(mLiveStorages);
   for (uint32_t i = 0; i < Client::TYPE_MAX; i++) {
     nsRefPtr<Client>& client = mClients[i];
     bool utilized = service && client->IsFileServiceUtilized();
     bool activated = client->IsTransactionServiceActivated();
     nsTArray<nsIOfflineStorage*>& array = liveStorages[i];
     for (uint32_t j = 0; j < array.Length(); j++) {
       nsIOfflineStorage*& storage = array[j];
       if (storage->IsOwned(aWindow)) {
         if (NS_FAILED(storage->Close())) {
           NS_WARNING("Failed to close storage for dying window!");
         }
         if (utilized) {
           service->AbortLockedFilesForStorage(storage);
         }
         if (activated) {
           client->AbortTransactionsForStorage(storage);
         }
       }
     }
   }
 }
 bool
 QuotaManager::HasOpenTransactions(nsPIDOMWindow* aWindow)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aWindow, "Null pointer!");
   FileService* service = FileService::Get();
   nsAutoPtr<StorageMatcher<ArrayCluster<nsIOfflineStorage*> > > liveStorages;
   for (uint32_t i = 0; i < Client::TYPE_MAX; i++) {
     nsRefPtr<Client>& client = mClients[i];
     bool utilized = service && client->IsFileServiceUtilized();
     bool activated = client->IsTransactionServiceActivated();
     if (utilized || activated) {
       if (!liveStorages) {
         liveStorages = new StorageMatcher<ArrayCluster<nsIOfflineStorage*> >();
         liveStorages->Find(mLiveStorages);
       }
       nsTArray<nsIOfflineStorage*>& storages = liveStorages->ArrayAt(i);
       for (uint32_t j = 0; j < storages.Length(); j++) {
         nsIOfflineStorage*& storage = storages[j];
         if (storage->IsOwned(aWindow) &&
             ((utilized && service->HasLockedFilesForStorage(storage)) ||
              (activated && client->HasTransactionsForStorage(storage)))) {
           return true;
         }
       }
     }
   }
   return false;
 }
 nsresult
 QuotaManager::WaitForOpenAllowed(const OriginOrPatternString& aOriginOrPattern,
                                  Nullable<PersistenceType> aPersistenceType,
                                  const nsACString& aId, nsIRunnable* aRunnable)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(!aOriginOrPattern.IsEmpty() || aOriginOrPattern.IsNull(),
                "Empty pattern!");
   NS_ASSERTION(aRunnable, "Null pointer!");
   nsAutoPtr<SynchronizedOp> op(new SynchronizedOp(aOriginOrPattern,
                                                   aPersistenceType, aId));
   // See if this runnable needs to wait.
   bool delayed = false;
   for (uint32_t index = mSynchronizedOps.Length(); index > 0; index--) {
     nsAutoPtr<SynchronizedOp>& existingOp = mSynchronizedOps[index - 1];
     if (op->MustWaitFor(*existingOp)) {
       existingOp->DelayRunnable(aRunnable);
       delayed = true;
       break;
     }
   }
   // Otherwise, dispatch it immediately.
   if (!delayed) {
     nsresult rv = NS_DispatchToCurrentThread(aRunnable);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   // Adding this to the synchronized ops list will block any additional
   // ops from proceeding until this one is done.
   mSynchronizedOps.AppendElement(op.forget());
   return NS_OK;
 }
 void
 QuotaManager::AddSynchronizedOp(const OriginOrPatternString& aOriginOrPattern,
                                 Nullable<PersistenceType> aPersistenceType)
 {
   nsAutoPtr<SynchronizedOp> op(new SynchronizedOp(aOriginOrPattern,
                                                   aPersistenceType,
                                                   EmptyCString()));
 #ifdef DEBUG
   for (uint32_t index = mSynchronizedOps.Length(); index > 0; index--) {
     nsAutoPtr<SynchronizedOp>& existingOp = mSynchronizedOps[index - 1];
     NS_ASSERTION(!op->MustWaitFor(*existingOp), "What?");
   }
 #endif
   mSynchronizedOps.AppendElement(op.forget());
 }
 void
 QuotaManager::AllowNextSynchronizedOp(
                                   const OriginOrPatternString& aOriginOrPattern,
                                   Nullable<PersistenceType> aPersistenceType,
                                   const nsACString& aId)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(!aOriginOrPattern.IsEmpty() || aOriginOrPattern.IsNull(),
                "Empty origin/pattern!");
   uint32_t count = mSynchronizedOps.Length();
   for (uint32_t index = 0; index < count; index++) {
     nsAutoPtr<SynchronizedOp>& op = mSynchronizedOps[index];
     if (op->mOriginOrPattern.IsOrigin() == aOriginOrPattern.IsOrigin() &&
         op->mOriginOrPattern == aOriginOrPattern &&
         op->mPersistenceType == aPersistenceType) {
       if (op->mId == aId) {
         NS_ASSERTION(op->mStorages.IsEmpty(), "How did this happen?");
         op->DispatchDelayedRunnables();
         mSynchronizedOps.RemoveElementAt(index);
         return;
       }
       // If one or the other is for an origin clear, we should have matched
       // solely on origin.
       NS_ASSERTION(!op->mId.IsEmpty() && !aId.IsEmpty(),
                    "Why didn't we match earlier?");
     }
   }
   NS_NOTREACHED("Why didn't we find a SynchronizedOp?");
 }
 nsresult
 QuotaManager::GetDirectoryForOrigin(PersistenceType aPersistenceType,
                                     const nsACString& aASCIIOrigin,
                                     nsIFile** aDirectory) const
 {
   nsresult rv;
   nsCOMPtr<nsIFile> directory =
     do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = directory->InitWithPath(GetStoragePath(aPersistenceType));
   NS_ENSURE_SUCCESS(rv, rv);
   nsAutoCString originSanitized(aASCIIOrigin);
   SanitizeOriginString(originSanitized);
   rv = directory->Append(NS_ConvertASCIItoUTF16(originSanitized));
   NS_ENSURE_SUCCESS(rv, rv);
   directory.forget(aDirectory);
   return NS_OK;
 }
 nsresult
 QuotaManager::InitializeOrigin(PersistenceType aPersistenceType,
                                const nsACString& aGroup,
                                const nsACString& aOrigin,
                                bool aTrackQuota,
                                int64_t aAccessTime,
                                nsIFile* aDirectory)
 {
   AssertIsOnIOThread();
   nsresult rv;
   bool temporaryStorage = aPersistenceType == PERSISTENCE_TYPE_TEMPORARY;
   if (!temporaryStorage) {
     rv = MaybeUpgradeOriginDirectory(aDirectory);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   // We need to initialize directories of all clients if they exists and also
   // get the total usage to initialize the quota.
   nsAutoPtr<UsageInfo> usageInfo;
   if (aTrackQuota) {
     usageInfo = new UsageInfo();
   }
   nsCOMPtr<nsISimpleEnumerator> entries;
   rv = aDirectory->GetDirectoryEntries(getter_AddRefs(entries));
   NS_ENSURE_SUCCESS(rv, rv);
   bool hasMore;
   while (NS_SUCCEEDED((rv = entries->HasMoreElements(&hasMore))) && hasMore) {
     nsCOMPtr<nsISupports> entry;
     rv = entries->GetNext(getter_AddRefs(entry));
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsIFile> file = do_QueryInterface(entry);
     NS_ENSURE_TRUE(file, NS_NOINTERFACE);
     nsString leafName;
     rv = file->GetLeafName(leafName);
     NS_ENSURE_SUCCESS(rv, rv);
     if (leafName.EqualsLiteral(METADATA_FILE_NAME) ||
         leafName.EqualsLiteral(DSSTORE_FILE_NAME)) {
       continue;
     }
     bool isDirectory;
     rv = file->IsDirectory(&isDirectory);
     NS_ENSURE_SUCCESS(rv, rv);
     if (!isDirectory) {
       NS_WARNING("Unknown file found!");
       return NS_ERROR_UNEXPECTED;
     }
     Client::Type clientType;
     rv = Client::TypeFromText(leafName, clientType);
     if (NS_FAILED(rv)) {
       NS_WARNING("Unknown directory found!");
       return NS_ERROR_UNEXPECTED;
     }
     rv = mClients[clientType]->InitOrigin(aPersistenceType, aGroup, aOrigin,
                                           usageInfo);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   if (aTrackQuota) {
     uint64_t quotaMaxBytes;
     uint64_t totalUsageBytes = usageInfo->TotalUsage();
     if (temporaryStorage) {
       // Temporary storage has no limit for origin usage (there's a group and
       // the global limit though).
       quotaMaxBytes = 0;
     }
     else {
       quotaMaxBytes = GetStorageQuotaMB() * 1024 * 1024;
       if (totalUsageBytes > quotaMaxBytes) {
         NS_WARNING("Origin is already using more storage than allowed!");
         return NS_ERROR_UNEXPECTED;
       }
     }
     InitQuotaForOrigin(aPersistenceType, aGroup, aOrigin, quotaMaxBytes,
                        totalUsageBytes, aAccessTime);
   }
   return NS_OK;
 }
 nsresult
 QuotaManager::MaybeUpgradeIndexedDBDirectory()
 {
   AssertIsOnIOThread();
   if (mStorageAreaInitialized) {
     return NS_OK;
   }
   nsresult rv;
   nsCOMPtr<nsIFile> indexedDBDir =
     do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = indexedDBDir->InitWithPath(mIndexedDBPath);
   NS_ENSURE_SUCCESS(rv, rv);
   bool exists;
   rv = indexedDBDir->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
   if (!exists) {
     // Nothing to upgrade.
     mStorageAreaInitialized = true;
     return NS_OK;
   }
   bool isDirectory;
   rv = indexedDBDir->IsDirectory(&isDirectory);
   NS_ENSURE_SUCCESS(rv, rv);
   if (!isDirectory) {
     NS_WARNING("indexedDB entry is not a directory!");
     return NS_OK;
   }
   nsCOMPtr<nsIFile> persistentStorageDir =
     do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = persistentStorageDir->InitWithPath(mPersistentStoragePath);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = persistentStorageDir->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
   if (exists) {
     NS_WARNING("indexedDB directory shouldn't exist after the upgrade!");
     return NS_OK;
   }
   nsCOMPtr<nsIFile> storageDir;
   rv = persistentStorageDir->GetParent(getter_AddRefs(storageDir));
   NS_ENSURE_SUCCESS(rv, rv);
   nsString persistentStorageName;
   rv = persistentStorageDir->GetLeafName(persistentStorageName);
   NS_ENSURE_SUCCESS(rv, rv);
   // MoveTo() is atomic if the move happens on the same volume which should
   // be our case, so even if we crash in the middle of the operation nothing
   // breaks next time we try to initialize.
   // However there's a theoretical possibility that the indexedDB directory
   // is on different volume, but it should be rare enough that we don't have
   // to worry about it.
   rv = indexedDBDir->MoveTo(storageDir, persistentStorageName);
   NS_ENSURE_SUCCESS(rv, rv);
   mStorageAreaInitialized = true;
   return NS_OK;
 }
 nsresult
 QuotaManager::EnsureOriginIsInitialized(PersistenceType aPersistenceType,
                                         const nsACString& aGroup,
                                         const nsACString& aOrigin,
                                         bool aTrackQuota,
                                         nsIFile** aDirectory)
 {
   AssertIsOnIOThread();
   nsresult rv = MaybeUpgradeIndexedDBDirectory();
   NS_ENSURE_SUCCESS(rv, rv);
   // Get directory for this origin and persistence type.
   nsCOMPtr<nsIFile> directory;
   rv = GetDirectoryForOrigin(aPersistenceType, aOrigin,
                              getter_AddRefs(directory));
   NS_ENSURE_SUCCESS(rv, rv);
   if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
     if (mInitializedOrigins.Contains(aOrigin)) {
       NS_ADDREF(*aDirectory = directory);
       return NS_OK;
     }
     bool created;
     rv = EnsureDirectory(directory, &created);
     NS_ENSURE_SUCCESS(rv, rv);
     if (created) {
       rv = CreateDirectoryUpgradeStamp(directory);
       NS_ENSURE_SUCCESS(rv, rv);
     }
     rv = InitializeOrigin(aPersistenceType, aGroup, aOrigin, aTrackQuota, 0,
                           directory);
     NS_ENSURE_SUCCESS(rv, rv);
     mInitializedOrigins.AppendElement(aOrigin);
     directory.forget(aDirectory);
     return NS_OK;
   }
   NS_ASSERTION(aPersistenceType == PERSISTENCE_TYPE_TEMPORARY, "Huh?");
   NS_ASSERTION(aTrackQuota, "Huh?");
   if (!mTemporaryStorageInitialized) {
     nsCOMPtr<nsIFile> parentDirectory;
     rv = directory->GetParent(getter_AddRefs(parentDirectory));
     NS_ENSURE_SUCCESS(rv, rv);
     bool created;
     rv = EnsureDirectory(parentDirectory, &created);
     NS_ENSURE_SUCCESS(rv, rv);
     nsCOMPtr<nsISimpleEnumerator> entries;
     rv = parentDirectory->GetDirectoryEntries(getter_AddRefs(entries));
     NS_ENSURE_SUCCESS(rv, rv);
     bool hasMore;
     while (NS_SUCCEEDED((rv = entries->HasMoreElements(&hasMore))) && hasMore) {
       nsCOMPtr<nsISupports> entry;
       rv = entries->GetNext(getter_AddRefs(entry));
       NS_ENSURE_SUCCESS(rv, rv);
       nsCOMPtr<nsIFile> childDirectory = do_QueryInterface(entry);
       NS_ENSURE_TRUE(childDirectory, NS_NOINTERFACE);
       bool isDirectory;
       rv = childDirectory->IsDirectory(&isDirectory);
       NS_ENSURE_SUCCESS(rv, rv);
       NS_ENSURE_TRUE(isDirectory, NS_ERROR_UNEXPECTED);
       int64_t timestamp;
       nsCString group;
       nsCString origin;
       rv = GetDirectoryMetadata(childDirectory, &timestamp, group, origin);
       NS_ENSURE_SUCCESS(rv, rv);
       rv = InitializeOrigin(aPersistenceType, group, origin, aTrackQuota,
                             timestamp, childDirectory);
       if (NS_FAILED(rv)) {
         NS_WARNING("Failed to initialize origin!");
         // We have to cleanup partially initialized quota for temporary storage.
         RemoveQuotaForPersistenceType(aPersistenceType);
         return rv;
       }
     }
     if (gFixedLimitKB >= 0) {
       mTemporaryStorageLimit = gFixedLimitKB * 1024;
     }
     else {
       rv = GetTemporaryStorageLimit(parentDirectory, mTemporaryStorageUsage,
                                     &mTemporaryStorageLimit);
       NS_ENSURE_SUCCESS(rv, rv);
     }
     mTemporaryStorageInitialized = true;
     CheckTemporaryStorageLimits();
   }
   bool created;
   rv = EnsureDirectory(directory, &created);
   NS_ENSURE_SUCCESS(rv, rv);
   if (created) {
     int64_t timestamp = PR_Now();
     rv = CreateDirectoryMetadata(directory, timestamp, aGroup, aOrigin);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = InitializeOrigin(aPersistenceType, aGroup, aOrigin, aTrackQuota,
                           timestamp, directory);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   directory.forget(aDirectory);
   return NS_OK;
 }
 void
 QuotaManager::OriginClearCompleted(
                                   PersistenceType aPersistenceType,
                                   const OriginOrPatternString& aOriginOrPattern)
 {
   AssertIsOnIOThread();
   if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
     if (aOriginOrPattern.IsOrigin()) {
       mInitializedOrigins.RemoveElement(aOriginOrPattern);
     }
     else {
       for (uint32_t index = mInitializedOrigins.Length(); index > 0; index--) {
         if (PatternMatchesOrigin(aOriginOrPattern,
                                  mInitializedOrigins[index - 1])) {
           mInitializedOrigins.RemoveElementAt(index - 1);
         }
       }
     }
   }
   for (uint32_t index = 0; index < Client::TYPE_MAX; index++) {
     mClients[index]->OnOriginClearCompleted(aPersistenceType, aOriginOrPattern);
   }
 }
 void
 QuotaManager::ResetOrClearCompleted()
 {
   AssertIsOnIOThread();
   mInitializedOrigins.Clear();
   mTemporaryStorageInitialized = false;
   ReleaseIOThreadObjects();
 }
 already_AddRefed<mozilla::dom::quota::Client>
 QuotaManager::GetClient(Client::Type aClientType)
 {
   nsRefPtr<Client> client = mClients.SafeElementAt(aClientType);
   return client.forget();
 }
 uint64_t
 QuotaManager::GetGroupLimit() const
 {
   MOZ_ASSERT(mTemporaryStorageInitialized);
   // To avoid one group evicting all the rest, limit the amount any one group
   // can use to 20%. To prevent individual sites from using exorbitant amounts
   // of storage where there is a lot of free space, cap the group limit to 2GB.
   uint64_t x = std::min<uint64_t>(mTemporaryStorageLimit * .20, 2 GB);
   // In low-storage situations, make an exception (while not exceeding the total
   // storage limit).
   return std::min<uint64_t>(mTemporaryStorageLimit,
                             std::max<uint64_t>(x, 10 MB));
 }
 // static
 uint32_t
 QuotaManager::GetStorageQuotaMB()
 {
   return uint32_t(std::max(gStorageQuotaMB, 0));
 }
 // static
 void
 QuotaManager::GetStorageId(PersistenceType aPersistenceType,
                            const nsACString& aOrigin,
                            Client::Type aClientType,
                            const nsAString& aName,
                            nsACString& aDatabaseId)
 {
   nsAutoCString str;
   str.AppendInt(aPersistenceType);
   str.Append('*');
   str.Append(aOrigin);
   str.Append('*');
   str.AppendInt(aClientType);
   str.Append('*');
   str.Append(NS_ConvertUTF16toUTF8(aName));
   aDatabaseId = str;
 }
 // static
 nsresult
 QuotaManager::GetInfoFromURI(nsIURI* aURI,
                              uint32_t aAppId,
                              bool aInMozBrowser,
                              nsACString* aGroup,
                              nsACString* aASCIIOrigin,
                              StoragePrivilege* aPrivilege,
                              PersistenceType* aDefaultPersistenceType)
 {
   NS_ASSERTION(aURI, "Null uri!");
   nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
   NS_ENSURE_TRUE(secMan, NS_ERROR_FAILURE);
   nsCOMPtr<nsIPrincipal> principal;
   nsresult rv = secMan->GetAppCodebasePrincipal(aURI, aAppId, aInMozBrowser,
                                                 getter_AddRefs(principal));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = GetInfoFromPrincipal(principal, aGroup, aASCIIOrigin, aPrivilege,
                             aDefaultPersistenceType);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 // static
 nsresult
 QuotaManager::GetInfoFromPrincipal(nsIPrincipal* aPrincipal,
                                    nsACString* aGroup,
                                    nsACString* aASCIIOrigin,
                                    StoragePrivilege* aPrivilege,
                                    PersistenceType* aDefaultPersistenceType)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aPrincipal, "Don't hand me a null principal!");
   if (nsContentUtils::IsSystemPrincipal(aPrincipal)) {
     GetInfoForChrome(aGroup, aASCIIOrigin, aPrivilege, aDefaultPersistenceType);
     return NS_OK;
   }
   bool isNullPrincipal;
   nsresult rv = aPrincipal->GetIsNullPrincipal(&isNullPrincipal);
   NS_ENSURE_SUCCESS(rv, rv);
   if (isNullPrincipal) {
     NS_WARNING("IndexedDB not supported from this principal!");
     return NS_ERROR_FAILURE;
   }
   nsCString origin;
   rv = aPrincipal->GetOrigin(getter_Copies(origin));
   NS_ENSURE_SUCCESS(rv, rv);
   if (origin.EqualsLiteral("chrome")) {
     NS_WARNING("Non-chrome principal can't use chrome origin!");
     return NS_ERROR_FAILURE;
   }
   nsCString jarPrefix;
   if (aGroup || aASCIIOrigin) {
     rv = aPrincipal->GetJarPrefix(jarPrefix);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   if (aGroup) {
     nsCString baseDomain;
     rv = aPrincipal->GetBaseDomain(baseDomain);
     if (NS_FAILED(rv)) {
       // A hack for JetPack.
       nsCOMPtr<nsIURI> uri;
       rv = aPrincipal->GetURI(getter_AddRefs(uri));
       NS_ENSURE_SUCCESS(rv, rv);
       bool isIndexedDBURI = false;
       rv = uri->SchemeIs("indexedDB", &isIndexedDBURI);
       NS_ENSURE_SUCCESS(rv, rv);
       if (isIndexedDBURI) {
         rv = NS_OK;
       }
     }
     NS_ENSURE_SUCCESS(rv, rv);
     if (baseDomain.IsEmpty()) {
       aGroup->Assign(jarPrefix + origin);
     }
     else {
       aGroup->Assign(jarPrefix + baseDomain);
     }
   }
   if (aASCIIOrigin) {
     aASCIIOrigin->Assign(jarPrefix + origin);
   }
   if (aPrivilege) {
     *aPrivilege = Content;
   }
   if (aDefaultPersistenceType) {
     *aDefaultPersistenceType = PERSISTENCE_TYPE_PERSISTENT;
   }
   return NS_OK;
 }
 // static
 nsresult
 QuotaManager::GetInfoFromWindow(nsPIDOMWindow* aWindow,
                                 nsACString* aGroup,
                                 nsACString* aASCIIOrigin,
                                 StoragePrivilege* aPrivilege,
                                 PersistenceType* aDefaultPersistenceType)
 {
   NS_ASSERTION(NS_IsMainThread(),
                "We're about to touch a window off the main thread!");
   NS_ASSERTION(aWindow, "Don't hand me a null window!");
   nsCOMPtr<nsIScriptObjectPrincipal> sop = do_QueryInterface(aWindow);
   NS_ENSURE_TRUE(sop, NS_ERROR_FAILURE);
   nsCOMPtr<nsIPrincipal> principal = sop->GetPrincipal();
   NS_ENSURE_TRUE(principal, NS_ERROR_FAILURE);
   nsresult rv = GetInfoFromPrincipal(principal, aGroup, aASCIIOrigin,
                                      aPrivilege, aDefaultPersistenceType);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 // static
 void
 QuotaManager::GetInfoForChrome(nsACString* aGroup,
                                nsACString* aASCIIOrigin,
                                StoragePrivilege* aPrivilege,
                                PersistenceType* aDefaultPersistenceType)
 {
   NS_ASSERTION(nsContentUtils::IsCallerChrome(), "Only for chrome!");
   static const char kChromeOrigin[] = "chrome";
   if (aGroup) {
     aGroup->AssignLiteral(kChromeOrigin);
   }
   if (aASCIIOrigin) {
     aASCIIOrigin->AssignLiteral(kChromeOrigin);
   }
   if (aPrivilege) {
     *aPrivilege = Chrome;
   }
   if (aDefaultPersistenceType) {
     *aDefaultPersistenceType = PERSISTENCE_TYPE_PERSISTENT;
   }
 }
 NS_IMPL_ISUPPORTS(QuotaManager, nsIQuotaManager, nsIObserver)
 NS_IMETHODIMP
 QuotaManager::GetUsageForURI(nsIURI* aURI,
                              nsIUsageCallback* aCallback,
                              uint32_t aAppId,
                              bool aInMozBrowserOnly,
                              uint8_t aOptionalArgCount,
                              nsIQuotaRequest** _retval)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ENSURE_ARG_POINTER(aURI);
   NS_ENSURE_ARG_POINTER(aCallback);
   // This only works from the main process.
   NS_ENSURE_TRUE(IsMainProcess(), NS_ERROR_NOT_AVAILABLE);
   if (!aOptionalArgCount) {
     aAppId = nsIScriptSecurityManager::NO_APP_ID;
   }
   // Figure out which origin we're dealing with.
   nsCString group;
   nsCString origin;
   nsresult rv = GetInfoFromURI(aURI, aAppId, aInMozBrowserOnly, &group, &origin,
                                nullptr, nullptr);
   NS_ENSURE_SUCCESS(rv, rv);
   OriginOrPatternString oops = OriginOrPatternString::FromOrigin(origin);
   nsRefPtr<AsyncUsageRunnable> runnable =
     new AsyncUsageRunnable(aAppId, aInMozBrowserOnly, group, oops, aURI,
                            aCallback);
   // Put the computation runnable in the queue.
   rv = WaitForOpenAllowed(oops, Nullable<PersistenceType>(), EmptyCString(),
                           runnable);
   NS_ENSURE_SUCCESS(rv, rv);
   runnable->AdvanceState();
   runnable.forget(_retval);
   return NS_OK;
 }
 NS_IMETHODIMP
 QuotaManager::Clear()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   if (!gTestingEnabled) {
     NS_WARNING("Testing features are not enabled!");
     return NS_OK;
   }
   OriginOrPatternString oops = OriginOrPatternString::FromNull();
   nsRefPtr<ResetOrClearRunnable> runnable = new ResetOrClearRunnable(true);
   // Put the clear runnable in the queue.
   nsresult rv =
     WaitForOpenAllowed(oops, Nullable<PersistenceType>(), EmptyCString(),
                        runnable);
   NS_ENSURE_SUCCESS(rv, rv);
   runnable->AdvanceState();
   // Give the runnable some help by invalidating any storages in the way.
   StorageMatcher<nsAutoTArray<nsIOfflineStorage*, 20> > matches;
   matches.Find(mLiveStorages);
   for (uint32_t index = 0; index < matches.Length(); index++) {
     // We need to grab references to any live storages here to prevent them
     // from dying while we invalidate them.
     nsCOMPtr<nsIOfflineStorage> storage = matches[index];
     storage->Invalidate();
   }
   // After everything has been invalidated the helper should be dispatched to
   // the end of the event queue.
   return NS_OK;
 }
 NS_IMETHODIMP
 QuotaManager::ClearStoragesForURI(nsIURI* aURI,
                                   uint32_t aAppId,
                                   bool aInMozBrowserOnly,
                                   const nsACString& aPersistenceType,
                                   uint8_t aOptionalArgCount)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ENSURE_ARG_POINTER(aURI);
   // This only works from the main process.
   NS_ENSURE_TRUE(IsMainProcess(), NS_ERROR_NOT_AVAILABLE);
   if (!aOptionalArgCount) {
     aAppId = nsIScriptSecurityManager::NO_APP_ID;
   }
   // Figure out which origin we're dealing with.
   nsCString origin;
   nsresult rv = GetInfoFromURI(aURI, aAppId, aInMozBrowserOnly, nullptr, &origin,
                                nullptr, nullptr);
   NS_ENSURE_SUCCESS(rv, rv);
   nsAutoCString pattern;
   GetOriginPatternString(aAppId, aInMozBrowserOnly, origin, pattern);
   Nullable<PersistenceType> persistenceType;
   rv = NullablePersistenceTypeFromText(aPersistenceType, &persistenceType);
   NS_ENSURE_SUCCESS(rv, rv);
   // If there is a pending or running clear operation for this origin, return
   // immediately.
   if (IsClearOriginPending(pattern, persistenceType)) {
     return NS_OK;
   }
   OriginOrPatternString oops = OriginOrPatternString::FromPattern(pattern);
   // Queue up the origin clear runnable.
   nsRefPtr<OriginClearRunnable> runnable =
     new OriginClearRunnable(oops, persistenceType);
   rv = WaitForOpenAllowed(oops, persistenceType, EmptyCString(), runnable);
   NS_ENSURE_SUCCESS(rv, rv);
   runnable->AdvanceState();
   // Give the runnable some help by invalidating any storages in the way.
   StorageMatcher<nsAutoTArray<nsIOfflineStorage*, 20> > matches;
   matches.Find(mLiveStorages, pattern);
   for (uint32_t index = 0; index < matches.Length(); index++) {
     if (persistenceType.IsNull() ||
         matches[index]->Type() == persistenceType.Value()) {
       // We need to grab references to any live storages here to prevent them
       // from dying while we invalidate them.
       nsCOMPtr<nsIOfflineStorage> storage = matches[index];
       storage->Invalidate();
     }
   }
   // After everything has been invalidated the helper should be dispatched to
   // the end of the event queue.
   return NS_OK;
 }
 NS_IMETHODIMP
 QuotaManager::Reset()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   if (!gTestingEnabled) {
     NS_WARNING("Testing features are not enabled!");
     return NS_OK;
   }
   OriginOrPatternString oops = OriginOrPatternString::FromNull();
   nsRefPtr<ResetOrClearRunnable> runnable = new ResetOrClearRunnable(false);
   // Put the reset runnable in the queue.
   nsresult rv =
     WaitForOpenAllowed(oops, Nullable<PersistenceType>(), EmptyCString(),
                        runnable);
   NS_ENSURE_SUCCESS(rv, rv);
   runnable->AdvanceState();
   // Give the runnable some help by invalidating any storages in the way.
   StorageMatcher<nsAutoTArray<nsIOfflineStorage*, 20> > matches;
   matches.Find(mLiveStorages);
   for (uint32_t index = 0; index < matches.Length(); index++) {
     // We need to grab references to any live storages here to prevent them
     // from dying while we invalidate them.
     nsCOMPtr<nsIOfflineStorage> storage = matches[index];
     storage->Invalidate();
   }
   // After everything has been invalidated the helper should be dispatched to
   // the end of the event queue.
   return NS_OK;
 }
 NS_IMETHODIMP
 QuotaManager::Observe(nsISupports* aSubject,
                       const char* aTopic,
                       const char16_t* aData)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   if (!strcmp(aTopic, PROFILE_BEFORE_CHANGE_OBSERVER_ID)) {
     // Setting this flag prevents the service from being recreated and prevents
     // further storagess from being created.
     if (gShutdown.exchange(true)) {
       NS_ERROR("Shutdown more than once?!");
     }
     if (IsMainProcess()) {
       FileService* service = FileService::Get();
       if (service) {
         // This should only wait for storages registered in this manager
         // to complete. Other storages may still have running locked files.
         // If the necko service (thread pool) gets the shutdown notification
         // first then the sync loop won't be processed at all, otherwise it will
         // lock the main thread until all storages registered in this manager
         // are finished.
         nsTArray<uint32_t> indexes;
         for (uint32_t index = 0; index < Client::TYPE_MAX; index++) {
           if (mClients[index]->IsFileServiceUtilized()) {
             indexes.AppendElement(index);
           }
         }
         StorageMatcher<nsTArray<nsCOMPtr<nsIFileStorage> > > liveStorages;
         liveStorages.Find(mLiveStorages, &indexes);
         if (!liveStorages.IsEmpty()) {
           nsRefPtr<WaitForLockedFilesToFinishRunnable> runnable =
             new WaitForLockedFilesToFinishRunnable();
           service->WaitForStoragesToComplete(liveStorages, runnable);
           nsIThread* thread = NS_GetCurrentThread();
           while (runnable->IsBusy()) {
             if (!NS_ProcessNextEvent(thread)) {
               NS_ERROR("Failed to process next event!");
               break;
             }
           }
         }
       }
       // Kick off the shutdown timer.
       if (NS_FAILED(mShutdownTimer->Init(this, DEFAULT_SHUTDOWN_TIMER_MS,
                                          nsITimer::TYPE_ONE_SHOT))) {
         NS_WARNING("Failed to initialize shutdown timer!");
       }
       // Each client will spin the event loop while we wait on all the threads
       // to close. Our timer may fire during that loop.
       for (uint32_t index = 0; index < Client::TYPE_MAX; index++) {
         mClients[index]->ShutdownTransactionService();
       }
       // Cancel the timer regardless of whether it actually fired.
       if (NS_FAILED(mShutdownTimer->Cancel())) {
         NS_WARNING("Failed to cancel shutdown timer!");
       }
       // Give clients a chance to cleanup IO thread only objects.
       nsCOMPtr<nsIRunnable> runnable =
         NS_NewRunnableMethod(this, &QuotaManager::ReleaseIOThreadObjects);
       if (!runnable) {
         NS_WARNING("Failed to create runnable!");
       }
       if (NS_FAILED(mIOThread->Dispatch(runnable, NS_DISPATCH_NORMAL))) {
         NS_WARNING("Failed to dispatch runnable!");
       }
       // Make sure to join with our IO thread.
       if (NS_FAILED(mIOThread->Shutdown())) {
         NS_WARNING("Failed to shutdown IO thread!");
       }
     }
     return NS_OK;
   }
   if (!strcmp(aTopic, NS_TIMER_CALLBACK_TOPIC)) {
     NS_ASSERTION(IsMainProcess(), "Should only happen in the main process!");
     NS_WARNING("Some storage operations are taking longer than expected "
                "during shutdown and will be aborted!");
     // Grab all live storages, for all origins.
     StorageMatcher<nsAutoTArray<nsIOfflineStorage*, 50> > liveStorages;
     liveStorages.Find(mLiveStorages);
     // Invalidate them all.
     if (!liveStorages.IsEmpty()) {
       uint32_t count = liveStorages.Length();
       for (uint32_t index = 0; index < count; index++) {
         liveStorages[index]->Invalidate();
       }
     }
     return NS_OK;
   }
   if (!strcmp(aTopic, TOPIC_WEB_APP_CLEAR_DATA)) {
     nsCOMPtr<mozIApplicationClearPrivateDataParams> params =
       do_QueryInterface(aSubject);
     NS_ENSURE_TRUE(params, NS_ERROR_UNEXPECTED);
     uint32_t appId;
     nsresult rv = params->GetAppId(&appId);
     NS_ENSURE_SUCCESS(rv, rv);
     bool browserOnly;
     rv = params->GetBrowserOnly(&browserOnly);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = ClearStoragesForApp(appId, browserOnly);
     NS_ENSURE_SUCCESS(rv, rv);
     return NS_OK;
   }
   NS_NOTREACHED("Unknown topic!");
   return NS_ERROR_UNEXPECTED;
 }
 void
 QuotaManager::SetCurrentWindowInternal(nsPIDOMWindow* aWindow)
 {
   NS_ASSERTION(mCurrentWindowIndex != BAD_TLS_INDEX,
                "Should have a valid TLS storage index!");
   if (aWindow) {
     NS_ASSERTION(!PR_GetThreadPrivate(mCurrentWindowIndex),
                  "Somebody forgot to clear the current window!");
     PR_SetThreadPrivate(mCurrentWindowIndex, aWindow);
   }
   else {
     // We cannot assert PR_GetThreadPrivate(mCurrentWindowIndex) here because
     // there are some cases where we did not already have a window.
     PR_SetThreadPrivate(mCurrentWindowIndex, nullptr);
   }
 }
 void
 QuotaManager::CancelPromptsForWindowInternal(nsPIDOMWindow* aWindow)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   nsRefPtr<CheckQuotaHelper> helper;
   MutexAutoLock autoLock(mQuotaMutex);
   if (mCheckQuotaHelpers.Get(aWindow, getter_AddRefs(helper))) {
     helper->Cancel();
   }
 }
 bool
 QuotaManager::LockedQuotaIsLifted()
 {
   mQuotaMutex.AssertCurrentThreadOwns();
   NS_ASSERTION(mCurrentWindowIndex != BAD_TLS_INDEX,
                "Should have a valid TLS storage index!");
   nsPIDOMWindow* window =
     static_cast<nsPIDOMWindow*>(PR_GetThreadPrivate(mCurrentWindowIndex));
   // Quota is not enforced in chrome contexts (e.g. for components and JSMs)
   // so we must have a window here.
   NS_ASSERTION(window, "Why don't we have a Window here?");
   bool createdHelper = false;
   nsRefPtr<CheckQuotaHelper> helper;
   if (!mCheckQuotaHelpers.Get(window, getter_AddRefs(helper))) {
     helper = new CheckQuotaHelper(window, mQuotaMutex);
     createdHelper = true;
     mCheckQuotaHelpers.Put(window, helper);
     // Unlock while calling out to XPCOM (code behind the dispatch method needs
     // to acquire its own lock which can potentially lead to a deadlock and it
     // also calls an observer that can do various stuff like IO, so it's better
     // to not hold our mutex while that happens).
     {
       MutexAutoUnlock autoUnlock(mQuotaMutex);
       nsresult rv = NS_DispatchToMainThread(helper);
       NS_ENSURE_SUCCESS(rv, false);
     }
     // Relocked.  If any other threads hit the quota limit on the same Window,
     // they are using the helper we created here and are now blocking in
     // PromptAndReturnQuotaDisabled.
   }
   bool result = helper->PromptAndReturnQuotaIsDisabled();
   // If this thread created the helper and added it to the hash, this thread
   // must remove it.
   if (createdHelper) {
     mCheckQuotaHelpers.Remove(window);
   }
   return result;
 }
 uint64_t
 QuotaManager::LockedCollectOriginsForEviction(
                                             uint64_t aMinSizeToBeFreed,
                                             nsTArray<OriginInfo*>& aOriginInfos)
 {
   mQuotaMutex.AssertCurrentThreadOwns();
   nsRefPtr<CollectOriginsHelper> helper =
     new CollectOriginsHelper(mQuotaMutex, aMinSizeToBeFreed);
   // Unlock while calling out to XPCOM (see the detailed comment in
   // LockedQuotaIsLifted)
   {
     MutexAutoUnlock autoUnlock(mQuotaMutex);
     if (NS_FAILED(NS_DispatchToMainThread(helper))) {
       NS_WARNING("Failed to dispatch to the main thread!");
     }
   }
   return helper->BlockAndReturnOriginsForEviction(aOriginInfos);
 }
 void
 QuotaManager::LockedRemoveQuotaForOrigin(PersistenceType aPersistenceType,
                                          const nsACString& aGroup,
                                          const nsACString& aOrigin)
 {
   mQuotaMutex.AssertCurrentThreadOwns();
   GroupInfoPair* pair;
   mGroupInfoPairs.Get(aGroup, &pair);
   if (!pair) {
     return;
   }
   nsRefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
   if (groupInfo) {
     groupInfo->LockedRemoveOriginInfo(aOrigin);
     if (!groupInfo->LockedHasOriginInfos()) {
       pair->LockedClearGroupInfo(aPersistenceType);
       if (!pair->LockedHasGroupInfos()) {
         mGroupInfoPairs.Remove(aGroup);
       }
     }
   }
 }
 nsresult
 QuotaManager::AcquireExclusiveAccess(const nsACString& aPattern,
                                      Nullable<PersistenceType> aPersistenceType,
                                      nsIOfflineStorage* aStorage,
                                      AcquireListener* aListener,
                                      WaitingOnStoragesCallback aCallback,
                                      void* aClosure)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aListener, "Need a listener!");
   // Find the right SynchronizedOp.
   SynchronizedOp* op =
     FindSynchronizedOp(aPattern, aPersistenceType,
                        aStorage ? aStorage->Id() : EmptyCString());
   NS_ASSERTION(op, "We didn't find a SynchronizedOp?");
   NS_ASSERTION(!op->mListener, "SynchronizedOp already has a listener?!?");
   nsTArray<nsCOMPtr<nsIOfflineStorage> > liveStorages;
   if (aStorage) {
     // We need to wait for the storages to go away.
     // Hold on to all storage objects that represent the same storage file
     // (except the one that is requesting this version change).
     Client::Type clientType = aStorage->GetClient()->GetType();
     StorageMatcher<nsAutoTArray<nsIOfflineStorage*, 20> > matches;
     matches.Find(mLiveStorages, aPattern, clientType);
     if (!matches.IsEmpty()) {
       // Grab all storages that are not yet closed but whose storage id match
       // the one we're looking for.
       for (uint32_t index = 0; index < matches.Length(); index++) {
         nsIOfflineStorage*& storage = matches[index];
         if (!storage->IsClosed() &&
             storage != aStorage &&
             storage->Id() == aStorage->Id()) {
           liveStorages.AppendElement(storage);
         }
       }
     }
     if (!liveStorages.IsEmpty()) {
       NS_ASSERTION(op->mStorages[clientType].IsEmpty(),
                    "How do we already have storages here?");
       op->mStorages[clientType].AppendElements(liveStorages);
     }
   }
   else {
     StorageMatcher<ArrayCluster<nsIOfflineStorage*> > matches;
     if (aPattern.IsVoid()) {
       matches.Find(mLiveStorages);
     }
     else {
       matches.Find(mLiveStorages, aPattern);
     }
     if (!matches.IsEmpty()) {
       // We want *all* storages, even those that are closed, when we're going to
       // clear the origin.
       matches.AppendElementsTo(liveStorages);
       NS_ASSERTION(op->mStorages.IsEmpty(),
                    "How do we already have storages here?");
       matches.SwapElements(op->mStorages);
     }
   }
   op->mListener = aListener;
   if (!liveStorages.IsEmpty()) {
     // Give our callback the storages so it can decide what to do with them.
     aCallback(liveStorages, aClosure);
     NS_ASSERTION(liveStorages.IsEmpty(),
                  "Should have done something with the array!");
     if (aStorage) {
       // Wait for those storages to close.
       return NS_OK;
     }
   }
   // If we're trying to open a storage and nothing blocks it, or if we're
   // clearing an origin, then go ahead and schedule the op.
   nsresult rv = RunSynchronizedOp(aStorage, op);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 QuotaManager::RunSynchronizedOp(nsIOfflineStorage* aStorage,
                                 SynchronizedOp* aOp)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aOp, "Null pointer!");
   NS_ASSERTION(aOp->mListener, "No listener on this op!");
   NS_ASSERTION(!aStorage ||
                aOp->mStorages[aStorage->GetClient()->GetType()].IsEmpty(),
                "This op isn't ready to run!");
   ArrayCluster<nsIOfflineStorage*> storages;
   uint32_t startIndex;
   uint32_t endIndex;
   if (aStorage) {
     Client::Type clientType = aStorage->GetClient()->GetType();
     storages[clientType].AppendElement(aStorage);
     startIndex = clientType;
     endIndex = clientType + 1;
   }
   else {
     aOp->mStorages.SwapElements(storages);
     startIndex = 0;
     endIndex = Client::TYPE_MAX;
   }
   nsRefPtr<WaitForTransactionsToFinishRunnable> runnable =
     new WaitForTransactionsToFinishRunnable(aOp);
   // Ask the file service to call us back when it's done with this storage.
   FileService* service = FileService::Get();
   if (service) {
     // Have to copy here in case a transaction service needs a list too.
     nsTArray<nsCOMPtr<nsIFileStorage> > array;
     for (uint32_t index = startIndex; index < endIndex; index++)  {
       if (!storages[index].IsEmpty() &&
           mClients[index]->IsFileServiceUtilized()) {
         array.AppendElements(storages[index]);
       }
     }
     if (!array.IsEmpty()) {
       runnable->AddRun();
       service->WaitForStoragesToComplete(array, runnable);
     }
   }
   // Ask each transaction service to call us back when they're done with this
   // storage.
   for (uint32_t index = startIndex; index < endIndex; index++)  {
     nsRefPtr<Client>& client = mClients[index];
     if (!storages[index].IsEmpty() && client->IsTransactionServiceActivated()) {
       runnable->AddRun();
       client->WaitForStoragesToComplete(storages[index], runnable);
     }
   }
   nsresult rv = runnable->Run();
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 SynchronizedOp*
 QuotaManager::FindSynchronizedOp(const nsACString& aPattern,
                                  Nullable<PersistenceType> aPersistenceType,
                                  const nsACString& aId)
 {
   for (uint32_t index = 0; index < mSynchronizedOps.Length(); index++) {
     const nsAutoPtr<SynchronizedOp>& currentOp = mSynchronizedOps[index];
     if (PatternMatchesOrigin(aPattern, currentOp->mOriginOrPattern) &&
         (currentOp->mPersistenceType.IsNull() ||
          currentOp->mPersistenceType == aPersistenceType) &&
         (currentOp->mId.IsEmpty() || currentOp->mId == aId)) {
       return currentOp;
     }
   }
   return nullptr;
 }
 nsresult
 QuotaManager::ClearStoragesForApp(uint32_t aAppId, bool aBrowserOnly)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aAppId != nsIScriptSecurityManager::UNKNOWN_APP_ID,
                "Bad appId!");
   // This only works from the main process.
   NS_ENSURE_TRUE(IsMainProcess(), NS_ERROR_NOT_AVAILABLE);
   nsAutoCString pattern;
   GetOriginPatternStringMaybeIgnoreBrowser(aAppId, aBrowserOnly, pattern);
   // Clear both temporary and persistent storages.
   Nullable<PersistenceType> persistenceType;
   // If there is a pending or running clear operation for this app, return
   // immediately.
   if (IsClearOriginPending(pattern, persistenceType)) {
     return NS_OK;
   }
   OriginOrPatternString oops = OriginOrPatternString::FromPattern(pattern);
   // Queue up the origin clear runnable.
   nsRefPtr<OriginClearRunnable> runnable =
     new OriginClearRunnable(oops, persistenceType);
   nsresult rv =
     WaitForOpenAllowed(oops, persistenceType, EmptyCString(), runnable);
   NS_ENSURE_SUCCESS(rv, rv);
   runnable->AdvanceState();
   // Give the runnable some help by invalidating any storages in the way.
   StorageMatcher<nsAutoTArray<nsIOfflineStorage*, 20> > matches;
   matches.Find(mLiveStorages, pattern);
   for (uint32_t index = 0; index < matches.Length(); index++) {
     // We need to grab references here to prevent the storage from dying while
     // we invalidate it.
     nsCOMPtr<nsIOfflineStorage> storage = matches[index];
     storage->Invalidate();
   }
   return NS_OK;
 }
 // static
 PLDHashOperator
 QuotaManager::GetOriginsExceedingGroupLimit(const nsACString& aKey,
                                             GroupInfoPair* aValue,
                                             void* aUserArg)
 {
   NS_ASSERTION(!aKey.IsEmpty(), "Empty key!");
   NS_ASSERTION(aValue, "Null pointer!");
   nsRefPtr<GroupInfo> groupInfo =
     aValue->LockedGetGroupInfo(PERSISTENCE_TYPE_TEMPORARY);
   if (groupInfo) {
     QuotaManager* quotaManager = QuotaManager::Get();
     NS_ASSERTION(quotaManager, "Shouldn't be null!");
     if (groupInfo->mUsage > quotaManager->GetGroupLimit()) {
       nsTArray<OriginInfo*>* doomedOriginInfos =
         static_cast<nsTArray<OriginInfo*>*>(aUserArg);
       nsTArray<nsRefPtr<OriginInfo> >& originInfos = groupInfo->mOriginInfos;
       originInfos.Sort(OriginInfoLRUComparator());
       uint64_t usage = groupInfo->mUsage;
       for (uint32_t i = 0; i < originInfos.Length(); i++) {
         OriginInfo* originInfo = originInfos[i];
         doomedOriginInfos->AppendElement(originInfo);
         usage -= originInfo->mUsage;
         if (usage <= quotaManager->GetGroupLimit()) {
           break;
         }
       }
     }
   }
   return PL_DHASH_NEXT;
 }
 // static
 PLDHashOperator
 QuotaManager::GetAllTemporaryStorageOrigins(const nsACString& aKey,
                                             GroupInfoPair* aValue,
                                             void* aUserArg)
 {
   NS_ASSERTION(!aKey.IsEmpty(), "Empty key!");
   NS_ASSERTION(aValue, "Null pointer!");
   nsRefPtr<GroupInfo> groupInfo =
     aValue->LockedGetGroupInfo(PERSISTENCE_TYPE_TEMPORARY);
   if (groupInfo) {
     nsTArray<OriginInfo*>* originInfos =
       static_cast<nsTArray<OriginInfo*>*>(aUserArg);
     originInfos->AppendElements(groupInfo->mOriginInfos);
   }
   return PL_DHASH_NEXT;
 }
 void
 QuotaManager::CheckTemporaryStorageLimits()
 {
   AssertIsOnIOThread();
   nsTArray<OriginInfo*> doomedOriginInfos;
   {
     MutexAutoLock lock(mQuotaMutex);
     mGroupInfoPairs.EnumerateRead(GetOriginsExceedingGroupLimit,
                                   &doomedOriginInfos);
     uint64_t usage = 0;
     for (uint32_t index = 0; index < doomedOriginInfos.Length(); index++) {
       usage += doomedOriginInfos[index]->mUsage;
     }
     if (mTemporaryStorageUsage - usage > mTemporaryStorageLimit) {
       nsTArray<OriginInfo*> originInfos;
       mGroupInfoPairs.EnumerateRead(GetAllTemporaryStorageOrigins,
                                     &originInfos);
       for (uint32_t index = originInfos.Length(); index > 0; index--) {
         if (doomedOriginInfos.Contains(originInfos[index - 1])) {
           originInfos.RemoveElementAt(index - 1);
         }
       }
       originInfos.Sort(OriginInfoLRUComparator());
       for (uint32_t i = 0; i < originInfos.Length(); i++) {
         if (mTemporaryStorageUsage - usage <= mTemporaryStorageLimit) {
           originInfos.TruncateLength(i);
           break;
         }
         usage += originInfos[i]->mUsage;
       }
       doomedOriginInfos.AppendElements(originInfos);
     }
   }
   for (uint32_t index = 0; index < doomedOriginInfos.Length(); index++) {
     DeleteTemporaryFilesForOrigin(doomedOriginInfos[index]->mOrigin);
   }
   nsTArray<nsCString> doomedOrigins;
   {
     MutexAutoLock lock(mQuotaMutex);
     for (uint32_t index = 0; index < doomedOriginInfos.Length(); index++) {
       OriginInfo* doomedOriginInfo = doomedOriginInfos[index];
       nsCString group = doomedOriginInfo->mGroupInfo->mGroup;
       nsCString origin = doomedOriginInfo->mOrigin;
       LockedRemoveQuotaForOrigin(PERSISTENCE_TYPE_TEMPORARY, group, origin);
 #ifdef DEBUG
       doomedOriginInfos[index] = nullptr;
 #endif
       doomedOrigins.AppendElement(origin);
     }
   }
   for (uint32_t index = 0; index < doomedOrigins.Length(); index++) {
     OriginClearCompleted(
                        PERSISTENCE_TYPE_TEMPORARY,
                        OriginOrPatternString::FromOrigin(doomedOrigins[index]));
   }
 }
 // static
 PLDHashOperator
 QuotaManager::AddTemporaryStorageOrigins(
                                        const nsACString& aKey,
                                        ArrayCluster<nsIOfflineStorage*>* aValue,
                                        void* aUserArg)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(!aKey.IsEmpty(), "Empty key!");
   NS_ASSERTION(aValue, "Null pointer!");
   NS_ASSERTION(aUserArg, "Null pointer!");
   OriginCollection& collection = *static_cast<OriginCollection*>(aUserArg);
   if (collection.ContainsOrigin(aKey)) {
     return PL_DHASH_NEXT;
   }
   for (uint32_t i = 0; i < Client::TYPE_MAX; i++) {
     nsTArray<nsIOfflineStorage*>& array = (*aValue)[i];
     for (uint32_t j = 0; j < array.Length(); j++) {
       nsIOfflineStorage*& storage = array[j];
       if (storage->Type() == PERSISTENCE_TYPE_TEMPORARY) {
         collection.AddOrigin(aKey);
         return PL_DHASH_NEXT;
       }
     }
   }
   return PL_DHASH_NEXT;
 }
 // static
 PLDHashOperator
 QuotaManager::GetInactiveTemporaryStorageOrigins(const nsACString& aKey,
                                                  GroupInfoPair* aValue,
                                                  void* aUserArg)
 {
   NS_ASSERTION(!aKey.IsEmpty(), "Empty key!");
   NS_ASSERTION(aValue, "Null pointer!");
   NS_ASSERTION(aUserArg, "Null pointer!");
   nsRefPtr<GroupInfo> groupInfo =
     aValue->LockedGetGroupInfo(PERSISTENCE_TYPE_TEMPORARY);
   if (groupInfo) {
     InactiveOriginsInfo* info = static_cast<InactiveOriginsInfo*>(aUserArg);
     nsTArray<nsRefPtr<OriginInfo> >& originInfos = groupInfo->mOriginInfos;
     for (uint32_t i = 0; i < originInfos.Length(); i++) {
       OriginInfo* originInfo = originInfos[i];
       if (!info->collection.ContainsOrigin(originInfo->mOrigin)) {
         NS_ASSERTION(!originInfo->mQuotaObjects.Count(),
                      "Inactive origin shouldn't have open files!");
         info->origins.AppendElement(originInfo);
       }
     }
   }
   return PL_DHASH_NEXT;
 }
 uint64_t
 QuotaManager::CollectOriginsForEviction(uint64_t aMinSizeToBeFreed,
                                         nsTArray<OriginInfo*>& aOriginInfos)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   // Collect active origins first.
   OriginCollection originCollection;
   // Add patterns and origins that have running or pending synchronized ops.
   // (add patterns first to reduce redundancy in the origin collection).
   uint32_t index;
   for (index = 0; index < mSynchronizedOps.Length(); index++) {
     nsAutoPtr<SynchronizedOp>& op = mSynchronizedOps[index];
     if (op->mPersistenceType.IsNull() ||
         op->mPersistenceType.Value() == PERSISTENCE_TYPE_TEMPORARY) {
       if (op->mOriginOrPattern.IsPattern() &&
           !originCollection.ContainsPattern(op->mOriginOrPattern)) {
         originCollection.AddPattern(op->mOriginOrPattern);
       }
     }
   }
   for (index = 0; index < mSynchronizedOps.Length(); index++) {
     nsAutoPtr<SynchronizedOp>& op = mSynchronizedOps[index];
     if (op->mPersistenceType.IsNull() ||
         op->mPersistenceType.Value() == PERSISTENCE_TYPE_TEMPORARY) {
       if (op->mOriginOrPattern.IsOrigin() &&
           !originCollection.ContainsOrigin(op->mOriginOrPattern)) {
         originCollection.AddOrigin(op->mOriginOrPattern);
       }
     }
   }
   // Add origins that have live temporary storages.
   mLiveStorages.EnumerateRead(AddTemporaryStorageOrigins, &originCollection);
   // Enumerate inactive origins. This must be protected by the mutex.
   nsTArray<OriginInfo*> inactiveOrigins;
   {
     InactiveOriginsInfo info(originCollection, inactiveOrigins);
     MutexAutoLock lock(mQuotaMutex);
     mGroupInfoPairs.EnumerateRead(GetInactiveTemporaryStorageOrigins, &info);
   }
   // We now have a list of all inactive origins. So it's safe to sort the list
   // and calculate available size without holding the lock.
   // Sort by the origin access time.
   inactiveOrigins.Sort(OriginInfoLRUComparator());
   // Create a list of inactive and the least recently used origins
   // whose aggregate size is greater or equals the minimal size to be freed.
   uint64_t sizeToBeFreed = 0;
   for(index = 0; index < inactiveOrigins.Length(); index++) {
     if (sizeToBeFreed >= aMinSizeToBeFreed) {
       inactiveOrigins.TruncateLength(index);
       break;
     }
     sizeToBeFreed += inactiveOrigins[index]->mUsage;
   }
   if (sizeToBeFreed >= aMinSizeToBeFreed) {
     // Success, add synchronized ops for these origins, so any other
     // operations for them will be delayed (until origin eviction is finalized).
     for(index = 0; index < inactiveOrigins.Length(); index++) {
       OriginOrPatternString oops =
         OriginOrPatternString::FromOrigin(inactiveOrigins[index]->mOrigin);
       AddSynchronizedOp(oops,
                         Nullable<PersistenceType>(PERSISTENCE_TYPE_TEMPORARY));
     }
     inactiveOrigins.SwapElements(aOriginInfos);
     return sizeToBeFreed;
   }
   return 0;
 }
 void
 QuotaManager::DeleteTemporaryFilesForOrigin(const nsACString& aOrigin)
 {
   nsCOMPtr<nsIFile> directory;
   nsresult rv = GetDirectoryForOrigin(PERSISTENCE_TYPE_TEMPORARY, aOrigin,
                                       getter_AddRefs(directory));
   NS_ENSURE_SUCCESS_VOID(rv);
   rv = directory->Remove(true);
   if (rv != NS_ERROR_FILE_TARGET_DOES_NOT_EXIST &&
       rv != NS_ERROR_FILE_NOT_FOUND && NS_FAILED(rv)) {
     // This should never fail if we've closed all storage connections
     // correctly...
     NS_ERROR("Failed to remove directory!");
   }
 }
 void
 QuotaManager::FinalizeOriginEviction(nsTArray<nsCString>& aOrigins)
 {
   NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
   nsRefPtr<FinalizeOriginEvictionRunnable> runnable =
     new FinalizeOriginEvictionRunnable(aOrigins);
   nsresult rv = IsOnIOThread() ? runnable->RunImmediately()
                                : runnable->Dispatch();
   NS_ENSURE_SUCCESS_VOID(rv);
 }
 void
 QuotaManager::SaveOriginAccessTime(const nsACString& aOrigin,
                                    int64_t aTimestamp)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   if (QuotaManager::IsShuttingDown()) {
     return;
   }
   nsRefPtr<SaveOriginAccessTimeRunnable> runnable =
     new SaveOriginAccessTimeRunnable(aOrigin, aTimestamp);
   if (NS_FAILED(mIOThread->Dispatch(runnable, NS_DISPATCH_NORMAL))) {
     NS_WARNING("Failed to dispatch runnable!");
   }
 }
 void
 QuotaManager::GetOriginPatternString(uint32_t aAppId,
                                      MozBrowserPatternFlag aBrowserFlag,
                                      const nsACString& aOrigin,
                                      nsAutoCString& _retval)
 {
   NS_ASSERTION(aAppId != nsIScriptSecurityManager::UNKNOWN_APP_ID,
                "Bad appId!");
   NS_ASSERTION(aOrigin.IsEmpty() || aBrowserFlag != IgnoreMozBrowser,
                "Bad args!");
   if (aOrigin.IsEmpty()) {
     _retval.Truncate();
     _retval.AppendInt(aAppId);
     _retval.Append('+');
     if (aBrowserFlag != IgnoreMozBrowser) {
       if (aBrowserFlag == MozBrowser) {
         _retval.Append('t');
       }
       else {
         _retval.Append('f');
       }
       _retval.Append('+');
     }
     return;
   }
 #ifdef DEBUG
   if (aAppId != nsIScriptSecurityManager::NO_APP_ID ||
       aBrowserFlag == MozBrowser) {
     nsAutoCString pattern;
     GetOriginPatternString(aAppId, aBrowserFlag, EmptyCString(), pattern);
     NS_ASSERTION(PatternMatchesOrigin(pattern, aOrigin),
                  "Origin doesn't match parameters!");
   }
 #endif
   _retval = aOrigin;
 }
 SynchronizedOp::SynchronizedOp(const OriginOrPatternString& aOriginOrPattern,
                                Nullable<PersistenceType> aPersistenceType,
                                const nsACString& aId)
 : mOriginOrPattern(aOriginOrPattern), mPersistenceType(aPersistenceType),
   mId(aId)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   MOZ_COUNT_CTOR(SynchronizedOp);
 }
 SynchronizedOp::~SynchronizedOp()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   MOZ_COUNT_DTOR(SynchronizedOp);
 }
 bool
 SynchronizedOp::MustWaitFor(const SynchronizedOp& aExistingOp)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   if (aExistingOp.mOriginOrPattern.IsNull() || mOriginOrPattern.IsNull()) {
     return true;
   }
   bool match;
   if (aExistingOp.mOriginOrPattern.IsOrigin()) {
     if (mOriginOrPattern.IsOrigin()) {
       match = aExistingOp.mOriginOrPattern.Equals(mOriginOrPattern);
     }
     else {
       match = PatternMatchesOrigin(mOriginOrPattern, aExistingOp.mOriginOrPattern);
     }
   }
   else if (mOriginOrPattern.IsOrigin()) {
     match = PatternMatchesOrigin(aExistingOp.mOriginOrPattern, mOriginOrPattern);
   }
   else {
     match = PatternMatchesOrigin(mOriginOrPattern, aExistingOp.mOriginOrPattern) ||
             PatternMatchesOrigin(aExistingOp.mOriginOrPattern, mOriginOrPattern);
   }
   // If the origins don't match, the second can proceed.
   if (!match) {
     return false;
   }
   // If the origins match but the persistence types are different, the second
   // can proceed.
   if (!aExistingOp.mPersistenceType.IsNull() && !mPersistenceType.IsNull() &&
       aExistingOp.mPersistenceType.Value() != mPersistenceType.Value()) {
     return false;
   }
   // If the origins and the ids match, the second must wait.
   if (aExistingOp.mId == mId) {
     return true;
   }
   // Waiting is required if either one corresponds to an origin clearing
   // (an empty Id).
   if (aExistingOp.mId.IsEmpty() || mId.IsEmpty()) {
     return true;
   }
   // Otherwise, things for the same origin but different storages can proceed
   // independently.
   return false;
 }
 void
 SynchronizedOp::DelayRunnable(nsIRunnable* aRunnable)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(mDelayedRunnables.IsEmpty() || mId.IsEmpty(),
                "Only ClearOrigin operations can delay multiple runnables!");
   mDelayedRunnables.AppendElement(aRunnable);
 }
 void
 SynchronizedOp::DispatchDelayedRunnables()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(!mListener, "Any listener should be gone by now!");
   uint32_t count = mDelayedRunnables.Length();
   for (uint32_t index = 0; index < count; index++) {
     NS_DispatchToCurrentThread(mDelayedRunnables[index]);
   }
   mDelayedRunnables.Clear();
 }
 CollectOriginsHelper::CollectOriginsHelper(mozilla::Mutex& aMutex,
                                            uint64_t aMinSizeToBeFreed)
 : mMinSizeToBeFreed(aMinSizeToBeFreed),
   mMutex(aMutex),
   mCondVar(aMutex, "CollectOriginsHelper::mCondVar"),
   mSizeToBeFreed(0),
   mWaiting(true)
 {
   MOZ_ASSERT(!NS_IsMainThread(), "Wrong thread!");
   mMutex.AssertCurrentThreadOwns();
 }
 int64_t
 CollectOriginsHelper::BlockAndReturnOriginsForEviction(
                                             nsTArray<OriginInfo*>& aOriginInfos)
 {
   MOZ_ASSERT(!NS_IsMainThread(), "Wrong thread!");
   mMutex.AssertCurrentThreadOwns();
   while (mWaiting) {
     mCondVar.Wait();
   }
   mOriginInfos.SwapElements(aOriginInfos);
   return mSizeToBeFreed;
 }
 NS_IMETHODIMP
 CollectOriginsHelper::Run()
 {
   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
   QuotaManager* quotaManager = QuotaManager::Get();
   NS_ASSERTION(quotaManager, "Shouldn't be null!");
   // We use extra stack vars here to avoid race detector warnings (the same
   // memory accessed with and without the lock held).
   nsTArray<OriginInfo*> originInfos;
   uint64_t sizeToBeFreed =
     quotaManager->CollectOriginsForEviction(mMinSizeToBeFreed, originInfos);
   MutexAutoLock lock(mMutex);
   NS_ASSERTION(mWaiting, "Huh?!");
   mOriginInfos.SwapElements(originInfos);
   mSizeToBeFreed = sizeToBeFreed;
   mWaiting = false;
   mCondVar.Notify();
   return NS_OK;
 }
 nsresult
 OriginClearRunnable::OnExclusiveAccessAcquired()
 {
   QuotaManager* quotaManager = QuotaManager::Get();
   NS_ASSERTION(quotaManager, "This should never fail!");
   nsresult rv = quotaManager->IOThread()->Dispatch(this, NS_DISPATCH_NORMAL);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 // static
 void
 OriginClearRunnable::InvalidateOpenedStorages(
                               nsTArray<nsCOMPtr<nsIOfflineStorage> >& aStorages,
                               void* aClosure)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   nsTArray<nsCOMPtr<nsIOfflineStorage> > storages;
   storages.SwapElements(aStorages);
   for (uint32_t index = 0; index < storages.Length(); index++) {
     storages[index]->Invalidate();
   }
 }
 void
 OriginClearRunnable::DeleteFiles(QuotaManager* aQuotaManager,
                                  PersistenceType aPersistenceType)
 {
   AssertIsOnIOThread();
   NS_ASSERTION(aQuotaManager, "Don't pass me null!");
   nsresult rv;
   nsCOMPtr<nsIFile> directory =
     do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS_VOID(rv);
   rv = directory->InitWithPath(aQuotaManager->GetStoragePath(aPersistenceType));
   NS_ENSURE_SUCCESS_VOID(rv);
   nsCOMPtr<nsISimpleEnumerator> entries;
   if (NS_FAILED(directory->GetDirectoryEntries(getter_AddRefs(entries))) ||
       !entries) {
     return;
   }
   nsCString originSanitized(mOriginOrPattern);
   SanitizeOriginString(originSanitized);
   bool hasMore;
   while (NS_SUCCEEDED((rv = entries->HasMoreElements(&hasMore))) && hasMore) {
     nsCOMPtr<nsISupports> entry;
     rv = entries->GetNext(getter_AddRefs(entry));
     NS_ENSURE_SUCCESS_VOID(rv);
     nsCOMPtr<nsIFile> file = do_QueryInterface(entry);
     NS_ASSERTION(file, "Don't know what this is!");
     bool isDirectory;
     rv = file->IsDirectory(&isDirectory);
     NS_ENSURE_SUCCESS_VOID(rv);
     if (!isDirectory) {
       NS_WARNING("Something in the IndexedDB directory that doesn't belong!");
       continue;
     }
     nsString leafName;
     rv = file->GetLeafName(leafName);
     NS_ENSURE_SUCCESS_VOID(rv);
     // Skip storages for other apps.
     if (!PatternMatchesOrigin(originSanitized,
                               NS_ConvertUTF16toUTF8(leafName))) {
       continue;
     }
     if (NS_FAILED(file->Remove(true))) {
       // This should never fail if we've closed all storage connections
       // correctly...
       NS_ERROR("Failed to remove directory!");
     }
   }
   aQuotaManager->RemoveQuotaForPattern(aPersistenceType, mOriginOrPattern);
   aQuotaManager->OriginClearCompleted(aPersistenceType, mOriginOrPattern);
 }
 NS_IMPL_ISUPPORTS_INHERITED0(OriginClearRunnable, nsRunnable)
 NS_IMETHODIMP
 OriginClearRunnable::Run()
 {
   PROFILER_LABEL("Quota", "OriginClearRunnable::Run");
   QuotaManager* quotaManager = QuotaManager::Get();
   NS_ASSERTION(quotaManager, "This should never fail!");
   switch (mCallbackState) {
     case Pending: {
       NS_NOTREACHED("Should never get here without being dispatched!");
       return NS_ERROR_UNEXPECTED;
     }
     case OpenAllowed: {
       NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
       AdvanceState();
       // Now we have to wait until the thread pool is done with all of the
       // storages we care about.
       nsresult rv =
         quotaManager->AcquireExclusiveAccess(mOriginOrPattern, mPersistenceType,
                                              this, InvalidateOpenedStorages,
                                              nullptr);
       NS_ENSURE_SUCCESS(rv, rv);
       return NS_OK;
     }
     case IO: {
       AssertIsOnIOThread();
       AdvanceState();
       if (mPersistenceType.IsNull()) {
         DeleteFiles(quotaManager, PERSISTENCE_TYPE_PERSISTENT);
         DeleteFiles(quotaManager, PERSISTENCE_TYPE_TEMPORARY);
       } else {
         DeleteFiles(quotaManager, mPersistenceType.Value());
       }
       // Now dispatch back to the main thread.
       if (NS_FAILED(NS_DispatchToMainThread(this, NS_DISPATCH_NORMAL))) {
         NS_WARNING("Failed to dispatch to main thread!");
         return NS_ERROR_FAILURE;
       }
       return NS_OK;
     }
     case Complete: {
       NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
       // Tell the QuotaManager that we're done.
       quotaManager->AllowNextSynchronizedOp(mOriginOrPattern, mPersistenceType,
                                             EmptyCString());
       return NS_OK;
     }
     default:
       NS_ERROR("Unknown state value!");
       return NS_ERROR_UNEXPECTED;
   }
   NS_NOTREACHED("Should never get here!");
   return NS_ERROR_UNEXPECTED;
 }
 AsyncUsageRunnable::AsyncUsageRunnable(uint32_t aAppId,
                                        bool aInMozBrowserOnly,
                                        const nsACString& aGroup,
                                        const OriginOrPatternString& aOrigin,
                                        nsIURI* aURI,
                                        nsIUsageCallback* aCallback)
 : mURI(aURI),
   mCallback(aCallback),
   mAppId(aAppId),
   mGroup(aGroup),
   mOrigin(aOrigin),
   mCallbackState(Pending),
   mInMozBrowserOnly(aInMozBrowserOnly)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(aURI, "Null pointer!");
   NS_ASSERTION(!aGroup.IsEmpty(), "Empty group!");
   NS_ASSERTION(aOrigin.IsOrigin(), "Expect origin only here!");
   NS_ASSERTION(!aOrigin.IsEmpty(), "Empty origin!");
   NS_ASSERTION(aCallback, "Null pointer!");
 }
 nsresult
 AsyncUsageRunnable::TakeShortcut()
 {
   NS_ASSERTION(mCallbackState == Pending, "Huh?");
   nsresult rv = NS_DispatchToCurrentThread(this);
   NS_ENSURE_SUCCESS(rv, rv);
   mCallbackState = Shortcut;
   return NS_OK;
 }
 nsresult
 AsyncUsageRunnable::RunInternal()
 {
   QuotaManager* quotaManager = QuotaManager::Get();
   NS_ASSERTION(quotaManager, "This should never fail!");
   nsresult rv;
   switch (mCallbackState) {
     case Pending: {
       NS_NOTREACHED("Should never get here without being dispatched!");
       return NS_ERROR_UNEXPECTED;
     }
     case OpenAllowed: {
       NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
       AdvanceState();
       rv = quotaManager->IOThread()->Dispatch(this, NS_DISPATCH_NORMAL);
       if (NS_FAILED(rv)) {
         NS_WARNING("Failed to dispatch to the IO thread!");
       }
       return NS_OK;
     }
     case IO: {
       AssertIsOnIOThread();
       AdvanceState();
       // Add all the persistent storage files we care about.
       rv = AddToUsage(quotaManager, PERSISTENCE_TYPE_PERSISTENT);
       NS_ENSURE_SUCCESS(rv, rv);
       // Add all the temporary storage files we care about.
       rv = AddToUsage(quotaManager, PERSISTENCE_TYPE_TEMPORARY);
       NS_ENSURE_SUCCESS(rv, rv);
       // Run dispatches us back to the main thread.
       return NS_OK;
     }
     case Complete: // Fall through
     case Shortcut: {
       NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
       // Call the callback unless we were canceled.
       if (!mCanceled) {
         mCallback->OnUsageResult(mURI, TotalUsage(), FileUsage(), mAppId,
                                  mInMozBrowserOnly);
       }
       // Clean up.
       mURI = nullptr;
       mCallback = nullptr;
       // And tell the QuotaManager that we're done.
       if (mCallbackState == Complete) {
         quotaManager->AllowNextSynchronizedOp(mOrigin,
                                               Nullable<PersistenceType>(),
                                               EmptyCString());
       }
       return NS_OK;
     }
     default:
       NS_ERROR("Unknown state value!");
       return NS_ERROR_UNEXPECTED;
   }
   NS_NOTREACHED("Should never get here!");
   return NS_ERROR_UNEXPECTED;
 }
 nsresult
 AsyncUsageRunnable::AddToUsage(QuotaManager* aQuotaManager,
                                PersistenceType aPersistenceType)
 {
   AssertIsOnIOThread();
   nsCOMPtr<nsIFile> directory;
   nsresult rv = aQuotaManager->GetDirectoryForOrigin(aPersistenceType, mOrigin,
                                                      getter_AddRefs(directory));
   NS_ENSURE_SUCCESS(rv, rv);
   bool exists;
   rv = directory->Exists(&exists);
   NS_ENSURE_SUCCESS(rv, rv);
   // If the directory exists then enumerate all the files inside, adding up
   // the sizes to get the final usage statistic.
   if (exists && !mCanceled) {
     bool initialized;
     if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
       initialized = aQuotaManager->mInitializedOrigins.Contains(mOrigin);
       if (!initialized) {
         rv = MaybeUpgradeOriginDirectory(directory);
         NS_ENSURE_SUCCESS(rv, rv);
       }
     }
     else {
       NS_ASSERTION(aPersistenceType == PERSISTENCE_TYPE_TEMPORARY, "Huh?");
       initialized = aQuotaManager->mTemporaryStorageInitialized;
     }
     nsCOMPtr<nsISimpleEnumerator> entries;
     rv = directory->GetDirectoryEntries(getter_AddRefs(entries));
     NS_ENSURE_SUCCESS(rv, rv);
     bool hasMore;
     while (NS_SUCCEEDED((rv = entries->HasMoreElements(&hasMore))) &&
            hasMore && !mCanceled) {
       nsCOMPtr<nsISupports> entry;
       rv = entries->GetNext(getter_AddRefs(entry));
       NS_ENSURE_SUCCESS(rv, rv);
       nsCOMPtr<nsIFile> file = do_QueryInterface(entry);
       NS_ENSURE_TRUE(file, NS_NOINTERFACE);
       nsString leafName;
       rv = file->GetLeafName(leafName);
       NS_ENSURE_SUCCESS(rv, rv);
       if (leafName.EqualsLiteral(METADATA_FILE_NAME) ||
           leafName.EqualsLiteral(DSSTORE_FILE_NAME)) {
         continue;
       }
       if (!initialized) {
         bool isDirectory;
         rv = file->IsDirectory(&isDirectory);
         NS_ENSURE_SUCCESS(rv, rv);
         if (!isDirectory) {
           NS_WARNING("Unknown file found!");
           return NS_ERROR_UNEXPECTED;
         }
       }
       Client::Type clientType;
       rv = Client::TypeFromText(leafName, clientType);
       if (NS_FAILED(rv)) {
         NS_WARNING("Unknown directory found!");
         if (!initialized) {
           return NS_ERROR_UNEXPECTED;
         }
         continue;
       }
       nsRefPtr<Client>& client = aQuotaManager->mClients[clientType];
       if (initialized) {
         rv = client->GetUsageForOrigin(aPersistenceType, mGroup, mOrigin, this);
       }
       else {
         rv = client->InitOrigin(aPersistenceType, mGroup, mOrigin, this);
       }
       NS_ENSURE_SUCCESS(rv, rv);
     }
   }
   return NS_OK;
 }
 NS_IMPL_ISUPPORTS_INHERITED(AsyncUsageRunnable, nsRunnable, nsIQuotaRequest)
 NS_IMETHODIMP
 AsyncUsageRunnable::Run()
 {
   PROFILER_LABEL("Quota", "AsyncUsageRunnable::Run");
   nsresult rv = RunInternal();
   if (!NS_IsMainThread()) {
     if (NS_FAILED(rv)) {
       ResetUsage();
     }
     if (NS_FAILED(NS_DispatchToMainThread(this, NS_DISPATCH_NORMAL))) {
       NS_WARNING("Failed to dispatch to main thread!");
     }
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 AsyncUsageRunnable::Cancel()
 {
   if (mCanceled.exchange(true)) {
     NS_WARNING("Canceled more than once?!");
     return NS_ERROR_UNEXPECTED;
   }
   return NS_OK;
 }
 nsresult
 ResetOrClearRunnable::OnExclusiveAccessAcquired()
 {
   QuotaManager* quotaManager = QuotaManager::Get();
   NS_ASSERTION(quotaManager, "This should never fail!");
   nsresult rv = quotaManager->IOThread()->Dispatch(this, NS_DISPATCH_NORMAL);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 // static
 void
 ResetOrClearRunnable::InvalidateOpenedStorages(
                               nsTArray<nsCOMPtr<nsIOfflineStorage> >& aStorages,
                               void* aClosure)
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   nsTArray<nsCOMPtr<nsIOfflineStorage> > storages;
   storages.SwapElements(aStorages);
   for (uint32_t index = 0; index < storages.Length(); index++) {
     storages[index]->Invalidate();
   }
 }
 void
 ResetOrClearRunnable::DeleteFiles(QuotaManager* aQuotaManager,
                                   PersistenceType aPersistenceType)
 {
   AssertIsOnIOThread();
   NS_ASSERTION(aQuotaManager, "Don't pass me null!");
   nsresult rv;
   nsCOMPtr<nsIFile> directory =
     do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS_VOID(rv);
   rv = directory->InitWithPath(aQuotaManager->GetStoragePath(aPersistenceType));
   NS_ENSURE_SUCCESS_VOID(rv);
   rv = directory->Remove(true);
   if (rv != NS_ERROR_FILE_TARGET_DOES_NOT_EXIST &&
       rv != NS_ERROR_FILE_NOT_FOUND && NS_FAILED(rv)) {
     // This should never fail if we've closed all storage connections
     // correctly...
     NS_ERROR("Failed to remove directory!");
   }
 }
 NS_IMPL_ISUPPORTS_INHERITED0(ResetOrClearRunnable, nsRunnable)
 NS_IMETHODIMP
 ResetOrClearRunnable::Run()
 {
   QuotaManager* quotaManager = QuotaManager::Get();
   NS_ASSERTION(quotaManager, "This should never fail!");
   switch (mCallbackState) {
     case Pending: {
       NS_NOTREACHED("Should never get here without being dispatched!");
       return NS_ERROR_UNEXPECTED;
     }
     case OpenAllowed: {
       NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
       AdvanceState();
       // Now we have to wait until the thread pool is done with all of the
       // storages we care about.
       nsresult rv =
         quotaManager->AcquireExclusiveAccess(NullCString(),
                                              Nullable<PersistenceType>(), this,
                                              InvalidateOpenedStorages, nullptr);
       NS_ENSURE_SUCCESS(rv, rv);
       return NS_OK;
     }
     case IO: {
       AssertIsOnIOThread();
       AdvanceState();
       if (mClear) {
         DeleteFiles(quotaManager, PERSISTENCE_TYPE_PERSISTENT);
         DeleteFiles(quotaManager, PERSISTENCE_TYPE_TEMPORARY);
       }
       quotaManager->RemoveQuota();
       quotaManager->ResetOrClearCompleted();
       // Now dispatch back to the main thread.
       if (NS_FAILED(NS_DispatchToMainThread(this, NS_DISPATCH_NORMAL))) {
         NS_WARNING("Failed to dispatch to main thread!");
         return NS_ERROR_FAILURE;
       }
       return NS_OK;
     }
     case Complete: {
       NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
       // Tell the QuotaManager that we're done.
       quotaManager->AllowNextSynchronizedOp(OriginOrPatternString::FromNull(),
                                             Nullable<PersistenceType>(),
                                             EmptyCString());
       return NS_OK;
     }
     default:
       NS_ERROR("Unknown state value!");
       return NS_ERROR_UNEXPECTED;
   }
   NS_NOTREACHED("Should never get here!");
   return NS_ERROR_UNEXPECTED;
 }
 NS_IMETHODIMP
 FinalizeOriginEvictionRunnable::Run()
 {
   QuotaManager* quotaManager = QuotaManager::Get();
   NS_ASSERTION(quotaManager, "This should never fail!");
   nsresult rv;
   switch (mCallbackState) {
     case Pending: {
       NS_NOTREACHED("Should never get here without being dispatched!");
       return NS_ERROR_UNEXPECTED;
     }
     case OpenAllowed: {
       NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
       AdvanceState();
       rv = quotaManager->IOThread()->Dispatch(this, NS_DISPATCH_NORMAL);
       if (NS_FAILED(rv)) {
         NS_WARNING("Failed to dispatch to the IO thread!");
       }
       return NS_OK;
     }
     case IO: {
       AssertIsOnIOThread();
       AdvanceState();
       for (uint32_t index = 0; index < mOrigins.Length(); index++) {
         quotaManager->OriginClearCompleted(
                             PERSISTENCE_TYPE_TEMPORARY,
                             OriginOrPatternString::FromOrigin(mOrigins[index]));
       }
       if (NS_FAILED(NS_DispatchToMainThread(this, NS_DISPATCH_NORMAL))) {
         NS_WARNING("Failed to dispatch to main thread!");
         return NS_ERROR_FAILURE;
       }
       return NS_OK;
     }
     case Complete: {
       NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
       for (uint32_t index = 0; index < mOrigins.Length(); index++) {
         quotaManager->AllowNextSynchronizedOp(
                           OriginOrPatternString::FromOrigin(mOrigins[index]),
                           Nullable<PersistenceType>(PERSISTENCE_TYPE_TEMPORARY),
                           EmptyCString());
       }
       return NS_OK;
     }
     default:
       NS_ERROR("Unknown state value!");
       return NS_ERROR_UNEXPECTED;
   }
   NS_NOTREACHED("Should never get here!");
   return NS_ERROR_UNEXPECTED;
 }
 nsresult
 FinalizeOriginEvictionRunnable::Dispatch()
 {
   NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(mCallbackState == Pending, "Huh?");
   mCallbackState = OpenAllowed;
   return NS_DispatchToMainThread(this);
 }
 nsresult
 FinalizeOriginEvictionRunnable::RunImmediately()
 {
   AssertIsOnIOThread();
   NS_ASSERTION(mCallbackState == Pending, "Huh?");
   mCallbackState = IO;
   return this->Run();
 }
 NS_IMETHODIMP
 WaitForTransactionsToFinishRunnable::Run()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(mOp, "Null op!");
   NS_ASSERTION(mOp->mListener, "Nothing to run!");
   NS_ASSERTION(mCountdown, "Wrong countdown!");
   if (--mCountdown) {
     return NS_OK;
   }
   // Don't hold the listener alive longer than necessary.
   nsRefPtr<AcquireListener> listener;
   listener.swap(mOp->mListener);
   mOp = nullptr;
   nsresult rv = listener->OnExclusiveAccessAcquired();
   NS_ENSURE_SUCCESS(rv, rv);
   // The listener is responsible for calling
   // QuotaManager::AllowNextSynchronizedOp.
   return NS_OK;
 }
 NS_IMETHODIMP
 WaitForLockedFilesToFinishRunnable::Run()
 {
   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
   mBusy = false;
   return NS_OK;
 }
 NS_IMETHODIMP
 SaveOriginAccessTimeRunnable::Run()
 {
   AssertIsOnIOThread();
   QuotaManager* quotaManager = QuotaManager::Get();
   NS_ASSERTION(quotaManager, "This should never fail!");
   nsCOMPtr<nsIFile> directory;
   nsresult rv =
     quotaManager->GetDirectoryForOrigin(PERSISTENCE_TYPE_TEMPORARY, mOrigin,
                                         getter_AddRefs(directory));
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsIBinaryOutputStream> stream;
   rv = GetDirectoryMetadataStream(directory, true, getter_AddRefs(stream));
   NS_ENSURE_SUCCESS(rv, rv);
   // The origin directory may not exist anymore.
   if (stream) {
     rv = stream->Write64(mTimestamp);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   return NS_OK;
 }

The Tor Browser / annotate

dom/quota/QuotaManager.cpp@129ffea94266 (annotated)

dom/quota/QuotaManager.cpp