FileSystemDataManager.h (6137B)
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */ 3 /* This Source Code Form is subject to the terms of the Mozilla Public 4 * License, v. 2.0. If a copy of the MPL was not distributed with this 5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 6 7 #ifndef DOM_FS_PARENT_DATAMODEL_FILESYSTEMDATAMANAGER_H_ 8 #define DOM_FS_PARENT_DATAMODEL_FILESYSTEMDATAMANAGER_H_ 9 10 #include "FileSystemParentTypes.h" 11 #include "ResultConnection.h" 12 #include "mozilla/NotNull.h" 13 #include "mozilla/TaskQueue.h" 14 #include "mozilla/ThreadBound.h" 15 #include "mozilla/dom/FileSystemHelpers.h" 16 #include "mozilla/dom/FileSystemTypes.h" 17 #include "mozilla/dom/quota/CheckedUnsafePtr.h" 18 #include "mozilla/dom/quota/ClientDirectoryLockHandle.h" 19 #include "mozilla/dom/quota/CommonMetadata.h" 20 #include "mozilla/dom/quota/ForwardDecls.h" 21 #include "nsCOMPtr.h" 22 #include "nsISupportsUtils.h" 23 #include "nsString.h" 24 #include "nsTHashSet.h" 25 26 namespace mozilla { 27 28 template <typename V, typename E> 29 class Result; 30 31 namespace dom { 32 33 class FileSystemAccessHandle; 34 class FileSystemManagerParent; 35 36 namespace fs { 37 struct FileId; 38 class FileSystemChildMetadata; 39 } // namespace fs 40 41 namespace quota { 42 class ClientDirectoryLock; 43 class QuotaManager; 44 } // namespace quota 45 46 namespace fs::data { 47 48 class FileSystemDatabaseManager; 49 50 Result<EntryId, QMResult> GetRootHandle(const Origin& origin); 51 52 Result<EntryId, QMResult> GetEntryHandle( 53 const FileSystemChildMetadata& aHandle); 54 55 Result<ResultConnection, QMResult> GetStorageConnection( 56 const quota::OriginMetadata& aOriginMetadata, 57 const int64_t aDirectoryLockId); 58 59 // The assertion type must be the same as the assertion type used for defining 60 // FileSystemDataManagerHashKey in FileSystemDataManager.cpp! 61 class FileSystemDataManager 62 : public SupportsCheckedUnsafePtr<CheckIf<ReleaseAssertEnabled>> { 63 public: 64 enum struct State : uint8_t { Initial = 0, Opening, Open, Closing, Closed }; 65 66 FileSystemDataManager(const quota::OriginMetadata& aOriginMetadata, 67 RefPtr<quota::QuotaManager> aQuotaManager, 68 MovingNotNull<nsCOMPtr<nsIEventTarget>> aIOTarget, 69 MovingNotNull<RefPtr<TaskQueue>> aIOTaskQueue); 70 71 // IsExclusive is true because we want to allow the move operations. There's 72 // always just one consumer anyway. 73 using CreatePromise = MozPromise<Registered<FileSystemDataManager>, nsresult, 74 /* IsExclusive */ true>; 75 static RefPtr<CreatePromise> GetOrCreateFileSystemDataManager( 76 const quota::OriginMetadata& aOriginMetadata); 77 78 static void AbortOperationsForLocks( 79 const quota::Client::DirectoryLockIdTable& aDirectoryLockIds); 80 81 static void InitiateShutdown(); 82 83 static bool IsShutdownCompleted(); 84 85 NS_INLINE_DECL_THREADSAFE_REFCOUNTING(FileSystemDataManager) 86 87 void AssertIsOnIOTarget() const; 88 89 const quota::OriginMetadata& OriginMetadataRef() const { 90 return mOriginMetadata; 91 } 92 93 nsISerialEventTarget* MutableBackgroundTargetPtr() const { 94 return mBackgroundTarget.get(); 95 } 96 97 nsIEventTarget* MutableIOTargetPtr() const { return mIOTarget.get(); } 98 99 nsISerialEventTarget* MutableIOTaskQueuePtr() const { 100 return mIOTaskQueue.get(); 101 } 102 103 Maybe<quota::ClientDirectoryLock&> MaybeDirectoryLockRef() const { 104 return ToMaybeRef(mDirectoryLockHandle.get()); 105 } 106 107 FileSystemDatabaseManager* MutableDatabaseManagerPtr() const { 108 MOZ_ASSERT(mDatabaseManager); 109 110 return mDatabaseManager.get(); 111 } 112 113 void Register(); 114 115 void Unregister(); 116 117 void RegisterActor(NotNull<FileSystemManagerParent*> aActor); 118 119 void UnregisterActor(NotNull<FileSystemManagerParent*> aActor); 120 121 void RegisterAccessHandle(NotNull<FileSystemAccessHandle*> aAccessHandle); 122 123 void UnregisterAccessHandle(NotNull<FileSystemAccessHandle*> aAccessHandle); 124 125 bool IsOpen() const { return mState == State::Open; } 126 127 RefPtr<BoolPromise> OnOpen(); 128 129 RefPtr<BoolPromise> OnClose(); 130 131 Result<bool, QMResult> IsLocked(const FileId& aFileId) const; 132 133 Result<bool, QMResult> IsLocked(const EntryId& aEntryId) const; 134 135 Result<FileId, QMResult> LockExclusive(const EntryId& aEntryId); 136 137 void UnlockExclusive(const EntryId& aEntryId); 138 139 Result<FileId, QMResult> LockShared(const EntryId& aEntryId); 140 141 void UnlockShared(const EntryId& aEntryId, const FileId& aFileId, 142 bool aAbort); 143 144 void DeprecateSharedLocks(const EntryId& aEntryId, const FileId& aFileId); 145 146 bool IsLockedWithDeprecatedSharedLock(const EntryId& aEntryId, 147 const FileId& aFileId) const; 148 149 FileMode GetMode(bool aKeepData) const; 150 151 protected: 152 virtual ~FileSystemDataManager(); 153 154 bool IsInactive() const; 155 156 bool IsOpening() const { return mState == State::Opening; } 157 158 bool IsClosing() const { return mState == State::Closing; } 159 160 void RequestAllowToClose(); 161 162 RefPtr<BoolPromise> BeginOpen(); 163 164 RefPtr<BoolPromise> BeginClose(); 165 166 // Things touched on background thread only. 167 struct BackgroundThreadAccessible { 168 nsTHashSet<FileSystemManagerParent*> mActors; 169 nsTHashSet<FileSystemAccessHandle*> mAccessHandles; 170 }; 171 ThreadBound<BackgroundThreadAccessible> mBackgroundThreadAccessible; 172 173 const quota::OriginMetadata mOriginMetadata; 174 nsTHashSet<EntryId> mExclusiveLocks; 175 nsTHashMap<EntryId, uint32_t> mSharedLocks; 176 nsTHashMap<EntryId, nsTArray<FileId>> mDeprecatedLocks; 177 NS_DECL_OWNINGEVENTTARGET 178 const RefPtr<quota::QuotaManager> mQuotaManager; 179 const NotNull<nsCOMPtr<nsISerialEventTarget>> mBackgroundTarget; 180 const NotNull<nsCOMPtr<nsIEventTarget>> mIOTarget; 181 const NotNull<RefPtr<TaskQueue>> mIOTaskQueue; 182 quota::ClientDirectoryLockHandle mDirectoryLockHandle; 183 UniquePtr<FileSystemDatabaseManager> mDatabaseManager; 184 MozPromiseHolder<BoolPromise> mOpenPromiseHolder; 185 MozPromiseHolder<BoolPromise> mClosePromiseHolder; 186 int64_t mDirectoryLockId; 187 uint32_t mRegCount; 188 DatabaseVersion mVersion; 189 State mState; 190 }; 191 192 } // namespace fs::data 193 } // namespace dom 194 } // namespace mozilla 195 196 #endif // DOM_FS_PARENT_DATAMODEL_FILESYSTEMDATAMANAGER_H_