?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bug 1526591 - Remove devtools.inspector.shapesHighlighter.enabled pref. r=rcaliman
[gecko.git] / dom / quota / ActorsParent.cpp
blob5447c4509af95abd0faa284ae19516354a129d09
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
5 * You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 #include "ActorsParent.h"
8
9 #include "mozIStorageConnection.h"
10 #include "mozIStorageService.h"
11 #include "nsIObjectInputStream.h"
12 #include "nsIObjectOutputStream.h"
13 #include "nsIFile.h"
14 #include "nsIFileStreams.h"
15 #include "nsIObserverService.h"
16 #include "nsIPermissionManager.h"
17 #include "nsIPrincipal.h"
18 #include "nsIRunnable.h"
19 #include "nsISimpleEnumerator.h"
20 #include "nsIScriptObjectPrincipal.h"
21 #include "nsIScriptSecurityManager.h"
22 #include "nsISupportsPrimitives.h"
23 #include "nsITimer.h"
24 #include "nsIURI.h"
25 #include "nsPIDOMWindow.h"
26
27 #include <algorithm>
28 #include "GeckoProfiler.h"
29 #include "mozilla/Atomics.h"
30 #include "mozilla/BasePrincipal.h"
31 #include "mozilla/CondVar.h"
32 #include "mozilla/Telemetry.h"
33 #include "mozilla/dom/PContent.h"
34 #include "mozilla/dom/asmjscache/AsmJSCache.h"
35 #include "mozilla/dom/cache/QuotaClient.h"
36 #include "mozilla/dom/indexedDB/ActorsParent.h"
37 #include "mozilla/dom/localstorage/ActorsParent.h"
38 #include "mozilla/dom/quota/PQuotaParent.h"
39 #include "mozilla/dom/quota/PQuotaRequestParent.h"
40 #include "mozilla/dom/quota/PQuotaUsageRequestParent.h"
41 #include "mozilla/dom/simpledb/ActorsParent.h"
42 #include "mozilla/dom/StorageActivityService.h"
43 #include "mozilla/dom/StorageDBUpdater.h"
44 #include "mozilla/ipc/BackgroundParent.h"
45 #include "mozilla/ipc/BackgroundUtils.h"
46 #include "mozilla/IntegerRange.h"
47 #include "mozilla/Mutex.h"
48 #include "mozilla/Preferences.h"
49 #include "mozilla/Services.h"
50 #include "mozilla/StaticPtr.h"
51 #include "mozilla/TextUtils.h"
52 #include "mozilla/Telemetry.h"
53 #include "mozilla/TypeTraits.h"
54 #include "mozilla/Unused.h"
55 #include "mozStorageCID.h"
56 #include "mozStorageHelper.h"
57 #include "nsAppDirectoryServiceDefs.h"
58 #include "nsComponentManagerUtils.h"
59 #include "nsAboutProtocolUtils.h"
60 #include "nsCharSeparatedTokenizer.h"
61 #include "nsContentUtils.h"
62 #include "nsCRTGlue.h"
63 #include "nsDirectoryServiceUtils.h"
64 #include "nsEscape.h"
65 #include "nsNetUtil.h"
66 #include "nsPrintfCString.h"
67 #include "nsScriptSecurityManager.h"
68 #include "nsThreadUtils.h"
69 #include "nsXULAppAPI.h"
70 #include "prio.h"
71 #include "xpcpublic.h"
72
73 #include "OriginScope.h"
74 #include "QuotaManager.h"
75 #include "QuotaManagerService.h"
76 #include "QuotaObject.h"
77 #include "UsageInfo.h"
78
79 #define DISABLE_ASSERTS_FOR_FUZZING 0
80
81 #if DISABLE_ASSERTS_FOR_FUZZING
82 # define ASSERT_UNLESS_FUZZING(...) \
83 do { \
84 } while (0)
85 #else
86 # define ASSERT_UNLESS_FUZZING(...) MOZ_ASSERT(false, __VA_ARGS__)
87 #endif
88
89 #define UNKNOWN_FILE_WARNING(_leafName) \
90 QM_WARNING("Something (%s) in the directory that doesn't belong!", \
91 NS_ConvertUTF16toUTF8(_leafName).get())
92
93 // The amount of time, in milliseconds, that our IO thread will stay alive
94 // after the last event it processes.
95 #define DEFAULT_THREAD_TIMEOUT_MS 30000
96
97 // The amount of time, in milliseconds, that we will wait for active storage
98 // transactions on shutdown before aborting them.
99 #define DEFAULT_SHUTDOWN_TIMER_MS 30000
100
101 // Preference that users can set to override temporary storage smart limit
102 // calculation.
103 #define PREF_FIXED_LIMIT "dom.quotaManager.temporaryStorage.fixedLimit"
104 #define PREF_CHUNK_SIZE "dom.quotaManager.temporaryStorage.chunkSize"
105
106 // Preference that is used to enable testing features
107 #define PREF_TESTING_FEATURES "dom.quotaManager.testing"
108
109 // profile-before-change, when we need to shut down quota manager
110 #define PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID "profile-before-change-qm"
111
112 #define KB *1024ULL
113 #define MB *1024ULL KB
114 #define GB *1024ULL MB
115
116 namespace mozilla {
117 namespace dom {
118 namespace quota {
119
120 using namespace mozilla::ipc;
121
122 // We want profiles to be platform-independent so we always need to replace
123 // the same characters on every platform. Windows has the most extensive set
124 // of illegal characters so we use its FILE_ILLEGAL_CHARACTERS and
125 // FILE_PATH_SEPARATOR.
126 const char QuotaManager::kReplaceChars[] = CONTROL_CHARACTERS "/:*?\"<>|\\";
127
128 namespace {
129
130 /*******************************************************************************
131 * Constants
132 ******************************************************************************/
133
134 const uint32_t kSQLitePageSizeOverride = 512;
135
136 const uint32_t kHackyDowngradeMajorStorageVersion = 2;
137 const uint32_t kHackyDowngradeMinorStorageVersion = 1;
138
139 // Important version history:
140 // - Bug 1290481 bumped our schema from major.minor 2.0 to 3.0 in Firefox 57
141 // which caused Firefox 57 release concerns because the major schema upgrade
142 // means anyone downgrading to Firefox 56 will experience a non-operational
143 // QuotaManager and all of its clients.
144 // - Bug 1404344 got very concerned about that and so we decided to effectively
145 // rename 3.0 to 2.1, effective in Firefox 57. This works because post
146 // storage.sqlite v1.0, QuotaManager doesn't care about minor storage version
147 // increases. It also works because all the upgrade did was give the DOM
148 // Cache API QuotaClient an opportunity to create its newly added .padding
149 // files during initialization/upgrade, which isn't functionally necessary as
150 // that can be done on demand.
151
152 // Major storage version. Bump for backwards-incompatible changes.
153 // (The next major version should be 4 to distinguish from the Bug 1290481
154 // downgrade snafu.)
155 const uint32_t kMajorStorageVersion = 2;
156
157 // Minor storage version. Bump for backwards-compatible changes.
158 const uint32_t kMinorStorageVersion = 1;
159
160 // The storage version we store in the SQLite database is a (signed) 32-bit
161 // integer. The major version is left-shifted 16 bits so the max value is
162 // 0xFFFF. The minor version occupies the lower 16 bits and its max is 0xFFFF.
163 static_assert(kMajorStorageVersion <= 0xFFFF,
164 "Major version needs to fit in 16 bits.");
165 static_assert(kMinorStorageVersion <= 0xFFFF,
166 "Minor version needs to fit in 16 bits.");
167
168 const int32_t kStorageVersion =
169 int32_t((kMajorStorageVersion << 16) + kMinorStorageVersion);
170
171 // See comments above about why these are a thing.
172 const int32_t kHackyPreDowngradeStorageVersion = int32_t((3 << 16) + 0);
173 const int32_t kHackyPostDowngradeStorageVersion = int32_t((2 << 16) + 1);
174
175 static_assert(static_cast<uint32_t>(StorageType::Persistent) ==
176 static_cast<uint32_t>(PERSISTENCE_TYPE_PERSISTENT),
177 "Enum values should match.");
178
179 static_assert(static_cast<uint32_t>(StorageType::Temporary) ==
180 static_cast<uint32_t>(PERSISTENCE_TYPE_TEMPORARY),
181 "Enum values should match.");
182
183 static_assert(static_cast<uint32_t>(StorageType::Default) ==
184 static_cast<uint32_t>(PERSISTENCE_TYPE_DEFAULT),
185 "Enum values should match.");
186
187 const char kChromeOrigin[] = "chrome";
188 const char kAboutHomeOriginPrefix[] = "moz-safe-about:home";
189 const char kIndexedDBOriginPrefix[] = "indexeddb://";
190 const char kResourceOriginPrefix[] = "resource://";
191
192 #define INDEXEDDB_DIRECTORY_NAME "indexedDB"
193 #define STORAGE_DIRECTORY_NAME "storage"
194 #define PERSISTENT_DIRECTORY_NAME "persistent"
195 #define PERMANENT_DIRECTORY_NAME "permanent"
196 #define TEMPORARY_DIRECTORY_NAME "temporary"
197 #define DEFAULT_DIRECTORY_NAME "default"
198
199 enum AppId {
200 kNoAppId = nsIScriptSecurityManager::NO_APP_ID,
201 kUnknownAppId = nsIScriptSecurityManager::UNKNOWN_APP_ID
202 };
203
204 #define STORAGE_FILE_NAME "storage.sqlite"
205
206 // The name of the file that we use to load/save the last access time of an
207 // origin.
208 // XXX We should get rid of old metadata files at some point, bug 1343576.
209 #define METADATA_FILE_NAME ".metadata"
210 #define METADATA_TMP_FILE_NAME ".metadata-tmp"
211 #define METADATA_V2_FILE_NAME ".metadata-v2"
212 #define METADATA_V2_TMP_FILE_NAME ".metadata-v2-tmp"
213
214 #define WEB_APPS_STORE_FILE_NAME "webappsstore.sqlite"
215 #define LS_ARCHIVE_FILE_NAME "ls-archive.sqlite"
216 #define LS_ARCHIVE_TMP_FILE_NAME "ls-archive-tmp.sqlite"
217
218 /******************************************************************************
219 * SQLite functions
220 ******************************************************************************/
221
222 int32_t MakeStorageVersion(uint32_t aMajorStorageVersion,
223 uint32_t aMinorStorageVersion) {
224 return int32_t((aMajorStorageVersion << 16) + aMinorStorageVersion);
225 }
226
227 uint32_t GetMajorStorageVersion(int32_t aStorageVersion) {
228 return uint32_t(aStorageVersion >> 16);
229 }
230
231 nsresult CreateTables(mozIStorageConnection* aConnection) {
232 AssertIsOnIOThread();
233 MOZ_ASSERT(aConnection);
234
235 // The database doesn't have any tables for now. It's only used for storage
236 // version checking.
237 // However, this is the place where any future tables should be created.
238
239 nsresult rv;
240
241 #ifdef DEBUG
242 {
243 int32_t storageVersion;
244 rv = aConnection->GetSchemaVersion(&storageVersion);
245 if (NS_WARN_IF(NS_FAILED(rv))) {
246 return rv;
247 }
248
249 MOZ_ASSERT(storageVersion == 0);
250 }
251 #endif
252
253 rv = aConnection->SetSchemaVersion(kStorageVersion);
254 if (NS_WARN_IF(NS_FAILED(rv))) {
255 return rv;
256 }
257
258 return NS_OK;
259 }
260
261 nsresult CreateWebAppsStoreConnection(nsIFile* aWebAppsStoreFile,
262 mozIStorageService* aStorageService,
263 mozIStorageConnection** aConnection) {
264 AssertIsOnIOThread();
265 MOZ_ASSERT(aWebAppsStoreFile);
266 MOZ_ASSERT(aStorageService);
267 MOZ_ASSERT(aConnection);
268
269 // Check if the old database exists at all.
270 bool exists;
271 nsresult rv = aWebAppsStoreFile->Exists(&exists);
272 if (NS_WARN_IF(NS_FAILED(rv))) {
273 return rv;
274 }
275
276 if (!exists) {
277 // webappsstore.sqlite doesn't exist, return a null connection.
278 *aConnection = nullptr;
279 return NS_OK;
280 }
281
282 bool isDirectory;
283 rv = aWebAppsStoreFile->IsDirectory(&isDirectory);
284 if (NS_WARN_IF(NS_FAILED(rv))) {
285 return rv;
286 }
287
288 if (isDirectory) {
289 QM_WARNING("webappsstore.sqlite is not a file!");
290 *aConnection = nullptr;
291 return NS_OK;
292 }
293
294 nsCOMPtr<mozIStorageConnection> connection;
295 rv = aStorageService->OpenUnsharedDatabase(aWebAppsStoreFile,
296 getter_AddRefs(connection));
297 if (rv == NS_ERROR_FILE_CORRUPTED) {
298 // Don't throw an error, leave a corrupted webappsstore database as it is.
299 *aConnection = nullptr;
300 return NS_OK;
301 }
302 if (NS_WARN_IF(NS_FAILED(rv))) {
303 return rv;
304 }
305
306 rv = StorageDBUpdater::Update(connection);
307 if (NS_FAILED(rv)) {
308 // Don't throw an error, leave a non-updateable webappsstore database as
309 // it is.
310 *aConnection = nullptr;
311 return NS_OK;
312 }
313
314 connection.forget(aConnection);
315 return NS_OK;
316 }
317
318 /******************************************************************************
319 * Quota manager class declarations
320 ******************************************************************************/
321
322 } // namespace
323
324 class DirectoryLockImpl final : public DirectoryLock {
325 RefPtr<QuotaManager> mQuotaManager;
326
327 const Nullable<PersistenceType> mPersistenceType;
328 const nsCString mGroup;
329 const OriginScope mOriginScope;
330 const Nullable<Client::Type> mClientType;
331 RefPtr<OpenDirectoryListener> mOpenListener;
332
333 nsTArray<DirectoryLockImpl*> mBlocking;
334 nsTArray<DirectoryLockImpl*> mBlockedOn;
335
336 const bool mExclusive;
337
338 // Internal quota manager operations use this flag to prevent directory lock
339 // registraction/unregistration from updating origin access time, etc.
340 const bool mInternal;
341
342 bool mInvalidated;
343
344 public:
345 DirectoryLockImpl(QuotaManager* aQuotaManager,
346 const Nullable<PersistenceType>& aPersistenceType,
347 const nsACString& aGroup, const OriginScope& aOriginScope,
348 const Nullable<Client::Type>& aClientType, bool aExclusive,
349 bool aInternal, OpenDirectoryListener* aOpenListener);
350
351 void AssertIsOnOwningThread() const
352 #ifdef DEBUG
353 ;
354 #else
355 {
356 }
357 #endif
358
359 const Nullable<PersistenceType>& GetPersistenceType() const {
360 return mPersistenceType;
361 }
362
363 const nsACString& GetGroup() const { return mGroup; }
364
365 const OriginScope& GetOriginScope() const { return mOriginScope; }
366
367 const Nullable<Client::Type>& GetClientType() const { return mClientType; }
368
369 bool IsInternal() const { return mInternal; }
370
371 bool ShouldUpdateLockTable() {
372 return !mInternal &&
373 mPersistenceType.Value() != PERSISTENCE_TYPE_PERSISTENT;
374 }
375
376 // Test whether this DirectoryLock needs to wait for the given lock.
377 bool MustWaitFor(const DirectoryLockImpl& aLock);
378
379 void AddBlockingLock(DirectoryLockImpl* aLock) {
380 AssertIsOnOwningThread();
381
382 mBlocking.AppendElement(aLock);
383 }
384
385 const nsTArray<DirectoryLockImpl*>& GetBlockedOnLocks() { return mBlockedOn; }
386
387 void AddBlockedOnLock(DirectoryLockImpl* aLock) {
388 AssertIsOnOwningThread();
389
390 mBlockedOn.AppendElement(aLock);
391 }
392
393 void MaybeUnblock(DirectoryLockImpl* aLock) {
394 AssertIsOnOwningThread();
395
396 mBlockedOn.RemoveElement(aLock);
397 if (mBlockedOn.IsEmpty()) {
398 NotifyOpenListener();
399 }
400 }
401
402 void NotifyOpenListener();
403
404 void Invalidate() {
405 AssertIsOnOwningThread();
406
407 mInvalidated = true;
408 }
409
410 NS_INLINE_DECL_REFCOUNTING(DirectoryLockImpl, override)
411
412 private:
413 ~DirectoryLockImpl();
414 };
415
416 class QuotaManager::CreateRunnable final : public BackgroundThreadObject,
417 public Runnable {
418 nsCOMPtr<nsIEventTarget> mMainEventTarget;
419 nsTArray<nsCOMPtr<nsIRunnable>> mCallbacks;
420 nsString mBaseDirPath;
421 RefPtr<QuotaManager> mManager;
422 nsresult mResultCode;
423
424 enum class State {
425 Initial,
426 CreatingManager,
427 RegisteringObserver,
428 CallingCallbacks,
429 Completed
430 };
431
432 State mState;
433
434 public:
435 explicit CreateRunnable(nsIEventTarget* aMainEventTarget)
436 : Runnable("dom::quota::QuotaManager::CreateRunnable"),
437 mMainEventTarget(aMainEventTarget),
438 mResultCode(NS_OK),
439 mState(State::Initial) {
440 AssertIsOnBackgroundThread();
441 }
442
443 void AddCallback(nsIRunnable* aCallback) {
444 AssertIsOnOwningThread();
445 MOZ_ASSERT(aCallback);
446
447 mCallbacks.AppendElement(aCallback);
448 }
449
450 private:
451 ~CreateRunnable() {}
452
453 nsresult Init();
454
455 nsresult CreateManager();
456
457 nsresult RegisterObserver();
458
459 void CallCallbacks();
460
461 State GetNextState(nsCOMPtr<nsIEventTarget>& aThread);
462
463 NS_DECL_NSIRUNNABLE
464 };
465
466 class QuotaManager::ShutdownRunnable final : public Runnable {
467 // Only touched on the main thread.
468 bool& mDone;
469
470 public:
471 explicit ShutdownRunnable(bool& aDone)
472 : Runnable("dom::quota::QuotaManager::ShutdownRunnable"), mDone(aDone) {
473 MOZ_ASSERT(NS_IsMainThread());
474 }
475
476 private:
477 ~ShutdownRunnable() {}
478
479 NS_DECL_NSIRUNNABLE
480 };
481
482 class QuotaManager::ShutdownObserver final : public nsIObserver {
483 nsCOMPtr<nsIEventTarget> mBackgroundThread;
484
485 public:
486 explicit ShutdownObserver(nsIEventTarget* aBackgroundThread)
487 : mBackgroundThread(aBackgroundThread) {
488 MOZ_ASSERT(NS_IsMainThread());
489 }
490
491 NS_DECL_ISUPPORTS
492 NS_DECL_NSIOBSERVER
493
494 private:
495 ~ShutdownObserver() { MOZ_ASSERT(NS_IsMainThread()); }
496 };
497
498 namespace {
499
500 /*******************************************************************************
501 * Local class declarations
502 ******************************************************************************/
503
504 } // namespace
505
506 class OriginInfo final {
507 friend class GroupInfo;
508 friend class QuotaManager;
509 friend class QuotaObject;
510
511 public:
512 OriginInfo(GroupInfo* aGroupInfo, const nsACString& aOrigin, uint64_t aUsage,
513 int64_t aAccessTime, bool aPersisted);
514
515 NS_INLINE_DECL_THREADSAFE_REFCOUNTING(OriginInfo)
516
517 int64_t LockedAccessTime() const {
518 AssertCurrentThreadOwnsQuotaMutex();
519
520 return mAccessTime;
521 }
522
523 bool LockedPersisted() const {
524 AssertCurrentThreadOwnsQuotaMutex();
525
526 return mPersisted;
527 }
528
529 private:
530 // Private destructor, to discourage deletion outside of Release():
531 ~OriginInfo() {
532 MOZ_COUNT_DTOR(OriginInfo);
533
534 MOZ_ASSERT(!mQuotaObjects.Count());
535 }
536
537 void LockedDecreaseUsage(int64_t aSize);
538
539 void LockedUpdateAccessTime(int64_t aAccessTime) {
540 AssertCurrentThreadOwnsQuotaMutex();
541
542 mAccessTime = aAccessTime;
543 }
544
545 void LockedPersist();
546
547 nsDataHashtable<nsStringHashKey, QuotaObject*> mQuotaObjects;
548
549 GroupInfo* mGroupInfo;
550 const nsCString mOrigin;
551 uint64_t mUsage;
552 int64_t mAccessTime;
553 bool mPersisted;
554 };
555
556 class OriginInfoLRUComparator {
557 public:
558 bool Equals(const OriginInfo* a, const OriginInfo* b) const {
559 return a && b ? a->LockedAccessTime() == b->LockedAccessTime()
560 : !a && !b ? true : false;
561 }
562
563 bool LessThan(const OriginInfo* a, const OriginInfo* b) const {
564 return a && b ? a->LockedAccessTime() < b->LockedAccessTime()
565 : b ? true : false;
566 }
567 };
568
569 class GroupInfo final {
570 friend class GroupInfoPair;
571 friend class OriginInfo;
572 friend class QuotaManager;
573 friend class QuotaObject;
574
575 public:
576 GroupInfo(GroupInfoPair* aGroupInfoPair, PersistenceType aPersistenceType,
577 const nsACString& aGroup)
578 : mGroupInfoPair(aGroupInfoPair),
579 mPersistenceType(aPersistenceType),
580 mGroup(aGroup),
581 mUsage(0) {
582 MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_PERSISTENT);
583
584 MOZ_COUNT_CTOR(GroupInfo);
585 }
586
587 NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GroupInfo)
588
589 private:
590 // Private destructor, to discourage deletion outside of Release():
591 ~GroupInfo() { MOZ_COUNT_DTOR(GroupInfo); }
592
593 already_AddRefed<OriginInfo> LockedGetOriginInfo(const nsACString& aOrigin);
594
595 void LockedAddOriginInfo(OriginInfo* aOriginInfo);
596
597 void LockedRemoveOriginInfo(const nsACString& aOrigin);
598
599 void LockedRemoveOriginInfos();
600
601 bool LockedHasOriginInfos() {
602 AssertCurrentThreadOwnsQuotaMutex();
603
604 return !mOriginInfos.IsEmpty();
605 }
606
607 nsTArray<RefPtr<OriginInfo>> mOriginInfos;
608
609 GroupInfoPair* mGroupInfoPair;
610 PersistenceType mPersistenceType;
611 nsCString mGroup;
612 uint64_t mUsage;
613 };
614
615 class GroupInfoPair {
616 friend class QuotaManager;
617 friend class QuotaObject;
618
619 public:
620 GroupInfoPair() { MOZ_COUNT_CTOR(GroupInfoPair); }
621
622 ~GroupInfoPair() { MOZ_COUNT_DTOR(GroupInfoPair); }
623
624 private:
625 already_AddRefed<GroupInfo> LockedGetGroupInfo(
626 PersistenceType aPersistenceType) {
627 AssertCurrentThreadOwnsQuotaMutex();
628 MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_PERSISTENT);
629
630 RefPtr<GroupInfo> groupInfo =
631 GetGroupInfoForPersistenceType(aPersistenceType);
632 return groupInfo.forget();
633 }
634
635 void LockedSetGroupInfo(PersistenceType aPersistenceType,
636 GroupInfo* aGroupInfo) {
637 AssertCurrentThreadOwnsQuotaMutex();
638 MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_PERSISTENT);
639
640 RefPtr<GroupInfo>& groupInfo =
641 GetGroupInfoForPersistenceType(aPersistenceType);
642 groupInfo = aGroupInfo;
643 }
644
645 void LockedClearGroupInfo(PersistenceType aPersistenceType) {
646 AssertCurrentThreadOwnsQuotaMutex();
647 MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_PERSISTENT);
648
649 RefPtr<GroupInfo>& groupInfo =
650 GetGroupInfoForPersistenceType(aPersistenceType);
651 groupInfo = nullptr;
652 }
653
654 bool LockedHasGroupInfos() {
655 AssertCurrentThreadOwnsQuotaMutex();
656
657 return mTemporaryStorageGroupInfo || mDefaultStorageGroupInfo;
658 }
659
660 RefPtr<GroupInfo>& GetGroupInfoForPersistenceType(
661 PersistenceType aPersistenceType);
662
663 RefPtr<GroupInfo> mTemporaryStorageGroupInfo;
664 RefPtr<GroupInfo> mDefaultStorageGroupInfo;
665 };
666
667 namespace {
668
669 class CollectOriginsHelper final : public Runnable {
670 uint64_t mMinSizeToBeFreed;
671
672 Mutex& mMutex;
673 CondVar mCondVar;
674
675 // The members below are protected by mMutex.
676 nsTArray<RefPtr<DirectoryLockImpl>> mLocks;
677 uint64_t mSizeToBeFreed;
678 bool mWaiting;
679
680 public:
681 CollectOriginsHelper(mozilla::Mutex& aMutex, uint64_t aMinSizeToBeFreed);
682
683 // Blocks the current thread until origins are collected on the main thread.
684 // The returned value contains an aggregate size of those origins.
685 int64_t BlockAndReturnOriginsForEviction(
686 nsTArray<RefPtr<DirectoryLockImpl>>& aLocks);
687
688 private:
689 ~CollectOriginsHelper() {}
690
691 NS_IMETHOD
692 Run() override;
693 };
694
695 class OriginOperationBase : public BackgroundThreadObject, public Runnable {
696 protected:
697 nsresult mResultCode;
698
699 enum State {
700 // Not yet run.
701 State_Initial,
702
703 // Running initialization on the main thread.
704 State_Initializing,
705
706 // Running initialization on the owning thread.
707 State_FinishingInit,
708
709 // Running quota manager initialization on the owning thread.
710 State_CreatingQuotaManager,
711
712 // Running on the owning thread in the listener for OpenDirectory.
713 State_DirectoryOpenPending,
714
715 // Running on the IO thread.
716 State_DirectoryWorkOpen,
717
718 // Running on the owning thread after all work is done.
719 State_UnblockingOpen,
720
721 // All done.
722 State_Complete
723 };
724
725 private:
726 State mState;
727 bool mActorDestroyed;
728
729 protected:
730 bool mNeedsMainThreadInit;
731 bool mNeedsQuotaManagerInit;
732
733 public:
734 void NoteActorDestroyed() {
735 AssertIsOnOwningThread();
736
737 mActorDestroyed = true;
738 }
739
740 bool IsActorDestroyed() const {
741 AssertIsOnOwningThread();
742
743 return mActorDestroyed;
744 }
745
746 protected:
747 explicit OriginOperationBase(
748 nsIEventTarget* aOwningThread = GetCurrentThreadEventTarget())
749 : BackgroundThreadObject(aOwningThread),
750 Runnable("dom::quota::OriginOperationBase"),
751 mResultCode(NS_OK),
752 mState(State_Initial),
753 mActorDestroyed(false),
754 mNeedsMainThreadInit(false),
755 mNeedsQuotaManagerInit(false) {}
756
757 // Reference counted.
758 virtual ~OriginOperationBase() {
759 MOZ_ASSERT(mState == State_Complete);
760 MOZ_ASSERT(mActorDestroyed);
761 }
762
763 #ifdef DEBUG
764 State GetState() const { return mState; }
765 #endif
766
767 void SetState(State aState) {
768 MOZ_ASSERT(mState == State_Initial);
769 mState = aState;
770 }
771
772 void AdvanceState() {
773 switch (mState) {
774 case State_Initial:
775 mState = State_Initializing;
776 return;
777 case State_Initializing:
778 mState = State_FinishingInit;
779 return;
780 case State_FinishingInit:
781 mState = State_CreatingQuotaManager;
782 return;
783 case State_CreatingQuotaManager:
784 mState = State_DirectoryOpenPending;
785 return;
786 case State_DirectoryOpenPending:
787 mState = State_DirectoryWorkOpen;
788 return;
789 case State_DirectoryWorkOpen:
790 mState = State_UnblockingOpen;
791 return;
792 case State_UnblockingOpen:
793 mState = State_Complete;
794 return;
795 default:
796 MOZ_CRASH("Bad state!");
797 }
798 }
799
800 NS_IMETHOD
801 Run() override;
802
803 virtual nsresult DoInitOnMainThread() { return NS_OK; }
804
805 virtual void Open() = 0;
806
807 nsresult DirectoryOpen();
808
809 virtual nsresult DoDirectoryWork(QuotaManager* aQuotaManager) = 0;
810
811 void Finish(nsresult aResult);
812
813 virtual void UnblockOpen() = 0;
814
815 private:
816 nsresult Init();
817
818 nsresult InitOnMainThread();
819
820 nsresult FinishInit();
821
822 nsresult QuotaManagerOpen();
823
824 nsresult DirectoryWork();
825 };
826
827 class FinalizeOriginEvictionOp : public OriginOperationBase {
828 nsTArray<RefPtr<DirectoryLockImpl>> mLocks;
829
830 public:
831 FinalizeOriginEvictionOp(nsIEventTarget* aBackgroundThread,
832 nsTArray<RefPtr<DirectoryLockImpl>>& aLocks)
833 : OriginOperationBase(aBackgroundThread) {
834 MOZ_ASSERT(!NS_IsMainThread());
835
836 mLocks.SwapElements(aLocks);
837 }
838
839 void Dispatch();
840
841 void RunOnIOThreadImmediately();
842
843 private:
844 ~FinalizeOriginEvictionOp() {}
845
846 virtual void Open() override;
847
848 virtual nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
849
850 virtual void UnblockOpen() override;
851 };
852
853 class NormalOriginOperationBase : public OriginOperationBase,
854 public OpenDirectoryListener {
855 RefPtr<DirectoryLock> mDirectoryLock;
856
857 protected:
858 Nullable<PersistenceType> mPersistenceType;
859 OriginScope mOriginScope;
860 Nullable<Client::Type> mClientType;
861 mozilla::Atomic<bool> mCanceled;
862 const bool mExclusive;
863
864 public:
865 void RunImmediately() {
866 MOZ_ASSERT(GetState() == State_Initial);
867
868 MOZ_ALWAYS_SUCCEEDS(this->Run());
869 }
870
871 protected:
872 NormalOriginOperationBase(const Nullable<PersistenceType>& aPersistenceType,
873 const OriginScope& aOriginScope, bool aExclusive)
874 : mPersistenceType(aPersistenceType),
875 mOriginScope(aOriginScope),
876 mExclusive(aExclusive) {
877 AssertIsOnOwningThread();
878 }
879
880 ~NormalOriginOperationBase() {}
881
882 private:
883 // Need to declare refcounting unconditionally, because
884 // OpenDirectoryListener has pure-virtual refcounting.
885 NS_DECL_ISUPPORTS_INHERITED
886
887 virtual void Open() override;
888
889 virtual void UnblockOpen() override;
890
891 // OpenDirectoryListener overrides.
892 virtual void DirectoryLockAcquired(DirectoryLock* aLock) override;
893
894 virtual void DirectoryLockFailed() override;
895
896 // Used to send results before unblocking open.
897 virtual void SendResults() = 0;
898 };
899
900 class SaveOriginAccessTimeOp : public NormalOriginOperationBase {
901 int64_t mTimestamp;
902
903 public:
904 SaveOriginAccessTimeOp(PersistenceType aPersistenceType,
905 const nsACString& aOrigin, int64_t aTimestamp)
906 : NormalOriginOperationBase(Nullable<PersistenceType>(aPersistenceType),
907 OriginScope::FromOrigin(aOrigin),
908 /* aExclusive */ false),
909 mTimestamp(aTimestamp) {
910 AssertIsOnOwningThread();
911 }
912
913 private:
914 ~SaveOriginAccessTimeOp() {}
915
916 virtual nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
917
918 virtual void SendResults() override;
919 };
920
921 /*******************************************************************************
922 * Actor class declarations
923 ******************************************************************************/
924
925 class Quota final : public PQuotaParent {
926 #ifdef DEBUG
927 bool mActorDestroyed;
928 #endif
929
930 public:
931 Quota();
932
933 NS_INLINE_DECL_THREADSAFE_REFCOUNTING(mozilla::dom::quota::Quota)
934
935 private:
936 ~Quota();
937
938 void StartIdleMaintenance();
939
940 // IPDL methods.
941 virtual void ActorDestroy(ActorDestroyReason aWhy) override;
942
943 virtual PQuotaUsageRequestParent* AllocPQuotaUsageRequestParent(
944 const UsageRequestParams& aParams) override;
945
946 virtual mozilla::ipc::IPCResult RecvPQuotaUsageRequestConstructor(
947 PQuotaUsageRequestParent* aActor,
948 const UsageRequestParams& aParams) override;
949
950 virtual bool DeallocPQuotaUsageRequestParent(
951 PQuotaUsageRequestParent* aActor) override;
952
953 virtual PQuotaRequestParent* AllocPQuotaRequestParent(
954 const RequestParams& aParams) override;
955
956 virtual mozilla::ipc::IPCResult RecvPQuotaRequestConstructor(
957 PQuotaRequestParent* aActor, const RequestParams& aParams) override;
958
959 virtual bool DeallocPQuotaRequestParent(PQuotaRequestParent* aActor) override;
960
961 virtual mozilla::ipc::IPCResult RecvStartIdleMaintenance() override;
962
963 virtual mozilla::ipc::IPCResult RecvStopIdleMaintenance() override;
964 };
965
966 class QuotaUsageRequestBase : public NormalOriginOperationBase,
967 public PQuotaUsageRequestParent {
968 public:
969 // May be overridden by subclasses if they need to perform work on the
970 // background thread before being run.
971 virtual bool Init(Quota* aQuota);
972
973 protected:
974 QuotaUsageRequestBase()
975 : NormalOriginOperationBase(Nullable<PersistenceType>(),
976 OriginScope::FromNull(),
977 /* aExclusive */ false) {}
978
979 nsresult GetUsageForOrigin(QuotaManager* aQuotaManager,
980 PersistenceType aPersistenceType,
981 const nsACString& aGroup,
982 const nsACString& aOrigin, UsageInfo* aUsageInfo);
983
984 // Subclasses use this override to set the IPDL response value.
985 virtual void GetResponse(UsageRequestResponse& aResponse) = 0;
986
987 private:
988 void SendResults() override;
989
990 // IPDL methods.
991 void ActorDestroy(ActorDestroyReason aWhy) override;
992
993 mozilla::ipc::IPCResult RecvCancel() final;
994 };
995
996 class GetUsageOp final : public QuotaUsageRequestBase {
997 nsTArray<OriginUsage> mOriginUsages;
998 nsDataHashtable<nsCStringHashKey, uint32_t> mOriginUsagesIndex;
999
1000 bool mGetAll;
1001
1002 public:
1003 explicit GetUsageOp(const UsageRequestParams& aParams);
1004
1005 private:
1006 ~GetUsageOp() {}
1007
1008 nsresult TraverseRepository(QuotaManager* aQuotaManager,
1009 PersistenceType aPersistenceType);
1010
1011 nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
1012
1013 void GetResponse(UsageRequestResponse& aResponse) override;
1014 };
1015
1016 class GetOriginUsageOp final : public QuotaUsageRequestBase {
1017 // If mGetGroupUsage is false, we use mUsageInfo to record the origin usage
1018 // and the file usage. Otherwise, we use it to record the group usage and the
1019 // limit.
1020 UsageInfo mUsageInfo;
1021
1022 const OriginUsageParams mParams;
1023 nsCString mSuffix;
1024 nsCString mGroup;
1025 bool mGetGroupUsage;
1026
1027 public:
1028 explicit GetOriginUsageOp(const UsageRequestParams& aParams);
1029
1030 MOZ_IS_CLASS_INIT bool Init(Quota* aQuota) override;
1031
1032 private:
1033 ~GetOriginUsageOp() {}
1034
1035 MOZ_IS_CLASS_INIT virtual nsresult DoInitOnMainThread() override;
1036
1037 virtual nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
1038
1039 void GetResponse(UsageRequestResponse& aResponse) override;
1040 };
1041
1042 class QuotaRequestBase : public NormalOriginOperationBase,
1043 public PQuotaRequestParent {
1044 public:
1045 // May be overridden by subclasses if they need to perform work on the
1046 // background thread before being run.
1047 virtual bool Init(Quota* aQuota);
1048
1049 protected:
1050 explicit QuotaRequestBase(bool aExclusive)
1051 : NormalOriginOperationBase(Nullable<PersistenceType>(),
1052 OriginScope::FromNull(), aExclusive) {}
1053
1054 // Subclasses use this override to set the IPDL response value.
1055 virtual void GetResponse(RequestResponse& aResponse) = 0;
1056
1057 private:
1058 virtual void SendResults() override;
1059
1060 // IPDL methods.
1061 virtual void ActorDestroy(ActorDestroyReason aWhy) override;
1062 };
1063
1064 class InitOp final : public QuotaRequestBase {
1065 public:
1066 InitOp() : QuotaRequestBase(/* aExclusive */ false) {
1067 AssertIsOnOwningThread();
1068 }
1069
1070 private:
1071 ~InitOp() {}
1072
1073 nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
1074
1075 void GetResponse(RequestResponse& aResponse) override;
1076 };
1077
1078 class InitTemporaryStorageOp final : public QuotaRequestBase {
1079 public:
1080 InitTemporaryStorageOp() : QuotaRequestBase(/* aExclusive */ false) {
1081 AssertIsOnOwningThread();
1082 }
1083
1084 private:
1085 ~InitTemporaryStorageOp() {}
1086
1087 nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
1088
1089 void GetResponse(RequestResponse& aResponse) override;
1090 };
1091
1092 class InitOriginOp final : public QuotaRequestBase {
1093 const InitOriginParams mParams;
1094 nsCString mSuffix;
1095 nsCString mGroup;
1096 bool mCreated;
1097
1098 public:
1099 explicit InitOriginOp(const RequestParams& aParams);
1100
1101 bool Init(Quota* aQuota) override;
1102
1103 private:
1104 ~InitOriginOp() {}
1105
1106 nsresult DoInitOnMainThread() override;
1107
1108 nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
1109
1110 void GetResponse(RequestResponse& aResponse) override;
1111 };
1112
1113 class ResetOrClearOp final : public QuotaRequestBase {
1114 const bool mClear;
1115
1116 public:
1117 explicit ResetOrClearOp(bool aClear)
1118 : QuotaRequestBase(/* aExclusive */ true), mClear(aClear) {
1119 AssertIsOnOwningThread();
1120 }
1121
1122 private:
1123 ~ResetOrClearOp() {}
1124
1125 void DeleteFiles(QuotaManager* aQuotaManager);
1126
1127 virtual nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
1128
1129 virtual void GetResponse(RequestResponse& aResponse) override;
1130 };
1131
1132 class ClearRequestBase : public QuotaRequestBase {
1133 protected:
1134 const bool mClear;
1135
1136 protected:
1137 ClearRequestBase(bool aExclusive, bool aClear)
1138 : QuotaRequestBase(aExclusive), mClear(aClear) {
1139 AssertIsOnOwningThread();
1140 }
1141
1142 void DeleteFiles(QuotaManager* aQuotaManager,
1143 PersistenceType aPersistenceType);
1144
1145 nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
1146 };
1147
1148 class ClearOriginOp final : public ClearRequestBase {
1149 const ClearResetOriginParams mParams;
1150
1151 public:
1152 explicit ClearOriginOp(const RequestParams& aParams);
1153
1154 bool Init(Quota* aQuota) override;
1155
1156 private:
1157 ~ClearOriginOp() {}
1158
1159 nsresult DoInitOnMainThread() override;
1160
1161 void GetResponse(RequestResponse& aResponse) override;
1162 };
1163
1164 class ClearDataOp final : public ClearRequestBase {
1165 const ClearDataParams mParams;
1166
1167 public:
1168 explicit ClearDataOp(const RequestParams& aParams);
1169
1170 bool Init(Quota* aQuota) override;
1171
1172 private:
1173 ~ClearDataOp() {}
1174
1175 nsresult DoInitOnMainThread() override;
1176
1177 void GetResponse(RequestResponse& aResponse) override;
1178 };
1179
1180 class PersistRequestBase : public QuotaRequestBase {
1181 const PrincipalInfo mPrincipalInfo;
1182
1183 protected:
1184 nsCString mSuffix;
1185 nsCString mGroup;
1186
1187 public:
1188 bool Init(Quota* aQuota) override;
1189
1190 protected:
1191 explicit PersistRequestBase(const PrincipalInfo& aPrincipalInfo);
1192
1193 private:
1194 nsresult DoInitOnMainThread() override;
1195 };
1196
1197 class PersistedOp final : public PersistRequestBase {
1198 bool mPersisted;
1199
1200 public:
1201 explicit PersistedOp(const RequestParams& aParams);
1202
1203 private:
1204 ~PersistedOp() {}
1205
1206 nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
1207
1208 void GetResponse(RequestResponse& aResponse) override;
1209 };
1210
1211 class PersistOp final : public PersistRequestBase {
1212 public:
1213 explicit PersistOp(const RequestParams& aParams);
1214
1215 private:
1216 ~PersistOp() {}
1217
1218 nsresult DoDirectoryWork(QuotaManager* aQuotaManager) override;
1219
1220 void GetResponse(RequestResponse& aResponse) override;
1221 };
1222
1223 class StoragePressureRunnable final : public Runnable {
1224 const uint64_t mUsage;
1225
1226 public:
1227 explicit StoragePressureRunnable(uint64_t aUsage)
1228 : Runnable("dom::quota::QuotaObject::StoragePressureRunnable"),
1229 mUsage(aUsage) {}
1230
1231 private:
1232 ~StoragePressureRunnable() = default;
1233
1234 NS_DECL_NSIRUNNABLE
1235 };
1236
1237 /*******************************************************************************
1238 * Helper Functions
1239 ******************************************************************************/
1240
1241 template <typename T, bool = mozilla::IsUnsigned<T>::value>
1242 struct IntChecker {
1243 static void Assert(T aInt) {
1244 static_assert(mozilla::IsIntegral<T>::value, "Not an integer!");
1245 MOZ_ASSERT(aInt >= 0);
1246 }
1247 };
1248
1249 template <typename T>
1250 struct IntChecker<T, true> {
1251 static void Assert(T aInt) {
1252 static_assert(mozilla::IsIntegral<T>::value, "Not an integer!");
1253 }
1254 };
1255
1256 template <typename T>
1257 void AssertNoOverflow(uint64_t aDest, T aArg) {
1258 IntChecker<T>::Assert(aDest);
1259 IntChecker<T>::Assert(aArg);
1260 MOZ_ASSERT(UINT64_MAX - aDest >= uint64_t(aArg));
1261 }
1262
1263 template <typename T, typename U>
1264 void AssertNoUnderflow(T aDest, U aArg) {
1265 IntChecker<T>::Assert(aDest);
1266 IntChecker<T>::Assert(aArg);
1267 MOZ_ASSERT(uint64_t(aDest) >= uint64_t(aArg));
1268 }
1269
1270 inline bool IsDotFile(const nsAString& aFileName) {
1271 return QuotaManager::IsDotFile(aFileName);
1272 }
1273
1274 inline bool IsOSMetadata(const nsAString& aFileName) {
1275 return QuotaManager::IsOSMetadata(aFileName);
1276 }
1277
1278 bool IsOriginMetadata(const nsAString& aFileName) {
1279 return aFileName.EqualsLiteral(METADATA_FILE_NAME) ||
1280 aFileName.EqualsLiteral(METADATA_V2_FILE_NAME) ||
1281 IsOSMetadata(aFileName);
1282 }
1283
1284 bool IsTempMetadata(const nsAString& aFileName) {
1285 return aFileName.EqualsLiteral(METADATA_TMP_FILE_NAME) ||
1286 aFileName.EqualsLiteral(METADATA_V2_TMP_FILE_NAME);
1287 }
1288
1289 } // namespace
1290
1291 BackgroundThreadObject::BackgroundThreadObject()
1292 : mOwningThread(GetCurrentThreadEventTarget()) {
1293 AssertIsOnOwningThread();
1294 }
1295
1296 BackgroundThreadObject::BackgroundThreadObject(nsIEventTarget* aOwningThread)
1297 : mOwningThread(aOwningThread) {}
1298
1299 #ifdef DEBUG
1300
1301 void BackgroundThreadObject::AssertIsOnOwningThread() const {
1302 AssertIsOnBackgroundThread();
1303 MOZ_ASSERT(mOwningThread);
1304 bool current;
1305 MOZ_ASSERT(NS_SUCCEEDED(mOwningThread->IsOnCurrentThread(&current)));
1306 MOZ_ASSERT(current);
1307 }
1308
1309 #endif // DEBUG
1310
1311 nsIEventTarget* BackgroundThreadObject::OwningThread() const {
1312 MOZ_ASSERT(mOwningThread);
1313 return mOwningThread;
1314 }
1315
1316 bool IsOnIOThread() {
1317 QuotaManager* quotaManager = QuotaManager::Get();
1318 NS_ASSERTION(quotaManager, "Must have a manager here!");
1319
1320 bool currentThread;
1321 return NS_SUCCEEDED(
1322 quotaManager->IOThread()->IsOnCurrentThread(&currentThread)) &&
1323 currentThread;
1324 }
1325
1326 void AssertIsOnIOThread() {
1327 NS_ASSERTION(IsOnIOThread(), "Running on the wrong thread!");
1328 }
1329
1330 void AssertCurrentThreadOwnsQuotaMutex() {
1331 #ifdef DEBUG
1332 QuotaManager* quotaManager = QuotaManager::Get();
1333 NS_ASSERTION(quotaManager, "Must have a manager here!");
1334
1335 quotaManager->AssertCurrentThreadOwnsQuotaMutex();
1336 #endif
1337 }
1338
1339 void ReportInternalError(const char* aFile, uint32_t aLine, const char* aStr) {
1340 // Get leaf of file path
1341 for (const char* p = aFile; *p; ++p) {
1342 if (*p == '/' && *(p + 1)) {
1343 aFile = p + 1;
1344 }
1345 }
1346
1347 nsContentUtils::LogSimpleConsoleError(
1348 NS_ConvertUTF8toUTF16(
1349 nsPrintfCString("Quota %s: %s:%" PRIu32, aStr, aFile, aLine)),
1350 "quota",
1351 false /* Quota Manager is not active in private browsing mode */);
1352 }
1353
1354 namespace {
1355
1356 StaticRefPtr<QuotaManager> gInstance;
1357 bool gCreateFailed = false;
1358 StaticRefPtr<QuotaManager::CreateRunnable> gCreateRunnable;
1359 mozilla::Atomic<bool> gShutdown(false);
1360
1361 // Constants for temporary storage limit computing.
1362 static const int32_t kDefaultFixedLimitKB = -1;
1363 static const uint32_t kDefaultChunkSizeKB = 10 * 1024;
1364 int32_t gFixedLimitKB = kDefaultFixedLimitKB;
1365 uint32_t gChunkSizeKB = kDefaultChunkSizeKB;
1366
1367 bool gTestingEnabled = false;
1368
1369 class StorageOperationBase : public Runnable {
1370 mozilla::Mutex mMutex;
1371 mozilla::CondVar mCondVar;
1372 nsresult mMainThreadResultCode;
1373 bool mWaiting;
1374
1375 protected:
1376 struct OriginProps;
1377
1378 nsTArray<OriginProps> mOriginProps;
1379
1380 nsCOMPtr<nsIFile> mDirectory;
1381
1382 const bool mPersistent;
1383
1384 public:
1385 StorageOperationBase(nsIFile* aDirectory, bool aPersistent)
1386 : Runnable("dom::quota::StorageOperationBase"),
1387 mMutex("StorageOperationBase::mMutex"),
1388 mCondVar(mMutex, "StorageOperationBase::mCondVar"),
1389 mMainThreadResultCode(NS_OK),
1390 mWaiting(true),
1391 mDirectory(aDirectory),
1392 mPersistent(aPersistent) {
1393 AssertIsOnIOThread();
1394 }
1395
1396 protected:
1397 virtual ~StorageOperationBase() {}
1398
1399 nsresult GetDirectoryMetadata(nsIFile* aDirectory, int64_t& aTimestamp,
1400 nsACString& aGroup, nsACString& aOrigin,
1401 Nullable<bool>& aIsApp);
1402
1403 // Upgrade helper to load the contents of ".metadata-v2" files from previous
1404 // schema versions. Although QuotaManager has a similar GetDirectoryMetadata2
1405 // method, it is only intended to read current version ".metadata-v2" files.
1406 // And unlike the old ".metadata" files, the ".metadata-v2" format can evolve
1407 // because our "storage.sqlite" lets us track the overall version of the
1408 // storage directory.
1409 nsresult GetDirectoryMetadata2(nsIFile* aDirectory, int64_t& aTimestamp,
1410 nsACString& aSuffix, nsACString& aGroup,
1411 nsACString& aOrigin, bool& aIsApp);
1412
1413 nsresult RemoveObsoleteOrigin(const OriginProps& aOriginProps);
1414
1415 nsresult ProcessOriginDirectories();
1416
1417 virtual nsresult ProcessOriginDirectory(const OriginProps& aOriginProps) = 0;
1418
1419 private:
1420 nsresult RunOnMainThread();
1421
1422 NS_IMETHOD
1423 Run() override;
1424 };
1425
1426 struct StorageOperationBase::OriginProps {
1427 enum Type { eChrome, eContent, eObsolete };
1428
1429 nsCOMPtr<nsIFile> mDirectory;
1430 nsString mLeafName;
1431 nsCString mSpec;
1432 OriginAttributes mAttrs;
1433 int64_t mTimestamp;
1434 nsCString mSuffix;
1435 nsCString mGroup;
1436 nsCString mOrigin;
1437
1438 Type mType;
1439 bool mNeedsRestore;
1440 bool mNeedsRestore2;
1441 bool mIgnore;
1442
1443 public:
1444 explicit OriginProps()
1445 : mTimestamp(0),
1446 mType(eContent),
1447 mNeedsRestore(false),
1448 mNeedsRestore2(false),
1449 mIgnore(false) {}
1450
1451 nsresult Init(nsIFile* aDirectory);
1452 };
1453
1454 class MOZ_STACK_CLASS OriginParser final {
1455 public:
1456 enum ResultType { InvalidOrigin, ObsoleteOrigin, ValidOrigin };
1457
1458 private:
1459 static bool IgnoreWhitespace(char16_t /* aChar */) { return false; }
1460
1461 typedef nsCCharSeparatedTokenizerTemplate<IgnoreWhitespace> Tokenizer;
1462
1463 enum SchemeType { eNone, eFile, eAbout };
1464
1465 enum State {
1466 eExpectingAppIdOrScheme,
1467 eExpectingInMozBrowser,
1468 eExpectingScheme,
1469 eExpectingEmptyToken1,
1470 eExpectingEmptyToken2,
1471 eExpectingEmptyTokenOrUniversalFileOrigin,
1472 eExpectingHost,
1473 eExpectingPort,
1474 eExpectingEmptyTokenOrDriveLetterOrPathnameComponent,
1475 eExpectingEmptyTokenOrPathnameComponent,
1476
1477 // We transit from eExpectingHost to this state when we encounter a host
1478 // beginning with "[" which indicates an IPv6 literal. Because we mangle the
1479 // IPv6 ":" delimiter to be a "+", we will receive separate tokens for each
1480 // portion of the IPv6 address, including a final token that ends with "]".
1481 // (Note that we do not mangle "[" or "]".) Note that the URL spec
1482 // explicitly disclaims support for "<zone_id>" and so we don't have to deal
1483 // with that.
1484 eExpectingIPV6Token,
1485 eComplete,
1486 eHandledTrailingSeparator
1487 };
1488
1489 const nsCString mOrigin;
1490 const OriginAttributes mOriginAttributes;
1491 Tokenizer mTokenizer;
1492
1493 uint32_t mAppId;
1494 nsCString mScheme;
1495 nsCString mHost;
1496 Nullable<uint32_t> mPort;
1497 nsTArray<nsCString> mPathnameComponents;
1498 nsCString mHandledTokens;
1499
1500 SchemeType mSchemeType;
1501 State mState;
1502 bool mInIsolatedMozBrowser;
1503 bool mUniversalFileOrigin;
1504 bool mMaybeDriveLetter;
1505 bool mError;
1506
1507 // Number of group which a IPv6 address has. Should be less than 9.
1508 uint8_t mIPGroup;
1509
1510 public:
1511 OriginParser(const nsACString& aOrigin,
1512 const OriginAttributes& aOriginAttributes)
1513 : mOrigin(aOrigin),
1514 mOriginAttributes(aOriginAttributes),
1515 mTokenizer(aOrigin, '+'),
1516 mAppId(kNoAppId),
1517 mPort(),
1518 mSchemeType(eNone),
1519 mState(eExpectingAppIdOrScheme),
1520 mInIsolatedMozBrowser(false),
1521 mUniversalFileOrigin(false),
1522 mMaybeDriveLetter(false),
1523 mError(false),
1524 mIPGroup(0) {}
1525
1526 static ResultType ParseOrigin(const nsACString& aOrigin, nsCString& aSpec,
1527 OriginAttributes* aAttrs);
1528
1529 ResultType Parse(nsACString& aSpec, OriginAttributes* aAttrs);
1530
1531 private:
1532 void HandleScheme(const nsDependentCSubstring& aToken);
1533
1534 void HandlePathnameComponent(const nsDependentCSubstring& aToken);
1535
1536 void HandleToken(const nsDependentCSubstring& aToken);
1537
1538 void HandleTrailingSeparator();
1539 };
1540
1541 class RepositoryOperationBase : public StorageOperationBase {
1542 public:
1543 RepositoryOperationBase(nsIFile* aDirectory, bool aPersistent)
1544 : StorageOperationBase(aDirectory, aPersistent) {}
1545
1546 nsresult ProcessRepository();
1547
1548 protected:
1549 virtual ~RepositoryOperationBase() {}
1550
1551 template <typename UpgradeMethod>
1552 nsresult MaybeUpgradeClients(const OriginProps& aOriginsProps,
1553 UpgradeMethod aMethod);
1554
1555 private:
1556 virtual nsresult PrepareOriginDirectory(OriginProps& aOriginProps,
1557 bool* aRemoved) = 0;
1558 };
1559
1560 class CreateOrUpgradeDirectoryMetadataHelper final
1561 : public RepositoryOperationBase {
1562 nsCOMPtr<nsIFile> mPermanentStorageDir;
1563
1564 public:
1565 CreateOrUpgradeDirectoryMetadataHelper(nsIFile* aDirectory, bool aPersistent)
1566 : RepositoryOperationBase(aDirectory, aPersistent) {}
1567
1568 private:
1569 nsresult MaybeUpgradeOriginDirectory(nsIFile* aDirectory);
1570
1571 nsresult PrepareOriginDirectory(OriginProps& aOriginProps,
1572 bool* aRemoved) override;
1573
1574 nsresult ProcessOriginDirectory(const OriginProps& aOriginProps) override;
1575 };
1576
1577 class UpgradeStorageFrom0_0To1_0Helper final : public RepositoryOperationBase {
1578 public:
1579 UpgradeStorageFrom0_0To1_0Helper(nsIFile* aDirectory, bool aPersistent)
1580 : RepositoryOperationBase(aDirectory, aPersistent) {}
1581
1582 private:
1583 nsresult PrepareOriginDirectory(OriginProps& aOriginProps,
1584 bool* aRemoved) override;
1585
1586 nsresult ProcessOriginDirectory(const OriginProps& aOriginProps) override;
1587 };
1588
1589 class UpgradeStorageFrom1_0To2_0Helper final : public RepositoryOperationBase {
1590 public:
1591 UpgradeStorageFrom1_0To2_0Helper(nsIFile* aDirectory, bool aPersistent)
1592 : RepositoryOperationBase(aDirectory, aPersistent) {}
1593
1594 private:
1595 nsresult MaybeRemoveMorgueDirectory(const OriginProps& aOriginProps);
1596
1597 nsresult MaybeRemoveAppsData(const OriginProps& aOriginProps, bool* aRemoved);
1598
1599 nsresult MaybeStripObsoleteOriginAttributes(const OriginProps& aOriginProps,
1600 bool* aStripped);
1601
1602 nsresult PrepareOriginDirectory(OriginProps& aOriginProps,
1603 bool* aRemoved) override;
1604
1605 nsresult ProcessOriginDirectory(const OriginProps& aOriginProps) override;
1606 };
1607
1608 class UpgradeStorageFrom2_0To2_1Helper final : public RepositoryOperationBase {
1609 public:
1610 UpgradeStorageFrom2_0To2_1Helper(nsIFile* aDirectory, bool aPersistent)
1611 : RepositoryOperationBase(aDirectory, aPersistent) {}
1612
1613 private:
1614 nsresult PrepareOriginDirectory(OriginProps& aOriginProps,
1615 bool* aRemoved) override;
1616
1617 nsresult ProcessOriginDirectory(const OriginProps& aOriginProps) override;
1618 };
1619
1620 class RestoreDirectoryMetadata2Helper final : public StorageOperationBase {
1621 public:
1622 RestoreDirectoryMetadata2Helper(nsIFile* aDirectory, bool aPersistent)
1623 : StorageOperationBase(aDirectory, aPersistent) {}
1624
1625 nsresult RestoreMetadata2File();
1626
1627 private:
1628 nsresult ProcessOriginDirectory(const OriginProps& aOriginProps) override;
1629 };
1630
1631 void SanitizeOriginString(nsCString& aOrigin) {
1632 #ifdef XP_WIN
1633 NS_ASSERTION(!strcmp(QuotaManager::kReplaceChars,
1634 FILE_ILLEGAL_CHARACTERS FILE_PATH_SEPARATOR),
1635 "Illegal file characters have changed!");
1636 #endif
1637
1638 aOrigin.ReplaceChar(QuotaManager::kReplaceChars, '+');
1639 }
1640
1641 nsresult CloneStoragePath(nsIFile* aBaseDir, const nsAString& aStorageName,
1642 nsAString& aStoragePath) {
1643 nsresult rv;
1644
1645 nsCOMPtr<nsIFile> storageDir;
1646 rv = aBaseDir->Clone(getter_AddRefs(storageDir));
1647 if (NS_WARN_IF(NS_FAILED(rv))) {
1648 return rv;
1649 }
1650
1651 rv = storageDir->Append(aStorageName);
1652 if (NS_WARN_IF(NS_FAILED(rv))) {
1653 return rv;
1654 }
1655
1656 rv = storageDir->GetPath(aStoragePath);
1657 if (NS_WARN_IF(NS_FAILED(rv))) {
1658 return rv;
1659 }
1660
1661 return NS_OK;
1662 }
1663
1664 int64_t GetLastModifiedTime(nsIFile* aFile, bool aPersistent) {
1665 AssertIsOnIOThread();
1666 MOZ_ASSERT(aFile);
1667
1668 class MOZ_STACK_CLASS Helper final {
1669 public:
1670 static nsresult GetLastModifiedTime(nsIFile* aFile, int64_t* aTimestamp) {
1671 AssertIsOnIOThread();
1672 MOZ_ASSERT(aFile);
1673 MOZ_ASSERT(aTimestamp);
1674
1675 bool isDirectory;
1676 nsresult rv = aFile->IsDirectory(&isDirectory);
1677 if (NS_WARN_IF(NS_FAILED(rv))) {
1678 return rv;
1679 }
1680
1681 if (!isDirectory) {
1682 nsString leafName;
1683 rv = aFile->GetLeafName(leafName);
1684 if (NS_WARN_IF(NS_FAILED(rv))) {
1685 return rv;
1686 }
1687
1688 if (IsOriginMetadata(leafName) || IsTempMetadata(leafName) ||
1689 IsDotFile(leafName)) {
1690 return NS_OK;
1691 }
1692
1693 int64_t timestamp;
1694 rv = aFile->GetLastModifiedTime(&timestamp);
1695 if (NS_WARN_IF(NS_FAILED(rv))) {
1696 return rv;
1697 }
1698
1699 // Need to convert from milliseconds to microseconds.
1700 MOZ_ASSERT((INT64_MAX / PR_USEC_PER_MSEC) > timestamp);
1701 timestamp *= int64_t(PR_USEC_PER_MSEC);
1702
1703 if (timestamp > *aTimestamp) {
1704 *aTimestamp = timestamp;
1705 }
1706 return NS_OK;
1707 }
1708
1709 nsCOMPtr<nsIDirectoryEnumerator> entries;
1710 rv = aFile->GetDirectoryEntries(getter_AddRefs(entries));
1711 if (NS_WARN_IF(NS_FAILED(rv))) {
1712 return rv;
1713 }
1714
1715 nsCOMPtr<nsIFile> file;
1716 while (NS_SUCCEEDED((rv = entries->GetNextFile(getter_AddRefs(file)))) &&
1717 file) {
1718 rv = GetLastModifiedTime(file, aTimestamp);
1719 if (NS_WARN_IF(NS_FAILED(rv))) {
1720 return rv;
1721 }
1722 }
1723 if (NS_WARN_IF(NS_FAILED(rv))) {
1724 return rv;
1725 }
1726
1727 return NS_OK;
1728 }
1729 };
1730
1731 if (aPersistent) {
1732 return PR_Now();
1733 }
1734
1735 int64_t timestamp = INT64_MIN;
1736 nsresult rv = Helper::GetLastModifiedTime(aFile, &timestamp);
1737 if (NS_FAILED(rv)) {
1738 timestamp = PR_Now();
1739 }
1740
1741 return timestamp;
1742 }
1743
1744 nsresult EnsureDirectory(nsIFile* aDirectory, bool* aCreated) {
1745 AssertIsOnIOThread();
1746
1747 nsresult rv = aDirectory->Create(nsIFile::DIRECTORY_TYPE, 0755);
1748 if (rv == NS_ERROR_FILE_ALREADY_EXISTS) {
1749 bool isDirectory;
1750 rv = aDirectory->IsDirectory(&isDirectory);
1751 NS_ENSURE_SUCCESS(rv, rv);
1752 NS_ENSURE_TRUE(isDirectory, NS_ERROR_UNEXPECTED);
1753
1754 *aCreated = false;
1755 } else {
1756 NS_ENSURE_SUCCESS(rv, rv);
1757
1758 *aCreated = true;
1759 }
1760
1761 return NS_OK;
1762 }
1763
1764 enum FileFlag { kTruncateFileFlag, kUpdateFileFlag, kAppendFileFlag };
1765
1766 nsresult GetOutputStream(nsIFile* aFile, FileFlag aFileFlag,
1767 nsIOutputStream** aStream) {
1768 AssertIsOnIOThread();
1769
1770 nsresult rv;
1771
1772 nsCOMPtr<nsIOutputStream> outputStream;
1773 switch (aFileFlag) {
1774 case kTruncateFileFlag: {
1775 rv = NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), aFile);
1776 if (NS_WARN_IF(NS_FAILED(rv))) {
1777 return rv;
1778 }
1779
1780 break;
1781 }
1782
1783 case kUpdateFileFlag: {
1784 bool exists;
1785 rv = aFile->Exists(&exists);
1786 if (NS_WARN_IF(NS_FAILED(rv))) {
1787 return rv;
1788 }
1789
1790 if (!exists) {
1791 *aStream = nullptr;
1792 return NS_OK;
1793 }
1794
1795 nsCOMPtr<nsIFileStream> stream;
1796 rv = NS_NewLocalFileStream(getter_AddRefs(stream), aFile);
1797 if (NS_WARN_IF(NS_FAILED(rv))) {
1798 return rv;
1799 }
1800
1801 outputStream = do_QueryInterface(stream);
1802 if (NS_WARN_IF(!outputStream)) {
1803 return NS_ERROR_FAILURE;
1804 }
1805
1806 break;
1807 }
1808
1809 case kAppendFileFlag: {
1810 rv = NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), aFile,
1811 PR_WRONLY | PR_CREATE_FILE | PR_APPEND);
1812 if (NS_WARN_IF(NS_FAILED(rv))) {
1813 return rv;
1814 }
1815
1816 break;
1817 }
1818
1819 default:
1820 MOZ_CRASH("Should never get here!");
1821 }
1822
1823 outputStream.forget(aStream);
1824 return NS_OK;
1825 }
1826
1827 nsresult GetBinaryOutputStream(nsIFile* aFile, FileFlag aFileFlag,
1828 nsIBinaryOutputStream** aStream) {
1829 nsCOMPtr<nsIOutputStream> outputStream;
1830 nsresult rv = GetOutputStream(aFile, aFileFlag, getter_AddRefs(outputStream));
1831 if (NS_WARN_IF(NS_FAILED(rv))) {
1832 return rv;
1833 }
1834
1835 if (NS_WARN_IF(!outputStream)) {
1836 return NS_ERROR_UNEXPECTED;
1837 }
1838
1839 nsCOMPtr<nsIObjectOutputStream> objectOutputStream =
1840 NS_NewObjectOutputStream(outputStream);
1841
1842 objectOutputStream.forget(aStream);
1843 return NS_OK;
1844 }
1845
1846 void GetJarPrefix(uint32_t aAppId, bool aInIsolatedMozBrowser,
1847 nsACString& aJarPrefix) {
1848 MOZ_ASSERT(aAppId != nsIScriptSecurityManager::UNKNOWN_APP_ID);
1849
1850 if (aAppId == nsIScriptSecurityManager::UNKNOWN_APP_ID) {
1851 aAppId = nsIScriptSecurityManager::NO_APP_ID;
1852 }
1853
1854 aJarPrefix.Truncate();
1855
1856 // Fallback.
1857 if (aAppId == nsIScriptSecurityManager::NO_APP_ID && !aInIsolatedMozBrowser) {
1858 return;
1859 }
1860
1861 // aJarPrefix = appId + "+" + { 't', 'f' } + "+";
1862 aJarPrefix.AppendInt(aAppId);
1863 aJarPrefix.Append('+');
1864 aJarPrefix.Append(aInIsolatedMozBrowser ? 't' : 'f');
1865 aJarPrefix.Append('+');
1866 }
1867
1868 nsresult CreateDirectoryMetadata(nsIFile* aDirectory, int64_t aTimestamp,
1869 const nsACString& aSuffix,
1870 const nsACString& aGroup,
1871 const nsACString& aOrigin) {
1872 AssertIsOnIOThread();
1873
1874 OriginAttributes groupAttributes;
1875
1876 nsCString groupNoSuffix;
1877 bool ok = groupAttributes.PopulateFromOrigin(aGroup, groupNoSuffix);
1878 if (!ok) {
1879 return NS_ERROR_FAILURE;
1880 }
1881
1882 nsCString groupPrefix;
1883 GetJarPrefix(groupAttributes.mAppId, groupAttributes.mInIsolatedMozBrowser,
1884 groupPrefix);
1885
1886 nsCString group = groupPrefix + groupNoSuffix;
1887
1888 OriginAttributes originAttributes;
1889
1890 nsCString originNoSuffix;
1891 ok = originAttributes.PopulateFromOrigin(aOrigin, originNoSuffix);
1892 if (!ok) {
1893 return NS_ERROR_FAILURE;
1894 }
1895
1896 nsCString originPrefix;
1897 GetJarPrefix(originAttributes.mAppId, originAttributes.mInIsolatedMozBrowser,
1898 originPrefix);
1899
1900 nsCString origin = originPrefix + originNoSuffix;
1901
1902 MOZ_ASSERT(groupPrefix == originPrefix);
1903
1904 nsCOMPtr<nsIFile> file;
1905 nsresult rv = aDirectory->Clone(getter_AddRefs(file));
1906 if (NS_WARN_IF(NS_FAILED(rv))) {
1907 return rv;
1908 }
1909
1910 rv = file->Append(NS_LITERAL_STRING(METADATA_TMP_FILE_NAME));
1911 if (NS_WARN_IF(NS_FAILED(rv))) {
1912 return rv;
1913 }
1914
1915 nsCOMPtr<nsIBinaryOutputStream> stream;
1916 rv = GetBinaryOutputStream(file, kTruncateFileFlag, getter_AddRefs(stream));
1917 if (NS_WARN_IF(NS_FAILED(rv))) {
1918 return rv;
1919 }
1920
1921 MOZ_ASSERT(stream);
1922
1923 rv = stream->Write64(aTimestamp);
1924 if (NS_WARN_IF(NS_FAILED(rv))) {
1925 return rv;
1926 }
1927
1928 rv = stream->WriteStringZ(group.get());
1929 if (NS_WARN_IF(NS_FAILED(rv))) {
1930 return rv;
1931 }
1932
1933 rv = stream->WriteStringZ(origin.get());
1934 if (NS_WARN_IF(NS_FAILED(rv))) {
1935 return rv;
1936 }
1937
1938 // Currently unused (used to be isApp).
1939 rv = stream->WriteBoolean(false);
1940 if (NS_WARN_IF(NS_FAILED(rv))) {
1941 return rv;
1942 }
1943
1944 rv = stream->Flush();
1945 if (NS_WARN_IF(NS_FAILED(rv))) {
1946 return rv;
1947 }
1948
1949 rv = stream->Close();
1950 if (NS_WARN_IF(NS_FAILED(rv))) {
1951 return rv;
1952 }
1953
1954 rv = file->RenameTo(nullptr, NS_LITERAL_STRING(METADATA_FILE_NAME));
1955 if (NS_WARN_IF(NS_FAILED(rv))) {
1956 return rv;
1957 }
1958
1959 return NS_OK;
1960 }
1961
1962 nsresult CreateDirectoryMetadata2(nsIFile* aDirectory, int64_t aTimestamp,
1963 bool aPersisted, const nsACString& aSuffix,
1964 const nsACString& aGroup,
1965 const nsACString& aOrigin) {
1966 AssertIsOnIOThread();
1967 MOZ_ASSERT(aDirectory);
1968
1969 nsCOMPtr<nsIFile> file;
1970 nsresult rv = aDirectory->Clone(getter_AddRefs(file));
1971 if (NS_WARN_IF(NS_FAILED(rv))) {
1972 return rv;
1973 }
1974
1975 rv = file->Append(NS_LITERAL_STRING(METADATA_V2_TMP_FILE_NAME));
1976 if (NS_WARN_IF(NS_FAILED(rv))) {
1977 return rv;
1978 }
1979
1980 nsCOMPtr<nsIBinaryOutputStream> stream;
1981 rv = GetBinaryOutputStream(file, kTruncateFileFlag, getter_AddRefs(stream));
1982 if (NS_WARN_IF(NS_FAILED(rv))) {
1983 return rv;
1984 }
1985
1986 MOZ_ASSERT(stream);
1987
1988 rv = stream->Write64(aTimestamp);
1989 if (NS_WARN_IF(NS_FAILED(rv))) {
1990 return rv;
1991 }
1992
1993 rv = stream->WriteBoolean(aPersisted);
1994 if (NS_WARN_IF(NS_FAILED(rv))) {
1995 return rv;
1996 }
1997
1998 // Reserved data 1
1999 rv = stream->Write32(0);
2000 if (NS_WARN_IF(NS_FAILED(rv))) {
2001 return rv;
2002 }
2003
2004 // Reserved data 2
2005 rv = stream->Write32(0);
2006 if (NS_WARN_IF(NS_FAILED(rv))) {
2007 return rv;
2008 }
2009
2010 // The suffix isn't used right now, but we might need it in future. It's
2011 // a bit of redundancy we can live with given how painful is to upgrade
2012 // metadata files.
2013 rv = stream->WriteStringZ(PromiseFlatCString(aSuffix).get());
2014 if (NS_WARN_IF(NS_FAILED(rv))) {
2015 return rv;
2016 }
2017
2018 rv = stream->WriteStringZ(PromiseFlatCString(aGroup).get());
2019 if (NS_WARN_IF(NS_FAILED(rv))) {
2020 return rv;
2021 }
2022
2023 rv = stream->WriteStringZ(PromiseFlatCString(aOrigin).get());
2024 if (NS_WARN_IF(NS_FAILED(rv))) {
2025 return rv;
2026 }
2027
2028 // Currently unused (used to be isApp).
2029 rv = stream->WriteBoolean(false);
2030 if (NS_WARN_IF(NS_FAILED(rv))) {
2031 return rv;
2032 }
2033
2034 rv = stream->Flush();
2035 if (NS_WARN_IF(NS_FAILED(rv))) {
2036 return rv;
2037 }
2038
2039 rv = stream->Close();
2040 if (NS_WARN_IF(NS_FAILED(rv))) {
2041 return rv;
2042 }
2043
2044 rv = file->RenameTo(nullptr, NS_LITERAL_STRING(METADATA_V2_FILE_NAME));
2045 if (NS_WARN_IF(NS_FAILED(rv))) {
2046 return rv;
2047 }
2048
2049 return NS_OK;
2050 }
2051
2052 nsresult CreateDirectoryMetadataFiles(nsIFile* aDirectory, bool aPersisted,
2053 const nsACString& aSuffix,
2054 const nsACString& aGroup,
2055 const nsACString& aOrigin,
2056 int64_t* aTimestamp) {
2057 AssertIsOnIOThread();
2058
2059 int64_t timestamp = PR_Now();
2060
2061 nsresult rv =
2062 CreateDirectoryMetadata(aDirectory, timestamp, aSuffix, aGroup, aOrigin);
2063 if (NS_WARN_IF(NS_FAILED(rv))) {
2064 return rv;
2065 }
2066
2067 rv = CreateDirectoryMetadata2(aDirectory, timestamp, aPersisted, aSuffix,
2068 aGroup, aOrigin);
2069 if (NS_WARN_IF(NS_FAILED(rv))) {
2070 return rv;
2071 }
2072
2073 if (aTimestamp) {
2074 *aTimestamp = timestamp;
2075 }
2076 return NS_OK;
2077 }
2078
2079 nsresult GetBinaryInputStream(nsIFile* aDirectory, const nsAString& aFilename,
2080 nsIBinaryInputStream** aStream) {
2081 MOZ_ASSERT(!NS_IsMainThread());
2082 MOZ_ASSERT(aDirectory);
2083 MOZ_ASSERT(aStream);
2084
2085 nsCOMPtr<nsIFile> file;
2086 nsresult rv = aDirectory->Clone(getter_AddRefs(file));
2087 if (NS_WARN_IF(NS_FAILED(rv))) {
2088 return rv;
2089 }
2090
2091 rv = file->Append(aFilename);
2092 if (NS_WARN_IF(NS_FAILED(rv))) {
2093 return rv;
2094 }
2095
2096 nsCOMPtr<nsIInputStream> stream;
2097 rv = NS_NewLocalFileInputStream(getter_AddRefs(stream), file);
2098 if (NS_WARN_IF(NS_FAILED(rv))) {
2099 return rv;
2100 }
2101
2102 nsCOMPtr<nsIInputStream> bufferedStream;
2103 rv = NS_NewBufferedInputStream(getter_AddRefs(bufferedStream),
2104 stream.forget(), 512);
2105 if (NS_WARN_IF(NS_FAILED(rv))) {
2106 return rv;
2107 }
2108
2109 nsCOMPtr<nsIBinaryInputStream> binaryStream =
2110 do_CreateInstance("@mozilla.org/binaryinputstream;1");
2111 if (NS_WARN_IF(!binaryStream)) {
2112 return NS_ERROR_FAILURE;
2113 }
2114
2115 rv = binaryStream->SetInputStream(bufferedStream);
2116 if (NS_WARN_IF(NS_FAILED(rv))) {
2117 return rv;
2118 }
2119
2120 binaryStream.forget(aStream);
2121 return NS_OK;
2122 }
2123
2124 // This method computes and returns our best guess for the temporary storage
2125 // limit (in bytes), based on the amount of space users have free on their hard
2126 // drive and on given temporary storage usage (also in bytes).
2127 nsresult GetTemporaryStorageLimit(nsIFile* aDirectory, uint64_t aCurrentUsage,
2128 uint64_t* aLimit) {
2129 // Check for free space on device where temporary storage directory lives.
2130 int64_t bytesAvailable;
2131 nsresult rv = aDirectory->GetDiskSpaceAvailable(&bytesAvailable);
2132 NS_ENSURE_SUCCESS(rv, rv);
2133
2134 NS_ASSERTION(bytesAvailable >= 0, "Negative bytes available?!");
2135
2136 uint64_t availableKB =
2137 static_cast<uint64_t>((bytesAvailable + aCurrentUsage) / 1024);
2138
2139 // Grow/shrink in gChunkSizeKB units, deliberately, so that in the common case
2140 // we don't shrink temporary storage and evict origin data every time we
2141 // initialize.
2142 availableKB = (availableKB / gChunkSizeKB) * gChunkSizeKB;
2143
2144 // Allow temporary storage to consume up to half the available space.
2145 uint64_t resultKB = availableKB * .50;
2146
2147 *aLimit = resultKB * 1024;
2148 return NS_OK;
2149 }
2150
2151 } // namespace
2152
2153 /*******************************************************************************
2154 * Exported functions
2155 ******************************************************************************/
2156
2157 PQuotaParent* AllocPQuotaParent() {
2158 AssertIsOnBackgroundThread();
2159
2160 if (NS_WARN_IF(QuotaManager::IsShuttingDown())) {
2161 return nullptr;
2162 }
2163
2164 RefPtr<Quota> actor = new Quota();
2165
2166 return actor.forget().take();
2167 }
2168
2169 bool DeallocPQuotaParent(PQuotaParent* aActor) {
2170 AssertIsOnBackgroundThread();
2171 MOZ_ASSERT(aActor);
2172
2173 RefPtr<Quota> actor = dont_AddRef(static_cast<Quota*>(aActor));
2174 return true;
2175 }
2176
2177 /*******************************************************************************
2178 * Directory lock
2179 ******************************************************************************/
2180
2181 DirectoryLockImpl::DirectoryLockImpl(
2182 QuotaManager* aQuotaManager,
2183 const Nullable<PersistenceType>& aPersistenceType, const nsACString& aGroup,
2184 const OriginScope& aOriginScope, const Nullable<Client::Type>& aClientType,
2185 bool aExclusive, bool aInternal, OpenDirectoryListener* aOpenListener)
2186 : mQuotaManager(aQuotaManager),
2187 mPersistenceType(aPersistenceType),
2188 mGroup(aGroup),
2189 mOriginScope(aOriginScope),
2190 mClientType(aClientType),
2191 mOpenListener(aOpenListener),
2192 mExclusive(aExclusive),
2193 mInternal(aInternal),
2194 mInvalidated(false) {
2195 AssertIsOnOwningThread();
2196 MOZ_ASSERT(aQuotaManager);
2197 MOZ_ASSERT_IF(aOriginScope.IsOrigin(), !aOriginScope.GetOrigin().IsEmpty());
2198 MOZ_ASSERT_IF(!aInternal, !aPersistenceType.IsNull());
2199 MOZ_ASSERT_IF(!aInternal,
2200 aPersistenceType.Value() != PERSISTENCE_TYPE_INVALID);
2201 MOZ_ASSERT_IF(!aInternal, !aGroup.IsEmpty());
2202 MOZ_ASSERT_IF(!aInternal, aOriginScope.IsOrigin());
2203 MOZ_ASSERT_IF(!aInternal, !aClientType.IsNull());
2204 MOZ_ASSERT_IF(!aInternal, aClientType.Value() < Client::TypeMax());
2205 MOZ_ASSERT_IF(!aInternal, aOpenListener);
2206 }
2207
2208 DirectoryLockImpl::~DirectoryLockImpl() {
2209 AssertIsOnOwningThread();
2210 MOZ_ASSERT(mQuotaManager);
2211
2212 for (DirectoryLockImpl* blockingLock : mBlocking) {
2213 blockingLock->MaybeUnblock(this);
2214 }
2215
2216 mBlocking.Clear();
2217
2218 mQuotaManager->UnregisterDirectoryLock(this);
2219 }
2220
2221 #ifdef DEBUG
2222
2223 void DirectoryLockImpl::AssertIsOnOwningThread() const {
2224 MOZ_ASSERT(mQuotaManager);
2225 mQuotaManager->AssertIsOnOwningThread();
2226 }
2227
2228 #endif // DEBUG
2229
2230 bool DirectoryLockImpl::MustWaitFor(const DirectoryLockImpl& aExistingLock) {
2231 AssertIsOnOwningThread();
2232
2233 // Waiting is never required if the ops in comparison represent shared locks.
2234 if (!aExistingLock.mExclusive && !mExclusive) {
2235 return false;
2236 }
2237
2238 // If the persistence types don't overlap, the op can proceed.
2239 if (!aExistingLock.mPersistenceType.IsNull() && !mPersistenceType.IsNull() &&
2240 aExistingLock.mPersistenceType.Value() != mPersistenceType.Value()) {
2241 return false;
2242 }
2243
2244 // If the origin scopes don't overlap, the op can proceed.
2245 bool match = aExistingLock.mOriginScope.Matches(mOriginScope);
2246 if (!match) {
2247 return false;
2248 }
2249
2250 // If the client types don't overlap, the op can proceed.
2251 if (!aExistingLock.mClientType.IsNull() && !mClientType.IsNull() &&
2252 aExistingLock.mClientType.Value() != mClientType.Value()) {
2253 return false;
2254 }
2255
2256 // Otherwise, when all attributes overlap (persistence type, origin scope and
2257 // client type) the op must wait.
2258 return true;
2259 }
2260
2261 void DirectoryLockImpl::NotifyOpenListener() {
2262 AssertIsOnOwningThread();
2263 MOZ_ASSERT(mQuotaManager);
2264 MOZ_ASSERT(mOpenListener);
2265
2266 if (mInvalidated) {
2267 mOpenListener->DirectoryLockFailed();
2268 } else {
2269 mOpenListener->DirectoryLockAcquired(this);
2270 }
2271
2272 mOpenListener = nullptr;
2273
2274 mQuotaManager->RemovePendingDirectoryLock(this);
2275 }
2276
2277 nsresult QuotaManager::CreateRunnable::Init() {
2278 MOZ_ASSERT(NS_IsMainThread());
2279 MOZ_ASSERT(mState == State::Initial);
2280
2281 nsresult rv;
2282
2283 nsCOMPtr<nsIFile> baseDir;
2284 rv = NS_GetSpecialDirectory(NS_APP_INDEXEDDB_PARENT_DIR,
2285 getter_AddRefs(baseDir));
2286 if (NS_FAILED(rv)) {
2287 rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
2288 getter_AddRefs(baseDir));
2289 }
2290 if (NS_WARN_IF(NS_FAILED(rv))) {
2291 return rv;
2292 }
2293
2294 rv = baseDir->GetPath(mBaseDirPath);
2295 if (NS_WARN_IF(NS_FAILED(rv))) {
2296 return rv;
2297 }
2298
2299 Unused << NextGenLocalStorageEnabled();
2300
2301 return NS_OK;
2302 }
2303
2304 nsresult QuotaManager::CreateRunnable::CreateManager() {
2305 AssertIsOnOwningThread();
2306 MOZ_ASSERT(mState == State::CreatingManager);
2307
2308 mManager = new QuotaManager();
2309
2310 nsresult rv = mManager->Init(mBaseDirPath);
2311 if (NS_WARN_IF(NS_FAILED(rv))) {
2312 return rv;
2313 }
2314
2315 return NS_OK;
2316 }
2317
2318 nsresult QuotaManager::CreateRunnable::RegisterObserver() {
2319 MOZ_ASSERT(NS_IsMainThread());
2320 MOZ_ASSERT(mState == State::RegisteringObserver);
2321
2322 if (NS_FAILED(Preferences::AddIntVarCache(&gFixedLimitKB, PREF_FIXED_LIMIT,
2323 kDefaultFixedLimitKB)) ||
2324 NS_FAILED(Preferences::AddUintVarCache(&gChunkSizeKB, PREF_CHUNK_SIZE,
2325 kDefaultChunkSizeKB))) {
2326 NS_WARNING("Unable to respond to temp storage pref changes!");
2327 }
2328
2329 if (NS_FAILED(Preferences::AddBoolVarCache(&gTestingEnabled,
2330 PREF_TESTING_FEATURES, false))) {
2331 NS_WARNING("Unable to respond to testing pref changes!");
2332 }
2333
2334 nsCOMPtr<nsIObserverService> observerService =
2335 mozilla::services::GetObserverService();
2336 if (NS_WARN_IF(!observerService)) {
2337 return NS_ERROR_FAILURE;
2338 }
2339
2340 nsCOMPtr<nsIObserver> observer = new ShutdownObserver(mOwningThread);
2341
2342 nsresult rv = observerService->AddObserver(
2343 observer, PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID, false);
2344 if (NS_WARN_IF(NS_FAILED(rv))) {
2345 return rv;
2346 }
2347
2348 // This service has to be started on the main thread currently.
2349 nsCOMPtr<mozIStorageService> ss =
2350 do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID, &rv);
2351 if (NS_WARN_IF(NS_FAILED(rv))) {
2352 return rv;
2353 }
2354
2355 QuotaManagerService* qms = QuotaManagerService::GetOrCreate();
2356 if (NS_WARN_IF(!qms)) {
2357 return rv;
2358 }
2359
2360 qms->NoteLiveManager(mManager);
2361
2362 for (RefPtr<Client>& client : mManager->mClients) {
2363 client->DidInitialize(mManager);
2364 }
2365
2366 return NS_OK;
2367 }
2368
2369 void QuotaManager::CreateRunnable::CallCallbacks() {
2370 AssertIsOnOwningThread();
2371 MOZ_ASSERT(mState == State::CallingCallbacks);
2372
2373 gCreateRunnable = nullptr;
2374
2375 if (NS_FAILED(mResultCode)) {
2376 gCreateFailed = true;
2377 } else {
2378 gInstance = mManager;
2379 }
2380
2381 mManager = nullptr;
2382
2383 nsTArray<nsCOMPtr<nsIRunnable>> callbacks;
2384 mCallbacks.SwapElements(callbacks);
2385
2386 for (nsCOMPtr<nsIRunnable>& callback : callbacks) {
2387 Unused << callback->Run();
2388 }
2389 }
2390
2391 auto QuotaManager::CreateRunnable::GetNextState(
2392 nsCOMPtr<nsIEventTarget>& aThread) -> State {
2393 switch (mState) {
2394 case State::Initial:
2395 aThread = mOwningThread;
2396 return State::CreatingManager;
2397 case State::CreatingManager:
2398 if (mMainEventTarget) {
2399 aThread = mMainEventTarget;
2400 } else {
2401 aThread = GetMainThreadEventTarget();
2402 }
2403 return State::RegisteringObserver;
2404 case State::RegisteringObserver:
2405 aThread = mOwningThread;
2406 return State::CallingCallbacks;
2407 case State::CallingCallbacks:
2408 aThread = nullptr;
2409 return State::Completed;
2410 default:
2411 MOZ_CRASH("Bad state!");
2412 }
2413 }
2414
2415 NS_IMETHODIMP
2416 QuotaManager::CreateRunnable::Run() {
2417 nsresult rv;
2418
2419 switch (mState) {
2420 case State::Initial:
2421 rv = Init();
2422 break;
2423
2424 case State::CreatingManager:
2425 rv = CreateManager();
2426 break;
2427
2428 case State::RegisteringObserver:
2429 rv = RegisterObserver();
2430 break;
2431
2432 case State::CallingCallbacks:
2433 CallCallbacks();
2434 rv = NS_OK;
2435 break;
2436
2437 case State::Completed:
2438 default:
2439 MOZ_CRASH("Bad state!");
2440 }
2441
2442 nsCOMPtr<nsIEventTarget> thread;
2443 if (NS_WARN_IF(NS_FAILED(rv))) {
2444 if (NS_SUCCEEDED(mResultCode)) {
2445 mResultCode = rv;
2446 }
2447
2448 mState = State::CallingCallbacks;
2449 thread = mOwningThread;
2450 } else {
2451 mState = GetNextState(thread);
2452 }
2453
2454 if (thread) {
2455 MOZ_ALWAYS_SUCCEEDS(thread->Dispatch(this, NS_DISPATCH_NORMAL));
2456 }
2457
2458 return NS_OK;
2459 }
2460
2461 NS_IMETHODIMP
2462 QuotaManager::ShutdownRunnable::Run() {
2463 if (NS_IsMainThread()) {
2464 mDone = true;
2465
2466 return NS_OK;
2467 }
2468
2469 AssertIsOnBackgroundThread();
2470
2471 RefPtr<QuotaManager> quotaManager = gInstance.get();
2472 if (quotaManager) {
2473 quotaManager->Shutdown();
2474
2475 gInstance = nullptr;
2476 }
2477
2478 MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
2479
2480 return NS_OK;
2481 }
2482
2483 NS_IMPL_ISUPPORTS(QuotaManager::ShutdownObserver, nsIObserver)
2484
2485 NS_IMETHODIMP
2486 QuotaManager::ShutdownObserver::Observe(nsISupports* aSubject,
2487 const char* aTopic,
2488 const char16_t* aData) {
2489 MOZ_ASSERT(NS_IsMainThread());
2490 MOZ_ASSERT(!strcmp(aTopic, PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID));
2491 MOZ_ASSERT(gInstance);
2492
2493 nsCOMPtr<nsIObserverService> observerService =
2494 mozilla::services::GetObserverService();
2495 if (NS_WARN_IF(!observerService)) {
2496 return NS_ERROR_FAILURE;
2497 }
2498
2499 // Unregister ourselves from the observer service first to make sure the
2500 // nested event loop below will not cause re-entrancy issues.
2501 Unused << observerService->RemoveObserver(
2502 this, PROFILE_BEFORE_CHANGE_QM_OBSERVER_ID);
2503
2504 QuotaManagerService* qms = QuotaManagerService::Get();
2505 MOZ_ASSERT(qms);
2506
2507 qms->NoteShuttingDownManager();
2508
2509 for (RefPtr<Client>& client : gInstance->mClients) {
2510 client->WillShutdown();
2511 }
2512
2513 bool done = false;
2514
2515 RefPtr<ShutdownRunnable> shutdownRunnable = new ShutdownRunnable(done);
2516 MOZ_ALWAYS_SUCCEEDS(
2517 mBackgroundThread->Dispatch(shutdownRunnable, NS_DISPATCH_NORMAL));
2518
2519 MOZ_ALWAYS_TRUE(SpinEventLoopUntil([&]() { return done; }));
2520
2521 return NS_OK;
2522 }
2523
2524 /*******************************************************************************
2525 * Quota object
2526 ******************************************************************************/
2527
2528 void QuotaObject::AddRef() {
2529 QuotaManager* quotaManager = QuotaManager::Get();
2530 if (!quotaManager) {
2531 NS_ERROR("Null quota manager, this shouldn't happen, possible leak!");
2532
2533 ++mRefCnt;
2534
2535 return;
2536 }
2537
2538 MutexAutoLock lock(quotaManager->mQuotaMutex);
2539
2540 ++mRefCnt;
2541 }
2542
2543 void QuotaObject::Release() {
2544 QuotaManager* quotaManager = QuotaManager::Get();
2545 if (!quotaManager) {
2546 NS_ERROR("Null quota manager, this shouldn't happen, possible leak!");
2547
2548 nsrefcnt count = --mRefCnt;
2549 if (count == 0) {
2550 mRefCnt = 1;
2551 delete this;
2552 }
2553
2554 return;
2555 }
2556
2557 {
2558 MutexAutoLock lock(quotaManager->mQuotaMutex);
2559
2560 --mRefCnt;
2561
2562 if (mRefCnt > 0) {
2563 return;
2564 }
2565
2566 if (mOriginInfo) {
2567 mOriginInfo->mQuotaObjects.Remove(mPath);
2568 }
2569 }
2570
2571 delete this;
2572 }
2573
2574 bool QuotaObject::MaybeUpdateSize(int64_t aSize, bool aTruncate) {
2575 QuotaManager* quotaManager = QuotaManager::Get();
2576 MOZ_ASSERT(quotaManager);
2577
2578 MutexAutoLock lock(quotaManager->mQuotaMutex);
2579
2580 return LockedMaybeUpdateSize(aSize, aTruncate);
2581 }
2582
2583 bool QuotaObject::IncreaseSize(int64_t aDelta) {
2584 MOZ_ASSERT(aDelta >= 0);
2585
2586 QuotaManager* quotaManager = QuotaManager::Get();
2587 MOZ_ASSERT(quotaManager);
2588
2589 MutexAutoLock lock(quotaManager->mQuotaMutex);
2590
2591 AssertNoOverflow(mSize, aDelta);
2592 int64_t size = mSize + aDelta;
2593
2594 return LockedMaybeUpdateSize(size, /* aTruncate */ false);
2595 }
2596
2597 void QuotaObject::DisableQuotaCheck() {
2598 QuotaManager* quotaManager = QuotaManager::Get();
2599 MOZ_ASSERT(quotaManager);
2600
2601 MutexAutoLock lock(quotaManager->mQuotaMutex);
2602
2603 mQuotaCheckDisabled = true;
2604 }
2605
2606 void QuotaObject::EnableQuotaCheck() {
2607 QuotaManager* quotaManager = QuotaManager::Get();
2608 MOZ_ASSERT(quotaManager);
2609
2610 MutexAutoLock lock(quotaManager->mQuotaMutex);
2611
2612 mQuotaCheckDisabled = false;
2613 }
2614
2615 bool QuotaObject::LockedMaybeUpdateSize(int64_t aSize, bool aTruncate) {
2616 QuotaManager* quotaManager = QuotaManager::Get();
2617 MOZ_ASSERT(quotaManager);
2618
2619 quotaManager->mQuotaMutex.AssertCurrentThreadOwns();
2620
2621 if (mWritingDone == false && mOriginInfo) {
2622 mWritingDone = true;
2623 StorageActivityService::SendActivity(mOriginInfo->mOrigin);
2624 }
2625
2626 if (mQuotaCheckDisabled) {
2627 return true;
2628 }
2629
2630 if (mSize == aSize) {
2631 return true;
2632 }
2633
2634 if (!mOriginInfo) {
2635 mSize = aSize;
2636 return true;
2637 }
2638
2639 GroupInfo* groupInfo = mOriginInfo->mGroupInfo;
2640 MOZ_ASSERT(groupInfo);
2641
2642 if (mSize > aSize) {
2643 if (aTruncate) {
2644 const int64_t delta = mSize - aSize;
2645
2646 AssertNoUnderflow(quotaManager->mTemporaryStorageUsage, delta);
2647 quotaManager->mTemporaryStorageUsage -= delta;
2648
2649 if (!mOriginInfo->LockedPersisted()) {
2650 AssertNoUnderflow(groupInfo->mUsage, delta);
2651 groupInfo->mUsage -= delta;
2652 }
2653
2654 AssertNoUnderflow(mOriginInfo->mUsage, delta);
2655 mOriginInfo->mUsage -= delta;
2656
2657 mSize = aSize;
2658 }
2659 return true;
2660 }
2661
2662 MOZ_ASSERT(mSize < aSize);
2663
2664 RefPtr<GroupInfo> complementaryGroupInfo =
2665 groupInfo->mGroupInfoPair->LockedGetGroupInfo(
2666 ComplementaryPersistenceType(groupInfo->mPersistenceType));
2667
2668 uint64_t delta = aSize - mSize;
2669
2670 AssertNoOverflow(mOriginInfo->mUsage, delta);
2671 uint64_t newUsage = mOriginInfo->mUsage + delta;
2672
2673 // Temporary storage has no limit for origin usage (there's a group and the
2674 // global limit though).
2675
2676 uint64_t newGroupUsage = groupInfo->mUsage;
2677 if (!mOriginInfo->LockedPersisted()) {
2678 AssertNoOverflow(groupInfo->mUsage, delta);
2679 newGroupUsage += delta;
2680
2681 uint64_t groupUsage = groupInfo->mUsage;
2682 if (complementaryGroupInfo) {
2683 AssertNoOverflow(groupUsage, complementaryGroupInfo->mUsage);
2684 groupUsage += complementaryGroupInfo->mUsage;
2685 }
2686
2687 // Temporary storage has a hard limit for group usage (20 % of the global
2688 // limit).
2689 AssertNoOverflow(groupUsage, delta);
2690 if (groupUsage + delta > quotaManager->GetGroupLimit()) {
2691 return false;
2692 }
2693 }
2694
2695 AssertNoOverflow(quotaManager->mTemporaryStorageUsage, delta);
2696 uint64_t newTemporaryStorageUsage =
2697 quotaManager->mTemporaryStorageUsage + delta;
2698
2699 if (newTemporaryStorageUsage > quotaManager->mTemporaryStorageLimit) {
2700 // This will block the thread without holding the lock while waitting.
2701
2702 AutoTArray<RefPtr<DirectoryLockImpl>, 10> locks;
2703 uint64_t sizeToBeFreed;
2704
2705 if (IsOnBackgroundThread()) {
2706 MutexAutoUnlock autoUnlock(quotaManager->mQuotaMutex);
2707
2708 sizeToBeFreed = quotaManager->CollectOriginsForEviction(delta, locks);
2709 } else {
2710 sizeToBeFreed =
2711 quotaManager->LockedCollectOriginsForEviction(delta, locks);
2712 }
2713
2714 if (!sizeToBeFreed) {
2715 uint64_t usage = quotaManager->mTemporaryStorageUsage;
2716
2717 MutexAutoUnlock autoUnlock(quotaManager->mQuotaMutex);
2718
2719 quotaManager->NotifyStoragePressure(usage);
2720
2721 return false;
2722 }
2723
2724 NS_ASSERTION(sizeToBeFreed >= delta, "Huh?");
2725
2726 {
2727 MutexAutoUnlock autoUnlock(quotaManager->mQuotaMutex);
2728
2729 for (RefPtr<DirectoryLockImpl>& lock : locks) {
2730 MOZ_ASSERT(!lock->GetPersistenceType().IsNull());
2731 MOZ_ASSERT(lock->GetOriginScope().IsOrigin());
2732 MOZ_ASSERT(!lock->GetOriginScope().GetOrigin().IsEmpty());
2733
2734 quotaManager->DeleteFilesForOrigin(lock->GetPersistenceType().Value(),
2735 lock->GetOriginScope().GetOrigin());
2736 }
2737 }
2738
2739 // Relocked.
2740
2741 NS_ASSERTION(mOriginInfo, "How come?!");
2742
2743 for (DirectoryLockImpl* lock : locks) {
2744 MOZ_ASSERT(!lock->GetPersistenceType().IsNull());
2745 MOZ_ASSERT(!lock->GetGroup().IsEmpty());
2746 MOZ_ASSERT(lock->GetOriginScope().IsOrigin());
2747 MOZ_ASSERT(!lock->GetOriginScope().GetOrigin().IsEmpty());
2748 MOZ_ASSERT(
2749 !(lock->GetOriginScope().GetOrigin() == mOriginInfo->mOrigin &&
2750 lock->GetPersistenceType().Value() == groupInfo->mPersistenceType),
2751 "Deleted itself!");
2752
2753 quotaManager->LockedRemoveQuotaForOrigin(
2754 lock->GetPersistenceType().Value(), lock->GetGroup(),
2755 lock->GetOriginScope().GetOrigin());
2756 }
2757
2758 // We unlocked and relocked several times so we need to recompute all the
2759 // essential variables and recheck the group limit.
2760
2761 AssertNoUnderflow(aSize, mSize);
2762 delta = aSize - mSize;
2763
2764 AssertNoOverflow(mOriginInfo->mUsage, delta);
2765 newUsage = mOriginInfo->mUsage + delta;
2766
2767 newGroupUsage = groupInfo->mUsage;
2768 if (!mOriginInfo->LockedPersisted()) {
2769 AssertNoOverflow(groupInfo->mUsage, delta);
2770 newGroupUsage += delta;
2771
2772 uint64_t groupUsage = groupInfo->mUsage;
2773 if (complementaryGroupInfo) {
2774 AssertNoOverflow(groupUsage, complementaryGroupInfo->mUsage);
2775 groupUsage += complementaryGroupInfo->mUsage;
2776 }
2777
2778 AssertNoOverflow(groupUsage, delta);
2779 if (groupUsage + delta > quotaManager->GetGroupLimit()) {
2780 // Unfortunately some other thread increased the group usage in the
2781 // meantime and we are not below the group limit anymore.
2782
2783 // However, the origin eviction must be finalized in this case too.
2784 MutexAutoUnlock autoUnlock(quotaManager->mQuotaMutex);
2785
2786 quotaManager->FinalizeOriginEviction(locks);
2787
2788 return false;
2789 }
2790 }
2791
2792 AssertNoOverflow(quotaManager->mTemporaryStorageUsage, delta);
2793 newTemporaryStorageUsage = quotaManager->mTemporaryStorageUsage + delta;
2794
2795 NS_ASSERTION(
2796 newTemporaryStorageUsage <= quotaManager->mTemporaryStorageLimit,
2797 "How come?!");
2798
2799 // Ok, we successfully freed enough space and the operation can continue
2800 // without throwing the quota error.
2801 mOriginInfo->mUsage = newUsage;
2802 if (!mOriginInfo->LockedPersisted()) {
2803 groupInfo->mUsage = newGroupUsage;
2804 }
2805 quotaManager->mTemporaryStorageUsage = newTemporaryStorageUsage;
2806 ;
2807
2808 // Some other thread could increase the size in the meantime, but no more
2809 // than this one.
2810 MOZ_ASSERT(mSize < aSize);
2811 mSize = aSize;
2812
2813 // Finally, release IO thread only objects and allow next synchronized
2814 // ops for the evicted origins.
2815 MutexAutoUnlock autoUnlock(quotaManager->mQuotaMutex);
2816
2817 quotaManager->FinalizeOriginEviction(locks);
2818
2819 return true;
2820 }
2821
2822 mOriginInfo->mUsage = newUsage;
2823 if (!mOriginInfo->LockedPersisted()) {
2824 groupInfo->mUsage = newGroupUsage;
2825 }
2826 quotaManager->mTemporaryStorageUsage = newTemporaryStorageUsage;
2827
2828 mSize = aSize;
2829
2830 return true;
2831 }
2832
2833 /*******************************************************************************
2834 * Quota manager
2835 ******************************************************************************/
2836
2837 QuotaManager::QuotaManager()
2838 : mQuotaMutex("QuotaManager.mQuotaMutex"),
2839 mTemporaryStorageLimit(0),
2840 mTemporaryStorageUsage(0),
2841 mTemporaryStorageInitialized(false),
2842 mStorageInitialized(false) {
2843 AssertIsOnOwningThread();
2844 MOZ_ASSERT(!gInstance);
2845 }
2846
2847 QuotaManager::~QuotaManager() {
2848 AssertIsOnOwningThread();
2849 MOZ_ASSERT(!gInstance || gInstance == this);
2850 }
2851
2852 void QuotaManager::GetOrCreate(nsIRunnable* aCallback,
2853 nsIEventTarget* aMainEventTarget) {
2854 AssertIsOnBackgroundThread();
2855
2856 if (IsShuttingDown()) {
2857 MOZ_ASSERT(false, "Calling GetOrCreate() after shutdown!");
2858 return;
2859 }
2860
2861 if (gInstance || gCreateFailed) {
2862 MOZ_ASSERT(!gCreateRunnable);
2863 MOZ_ASSERT_IF(gCreateFailed, !gInstance);
2864
2865 MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(aCallback));
2866 } else {
2867 if (!gCreateRunnable) {
2868 gCreateRunnable = new CreateRunnable(aMainEventTarget);
2869 if (aMainEventTarget) {
2870 MOZ_ALWAYS_SUCCEEDS(
2871 aMainEventTarget->Dispatch(gCreateRunnable, NS_DISPATCH_NORMAL));
2872 } else {
2873 MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(gCreateRunnable));
2874 }
2875 }
2876
2877 gCreateRunnable->AddCallback(aCallback);
2878 }
2879 }
2880
2881 // static
2882 QuotaManager* QuotaManager::Get() {
2883 // Does not return an owning reference.
2884 return gInstance;
2885 }
2886
2887 // static
2888 bool QuotaManager::IsShuttingDown() { return gShutdown; }
2889
2890 // static
2891 bool QuotaManager::IsOSMetadata(const nsAString& aFileName) {
2892 return aFileName.EqualsLiteral(DSSTORE_FILE_NAME) ||
2893 aFileName.EqualsLiteral(DESKTOP_FILE_NAME) ||
2894 aFileName.LowerCaseEqualsLiteral(DESKTOP_INI_FILE_NAME) ||
2895 aFileName.EqualsLiteral(THUMBS_DB_FILE_NAME);
2896 }
2897
2898 // static
2899 bool QuotaManager::IsDotFile(const nsAString& aFileName) {
2900 return aFileName.First() == char16_t('.');
2901 }
2902
2903 auto QuotaManager::CreateDirectoryLock(
2904 const Nullable<PersistenceType>& aPersistenceType, const nsACString& aGroup,
2905 const OriginScope& aOriginScope, const Nullable<Client::Type>& aClientType,
2906 bool aExclusive, bool aInternal, OpenDirectoryListener* aOpenListener)
2907 -> already_AddRefed<DirectoryLockImpl> {
2908 AssertIsOnOwningThread();
2909 MOZ_ASSERT_IF(aOriginScope.IsOrigin(), !aOriginScope.GetOrigin().IsEmpty());
2910 MOZ_ASSERT_IF(!aInternal, !aPersistenceType.IsNull());
2911 MOZ_ASSERT_IF(!aInternal,
2912 aPersistenceType.Value() != PERSISTENCE_TYPE_INVALID);
2913 MOZ_ASSERT_IF(!aInternal, !aGroup.IsEmpty());
2914 MOZ_ASSERT_IF(!aInternal, aOriginScope.IsOrigin());
2915 MOZ_ASSERT_IF(!aInternal, !aClientType.IsNull());
2916 MOZ_ASSERT_IF(!aInternal, aClientType.Value() < Client::TypeMax());
2917 MOZ_ASSERT_IF(!aInternal, aOpenListener);
2918
2919 RefPtr<DirectoryLockImpl> lock =
2920 new DirectoryLockImpl(this, aPersistenceType, aGroup, aOriginScope,
2921 aClientType, aExclusive, aInternal, aOpenListener);
2922
2923 mPendingDirectoryLocks.AppendElement(lock);
2924
2925 // See if this lock needs to wait.
2926 bool blocked = false;
2927 for (uint32_t index = mDirectoryLocks.Length(); index > 0; index--) {
2928 DirectoryLockImpl* existingLock = mDirectoryLocks[index - 1];
2929 if (lock->MustWaitFor(*existingLock)) {
2930 existingLock->AddBlockingLock(lock);
2931 lock->AddBlockedOnLock(existingLock);
2932 blocked = true;
2933 }
2934 }
2935
2936 RegisterDirectoryLock(lock);
2937
2938 // Otherwise, notify the open listener immediately.
2939 if (!blocked) {
2940 lock->NotifyOpenListener();
2941 }
2942
2943 return lock.forget();
2944 }
2945
2946 auto QuotaManager::CreateDirectoryLockForEviction(
2947 PersistenceType aPersistenceType, const nsACString& aGroup,
2948 const nsACString& aOrigin) -> already_AddRefed<DirectoryLockImpl> {
2949 AssertIsOnOwningThread();
2950 MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_INVALID);
2951 MOZ_ASSERT(!aOrigin.IsEmpty());
2952
2953 RefPtr<DirectoryLockImpl> lock = new DirectoryLockImpl(
2954 this, Nullable<PersistenceType>(aPersistenceType), aGroup,
2955 OriginScope::FromOrigin(aOrigin), Nullable<Client::Type>(),
2956 /* aExclusive */ true,
2957 /* aInternal */ true, nullptr);
2958
2959 #ifdef DEBUG
2960 for (uint32_t index = mDirectoryLocks.Length(); index > 0; index--) {
2961 DirectoryLockImpl* existingLock = mDirectoryLocks[index - 1];
2962 MOZ_ASSERT(!lock->MustWaitFor(*existingLock));
2963 }
2964 #endif
2965
2966 RegisterDirectoryLock(lock);
2967
2968 return lock.forget();
2969 }
2970
2971 void QuotaManager::RegisterDirectoryLock(DirectoryLockImpl* aLock) {
2972 AssertIsOnOwningThread();
2973 MOZ_ASSERT(aLock);
2974
2975 mDirectoryLocks.AppendElement(aLock);
2976
2977 if (aLock->ShouldUpdateLockTable()) {
2978 const Nullable<PersistenceType>& persistenceType =
2979 aLock->GetPersistenceType();
2980 const OriginScope& originScope = aLock->GetOriginScope();
2981
2982 MOZ_ASSERT(!persistenceType.IsNull());
2983 MOZ_ASSERT(!aLock->GetGroup().IsEmpty());
2984 MOZ_ASSERT(originScope.IsOrigin());
2985 MOZ_ASSERT(!originScope.GetOrigin().IsEmpty());
2986
2987 DirectoryLockTable& directoryLockTable =
2988 GetDirectoryLockTable(persistenceType.Value());
2989
2990 nsTArray<DirectoryLockImpl*>* array;
2991 if (!directoryLockTable.Get(originScope.GetOrigin(), &array)) {
2992 array = new nsTArray<DirectoryLockImpl*>();
2993 directoryLockTable.Put(originScope.GetOrigin(), array);
2994
2995 if (!IsShuttingDown()) {
2996 UpdateOriginAccessTime(persistenceType.Value(), aLock->GetGroup(),
2997 originScope.GetOrigin());
2998 }
2999 }
3000 array->AppendElement(aLock);
3001 }
3002 }
3003
3004 void QuotaManager::UnregisterDirectoryLock(DirectoryLockImpl* aLock) {
3005 AssertIsOnOwningThread();
3006
3007 MOZ_ALWAYS_TRUE(mDirectoryLocks.RemoveElement(aLock));
3008
3009 if (aLock->ShouldUpdateLockTable()) {
3010 const Nullable<PersistenceType>& persistenceType =
3011 aLock->GetPersistenceType();
3012 const OriginScope& originScope = aLock->GetOriginScope();
3013
3014 MOZ_ASSERT(!persistenceType.IsNull());
3015 MOZ_ASSERT(!aLock->GetGroup().IsEmpty());
3016 MOZ_ASSERT(originScope.IsOrigin());
3017 MOZ_ASSERT(!originScope.GetOrigin().IsEmpty());
3018
3019 DirectoryLockTable& directoryLockTable =
3020 GetDirectoryLockTable(persistenceType.Value());
3021
3022 nsTArray<DirectoryLockImpl*>* array;
3023 MOZ_ALWAYS_TRUE(directoryLockTable.Get(originScope.GetOrigin(), &array));
3024
3025 MOZ_ALWAYS_TRUE(array->RemoveElement(aLock));
3026 if (array->IsEmpty()) {
3027 directoryLockTable.Remove(originScope.GetOrigin());
3028
3029 if (!IsShuttingDown()) {
3030 UpdateOriginAccessTime(persistenceType.Value(), aLock->GetGroup(),
3031 originScope.GetOrigin());
3032 }
3033 }
3034 }
3035 }
3036
3037 void QuotaManager::RemovePendingDirectoryLock(DirectoryLockImpl* aLock) {
3038 AssertIsOnOwningThread();
3039 MOZ_ASSERT(aLock);
3040
3041 MOZ_ALWAYS_TRUE(mPendingDirectoryLocks.RemoveElement(aLock));
3042 }
3043
3044 uint64_t QuotaManager::CollectOriginsForEviction(
3045 uint64_t aMinSizeToBeFreed, nsTArray<RefPtr<DirectoryLockImpl>>& aLocks) {
3046 AssertIsOnOwningThread();
3047 MOZ_ASSERT(aLocks.IsEmpty());
3048
3049 struct MOZ_STACK_CLASS Helper final {
3050 static void GetInactiveOriginInfos(
3051 nsTArray<RefPtr<OriginInfo>>& aOriginInfos,
3052 nsTArray<DirectoryLockImpl*>& aLocks,
3053 nsTArray<OriginInfo*>& aInactiveOriginInfos) {
3054 for (OriginInfo* originInfo : aOriginInfos) {
3055 MOZ_ASSERT(originInfo->mGroupInfo->mPersistenceType !=
3056 PERSISTENCE_TYPE_PERSISTENT);
3057
3058 if (originInfo->LockedPersisted()) {
3059 continue;
3060 }
3061
3062 OriginScope originScope = OriginScope::FromOrigin(originInfo->mOrigin);
3063
3064 bool match = false;
3065 for (uint32_t j = aLocks.Length(); j > 0; j--) {
3066 DirectoryLockImpl* lock = aLocks[j - 1];
3067 if (originScope.Matches(lock->GetOriginScope())) {
3068 match = true;
3069 break;
3070 }
3071 }
3072
3073 if (!match) {
3074 MOZ_ASSERT(!originInfo->mQuotaObjects.Count(),
3075 "Inactive origin shouldn't have open files!");
3076 aInactiveOriginInfos.InsertElementSorted(originInfo,
3077 OriginInfoLRUComparator());
3078 }
3079 }
3080 }
3081 };
3082
3083 // Split locks into separate arrays and filter out locks for persistent
3084 // storage, they can't block us.
3085 nsTArray<DirectoryLockImpl*> temporaryStorageLocks;
3086 nsTArray<DirectoryLockImpl*> defaultStorageLocks;
3087 for (DirectoryLockImpl* lock : mDirectoryLocks) {
3088 const Nullable<PersistenceType>& persistenceType =
3089 lock->GetPersistenceType();
3090
3091 if (persistenceType.IsNull()) {
3092 temporaryStorageLocks.AppendElement(lock);
3093 defaultStorageLocks.AppendElement(lock);
3094 } else if (persistenceType.Value() == PERSISTENCE_TYPE_TEMPORARY) {
3095 temporaryStorageLocks.AppendElement(lock);
3096 } else if (persistenceType.Value() == PERSISTENCE_TYPE_DEFAULT) {
3097 defaultStorageLocks.AppendElement(lock);
3098 } else {
3099 MOZ_ASSERT(persistenceType.Value() == PERSISTENCE_TYPE_PERSISTENT);
3100
3101 // Do nothing here, persistent origins don't need to be collected ever.
3102 }
3103 }
3104
3105 nsTArray<OriginInfo*> inactiveOrigins;
3106
3107 // Enumerate and process inactive origins. This must be protected by the
3108 // mutex.
3109 MutexAutoLock lock(mQuotaMutex);
3110
3111 for (auto iter = mGroupInfoPairs.Iter(); !iter.Done(); iter.Next()) {
3112 GroupInfoPair* pair = iter.UserData();
3113
3114 MOZ_ASSERT(!iter.Key().IsEmpty());
3115 MOZ_ASSERT(pair);
3116
3117 RefPtr<GroupInfo> groupInfo =
3118 pair->LockedGetGroupInfo(PERSISTENCE_TYPE_TEMPORARY);
3119 if (groupInfo) {
3120 Helper::GetInactiveOriginInfos(groupInfo->mOriginInfos,
3121 temporaryStorageLocks, inactiveOrigins);
3122 }
3123
3124 groupInfo = pair->LockedGetGroupInfo(PERSISTENCE_TYPE_DEFAULT);
3125 if (groupInfo) {
3126 Helper::GetInactiveOriginInfos(groupInfo->mOriginInfos,
3127 defaultStorageLocks, inactiveOrigins);
3128 }
3129 }
3130
3131 #ifdef DEBUG
3132 // Make sure the array is sorted correctly.
3133 for (uint32_t index = inactiveOrigins.Length(); index > 1; index--) {
3134 MOZ_ASSERT(inactiveOrigins[index - 1]->mAccessTime >=
3135 inactiveOrigins[index - 2]->mAccessTime);
3136 }
3137 #endif
3138
3139 // Create a list of inactive and the least recently used origins
3140 // whose aggregate size is greater or equals the minimal size to be freed.
3141 uint64_t sizeToBeFreed = 0;
3142 for (uint32_t count = inactiveOrigins.Length(), index = 0; index < count;
3143 index++) {
3144 if (sizeToBeFreed >= aMinSizeToBeFreed) {
3145 inactiveOrigins.TruncateLength(index);
3146 break;
3147 }
3148
3149 sizeToBeFreed += inactiveOrigins[index]->mUsage;
3150 }
3151
3152 if (sizeToBeFreed >= aMinSizeToBeFreed) {
3153 // Success, add directory locks for these origins, so any other
3154 // operations for them will be delayed (until origin eviction is finalized).
3155
3156 for (OriginInfo* originInfo : inactiveOrigins) {
3157 RefPtr<DirectoryLockImpl> lock = CreateDirectoryLockForEviction(
3158 originInfo->mGroupInfo->mPersistenceType,
3159 originInfo->mGroupInfo->mGroup, originInfo->mOrigin);
3160 aLocks.AppendElement(lock.forget());
3161 }
3162
3163 return sizeToBeFreed;
3164 }
3165
3166 return 0;
3167 }
3168
3169 nsresult QuotaManager::Init(const nsAString& aBasePath) {
3170 mBasePath = aBasePath;
3171
3172 nsCOMPtr<nsIFile> baseDir;
3173 nsresult rv = NS_NewLocalFile(aBasePath, false, getter_AddRefs(baseDir));
3174 if (NS_WARN_IF(NS_FAILED(rv))) {
3175 return rv;
3176 }
3177
3178 rv = CloneStoragePath(baseDir, NS_LITERAL_STRING(INDEXEDDB_DIRECTORY_NAME),
3179 mIndexedDBPath);
3180 if (NS_WARN_IF(NS_FAILED(rv))) {
3181 return rv;
3182 }
3183
3184 rv = baseDir->Append(NS_LITERAL_STRING(STORAGE_DIRECTORY_NAME));
3185 if (NS_WARN_IF(NS_FAILED(rv))) {
3186 return rv;
3187 }
3188
3189 rv = baseDir->GetPath(mStoragePath);
3190 if (NS_WARN_IF(NS_FAILED(rv))) {
3191 return rv;
3192 }
3193
3194 rv = CloneStoragePath(baseDir, NS_LITERAL_STRING(PERMANENT_DIRECTORY_NAME),
3195 mPermanentStoragePath);
3196 if (NS_WARN_IF(NS_FAILED(rv))) {
3197 return rv;
3198 }
3199
3200 rv = CloneStoragePath(baseDir, NS_LITERAL_STRING(TEMPORARY_DIRECTORY_NAME),
3201 mTemporaryStoragePath);
3202 if (NS_WARN_IF(NS_FAILED(rv))) {
3203 return rv;
3204 }
3205
3206 rv = CloneStoragePath(baseDir, NS_LITERAL_STRING(DEFAULT_DIRECTORY_NAME),
3207 mDefaultStoragePath);
3208 if (NS_WARN_IF(NS_FAILED(rv))) {
3209 return rv;
3210 }
3211
3212 rv = NS_NewNamedThread("QuotaManager IO", getter_AddRefs(mIOThread));
3213 if (NS_WARN_IF(NS_FAILED(rv))) {
3214 return rv;
3215 }
3216
3217 // Make a timer here to avoid potential failures later. We don't actually
3218 // initialize the timer until shutdown.
3219 mShutdownTimer = NS_NewTimer();
3220 if (NS_WARN_IF(!mShutdownTimer)) {
3221 return NS_ERROR_FAILURE;
3222 }
3223
3224 static_assert(Client::IDB == 0 && Client::ASMJS == 1 &&
3225 Client::DOMCACHE == 2 && Client::SDB == 3 &&
3226 Client::LS == 4 && Client::TYPE_MAX == 5,
3227 "Fix the registration!");
3228
3229 MOZ_ASSERT(mClients.Capacity() == Client::TYPE_MAX,
3230 "Should be using an auto array with correct capacity!");
3231
3232 // Register clients.
3233 mClients.AppendElement(indexedDB::CreateQuotaClient());
3234 mClients.AppendElement(asmjscache::CreateClient());
3235 mClients.AppendElement(cache::CreateQuotaClient());
3236 mClients.AppendElement(simpledb::CreateQuotaClient());
3237 if (CachedNextGenLocalStorageEnabled()) {
3238 mClients.AppendElement(localstorage::CreateQuotaClient());
3239 } else {
3240 mClients.SetLength(Client::TypeMax());
3241 }
3242
3243 return NS_OK;
3244 }
3245
3246 void QuotaManager::Shutdown() {
3247 AssertIsOnOwningThread();
3248
3249 // Setting this flag prevents the service from being recreated and prevents
3250 // further storagess from being created.
3251 if (gShutdown.exchange(true)) {
3252 NS_ERROR("Shutdown more than once?!");
3253 }
3254
3255 StopIdleMaintenance();
3256
3257 // Kick off the shutdown timer.
3258 MOZ_ALWAYS_SUCCEEDS(mShutdownTimer->InitWithNamedFuncCallback(
3259 &ShutdownTimerCallback, this, DEFAULT_SHUTDOWN_TIMER_MS,
3260 nsITimer::TYPE_ONE_SHOT, "QuotaManager::ShutdownTimerCallback"));
3261
3262 // Each client will spin the event loop while we wait on all the threads
3263 // to close. Our timer may fire during that loop.
3264 for (uint32_t index = 0; index < uint32_t(Client::TypeMax()); index++) {
3265 mClients[index]->ShutdownWorkThreads();
3266 }
3267
3268 // Cancel the timer regardless of whether it actually fired.
3269 if (NS_FAILED(mShutdownTimer->Cancel())) {
3270 NS_WARNING("Failed to cancel shutdown timer!");
3271 }
3272
3273 // NB: It's very important that runnable is destroyed on this thread
3274 // (i.e. after we join the IO thread) because we can't release the
3275 // QuotaManager on the IO thread. This should probably use
3276 // NewNonOwningRunnableMethod ...
3277 RefPtr<Runnable> runnable =
3278 NewRunnableMethod("dom::quota::QuotaManager::ReleaseIOThreadObjects",
3279 this, &QuotaManager::ReleaseIOThreadObjects);
3280 MOZ_ASSERT(runnable);
3281
3282 // Give clients a chance to cleanup IO thread only objects.
3283 if (NS_FAILED(mIOThread->Dispatch(runnable, NS_DISPATCH_NORMAL))) {
3284 NS_WARNING("Failed to dispatch runnable!");
3285 }
3286
3287 // Make sure to join with our IO thread.
3288 if (NS_FAILED(mIOThread->Shutdown())) {
3289 NS_WARNING("Failed to shutdown IO thread!");
3290 }
3291
3292 for (RefPtr<DirectoryLockImpl>& lock : mPendingDirectoryLocks) {
3293 lock->Invalidate();
3294 }
3295 }
3296
3297 void QuotaManager::InitQuotaForOrigin(PersistenceType aPersistenceType,
3298 const nsACString& aGroup,
3299 const nsACString& aOrigin,
3300 uint64_t aUsageBytes, int64_t aAccessTime,
3301 bool aPersisted) {
3302 AssertIsOnIOThread();
3303 MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_PERSISTENT);
3304
3305 MutexAutoLock lock(mQuotaMutex);
3306
3307 GroupInfoPair* pair;
3308 if (!mGroupInfoPairs.Get(aGroup, &pair)) {
3309 pair = new GroupInfoPair();
3310 mGroupInfoPairs.Put(aGroup, pair);
3311 // The hashtable is now responsible to delete the GroupInfoPair.
3312 }
3313
3314 RefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
3315 if (!groupInfo) {
3316 groupInfo = new GroupInfo(pair, aPersistenceType, aGroup);
3317 pair->LockedSetGroupInfo(aPersistenceType, groupInfo);
3318 }
3319
3320 RefPtr<OriginInfo> originInfo =
3321 new OriginInfo(groupInfo, aOrigin, aUsageBytes, aAccessTime, aPersisted);
3322 groupInfo->LockedAddOriginInfo(originInfo);
3323 }
3324
3325 void QuotaManager::DecreaseUsageForOrigin(PersistenceType aPersistenceType,
3326 const nsACString& aGroup,
3327 const nsACString& aOrigin,
3328 int64_t aSize) {
3329 MOZ_ASSERT(!NS_IsMainThread());
3330 MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_PERSISTENT);
3331
3332 MutexAutoLock lock(mQuotaMutex);
3333
3334 GroupInfoPair* pair;
3335 if (!mGroupInfoPairs.Get(aGroup, &pair)) {
3336 return;
3337 }
3338
3339 RefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
3340 if (!groupInfo) {
3341 return;
3342 }
3343
3344 RefPtr<OriginInfo> originInfo = groupInfo->LockedGetOriginInfo(aOrigin);
3345 if (originInfo) {
3346 originInfo->LockedDecreaseUsage(aSize);
3347 }
3348 }
3349
3350 void QuotaManager::UpdateOriginAccessTime(PersistenceType aPersistenceType,
3351 const nsACString& aGroup,
3352 const nsACString& aOrigin) {
3353 AssertIsOnOwningThread();
3354 MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_PERSISTENT);
3355
3356 MutexAutoLock lock(mQuotaMutex);
3357
3358 GroupInfoPair* pair;
3359 if (!mGroupInfoPairs.Get(aGroup, &pair)) {
3360 return;
3361 }
3362
3363 RefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
3364 if (!groupInfo) {
3365 return;
3366 }
3367
3368 RefPtr<OriginInfo> originInfo = groupInfo->LockedGetOriginInfo(aOrigin);
3369 if (originInfo) {
3370 int64_t timestamp = PR_Now();
3371 originInfo->LockedUpdateAccessTime(timestamp);
3372
3373 MutexAutoUnlock autoUnlock(mQuotaMutex);
3374
3375 RefPtr<SaveOriginAccessTimeOp> op =
3376 new SaveOriginAccessTimeOp(aPersistenceType, aOrigin, timestamp);
3377
3378 op->RunImmediately();
3379 }
3380 }
3381
3382 void QuotaManager::RemoveQuota() {
3383 AssertIsOnIOThread();
3384
3385 MutexAutoLock lock(mQuotaMutex);
3386
3387 for (auto iter = mGroupInfoPairs.Iter(); !iter.Done(); iter.Next()) {
3388 nsAutoPtr<GroupInfoPair>& pair = iter.Data();
3389
3390 MOZ_ASSERT(!iter.Key().IsEmpty(), "Empty key!");
3391 MOZ_ASSERT(pair, "Null pointer!");
3392
3393 RefPtr<GroupInfo> groupInfo =
3394 pair->LockedGetGroupInfo(PERSISTENCE_TYPE_TEMPORARY);
3395 if (groupInfo) {
3396 groupInfo->LockedRemoveOriginInfos();
3397 }
3398
3399 groupInfo = pair->LockedGetGroupInfo(PERSISTENCE_TYPE_DEFAULT);
3400 if (groupInfo) {
3401 groupInfo->LockedRemoveOriginInfos();
3402 }
3403
3404 iter.Remove();
3405 }
3406
3407 NS_ASSERTION(mTemporaryStorageUsage == 0, "Should be zero!");
3408 }
3409
3410 already_AddRefed<QuotaObject> QuotaManager::GetQuotaObject(
3411 PersistenceType aPersistenceType, const nsACString& aGroup,
3412 const nsACString& aOrigin, nsIFile* aFile, int64_t aFileSize,
3413 int64_t* aFileSizeOut /* = nullptr */) {
3414 NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
3415
3416 if (aFileSizeOut) {
3417 *aFileSizeOut = 0;
3418 }
3419
3420 if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
3421 return nullptr;
3422 }
3423
3424 nsString path;
3425 nsresult rv = aFile->GetPath(path);
3426 NS_ENSURE_SUCCESS(rv, nullptr);
3427
3428 int64_t fileSize;
3429
3430 if (aFileSize == -1) {
3431 bool exists;
3432 rv = aFile->Exists(&exists);
3433 NS_ENSURE_SUCCESS(rv, nullptr);
3434
3435 if (exists) {
3436 rv = aFile->GetFileSize(&fileSize);
3437 NS_ENSURE_SUCCESS(rv, nullptr);
3438 } else {
3439 fileSize = 0;
3440 }
3441 } else {
3442 fileSize = aFileSize;
3443 }
3444
3445 // Re-escape our parameters above to make sure we get the right quota group.
3446 nsAutoCString group;
3447 rv = NS_EscapeURL(aGroup, esc_Query, group, fallible);
3448 NS_ENSURE_SUCCESS(rv, nullptr);
3449
3450 nsAutoCString origin;
3451 rv = NS_EscapeURL(aOrigin, esc_Query, origin, fallible);
3452 NS_ENSURE_SUCCESS(rv, nullptr);
3453
3454 RefPtr<QuotaObject> result;
3455 {
3456 MutexAutoLock lock(mQuotaMutex);
3457
3458 GroupInfoPair* pair;
3459 if (!mGroupInfoPairs.Get(group, &pair)) {
3460 return nullptr;
3461 }
3462
3463 RefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
3464
3465 if (!groupInfo) {
3466 return nullptr;
3467 }
3468
3469 RefPtr<OriginInfo> originInfo = groupInfo->LockedGetOriginInfo(origin);
3470
3471 if (!originInfo) {
3472 return nullptr;
3473 }
3474
3475 // We need this extra raw pointer because we can't assign to the smart
3476 // pointer directly since QuotaObject::AddRef would try to acquire the same
3477 // mutex.
3478 QuotaObject* quotaObject;
3479 if (!originInfo->mQuotaObjects.Get(path, &quotaObject)) {
3480 // Create a new QuotaObject.
3481 quotaObject = new QuotaObject(originInfo, path, fileSize);
3482
3483 // Put it to the hashtable. The hashtable is not responsible to delete
3484 // the QuotaObject.
3485 originInfo->mQuotaObjects.Put(path, quotaObject);
3486 }
3487
3488 // Addref the QuotaObject and move the ownership to the result. This must
3489 // happen before we unlock!
3490 result = quotaObject->LockedAddRef();
3491 }
3492
3493 if (aFileSizeOut) {
3494 *aFileSizeOut = fileSize;
3495 }
3496
3497 // The caller becomes the owner of the QuotaObject, that is, the caller is
3498 // is responsible to delete it when the last reference is removed.
3499 return result.forget();
3500 }
3501
3502 already_AddRefed<QuotaObject> QuotaManager::GetQuotaObject(
3503 PersistenceType aPersistenceType, const nsACString& aGroup,
3504 const nsACString& aOrigin, const nsAString& aPath, int64_t aFileSize,
3505 int64_t* aFileSizeOut /* = nullptr */) {
3506 NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
3507
3508 if (aFileSizeOut) {
3509 *aFileSizeOut = 0;
3510 }
3511
3512 nsCOMPtr<nsIFile> file;
3513 nsresult rv = NS_NewLocalFile(aPath, false, getter_AddRefs(file));
3514 NS_ENSURE_SUCCESS(rv, nullptr);
3515
3516 return GetQuotaObject(aPersistenceType, aGroup, aOrigin, file, aFileSize,
3517 aFileSizeOut);
3518 }
3519
3520 Nullable<bool> QuotaManager::OriginPersisted(const nsACString& aGroup,
3521 const nsACString& aOrigin) {
3522 AssertIsOnIOThread();
3523
3524 MutexAutoLock lock(mQuotaMutex);
3525
3526 RefPtr<OriginInfo> originInfo =
3527 LockedGetOriginInfo(PERSISTENCE_TYPE_DEFAULT, aGroup, aOrigin);
3528 if (originInfo) {
3529 return Nullable<bool>(originInfo->LockedPersisted());
3530 }
3531
3532 return Nullable<bool>();
3533 }
3534
3535 void QuotaManager::PersistOrigin(const nsACString& aGroup,
3536 const nsACString& aOrigin) {
3537 AssertIsOnIOThread();
3538
3539 MutexAutoLock lock(mQuotaMutex);
3540
3541 RefPtr<OriginInfo> originInfo =
3542 LockedGetOriginInfo(PERSISTENCE_TYPE_DEFAULT, aGroup, aOrigin);
3543 if (originInfo && !originInfo->LockedPersisted()) {
3544 originInfo->LockedPersist();
3545 }
3546 }
3547
3548 void QuotaManager::AbortOperationsForProcess(ContentParentId aContentParentId) {
3549 AssertIsOnOwningThread();
3550
3551 for (RefPtr<Client>& client : mClients) {
3552 client->AbortOperationsForProcess(aContentParentId);
3553 }
3554 }
3555
3556 nsresult QuotaManager::GetDirectoryForOrigin(PersistenceType aPersistenceType,
3557 const nsACString& aASCIIOrigin,
3558 nsIFile** aDirectory) const {
3559 nsCOMPtr<nsIFile> directory;
3560 nsresult rv = NS_NewLocalFile(GetStoragePath(aPersistenceType), false,
3561 getter_AddRefs(directory));
3562 NS_ENSURE_SUCCESS(rv, rv);
3563
3564 nsAutoCString originSanitized(aASCIIOrigin);
3565 SanitizeOriginString(originSanitized);
3566
3567 rv = directory->Append(NS_ConvertASCIItoUTF16(originSanitized));
3568 NS_ENSURE_SUCCESS(rv, rv);
3569
3570 directory.forget(aDirectory);
3571 return NS_OK;
3572 }
3573
3574 nsresult QuotaManager::RestoreDirectoryMetadata2(nsIFile* aDirectory,
3575 bool aPersistent) {
3576 AssertIsOnIOThread();
3577 MOZ_ASSERT(aDirectory);
3578 MOZ_ASSERT(mStorageInitialized);
3579
3580 RefPtr<RestoreDirectoryMetadata2Helper> helper =
3581 new RestoreDirectoryMetadata2Helper(aDirectory, aPersistent);
3582
3583 nsresult rv = helper->RestoreMetadata2File();
3584 if (NS_WARN_IF(NS_FAILED(rv))) {
3585 return rv;
3586 }
3587
3588 return NS_OK;
3589 }
3590
3591 nsresult QuotaManager::GetDirectoryMetadata2(
3592 nsIFile* aDirectory, int64_t* aTimestamp, bool* aPersisted,
3593 nsACString& aSuffix, nsACString& aGroup, nsACString& aOrigin) {
3594 MOZ_ASSERT(!NS_IsMainThread());
3595 MOZ_ASSERT(aDirectory);
3596 MOZ_ASSERT(aTimestamp);
3597 MOZ_ASSERT(aPersisted);
3598 MOZ_ASSERT(mStorageInitialized);
3599
3600 nsCOMPtr<nsIBinaryInputStream> binaryStream;
3601 nsresult rv =
3602 GetBinaryInputStream(aDirectory, NS_LITERAL_STRING(METADATA_V2_FILE_NAME),
3603 getter_AddRefs(binaryStream));
3604 NS_ENSURE_SUCCESS(rv, rv);
3605
3606 uint64_t timestamp;
3607 rv = binaryStream->Read64(&timestamp);
3608 NS_ENSURE_SUCCESS(rv, rv);
3609
3610 bool persisted;
3611 rv = binaryStream->ReadBoolean(&persisted);
3612 if (NS_WARN_IF(NS_FAILED(rv))) {
3613 return rv;
3614 }
3615
3616 uint32_t reservedData1;
3617 rv = binaryStream->Read32(&reservedData1);
3618 if (NS_WARN_IF(NS_FAILED(rv))) {
3619 return rv;
3620 }
3621
3622 uint32_t reservedData2;
3623 rv = binaryStream->Read32(&reservedData2);
3624 if (NS_WARN_IF(NS_FAILED(rv))) {
3625 return rv;
3626 }
3627
3628 nsCString suffix;
3629 rv = binaryStream->ReadCString(suffix);
3630 if (NS_WARN_IF(NS_FAILED(rv))) {
3631 return rv;
3632 }
3633
3634 nsCString group;
3635 rv = binaryStream->ReadCString(group);
3636 NS_ENSURE_SUCCESS(rv, rv);
3637
3638 nsCString origin;
3639 rv = binaryStream->ReadCString(origin);
3640 NS_ENSURE_SUCCESS(rv, rv);
3641
3642 // Currently unused (used to be isApp).
3643 bool dummy;
3644 rv = binaryStream->ReadBoolean(&dummy);
3645 if (NS_WARN_IF(NS_FAILED(rv))) {
3646 return rv;
3647 }
3648
3649 *aTimestamp = timestamp;
3650 *aPersisted = persisted;
3651 aSuffix = suffix;
3652 aGroup = group;
3653 aOrigin = origin;
3654 return NS_OK;
3655 }
3656
3657 nsresult QuotaManager::GetDirectoryMetadata2WithRestore(
3658 nsIFile* aDirectory, bool aPersistent, int64_t* aTimestamp,
3659 bool* aPersisted, nsACString& aSuffix, nsACString& aGroup,
3660 nsACString& aOrigin, const bool aTelemetry) {
3661 nsresult rv = GetDirectoryMetadata2(aDirectory, aTimestamp, aPersisted,
3662 aSuffix, aGroup, aOrigin);
3663 if (NS_WARN_IF(NS_FAILED(rv))) {
3664 rv = RestoreDirectoryMetadata2(aDirectory, aPersistent);
3665 if (NS_WARN_IF(NS_FAILED(rv))) {
3666 if (aTelemetry) {
3667 REPORT_TELEMETRY_INIT_ERR(kInternalError, Rep_RestoreDirMeta);
3668 }
3669 return rv;
3670 }
3671
3672 rv = GetDirectoryMetadata2(aDirectory, aTimestamp, aPersisted, aSuffix,
3673 aGroup, aOrigin);
3674 if (NS_WARN_IF(NS_FAILED(rv))) {
3675 if (aTelemetry) {
3676 REPORT_TELEMETRY_INIT_ERR(kExternalError, Rep_GetDirMeta);
3677 }
3678 return rv;
3679 }
3680 }
3681
3682 return NS_OK;
3683 }
3684
3685 nsresult QuotaManager::GetDirectoryMetadata2(nsIFile* aDirectory,
3686 int64_t* aTimestamp,
3687 bool* aPersisted) {
3688 AssertIsOnIOThread();
3689 MOZ_ASSERT(aDirectory);
3690 MOZ_ASSERT(aTimestamp != nullptr || aPersisted != nullptr);
3691 MOZ_ASSERT(mStorageInitialized);
3692
3693 nsCOMPtr<nsIBinaryInputStream> binaryStream;
3694 nsresult rv =
3695 GetBinaryInputStream(aDirectory, NS_LITERAL_STRING(METADATA_V2_FILE_NAME),
3696 getter_AddRefs(binaryStream));
3697 if (NS_WARN_IF(NS_FAILED(rv))) {
3698 return rv;
3699 }
3700
3701 uint64_t timestamp;
3702 rv = binaryStream->Read64(&timestamp);
3703 if (NS_WARN_IF(NS_FAILED(rv))) {
3704 return rv;
3705 }
3706
3707 bool persisted;
3708 if (aPersisted != nullptr) {
3709 rv = binaryStream->ReadBoolean(&persisted);
3710 if (NS_WARN_IF(NS_FAILED(rv))) {
3711 return rv;
3712 }
3713 }
3714
3715 if (aTimestamp != nullptr) {
3716 *aTimestamp = timestamp;
3717 }
3718 if (aPersisted != nullptr) {
3719 *aPersisted = persisted;
3720 }
3721 return NS_OK;
3722 }
3723
3724 nsresult QuotaManager::GetDirectoryMetadata2WithRestore(nsIFile* aDirectory,
3725 bool aPersistent,
3726 int64_t* aTimestamp,
3727 bool* aPersisted) {
3728 nsresult rv = GetDirectoryMetadata2(aDirectory, aTimestamp, aPersisted);
3729 if (NS_WARN_IF(NS_FAILED(rv))) {
3730 rv = RestoreDirectoryMetadata2(aDirectory, aPersistent);
3731 if (NS_WARN_IF(NS_FAILED(rv))) {
3732 return rv;
3733 }
3734
3735 rv = GetDirectoryMetadata2(aDirectory, aTimestamp, aPersisted);
3736 if (NS_WARN_IF(NS_FAILED(rv))) {
3737 return rv;
3738 }
3739 }
3740
3741 return NS_OK;
3742 }
3743
3744 nsresult QuotaManager::InitializeRepository(PersistenceType aPersistenceType) {
3745 MOZ_ASSERT(aPersistenceType == PERSISTENCE_TYPE_TEMPORARY ||
3746 aPersistenceType == PERSISTENCE_TYPE_DEFAULT);
3747
3748 nsCOMPtr<nsIFile> directory;
3749 nsresult rv = NS_NewLocalFile(GetStoragePath(aPersistenceType), false,
3750 getter_AddRefs(directory));
3751 if (NS_WARN_IF(NS_FAILED(rv))) {
3752 REPORT_TELEMETRY_INIT_ERR(kExternalError, Rep_NewLocalFile);
3753 return rv;
3754 }
3755
3756 bool created;
3757 rv = EnsureDirectory(directory, &created);
3758 if (NS_WARN_IF(NS_FAILED(rv))) {
3759 REPORT_TELEMETRY_INIT_ERR(kExternalError, Rep_EnsureDirectory);
3760 return rv;
3761 }
3762
3763 nsCOMPtr<nsIDirectoryEnumerator> entries;
3764 rv = directory->GetDirectoryEntries(getter_AddRefs(entries));
3765 if (NS_WARN_IF(NS_FAILED(rv))) {
3766 REPORT_TELEMETRY_INIT_ERR(kExternalError, Rep_GetDirEntries);
3767 return rv;
3768 }
3769
3770 // A keeper to defer the return only in Nightly, so that the telemetry data
3771 // for whole profile can be collected
3772 #ifdef NIGHTLY_BUILD
3773 nsresult statusKeeper = NS_OK;
3774 #endif
3775
3776 nsCOMPtr<nsIFile> childDirectory;
3777 while (NS_SUCCEEDED(
3778 (rv = entries->GetNextFile(getter_AddRefs(childDirectory)))) &&
3779 childDirectory) {
3780 bool isDirectory;
3781 rv = childDirectory->IsDirectory(&isDirectory);
3782 if (NS_WARN_IF(NS_FAILED(rv))) {
3783 REPORT_TELEMETRY_INIT_ERR(kExternalError, Rep_IsDirectory);
3784 RECORD_IN_NIGHTLY(statusKeeper, rv);
3785 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(rv);
3786 }
3787
3788 if (!isDirectory) {
3789 nsString leafName;
3790 rv = childDirectory->GetLeafName(leafName);
3791 if (NS_WARN_IF(NS_FAILED(rv))) {
3792 REPORT_TELEMETRY_INIT_ERR(kExternalError, Rep_GetLeafName);
3793 RECORD_IN_NIGHTLY(statusKeeper, rv);
3794 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(rv);
3795 }
3796
3797 if (IsOSMetadata(leafName) || IsDotFile(leafName)) {
3798 continue;
3799 }
3800
3801 UNKNOWN_FILE_WARNING(leafName);
3802
3803 REPORT_TELEMETRY_INIT_ERR(kInternalError, Rep_UnexpectedFile);
3804 RECORD_IN_NIGHTLY(statusKeeper, NS_ERROR_UNEXPECTED);
3805 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(NS_ERROR_UNEXPECTED);
3806 }
3807
3808 int64_t timestamp;
3809 bool persisted;
3810 nsCString suffix;
3811 nsCString group;
3812 nsCString origin;
3813 rv = GetDirectoryMetadata2WithRestore(childDirectory,
3814 /* aPersistent */ false, &timestamp,
3815 &persisted, suffix, group, origin,
3816 /* aTelemetry */ true);
3817 if (NS_WARN_IF(NS_FAILED(rv))) {
3818 // Error should have reported in GetDirectoryMetadata2WithRestore
3819 RECORD_IN_NIGHTLY(statusKeeper, rv);
3820 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(rv);
3821 }
3822
3823 rv = InitializeOrigin(aPersistenceType, group, origin, timestamp, persisted,
3824 childDirectory);
3825 if (NS_WARN_IF(NS_FAILED(rv))) {
3826 // Error should have reported in InitializeOrigin
3827 RECORD_IN_NIGHTLY(statusKeeper, rv);
3828 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(rv);
3829 }
3830 }
3831 if (NS_WARN_IF(NS_FAILED(rv))) {
3832 REPORT_TELEMETRY_INIT_ERR(kInternalError, Rep_GetNextFile);
3833 RECORD_IN_NIGHTLY(statusKeeper, rv);
3834 #ifndef NIGHTLY_BUILD
3835 return rv;
3836 #endif
3837 }
3838
3839 #ifdef NIGHTLY_BUILD
3840 if (NS_FAILED(statusKeeper)) {
3841 return statusKeeper;
3842 }
3843 #endif
3844
3845 return NS_OK;
3846 }
3847
3848 nsresult QuotaManager::InitializeOrigin(PersistenceType aPersistenceType,
3849 const nsACString& aGroup,
3850 const nsACString& aOrigin,
3851 int64_t aAccessTime, bool aPersisted,
3852 nsIFile* aDirectory) {
3853 AssertIsOnIOThread();
3854
3855 nsresult rv;
3856
3857 bool trackQuota = aPersistenceType != PERSISTENCE_TYPE_PERSISTENT;
3858
3859 // We need to initialize directories of all clients if they exists and also
3860 // get the total usage to initialize the quota.
3861 nsAutoPtr<UsageInfo> usageInfo;
3862 if (trackQuota) {
3863 usageInfo = new UsageInfo();
3864 }
3865
3866 // A keeper to defer the return only in Nightly, so that the telemetry data
3867 // for whole profile can be collected
3868 #ifdef NIGHTLY_BUILD
3869 nsresult statusKeeper = NS_OK;
3870 #endif
3871
3872 nsCOMPtr<nsIDirectoryEnumerator> entries;
3873 rv = aDirectory->GetDirectoryEntries(getter_AddRefs(entries));
3874 if (NS_WARN_IF(NS_FAILED(rv))) {
3875 REPORT_TELEMETRY_INIT_ERR(kExternalError, Ori_GetDirEntries);
3876 return rv;
3877 }
3878
3879 nsCOMPtr<nsIFile> file;
3880 while (NS_SUCCEEDED((rv = entries->GetNextFile(getter_AddRefs(file)))) &&
3881 file) {
3882 bool isDirectory;
3883 rv = file->IsDirectory(&isDirectory);
3884 if (NS_WARN_IF(NS_FAILED(rv))) {
3885 REPORT_TELEMETRY_INIT_ERR(kExternalError, Ori_IsDirectory);
3886 RECORD_IN_NIGHTLY(statusKeeper, rv);
3887 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(rv);
3888 }
3889
3890 nsString leafName;
3891 rv = file->GetLeafName(leafName);
3892 if (NS_WARN_IF(NS_FAILED(rv))) {
3893 REPORT_TELEMETRY_INIT_ERR(kExternalError, Ori_GetLeafName);
3894 RECORD_IN_NIGHTLY(statusKeeper, rv);
3895 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(rv);
3896 }
3897
3898 if (!isDirectory) {
3899 if (IsOriginMetadata(leafName)) {
3900 continue;
3901 }
3902
3903 if (IsTempMetadata(leafName)) {
3904 rv = file->Remove(/* recursive */ false);
3905 if (NS_WARN_IF(NS_FAILED(rv))) {
3906 REPORT_TELEMETRY_INIT_ERR(kExternalError, Ori_Remove);
3907 RECORD_IN_NIGHTLY(statusKeeper, rv);
3908 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(rv);
3909 }
3910
3911 continue;
3912 }
3913
3914 if (IsOSMetadata(leafName) || IsDotFile(leafName)) {
3915 continue;
3916 }
3917
3918 UNKNOWN_FILE_WARNING(leafName);
3919 REPORT_TELEMETRY_INIT_ERR(kInternalError, Ori_UnexpectedFile);
3920 RECORD_IN_NIGHTLY(statusKeeper, NS_ERROR_UNEXPECTED);
3921 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(NS_ERROR_UNEXPECTED);
3922 }
3923
3924 Client::Type clientType;
3925 rv = Client::TypeFromText(leafName, clientType);
3926 if (NS_FAILED(rv)) {
3927 UNKNOWN_FILE_WARNING(leafName);
3928 REPORT_TELEMETRY_INIT_ERR(kInternalError, Ori_UnexpectedClient);
3929 RECORD_IN_NIGHTLY(statusKeeper, NS_ERROR_UNEXPECTED);
3930 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(NS_ERROR_UNEXPECTED);
3931 }
3932
3933 Atomic<bool> dummy(false);
3934 rv = mClients[clientType]->InitOrigin(aPersistenceType, aGroup, aOrigin,
3935 /* aCanceled */ dummy, usageInfo);
3936 if (NS_WARN_IF(NS_FAILED(rv))) {
3937 // error should have reported in InitOrigin
3938 RECORD_IN_NIGHTLY(statusKeeper, rv);
3939 CONTINUE_IN_NIGHTLY_RETURN_IN_OTHERS(rv);
3940 }
3941 }
3942 if (NS_WARN_IF(NS_FAILED(rv))) {
3943 REPORT_TELEMETRY_INIT_ERR(kInternalError, Ori_GetNextFile);
3944 RECORD_IN_NIGHTLY(statusKeeper, rv);
3945 #ifndef NIGHTLY_BUILD
3946 return rv;
3947 #endif
3948 }
3949
3950 #ifdef NIGHTLY_BUILD
3951 if (NS_FAILED(statusKeeper)) {
3952 return statusKeeper;
3953 }
3954 #endif
3955
3956 if (trackQuota) {
3957 InitQuotaForOrigin(aPersistenceType, aGroup, aOrigin,
3958 usageInfo->TotalUsage(), aAccessTime, aPersisted);
3959 }
3960
3961 return NS_OK;
3962 }
3963
3964 nsresult QuotaManager::MaybeUpgradeIndexedDBDirectory() {
3965 AssertIsOnIOThread();
3966
3967 nsCOMPtr<nsIFile> indexedDBDir;
3968 nsresult rv =
3969 NS_NewLocalFile(mIndexedDBPath, false, getter_AddRefs(indexedDBDir));
3970 NS_ENSURE_SUCCESS(rv, rv);
3971
3972 bool exists;
3973 rv = indexedDBDir->Exists(&exists);
3974 NS_ENSURE_SUCCESS(rv, rv);
3975
3976 if (!exists) {
3977 // Nothing to upgrade.
3978 return NS_OK;
3979 }
3980
3981 bool isDirectory;
3982 rv = indexedDBDir->IsDirectory(&isDirectory);
3983 NS_ENSURE_SUCCESS(rv, rv);
3984
3985 if (!isDirectory) {
3986 NS_WARNING("indexedDB entry is not a directory!");
3987 return NS_OK;
3988 }
3989
3990 nsCOMPtr<nsIFile> persistentStorageDir;
3991 rv = NS_NewLocalFile(mStoragePath, false,
3992 getter_AddRefs(persistentStorageDir));
3993 NS_ENSURE_SUCCESS(rv, rv);
3994
3995 rv = persistentStorageDir->Append(
3996 NS_LITERAL_STRING(PERSISTENT_DIRECTORY_NAME));
3997 NS_ENSURE_SUCCESS(rv, rv);
3998
3999 rv = persistentStorageDir->Exists(&exists);
4000 NS_ENSURE_SUCCESS(rv, rv);
4001
4002 if (exists) {
4003 NS_WARNING("indexedDB directory shouldn't exist after the upgrade!");
4004 return NS_OK;
4005 }
4006
4007 nsCOMPtr<nsIFile> storageDir;
4008 rv = persistentStorageDir->GetParent(getter_AddRefs(storageDir));
4009 NS_ENSURE_SUCCESS(rv, rv);
4010
4011 // MoveTo() is atomic if the move happens on the same volume which should
4012 // be our case, so even if we crash in the middle of the operation nothing
4013 // breaks next time we try to initialize.
4014 // However there's a theoretical possibility that the indexedDB directory
4015 // is on different volume, but it should be rare enough that we don't have
4016 // to worry about it.
4017 rv = indexedDBDir->MoveTo(storageDir,
4018 NS_LITERAL_STRING(PERSISTENT_DIRECTORY_NAME));
4019 NS_ENSURE_SUCCESS(rv, rv);
4020
4021 return NS_OK;
4022 }
4023
4024 nsresult QuotaManager::MaybeUpgradePersistentStorageDirectory() {
4025 AssertIsOnIOThread();
4026
4027 nsCOMPtr<nsIFile> persistentStorageDir;
4028 nsresult rv = NS_NewLocalFile(mStoragePath, false,
4029 getter_AddRefs(persistentStorageDir));
4030 if (NS_WARN_IF(NS_FAILED(rv))) {
4031 return rv;
4032 }
4033
4034 rv = persistentStorageDir->Append(
4035 NS_LITERAL_STRING(PERSISTENT_DIRECTORY_NAME));
4036 if (NS_WARN_IF(NS_FAILED(rv))) {
4037 return rv;
4038 }
4039
4040 bool exists;
4041 rv = persistentStorageDir->Exists(&exists);
4042 if (NS_WARN_IF(NS_FAILED(rv))) {
4043 return rv;
4044 }
4045
4046 if (!exists) {
4047 // Nothing to upgrade.
4048 return NS_OK;
4049 }
4050
4051 bool isDirectory;
4052 rv = persistentStorageDir->IsDirectory(&isDirectory);
4053 if (NS_WARN_IF(NS_FAILED(rv))) {
4054 return rv;
4055 }
4056
4057 if (!isDirectory) {
4058 NS_WARNING("persistent entry is not a directory!");
4059 return NS_OK;
4060 }
4061
4062 nsCOMPtr<nsIFile> defaultStorageDir;
4063 rv = NS_NewLocalFile(mDefaultStoragePath, false,
4064 getter_AddRefs(defaultStorageDir));
4065 if (NS_WARN_IF(NS_FAILED(rv))) {
4066 return rv;
4067 }
4068
4069 rv = defaultStorageDir->Exists(&exists);
4070 if (NS_WARN_IF(NS_FAILED(rv))) {
4071 return rv;
4072 }
4073
4074 if (exists) {
4075 NS_WARNING("storage/persistent shouldn't exist after the upgrade!");
4076 return NS_OK;
4077 }
4078
4079 // Create real metadata files for origin directories in persistent storage.
4080 RefPtr<CreateOrUpgradeDirectoryMetadataHelper> helper =
4081 new CreateOrUpgradeDirectoryMetadataHelper(persistentStorageDir,
4082 /* aPersistent */ true);
4083
4084 rv = helper->ProcessRepository();
4085 if (NS_WARN_IF(NS_FAILED(rv))) {
4086 return rv;
4087 }
4088
4089 // Upgrade metadata files for origin directories in temporary storage.
4090 nsCOMPtr<nsIFile> temporaryStorageDir;
4091 rv = NS_NewLocalFile(mTemporaryStoragePath, false,
4092 getter_AddRefs(temporaryStorageDir));
4093 if (NS_WARN_IF(NS_FAILED(rv))) {
4094 return rv;
4095 }
4096
4097 rv = temporaryStorageDir->Exists(&exists);
4098 if (NS_WARN_IF(NS_FAILED(rv))) {
4099 return rv;
4100 }
4101
4102 if (exists) {
4103 rv = temporaryStorageDir->IsDirectory(&isDirectory);
4104 if (NS_WARN_IF(NS_FAILED(rv))) {
4105 return rv;
4106 }
4107
4108 if (!isDirectory) {
4109 NS_WARNING("temporary entry is not a directory!");
4110 return NS_OK;
4111 }
4112
4113 helper =
4114 new CreateOrUpgradeDirectoryMetadataHelper(temporaryStorageDir,
4115 /* aPersistent */ false);
4116
4117 rv = helper->ProcessRepository();
4118 if (NS_WARN_IF(NS_FAILED(rv))) {
4119 return rv;
4120 }
4121 }
4122
4123 // And finally rename persistent to default.
4124 rv = persistentStorageDir->RenameTo(
4125 nullptr, NS_LITERAL_STRING(DEFAULT_DIRECTORY_NAME));
4126 if (NS_WARN_IF(NS_FAILED(rv))) {
4127 return rv;
4128 }
4129
4130 return NS_OK;
4131 }
4132
4133 nsresult QuotaManager::MaybeRemoveOldDirectories() {
4134 AssertIsOnIOThread();
4135
4136 nsCOMPtr<nsIFile> indexedDBDir;
4137 nsresult rv =
4138 NS_NewLocalFile(mIndexedDBPath, false, getter_AddRefs(indexedDBDir));
4139 if (NS_WARN_IF(NS_FAILED(rv))) {
4140 return rv;
4141 }
4142
4143 bool exists;
4144 rv = indexedDBDir->Exists(&exists);
4145 if (NS_WARN_IF(NS_FAILED(rv))) {
4146 return rv;
4147 }
4148
4149 if (exists) {
4150 QM_WARNING("Deleting old <profile>/indexedDB directory!");
4151
4152 rv = indexedDBDir->Remove(/* aRecursive */ true);
4153 if (NS_WARN_IF(NS_FAILED(rv))) {
4154 return rv;
4155 }
4156 }
4157
4158 nsCOMPtr<nsIFile> persistentStorageDir;
4159 rv = NS_NewLocalFile(mStoragePath, false,
4160 getter_AddRefs(persistentStorageDir));
4161 if (NS_WARN_IF(NS_FAILED(rv))) {
4162 return rv;
4163 }
4164
4165 rv = persistentStorageDir->Append(
4166 NS_LITERAL_STRING(PERSISTENT_DIRECTORY_NAME));
4167 if (NS_WARN_IF(NS_FAILED(rv))) {
4168 return rv;
4169 }
4170
4171 rv = persistentStorageDir->Exists(&exists);
4172 if (NS_WARN_IF(NS_FAILED(rv))) {
4173 return rv;
4174 }
4175
4176 if (exists) {
4177 QM_WARNING("Deleting old <profile>/storage/persistent directory!");
4178
4179 rv = persistentStorageDir->Remove(/* aRecursive */ true);
4180 if (NS_WARN_IF(NS_FAILED(rv))) {
4181 return rv;
4182 }
4183 }
4184
4185 return NS_OK;
4186 }
4187
4188 template <typename Helper>
4189 nsresult QuotaManager::UpgradeStorage(const int32_t aOldVersion,
4190 const int32_t aNewVersion,
4191 mozIStorageConnection* aConnection) {
4192 AssertIsOnIOThread();
4193 MOZ_ASSERT(aNewVersion > aOldVersion);
4194 MOZ_ASSERT(aNewVersion <= kStorageVersion);
4195 MOZ_ASSERT(aConnection);
4196
4197 nsresult rv;
4198
4199 for (const PersistenceType persistenceType : kAllPersistenceTypes) {
4200 nsCOMPtr<nsIFile> directory;
4201 rv = NS_NewLocalFile(GetStoragePath(persistenceType), false,
4202 getter_AddRefs(directory));
4203 if (NS_WARN_IF(NS_FAILED(rv))) {
4204 return rv;
4205 }
4206
4207 bool exists;
4208 rv = directory->Exists(&exists);
4209 if (NS_WARN_IF(NS_FAILED(rv))) {
4210 return rv;
4211 }
4212
4213 if (!exists) {
4214 continue;
4215 }
4216
4217 bool persistent = persistenceType == PERSISTENCE_TYPE_PERSISTENT;
4218 RefPtr<RepositoryOperationBase> helper = new Helper(directory, persistent);
4219 rv = helper->ProcessRepository();
4220 if (NS_WARN_IF(NS_FAILED(rv))) {
4221 return rv;
4222 }
4223 }
4224
4225 #ifdef DEBUG
4226 {
4227 int32_t storageVersion;
4228 rv = aConnection->GetSchemaVersion(&storageVersion);
4229 if (NS_WARN_IF(NS_FAILED(rv))) {
4230 return rv;
4231 }
4232
4233 MOZ_ASSERT(storageVersion == aOldVersion);
4234 }
4235 #endif
4236
4237 rv = aConnection->SetSchemaVersion(aNewVersion);
4238 if (NS_WARN_IF(NS_FAILED(rv))) {
4239 return rv;
4240 }
4241
4242 return NS_OK;
4243 }
4244
4245 nsresult QuotaManager::UpgradeStorageFrom0_0To1_0(
4246 mozIStorageConnection* aConnection) {
4247 AssertIsOnIOThread();
4248 MOZ_ASSERT(aConnection);
4249
4250 nsresult rv = MaybeUpgradeIndexedDBDirectory();
4251 if (NS_WARN_IF(NS_FAILED(rv))) {
4252 return rv;
4253 }
4254
4255 rv = MaybeUpgradePersistentStorageDirectory();
4256 if (NS_WARN_IF(NS_FAILED(rv))) {
4257 return rv;
4258 }
4259
4260 rv = MaybeRemoveOldDirectories();
4261 if (NS_WARN_IF(NS_FAILED(rv))) {
4262 return rv;
4263 }
4264
4265 rv = UpgradeStorage<UpgradeStorageFrom0_0To1_0Helper>(
4266 0, MakeStorageVersion(1, 0), aConnection);
4267 if (NS_WARN_IF(NS_FAILED(rv))) {
4268 return rv;
4269 }
4270
4271 return NS_OK;
4272 }
4273
4274 nsresult QuotaManager::UpgradeStorageFrom1_0To2_0(
4275 mozIStorageConnection* aConnection) {
4276 AssertIsOnIOThread();
4277 MOZ_ASSERT(aConnection);
4278
4279 // The upgrade consists of a number of logically distinct bugs that
4280 // intentionally got fixed at the same time to trigger just one major
4281 // version bump.
4282 //
4283 //
4284 // Morgue directory cleanup
4285 // [Feature/Bug]:
4286 // The original bug that added "on demand" morgue cleanup is 1165119.
4287 //
4288 // [Mutations]:
4289 // Morgue directories are removed from all origin directories during the
4290 // upgrade process. Origin initialization and usage calculation doesn't try
4291 // to remove morgue directories anymore.
4292 //
4293 // [Downgrade-incompatible changes]:
4294 // Morgue directories can reappear if user runs an already upgraded profile
4295 // in an older version of Firefox. Morgue directories then prevent current
4296 // Firefox from initializing and using the storage.
4297 //
4298 //
4299 // App data removal
4300 // [Feature/Bug]:
4301 // The bug that removes isApp flags is 1311057.
4302 //
4303 // [Mutations]:
4304 // Origin directories with appIds are removed during the upgrade process.
4305 //
4306 // [Downgrade-incompatible changes]:
4307 // Origin directories with appIds can reappear if user runs an already
4308 // upgraded profile in an older version of Firefox. Origin directories with
4309 // appIds don't prevent current Firefox from initializing and using the
4310 // storage, but they wouldn't ever be removed again, potentially causing
4311 // problems once appId is removed from origin attributes.
4312 //
4313 //
4314 // Strip obsolete origin attributes
4315 // [Feature/Bug]:
4316 // The bug that strips obsolete origin attributes is 1314361.
4317 //
4318 // [Mutations]:
4319 // Origin directories with obsolete origin attributes are renamed and their
4320 // metadata files are updated during the upgrade process.
4321 //
4322 // [Downgrade-incompatible changes]:
4323 // Origin directories with obsolete origin attributes can reappear if user
4324 // runs an already upgraded profile in an older version of Firefox. Origin
4325 // directories with obsolete origin attributes don't prevent current Firefox
4326 // from initializing and using the storage, but they wouldn't ever be upgraded
4327 // again, potentially causing problems in future.
4328 //
4329 //
4330 // File manager directory renaming (client specific)
4331 // [Feature/Bug]:
4332 // The original bug that added "on demand" file manager directory renaming is
4333 // 1056939.
4334 //
4335 // [Mutations]:
4336 // All file manager directories are renamed to contain the ".files" suffix.
4337 //
4338 // [Downgrade-incompatible changes]:
4339 // File manager directories with the ".files" suffix prevent older versions of
4340 // Firefox from initializing and using the storage.
4341 // File manager directories without the ".files" suffix can appear if user
4342 // runs an already upgraded profile in an older version of Firefox. File
4343 // manager directories without the ".files" suffix then prevent current
4344 // Firefox from initializing and using the storage.
4345
4346 nsresult rv = UpgradeStorage<UpgradeStorageFrom1_0To2_0Helper>(
4347 MakeStorageVersion(1, 0), MakeStorageVersion(2, 0), aConnection);
4348 if (NS_WARN_IF(NS_FAILED(rv))) {
4349 return rv;
4350 }
4351
4352 return NS_OK;
4353 }
4354
4355 nsresult QuotaManager::UpgradeStorageFrom2_0To2_1(
4356 mozIStorageConnection* aConnection) {
4357 AssertIsOnIOThread();
4358 MOZ_ASSERT(aConnection);
4359
4360 // The upgrade is mainly to create a directory padding file in DOM Cache
4361 // directory to record the overall padding size of an origin.
4362
4363 nsresult rv = UpgradeStorage<UpgradeStorageFrom2_0To2_1Helper>(
4364 MakeStorageVersion(2, 0), MakeStorageVersion(2, 1), aConnection);
4365 if (NS_WARN_IF(NS_FAILED(rv))) {
4366 return rv;
4367 }
4368
4369 return NS_OK;
4370 }
4371
4372 nsresult QuotaManager::MaybeRemoveLocalStorageData() {
4373 AssertIsOnIOThread();
4374 MOZ_ASSERT(!CachedNextGenLocalStorageEnabled());
4375
4376 // Cleanup the tmp file first, if there's any.
4377 nsCOMPtr<nsIFile> lsArchiveTmpFile;
4378 nsresult rv =
4379 NS_NewLocalFile(mStoragePath, false, getter_AddRefs(lsArchiveTmpFile));
4380 if (NS_WARN_IF(NS_FAILED(rv))) {
4381 return rv;
4382 }
4383
4384 rv = lsArchiveTmpFile->Append(NS_LITERAL_STRING(LS_ARCHIVE_TMP_FILE_NAME));
4385 if (NS_WARN_IF(NS_FAILED(rv))) {
4386 return rv;
4387 }
4388
4389 bool exists;
4390 rv = lsArchiveTmpFile->Exists(&exists);
4391 if (NS_WARN_IF(NS_FAILED(rv))) {
4392 return rv;
4393 }
4394
4395 if (exists) {
4396 rv = lsArchiveTmpFile->Remove(false);
4397 if (NS_WARN_IF(NS_FAILED(rv))) {
4398 return rv;
4399 }
4400 }
4401
4402 // Now check the real archive file.
4403 nsCOMPtr<nsIFile> lsArchiveFile;
4404 rv = NS_NewLocalFile(mStoragePath, false, getter_AddRefs(lsArchiveFile));
4405 if (NS_WARN_IF(NS_FAILED(rv))) {
4406 return rv;
4407 }
4408
4409 rv = lsArchiveFile->Append(NS_LITERAL_STRING(LS_ARCHIVE_FILE_NAME));
4410 if (NS_WARN_IF(NS_FAILED(rv))) {
4411 return rv;
4412 }
4413
4414 rv = lsArchiveFile->Exists(&exists);
4415 if (NS_WARN_IF(NS_FAILED(rv))) {
4416 return rv;
4417 }
4418
4419 if (!exists) {
4420 // If the ls archive doesn't exist then ls directories can't exist either.
4421 return NS_OK;
4422 }
4423
4424 rv = MaybeRemoveLocalStorageDirectories();
4425 if (NS_WARN_IF(NS_FAILED(rv))) {
4426 return rv;
4427 }
4428
4429 // Finally remove the ls archive, so we don't have to check all origin
4430 // directories next time this method is called.
4431 rv = lsArchiveFile->Remove(false);
4432 if (NS_WARN_IF(NS_FAILED(rv))) {
4433 return rv;
4434 }
4435
4436 return NS_OK;
4437 }
4438
4439 nsresult QuotaManager::MaybeRemoveLocalStorageDirectories() {
4440 AssertIsOnIOThread();
4441
4442 nsCOMPtr<nsIFile> defaultStorageDir;
4443 nsresult rv = NS_NewLocalFile(mDefaultStoragePath, false,
4444 getter_AddRefs(defaultStorageDir));
4445 if (NS_WARN_IF(NS_FAILED(rv))) {
4446 return rv;
4447 }
4448
4449 bool exists;
4450 rv = defaultStorageDir->Exists(&exists);
4451 if (NS_WARN_IF(NS_FAILED(rv))) {
4452 return rv;
4453 }
4454
4455 if (!exists) {
4456 return NS_OK;
4457 }
4458
4459 nsCOMPtr<nsIDirectoryEnumerator> entries;
4460 rv = defaultStorageDir->GetDirectoryEntries(getter_AddRefs(entries));
4461 if (NS_WARN_IF(NS_FAILED(rv))) {
4462 return rv;
4463 }
4464
4465 if (!entries) {
4466 return NS_OK;
4467 }
4468
4469 while (true) {
4470 bool hasMore;
4471 rv = entries->HasMoreElements(&hasMore);
4472 if (NS_WARN_IF(NS_FAILED(rv))) {
4473 return rv;
4474 }
4475
4476 if (!hasMore) {
4477 break;
4478 }
4479
4480 nsCOMPtr<nsISupports> entry;
4481 rv = entries->GetNext(getter_AddRefs(entry));
4482 if (NS_WARN_IF(NS_FAILED(rv))) {
4483 return rv;
4484 }
4485
4486 nsCOMPtr<nsIFile> originDir = do_QueryInterface(entry);
4487 MOZ_ASSERT(originDir);
4488
4489 rv = originDir->Exists(&exists);
4490 if (NS_WARN_IF(NS_FAILED(rv))) {
4491 return rv;
4492 }
4493
4494 MOZ_ASSERT(exists);
4495
4496 bool isDirectory;
4497 rv = originDir->IsDirectory(&isDirectory);
4498 if (NS_WARN_IF(NS_FAILED(rv))) {
4499 return rv;
4500 }
4501
4502 if (!isDirectory) {
4503 nsString leafName;
4504 rv = originDir->GetLeafName(leafName);
4505 if (NS_WARN_IF(NS_FAILED(rv))) {
4506 return rv;
4507 }
4508
4509 // Unknown files during upgrade are allowed. Just warn if we find them.
4510 if (!IsOSMetadata(leafName)) {
4511 UNKNOWN_FILE_WARNING(leafName);
4512 }
4513
4514 continue;
4515 }
4516
4517 nsCOMPtr<nsIFile> lsDir;
4518 rv = originDir->Clone(getter_AddRefs(lsDir));
4519 if (NS_WARN_IF(NS_FAILED(rv))) {
4520 return rv;
4521 }
4522
4523 rv = lsDir->Append(NS_LITERAL_STRING(LS_DIRECTORY_NAME));
4524 if (NS_WARN_IF(NS_FAILED(rv))) {
4525 return rv;
4526 }
4527
4528 rv = lsDir->Exists(&exists);
4529 if (NS_WARN_IF(NS_FAILED(rv))) {
4530 return rv;
4531 }
4532
4533 if (!exists) {
4534 continue;
4535 }
4536
4537 rv = lsDir->IsDirectory(&isDirectory);
4538 if (NS_WARN_IF(NS_FAILED(rv))) {
4539 return rv;
4540 }
4541
4542 if (!isDirectory) {
4543 QM_WARNING("ls entry is not a directory!");
4544
4545 continue;
4546 }
4547
4548 nsString path;
4549 rv = lsDir->GetPath(path);
4550 if (NS_WARN_IF(NS_FAILED(rv))) {
4551 return rv;
4552 }
4553
4554 QM_WARNING("Deleting %s directory!", NS_ConvertUTF16toUTF8(path).get());
4555
4556 rv = lsDir->Remove(/* aRecursive */ true);
4557 if (NS_WARN_IF(NS_FAILED(rv))) {
4558 return rv;
4559 }
4560 }
4561
4562 return NS_OK;
4563 }
4564
4565 nsresult QuotaManager::MaybeCreateLocalStorageArchive() {
4566 AssertIsOnIOThread();
4567 MOZ_ASSERT(CachedNextGenLocalStorageEnabled());
4568
4569 // Check if the archive was already successfully created.
4570 nsCOMPtr<nsIFile> lsArchiveFile;
4571 nsresult rv =
4572 NS_NewLocalFile(mStoragePath, false, getter_AddRefs(lsArchiveFile));
4573 if (NS_WARN_IF(NS_FAILED(rv))) {
4574 return rv;
4575 }
4576
4577 rv = lsArchiveFile->Append(NS_LITERAL_STRING(LS_ARCHIVE_FILE_NAME));
4578 if (NS_WARN_IF(NS_FAILED(rv))) {
4579 return rv;
4580 }
4581
4582 bool exists;
4583 rv = lsArchiveFile->Exists(&exists);
4584 if (NS_WARN_IF(NS_FAILED(rv))) {
4585 return rv;
4586 }
4587
4588 if (exists) {
4589 // ls-archive.sqlite already exists, nothing to create.
4590 return NS_OK;
4591 }
4592
4593 // Get the storage service first, we will need it at multiple places.
4594 nsCOMPtr<mozIStorageService> ss =
4595 do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID, &rv);
4596 if (NS_WARN_IF(NS_FAILED(rv))) {
4597 return rv;
4598 }
4599
4600 // Get the web apps store file.
4601 nsCOMPtr<nsIFile> webAppsStoreFile;
4602 rv = NS_NewLocalFile(mBasePath, false, getter_AddRefs(webAppsStoreFile));
4603 if (NS_WARN_IF(NS_FAILED(rv))) {
4604 return rv;
4605 }
4606
4607 rv = webAppsStoreFile->Append(NS_LITERAL_STRING(WEB_APPS_STORE_FILE_NAME));
4608 if (NS_WARN_IF(NS_FAILED(rv))) {
4609 return rv;
4610 }
4611
4612 // Now check if the web apps store is useable.
4613 nsCOMPtr<mozIStorageConnection> connection;
4614 rv = CreateWebAppsStoreConnection(webAppsStoreFile, ss,
4615 getter_AddRefs(connection));
4616 if (NS_WARN_IF(NS_FAILED(rv))) {
4617 return rv;
4618 }
4619
4620 if (connection) {
4621 // Find out the journal mode.
4622 nsCOMPtr<mozIStorageStatement> stmt;
4623 rv = connection->CreateStatement(NS_LITERAL_CSTRING("PRAGMA journal_mode;"),
4624 getter_AddRefs(stmt));
4625 if (NS_WARN_IF(NS_FAILED(rv))) {
4626 return rv;
4627 }
4628
4629 bool hasResult;
4630 rv = stmt->ExecuteStep(&hasResult);
4631 if (NS_WARN_IF(NS_FAILED(rv))) {
4632 return rv;
4633 }
4634
4635 MOZ_ASSERT(hasResult);
4636
4637 nsCString journalMode;
4638 rv = stmt->GetUTF8String(0, journalMode);
4639 if (NS_WARN_IF(NS_FAILED(rv))) {
4640 return rv;
4641 }
4642
4643 rv = stmt->Finalize();
4644 if (NS_WARN_IF(NS_FAILED(rv))) {
4645 return rv;
4646 }
4647
4648 if (journalMode.EqualsLiteral("wal")) {
4649 // We don't copy the WAL file, so make sure the old database is fully
4650 // checkpointed.
4651 rv = connection->ExecuteSimpleSQL(
4652 NS_LITERAL_CSTRING("PRAGMA wal_checkpoint(TRUNCATE);"));
4653 if (NS_WARN_IF(NS_FAILED(rv))) {
4654 return rv;
4655 }
4656 }
4657
4658 // Explicitely close the connection before the old database is copied.
4659 rv = connection->Close();
4660 if (NS_WARN_IF(NS_FAILED(rv))) {
4661 return rv;
4662 }
4663
4664 // Copy the old database. The database is copied from
4665 // <profile>/webappsstore.sqlite to
4666 // <profile>/storage/ls-archive-tmp.sqlite
4667 // We use a "-tmp" postfix since we are not done yet.
4668 nsCOMPtr<nsIFile> storageDir;
4669 rv = NS_NewLocalFile(mStoragePath, false, getter_AddRefs(storageDir));
4670 if (NS_WARN_IF(NS_FAILED(rv))) {
4671 return rv;
4672 }
4673
4674 rv = webAppsStoreFile->CopyTo(storageDir,
4675 NS_LITERAL_STRING(LS_ARCHIVE_TMP_FILE_NAME));
4676 if (NS_WARN_IF(NS_FAILED(rv))) {
4677 return rv;
4678 }
4679
4680 nsCOMPtr<nsIFile> lsArchiveTmpFile;
4681 rv = NS_NewLocalFile(mStoragePath, false, getter_AddRefs(lsArchiveTmpFile));
4682 if (NS_WARN_IF(NS_FAILED(rv))) {
4683 return rv;
4684 }
4685
4686 rv = lsArchiveTmpFile->Append(NS_LITERAL_STRING(LS_ARCHIVE_TMP_FILE_NAME));
4687 if (NS_WARN_IF(NS_FAILED(rv))) {
4688 return rv;
4689 }
4690
4691 if (journalMode.EqualsLiteral("wal")) {
4692 nsCOMPtr<mozIStorageConnection> lsArchiveTmpConnection;
4693 rv = ss->OpenUnsharedDatabase(lsArchiveTmpFile,
4694 getter_AddRefs(lsArchiveTmpConnection));
4695 if (NS_WARN_IF(NS_FAILED(rv))) {
4696 return rv;
4697 }
4698
4699 // The archive will only be used for lazy data migration. There won't be
4700 // any concurrent readers and writers that could benefit from Write-Ahead
4701 // Logging. So switch to a standard rollback journal. The standard
4702 // rollback journal also provides atomicity across multiple attached
4703 // databases which is import for the lazy data migration to work safely.
4704 rv = lsArchiveTmpConnection->ExecuteSimpleSQL(
4705 NS_LITERAL_CSTRING("PRAGMA journal_mode = DELETE;"));
4706 if (NS_WARN_IF(NS_FAILED(rv))) {
4707 return rv;
4708 }
4709
4710 // The connection will be now implicitely closed (it's always safer to
4711 // close database connection before we manipulate underlying file)
4712 }
4713
4714 // Finally, rename ls-archive-tmp.sqlite to ls-archive.sqlite
4715 rv = lsArchiveTmpFile->MoveTo(nullptr,
4716 NS_LITERAL_STRING(LS_ARCHIVE_FILE_NAME));
4717 if (NS_WARN_IF(NS_FAILED(rv))) {
4718 return rv;
4719 }
4720 } else {
4721 // If webappsstore database is not useable, just create an empty archive.
4722
4723 // Ensure the storage directory actually exists.
4724 nsCOMPtr<nsIFile> storageDirectory;
4725 rv = NS_NewLocalFile(GetStoragePath(), false,
4726 getter_AddRefs(storageDirectory));
4727 if (NS_WARN_IF(NS_FAILED(rv))) {
4728 return rv;
4729 }
4730
4731 bool dummy;
4732 rv = EnsureDirectory(storageDirectory, &dummy);
4733 if (NS_WARN_IF(NS_FAILED(rv))) {
4734 return rv;
4735 }
4736
4737 nsCOMPtr<mozIStorageConnection> lsArchiveConnection;
4738 rv = ss->OpenUnsharedDatabase(lsArchiveFile,
4739 getter_AddRefs(lsArchiveConnection));
4740 if (NS_WARN_IF(NS_FAILED(rv))) {
4741 return rv;
4742 }
4743
4744 rv = StorageDBUpdater::Update(lsArchiveConnection);
4745 if (NS_WARN_IF(NS_FAILED(rv))) {
4746 return rv;
4747 }
4748 }
4749
4750 return NS_OK;
4751 }
4752
4753 #ifdef DEBUG
4754
4755 void QuotaManager::AssertStorageIsInitialized() const {
4756 AssertIsOnIOThread();
4757 MOZ_ASSERT(mStorageInitialized);
4758 }
4759
4760 #endif // DEBUG
4761
4762 nsresult QuotaManager::EnsureStorageIsInitialized() {
4763 AssertIsOnIOThread();
4764
4765 if (mStorageInitialized) {
4766 return NS_OK;
4767 }
4768
4769 nsCOMPtr<nsIFile> storageFile;
4770 nsresult rv = NS_NewLocalFile(mBasePath, false, getter_AddRefs(storageFile));
4771 if (NS_WARN_IF(NS_FAILED(rv))) {
4772 return rv;
4773 }
4774
4775 rv = storageFile->Append(NS_LITERAL_STRING(STORAGE_FILE_NAME));
4776 if (NS_WARN_IF(NS_FAILED(rv))) {
4777 return rv;
4778 }
4779
4780 nsCOMPtr<mozIStorageService> ss =
4781 do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID, &rv);
4782 if (NS_WARN_IF(NS_FAILED(rv))) {
4783 return rv;
4784 }
4785
4786 nsCOMPtr<mozIStorageConnection> connection;
4787 rv = ss->OpenUnsharedDatabase(storageFile, getter_AddRefs(connection));
4788 if (rv == NS_ERROR_FILE_CORRUPTED) {
4789 // Nuke the database file.
4790 rv = storageFile->Remove(false);
4791 if (NS_WARN_IF(NS_FAILED(rv))) {
4792 return rv;
4793 }
4794
4795 rv = ss->OpenUnsharedDatabase(storageFile, getter_AddRefs(connection));
4796 }
4797
4798 if (NS_WARN_IF(NS_FAILED(rv))) {
4799 return rv;
4800 }
4801
4802 // We want extra durability for this important file.
4803 rv = connection->ExecuteSimpleSQL(
4804 NS_LITERAL_CSTRING("PRAGMA synchronous = EXTRA;"));
4805 if (NS_WARN_IF(NS_FAILED(rv))) {
4806 return rv;
4807 }
4808
4809 // Check to make sure that the storage version is correct.
4810 int32_t storageVersion;
4811 rv = connection->GetSchemaVersion(&storageVersion);
4812 if (NS_WARN_IF(NS_FAILED(rv))) {
4813 return rv;
4814 }
4815
4816 // Hacky downgrade logic!
4817 // If we see major.minor of 3.0, downgrade it to be 2.1.
4818 if (storageVersion == kHackyPreDowngradeStorageVersion) {
4819 storageVersion = kHackyPostDowngradeStorageVersion;
4820 rv = connection->SetSchemaVersion(storageVersion);
4821 if (NS_WARN_IF(NS_FAILED(rv))) {
4822 MOZ_ASSERT(false, "Downgrade didn't take.");
4823 return rv;
4824 }
4825 }
4826
4827 if (GetMajorStorageVersion(storageVersion) > kMajorStorageVersion) {
4828 NS_WARNING("Unable to initialize storage, version is too high!");
4829 return NS_ERROR_FAILURE;
4830 }
4831
4832 if (storageVersion < kStorageVersion) {
4833 const bool newDatabase = !storageVersion;
4834
4835 nsCOMPtr<nsIFile> storageDir;
4836 rv = NS_NewLocalFile(mStoragePath, false, getter_AddRefs(storageDir));
4837 if (NS_WARN_IF(NS_FAILED(rv))) {
4838 return rv;
4839 }
4840
4841 bool exists;
4842 rv = storageDir->Exists(&exists);
4843 if (NS_WARN_IF(NS_FAILED(rv))) {
4844 return rv;
4845 }
4846
4847 if (!exists) {
4848 nsCOMPtr<nsIFile> indexedDBDir;
4849 rv = NS_NewLocalFile(mIndexedDBPath, false, getter_AddRefs(indexedDBDir));
4850 if (NS_WARN_IF(NS_FAILED(rv))) {
4851 return rv;
4852 }
4853
4854 rv = indexedDBDir->Exists(&exists);
4855 if (NS_WARN_IF(NS_FAILED(rv))) {
4856 return rv;
4857 }
4858 }
4859
4860 const bool newDirectory = !exists;
4861
4862 if (newDatabase) {
4863 // Set the page size first.
4864 if (kSQLitePageSizeOverride) {
4865 rv = connection->ExecuteSimpleSQL(nsPrintfCString(
4866 "PRAGMA page_size = %" PRIu32 ";", kSQLitePageSizeOverride));
4867 if (NS_WARN_IF(NS_FAILED(rv))) {
4868 return rv;
4869 }
4870 }
4871 }
4872
4873 mozStorageTransaction transaction(
4874 connection, false, mozIStorageConnection::TRANSACTION_IMMEDIATE);
4875
4876 // An upgrade method can upgrade the database, the storage or both.
4877 // The upgrade loop below can only be avoided when there's no database and
4878 // no storage yet (e.g. new profile).
4879 if (newDatabase && newDirectory) {
4880 rv = CreateTables(connection);
4881 if (NS_WARN_IF(NS_FAILED(rv))) {
4882 return rv;
4883 }
4884
4885 MOZ_ASSERT(NS_SUCCEEDED(connection->GetSchemaVersion(&storageVersion)));
4886 MOZ_ASSERT(storageVersion == kStorageVersion);
4887 } else {
4888 // This logic needs to change next time we change the storage!
4889 static_assert(kStorageVersion == int32_t((2 << 16) + 1),
4890 "Upgrade function needed due to storage version increase.");
4891
4892 while (storageVersion != kStorageVersion) {
4893 if (storageVersion == 0) {
4894 rv = UpgradeStorageFrom0_0To1_0(connection);
4895 } else if (storageVersion == MakeStorageVersion(1, 0)) {
4896 rv = UpgradeStorageFrom1_0To2_0(connection);
4897 } else if (storageVersion == MakeStorageVersion(2, 0)) {
4898 rv = UpgradeStorageFrom2_0To2_1(connection);
4899 } else {
4900 NS_WARNING(
4901 "Unable to initialize storage, no upgrade path is "
4902 "available!");
4903 return NS_ERROR_FAILURE;
4904 }
4905
4906 if (NS_WARN_IF(NS_FAILED(rv))) {
4907 return rv;
4908 }
4909
4910 rv = connection->GetSchemaVersion(&storageVersion);
4911 if (NS_WARN_IF(NS_FAILED(rv))) {
4912 return rv;
4913 }
4914 }
4915
4916 MOZ_ASSERT(storageVersion == kStorageVersion);
4917 }
4918
4919 rv = transaction.Commit();
4920 if (NS_WARN_IF(NS_FAILED(rv))) {
4921 return rv;
4922 }
4923 }
4924
4925 if (CachedNextGenLocalStorageEnabled()) {
4926 rv = MaybeCreateLocalStorageArchive();
4927 } else {
4928 rv = MaybeRemoveLocalStorageData();
4929 }
4930 if (NS_WARN_IF(NS_FAILED(rv))) {
4931 return rv;
4932 }
4933
4934 mStorageInitialized = true;
4935
4936 return NS_OK;
4937 }
4938
4939 void QuotaManager::OpenDirectory(PersistenceType aPersistenceType,
4940 const nsACString& aGroup,
4941 const nsACString& aOrigin,
4942 Client::Type aClientType, bool aExclusive,
4943 OpenDirectoryListener* aOpenListener) {
4944 AssertIsOnOwningThread();
4945
4946 RefPtr<DirectoryLockImpl> lock = CreateDirectoryLock(
4947 Nullable<PersistenceType>(aPersistenceType), aGroup,
4948 OriginScope::FromOrigin(aOrigin), Nullable<Client::Type>(aClientType),
4949 aExclusive, false, aOpenListener);
4950 MOZ_ASSERT(lock);
4951 }
4952
4953 void QuotaManager::OpenDirectoryInternal(
4954 const Nullable<PersistenceType>& aPersistenceType,
4955 const OriginScope& aOriginScope, const Nullable<Client::Type>& aClientType,
4956 bool aExclusive, OpenDirectoryListener* aOpenListener) {
4957 AssertIsOnOwningThread();
4958
4959 RefPtr<DirectoryLockImpl> lock = CreateDirectoryLock(
4960 aPersistenceType, EmptyCString(), aOriginScope,
4961 Nullable<Client::Type>(aClientType), aExclusive, true, aOpenListener);
4962 MOZ_ASSERT(lock);
4963
4964 if (!aExclusive) {
4965 return;
4966 }
4967
4968 // All the locks that block this new exclusive lock need to be invalidated.
4969 // We also need to notify clients to abort operations for them.
4970 AutoTArray<nsAutoPtr<nsTHashtable<nsCStringHashKey>>, Client::TYPE_MAX>
4971 origins;
4972 origins.SetLength(Client::TypeMax());
4973
4974 const nsTArray<DirectoryLockImpl*>& blockedOnLocks =
4975 lock->GetBlockedOnLocks();
4976
4977 for (DirectoryLockImpl* blockedOnLock : blockedOnLocks) {
4978 if (!blockedOnLock->IsInternal()) {
4979 blockedOnLock->Invalidate();
4980
4981 MOZ_ASSERT(!blockedOnLock->GetClientType().IsNull());
4982 Client::Type clientType = blockedOnLock->GetClientType().Value();
4983 MOZ_ASSERT(clientType < Client::TypeMax());
4984
4985 const OriginScope& originScope = blockedOnLock->GetOriginScope();
4986 MOZ_ASSERT(originScope.IsOrigin());
4987 MOZ_ASSERT(!originScope.GetOrigin().IsEmpty());
4988
4989 nsAutoPtr<nsTHashtable<nsCStringHashKey>>& origin = origins[clientType];
4990 if (!origin) {
4991 origin = new nsTHashtable<nsCStringHashKey>();
4992 }
4993 origin->PutEntry(originScope.GetOrigin());
4994 }
4995 }
4996
4997 for (uint32_t index : IntegerRange(uint32_t(Client::TypeMax()))) {
4998 if (origins[index]) {
4999 for (auto iter = origins[index]->Iter(); !iter.Done(); iter.Next()) {
5000 MOZ_ASSERT(mClients[index]);
5001
5002 mClients[index]->AbortOperations(iter.Get()->GetKey());
5003 }
5004 }
5005 }
5006 }
5007
5008 nsresult QuotaManager::EnsureOriginIsInitialized(
5009 PersistenceType aPersistenceType, const nsACString& aSuffix,
5010 const nsACString& aGroup, const nsACString& aOrigin,
5011 bool aCreateIfNotExists, nsIFile** aDirectory) {
5012 AssertIsOnIOThread();
5013 MOZ_ASSERT(aDirectory);
5014
5015 nsCOMPtr<nsIFile> directory;
5016 bool created;
5017 nsresult rv = EnsureOriginIsInitializedInternal(
5018 aPersistenceType, aSuffix, aGroup, aOrigin, aCreateIfNotExists,
5019 getter_AddRefs(directory), &created);
5020 if (rv == NS_ERROR_NOT_AVAILABLE) {
5021 return rv;
5022 }
5023 if (NS_WARN_IF(NS_FAILED(rv))) {
5024 return rv;
5025 }
5026
5027 directory.forget(aDirectory);
5028 return NS_OK;
5029 }
5030
5031 nsresult QuotaManager::EnsureOriginIsInitializedInternal(
5032 PersistenceType aPersistenceType, const nsACString& aSuffix,
5033 const nsACString& aGroup, const nsACString& aOrigin,
5034 bool aCreateIfNotExists, nsIFile** aDirectory, bool* aCreated) {
5035 AssertIsOnIOThread();
5036 MOZ_ASSERT(aDirectory);
5037 MOZ_ASSERT(aCreated);
5038
5039 nsresult rv = EnsureStorageIsInitialized();
5040 NS_ENSURE_SUCCESS(rv, rv);
5041
5042 // Get directory for this origin and persistence type.
5043 nsCOMPtr<nsIFile> directory;
5044 rv = GetDirectoryForOrigin(aPersistenceType, aOrigin,
5045 getter_AddRefs(directory));
5046 NS_ENSURE_SUCCESS(rv, rv);
5047
5048 if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
5049 if (mInitializedOrigins.Contains(aOrigin)) {
5050 directory.forget(aDirectory);
5051 *aCreated = false;
5052 return NS_OK;
5053 }
5054 } else {
5055 rv = EnsureTemporaryStorageIsInitialized();
5056 if (NS_WARN_IF(NS_FAILED(rv))) {
5057 return rv;
5058 }
5059 }
5060
5061 bool created;
5062 rv = EnsureOriginDirectory(directory, aCreateIfNotExists, &created);
5063 if (rv == NS_ERROR_NOT_AVAILABLE) {
5064 return rv;
5065 }
5066 if (NS_WARN_IF(NS_FAILED(rv))) {
5067 return rv;
5068 }
5069
5070 int64_t timestamp;
5071 if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
5072 if (created) {
5073 rv = CreateDirectoryMetadataFiles(directory,
5074 /* aPersisted */ true, aSuffix, aGroup,
5075 aOrigin, &timestamp);
5076 if (NS_WARN_IF(NS_FAILED(rv))) {
5077 return rv;
5078 }
5079 } else {
5080 rv = GetDirectoryMetadata2WithRestore(directory,
5081 /* aPersistent */ true, &timestamp,
5082 /* aPersisted */ nullptr);
5083 if (NS_WARN_IF(NS_FAILED(rv))) {
5084 return rv;
5085 }
5086
5087 MOZ_ASSERT(timestamp <= PR_Now());
5088 }
5089
5090 rv = InitializeOrigin(aPersistenceType, aGroup, aOrigin, timestamp,
5091 /* aPersisted */ true, directory);
5092 NS_ENSURE_SUCCESS(rv, rv);
5093
5094 mInitializedOrigins.AppendElement(aOrigin);
5095 } else if (created) {
5096 rv = CreateDirectoryMetadataFiles(directory,
5097 /* aPersisted */ false, aSuffix, aGroup,
5098 aOrigin, &timestamp);
5099 if (NS_WARN_IF(NS_FAILED(rv))) {
5100 return rv;
5101 }
5102
5103 // Don't need to traverse the directory, since it's empty.
5104 InitQuotaForOrigin(aPersistenceType, aGroup, aOrigin,
5105 /* aUsageBytes */ 0, timestamp,
5106 /* aPersisted */ false);
5107 }
5108
5109 directory.forget(aDirectory);
5110 *aCreated = created;
5111 return NS_OK;
5112 }
5113
5114 nsresult QuotaManager::EnsureTemporaryStorageIsInitialized() {
5115 AssertIsOnIOThread();
5116 MOZ_ASSERT(mStorageInitialized);
5117
5118 if (mTemporaryStorageInitialized) {
5119 return NS_OK;
5120 }
5121
5122 TimeStamp startTime = TimeStamp::Now();
5123
5124 // A keeper to defer the return only in Nightly, so that the telemetry data
5125 // for whole profile can be collected
5126 nsresult statusKeeper = NS_OK;
5127
5128 nsresult rv = InitializeRepository(PERSISTENCE_TYPE_DEFAULT);
5129 if (NS_WARN_IF(NS_FAILED(rv))) {
5130 RECORD_IN_NIGHTLY(statusKeeper, rv);
5131
5132 #ifndef NIGHTLY_BUILD
5133 // We have to cleanup partially initialized quota.
5134 RemoveQuota();
5135
5136 return rv;
5137 #endif
5138 }
5139
5140 rv = InitializeRepository(PERSISTENCE_TYPE_TEMPORARY);
5141 if (NS_WARN_IF(NS_FAILED(rv)) || NS_FAILED(statusKeeper)) {
5142 // We have to cleanup partially initialized quota.
5143 RemoveQuota();
5144
5145 #ifdef NIGHTLY_BUILD
5146 return NS_FAILED(statusKeeper) ? statusKeeper : rv;
5147 #else
5148 return rv;
5149 #endif
5150 }
5151
5152 Telemetry::AccumulateTimeDelta(Telemetry::QM_REPOSITORIES_INITIALIZATION_TIME,
5153 startTime, TimeStamp::Now());
5154
5155 if (gFixedLimitKB >= 0) {
5156 mTemporaryStorageLimit = static_cast<uint64_t>(gFixedLimitKB) * 1024;
5157 } else {
5158 nsCOMPtr<nsIFile> storageDir =
5159 do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv);
5160 if (NS_WARN_IF(NS_FAILED(rv))) {
5161 return rv;
5162 }
5163
5164 rv = storageDir->InitWithPath(GetStoragePath());
5165 if (NS_WARN_IF(NS_FAILED(rv))) {
5166 return rv;
5167 }
5168
5169 rv = GetTemporaryStorageLimit(storageDir, mTemporaryStorageUsage,
5170 &mTemporaryStorageLimit);
5171 if (NS_WARN_IF(NS_FAILED(rv))) {
5172 return rv;
5173 }
5174 }
5175
5176 mTemporaryStorageInitialized = true;
5177
5178 CheckTemporaryStorageLimits();
5179
5180 return rv;
5181 }
5182
5183 nsresult QuotaManager::EnsureOriginDirectory(nsIFile* aDirectory,
5184 bool aCreateIfNotExists,
5185 bool* aCreated) {
5186 AssertIsOnIOThread();
5187 MOZ_ASSERT(aDirectory);
5188 MOZ_ASSERT(aCreated);
5189
5190 bool exists;
5191 nsresult rv = aDirectory->Exists(&exists);
5192 if (NS_WARN_IF(NS_FAILED(rv))) {
5193 return rv;
5194 }
5195
5196 if (!exists) {
5197 if (!aCreateIfNotExists) {
5198 return NS_ERROR_NOT_AVAILABLE;
5199 }
5200
5201 nsString leafName;
5202 rv = aDirectory->GetLeafName(leafName);
5203 if (NS_WARN_IF(NS_FAILED(rv))) {
5204 return rv;
5205 }
5206
5207 if (!leafName.EqualsLiteral(kChromeOrigin) &&
5208 !IsSanitizedOriginValid(NS_ConvertUTF16toUTF8(leafName))) {
5209 QM_WARNING(
5210 "Preventing creation of a new origin directory which is not "
5211 "supported by our origin parser or is obsolete!");
5212 return NS_ERROR_FAILURE;
5213 }
5214 }
5215
5216 rv = EnsureDirectory(aDirectory, aCreated);
5217 if (NS_WARN_IF(NS_FAILED(rv))) {
5218 return rv;
5219 }
5220
5221 return NS_OK;
5222 }
5223
5224 nsresult QuotaManager::AboutToClearOrigins(
5225 const Nullable<PersistenceType>& aPersistenceType,
5226 const OriginScope& aOriginScope,
5227 const Nullable<Client::Type>& aClientType) {
5228 AssertIsOnIOThread();
5229
5230 nsresult rv;
5231
5232 if (aClientType.IsNull()) {
5233 for (uint32_t index = 0; index < uint32_t(Client::TypeMax()); index++) {
5234 rv = mClients[index]->AboutToClearOrigins(aPersistenceType, aOriginScope);
5235 if (NS_WARN_IF(NS_FAILED(rv))) {
5236 return rv;
5237 }
5238 }
5239 } else {
5240 rv = mClients[aClientType.Value()]->AboutToClearOrigins(aPersistenceType,
5241 aOriginScope);
5242 if (NS_WARN_IF(NS_FAILED(rv))) {
5243 return rv;
5244 }
5245 }
5246
5247 return NS_OK;
5248 }
5249
5250 void QuotaManager::OriginClearCompleted(
5251 PersistenceType aPersistenceType, const nsACString& aOrigin,
5252 const Nullable<Client::Type>& aClientType) {
5253 AssertIsOnIOThread();
5254
5255 if (aClientType.IsNull()) {
5256 if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
5257 mInitializedOrigins.RemoveElement(aOrigin);
5258 }
5259
5260 for (uint32_t index = 0; index < uint32_t(Client::TypeMax()); index++) {
5261 mClients[index]->OnOriginClearCompleted(aPersistenceType, aOrigin);
5262 }
5263 } else {
5264 mClients[aClientType.Value()]->OnOriginClearCompleted(aPersistenceType,
5265 aOrigin);
5266 }
5267 }
5268
5269 void QuotaManager::ResetOrClearCompleted() {
5270 AssertIsOnIOThread();
5271
5272 mInitializedOrigins.Clear();
5273 mTemporaryStorageInitialized = false;
5274 mStorageInitialized = false;
5275
5276 ReleaseIOThreadObjects();
5277 }
5278
5279 Client* QuotaManager::GetClient(Client::Type aClientType) {
5280 MOZ_ASSERT(aClientType >= Client::IDB);
5281 MOZ_ASSERT(aClientType < Client::TypeMax());
5282
5283 return mClients.ElementAt(aClientType);
5284 }
5285
5286 uint64_t QuotaManager::GetGroupLimit() const {
5287 MOZ_ASSERT(mTemporaryStorageInitialized);
5288
5289 // To avoid one group evicting all the rest, limit the amount any one group
5290 // can use to 20%. To prevent individual sites from using exorbitant amounts
5291 // of storage where there is a lot of free space, cap the group limit to 2GB.
5292 uint64_t x = std::min<uint64_t>(mTemporaryStorageLimit * .20, 2 GB);
5293
5294 // In low-storage situations, make an exception (while not exceeding the total
5295 // storage limit).
5296 return std::min<uint64_t>(mTemporaryStorageLimit,
5297 std::max<uint64_t>(x, 10 MB));
5298 }
5299
5300 void QuotaManager::GetGroupUsageAndLimit(const nsACString& aGroup,
5301 UsageInfo* aUsageInfo) {
5302 AssertIsOnIOThread();
5303 MOZ_ASSERT(aUsageInfo);
5304
5305 {
5306 MutexAutoLock lock(mQuotaMutex);
5307
5308 aUsageInfo->SetLimit(GetGroupLimit());
5309 aUsageInfo->ResetUsage();
5310
5311 GroupInfoPair* pair;
5312 if (!mGroupInfoPairs.Get(aGroup, &pair)) {
5313 return;
5314 }
5315
5316 // Calculate temporary group usage
5317 RefPtr<GroupInfo> temporaryGroupInfo =
5318 pair->LockedGetGroupInfo(PERSISTENCE_TYPE_TEMPORARY);
5319 if (temporaryGroupInfo) {
5320 aUsageInfo->AppendToDatabaseUsage(temporaryGroupInfo->mUsage);
5321 }
5322
5323 // Calculate default group usage
5324 RefPtr<GroupInfo> defaultGroupInfo =
5325 pair->LockedGetGroupInfo(PERSISTENCE_TYPE_DEFAULT);
5326 if (defaultGroupInfo) {
5327 aUsageInfo->AppendToDatabaseUsage(defaultGroupInfo->mUsage);
5328 }
5329 }
5330 }
5331
5332 void QuotaManager::NotifyStoragePressure(uint64_t aUsage) {
5333 mQuotaMutex.AssertNotCurrentThreadOwns();
5334
5335 RefPtr<StoragePressureRunnable> storagePressureRunnable =
5336 new StoragePressureRunnable(aUsage);
5337
5338 MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(storagePressureRunnable));
5339 }
5340
5341 // static
5342 void QuotaManager::GetStorageId(PersistenceType aPersistenceType,
5343 const nsACString& aOrigin,
5344 Client::Type aClientType,
5345 nsACString& aDatabaseId) {
5346 nsAutoCString str;
5347 str.AppendInt(aPersistenceType);
5348 str.Append('*');
5349 str.Append(aOrigin);
5350 str.Append('*');
5351 str.AppendInt(aClientType);
5352
5353 aDatabaseId = str;
5354 }
5355
5356 // static
5357 nsresult QuotaManager::GetInfoFromPrincipal(nsIPrincipal* aPrincipal,
5358 nsACString* aSuffix,
5359 nsACString* aGroup,
5360 nsACString* aOrigin) {
5361 MOZ_ASSERT(NS_IsMainThread());
5362 MOZ_ASSERT(aPrincipal);
5363
5364 if (nsContentUtils::IsSystemPrincipal(aPrincipal)) {
5365 GetInfoForChrome(aSuffix, aGroup, aOrigin);
5366 return NS_OK;
5367 }
5368
5369 if (aPrincipal->GetIsNullPrincipal()) {
5370 NS_WARNING("IndexedDB not supported from this principal!");
5371 return NS_ERROR_FAILURE;
5372 }
5373
5374 nsCString origin;
5375 nsresult rv = aPrincipal->GetOrigin(origin);
5376 NS_ENSURE_SUCCESS(rv, rv);
5377
5378 if (origin.EqualsLiteral(kChromeOrigin)) {
5379 NS_WARNING("Non-chrome principal can't use chrome origin!");
5380 return NS_ERROR_FAILURE;
5381 }
5382
5383 nsCString suffix;
5384 aPrincipal->OriginAttributesRef().CreateSuffix(suffix);
5385
5386 if (aSuffix) {
5387 aSuffix->Assign(suffix);
5388 }
5389
5390 if (aGroup) {
5391 nsCString baseDomain;
5392 rv = aPrincipal->GetBaseDomain(baseDomain);
5393 if (NS_FAILED(rv)) {
5394 // A hack for JetPack.
5395
5396 nsCOMPtr<nsIURI> uri;
5397 rv = aPrincipal->GetURI(getter_AddRefs(uri));
5398 NS_ENSURE_SUCCESS(rv, rv);
5399
5400 bool isIndexedDBURI = false;
5401 rv = uri->SchemeIs("indexedDB", &isIndexedDBURI);
5402 NS_ENSURE_SUCCESS(rv, rv);
5403
5404 if (isIndexedDBURI) {
5405 rv = NS_OK;
5406 }
5407 }
5408 NS_ENSURE_SUCCESS(rv, rv);
5409
5410 if (baseDomain.IsEmpty()) {
5411 aGroup->Assign(origin);
5412 } else {
5413 aGroup->Assign(baseDomain + suffix);
5414 }
5415 }
5416
5417 if (aOrigin) {
5418 aOrigin->Assign(origin);
5419 }
5420
5421 return NS_OK;
5422 }
5423
5424 // static
5425 nsresult QuotaManager::GetInfoFromWindow(nsPIDOMWindowOuter* aWindow,
5426 nsACString* aSuffix,
5427 nsACString* aGroup,
5428 nsACString* aOrigin) {
5429 MOZ_ASSERT(NS_IsMainThread());
5430 MOZ_ASSERT(aWindow);
5431
5432 nsCOMPtr<nsIScriptObjectPrincipal> sop = do_QueryInterface(aWindow);
5433 NS_ENSURE_TRUE(sop, NS_ERROR_FAILURE);
5434
5435 nsCOMPtr<nsIPrincipal> principal = sop->GetPrincipal();
5436 NS_ENSURE_TRUE(principal, NS_ERROR_FAILURE);
5437
5438 nsresult rv = GetInfoFromPrincipal(principal, aSuffix, aGroup, aOrigin);
5439 NS_ENSURE_SUCCESS(rv, rv);
5440
5441 return NS_OK;
5442 }
5443
5444 // static
5445 void QuotaManager::GetInfoForChrome(nsACString* aSuffix, nsACString* aGroup,
5446 nsACString* aOrigin) {
5447 MOZ_ASSERT(NS_IsMainThread());
5448 MOZ_ASSERT(nsContentUtils::LegacyIsCallerChromeOrNativeCode());
5449
5450 if (aSuffix) {
5451 aSuffix->Assign(EmptyCString());
5452 }
5453 if (aGroup) {
5454 ChromeOrigin(*aGroup);
5455 }
5456 if (aOrigin) {
5457 ChromeOrigin(*aOrigin);
5458 }
5459 }
5460
5461 // static
5462 bool QuotaManager::IsOriginInternal(const nsACString& aOrigin) {
5463 MOZ_ASSERT(!aOrigin.IsEmpty());
5464
5465 // The first prompt is not required for these origins.
5466 if (aOrigin.EqualsLiteral(kChromeOrigin) ||
5467 StringBeginsWith(aOrigin, nsDependentCString(kAboutHomeOriginPrefix)) ||
5468 StringBeginsWith(aOrigin, nsDependentCString(kIndexedDBOriginPrefix)) ||
5469 StringBeginsWith(aOrigin, nsDependentCString(kResourceOriginPrefix))) {
5470 return true;
5471 }
5472
5473 return false;
5474 }
5475
5476 // static
5477 void QuotaManager::ChromeOrigin(nsACString& aOrigin) {
5478 aOrigin.AssignLiteral(kChromeOrigin);
5479 }
5480
5481 // static
5482 bool QuotaManager::AreOriginsEqualOnDisk(nsACString& aOrigin1,
5483 nsACString& aOrigin2) {
5484 nsCString origin1Sanitized(aOrigin1);
5485 SanitizeOriginString(origin1Sanitized);
5486
5487 nsCString origin2Sanitized(aOrigin2);
5488 SanitizeOriginString(origin2Sanitized);
5489
5490 return origin1Sanitized == origin2Sanitized;
5491 }
5492
5493 // static
5494 bool QuotaManager::ParseOrigin(const nsACString& aOrigin, nsCString& aSpec,
5495 OriginAttributes* aAttrs) {
5496 MOZ_ASSERT(aAttrs);
5497
5498 if (aOrigin.Equals(kChromeOrigin)) {
5499 aSpec = kChromeOrigin;
5500 return true;
5501 }
5502
5503 nsCString sanitizedOrigin(aOrigin);
5504 SanitizeOriginString(sanitizedOrigin);
5505
5506 OriginParser::ResultType result =
5507 OriginParser::ParseOrigin(sanitizedOrigin, aSpec, aAttrs);
5508 if (NS_WARN_IF(result != OriginParser::ValidOrigin)) {
5509 return false;
5510 }
5511
5512 return true;
5513 }
5514
5515 uint64_t QuotaManager::LockedCollectOriginsForEviction(
5516 uint64_t aMinSizeToBeFreed, nsTArray<RefPtr<DirectoryLockImpl>>& aLocks) {
5517 mQuotaMutex.AssertCurrentThreadOwns();
5518
5519 RefPtr<CollectOriginsHelper> helper =
5520 new CollectOriginsHelper(mQuotaMutex, aMinSizeToBeFreed);
5521
5522 // Unlock while calling out to XPCOM (code behind the dispatch method needs
5523 // to acquire its own lock which can potentially lead to a deadlock and it
5524 // also calls an observer that can do various stuff like IO, so it's better
5525 // to not hold our mutex while that happens).
5526 {
5527 MutexAutoUnlock autoUnlock(mQuotaMutex);
5528
5529 MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(helper, NS_DISPATCH_NORMAL));
5530 }
5531
5532 return helper->BlockAndReturnOriginsForEviction(aLocks);
5533 }
5534
5535 void QuotaManager::LockedRemoveQuotaForOrigin(PersistenceType aPersistenceType,
5536 const nsACString& aGroup,
5537 const nsACString& aOrigin) {
5538 mQuotaMutex.AssertCurrentThreadOwns();
5539 MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_PERSISTENT);
5540
5541 GroupInfoPair* pair;
5542 mGroupInfoPairs.Get(aGroup, &pair);
5543
5544 if (!pair) {
5545 return;
5546 }
5547
5548 RefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
5549 if (groupInfo) {
5550 groupInfo->LockedRemoveOriginInfo(aOrigin);
5551
5552 if (!groupInfo->LockedHasOriginInfos()) {
5553 pair->LockedClearGroupInfo(aPersistenceType);
5554
5555 if (!pair->LockedHasGroupInfos()) {
5556 mGroupInfoPairs.Remove(aGroup);
5557 }
5558 }
5559 }
5560 }
5561
5562 already_AddRefed<OriginInfo> QuotaManager::LockedGetOriginInfo(
5563 PersistenceType aPersistenceType, const nsACString& aGroup,
5564 const nsACString& aOrigin) {
5565 mQuotaMutex.AssertCurrentThreadOwns();
5566 MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_PERSISTENT);
5567
5568 GroupInfoPair* pair;
5569 if (mGroupInfoPairs.Get(aGroup, &pair)) {
5570 RefPtr<GroupInfo> groupInfo = pair->LockedGetGroupInfo(aPersistenceType);
5571 if (groupInfo) {
5572 return groupInfo->LockedGetOriginInfo(aOrigin);
5573 }
5574 }
5575
5576 return nullptr;
5577 }
5578
5579 void QuotaManager::CheckTemporaryStorageLimits() {
5580 AssertIsOnIOThread();
5581
5582 nsTArray<OriginInfo*> doomedOriginInfos;
5583 {
5584 MutexAutoLock lock(mQuotaMutex);
5585
5586 for (auto iter = mGroupInfoPairs.Iter(); !iter.Done(); iter.Next()) {
5587 GroupInfoPair* pair = iter.UserData();
5588
5589 MOZ_ASSERT(!iter.Key().IsEmpty(), "Empty key!");
5590 MOZ_ASSERT(pair, "Null pointer!");
5591
5592 uint64_t groupUsage = 0;
5593
5594 RefPtr<GroupInfo> temporaryGroupInfo =
5595 pair->LockedGetGroupInfo(PERSISTENCE_TYPE_TEMPORARY);
5596 if (temporaryGroupInfo) {
5597 groupUsage += temporaryGroupInfo->mUsage;
5598 }
5599
5600 RefPtr<GroupInfo> defaultGroupInfo =
5601 pair->LockedGetGroupInfo(PERSISTENCE_TYPE_DEFAULT);
5602 if (defaultGroupInfo) {
5603 groupUsage += defaultGroupInfo->mUsage;
5604 }
5605
5606 if (groupUsage > 0) {
5607 QuotaManager* quotaManager = QuotaManager::Get();
5608 MOZ_ASSERT(quotaManager, "Shouldn't be null!");
5609
5610 if (groupUsage > quotaManager->GetGroupLimit()) {
5611 nsTArray<OriginInfo*> originInfos;
5612 if (temporaryGroupInfo) {
5613 originInfos.AppendElements(temporaryGroupInfo->mOriginInfos);
5614 }
5615 if (defaultGroupInfo) {
5616 originInfos.AppendElements(defaultGroupInfo->mOriginInfos);
5617 }
5618 originInfos.Sort(OriginInfoLRUComparator());
5619
5620 for (uint32_t i = 0; i < originInfos.Length(); i++) {
5621 OriginInfo* originInfo = originInfos[i];
5622 if (originInfo->LockedPersisted()) {
5623 continue;
5624 }
5625
5626 doomedOriginInfos.AppendElement(originInfo);
5627 groupUsage -= originInfo->mUsage;
5628
5629 if (groupUsage <= quotaManager->GetGroupLimit()) {
5630 break;
5631 }
5632 }
5633 }
5634 }
5635 }
5636
5637 uint64_t usage = 0;
5638 for (uint32_t index = 0; index < doomedOriginInfos.Length(); index++) {
5639 usage += doomedOriginInfos[index]->mUsage;
5640 }
5641
5642 if (mTemporaryStorageUsage - usage > mTemporaryStorageLimit) {
5643 nsTArray<OriginInfo*> originInfos;
5644
5645 for (auto iter = mGroupInfoPairs.Iter(); !iter.Done(); iter.Next()) {
5646 GroupInfoPair* pair = iter.UserData();
5647
5648 MOZ_ASSERT(!iter.Key().IsEmpty(), "Empty key!");
5649 MOZ_ASSERT(pair, "Null pointer!");
5650
5651 RefPtr<GroupInfo> groupInfo =
5652 pair->LockedGetGroupInfo(PERSISTENCE_TYPE_TEMPORARY);
5653 if (groupInfo) {
5654 originInfos.AppendElements(groupInfo->mOriginInfos);
5655 }
5656
5657 groupInfo = pair->LockedGetGroupInfo(PERSISTENCE_TYPE_DEFAULT);
5658 if (groupInfo) {
5659 originInfos.AppendElements(groupInfo->mOriginInfos);
5660 }
5661 }
5662
5663 for (uint32_t index = originInfos.Length(); index > 0; index--) {
5664 if (doomedOriginInfos.Contains(originInfos[index - 1]) ||
5665 originInfos[index - 1]->LockedPersisted()) {
5666 originInfos.RemoveElementAt(index - 1);
5667 }
5668 }
5669
5670 originInfos.Sort(OriginInfoLRUComparator());
5671
5672 for (uint32_t i = 0; i < originInfos.Length(); i++) {
5673 if (mTemporaryStorageUsage - usage <= mTemporaryStorageLimit) {
5674 originInfos.TruncateLength(i);
5675 break;
5676 }
5677
5678 usage += originInfos[i]->mUsage;
5679 }
5680
5681 doomedOriginInfos.AppendElements(originInfos);
5682 }
5683 }
5684
5685 for (uint32_t index = 0; index < doomedOriginInfos.Length(); index++) {
5686 OriginInfo* doomedOriginInfo = doomedOriginInfos[index];
5687
5688 #ifdef DEBUG
5689 {
5690 MutexAutoLock lock(mQuotaMutex);
5691 MOZ_ASSERT(!doomedOriginInfo->LockedPersisted());
5692 }
5693 #endif
5694
5695 DeleteFilesForOrigin(doomedOriginInfo->mGroupInfo->mPersistenceType,
5696 doomedOriginInfo->mOrigin);
5697 }
5698
5699 nsTArray<OriginParams> doomedOrigins;
5700 {
5701 MutexAutoLock lock(mQuotaMutex);
5702
5703 for (uint32_t index = 0; index < doomedOriginInfos.Length(); index++) {
5704 OriginInfo* doomedOriginInfo = doomedOriginInfos[index];
5705
5706 PersistenceType persistenceType =
5707 doomedOriginInfo->mGroupInfo->mPersistenceType;
5708 nsCString group = doomedOriginInfo->mGroupInfo->mGroup;
5709 nsCString origin = doomedOriginInfo->mOrigin;
5710 LockedRemoveQuotaForOrigin(persistenceType, group, origin);
5711
5712 #ifdef DEBUG
5713 doomedOriginInfos[index] = nullptr;
5714 #endif
5715
5716 doomedOrigins.AppendElement(OriginParams(persistenceType, origin));
5717 }
5718 }
5719
5720 for (const OriginParams& doomedOrigin : doomedOrigins) {
5721 OriginClearCompleted(doomedOrigin.mPersistenceType, doomedOrigin.mOrigin,
5722 Nullable<Client::Type>());
5723 }
5724
5725 if (mTemporaryStorageUsage > mTemporaryStorageLimit) {
5726 // If disk space is still low after origin clear, notify storage pressure.
5727 NotifyStoragePressure(mTemporaryStorageUsage);
5728 }
5729 }
5730
5731 void QuotaManager::DeleteFilesForOrigin(PersistenceType aPersistenceType,
5732 const nsACString& aOrigin) {
5733 nsCOMPtr<nsIFile> directory;
5734 nsresult rv = GetDirectoryForOrigin(aPersistenceType, aOrigin,
5735 getter_AddRefs(directory));
5736 NS_ENSURE_SUCCESS_VOID(rv);
5737
5738 rv = directory->Remove(true);
5739 if (rv != NS_ERROR_FILE_TARGET_DOES_NOT_EXIST &&
5740 rv != NS_ERROR_FILE_NOT_FOUND && NS_FAILED(rv)) {
5741 // This should never fail if we've closed all storage connections
5742 // correctly...
5743 NS_ERROR("Failed to remove directory!");
5744 }
5745 }
5746
5747 void QuotaManager::FinalizeOriginEviction(
5748 nsTArray<RefPtr<DirectoryLockImpl>>& aLocks) {
5749 NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
5750
5751 RefPtr<FinalizeOriginEvictionOp> op =
5752 new FinalizeOriginEvictionOp(mOwningThread, aLocks);
5753
5754 if (IsOnIOThread()) {
5755 op->RunOnIOThreadImmediately();
5756 } else {
5757 op->Dispatch();
5758 }
5759 }
5760
5761 void QuotaManager::ShutdownTimerCallback(nsITimer* aTimer, void* aClosure) {
5762 AssertIsOnBackgroundThread();
5763
5764 auto quotaManager = static_cast<QuotaManager*>(aClosure);
5765 MOZ_ASSERT(quotaManager);
5766
5767 NS_WARNING(
5768 "Some storage operations are taking longer than expected "
5769 "during shutdown and will be aborted!");
5770
5771 // Abort all operations.
5772 for (RefPtr<Client>& client : quotaManager->mClients) {
5773 client->AbortOperations(VoidCString());
5774 }
5775 }
5776
5777 auto QuotaManager::GetDirectoryLockTable(PersistenceType aPersistenceType)
5778 -> DirectoryLockTable& {
5779 switch (aPersistenceType) {
5780 case PERSISTENCE_TYPE_TEMPORARY:
5781 return mTemporaryDirectoryLockTable;
5782 case PERSISTENCE_TYPE_DEFAULT:
5783 return mDefaultDirectoryLockTable;
5784
5785 case PERSISTENCE_TYPE_PERSISTENT:
5786 case PERSISTENCE_TYPE_INVALID:
5787 default:
5788 MOZ_CRASH("Bad persistence type value!");
5789 }
5790 }
5791
5792 bool QuotaManager::IsSanitizedOriginValid(const nsACString& aSanitizedOrigin) {
5793 AssertIsOnIOThread();
5794 MOZ_ASSERT(!aSanitizedOrigin.Equals(kChromeOrigin));
5795
5796 bool valid;
5797 if (auto entry = mValidOrigins.LookupForAdd(aSanitizedOrigin)) {
5798 // We already parsed this sanitized origin string.
5799 valid = entry.Data();
5800 } else {
5801 nsCString spec;
5802 OriginAttributes attrs;
5803 OriginParser::ResultType result =
5804 OriginParser::ParseOrigin(aSanitizedOrigin, spec, &attrs);
5805
5806 valid = result == OriginParser::ValidOrigin;
5807 entry.OrInsert([valid]() { return valid; });
5808 }
5809
5810 return valid;
5811 }
5812
5813 /*******************************************************************************
5814 * Local class implementations
5815 ******************************************************************************/
5816
5817 OriginInfo::OriginInfo(GroupInfo* aGroupInfo, const nsACString& aOrigin,
5818 uint64_t aUsage, int64_t aAccessTime, bool aPersisted)
5819 : mGroupInfo(aGroupInfo),
5820 mOrigin(aOrigin),
5821 mUsage(aUsage),
5822 mAccessTime(aAccessTime),
5823 mPersisted(aPersisted) {
5824 MOZ_ASSERT(aGroupInfo);
5825 MOZ_ASSERT_IF(aPersisted,
5826 aGroupInfo->mPersistenceType == PERSISTENCE_TYPE_DEFAULT);
5827
5828 MOZ_COUNT_CTOR(OriginInfo);
5829 }
5830
5831 void OriginInfo::LockedDecreaseUsage(int64_t aSize) {
5832 AssertCurrentThreadOwnsQuotaMutex();
5833
5834 AssertNoUnderflow(mUsage, aSize);
5835 mUsage -= aSize;
5836
5837 if (!LockedPersisted()) {
5838 AssertNoUnderflow(mGroupInfo->mUsage, aSize);
5839 mGroupInfo->mUsage -= aSize;
5840 }
5841
5842 QuotaManager* quotaManager = QuotaManager::Get();
5843 MOZ_ASSERT(quotaManager);
5844
5845 AssertNoUnderflow(quotaManager->mTemporaryStorageUsage, aSize);
5846 quotaManager->mTemporaryStorageUsage -= aSize;
5847 }
5848
5849 void OriginInfo::LockedPersist() {
5850 AssertCurrentThreadOwnsQuotaMutex();
5851 MOZ_ASSERT(mGroupInfo->mPersistenceType == PERSISTENCE_TYPE_DEFAULT);
5852 MOZ_ASSERT(!mPersisted);
5853
5854 mPersisted = true;
5855
5856 // Remove Usage from GroupInfo
5857 AssertNoUnderflow(mGroupInfo->mUsage, mUsage);
5858 mGroupInfo->mUsage -= mUsage;
5859 }
5860
5861 already_AddRefed<OriginInfo> GroupInfo::LockedGetOriginInfo(
5862 const nsACString& aOrigin) {
5863 AssertCurrentThreadOwnsQuotaMutex();
5864
5865 for (RefPtr<OriginInfo>& originInfo : mOriginInfos) {
5866 if (originInfo->mOrigin == aOrigin) {
5867 RefPtr<OriginInfo> result = originInfo;
5868 return result.forget();
5869 }
5870 }
5871
5872 return nullptr;
5873 }
5874
5875 void GroupInfo::LockedAddOriginInfo(OriginInfo* aOriginInfo) {
5876 AssertCurrentThreadOwnsQuotaMutex();
5877
5878 NS_ASSERTION(!mOriginInfos.Contains(aOriginInfo),
5879 "Replacing an existing entry!");
5880 mOriginInfos.AppendElement(aOriginInfo);
5881
5882 if (!aOriginInfo->LockedPersisted()) {
5883 AssertNoOverflow(mUsage, aOriginInfo->mUsage);
5884 mUsage += aOriginInfo->mUsage;
5885 }
5886
5887 QuotaManager* quotaManager = QuotaManager::Get();
5888 MOZ_ASSERT(quotaManager);
5889
5890 AssertNoOverflow(quotaManager->mTemporaryStorageUsage, aOriginInfo->mUsage);
5891 quotaManager->mTemporaryStorageUsage += aOriginInfo->mUsage;
5892 }
5893
5894 void GroupInfo::LockedRemoveOriginInfo(const nsACString& aOrigin) {
5895 AssertCurrentThreadOwnsQuotaMutex();
5896
5897 for (uint32_t index = 0; index < mOriginInfos.Length(); index++) {
5898 if (mOriginInfos[index]->mOrigin == aOrigin) {
5899 if (!mOriginInfos[index]->LockedPersisted()) {
5900 AssertNoUnderflow(mUsage, mOriginInfos[index]->mUsage);
5901 mUsage -= mOriginInfos[index]->mUsage;
5902 }
5903
5904 QuotaManager* quotaManager = QuotaManager::Get();
5905 MOZ_ASSERT(quotaManager);
5906
5907 AssertNoUnderflow(quotaManager->mTemporaryStorageUsage,
5908 mOriginInfos[index]->mUsage);
5909 quotaManager->mTemporaryStorageUsage -= mOriginInfos[index]->mUsage;
5910
5911 mOriginInfos.RemoveElementAt(index);
5912
5913 return;
5914 }
5915 }
5916 }
5917
5918 void GroupInfo::LockedRemoveOriginInfos() {
5919 AssertCurrentThreadOwnsQuotaMutex();
5920
5921 QuotaManager* quotaManager = QuotaManager::Get();
5922 MOZ_ASSERT(quotaManager);
5923
5924 for (uint32_t index = mOriginInfos.Length(); index > 0; index--) {
5925 OriginInfo* originInfo = mOriginInfos[index - 1];
5926
5927 if (!originInfo->LockedPersisted()) {
5928 AssertNoUnderflow(mUsage, originInfo->mUsage);
5929 mUsage -= originInfo->mUsage;
5930 }
5931
5932 AssertNoUnderflow(quotaManager->mTemporaryStorageUsage, originInfo->mUsage);
5933 quotaManager->mTemporaryStorageUsage -= originInfo->mUsage;
5934
5935 mOriginInfos.RemoveElementAt(index - 1);
5936 }
5937 }
5938
5939 RefPtr<GroupInfo>& GroupInfoPair::GetGroupInfoForPersistenceType(
5940 PersistenceType aPersistenceType) {
5941 switch (aPersistenceType) {
5942 case PERSISTENCE_TYPE_TEMPORARY:
5943 return mTemporaryStorageGroupInfo;
5944 case PERSISTENCE_TYPE_DEFAULT:
5945 return mDefaultStorageGroupInfo;
5946
5947 case PERSISTENCE_TYPE_PERSISTENT:
5948 case PERSISTENCE_TYPE_INVALID:
5949 default:
5950 MOZ_CRASH("Bad persistence type value!");
5951 }
5952 }
5953
5954 CollectOriginsHelper::CollectOriginsHelper(mozilla::Mutex& aMutex,
5955 uint64_t aMinSizeToBeFreed)
5956 : Runnable("dom::quota::CollectOriginsHelper"),
5957 mMinSizeToBeFreed(aMinSizeToBeFreed),
5958 mMutex(aMutex),
5959 mCondVar(aMutex, "CollectOriginsHelper::mCondVar"),
5960 mSizeToBeFreed(0),
5961 mWaiting(true) {
5962 MOZ_ASSERT(!NS_IsMainThread(), "Wrong thread!");
5963 mMutex.AssertCurrentThreadOwns();
5964 }
5965
5966 int64_t CollectOriginsHelper::BlockAndReturnOriginsForEviction(
5967 nsTArray<RefPtr<DirectoryLockImpl>>& aLocks) {
5968 MOZ_ASSERT(!NS_IsMainThread(), "Wrong thread!");
5969 mMutex.AssertCurrentThreadOwns();
5970
5971 while (mWaiting) {
5972 mCondVar.Wait();
5973 }
5974
5975 mLocks.SwapElements(aLocks);
5976 return mSizeToBeFreed;
5977 }
5978
5979 NS_IMETHODIMP
5980 CollectOriginsHelper::Run() {
5981 AssertIsOnBackgroundThread();
5982
5983 QuotaManager* quotaManager = QuotaManager::Get();
5984 NS_ASSERTION(quotaManager, "Shouldn't be null!");
5985
5986 // We use extra stack vars here to avoid race detector warnings (the same
5987 // memory accessed with and without the lock held).
5988 nsTArray<RefPtr<DirectoryLockImpl>> locks;
5989 uint64_t sizeToBeFreed =
5990 quotaManager->CollectOriginsForEviction(mMinSizeToBeFreed, locks);
5991
5992 MutexAutoLock lock(mMutex);
5993
5994 NS_ASSERTION(mWaiting, "Huh?!");
5995
5996 mLocks.SwapElements(locks);
5997 mSizeToBeFreed = sizeToBeFreed;
5998 mWaiting = false;
5999 mCondVar.Notify();
6000
6001 return NS_OK;
6002 }
6003
6004 /*******************************************************************************
6005 * OriginOperationBase
6006 ******************************************************************************/
6007
6008 NS_IMETHODIMP
6009 OriginOperationBase::Run() {
6010 nsresult rv;
6011
6012 switch (mState) {
6013 case State_Initial: {
6014 rv = Init();
6015 break;
6016 }
6017
6018 case State_Initializing: {
6019 rv = InitOnMainThread();
6020 break;
6021 }
6022
6023 case State_FinishingInit: {
6024 rv = FinishInit();
6025 break;
6026 }
6027
6028 case State_CreatingQuotaManager: {
6029 rv = QuotaManagerOpen();
6030 break;
6031 }
6032
6033 case State_DirectoryOpenPending: {
6034 rv = DirectoryOpen();
6035 break;
6036 }
6037
6038 case State_DirectoryWorkOpen: {
6039 rv = DirectoryWork();
6040 break;
6041 }
6042
6043 case State_UnblockingOpen: {
6044 UnblockOpen();
6045 return NS_OK;
6046 }
6047
6048 default:
6049 MOZ_CRASH("Bad state!");
6050 }
6051
6052 if (NS_WARN_IF(NS_FAILED(rv)) && mState != State_UnblockingOpen) {
6053 Finish(rv);
6054 }
6055
6056 return NS_OK;
6057 }
6058
6059 nsresult OriginOperationBase::DirectoryOpen() {
6060 AssertIsOnOwningThread();
6061 MOZ_ASSERT(mState == State_DirectoryOpenPending);
6062
6063 QuotaManager* quotaManager = QuotaManager::Get();
6064 if (NS_WARN_IF(!quotaManager)) {
6065 return NS_ERROR_FAILURE;
6066 }
6067
6068 // Must set this before dispatching otherwise we will race with the IO thread.
6069 AdvanceState();
6070
6071 nsresult rv = quotaManager->IOThread()->Dispatch(this, NS_DISPATCH_NORMAL);
6072 if (NS_WARN_IF(NS_FAILED(rv))) {
6073 return NS_ERROR_FAILURE;
6074 }
6075
6076 return NS_OK;
6077 }
6078
6079 void OriginOperationBase::Finish(nsresult aResult) {
6080 if (NS_SUCCEEDED(mResultCode)) {
6081 mResultCode = aResult;
6082 }
6083
6084 // Must set mState before dispatching otherwise we will race with the main
6085 // thread.
6086 mState = State_UnblockingOpen;
6087
6088 MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
6089 }
6090
6091 nsresult OriginOperationBase::Init() {
6092 AssertIsOnOwningThread();
6093 MOZ_ASSERT(mState == State_Initial);
6094
6095 AdvanceState();
6096
6097 if (mNeedsMainThreadInit) {
6098 MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
6099 } else {
6100 AdvanceState();
6101 MOZ_ALWAYS_SUCCEEDS(Run());
6102 }
6103
6104 return NS_OK;
6105 }
6106
6107 nsresult OriginOperationBase::InitOnMainThread() {
6108 MOZ_ASSERT(NS_IsMainThread());
6109 MOZ_ASSERT(mState == State_Initializing);
6110
6111 nsresult rv = DoInitOnMainThread();
6112 if (NS_WARN_IF(NS_FAILED(rv))) {
6113 return rv;
6114 }
6115
6116 AdvanceState();
6117
6118 MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
6119
6120 return NS_OK;
6121 }
6122
6123 nsresult OriginOperationBase::FinishInit() {
6124 AssertIsOnOwningThread();
6125 MOZ_ASSERT(mState == State_FinishingInit);
6126
6127 if (QuotaManager::IsShuttingDown()) {
6128 return NS_ERROR_FAILURE;
6129 }
6130
6131 AdvanceState();
6132
6133 if (mNeedsQuotaManagerInit && !QuotaManager::Get()) {
6134 QuotaManager::GetOrCreate(this);
6135 } else {
6136 Open();
6137 }
6138
6139 return NS_OK;
6140 }
6141
6142 nsresult OriginOperationBase::QuotaManagerOpen() {
6143 AssertIsOnOwningThread();
6144 MOZ_ASSERT(mState == State_CreatingQuotaManager);
6145
6146 if (NS_WARN_IF(!QuotaManager::Get())) {
6147 return NS_ERROR_FAILURE;
6148 }
6149
6150 Open();
6151
6152 return NS_OK;
6153 }
6154
6155 nsresult OriginOperationBase::DirectoryWork() {
6156 AssertIsOnIOThread();
6157 MOZ_ASSERT(mState == State_DirectoryWorkOpen);
6158
6159 QuotaManager* quotaManager = QuotaManager::Get();
6160 if (NS_WARN_IF(!quotaManager)) {
6161 return NS_ERROR_FAILURE;
6162 }
6163
6164 nsresult rv;
6165
6166 if (mNeedsQuotaManagerInit) {
6167 rv = quotaManager->EnsureStorageIsInitialized();
6168 if (NS_WARN_IF(NS_FAILED(rv))) {
6169 return rv;
6170 }
6171 }
6172
6173 rv = DoDirectoryWork(quotaManager);
6174 if (NS_WARN_IF(NS_FAILED(rv))) {
6175 return rv;
6176 }
6177
6178 // Must set mState before dispatching otherwise we will race with the owning
6179 // thread.
6180 AdvanceState();
6181
6182 MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
6183
6184 return NS_OK;
6185 }
6186
6187 void FinalizeOriginEvictionOp::Dispatch() {
6188 MOZ_ASSERT(!NS_IsMainThread());
6189 MOZ_ASSERT(GetState() == State_Initial);
6190
6191 SetState(State_DirectoryOpenPending);
6192
6193 MOZ_ALWAYS_SUCCEEDS(mOwningThread->Dispatch(this, NS_DISPATCH_NORMAL));
6194 }
6195
6196 void FinalizeOriginEvictionOp::RunOnIOThreadImmediately() {
6197 AssertIsOnIOThread();
6198 MOZ_ASSERT(GetState() == State_Initial);
6199
6200 SetState(State_DirectoryWorkOpen);
6201
6202 MOZ_ALWAYS_SUCCEEDS(this->Run());
6203 }
6204
6205 void FinalizeOriginEvictionOp::Open() { MOZ_CRASH("Shouldn't get here!"); }
6206
6207 nsresult FinalizeOriginEvictionOp::DoDirectoryWork(
6208 QuotaManager* aQuotaManager) {
6209 AssertIsOnIOThread();
6210
6211 AUTO_PROFILER_LABEL("FinalizeOriginEvictionOp::DoDirectoryWork", OTHER);
6212
6213 for (RefPtr<DirectoryLockImpl>& lock : mLocks) {
6214 aQuotaManager->OriginClearCompleted(lock->GetPersistenceType().Value(),
6215 lock->GetOriginScope().GetOrigin(),
6216 Nullable<Client::Type>());
6217 }
6218
6219 return NS_OK;
6220 }
6221
6222 void FinalizeOriginEvictionOp::UnblockOpen() {
6223 AssertIsOnOwningThread();
6224 MOZ_ASSERT(GetState() == State_UnblockingOpen);
6225
6226 #ifdef DEBUG
6227 NoteActorDestroyed();
6228 #endif
6229
6230 mLocks.Clear();
6231
6232 AdvanceState();
6233 }
6234
6235 NS_IMPL_ISUPPORTS_INHERITED0(NormalOriginOperationBase, Runnable)
6236
6237 void NormalOriginOperationBase::Open() {
6238 AssertIsOnOwningThread();
6239 MOZ_ASSERT(GetState() == State_CreatingQuotaManager);
6240 MOZ_ASSERT(QuotaManager::Get());
6241
6242 AdvanceState();
6243
6244 QuotaManager::Get()->OpenDirectoryInternal(mPersistenceType, mOriginScope,
6245 mClientType, mExclusive, this);
6246 }
6247
6248 void NormalOriginOperationBase::UnblockOpen() {
6249 AssertIsOnOwningThread();
6250 MOZ_ASSERT(GetState() == State_UnblockingOpen);
6251
6252 SendResults();
6253
6254 mDirectoryLock = nullptr;
6255
6256 AdvanceState();
6257 }
6258
6259 void NormalOriginOperationBase::DirectoryLockAcquired(DirectoryLock* aLock) {
6260 AssertIsOnOwningThread();
6261 MOZ_ASSERT(aLock);
6262 MOZ_ASSERT(GetState() == State_DirectoryOpenPending);
6263 MOZ_ASSERT(!mDirectoryLock);
6264
6265 mDirectoryLock = aLock;
6266
6267 nsresult rv = DirectoryOpen();
6268 if (NS_WARN_IF(NS_FAILED(rv))) {
6269 Finish(rv);
6270 return;
6271 }
6272 }
6273
6274 void NormalOriginOperationBase::DirectoryLockFailed() {
6275 AssertIsOnOwningThread();
6276 MOZ_ASSERT(GetState() == State_DirectoryOpenPending);
6277 MOZ_ASSERT(!mDirectoryLock);
6278
6279 Finish(NS_ERROR_FAILURE);
6280 }
6281
6282 nsresult SaveOriginAccessTimeOp::DoDirectoryWork(QuotaManager* aQuotaManager) {
6283 AssertIsOnIOThread();
6284 MOZ_ASSERT(!mPersistenceType.IsNull());
6285 MOZ_ASSERT(mOriginScope.IsOrigin());
6286
6287 AUTO_PROFILER_LABEL("SaveOriginAccessTimeOp::DoDirectoryWork", OTHER);
6288
6289 nsCOMPtr<nsIFile> file;
6290 nsresult rv = aQuotaManager->GetDirectoryForOrigin(
6291 mPersistenceType.Value(), mOriginScope.GetOrigin(), getter_AddRefs(file));
6292 if (NS_WARN_IF(NS_FAILED(rv))) {
6293 return rv;
6294 }
6295
6296 rv = file->Append(NS_LITERAL_STRING(METADATA_V2_FILE_NAME));
6297 if (NS_WARN_IF(NS_FAILED(rv))) {
6298 return rv;
6299 }
6300
6301 nsCOMPtr<nsIBinaryOutputStream> stream;
6302 rv = GetBinaryOutputStream(file, kUpdateFileFlag, getter_AddRefs(stream));
6303 if (NS_WARN_IF(NS_FAILED(rv))) {
6304 return rv;
6305 }
6306
6307 // The origin directory may not exist anymore.
6308 if (stream) {
6309 rv = stream->Write64(mTimestamp);
6310 if (NS_WARN_IF(NS_FAILED(rv))) {
6311 return rv;
6312 }
6313 }
6314
6315 return NS_OK;
6316 }
6317
6318 void SaveOriginAccessTimeOp::SendResults() {
6319 #ifdef DEBUG
6320 NoteActorDestroyed();
6321 #endif
6322 }
6323
6324 NS_IMETHODIMP
6325 StoragePressureRunnable::Run() {
6326 MOZ_ASSERT(NS_IsMainThread());
6327
6328 nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService();
6329 if (NS_WARN_IF(!obsSvc)) {
6330 return NS_ERROR_FAILURE;
6331 }
6332
6333 nsCOMPtr<nsISupportsPRUint64> wrapper =
6334 do_CreateInstance(NS_SUPPORTS_PRUINT64_CONTRACTID);
6335 if (NS_WARN_IF(!wrapper)) {
6336 return NS_ERROR_FAILURE;
6337 }
6338
6339 wrapper->SetData(mUsage);
6340
6341 obsSvc->NotifyObservers(wrapper, "QuotaManager::StoragePressure", u"");
6342
6343 return NS_OK;
6344 }
6345
6346 /*******************************************************************************
6347 * Quota
6348 ******************************************************************************/
6349
6350 Quota::Quota()
6351 #ifdef DEBUG
6352 : mActorDestroyed(false)
6353 #endif
6354 {
6355 }
6356
6357 Quota::~Quota() { MOZ_ASSERT(mActorDestroyed); }
6358
6359 void Quota::StartIdleMaintenance() {
6360 AssertIsOnBackgroundThread();
6361 MOZ_ASSERT(!QuotaManager::IsShuttingDown());
6362
6363 QuotaManager* quotaManager = QuotaManager::Get();
6364 if (NS_WARN_IF(!quotaManager)) {
6365 return;
6366 }
6367
6368 quotaManager->StartIdleMaintenance();
6369 }
6370
6371 void Quota::ActorDestroy(ActorDestroyReason aWhy) {
6372 AssertIsOnBackgroundThread();
6373 #ifdef DEBUG
6374 MOZ_ASSERT(!mActorDestroyed);
6375 mActorDestroyed = true;
6376 #endif
6377 }
6378
6379 PQuotaUsageRequestParent* Quota::AllocPQuotaUsageRequestParent(
6380 const UsageRequestParams& aParams) {
6381 AssertIsOnBackgroundThread();
6382 MOZ_ASSERT(aParams.type() != UsageRequestParams::T__None);
6383
6384 RefPtr<QuotaUsageRequestBase> actor;
6385
6386 switch (aParams.type()) {
6387 case UsageRequestParams::TAllUsageParams:
6388 actor = new GetUsageOp(aParams);
6389 break;
6390
6391 case UsageRequestParams::TOriginUsageParams:
6392 actor = new GetOriginUsageOp(aParams);
6393 break;
6394
6395 default:
6396 MOZ_CRASH("Should never get here!");
6397 }
6398
6399 MOZ_ASSERT(actor);
6400
6401 // Transfer ownership to IPDL.
6402 return actor.forget().take();
6403 }
6404
6405 mozilla::ipc::IPCResult Quota::RecvPQuotaUsageRequestConstructor(
6406 PQuotaUsageRequestParent* aActor, const UsageRequestParams& aParams) {
6407 AssertIsOnBackgroundThread();
6408 MOZ_ASSERT(aActor);
6409 MOZ_ASSERT(aParams.type() != UsageRequestParams::T__None);
6410
6411 auto* op = static_cast<QuotaUsageRequestBase*>(aActor);
6412
6413 if (NS_WARN_IF(!op->Init(this))) {
6414 return IPC_FAIL_NO_REASON(this);
6415 }
6416
6417 op->RunImmediately();
6418 return IPC_OK();
6419 }
6420
6421 bool Quota::DeallocPQuotaUsageRequestParent(PQuotaUsageRequestParent* aActor) {
6422 AssertIsOnBackgroundThread();
6423 MOZ_ASSERT(aActor);
6424
6425 // Transfer ownership back from IPDL.
6426 RefPtr<QuotaUsageRequestBase> actor =
6427 dont_AddRef(static_cast<QuotaUsageRequestBase*>(aActor));
6428 return true;
6429 }
6430
6431 PQuotaRequestParent* Quota::AllocPQuotaRequestParent(
6432 const RequestParams& aParams) {
6433 AssertIsOnBackgroundThread();
6434 MOZ_ASSERT(aParams.type() != RequestParams::T__None);
6435
6436 if (aParams.type() == RequestParams::TClearDataParams) {
6437 PBackgroundParent* actor = Manager();
6438 MOZ_ASSERT(actor);
6439
6440 if (BackgroundParent::IsOtherProcessActor(actor)) {
6441 ASSERT_UNLESS_FUZZING();
6442 return nullptr;
6443 }
6444 }
6445
6446 RefPtr<QuotaRequestBase> actor;
6447
6448 switch (aParams.type()) {
6449 case RequestParams::TInitParams:
6450 actor = new InitOp();
6451 break;
6452
6453 case RequestParams::TInitTemporaryStorageParams:
6454 actor = new InitTemporaryStorageOp();
6455 break;
6456
6457 case RequestParams::TInitOriginParams:
6458 actor = new InitOriginOp(aParams);
6459 break;
6460
6461 case RequestParams::TClearOriginParams:
6462 case RequestParams::TResetOriginParams:
6463 actor = new ClearOriginOp(aParams);
6464 break;
6465
6466 case RequestParams::TClearDataParams:
6467 actor = new ClearDataOp(aParams);
6468 break;
6469
6470 case RequestParams::TClearAllParams:
6471 actor = new ResetOrClearOp(/* aClear */ true);
6472 break;
6473
6474 case RequestParams::TResetAllParams:
6475 actor = new ResetOrClearOp(/* aClear */ false);
6476 break;
6477
6478 case RequestParams::TPersistedParams:
6479 actor = new PersistedOp(aParams);
6480 break;
6481
6482 case RequestParams::TPersistParams:
6483 actor = new PersistOp(aParams);
6484 break;
6485
6486 default:
6487 MOZ_CRASH("Should never get here!");
6488 }
6489
6490 MOZ_ASSERT(actor);
6491
6492 // Transfer ownership to IPDL.
6493 return actor.forget().take();
6494 }
6495
6496 mozilla::ipc::IPCResult Quota::RecvPQuotaRequestConstructor(
6497 PQuotaRequestParent* aActor, const RequestParams& aParams) {
6498 AssertIsOnBackgroundThread();
6499 MOZ_ASSERT(aActor);
6500 MOZ_ASSERT(aParams.type() != RequestParams::T__None);
6501
6502 auto* op = static_cast<QuotaRequestBase*>(aActor);
6503
6504 if (NS_WARN_IF(!op->Init(this))) {
6505 return IPC_FAIL_NO_REASON(this);
6506 }
6507
6508 op->RunImmediately();
6509 return IPC_OK();
6510 }
6511
6512 bool Quota::DeallocPQuotaRequestParent(PQuotaRequestParent* aActor) {
6513 AssertIsOnBackgroundThread();
6514 MOZ_ASSERT(aActor);
6515
6516 // Transfer ownership back from IPDL.
6517 RefPtr<QuotaRequestBase> actor =
6518 dont_AddRef(static_cast<QuotaRequestBase*>(aActor));
6519 return true;
6520 }
6521
6522 mozilla::ipc::IPCResult Quota::RecvStartIdleMaintenance() {
6523 AssertIsOnBackgroundThread();
6524
6525 PBackgroundParent* actor = Manager();
6526 MOZ_ASSERT(actor);
6527
6528 if (BackgroundParent::IsOtherProcessActor(actor)) {
6529 ASSERT_UNLESS_FUZZING();
6530 return IPC_FAIL_NO_REASON(this);
6531 }
6532
6533 if (QuotaManager::IsShuttingDown()) {
6534 return IPC_OK();
6535 }
6536
6537 QuotaManager* quotaManager = QuotaManager::Get();
6538 if (!quotaManager) {
6539 nsCOMPtr<nsIRunnable> callback =
6540 NewRunnableMethod("dom::quota::Quota::StartIdleMaintenance", this,
6541 &Quota::StartIdleMaintenance);
6542
6543 QuotaManager::GetOrCreate(callback);
6544 return IPC_OK();
6545 }
6546
6547 quotaManager->StartIdleMaintenance();
6548
6549 return IPC_OK();
6550 }
6551
6552 mozilla::ipc::IPCResult Quota::RecvStopIdleMaintenance() {
6553 AssertIsOnBackgroundThread();
6554
6555 PBackgroundParent* actor = Manager();
6556 MOZ_ASSERT(actor);
6557
6558 if (BackgroundParent::IsOtherProcessActor(actor)) {
6559 ASSERT_UNLESS_FUZZING();
6560 return IPC_FAIL_NO_REASON(this);
6561 }
6562
6563 if (QuotaManager::IsShuttingDown()) {
6564 return IPC_OK();
6565 }
6566
6567 QuotaManager* quotaManager = QuotaManager::Get();
6568 if (!quotaManager) {
6569 return IPC_OK();
6570 }
6571
6572 quotaManager->StopIdleMaintenance();
6573
6574 return IPC_OK();
6575 }
6576
6577 bool QuotaUsageRequestBase::Init(Quota* aQuota) {
6578 AssertIsOnOwningThread();
6579 MOZ_ASSERT(aQuota);
6580
6581 mNeedsQuotaManagerInit = true;
6582
6583 return true;
6584 }
6585
6586 nsresult QuotaUsageRequestBase::GetUsageForOrigin(
6587 QuotaManager* aQuotaManager, PersistenceType aPersistenceType,
6588 const nsACString& aGroup, const nsACString& aOrigin,
6589 UsageInfo* aUsageInfo) {
6590 AssertIsOnIOThread();
6591 MOZ_ASSERT(aQuotaManager);
6592 MOZ_ASSERT(aUsageInfo);
6593 MOZ_ASSERT(aUsageInfo->TotalUsage() == 0);
6594
6595 nsCOMPtr<nsIFile> directory;
6596 nsresult rv = aQuotaManager->GetDirectoryForOrigin(aPersistenceType, aOrigin,
6597 getter_AddRefs(directory));
6598 NS_ENSURE_SUCCESS(rv, rv);
6599
6600 bool exists;
6601 rv = directory->Exists(&exists);
6602 NS_ENSURE_SUCCESS(rv, rv);
6603
6604 // If the directory exists then enumerate all the files inside, adding up
6605 // the sizes to get the final usage statistic.
6606 if (exists && !mCanceled) {
6607 bool initialized;
6608
6609 if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
6610 initialized = aQuotaManager->IsOriginInitialized(aOrigin);
6611 } else {
6612 initialized = aQuotaManager->IsTemporaryStorageInitialized();
6613 }
6614
6615 nsCOMPtr<nsIDirectoryEnumerator> entries;
6616 rv = directory->GetDirectoryEntries(getter_AddRefs(entries));
6617 NS_ENSURE_SUCCESS(rv, rv);
6618
6619 nsCOMPtr<nsIFile> file;
6620 while (NS_SUCCEEDED((rv = entries->GetNextFile(getter_AddRefs(file)))) &&
6621 file && !mCanceled) {
6622 bool isDirectory;
6623 rv = file->IsDirectory(&isDirectory);
6624 if (NS_WARN_IF(NS_FAILED(rv))) {
6625 return rv;
6626 }
6627
6628 nsString leafName;
6629 rv = file->GetLeafName(leafName);
6630 if (NS_WARN_IF(NS_FAILED(rv))) {
6631 return rv;
6632 }
6633
6634 if (!isDirectory) {
6635 // We are maintaining existing behavior here (failing if the origin is
6636 // not yet initialized or just continuing otherwise).
6637 // This can possibly be used by developers to add temporary backups into
6638 // origin directories without losing get usage functionality.
6639 if (IsOriginMetadata(leafName)) {
6640 continue;
6641 }
6642
6643 if (IsTempMetadata(leafName)) {
6644 if (!initialized) {
6645 rv = file->Remove(/* recursive */ false);
6646 if (NS_WARN_IF(NS_FAILED(rv))) {
6647 return rv;
6648 }
6649 }
6650
6651 continue;
6652 }
6653
6654 if (IsOSMetadata(leafName) || IsDotFile(leafName)) {
6655 continue;
6656 }
6657
6658 UNKNOWN_FILE_WARNING(leafName);
6659 if (!initialized) {
6660 return NS_ERROR_UNEXPECTED;
6661 }
6662 continue;
6663 }
6664
6665 Client::Type clientType;
6666 rv = Client::TypeFromText(leafName, clientType);
6667 if (NS_FAILED(rv)) {
6668 UNKNOWN_FILE_WARNING(leafName);
6669 if (!initialized) {
6670 return NS_ERROR_UNEXPECTED;
6671 }
6672 continue;
6673 }
6674
6675 Client* client = aQuotaManager->GetClient(clientType);
6676 MOZ_ASSERT(client);
6677
6678 if (initialized) {
6679 rv = client->GetUsageForOrigin(aPersistenceType, aGroup, aOrigin,
6680 mCanceled, aUsageInfo);
6681 } else {
6682 rv = client->InitOrigin(aPersistenceType, aGroup, aOrigin, mCanceled,
6683 aUsageInfo);
6684 }
6685 NS_ENSURE_SUCCESS(rv, rv);
6686 }
6687 }
6688
6689 return NS_OK;
6690 }
6691
6692 void QuotaUsageRequestBase::SendResults() {
6693 AssertIsOnOwningThread();
6694
6695 if (IsActorDestroyed()) {
6696 if (NS_SUCCEEDED(mResultCode)) {
6697 mResultCode = NS_ERROR_FAILURE;
6698 }
6699 } else {
6700 if (mCanceled) {
6701 mResultCode = NS_ERROR_FAILURE;
6702 }
6703
6704 UsageRequestResponse response;
6705
6706 if (NS_SUCCEEDED(mResultCode)) {
6707 GetResponse(response);
6708 } else {
6709 response = mResultCode;
6710 }
6711
6712 Unused << PQuotaUsageRequestParent::Send__delete__(this, response);
6713 }
6714 }
6715
6716 void QuotaUsageRequestBase::ActorDestroy(ActorDestroyReason aWhy) {
6717 AssertIsOnOwningThread();
6718
6719 NoteActorDestroyed();
6720 }
6721
6722 mozilla::ipc::IPCResult QuotaUsageRequestBase::RecvCancel() {
6723 AssertIsOnOwningThread();
6724
6725 if (mCanceled.exchange(true)) {
6726 NS_WARNING("Canceled more than once?!");
6727 return IPC_FAIL_NO_REASON(this);
6728 }
6729
6730 return IPC_OK();
6731 }
6732
6733 GetUsageOp::GetUsageOp(const UsageRequestParams& aParams)
6734 : mGetAll(aParams.get_AllUsageParams().getAll()) {
6735 AssertIsOnOwningThread();
6736 MOZ_ASSERT(aParams.type() == UsageRequestParams::TAllUsageParams);
6737 }
6738
6739 nsresult GetUsageOp::TraverseRepository(QuotaManager* aQuotaManager,
6740 PersistenceType aPersistenceType) {
6741 AssertIsOnIOThread();
6742 MOZ_ASSERT(aQuotaManager);
6743
6744 nsCOMPtr<nsIFile> directory;
6745 nsresult rv = NS_NewLocalFile(aQuotaManager->GetStoragePath(aPersistenceType),
6746 false, getter_AddRefs(directory));
6747 if (NS_WARN_IF(NS_FAILED(rv))) {
6748 return rv;
6749 }
6750
6751 bool exists;
6752 rv = directory->Exists(&exists);
6753 if (NS_WARN_IF(NS_FAILED(rv))) {
6754 return rv;
6755 }
6756
6757 if (!exists) {
6758 return NS_OK;
6759 }
6760
6761 nsCOMPtr<nsIDirectoryEnumerator> entries;
6762 rv = directory->GetDirectoryEntries(getter_AddRefs(entries));
6763 if (NS_WARN_IF(NS_FAILED(rv))) {
6764 return rv;
6765 }
6766
6767 bool persistent = aPersistenceType == PERSISTENCE_TYPE_PERSISTENT;
6768
6769 nsCOMPtr<nsIFile> originDir;
6770 while (NS_SUCCEEDED((rv = entries->GetNextFile(getter_AddRefs(originDir)))) &&
6771 originDir && !mCanceled) {
6772 bool isDirectory;
6773 rv = originDir->IsDirectory(&isDirectory);
6774 if (NS_WARN_IF(NS_FAILED(rv))) {
6775 return rv;
6776 }
6777
6778 if (!isDirectory) {
6779 nsString leafName;
6780 rv = originDir->GetLeafName(leafName);
6781 if (NS_WARN_IF(NS_FAILED(rv))) {
6782 return rv;
6783 }
6784
6785 // Unknown files during getting usages are allowed. Just warn if we find
6786 // them.
6787 if (!IsOSMetadata(leafName)) {
6788 UNKNOWN_FILE_WARNING(leafName);
6789 }
6790 continue;
6791 }
6792
6793 int64_t timestamp;
6794 bool persisted;
6795 nsCString suffix;
6796 nsCString group;
6797 nsCString origin;
6798 rv = aQuotaManager->GetDirectoryMetadata2WithRestore(
6799 originDir, persistent, &timestamp, &persisted, suffix, group, origin);
6800 if (NS_WARN_IF(NS_FAILED(rv))) {
6801 return rv;
6802 }
6803
6804 if (!mGetAll && aQuotaManager->IsOriginInternal(origin)) {
6805 continue;
6806 }
6807
6808 OriginUsage* originUsage;
6809
6810 // We can't store pointers to OriginUsage objects in the hashtable
6811 // since AppendElement() reallocates its internal array buffer as number
6812 // of elements grows.
6813 uint32_t index;
6814 if (mOriginUsagesIndex.Get(origin, &index)) {
6815 originUsage = &mOriginUsages[index];
6816 } else {
6817 index = mOriginUsages.Length();
6818
6819 originUsage = mOriginUsages.AppendElement();
6820
6821 originUsage->origin() = origin;
6822 originUsage->persisted() = false;
6823 originUsage->usage() = 0;
6824
6825 mOriginUsagesIndex.Put(origin, index);
6826 }
6827
6828 if (aPersistenceType == PERSISTENCE_TYPE_DEFAULT) {
6829 originUsage->persisted() = persisted;
6830 }
6831
6832 originUsage->lastAccessed() = timestamp;
6833
6834 UsageInfo usageInfo;
6835 rv = GetUsageForOrigin(aQuotaManager, aPersistenceType, group, origin,
6836 &usageInfo);
6837 if (NS_WARN_IF(NS_FAILED(rv))) {
6838 return rv;
6839 }
6840
6841 originUsage->usage() = originUsage->usage() + usageInfo.TotalUsage();
6842 }
6843 if (NS_WARN_IF(NS_FAILED(rv))) {
6844 return rv;
6845 }
6846
6847 return NS_OK;
6848 }
6849
6850 nsresult GetUsageOp::DoDirectoryWork(QuotaManager* aQuotaManager) {
6851 AssertIsOnIOThread();
6852
6853 AUTO_PROFILER_LABEL("GetUsageOp::DoDirectoryWork", OTHER);
6854
6855 nsresult rv;
6856
6857 for (const PersistenceType type : kAllPersistenceTypes) {
6858 rv = TraverseRepository(aQuotaManager, type);
6859 if (NS_WARN_IF(NS_FAILED(rv))) {
6860 return rv;
6861 }
6862 }
6863
6864 return NS_OK;
6865 }
6866
6867 void GetUsageOp::GetResponse(UsageRequestResponse& aResponse) {
6868 AssertIsOnOwningThread();
6869
6870 aResponse = AllUsageResponse();
6871
6872 if (!mOriginUsages.IsEmpty()) {
6873 nsTArray<OriginUsage>& originUsages =
6874 aResponse.get_AllUsageResponse().originUsages();
6875
6876 mOriginUsages.SwapElements(originUsages);
6877 }
6878 }
6879
6880 GetOriginUsageOp::GetOriginUsageOp(const UsageRequestParams& aParams)
6881 : mParams(aParams.get_OriginUsageParams()),
6882 mGetGroupUsage(aParams.get_OriginUsageParams().getGroupUsage()) {
6883 AssertIsOnOwningThread();
6884 MOZ_ASSERT(aParams.type() == UsageRequestParams::TOriginUsageParams);
6885 }
6886
6887 bool GetOriginUsageOp::Init(Quota* aQuota) {
6888 AssertIsOnOwningThread();
6889 MOZ_ASSERT(aQuota);
6890
6891 if (NS_WARN_IF(!QuotaUsageRequestBase::Init(aQuota))) {
6892 return false;
6893 }
6894
6895 mNeedsMainThreadInit = true;
6896
6897 return true;
6898 }
6899
6900 nsresult GetOriginUsageOp::DoInitOnMainThread() {
6901 MOZ_ASSERT(NS_IsMainThread());
6902 MOZ_ASSERT(GetState() == State_Initializing);
6903 MOZ_ASSERT(mNeedsMainThreadInit);
6904
6905 const PrincipalInfo& principalInfo = mParams.principalInfo();
6906
6907 nsresult rv;
6908 nsCOMPtr<nsIPrincipal> principal =
6909 PrincipalInfoToPrincipal(principalInfo, &rv);
6910 if (NS_WARN_IF(NS_FAILED(rv))) {
6911 return rv;
6912 }
6913
6914 // Figure out which origin we're dealing with.
6915 nsCString origin;
6916 rv =
6917 QuotaManager::GetInfoFromPrincipal(principal, &mSuffix, &mGroup, &origin);
6918 if (NS_WARN_IF(NS_FAILED(rv))) {
6919 return rv;
6920 }
6921
6922 mOriginScope.SetFromOrigin(origin);
6923
6924 return NS_OK;
6925 }
6926
6927 nsresult GetOriginUsageOp::DoDirectoryWork(QuotaManager* aQuotaManager) {
6928 AssertIsOnIOThread();
6929 MOZ_ASSERT(mUsageInfo.TotalUsage() == 0);
6930
6931 AUTO_PROFILER_LABEL("GetOriginUsageOp::DoDirectoryWork", OTHER);
6932
6933 nsresult rv;
6934
6935 if (mGetGroupUsage) {
6936 // Ensure temporary storage is initialized first. It will initialize all
6937 // origins for temporary storage including origins belonging to our group by
6938 // traversing the repositories. EnsureStorageIsInitialized is needed before
6939 // EnsureTemporaryStorageIsInitialized.
6940 rv = aQuotaManager->EnsureStorageIsInitialized();
6941 if (NS_WARN_IF(NS_FAILED(rv))) {
6942 return rv;
6943 }
6944
6945 rv = aQuotaManager->EnsureTemporaryStorageIsInitialized();
6946 if (NS_WARN_IF(NS_FAILED(rv))) {
6947 return rv;
6948 }
6949
6950 // Get cached usage and limit (the method doesn't have to stat any files).
6951 aQuotaManager->GetGroupUsageAndLimit(mGroup, &mUsageInfo);
6952
6953 return NS_OK;
6954 }
6955
6956 // Add all the persistent/temporary/default storage files we care about.
6957 for (const PersistenceType type : kAllPersistenceTypes) {
6958 UsageInfo usageInfo;
6959 rv = GetUsageForOrigin(aQuotaManager, type, mGroup,
6960 mOriginScope.GetOrigin(), &usageInfo);
6961 if (NS_WARN_IF(NS_FAILED(rv))) {
6962 return rv;
6963 }
6964
6965 mUsageInfo.Append(usageInfo);
6966 }
6967
6968 return NS_OK;
6969 }
6970
6971 void GetOriginUsageOp::GetResponse(UsageRequestResponse& aResponse) {
6972 AssertIsOnOwningThread();
6973
6974 OriginUsageResponse usageResponse;
6975
6976 // We'll get the group usage when mGetGroupUsage is true and get the
6977 // origin usage when mGetGroupUsage is false.
6978 usageResponse.usage() = mUsageInfo.TotalUsage();
6979
6980 if (mGetGroupUsage) {
6981 usageResponse.limit() = mUsageInfo.Limit();
6982 } else {
6983 usageResponse.fileUsage() = mUsageInfo.FileUsage();
6984 }
6985
6986 aResponse = usageResponse;
6987 }
6988
6989 bool QuotaRequestBase::Init(Quota* aQuota) {
6990 AssertIsOnOwningThread();
6991 MOZ_ASSERT(aQuota);
6992
6993 mNeedsQuotaManagerInit = true;
6994
6995 return true;
6996 }
6997
6998 void QuotaRequestBase::SendResults() {
6999 AssertIsOnOwningThread();
7000
7001 if (IsActorDestroyed()) {
7002 if (NS_SUCCEEDED(mResultCode)) {
7003 mResultCode = NS_ERROR_FAILURE;
7004 }
7005 } else {
7006 RequestResponse response;
7007
7008 if (NS_SUCCEEDED(mResultCode)) {
7009 GetResponse(response);
7010 } else {
7011 response = mResultCode;
7012 }
7013
7014 Unused << PQuotaRequestParent::Send__delete__(this, response);
7015 }
7016 }
7017
7018 void QuotaRequestBase::ActorDestroy(ActorDestroyReason aWhy) {
7019 AssertIsOnOwningThread();
7020
7021 NoteActorDestroyed();
7022 }
7023
7024 nsresult InitOp::DoDirectoryWork(QuotaManager* aQuotaManager) {
7025 AssertIsOnIOThread();
7026
7027 AUTO_PROFILER_LABEL("InitOp::DoDirectoryWork", OTHER);
7028
7029 aQuotaManager->AssertStorageIsInitialized();
7030
7031 return NS_OK;
7032 }
7033
7034 void InitOp::GetResponse(RequestResponse& aResponse) {
7035 AssertIsOnOwningThread();
7036
7037 aResponse = InitResponse();
7038 }
7039
7040 nsresult InitTemporaryStorageOp::DoDirectoryWork(QuotaManager* aQuotaManager) {
7041 AssertIsOnIOThread();
7042
7043 AUTO_PROFILER_LABEL("InitTemporaryStorageOp::DoDirectoryWork", OTHER);
7044
7045 aQuotaManager->AssertStorageIsInitialized();
7046
7047 nsresult rv = aQuotaManager->EnsureTemporaryStorageIsInitialized();
7048 if (NS_WARN_IF(NS_FAILED(rv))) {
7049 return rv;
7050 }
7051
7052 return NS_OK;
7053 }
7054
7055 void InitTemporaryStorageOp::GetResponse(RequestResponse& aResponse) {
7056 AssertIsOnOwningThread();
7057
7058 aResponse = InitTemporaryStorageResponse();
7059 }
7060
7061 InitOriginOp::InitOriginOp(const RequestParams& aParams)
7062 : QuotaRequestBase(/* aExclusive */ false),
7063 mParams(aParams.get_InitOriginParams()),
7064 mCreated(false) {
7065 AssertIsOnOwningThread();
7066 MOZ_ASSERT(aParams.type() == RequestParams::TInitOriginParams);
7067 }
7068
7069 bool InitOriginOp::Init(Quota* aQuota) {
7070 AssertIsOnOwningThread();
7071 MOZ_ASSERT(aQuota);
7072
7073 if (NS_WARN_IF(!QuotaRequestBase::Init(aQuota))) {
7074 return false;
7075 }
7076
7077 MOZ_ASSERT(mParams.persistenceType() != PERSISTENCE_TYPE_INVALID);
7078
7079 mPersistenceType.SetValue(mParams.persistenceType());
7080
7081 mNeedsMainThreadInit = true;
7082
7083 return true;
7084 }
7085
7086 nsresult InitOriginOp::DoInitOnMainThread() {
7087 MOZ_ASSERT(NS_IsMainThread());
7088 MOZ_ASSERT(GetState() == State_Initializing);
7089 MOZ_ASSERT(mNeedsMainThreadInit);
7090
7091 const PrincipalInfo& principalInfo = mParams.principalInfo();
7092
7093 nsresult rv;
7094 nsCOMPtr<nsIPrincipal> principal =
7095 PrincipalInfoToPrincipal(principalInfo, &rv);
7096 if (NS_WARN_IF(NS_FAILED(rv))) {
7097 return rv;
7098 }
7099
7100 // Figure out which origin we're dealing with.
7101 nsCString origin;
7102 rv =
7103 QuotaManager::GetInfoFromPrincipal(principal, &mSuffix, &mGroup, &origin);
7104 if (NS_WARN_IF(NS_FAILED(rv))) {
7105 return rv;
7106 }
7107
7108 mOriginScope.SetFromOrigin(origin);
7109
7110 return NS_OK;
7111 }
7112
7113 nsresult InitOriginOp::DoDirectoryWork(QuotaManager* aQuotaManager) {
7114 AssertIsOnIOThread();
7115 MOZ_ASSERT(!mPersistenceType.IsNull());
7116
7117 AUTO_PROFILER_LABEL("InitOriginOp::DoDirectoryWork", OTHER);
7118
7119 nsCOMPtr<nsIFile> directory;
7120 bool created;
7121 nsresult rv = aQuotaManager->EnsureOriginIsInitializedInternal(
7122 mPersistenceType.Value(), mSuffix, mGroup, mOriginScope.GetOrigin(),
7123 /* aCreateIfNotExists */ true, getter_AddRefs(directory), &created);
7124 if (NS_WARN_IF(NS_FAILED(rv))) {
7125 return rv;
7126 }
7127
7128 mCreated = created;
7129
7130 return NS_OK;
7131 }
7132
7133 void InitOriginOp::GetResponse(RequestResponse& aResponse) {
7134 AssertIsOnOwningThread();
7135
7136 InitOriginResponse response;
7137
7138 response.created() = mCreated;
7139
7140 aResponse = response;
7141 }
7142
7143 void ResetOrClearOp::DeleteFiles(QuotaManager* aQuotaManager) {
7144 AssertIsOnIOThread();
7145 MOZ_ASSERT(aQuotaManager);
7146
7147 nsresult rv = aQuotaManager->AboutToClearOrigins(Nullable<PersistenceType>(),
7148 OriginScope::FromNull(),
7149 Nullable<Client::Type>());
7150 if (NS_WARN_IF(NS_FAILED(rv))) {
7151 return;
7152 }
7153
7154 nsCOMPtr<nsIFile> directory;
7155 rv = NS_NewLocalFile(aQuotaManager->GetStoragePath(), false,
7156 getter_AddRefs(directory));
7157 if (NS_WARN_IF(NS_FAILED(rv))) {
7158 return;
7159 }
7160
7161 rv = directory->Remove(true);
7162 if (rv != NS_ERROR_FILE_TARGET_DOES_NOT_EXIST &&
7163 rv != NS_ERROR_FILE_NOT_FOUND && NS_FAILED(rv)) {
7164 // This should never fail if we've closed all storage connections
7165 // correctly...
7166 MOZ_ASSERT(false, "Failed to remove storage directory!");
7167 }
7168
7169 nsCOMPtr<nsIFile> storageFile;
7170 rv = NS_NewLocalFile(aQuotaManager->GetBasePath(), false,
7171 getter_AddRefs(storageFile));
7172 if (NS_WARN_IF(NS_FAILED(rv))) {
7173 return;
7174 }
7175
7176 rv = storageFile->Append(NS_LITERAL_STRING(STORAGE_FILE_NAME));
7177 if (NS_WARN_IF(NS_FAILED(rv))) {
7178 return;
7179 }
7180
7181 rv = storageFile->Remove(true);
7182 if (rv != NS_ERROR_FILE_TARGET_DOES_NOT_EXIST &&
7183 rv != NS_ERROR_FILE_NOT_FOUND && NS_FAILED(rv)) {
7184 // This should never fail if we've closed the storage connection
7185 // correctly...
7186 MOZ_ASSERT(false, "Failed to remove storage file!");
7187 }
7188 }
7189
7190 nsresult ResetOrClearOp::DoDirectoryWork(QuotaManager* aQuotaManager) {
7191 AssertIsOnIOThread();
7192
7193 AUTO_PROFILER_LABEL("ResetOrClearOp::DoDirectoryWork", OTHER);
7194
7195 if (mClear) {
7196 DeleteFiles(aQuotaManager);
7197 }
7198
7199 aQuotaManager->RemoveQuota();
7200
7201 aQuotaManager->ResetOrClearCompleted();
7202
7203 return NS_OK;
7204 }
7205
7206 void ResetOrClearOp::GetResponse(RequestResponse& aResponse) {
7207 AssertIsOnOwningThread();
7208 if (mClear) {
7209 aResponse = ClearAllResponse();
7210 } else {
7211 aResponse = ResetAllResponse();
7212 }
7213 }
7214
7215 void ClearRequestBase::DeleteFiles(QuotaManager* aQuotaManager,
7216 PersistenceType aPersistenceType) {
7217 AssertIsOnIOThread();
7218 MOZ_ASSERT(aQuotaManager);
7219
7220 nsresult rv = aQuotaManager->AboutToClearOrigins(
7221 Nullable<PersistenceType>(aPersistenceType), mOriginScope, mClientType);
7222 if (NS_WARN_IF(NS_FAILED(rv))) {
7223 return;
7224 }
7225
7226 nsCOMPtr<nsIFile> directory;
7227 rv = NS_NewLocalFile(aQuotaManager->GetStoragePath(aPersistenceType), false,
7228 getter_AddRefs(directory));
7229 if (NS_WARN_IF(NS_FAILED(rv))) {
7230 return;
7231 }
7232
7233 nsCOMPtr<nsIDirectoryEnumerator> entries;
7234 if (NS_WARN_IF(
7235 NS_FAILED(directory->GetDirectoryEntries(getter_AddRefs(entries)))) ||
7236 !entries) {
7237 return;
7238 }
7239
7240 OriginScope originScope = mOriginScope.Clone();
7241 if (originScope.IsOrigin()) {
7242 nsCString originSanitized(originScope.GetOrigin());
7243 SanitizeOriginString(originSanitized);
7244 originScope.SetOrigin(originSanitized);
7245 } else if (originScope.IsPrefix()) {
7246 nsCString originNoSuffixSanitized(originScope.GetOriginNoSuffix());
7247 SanitizeOriginString(originNoSuffixSanitized);
7248 originScope.SetOriginNoSuffix(originNoSuffixSanitized);
7249 }
7250
7251 nsCOMPtr<nsIFile> file;
7252 while (NS_SUCCEEDED((rv = entries->GetNextFile(getter_AddRefs(file)))) &&
7253 file) {
7254 bool isDirectory;
7255 rv = file->IsDirectory(&isDirectory);
7256 if (NS_WARN_IF(NS_FAILED(rv))) {
7257 return;
7258 }
7259
7260 nsString leafName;
7261 rv = file->GetLeafName(leafName);
7262 if (NS_WARN_IF(NS_FAILED(rv))) {
7263 return;
7264 }
7265
7266 if (!isDirectory) {
7267 // Unknown files during clearing are allowed. Just warn if we find them.
7268 if (!IsOSMetadata(leafName)) {
7269 UNKNOWN_FILE_WARNING(leafName);
7270 }
7271 continue;
7272 }
7273
7274 // Skip the origin directory if it doesn't match the pattern.
7275 if (!originScope.Matches(
7276 OriginScope::FromOrigin(NS_ConvertUTF16toUTF8(leafName)))) {
7277 continue;
7278 }
7279
7280 bool persistent = aPersistenceType == PERSISTENCE_TYPE_PERSISTENT;
7281
7282 int64_t timestamp;
7283 nsCString suffix;
7284 nsCString group;
7285 nsCString origin;
7286 bool persisted;
7287 rv = aQuotaManager->GetDirectoryMetadata2WithRestore(
7288 file, persistent, &timestamp, &persisted, suffix, group, origin);
7289 if (NS_WARN_IF(NS_FAILED(rv))) {
7290 return;
7291 }
7292
7293 UsageInfo usageInfo;
7294
7295 if (!mClientType.IsNull()) {
7296 Client::Type clientType = mClientType.Value();
7297
7298 nsAutoString clientDirectoryName;
7299 rv = Client::TypeToText(clientType, clientDirectoryName);
7300 if (NS_WARN_IF(NS_FAILED(rv))) {
7301 return;
7302 }
7303
7304 rv = file->Append(clientDirectoryName);
7305 if (NS_WARN_IF(NS_FAILED(rv))) {
7306 return;
7307 }
7308
7309 bool exists;
7310 rv = file->Exists(&exists);
7311 if (NS_WARN_IF(NS_FAILED(rv))) {
7312 return;
7313 }
7314
7315 if (!exists) {
7316 continue;
7317 }
7318
7319 bool initialized;
7320 if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
7321 initialized = aQuotaManager->IsOriginInitialized(origin);
7322 } else {
7323 initialized = aQuotaManager->IsTemporaryStorageInitialized();
7324 }
7325
7326 Client* client = aQuotaManager->GetClient(clientType);
7327 MOZ_ASSERT(client);
7328
7329 Atomic<bool> dummy(false);
7330 if (initialized) {
7331 rv = client->GetUsageForOrigin(aPersistenceType, group, origin, dummy,
7332 &usageInfo);
7333 } else {
7334 rv = client->InitOrigin(aPersistenceType, group, origin, dummy,
7335 &usageInfo);
7336 }
7337 if (NS_WARN_IF(NS_FAILED(rv))) {
7338 return;
7339 }
7340 }
7341
7342 for (uint32_t index = 0; index < 10; index++) {
7343 // We can't guarantee that this will always succeed on Windows...
7344 if (NS_SUCCEEDED((rv = file->Remove(true)))) {
7345 break;
7346 }
7347
7348 NS_WARNING("Failed to remove directory, retrying after a short delay.");
7349
7350 PR_Sleep(PR_MillisecondsToInterval(200));
7351 }
7352
7353 if (NS_FAILED(rv)) {
7354 NS_WARNING("Failed to remove directory, giving up!");
7355 }
7356
7357 if (aPersistenceType != PERSISTENCE_TYPE_PERSISTENT) {
7358 if (mClientType.IsNull()) {
7359 aQuotaManager->RemoveQuotaForOrigin(aPersistenceType, group, origin);
7360 } else {
7361 aQuotaManager->DecreaseUsageForOrigin(aPersistenceType, group, origin,
7362 usageInfo.TotalUsage());
7363 }
7364 }
7365
7366 aQuotaManager->OriginClearCompleted(aPersistenceType, origin, mClientType);
7367 }
7368 }
7369
7370 nsresult ClearRequestBase::DoDirectoryWork(QuotaManager* aQuotaManager) {
7371 AssertIsOnIOThread();
7372
7373 AUTO_PROFILER_LABEL("ClearRequestBase::DoDirectoryWork", OTHER);
7374
7375 if (mClear) {
7376 if (mPersistenceType.IsNull()) {
7377 for (const PersistenceType type : kAllPersistenceTypes) {
7378 DeleteFiles(aQuotaManager, type);
7379 }
7380 } else {
7381 DeleteFiles(aQuotaManager, mPersistenceType.Value());
7382 }
7383 }
7384
7385 return NS_OK;
7386 }
7387
7388 ClearOriginOp::ClearOriginOp(const RequestParams& aParams)
7389 : ClearRequestBase(/* aExclusive */ true,
7390 aParams.type() == RequestParams::TClearOriginParams),
7391 mParams(aParams.type() == RequestParams::TClearOriginParams
7392 ? aParams.get_ClearOriginParams().commonParams()
7393 : aParams.get_ResetOriginParams().commonParams())
7394
7395 {
7396 MOZ_ASSERT(aParams.type() == RequestParams::TClearOriginParams ||
7397 aParams.type() == RequestParams::TResetOriginParams);
7398 }
7399
7400 bool ClearOriginOp::Init(Quota* aQuota) {
7401 AssertIsOnOwningThread();
7402 MOZ_ASSERT(aQuota);
7403
7404 if (NS_WARN_IF(!QuotaRequestBase::Init(aQuota))) {
7405 return false;
7406 }
7407
7408 if (mParams.persistenceTypeIsExplicit()) {
7409 MOZ_ASSERT(mParams.persistenceType() != PERSISTENCE_TYPE_INVALID);
7410
7411 mPersistenceType.SetValue(mParams.persistenceType());
7412 }
7413
7414 if (mParams.clientTypeIsExplicit()) {
7415 MOZ_ASSERT(mParams.clientType() != Client::TYPE_MAX);
7416
7417 mClientType.SetValue(mParams.clientType());
7418 }
7419
7420 mNeedsMainThreadInit = true;
7421
7422 return true;
7423 }
7424
7425 nsresult ClearOriginOp::DoInitOnMainThread() {
7426 MOZ_ASSERT(NS_IsMainThread());
7427 MOZ_ASSERT(GetState() == State_Initializing);
7428 MOZ_ASSERT(mNeedsMainThreadInit);
7429
7430 const PrincipalInfo& principalInfo = mParams.principalInfo();
7431
7432 nsresult rv;
7433 nsCOMPtr<nsIPrincipal> principal =
7434 PrincipalInfoToPrincipal(principalInfo, &rv);
7435 if (NS_WARN_IF(NS_FAILED(rv))) {
7436 return rv;
7437 }
7438
7439 // Figure out which origin we're dealing with.
7440 nsCString origin;
7441 rv = QuotaManager::GetInfoFromPrincipal(principal, nullptr, nullptr, &origin);
7442 if (NS_WARN_IF(NS_FAILED(rv))) {
7443 return rv;
7444 }
7445
7446 if (mParams.matchAll()) {
7447 mOriginScope.SetFromPrefix(origin);
7448 } else {
7449 mOriginScope.SetFromOrigin(origin);
7450 }
7451
7452 return NS_OK;
7453 }
7454
7455 void ClearOriginOp::GetResponse(RequestResponse& aResponse) {
7456 AssertIsOnOwningThread();
7457
7458 if (mClear) {
7459 aResponse = ClearOriginResponse();
7460 } else {
7461 aResponse = ResetOriginResponse();
7462 }
7463 }
7464
7465 ClearDataOp::ClearDataOp(const RequestParams& aParams)
7466 : ClearRequestBase(/* aExclusive */ true,
7467 /* aClear */ true),
7468 mParams(aParams) {
7469 MOZ_ASSERT(aParams.type() == RequestParams::TClearDataParams);
7470 }
7471
7472 bool ClearDataOp::Init(Quota* aQuota) {
7473 AssertIsOnOwningThread();
7474 MOZ_ASSERT(aQuota);
7475
7476 if (NS_WARN_IF(!QuotaRequestBase::Init(aQuota))) {
7477 return false;
7478 }
7479
7480 mNeedsMainThreadInit = true;
7481
7482 return true;
7483 }
7484
7485 nsresult ClearDataOp::DoInitOnMainThread() {
7486 MOZ_ASSERT(NS_IsMainThread());
7487 MOZ_ASSERT(GetState() == State_Initializing);
7488 MOZ_ASSERT(mNeedsMainThreadInit);
7489
7490 mOriginScope.SetFromJSONPattern(mParams.pattern());
7491
7492 return NS_OK;
7493 }
7494
7495 void ClearDataOp::GetResponse(RequestResponse& aResponse) {
7496 AssertIsOnOwningThread();
7497
7498 aResponse = ClearDataResponse();
7499 }
7500
7501 PersistRequestBase::PersistRequestBase(const PrincipalInfo& aPrincipalInfo)
7502 : QuotaRequestBase(/* aExclusive */ false), mPrincipalInfo(aPrincipalInfo) {
7503 AssertIsOnOwningThread();
7504 }
7505
7506 bool PersistRequestBase::Init(Quota* aQuota) {
7507 AssertIsOnOwningThread();
7508 MOZ_ASSERT(aQuota);
7509
7510 if (NS_WARN_IF(!QuotaRequestBase::Init(aQuota))) {
7511 return false;
7512 }
7513
7514 mPersistenceType.SetValue(PERSISTENCE_TYPE_DEFAULT);
7515
7516 mNeedsMainThreadInit = true;
7517
7518 return true;
7519 }
7520
7521 nsresult PersistRequestBase::DoInitOnMainThread() {
7522 MOZ_ASSERT(NS_IsMainThread());
7523 MOZ_ASSERT(GetState() == State_Initializing);
7524 MOZ_ASSERT(mNeedsMainThreadInit);
7525
7526 nsresult rv;
7527 nsCOMPtr<nsIPrincipal> principal =
7528 PrincipalInfoToPrincipal(mPrincipalInfo, &rv);
7529 if (NS_WARN_IF(NS_FAILED(rv))) {
7530 return rv;
7531 }
7532
7533 // Figure out which origin we're dealing with.
7534 nsCString origin;
7535 rv =
7536 QuotaManager::GetInfoFromPrincipal(principal, &mSuffix, &mGroup, &origin);
7537 if (NS_WARN_IF(NS_FAILED(rv))) {
7538 return rv;
7539 }
7540
7541 mOriginScope.SetFromOrigin(origin);
7542
7543 return NS_OK;
7544 }
7545
7546 PersistedOp::PersistedOp(const RequestParams& aParams)
7547 : PersistRequestBase(aParams.get_PersistedParams().principalInfo()),
7548 mPersisted(false) {
7549 MOZ_ASSERT(aParams.type() == RequestParams::TPersistedParams);
7550 }
7551
7552 nsresult PersistedOp::DoDirectoryWork(QuotaManager* aQuotaManager) {
7553 AssertIsOnIOThread();
7554 MOZ_ASSERT(!mPersistenceType.IsNull());
7555 MOZ_ASSERT(mPersistenceType.Value() == PERSISTENCE_TYPE_DEFAULT);
7556 MOZ_ASSERT(mOriginScope.IsOrigin());
7557
7558 AUTO_PROFILER_LABEL("PersistedOp::DoDirectoryWork", OTHER);
7559
7560 Nullable<bool> persisted =
7561 aQuotaManager->OriginPersisted(mGroup, mOriginScope.GetOrigin());
7562
7563 if (!persisted.IsNull()) {
7564 mPersisted = persisted.Value();
7565 return NS_OK;
7566 }
7567
7568 // If we get here, it means the origin hasn't been initialized yet.
7569 // Try to get the persisted flag from directory metadata on disk.
7570
7571 nsCOMPtr<nsIFile> directory;
7572 nsresult rv = aQuotaManager->GetDirectoryForOrigin(mPersistenceType.Value(),
7573 mOriginScope.GetOrigin(),
7574 getter_AddRefs(directory));
7575 if (NS_WARN_IF(NS_FAILED(rv))) {
7576 return rv;
7577 }
7578
7579 bool exists;
7580 rv = directory->Exists(&exists);
7581 if (NS_WARN_IF(NS_FAILED(rv))) {
7582 return rv;
7583 }
7584
7585 if (exists) {
7586 // Get the persisted flag.
7587 bool persisted;
7588 rv = aQuotaManager->GetDirectoryMetadata2WithRestore(
7589 directory,
7590 /* aPersistent */ false,
7591 /* aTimestamp */ nullptr, &persisted);
7592 if (NS_WARN_IF(NS_FAILED(rv))) {
7593 return rv;
7594 }
7595
7596 mPersisted = persisted;
7597 } else {
7598 // The directory has not been created yet.
7599 mPersisted = false;
7600 }
7601
7602 return NS_OK;
7603 }
7604
7605 void PersistedOp::GetResponse(RequestResponse& aResponse) {
7606 AssertIsOnOwningThread();
7607
7608 PersistedResponse persistedResponse;
7609 persistedResponse.persisted() = mPersisted;
7610
7611 aResponse = persistedResponse;
7612 }
7613
7614 PersistOp::PersistOp(const RequestParams& aParams)
7615 : PersistRequestBase(aParams.get_PersistParams().principalInfo()) {
7616 MOZ_ASSERT(aParams.type() == RequestParams::TPersistParams);
7617 }
7618
7619 nsresult PersistOp::DoDirectoryWork(QuotaManager* aQuotaManager) {
7620 AssertIsOnIOThread();
7621 MOZ_ASSERT(!mPersistenceType.IsNull());
7622 MOZ_ASSERT(mPersistenceType.Value() == PERSISTENCE_TYPE_DEFAULT);
7623 MOZ_ASSERT(mOriginScope.IsOrigin());
7624
7625 AUTO_PROFILER_LABEL("PersistOp::DoDirectoryWork", OTHER);
7626
7627 // Update directory metadata on disk first. Then, create/update the originInfo
7628 // if needed.
7629 nsCOMPtr<nsIFile> directory;
7630 nsresult rv = aQuotaManager->GetDirectoryForOrigin(mPersistenceType.Value(),
7631 mOriginScope.GetOrigin(),
7632 getter_AddRefs(directory));
7633 if (NS_WARN_IF(NS_FAILED(rv))) {
7634 return rv;
7635 }
7636
7637 bool created;
7638 rv = aQuotaManager->EnsureOriginDirectory(directory,
7639 /* aCreateIfNotExists */ true,
7640 &created);
7641 if (NS_WARN_IF(NS_FAILED(rv))) {
7642 return rv;
7643 }
7644
7645 if (created) {
7646 int64_t timestamp;
7647 rv = CreateDirectoryMetadataFiles(directory,
7648 /* aPersisted */ true, mSuffix, mGroup,
7649 mOriginScope.GetOrigin(), &timestamp);
7650 if (NS_WARN_IF(NS_FAILED(rv))) {
7651 return rv;
7652 }
7653
7654 // Directory metadata has been successfully created.
7655 // Create OriginInfo too if temporary storage was already initialized.
7656 if (aQuotaManager->IsTemporaryStorageInitialized()) {
7657 aQuotaManager->InitQuotaForOrigin(mPersistenceType.Value(), mGroup,
7658 mOriginScope.GetOrigin(),
7659 /* aUsageBytes */ 0, timestamp,
7660 /* aPersisted */ true);
7661 }
7662 } else {
7663 // Get the persisted flag (restore the metadata file if necessary).
7664 bool persisted;
7665 rv = aQuotaManager->GetDirectoryMetadata2WithRestore(
7666 directory,
7667 /* aPersistent */ false,
7668 /* aTimestamp */ nullptr, &persisted);
7669 if (NS_WARN_IF(NS_FAILED(rv))) {
7670 return rv;
7671 }
7672
7673 if (!persisted) {
7674 nsCOMPtr<nsIFile> file;
7675 nsresult rv = directory->Clone(getter_AddRefs(file));
7676 if (NS_WARN_IF(NS_FAILED(rv))) {
7677 return rv;
7678 }
7679
7680 rv = file->Append(NS_LITERAL_STRING(METADATA_V2_FILE_NAME));
7681 if (NS_WARN_IF(NS_FAILED(rv))) {
7682 return rv;
7683 }
7684
7685 nsCOMPtr<nsIBinaryOutputStream> stream;
7686 rv = GetBinaryOutputStream(file, kUpdateFileFlag, getter_AddRefs(stream));
7687 if (NS_WARN_IF(NS_FAILED(rv))) {
7688 return rv;
7689 }
7690
7691 MOZ_ASSERT(stream);
7692
7693 // Update origin access time while we are here.
7694 rv = stream->Write64(PR_Now());
7695 if (NS_WARN_IF(NS_FAILED(rv))) {
7696 return rv;
7697 }
7698
7699 // Set the persisted flag to true.
7700 rv = stream->WriteBoolean(true);
7701 if (NS_WARN_IF(NS_FAILED(rv))) {
7702 return rv;
7703 }
7704 }
7705
7706 // Directory metadata has been successfully updated.
7707 // Update OriginInfo too if temporary storage was already initialized.
7708 if (aQuotaManager->IsTemporaryStorageInitialized()) {
7709 aQuotaManager->PersistOrigin(mGroup, mOriginScope.GetOrigin());
7710 }
7711 }
7712
7713 return NS_OK;
7714 }
7715
7716 void PersistOp::GetResponse(RequestResponse& aResponse) {
7717 AssertIsOnOwningThread();
7718
7719 aResponse = PersistResponse();
7720 }
7721
7722 nsresult StorageOperationBase::GetDirectoryMetadata(nsIFile* aDirectory,
7723 int64_t& aTimestamp,
7724 nsACString& aGroup,
7725 nsACString& aOrigin,
7726 Nullable<bool>& aIsApp) {
7727 AssertIsOnIOThread();
7728 MOZ_ASSERT(aDirectory);
7729
7730 nsCOMPtr<nsIBinaryInputStream> binaryStream;
7731 nsresult rv =
7732 GetBinaryInputStream(aDirectory, NS_LITERAL_STRING(METADATA_FILE_NAME),
7733 getter_AddRefs(binaryStream));
7734 if (NS_WARN_IF(NS_FAILED(rv))) {
7735 return rv;
7736 }
7737
7738 uint64_t timestamp;
7739 rv = binaryStream->Read64(&timestamp);
7740 if (NS_WARN_IF(NS_FAILED(rv))) {
7741 return rv;
7742 }
7743
7744 nsCString group;
7745 rv = binaryStream->ReadCString(group);
7746 if (NS_WARN_IF(NS_FAILED(rv))) {
7747 return rv;
7748 }
7749
7750 nsCString origin;
7751 rv = binaryStream->ReadCString(origin);
7752 if (NS_WARN_IF(NS_FAILED(rv))) {
7753 return rv;
7754 }
7755
7756 Nullable<bool> isApp;
7757 bool value;
7758 if (NS_SUCCEEDED(binaryStream->ReadBoolean(&value))) {
7759 isApp.SetValue(value);
7760 }
7761
7762 aTimestamp = timestamp;
7763 aGroup = group;
7764 aOrigin = origin;
7765 aIsApp = std::move(isApp);
7766 return NS_OK;
7767 }
7768
7769 nsresult StorageOperationBase::GetDirectoryMetadata2(
7770 nsIFile* aDirectory, int64_t& aTimestamp, nsACString& aSuffix,
7771 nsACString& aGroup, nsACString& aOrigin, bool& aIsApp) {
7772 AssertIsOnIOThread();
7773 MOZ_ASSERT(aDirectory);
7774
7775 nsCOMPtr<nsIBinaryInputStream> binaryStream;
7776 nsresult rv =
7777 GetBinaryInputStream(aDirectory, NS_LITERAL_STRING(METADATA_V2_FILE_NAME),
7778 getter_AddRefs(binaryStream));
7779 if (NS_WARN_IF(NS_FAILED(rv))) {
7780 return rv;
7781 }
7782
7783 uint64_t timestamp;
7784 rv = binaryStream->Read64(&timestamp);
7785 if (NS_WARN_IF(NS_FAILED(rv))) {
7786 return rv;
7787 }
7788
7789 bool persisted;
7790 rv = binaryStream->ReadBoolean(&persisted);
7791 if (NS_WARN_IF(NS_FAILED(rv))) {
7792 return rv;
7793 }
7794
7795 uint32_t reservedData1;
7796 rv = binaryStream->Read32(&reservedData1);
7797 if (NS_WARN_IF(NS_FAILED(rv))) {
7798 return rv;
7799 }
7800
7801 uint32_t reservedData2;
7802 rv = binaryStream->Read32(&reservedData2);
7803 if (NS_WARN_IF(NS_FAILED(rv))) {
7804 return rv;
7805 }
7806
7807 nsCString suffix;
7808 rv = binaryStream->ReadCString(suffix);
7809 if (NS_WARN_IF(NS_FAILED(rv))) {
7810 return rv;
7811 }
7812
7813 nsCString group;
7814 rv = binaryStream->ReadCString(group);
7815 if (NS_WARN_IF(NS_FAILED(rv))) {
7816 return rv;
7817 }
7818
7819 nsCString origin;
7820 rv = binaryStream->ReadCString(origin);
7821 if (NS_WARN_IF(NS_FAILED(rv))) {
7822 return rv;
7823 }
7824
7825 bool isApp;
7826 rv = binaryStream->ReadBoolean(&isApp);
7827 if (NS_WARN_IF(NS_FAILED(rv))) {
7828 return rv;
7829 }
7830
7831 aTimestamp = timestamp;
7832 aSuffix = suffix;
7833 aGroup = group;
7834 aOrigin = origin;
7835 aIsApp = isApp;
7836 return NS_OK;
7837 }
7838
7839 nsresult StorageOperationBase::RemoveObsoleteOrigin(
7840 const OriginProps& aOriginProps) {
7841 AssertIsOnIOThread();
7842 MOZ_ASSERT(aOriginProps.mDirectory);
7843
7844 QM_WARNING(
7845 "Deleting obsolete %s directory that is no longer a legal "
7846 "origin!",
7847 NS_ConvertUTF16toUTF8(aOriginProps.mLeafName).get());
7848
7849 nsresult rv = aOriginProps.mDirectory->Remove(/* recursive */ true);
7850 if (NS_WARN_IF(NS_FAILED(rv))) {
7851 return rv;
7852 }
7853
7854 return NS_OK;
7855 }
7856
7857 nsresult StorageOperationBase::ProcessOriginDirectories() {
7858 AssertIsOnIOThread();
7859 MOZ_ASSERT(!mOriginProps.IsEmpty());
7860
7861 MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
7862
7863 {
7864 mozilla::MutexAutoLock autolock(mMutex);
7865 while (mWaiting) {
7866 mCondVar.Wait();
7867 }
7868 }
7869
7870 if (NS_WARN_IF(NS_FAILED(mMainThreadResultCode))) {
7871 return mMainThreadResultCode;
7872 }
7873
7874 // Verify that the bounce to the main thread didn't start the shutdown
7875 // sequence.
7876 if (NS_WARN_IF(QuotaManager::IsShuttingDown())) {
7877 return NS_ERROR_FAILURE;
7878 }
7879
7880 nsresult rv;
7881
7882 // Don't try to upgrade obsolete origins, remove them right after we detect
7883 // them.
7884 for (auto& originProps : mOriginProps) {
7885 if (originProps.mType == OriginProps::eObsolete) {
7886 MOZ_ASSERT(originProps.mSuffix.IsEmpty());
7887 MOZ_ASSERT(originProps.mGroup.IsEmpty());
7888 MOZ_ASSERT(originProps.mOrigin.IsEmpty());
7889
7890 rv = RemoveObsoleteOrigin(originProps);
7891 } else {
7892 MOZ_ASSERT(!originProps.mGroup.IsEmpty());
7893 MOZ_ASSERT(!originProps.mOrigin.IsEmpty());
7894
7895 rv = ProcessOriginDirectory(originProps);
7896 }
7897 if (NS_WARN_IF(NS_FAILED(rv))) {
7898 return rv;
7899 }
7900 }
7901
7902 return NS_OK;
7903 }
7904
7905 nsresult StorageOperationBase::RunOnMainThread() {
7906 MOZ_ASSERT(NS_IsMainThread());
7907 MOZ_ASSERT(!mOriginProps.IsEmpty());
7908
7909 nsresult rv;
7910
7911 for (uint32_t count = mOriginProps.Length(), index = 0; index < count;
7912 index++) {
7913 OriginProps& originProps = mOriginProps[index];
7914
7915 switch (originProps.mType) {
7916 case OriginProps::eChrome: {
7917 QuotaManager::GetInfoForChrome(
7918 &originProps.mSuffix, &originProps.mGroup, &originProps.mOrigin);
7919 break;
7920 }
7921
7922 case OriginProps::eContent: {
7923 nsCOMPtr<nsIURI> uri;
7924 rv = NS_NewURI(getter_AddRefs(uri), originProps.mSpec);
7925 if (NS_WARN_IF(NS_FAILED(rv))) {
7926 return rv;
7927 }
7928
7929 nsCOMPtr<nsIPrincipal> principal =
7930 BasePrincipal::CreateCodebasePrincipal(uri, originProps.mAttrs);
7931 if (NS_WARN_IF(!principal)) {
7932 return NS_ERROR_FAILURE;
7933 }
7934
7935 rv = QuotaManager::GetInfoFromPrincipal(principal, &originProps.mSuffix,
7936 &originProps.mGroup,
7937 &originProps.mOrigin);
7938 if (NS_WARN_IF(NS_FAILED(rv))) {
7939 return rv;
7940 }
7941
7942 break;
7943 }
7944
7945 case OriginProps::eObsolete: {
7946 // There's no way to get info for obsolete origins.
7947 break;
7948 }
7949
7950 default:
7951 MOZ_CRASH("Bad type!");
7952 }
7953 }
7954
7955 return NS_OK;
7956 }
7957
7958 NS_IMETHODIMP
7959 StorageOperationBase::Run() {
7960 MOZ_ASSERT(NS_IsMainThread());
7961
7962 nsresult rv = RunOnMainThread();
7963 if (NS_WARN_IF(NS_FAILED(rv))) {
7964 mMainThreadResultCode = rv;
7965 }
7966
7967 MutexAutoLock lock(mMutex);
7968 MOZ_ASSERT(mWaiting);
7969
7970 mWaiting = false;
7971 mCondVar.Notify();
7972
7973 return NS_OK;
7974 }
7975
7976 nsresult StorageOperationBase::OriginProps::Init(nsIFile* aDirectory) {
7977 AssertIsOnIOThread();
7978 MOZ_ASSERT(aDirectory);
7979
7980 nsString leafName;
7981 nsresult rv = aDirectory->GetLeafName(leafName);
7982 if (NS_WARN_IF(NS_FAILED(rv))) {
7983 return rv;
7984 }
7985
7986 if (leafName.EqualsLiteral(kChromeOrigin)) {
7987 // XXX We can remove this special handling once origin parser supports it
7988 // directly.
7989 mDirectory = aDirectory;
7990 mLeafName = leafName;
7991 mSpec = kChromeOrigin;
7992 mType = eChrome;
7993 } else if (leafName.EqualsLiteral("moz-safe-about+++home")) {
7994 // XXX We can remove this special handling once origin parser supports it
7995 // directly.
7996
7997 // This directory was accidentally created by a buggy nightly and can be
7998 // safely removed.
7999
8000 mDirectory = aDirectory;
8001 mLeafName = leafName;
8002 mType = eObsolete;
8003 } else {
8004 nsCString spec;
8005 OriginAttributes attrs;
8006 OriginParser::ResultType result = OriginParser::ParseOrigin(
8007 NS_ConvertUTF16toUTF8(leafName), spec, &attrs);
8008 if (NS_WARN_IF(result == OriginParser::InvalidOrigin)) {
8009 return NS_ERROR_FAILURE;
8010 }
8011
8012 mDirectory = aDirectory;
8013 mLeafName = leafName;
8014 mSpec = spec;
8015 mAttrs = attrs;
8016 mType = result == OriginParser::ObsoleteOrigin ? eObsolete : eContent;
8017 }
8018
8019 return NS_OK;
8020 }
8021
8022 // static
8023 auto OriginParser::ParseOrigin(const nsACString& aOrigin, nsCString& aSpec,
8024 OriginAttributes* aAttrs) -> ResultType {
8025 MOZ_ASSERT(!aOrigin.IsEmpty());
8026 MOZ_ASSERT(aAttrs);
8027
8028 OriginAttributes originAttributes;
8029
8030 nsCString originNoSuffix;
8031 bool ok = originAttributes.PopulateFromOrigin(aOrigin, originNoSuffix);
8032 if (!ok) {
8033 return InvalidOrigin;
8034 }
8035
8036 OriginParser parser(originNoSuffix, originAttributes);
8037 return parser.Parse(aSpec, aAttrs);
8038 }
8039
8040 auto OriginParser::Parse(nsACString& aSpec, OriginAttributes* aAttrs)
8041 -> ResultType {
8042 MOZ_ASSERT(aAttrs);
8043
8044 while (mTokenizer.hasMoreTokens()) {
8045 const nsDependentCSubstring& token = mTokenizer.nextToken();
8046
8047 HandleToken(token);
8048
8049 if (mError) {
8050 break;
8051 }
8052
8053 if (!mHandledTokens.IsEmpty()) {
8054 mHandledTokens.AppendLiteral(", ");
8055 }
8056 mHandledTokens.Append('\'');
8057 mHandledTokens.Append(token);
8058 mHandledTokens.Append('\'');
8059 }
8060
8061 if (!mError && mTokenizer.separatorAfterCurrentToken()) {
8062 HandleTrailingSeparator();
8063 }
8064
8065 if (mError) {
8066 QM_WARNING("Origin '%s' failed to parse, handled tokens: %s", mOrigin.get(),
8067 mHandledTokens.get());
8068
8069 return InvalidOrigin;
8070 }
8071
8072 MOZ_ASSERT(mState == eComplete || mState == eHandledTrailingSeparator);
8073
8074 // For IPv6 URL, it should at least have three groups.
8075 MOZ_ASSERT_IF(mIPGroup > 0, mIPGroup >= 3);
8076
8077 if (mAppId == kNoAppId) {
8078 *aAttrs = mOriginAttributes;
8079 } else {
8080 MOZ_ASSERT(mOriginAttributes.mAppId == kNoAppId);
8081
8082 *aAttrs = OriginAttributes(mAppId, mInIsolatedMozBrowser);
8083 }
8084
8085 nsAutoCString spec(mScheme);
8086
8087 if (mSchemeType == eFile) {
8088 spec.AppendLiteral("://");
8089
8090 if (mUniversalFileOrigin) {
8091 MOZ_ASSERT(mPathnameComponents.Length() == 1);
8092
8093 spec.Append(mPathnameComponents[0]);
8094 } else {
8095 for (uint32_t count = mPathnameComponents.Length(), index = 0;
8096 index < count; index++) {
8097 spec.Append('/');
8098 spec.Append(mPathnameComponents[index]);
8099 }
8100 }
8101
8102 aSpec = spec;
8103
8104 return ValidOrigin;
8105 }
8106
8107 if (mSchemeType == eAbout) {
8108 spec.Append(':');
8109 } else {
8110 spec.AppendLiteral("://");
8111 }
8112
8113 spec.Append(mHost);
8114
8115 if (!mPort.IsNull()) {
8116 spec.Append(':');
8117 spec.AppendInt(mPort.Value());
8118 }
8119
8120 aSpec = spec;
8121
8122 return mScheme.EqualsLiteral("app") ? ObsoleteOrigin : ValidOrigin;
8123 }
8124
8125 void OriginParser::HandleScheme(const nsDependentCSubstring& aToken) {
8126 MOZ_ASSERT(!aToken.IsEmpty());
8127 MOZ_ASSERT(mState == eExpectingAppIdOrScheme || mState == eExpectingScheme);
8128
8129 bool isAbout = false;
8130 bool isFile = false;
8131 if (aToken.EqualsLiteral("http") || aToken.EqualsLiteral("https") ||
8132 (isAbout = aToken.EqualsLiteral("about") ||
8133 aToken.EqualsLiteral("moz-safe-about")) ||
8134 aToken.EqualsLiteral("indexeddb") ||
8135 (isFile = aToken.EqualsLiteral("file")) || aToken.EqualsLiteral("app") ||
8136 aToken.EqualsLiteral("resource") ||
8137 aToken.EqualsLiteral("moz-extension")) {
8138 mScheme = aToken;
8139
8140 if (isAbout) {
8141 mSchemeType = eAbout;
8142 mState = eExpectingHost;
8143 } else {
8144 if (isFile) {
8145 mSchemeType = eFile;
8146 }
8147 mState = eExpectingEmptyToken1;
8148 }
8149
8150 return;
8151 }
8152
8153 QM_WARNING("'%s' is not a valid scheme!", nsCString(aToken).get());
8154
8155 mError = true;
8156 }
8157
8158 void OriginParser::HandlePathnameComponent(
8159 const nsDependentCSubstring& aToken) {
8160 MOZ_ASSERT(!aToken.IsEmpty());
8161 MOZ_ASSERT(mState == eExpectingEmptyTokenOrDriveLetterOrPathnameComponent ||
8162 mState == eExpectingEmptyTokenOrPathnameComponent);
8163 MOZ_ASSERT(mSchemeType == eFile);
8164
8165 mPathnameComponents.AppendElement(aToken);
8166
8167 mState = mTokenizer.hasMoreTokens() ? eExpectingEmptyTokenOrPathnameComponent
8168 : eComplete;
8169 }
8170
8171 void OriginParser::HandleToken(const nsDependentCSubstring& aToken) {
8172 switch (mState) {
8173 case eExpectingAppIdOrScheme: {
8174 if (aToken.IsEmpty()) {
8175 QM_WARNING("Expected an app id or scheme (not an empty string)!");
8176
8177 mError = true;
8178 return;
8179 }
8180
8181 if (IsAsciiDigit(aToken.First())) {
8182 // nsDependentCSubstring doesn't provice ToInteger()
8183 nsCString token(aToken);
8184
8185 nsresult rv;
8186 uint32_t appId = token.ToInteger(&rv);
8187 if (NS_SUCCEEDED(rv)) {
8188 mAppId = appId;
8189 mState = eExpectingInMozBrowser;
8190 return;
8191 }
8192 }
8193
8194 HandleScheme(aToken);
8195
8196 return;
8197 }
8198
8199 case eExpectingInMozBrowser: {
8200 if (aToken.Length() != 1) {
8201 QM_WARNING("'%d' is not a valid length for the inMozBrowser flag!",
8202 aToken.Length());
8203
8204 mError = true;
8205 return;
8206 }
8207
8208 if (aToken.First() == 't') {
8209 mInIsolatedMozBrowser = true;
8210 } else if (aToken.First() == 'f') {
8211 mInIsolatedMozBrowser = false;
8212 } else {
8213 QM_WARNING("'%s' is not a valid value for the inMozBrowser flag!",
8214 nsCString(aToken).get());
8215
8216 mError = true;
8217 return;
8218 }
8219
8220 mState = eExpectingScheme;
8221
8222 return;
8223 }
8224
8225 case eExpectingScheme: {
8226 if (aToken.IsEmpty()) {
8227 QM_WARNING("Expected a scheme (not an empty string)!");
8228
8229 mError = true;
8230 return;
8231 }
8232
8233 HandleScheme(aToken);
8234
8235 return;
8236 }
8237
8238 case eExpectingEmptyToken1: {
8239 if (!aToken.IsEmpty()) {
8240 QM_WARNING("Expected the first empty token!");
8241
8242 mError = true;
8243 return;
8244 }
8245
8246 mState = eExpectingEmptyToken2;
8247
8248 return;
8249 }
8250
8251 case eExpectingEmptyToken2: {
8252 if (!aToken.IsEmpty()) {
8253 QM_WARNING("Expected the second empty token!");
8254
8255 mError = true;
8256 return;
8257 }
8258
8259 if (mSchemeType == eFile) {
8260 mState = eExpectingEmptyTokenOrUniversalFileOrigin;
8261 } else {
8262 mState = eExpectingHost;
8263 }
8264
8265 return;
8266 }
8267
8268 case eExpectingEmptyTokenOrUniversalFileOrigin: {
8269 MOZ_ASSERT(mSchemeType == eFile);
8270
8271 if (aToken.IsEmpty()) {
8272 mState = mTokenizer.hasMoreTokens()
8273 ? eExpectingEmptyTokenOrDriveLetterOrPathnameComponent
8274 : eComplete;
8275
8276 return;
8277 }
8278
8279 if (aToken.EqualsLiteral("UNIVERSAL_FILE_URI_ORIGIN")) {
8280 mUniversalFileOrigin = true;
8281
8282 mPathnameComponents.AppendElement(aToken);
8283
8284 mState = eComplete;
8285
8286 return;
8287 }
8288
8289 QM_WARNING(
8290 "Expected the third empty token or "
8291 "UNIVERSAL_FILE_URI_ORIGIN!");
8292
8293 mError = true;
8294 return;
8295 }
8296
8297 case eExpectingHost: {
8298 if (aToken.IsEmpty()) {
8299 QM_WARNING("Expected a host (not an empty string)!");
8300
8301 mError = true;
8302 return;
8303 }
8304
8305 mHost = aToken;
8306
8307 if (aToken.First() == '[') {
8308 MOZ_ASSERT(mIPGroup == 0);
8309
8310 ++mIPGroup;
8311 mState = eExpectingIPV6Token;
8312
8313 MOZ_ASSERT(mTokenizer.hasMoreTokens());
8314 return;
8315 }
8316
8317 mState = mTokenizer.hasMoreTokens() ? eExpectingPort : eComplete;
8318
8319 return;
8320 }
8321
8322 case eExpectingPort: {
8323 MOZ_ASSERT(mSchemeType == eNone);
8324
8325 if (aToken.IsEmpty()) {
8326 QM_WARNING("Expected a port (not an empty string)!");
8327
8328 mError = true;
8329 return;
8330 }
8331
8332 // nsDependentCSubstring doesn't provice ToInteger()
8333 nsCString token(aToken);
8334
8335 nsresult rv;
8336 uint32_t port = token.ToInteger(&rv);
8337 if (NS_SUCCEEDED(rv)) {
8338 mPort.SetValue() = port;
8339 } else {
8340 QM_WARNING("'%s' is not a valid port number!", token.get());
8341
8342 mError = true;
8343 return;
8344 }
8345
8346 mState = eComplete;
8347
8348 return;
8349 }
8350
8351 case eExpectingEmptyTokenOrDriveLetterOrPathnameComponent: {
8352 MOZ_ASSERT(mSchemeType == eFile);
8353
8354 if (aToken.IsEmpty()) {
8355 mPathnameComponents.AppendElement(EmptyCString());
8356
8357 mState = mTokenizer.hasMoreTokens()
8358 ? eExpectingEmptyTokenOrPathnameComponent
8359 : eComplete;
8360
8361 return;
8362 }
8363
8364 if (aToken.Length() == 1 && IsAsciiAlpha(aToken.First())) {
8365 mMaybeDriveLetter = true;
8366
8367 mPathnameComponents.AppendElement(aToken);
8368
8369 mState = mTokenizer.hasMoreTokens()
8370 ? eExpectingEmptyTokenOrPathnameComponent
8371 : eComplete;
8372
8373 return;
8374 }
8375
8376 HandlePathnameComponent(aToken);
8377
8378 return;
8379 }
8380
8381 case eExpectingEmptyTokenOrPathnameComponent: {
8382 MOZ_ASSERT(mSchemeType == eFile);
8383
8384 if (aToken.IsEmpty()) {
8385 if (mMaybeDriveLetter) {
8386 MOZ_ASSERT(mPathnameComponents.Length() == 1);
8387
8388 nsCString& pathnameComponent = mPathnameComponents[0];
8389 pathnameComponent.Append(':');
8390
8391 mMaybeDriveLetter = false;
8392 } else {
8393 mPathnameComponents.AppendElement(EmptyCString());
8394 }
8395
8396 mState = mTokenizer.hasMoreTokens()
8397 ? eExpectingEmptyTokenOrPathnameComponent
8398 : eComplete;
8399
8400 return;
8401 }
8402
8403 HandlePathnameComponent(aToken);
8404
8405 return;
8406 }
8407
8408 case eExpectingIPV6Token: {
8409 // A safe check for preventing infinity recursion.
8410 if (++mIPGroup > 8) {
8411 mError = true;
8412 return;
8413 }
8414
8415 mHost.AppendLiteral(":");
8416 mHost.Append(aToken);
8417 if (!aToken.IsEmpty() && aToken.Last() == ']') {
8418 mState = mTokenizer.hasMoreTokens() ? eExpectingPort : eComplete;
8419 }
8420
8421 return;
8422 }
8423
8424 default:
8425 MOZ_CRASH("Should never get here!");
8426 }
8427 }
8428
8429 void OriginParser::HandleTrailingSeparator() {
8430 MOZ_ASSERT(mState == eComplete);
8431 MOZ_ASSERT(mSchemeType == eFile);
8432
8433 mPathnameComponents.AppendElement(EmptyCString());
8434
8435 mState = eHandledTrailingSeparator;
8436 }
8437
8438 nsresult RepositoryOperationBase::ProcessRepository() {
8439 AssertIsOnIOThread();
8440
8441 DebugOnly<bool> exists;
8442 MOZ_ASSERT(NS_SUCCEEDED(mDirectory->Exists(&exists)));
8443 MOZ_ASSERT(exists);
8444
8445 nsCOMPtr<nsIDirectoryEnumerator> entries;
8446 nsresult rv = mDirectory->GetDirectoryEntries(getter_AddRefs(entries));
8447 if (NS_WARN_IF(NS_FAILED(rv))) {
8448 return rv;
8449 }
8450
8451 while (true) {
8452 nsCOMPtr<nsIFile> originDir;
8453 rv = entries->GetNextFile(getter_AddRefs(originDir));
8454 if (NS_WARN_IF(NS_FAILED(rv))) {
8455 return rv;
8456 }
8457
8458 if (!originDir) {
8459 break;
8460 }
8461
8462 bool isDirectory;
8463 rv = originDir->IsDirectory(&isDirectory);
8464 if (NS_WARN_IF(NS_FAILED(rv))) {
8465 return rv;
8466 }
8467
8468 if (!isDirectory) {
8469 nsString leafName;
8470 rv = originDir->GetLeafName(leafName);
8471 if (NS_WARN_IF(NS_FAILED(rv))) {
8472 return rv;
8473 }
8474
8475 // Unknown files during upgrade are allowed. Just warn if we find them.
8476 if (!IsOSMetadata(leafName)) {
8477 UNKNOWN_FILE_WARNING(leafName);
8478 }
8479 continue;
8480 }
8481
8482 OriginProps originProps;
8483 rv = originProps.Init(originDir);
8484 if (NS_WARN_IF(NS_FAILED(rv))) {
8485 return rv;
8486 }
8487
8488 if (originProps.mType != OriginProps::eObsolete) {
8489 bool removed;
8490 rv = PrepareOriginDirectory(originProps, &removed);
8491 if (NS_WARN_IF(NS_FAILED(rv))) {
8492 return rv;
8493 }
8494 if (removed) {
8495 continue;
8496 }
8497 }
8498
8499 mOriginProps.AppendElement(std::move(originProps));
8500 }
8501
8502 if (mOriginProps.IsEmpty()) {
8503 return NS_OK;
8504 }
8505
8506 rv = ProcessOriginDirectories();
8507 if (NS_WARN_IF(NS_FAILED(rv))) {
8508 return rv;
8509 }
8510
8511 return NS_OK;
8512 }
8513
8514 template <typename UpgradeMethod>
8515 nsresult RepositoryOperationBase::MaybeUpgradeClients(
8516 const OriginProps& aOriginProps, UpgradeMethod aMethod) {
8517 AssertIsOnIOThread();
8518 MOZ_ASSERT(aOriginProps.mDirectory);
8519 MOZ_ASSERT(aMethod);
8520
8521 QuotaManager* quotaManager = QuotaManager::Get();
8522 MOZ_ASSERT(quotaManager);
8523
8524 nsCOMPtr<nsIDirectoryEnumerator> entries;
8525 nsresult rv =
8526 aOriginProps.mDirectory->GetDirectoryEntries(getter_AddRefs(entries));
8527 if (NS_WARN_IF(NS_FAILED(rv))) {
8528 return rv;
8529 }
8530
8531 while (true) {
8532 nsCOMPtr<nsIFile> file;
8533 rv = entries->GetNextFile(getter_AddRefs(file));
8534 if (NS_WARN_IF(NS_FAILED(rv))) {
8535 return rv;
8536 }
8537
8538 if (!file) {
8539 break;
8540 }
8541
8542 bool isDirectory;
8543 rv = file->IsDirectory(&isDirectory);
8544 if (NS_WARN_IF(NS_FAILED(rv))) {
8545 return rv;
8546 }
8547
8548 nsString leafName;
8549 rv = file->GetLeafName(leafName);
8550 if (NS_WARN_IF(NS_FAILED(rv))) {
8551 return rv;
8552 }
8553
8554 if (!isDirectory) {
8555 // Unknown files during upgrade are allowed. Just warn if we find them.
8556 if (!IsOriginMetadata(leafName) && !IsTempMetadata(leafName)) {
8557 UNKNOWN_FILE_WARNING(leafName);
8558 }
8559 continue;
8560 }
8561
8562 Client::Type clientType;
8563 rv = Client::TypeFromText(leafName, clientType);
8564 if (NS_FAILED(rv)) {
8565 UNKNOWN_FILE_WARNING(leafName);
8566 continue;
8567 }
8568
8569 Client* client = quotaManager->GetClient(clientType);
8570 MOZ_ASSERT(client);
8571
8572 rv = (client->*aMethod)(file);
8573 if (NS_WARN_IF(NS_FAILED(rv))) {
8574 return rv;
8575 }
8576 }
8577
8578 return NS_OK;
8579 }
8580
8581 nsresult CreateOrUpgradeDirectoryMetadataHelper::MaybeUpgradeOriginDirectory(
8582 nsIFile* aDirectory) {
8583 AssertIsOnIOThread();
8584 MOZ_ASSERT(aDirectory);
8585
8586 nsCOMPtr<nsIFile> metadataFile;
8587 nsresult rv = aDirectory->Clone(getter_AddRefs(metadataFile));
8588 if (NS_WARN_IF(NS_FAILED(rv))) {
8589 return rv;
8590 }
8591
8592 rv = metadataFile->Append(NS_LITERAL_STRING(METADATA_FILE_NAME));
8593 if (NS_WARN_IF(NS_FAILED(rv))) {
8594 return rv;
8595 }
8596
8597 bool exists;
8598 rv = metadataFile->Exists(&exists);
8599 if (NS_WARN_IF(NS_FAILED(rv))) {
8600 return rv;
8601 }
8602
8603 if (!exists) {
8604 // Directory structure upgrade needed.
8605 // Move all files to IDB specific directory.
8606
8607 nsString idbDirectoryName;
8608 rv = Client::TypeToText(Client::IDB, idbDirectoryName);
8609 if (NS_WARN_IF(NS_FAILED(rv))) {
8610 return rv;
8611 }
8612
8613 nsCOMPtr<nsIFile> idbDirectory;
8614 rv = aDirectory->Clone(getter_AddRefs(idbDirectory));
8615 if (NS_WARN_IF(NS_FAILED(rv))) {
8616 return rv;
8617 }
8618
8619 rv = idbDirectory->Append(idbDirectoryName);
8620 if (NS_WARN_IF(NS_FAILED(rv))) {
8621 return rv;
8622 }
8623
8624 rv = idbDirectory->Create(nsIFile::DIRECTORY_TYPE, 0755);
8625 if (rv == NS_ERROR_FILE_ALREADY_EXISTS) {
8626 NS_WARNING("IDB directory already exists!");
8627
8628 bool isDirectory;
8629 rv = idbDirectory->IsDirectory(&isDirectory);
8630 if (NS_WARN_IF(NS_FAILED(rv))) {
8631 return rv;
8632 }
8633
8634 if (NS_WARN_IF(!isDirectory)) {
8635 return NS_ERROR_UNEXPECTED;
8636 }
8637 } else {
8638 if (NS_WARN_IF(NS_FAILED(rv))) {
8639 return rv;
8640 }
8641 }
8642
8643 nsCOMPtr<nsIDirectoryEnumerator> entries;
8644 rv = aDirectory->GetDirectoryEntries(getter_AddRefs(entries));
8645 if (NS_WARN_IF(NS_FAILED(rv))) {
8646 return rv;
8647 }
8648
8649 nsCOMPtr<nsIFile> file;
8650 while (NS_SUCCEEDED((rv = entries->GetNextFile(getter_AddRefs(file)))) &&
8651 file) {
8652 nsString leafName;
8653 rv = file->GetLeafName(leafName);
8654 if (NS_WARN_IF(NS_FAILED(rv))) {
8655 return rv;
8656 }
8657
8658 if (!leafName.Equals(idbDirectoryName)) {
8659 rv = file->MoveTo(idbDirectory, EmptyString());
8660 if (NS_WARN_IF(NS_FAILED(rv))) {
8661 return rv;
8662 }
8663 }
8664 }
8665
8666 rv = metadataFile->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
8667 if (NS_WARN_IF(NS_FAILED(rv))) {
8668 return rv;
8669 }
8670 }
8671
8672 return NS_OK;
8673 }
8674
8675 nsresult CreateOrUpgradeDirectoryMetadataHelper::PrepareOriginDirectory(
8676 OriginProps& aOriginProps, bool* aRemoved) {
8677 AssertIsOnIOThread();
8678 MOZ_ASSERT(aOriginProps.mDirectory);
8679 MOZ_ASSERT(aRemoved);
8680
8681 nsresult rv;
8682
8683 if (mPersistent) {
8684 rv = MaybeUpgradeOriginDirectory(aOriginProps.mDirectory);
8685 if (NS_WARN_IF(NS_FAILED(rv))) {
8686 return rv;
8687 }
8688
8689 bool persistent = QuotaManager::IsOriginInternal(aOriginProps.mSpec);
8690 aOriginProps.mTimestamp =
8691 GetLastModifiedTime(aOriginProps.mDirectory, persistent);
8692 } else {
8693 int64_t timestamp;
8694 nsCString group;
8695 nsCString origin;
8696 Nullable<bool> isApp;
8697 rv = GetDirectoryMetadata(aOriginProps.mDirectory, timestamp, group, origin,
8698 isApp);
8699 if (NS_FAILED(rv)) {
8700 aOriginProps.mTimestamp =
8701 GetLastModifiedTime(aOriginProps.mDirectory, mPersistent);
8702 aOriginProps.mNeedsRestore = true;
8703 } else if (!isApp.IsNull()) {
8704 aOriginProps.mIgnore = true;
8705 }
8706 }
8707
8708 *aRemoved = false;
8709 return NS_OK;
8710 }
8711
8712 nsresult CreateOrUpgradeDirectoryMetadataHelper::ProcessOriginDirectory(
8713 const OriginProps& aOriginProps) {
8714 AssertIsOnIOThread();
8715
8716 nsresult rv;
8717
8718 if (mPersistent) {
8719 rv = CreateDirectoryMetadata(aOriginProps.mDirectory,
8720 aOriginProps.mTimestamp, aOriginProps.mSuffix,
8721 aOriginProps.mGroup, aOriginProps.mOrigin);
8722 if (NS_WARN_IF(NS_FAILED(rv))) {
8723 return rv;
8724 }
8725
8726 // Move internal origins to new persistent storage.
8727 if (QuotaManager::IsOriginInternal(aOriginProps.mSpec)) {
8728 if (!mPermanentStorageDir) {
8729 QuotaManager* quotaManager = QuotaManager::Get();
8730 MOZ_ASSERT(quotaManager);
8731
8732 const nsString& permanentStoragePath =
8733 quotaManager->GetStoragePath(PERSISTENCE_TYPE_PERSISTENT);
8734
8735 rv = NS_NewLocalFile(permanentStoragePath, false,
8736 getter_AddRefs(mPermanentStorageDir));
8737 if (NS_WARN_IF(NS_FAILED(rv))) {
8738 return rv;
8739 }
8740 }
8741
8742 nsString leafName;
8743 rv = aOriginProps.mDirectory->GetLeafName(leafName);
8744 if (NS_WARN_IF(NS_FAILED(rv))) {
8745 return rv;
8746 }
8747
8748 nsCOMPtr<nsIFile> newDirectory;
8749 rv = mPermanentStorageDir->Clone(getter_AddRefs(newDirectory));
8750 if (NS_WARN_IF(NS_FAILED(rv))) {
8751 return rv;
8752 }
8753
8754 rv = newDirectory->Append(leafName);
8755 if (NS_WARN_IF(NS_FAILED(rv))) {
8756 return rv;
8757 }
8758
8759 bool exists;
8760 rv = newDirectory->Exists(&exists);
8761 if (NS_WARN_IF(NS_FAILED(rv))) {
8762 return rv;
8763 }
8764
8765 if (exists) {
8766 QM_WARNING("Found %s in storage/persistent and storage/permanent !",
8767 NS_ConvertUTF16toUTF8(leafName).get());
8768
8769 rv = aOriginProps.mDirectory->Remove(/* recursive */ true);
8770 } else {
8771 rv = aOriginProps.mDirectory->MoveTo(mPermanentStorageDir,
8772 EmptyString());
8773 }
8774 if (NS_WARN_IF(NS_FAILED(rv))) {
8775 return rv;
8776 }
8777 }
8778 } else if (aOriginProps.mNeedsRestore) {
8779 rv = CreateDirectoryMetadata(aOriginProps.mDirectory,
8780 aOriginProps.mTimestamp, aOriginProps.mSuffix,
8781 aOriginProps.mGroup, aOriginProps.mOrigin);
8782 if (NS_WARN_IF(NS_FAILED(rv))) {
8783 return rv;
8784 }
8785 } else if (!aOriginProps.mIgnore) {
8786 nsCOMPtr<nsIFile> file;
8787 rv = aOriginProps.mDirectory->Clone(getter_AddRefs(file));
8788 if (NS_WARN_IF(NS_FAILED(rv))) {
8789 return rv;
8790 }
8791
8792 rv = file->Append(NS_LITERAL_STRING(METADATA_FILE_NAME));
8793 if (NS_WARN_IF(NS_FAILED(rv))) {
8794 return rv;
8795 }
8796
8797 nsCOMPtr<nsIBinaryOutputStream> stream;
8798 rv = GetBinaryOutputStream(file, kAppendFileFlag, getter_AddRefs(stream));
8799 if (NS_WARN_IF(NS_FAILED(rv))) {
8800 return rv;
8801 }
8802
8803 MOZ_ASSERT(stream);
8804
8805 // Currently unused (used to be isApp).
8806 rv = stream->WriteBoolean(false);
8807 if (NS_WARN_IF(NS_FAILED(rv))) {
8808 return rv;
8809 }
8810 }
8811
8812 return NS_OK;
8813 }
8814
8815 nsresult UpgradeStorageFrom0_0To1_0Helper::PrepareOriginDirectory(
8816 OriginProps& aOriginProps, bool* aRemoved) {
8817 AssertIsOnIOThread();
8818 MOZ_ASSERT(aOriginProps.mDirectory);
8819 MOZ_ASSERT(aRemoved);
8820
8821 int64_t timestamp;
8822 nsCString group;
8823 nsCString origin;
8824 Nullable<bool> isApp;
8825 nsresult rv = GetDirectoryMetadata(aOriginProps.mDirectory, timestamp, group,
8826 origin, isApp);
8827 if (NS_FAILED(rv) || isApp.IsNull()) {
8828 aOriginProps.mTimestamp =
8829 GetLastModifiedTime(aOriginProps.mDirectory, mPersistent);
8830 aOriginProps.mNeedsRestore = true;
8831 } else {
8832 aOriginProps.mTimestamp = timestamp;
8833 }
8834
8835 *aRemoved = false;
8836 return NS_OK;
8837 }
8838
8839 nsresult UpgradeStorageFrom0_0To1_0Helper::ProcessOriginDirectory(
8840 const OriginProps& aOriginProps) {
8841 AssertIsOnIOThread();
8842
8843 nsresult rv;
8844
8845 if (aOriginProps.mNeedsRestore) {
8846 rv = CreateDirectoryMetadata(aOriginProps.mDirectory,
8847 aOriginProps.mTimestamp, aOriginProps.mSuffix,
8848 aOriginProps.mGroup, aOriginProps.mOrigin);
8849 if (NS_WARN_IF(NS_FAILED(rv))) {
8850 return rv;
8851 }
8852 }
8853
8854 rv =
8855 CreateDirectoryMetadata2(aOriginProps.mDirectory, aOriginProps.mTimestamp,
8856 /* aPersisted */ false, aOriginProps.mSuffix,
8857 aOriginProps.mGroup, aOriginProps.mOrigin);
8858 if (NS_WARN_IF(NS_FAILED(rv))) {
8859 return rv;
8860 }
8861
8862 nsString oldName;
8863 rv = aOriginProps.mDirectory->GetLeafName(oldName);
8864 if (NS_WARN_IF(NS_FAILED(rv))) {
8865 return rv;
8866 }
8867
8868 nsAutoCString originSanitized(aOriginProps.mOrigin);
8869 SanitizeOriginString(originSanitized);
8870
8871 NS_ConvertASCIItoUTF16 newName(originSanitized);
8872
8873 if (!oldName.Equals(newName)) {
8874 rv = aOriginProps.mDirectory->RenameTo(nullptr, newName);
8875 if (NS_WARN_IF(NS_FAILED(rv))) {
8876 return rv;
8877 }
8878 }
8879
8880 return NS_OK;
8881 }
8882
8883 nsresult UpgradeStorageFrom1_0To2_0Helper::MaybeRemoveMorgueDirectory(
8884 const OriginProps& aOriginProps) {
8885 AssertIsOnIOThread();
8886 MOZ_ASSERT(aOriginProps.mDirectory);
8887
8888 // The Cache API was creating top level morgue directories by accident for
8889 // a short time in nightly. This unfortunately prevents all storage from
8890 // working. So recover these profiles permanently by removing these corrupt
8891 // directories as part of this upgrade.
8892
8893 nsCOMPtr<nsIFile> morgueDir;
8894 nsresult rv = aOriginProps.mDirectory->Clone(getter_AddRefs(morgueDir));
8895 if (NS_WARN_IF(NS_FAILED(rv))) {
8896 return rv;
8897 }
8898
8899 rv = morgueDir->Append(NS_LITERAL_STRING("morgue"));
8900 if (NS_WARN_IF(NS_FAILED(rv))) {
8901 return rv;
8902 }
8903
8904 bool exists;
8905 rv = morgueDir->Exists(&exists);
8906 if (NS_WARN_IF(NS_FAILED(rv))) {
8907 return rv;
8908 }
8909
8910 if (exists) {
8911 QM_WARNING("Deleting accidental morgue directory!");
8912
8913 rv = morgueDir->Remove(/* recursive */ true);
8914 if (NS_WARN_IF(NS_FAILED(rv))) {
8915 return rv;
8916 }
8917 }
8918
8919 return NS_OK;
8920 }
8921
8922 nsresult UpgradeStorageFrom1_0To2_0Helper::MaybeRemoveAppsData(
8923 const OriginProps& aOriginProps, bool* aRemoved) {
8924 AssertIsOnIOThread();
8925
8926 // XXX This will need to be reworked as part of bug 1320404 (appId is
8927 // going to be removed from origin attributes).
8928 if (aOriginProps.mAttrs.mAppId != kNoAppId &&
8929 aOriginProps.mAttrs.mAppId != kUnknownAppId) {
8930 nsresult rv = RemoveObsoleteOrigin(aOriginProps);
8931 if (NS_WARN_IF(NS_FAILED(rv))) {
8932 return rv;
8933 }
8934
8935 *aRemoved = true;
8936 return NS_OK;
8937 }
8938
8939 *aRemoved = false;
8940 return NS_OK;
8941 }
8942
8943 nsresult UpgradeStorageFrom1_0To2_0Helper::MaybeStripObsoleteOriginAttributes(
8944 const OriginProps& aOriginProps, bool* aStripped) {
8945 AssertIsOnIOThread();
8946 MOZ_ASSERT(aOriginProps.mDirectory);
8947
8948 const nsAString& oldLeafName = aOriginProps.mLeafName;
8949
8950 nsCString originSanitized(aOriginProps.mOrigin);
8951 SanitizeOriginString(originSanitized);
8952
8953 NS_ConvertUTF8toUTF16 newLeafName(originSanitized);
8954
8955 if (oldLeafName == newLeafName) {
8956 *aStripped = false;
8957 return NS_OK;
8958 }
8959
8960 nsresult rv = CreateDirectoryMetadata(
8961 aOriginProps.mDirectory, aOriginProps.mTimestamp, aOriginProps.mSuffix,
8962 aOriginProps.mGroup, aOriginProps.mOrigin);
8963 if (NS_WARN_IF(NS_FAILED(rv))) {
8964 return rv;
8965 }
8966
8967 rv =
8968 CreateDirectoryMetadata2(aOriginProps.mDirectory, aOriginProps.mTimestamp,
8969 /* aPersisted */ false, aOriginProps.mSuffix,
8970 aOriginProps.mGroup, aOriginProps.mOrigin);
8971 if (NS_WARN_IF(NS_FAILED(rv))) {
8972 return rv;
8973 }
8974
8975 nsCOMPtr<nsIFile> newFile;
8976 rv = aOriginProps.mDirectory->GetParent(getter_AddRefs(newFile));
8977 if (NS_WARN_IF(NS_FAILED(rv))) {
8978 return rv;
8979 }
8980
8981 rv = newFile->Append(newLeafName);
8982 if (NS_WARN_IF(NS_FAILED(rv))) {
8983 return rv;
8984 }
8985
8986 bool exists;
8987 rv = newFile->Exists(&exists);
8988 if (NS_WARN_IF(NS_FAILED(rv))) {
8989 return rv;
8990 }
8991
8992 if (exists) {
8993 QM_WARNING(
8994 "Can't rename %s directory, %s directory already exists, "
8995 "removing!",
8996 NS_ConvertUTF16toUTF8(oldLeafName).get(),
8997 NS_ConvertUTF16toUTF8(newLeafName).get());
8998
8999 rv = aOriginProps.mDirectory->Remove(/* recursive */ true);
9000 } else {
9001 rv = aOriginProps.mDirectory->RenameTo(nullptr, newLeafName);
9002 }
9003 if (NS_WARN_IF(NS_FAILED(rv))) {
9004 return rv;
9005 }
9006
9007 *aStripped = true;
9008 return NS_OK;
9009 }
9010
9011 nsresult UpgradeStorageFrom1_0To2_0Helper::PrepareOriginDirectory(
9012 OriginProps& aOriginProps, bool* aRemoved) {
9013 AssertIsOnIOThread();
9014 MOZ_ASSERT(aOriginProps.mDirectory);
9015 MOZ_ASSERT(aRemoved);
9016
9017 nsresult rv = MaybeRemoveMorgueDirectory(aOriginProps);
9018 if (NS_WARN_IF(NS_FAILED(rv))) {
9019 return rv;
9020 }
9021
9022 rv = MaybeUpgradeClients(aOriginProps, &Client::UpgradeStorageFrom1_0To2_0);
9023 if (NS_WARN_IF(NS_FAILED(rv))) {
9024 return rv;
9025 }
9026
9027 bool removed;
9028 rv = MaybeRemoveAppsData(aOriginProps, &removed);
9029 if (NS_WARN_IF(NS_FAILED(rv))) {
9030 return rv;
9031 }
9032 if (removed) {
9033 *aRemoved = true;
9034 return NS_OK;
9035 }
9036
9037 int64_t timestamp;
9038 nsCString group;
9039 nsCString origin;
9040 Nullable<bool> isApp;
9041 rv = GetDirectoryMetadata(aOriginProps.mDirectory, timestamp, group, origin,
9042 isApp);
9043 if (NS_FAILED(rv) || isApp.IsNull()) {
9044 aOriginProps.mNeedsRestore = true;
9045 }
9046
9047 nsCString suffix;
9048 rv = GetDirectoryMetadata2(aOriginProps.mDirectory, timestamp, suffix, group,
9049 origin, isApp.SetValue());
9050 if (NS_FAILED(rv)) {
9051 aOriginProps.mTimestamp =
9052 GetLastModifiedTime(aOriginProps.mDirectory, mPersistent);
9053 aOriginProps.mNeedsRestore2 = true;
9054 } else {
9055 aOriginProps.mTimestamp = timestamp;
9056 }
9057
9058 *aRemoved = false;
9059 return NS_OK;
9060 }
9061
9062 nsresult UpgradeStorageFrom1_0To2_0Helper::ProcessOriginDirectory(
9063 const OriginProps& aOriginProps) {
9064 AssertIsOnIOThread();
9065
9066 bool stripped;
9067 nsresult rv = MaybeStripObsoleteOriginAttributes(aOriginProps, &stripped);
9068 if (NS_WARN_IF(NS_FAILED(rv))) {
9069 return rv;
9070 }
9071 if (stripped) {
9072 return NS_OK;
9073 }
9074
9075 if (aOriginProps.mNeedsRestore) {
9076 rv = CreateDirectoryMetadata(aOriginProps.mDirectory,
9077 aOriginProps.mTimestamp, aOriginProps.mSuffix,
9078 aOriginProps.mGroup, aOriginProps.mOrigin);
9079 if (NS_WARN_IF(NS_FAILED(rv))) {
9080 return rv;
9081 }
9082 }
9083
9084 if (aOriginProps.mNeedsRestore2) {
9085 rv = CreateDirectoryMetadata2(aOriginProps.mDirectory,
9086 aOriginProps.mTimestamp,
9087 /* aPersisted */ false, aOriginProps.mSuffix,
9088 aOriginProps.mGroup, aOriginProps.mOrigin);
9089 if (NS_WARN_IF(NS_FAILED(rv))) {
9090 return rv;
9091 }
9092 }
9093
9094 return NS_OK;
9095 }
9096
9097 nsresult UpgradeStorageFrom2_0To2_1Helper::PrepareOriginDirectory(
9098 OriginProps& aOriginProps, bool* aRemoved) {
9099 AssertIsOnIOThread();
9100 MOZ_ASSERT(aOriginProps.mDirectory);
9101 MOZ_ASSERT(aRemoved);
9102
9103 nsresult rv =
9104 MaybeUpgradeClients(aOriginProps, &Client::UpgradeStorageFrom2_0To2_1);
9105 if (NS_WARN_IF(NS_FAILED(rv))) {
9106 return rv;
9107 }
9108
9109 int64_t timestamp;
9110 nsCString group;
9111 nsCString origin;
9112 Nullable<bool> isApp;
9113 rv = GetDirectoryMetadata(aOriginProps.mDirectory, timestamp, group, origin,
9114 isApp);
9115 if (NS_FAILED(rv) || isApp.IsNull()) {
9116 aOriginProps.mNeedsRestore = true;
9117 }
9118
9119 nsCString suffix;
9120 rv = GetDirectoryMetadata2(aOriginProps.mDirectory, timestamp, suffix, group,
9121 origin, isApp.SetValue());
9122 if (NS_FAILED(rv)) {
9123 aOriginProps.mTimestamp =
9124 GetLastModifiedTime(aOriginProps.mDirectory, mPersistent);
9125 aOriginProps.mNeedsRestore2 = true;
9126 } else {
9127 aOriginProps.mTimestamp = timestamp;
9128 }
9129
9130 *aRemoved = false;
9131 return NS_OK;
9132 }
9133
9134 nsresult UpgradeStorageFrom2_0To2_1Helper::ProcessOriginDirectory(
9135 const OriginProps& aOriginProps) {
9136 AssertIsOnIOThread();
9137
9138 nsresult rv;
9139
9140 if (aOriginProps.mNeedsRestore) {
9141 rv = CreateDirectoryMetadata(aOriginProps.mDirectory,
9142 aOriginProps.mTimestamp, aOriginProps.mSuffix,
9143 aOriginProps.mGroup, aOriginProps.mOrigin);
9144 if (NS_WARN_IF(NS_FAILED(rv))) {
9145 return rv;
9146 }
9147 }
9148
9149 if (aOriginProps.mNeedsRestore2) {
9150 rv = CreateDirectoryMetadata2(aOriginProps.mDirectory,
9151 aOriginProps.mTimestamp,
9152 /* aPersisted */ false, aOriginProps.mSuffix,
9153 aOriginProps.mGroup, aOriginProps.mOrigin);
9154 if (NS_WARN_IF(NS_FAILED(rv))) {
9155 return rv;
9156 }
9157 }
9158
9159 return NS_OK;
9160 }
9161
9162 nsresult RestoreDirectoryMetadata2Helper::RestoreMetadata2File() {
9163 AssertIsOnIOThread();
9164
9165 nsresult rv;
9166
9167 OriginProps originProps;
9168 rv = originProps.Init(mDirectory);
9169 if (NS_WARN_IF(NS_FAILED(rv))) {
9170 return rv;
9171 }
9172
9173 originProps.mTimestamp = GetLastModifiedTime(mDirectory, mPersistent);
9174
9175 mOriginProps.AppendElement(std::move(originProps));
9176
9177 rv = ProcessOriginDirectories();
9178 if (NS_WARN_IF(NS_FAILED(rv))) {
9179 return rv;
9180 }
9181
9182 return NS_OK;
9183 }
9184
9185 nsresult RestoreDirectoryMetadata2Helper::ProcessOriginDirectory(
9186 const OriginProps& aOriginProps) {
9187 AssertIsOnIOThread();
9188
9189 // We don't have any approach to restore aPersisted, so reset it to false.
9190 nsresult rv =
9191 CreateDirectoryMetadata2(aOriginProps.mDirectory, aOriginProps.mTimestamp,
9192 /* aPersisted */ false, aOriginProps.mSuffix,
9193 aOriginProps.mGroup, aOriginProps.mOrigin);
9194 if (NS_WARN_IF(NS_FAILED(rv))) {
9195 return rv;
9196 }
9197
9198 return NS_OK;
9199 }
9200
9201 } // namespace quota
9202 } // namespace dom
9203 } // namespace mozilla