1749504 - Asynchronous storage initialization

Status: RESOLVED FIXED

(Core :: Storage: Quota Manager, task, P2)

Description

[Jan Varga [:janv]]

EnsureStorageIsInitialized is a prerequisite for EnsureTemporaryStorageIsInitialized so we need to make it asynchronous first and callable from the PBackground thread (instead of QM's IO thread).

Comment 1

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Convert TestQuotaManager.cpp from a file containing generic quota tests to a file dedicated for QuotaManager testing only; r=#dom-storage

New tests need to be added for the QuotaManager class, but TestQuotaManager.cpp
currently contains tests which are not directly related to the QuotaManager. It
would be better to keep them in separate files.

Changes done in this patch:

• OriginScope related tests moved to a new file TestOriginScope.cpp
• WARN_IF_FILE_IS_UNKNOWN tests moved to TestQuotaCommon.cpp
• A simple test for QuotaManager::ShutdownStorage added to TestQuotaManager.cpp

Comment 2

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Add more tests for QuotaManager::ShutdownStorage; r=#dom-storage

QuotaManager::ShutdownStorage currently reuses existing shutdown storage
operation which causes unexpected behavior when a storage initialization is
scheduled between two ShutdownStorage calls. The storage should be shutdown
when the second shutdown storage operation is finished (but it's not currently).

Changes done in this patch:

• a new test added for two subsequent ShutdownStorage calls
• a new disabled test added for two ShutdownStorage calls with storage
  initialization scheduled in between

Depends on D185524

Comment 3

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Change QuotaManager::ShutdownStorage to always create a new shutdown storage operation; r=#dom-storage

QuotaManager::ShutdownStorage can't reuse existing shutdown storage operation
because that causes unexpected behavior when a storage initialization is
scheduled between two ShutdownStorage calls. The storage should be shutdown
when the second shutdown storage operation is finished.

Changes done in this patch:

• QuotaManager::ShurdownStorage changed to always create a new shutdown storage
  operation
• a flag indicating that a storage shutdown is in progress has been removed
• the corresponding test has been enabled

Depends on D185525

Comment 4

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Add QuotaManager::IsShuttingDown check to Quota::RecvClearStoragesForPrivateBrowsing; r=#dom-storage

The clearing operation used to use a sub actor, so the IsShuttingDown check was
done in Quota::AllocPQuotaRequestParent. Bug 1840772 stopped using a sub actor, but a corresponding IsShuttingDown check was not added to a new method for
handling the clearing operation.

Changes done in this patch:

• AssertIsOnOwningThread added to QuotaManager::ClearPrivateRepository
• IsShuttingDown check added to Quota::RecvClearStoragesForPrivateBrowsing

Depends on D185526

Comment 5

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Separate the reset functionality out of ResetOrClearOp; r=#dom-storage

The ResetOrClearOp currently supports both the resetting and clearing of
storage. However, there's already an operation for resetting storage called
ShutdownStorageOp which can be used separately.

Changes done in this patch:

• ResetOrClearOp renamed to ClearOp
• ClearOp converted to support only storage clearing
• QuotaManagerService::Reset reworked to use an asynchronous message instead of
  creating a sub actor
• added generic helpers/callbacks for handling returned MozPromises

Depends on D185527

Comment 6

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Add QuotaManager::ClearStorage method; r=#dom-storage

There's currently no QuotaManager method for triggering storage clearing which
could be used by the ClearOp or directly in gtests. Asynchronous storage
initialization will introduce a flag which needs to be unset after storage
clearing or storage resetting. This can't be easilly done without a
QuotaManager method for storage clearing.

Changes done in this patch:

• added QuotaManager::ClearStorage method
• renamed ClearOp to ClearStorageOp
• QuotaManagerService::Clear reworked to use an asynchronous message instead of
  creating a sub actor

Depends on D185545

Comment 7

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Rename EnsureStorageIsInitialized to EnsureStorageIsInitializedInternal; r=#dom-storage

One of the goals of bug 1749504 is to call EnsureStorageIsInitialized only from
InitOp. Calling from other places including quota clients will be disallowed
by changing the method to a private method. The private nature of the method
should be emphasized by adding the Internal suffix.

Changes done in this patch:

• IsStorageInitialized renamed to IsStorageInitializedInternal
• AssertStorageIsInitialized renamed to AssertStorageIsInitializedInternal
• EnsureStorageIsInitialized renamed to EnsureStorageIsInitializedInternal

Depends on D185546

Comment 8

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Simplify signature of QuotaManager::CreateDirectoryLock; r=#dom-storage

CreateDirectoryLock currently takes three separate arguments which can be
expressed as just one argument.

Changes done in this patch:

• QuotaManager::CreateDirectoryLock changed to take just client metadata
• all call sites updated to reflect the changed signature

Depends on D185547

Comment 9

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Add a way to asynchronously release directory locks when they are invalidated; r=#dom-storage

Directory locks which block clearing operations are currently invalidated and
Client::AbortOperations is called for corresponding quota clients. There's no
other way for directory lock owners to release directory locks other than in
Client::AbortOperations or when they are no longer needed. This is especially
problematic in tests.

Changes done in this patch:

• added DirectoryLock::OnInvalidate pure virtual method
• added DirectoryLockImpl::OnInvalidate implementation

Depends on D185568

Comment 10

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Add QuotaManager::InitializeStorage method; r=#dom-storage

There's currently EnsureStorageIsInitializedInternal which can be only called
on the QuotaManager IO thread. That method shouldn't be exposed to quota
clients and origin operations. There should be a public method callable from
the PBackground thread returning a MozPromise instead. Such method will
guarantee that proper directory locking is acquired before storage
initialization is started.

Changes done in this patch:

• added QuotaManager::InitializeStorage method
• added QuotaManager::IsStorageInitialized method
• QuotaManagerService::Init reworked to use an asynchronous message instead of
  creating a sub actor
• added QuotaManagerDependencyFixture::IsStorageInitialized
• added QuotaManagerDependencyFixture::AssertStorageIsInitialized
• added QuotaManagerDependencyFixture::AssertStorageIsNotInitialized
• eliminated QuotaManager::IsStorageInitializedInternal calls in tests
• eliminated QuotaManager::EnsureStorageIsInitializedInternal calls in tests
• added a bunch of tests for the new QuotaManager::InitializeStorage method

Depends on D185569

Comment 11

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Introduce a new method QuotaManager::OpenClientDirectory; r=#dom-storage

Quota clients currently call QuotaManager::CreateDirectoryLock and
DirectoryLock::Acquire to acquire a client directory lock. Once that's
successfully done, they bounce to the QuotaManager IO thread where they call
QuotaManager::EnsureStorageIsInitializedInternal.
The new QuotaManager::OpenClientDirectory method wraps all this complexity, so
quota clients can just obtain a client directory lock when all required storage
initialization is done.

Changes done in this patch:

• added QuotaManager::OpenClientDirectory
• updated documentation for the main entry point into the QuotaManager API

Depends on D185570

Comment 12

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Add a disabled test for QuotaManager::OpenClientDirectory flaw; r=#dom-storage

QuotaManager::OpenClientDirectory currently acquires a client directory lock
only after storage initialization is finished (including the release of
the directory lock for storage initialization). This doesn't work well when a
previous QuotaManager::OpenClientDirectory operation is still ongoing and
storage shutdown has been scheduled in the meantime. The storage should be
initialized when the second QuotaManager::OpenClientDirectory operation is
finished. The added test proves that storage is not initialized in that case.

Changes done in this patch

• added a new disabled test for the problematic scenario

Depends on D185572

Comment 13

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Change OriginOperationBase to use a MozPromise chain; r=#dom-storage

OriginOperationBase currently uses manual dispatching of runnables controlled
by a state machine which is not that easy to understand and requires many
helper methods. Additionally, OriginOperationBase can be destroyed off the
PBackground thread which makes it hard to hold PBackground only objects.

Changes done in this patch:

• changed OriginOperationBase to not inherit from Runnable
• changed OriginOperationBase to be created and destroyed on the PBackground thread only
• replaced the manual dispatching of runnables with a MozPromise chain
• removed OriginOperationBase::Dispatch
• changed pure virtual method OriginOperationBase::Open to return a MozPromise

Depends on D185589

Comment 14

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Add not null strong reference to QuotaManager from OriginOperatiosBase; r=#dom-storage

OriginOperationBase and the derived classes currently must get QuotaManager by
calling QuotaManager::Get() and usually asserting that the returned value is
not null. Now when OriginOperationBase is created and destroyed only on the
PBackground thread, a new not null strong reference to QuotaManager can be
added to OriginOperationBase which will eliminate the need for calling
QuotaManager::Get

Changes done in this patch:

• added not null strong reference to QuotaManager from OriginOperationBase
• adjusted constructors of derived classes
• adjusted factories for origin operations
• started using the new member in some places (instead of calling QuotaManager::Get)
• removed some now unnecessary QuotaManager::Get calls

Depends on D185641

Comment 15

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Change NormalOriginOperationBase::CreateDirectoryLock to be a pure virtual method; r=#dom-storage

Directory locks are currently created either by NormalOriginOperationBase
based on the parameters passed to its constructor or derived classes override
the CreateDirectoryLock method. Some operations will need to acquire multiple
locks in future and eventually do some other stuff before they can start doing
IO work, so it would be better to remove the default implementation of
CreateDirectoryLock in advance and let the derived classes to always implement
the method.

Changes done in this patch:

• copied the default implementation of CreateDirectoryLock to each origin
  operation
• changed NormalOriginOperationBase::CreateDirectoryLock to be a pure virtual
  method
• removed the default implementation of CreateDirectoryLock
• added some missing AssertIsOnOwningThread calls

Depends on D185645

Comment 16

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Remove NormalOriginOperationBase members related to directory locking; r=#dom-storage

Now when NormalOriginOperationBase lets the derived classes to create directory
locks, it is no longer needed to keep members related to directory locking in
the NormalOriginOperationBase class.

Changes done in this patch:

• optimized members of derived classes
• adjusted CreateDirectoryLock implementations
• removed members related to directory locking from NormalOriginOperationBase
• adjusted constructors of derived classes

Depends on D185646

Comment 17

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Add a disabled test for QuotaManager::ShutdownStorage; r=#dom-storage

QuotaManager::ShutdownStorage acquires an exclusive lock which causes that
existing client directory locks are invalidated. However, invalidated client
directory locks currently still block other directory locks until they are
released by owners. It would be better to unregister invalidated directory
locks immediatelly, so blocked operations may start sooner.

Changes done in this patch:

• added a new disabled test for the described scenario

Depends on D185647

Comment 18

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Unregister invalidated directory locks when they become unblocked; r=#dom-storage

Invalidated pending directory locks can be unregistered immediately when they
become unblocked. There's no need to wait for the last release because they
were never acquired.

Changes done in this patch:

• moved the unregistration into own Unregister method
• added the directory lock unregistration to NotifyOpenListener as well
• enabled the disabled test for ShutdownStorage

Depends on D185656

Comment 19

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Simplify NormalOriginOperationBase::Open implementation; r=#dom-storage

Now when invalidated directory locks are immediately released when they become
unblocked, the implementation of NormalOriginOperationBase::Open can be
simplified by assigning the created directory lock directly to mDirectoryLock.
mDirectoryLock was previously set only when the directory lock was successfully
acquired to not block other directory locks longer than it was necessary.

Changes done in this patch:

• simplified NormalOriginOperationBase::Open implementation

Depends on D185692

Comment 20

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Allow to do more complex directory opening in derived classes of NormalOriginOperationsBase; r=#dom-storage

Some operations will need to do more complex directory opening involving for
example acquiring multiple directory locks. For this reason it's no longer
desired to hold a directory lock in the NormalOriginOperationBase class.

Changed done in this patch:

• changed NormalOriginOperationsBase::CreateDirectoryLock too return a
  MozPromise
• renamed NormalOriginOperationsBase::CreatedDirectoryLock to OpenDirectory
• added a new pure virtual method NormalOriginOperationBase::CloseDirectory
• removed mDirectoryLock member from NormalOriginOperationBase
• adjusted derived classes of NormalOriginOperationsBase

Depends on D185693

Comment 21

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Fix a QuotaManager::OpenClientDirectory flaw; r=#dom-storage

Now when origin operations have been refactored to do directory locking on
their own, it's possibly to pass an already acquired directory lock to the
InitOp object. This is required to fix a flaw in the implementation of
QuotaManager::OpenClientDirectory. Basically a directory lock for the InitOp
and a client directory lock both need to be acquired at the same time to
maintain correct ordering of operations.

Changes done in this patch:

• added a new method QuotaManager::DirectoryLockedInitializeStorage
• changed InitOp to work with an already acquired directory lock
• enabled a disabled test for QuotaManager::OpenClientDirectory
• added more tests for QuotaManager::OpenClientDirectory

Depends on D186079

Comment 22

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Remove redundant storage initialization from TestFileSystemQuotaClient tests; r=#dom-storage

TestFileSystemQuotaClient tests currently call InitializeStorage before calling
CreateRegisteredDataManager. However, CreateRegisteredDataManager calls
FileSystemDataManager::GetOrCreateFileSystemDataManager which ensures storage
is initialized, so the prior InitializeStorage call can be removed.

Changes done in this patch:

• removed all calls to InitializeStorage
• removed InitializeStorage method

Depends on D186080

Comment 23

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Convert OPFS to use the new way to access a client directory; r=#dom-storage

OPFS currently creates a client directory lock first and then when the
client directorylock is acquired, it bounces to the QuotaManager I/O thread
where it ensures that storage is initialized. This can be now replaced by just
calling QuotaManager::OpenClientDirectory.

Changes done in this patch:

• replaced QuotaManager::CreateDirectoryLock call with
  QuotaManager::OpenClientDirectory
• removed EnsureStorageIsInitializedInternal call from
  EnsureFileSystemDirectory

Depends on D186113

Comment 24

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Make sure storage is initialized before clearing storage; r=#dom-storage

LoadArchivedOrigins (called from QuotaClient::AboutToClearOrigins) currently
ensures that storage is initialized which eventually creates the archive from
webappsstore.sqlite. Conceptually, storage should be always initialized before
QuotaClient::AboutToClearOrigins is called.

Changes done in this patch:

• removed QuotaManager::EnsureStorageIsInitializedInternal call from
  LoadArchivedOrigins
• added QuotaManger::EnsureStorageIsInitializedInternal call to
  ClearStorageOp::DoDirectoryWork

Depends on D186114

Comment 25

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Add a way to synchronously return a pending client directory lock from OpenClientDirectory; r=#dom-storage

QuotaManager::OpenClientDirectory currently only supports returning a fully
acquired client directory by resolved the returned promise. However, sometimes
it's needed to access pending directory locks for logging purposes before they
are acquired.

Changes done in this patch:

• added an optional pending directory lock callback to
  QuotaManager::OpenClientDirectory

Depends on D186115

Comment 26

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Convert LSNG to use the new way to access a client directory; r=#dom-storage

LSNG currently creates a client directory lock first and then when the
client directorylock is acquired, it bounces to the QuotaManager I/O thread
where it ensures that storage is initialized. This can be now replaced by just
calling QuotaManager::OpenClientDirectory.

Changes done in this patch:

• replaced QuotaManager::CreateDirectoryLock call with
  QuotaManager::OpenClientDirectory
• removed EnsureStorageIsInitializedInternal call from
  PrepareDatastoreOp::DatabaseWork

Depends on D186116

Comment 27

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Convert SimpleDB to use the new way to access a client directory; r=#dom-storage

SimpleDB currently creates a client directory lock first and then when the
client directorylock is acquired, it bounces to the QuotaManager I/O thread
where it ensures that storage is initialized. This can be now replaced by just
calling QuotaManager::OpenClientDirectory.

Changes done in this patch:

• replaced QuotaManager::CreateDirectoryLock call with
  QuotaManager::OpenClientDirectory
• removed EnsureStorageIsInitializedInternal call from OpenOp::DatabaseWork

Depends on D186117

Comment 28

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Convert Cache API to use the new way to access a client directory; r=#dom-storage

Cache API currently creates a client directory lock first and then when the
client directorylock is acquired, it bounces to the QuotaManager I/O thread
where it ensures that storage is initialized. This can be now replaced by just
calling QuotaManager::OpenClientDirectory.

Changes done in this patch:

• replaced QuotaManager::CreateDirectoryLock call with
  QuotaManager::OpenClientDirectory
• removed EnsureStorageIsInitializedInternal call from
  Context::QuotaInitRunnable::Run

Depends on D186118

Comment 29

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Convert IndexedDB to use the new way to access a client directory; r=#dom-storage

IndexedDB currently creates a client directory lock first and then when the
client directorylock is acquired, it bounces to the QuotaManager I/O thread
where it ensures that storage is initialized. This can be now replaced by just
calling QuotaManager::OpenClientDirectory. The database maintenance can't use
QuotaManager::OpenClientDirectory, a special method will have to be added to
QuotaManager for that.

Changes done in this patch:

• replaced QuotaManager::CreateDirectoryLock calls with
  QuotaManager::OpenClientDirectory calls
• removed EnsureStorageIsInitializedInternal call from
  OpenDatabaseOp::DoDatabaseWork

Depends on D186119

Comment 30

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Introduce a new method QuotaManager::OpenStorageDirectory; r=#dom-storage

Quota manager origin operations and IndexedDB database maintenance currently
call QuotaManager::CreateDirectoryLockInternal and DirectoryLock::Acquire to
acquire a universal directory lock. Once that's all successfully done, they
bounce to the QuotaManager IO thread where they synchronously call
QuotaManager::EnsureStorageIsInitializedInternal.
The new QuotaManager::OpenStorageDirectory method wraps all this complexity, so
consumers can just obtain a universal directory lock when all required storage
initialization is done.

Changes done in this patch:

• added QuotaManager::OpenStorageDirectory
• added tests for the new method

Depends on D186120

Comment 31

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Convert IndexedDB to use the new way to access the storage directory; r=#dom-storage

IndexedDB currently creates a universal directory lock first and then when the
universal directorylock is acquired, it bounces to the QuotaManager I/O thread
where it ensures that storage is initialized. This can be now replaced by just
calling QuotaManager::OpenStorageDirectory.
The elimination of QuotaManager::EnsureStorageIsInitializedInternal calls in
IndexedDB is now complete.

Changes done in this patch:

• replaced QuotaManager::CreateDirectoryLockInternal call with
  QuotaManager::OpenStorageDirectory
• removed QuotaManager::EnsureStorageIsInitializedInternal call from
  Maintenance::DirectoryWork

Depends on D186134

Comment 32

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Add directory locking to origin operations which require storage initialization; r=#dom-storage

Some origin operations are currently not protected by directory locks because
they use cached data for generating responses. However these origin operations
ensure that storage is initializated on QuotaManager IO thread prior using the
cache data, so they should have directory directory locks as well.

Changed done in this patch:

• added directory locks to origin operations which require storage
  initialization
• changed corresponding OpenDirectory implementations
• added corresponding CloseDirectory implementations

Depends on D186135

Comment 33

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Convert origin operations which require storage initialization to use the new way to access the storage directory; r=#dom-storage

Origin operations which require storage initialization currently create a
universal directory lock first and then when the universal directorylock is
acquired, they bounce to the QuotaManager I/O thread where they ensure that
storage is initialized. This can be now replaced by just calling
QuotaManager::OpenStorageDirectory.

Changes done in this patch:

• replaced QuotaManager::CreateDirectoryLockInternal call with
  QuotaManager::OpenStorageDirectory in corresponding OpenDirectory
  implementations
• removed QuotaManager::EnsureStorageIsInitializedInternal call from
  corresponding DoDirectoryWork implementations

Depends on D186205

Comment 34

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Convert TestFileOutputStream to use the new way to access a client directory; r=#dom-storage

TestFileOutputStream currently doesn't create any client directory lock and
just directly bounces to the QuotaManager I/O thread where it ensures that
storage is initialized. This should be now replaced by calling
QuotaManager::OpenClientDirectory on the PBackground thread.

Changes done in this patch:

• added a PBackground task which is executed first
• added QuotaManager::OpenClientDirectory call on the PBackground thread
• removed QuotaManager::EnsureStorageIsInitializedInternal call on the IO
  thread

Depends on D186206

Comment 35

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Change QuotaManager::EnsureStorageIsInitializedInternal to be a private method; r=#dom-storage

The goal to call QuotaManager::EnsureStorageIsInitializedInternal only from
InitOp has been achieved. It's now easy to change the method to be a private
method.

Changes done in this patch

• moved InitOp to the mozilla::dom::quota namespace
• added InitOp as a friend to QuotaManager
• changed QuotaManager::EnsureStorageIsInitializedInternal to be a private
  method

Depends on D186207

Comment 36

[Jan Varga [:janv]]

https://treeherder.mozilla.org/jobs?repo=try&revision=427e380f0b33449049b1d8420e0db0afe1a31280

Comment 37

[Jan Varga [:janv]]

Attachment: Bug 1749504 - Make sure storage is initialized before saving origin access time; r=#dom-storage

SaveOriginAccessTimeOp::DoDirectoryWork currently doesn't call
QuotaManager::EnsureStorageIsInitializedInternal and just expects that
something else initialized storage previously. This seems to work, but it would
be cleaner to always make sure that storage is initialized. However, adding
QuotaManager::EnsureStorageIsInitializedInternal revealed another problem.
Storage shudown or storage clearing acquires an exlusive lock over entire
storage area which essentially forces that all existing directory locks are
released first. When the last directory lock for an origin is released, saving
of origin access time is scheduled. The problem is that it's scheduled after
the exclusive lock for storage shutdown or storage clearing, so storage would
be initialized again in the end or access time wouldn't be saved at all due
to quota manager shutdown being already in progress.

Changes done in this patch:

• added QuotaManager::EnsureStorageIsInitializedInternal call to
  SaveOriginAccessTimeOp::DoDirectoryWork
• changed QuotaManager::UnregisterDirectoryLock to work with already cleared
  directory lock tables
• added a new QuotaManager::ClearDirectoryLockTables method
• added QuotaManager::ClearDirectoryLockTables call to
  ShutdownStorageOp::OpenDirectory and ClearStorageOp::OpenDirectory
• made ClearStorageOp and ShutdownStorageOp friend classes of QuotaManager

Comment 38

[Jan Varga [:janv]]

https://treeherder.mozilla.org/jobs?repo=try&revision=21e1c161b05d1f672219279031183f69efbd4b8f

Comment 39

[Pulsebot]

Pushed by [e-mail]:
https://hg.mozilla.org/integration/autoland/rev/3d179c2f922d
Convert TestQuotaManager.cpp from a file containing generic quota tests to a file dedicated for QuotaManager testing only; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/cffe955cb490
Add more tests for QuotaManager::ShutdownStorage; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/fdd2a8439ae3
Change QuotaManager::ShutdownStorage to always create a new shutdown storage operation; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/b9b7f97dfc95
Add QuotaManager::IsShuttingDown check to Quota::RecvClearStoragesForPrivateBrowsing; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/aa4884f2ab9e
Separate the reset functionality out of ResetOrClearOp; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/5c9316959da0
Add QuotaManager::ClearStorage method; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/f047a5fd0be7
Rename EnsureStorageIsInitialized to EnsureStorageIsInitializedInternal; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/9b0afbba8134
Simplify signature of QuotaManager::CreateDirectoryLock; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/b7a6a77a0407
Add a way to asynchronously release directory locks when they are invalidated; r=dom-storage-reviewers,jstutte

Comment 40

[Narcis Beleuzu [:NarcisB]]

https://hg.mozilla.org/mozilla-central/rev/3d179c2f922d
https://hg.mozilla.org/mozilla-central/rev/cffe955cb490
https://hg.mozilla.org/mozilla-central/rev/fdd2a8439ae3
https://hg.mozilla.org/mozilla-central/rev/b9b7f97dfc95
https://hg.mozilla.org/mozilla-central/rev/aa4884f2ab9e
https://hg.mozilla.org/mozilla-central/rev/5c9316959da0
https://hg.mozilla.org/mozilla-central/rev/f047a5fd0be7
https://hg.mozilla.org/mozilla-central/rev/9b0afbba8134
https://hg.mozilla.org/mozilla-central/rev/b7a6a77a0407

Comment 41

[Jan Varga [:janv]]

https://treeherder.mozilla.org/jobs?repo=try&revision=0b837c5a3afff4893bb19f4e7b4fd0612bd1a213

Comment 42

[Pulsebot]

Pushed by [e-mail]:
https://hg.mozilla.org/integration/autoland/rev/fa9fd089117f
Add QuotaManager::InitializeStorage method; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/0ad071947f0b
Introduce a new method QuotaManager::OpenClientDirectory; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/469d430f1fa3
Add a disabled test for QuotaManager::OpenClientDirectory flaw; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/073ce3fabb82
Change OriginOperationBase to use a MozPromise chain; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/e0af232b391c
Add not null strong reference to QuotaManager from OriginOperatiosBase; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/79992ef6b704
Change NormalOriginOperationBase::CreateDirectoryLock to be a pure virtual method; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/193d99369dcc
Remove NormalOriginOperationBase members related to directory locking; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/173ce4941d5a
Add a disabled test for QuotaManager::ShutdownStorage; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/fe13f4fe366a
Unregister invalidated directory locks when they become unblocked; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/3666077ce589
Simplify NormalOriginOperationBase::Open implementation; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/689707828590
Allow to do more complex directory opening in derived classes of NormalOriginOperationsBase; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/322abcf9e913
Fix a QuotaManager::OpenClientDirectory flaw; r=dom-storage-reviewers,jstutte

Comment 43

[Jan Varga [:janv]]

https://treeherder.mozilla.org/jobs?repo=try&revision=c4b9f89ab5a81769842ebfdd98f68cf58601539a

Comment 44

[Pulsebot]

Pushed by [e-mail]:
https://hg.mozilla.org/integration/autoland/rev/fe8dbf616afc
Remove redundant storage initialization from TestFileSystemQuotaClient tests; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/153bf1967b81
Convert OPFS to use the new way to access a client directory; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/1f74e04f0138
Make sure storage is initialized before clearing storage; r=dom-storage-reviewers,jstutte

Comment 45

[Cosmin Sabou [:CosminS]]

https://hg.mozilla.org/mozilla-central/rev/fa9fd089117f
https://hg.mozilla.org/mozilla-central/rev/0ad071947f0b
https://hg.mozilla.org/mozilla-central/rev/469d430f1fa3
https://hg.mozilla.org/mozilla-central/rev/073ce3fabb82
https://hg.mozilla.org/mozilla-central/rev/e0af232b391c
https://hg.mozilla.org/mozilla-central/rev/79992ef6b704
https://hg.mozilla.org/mozilla-central/rev/193d99369dcc
https://hg.mozilla.org/mozilla-central/rev/173ce4941d5a
https://hg.mozilla.org/mozilla-central/rev/fe13f4fe366a
https://hg.mozilla.org/mozilla-central/rev/3666077ce589
https://hg.mozilla.org/mozilla-central/rev/689707828590
https://hg.mozilla.org/mozilla-central/rev/322abcf9e913

Comment 46

[Jan Varga [:janv]]

OPFS is now using the new way to access client directories, next one is LSNG which is currently being tested on try:
https://treeherder.mozilla.org/jobs?repo=try&revision=c07de5f0e5da6db3e1aa7e2e9c184f3c3fd6c71c

Comment 47

[Narcis Beleuzu [:NarcisB]]

https://hg.mozilla.org/mozilla-central/rev/fe8dbf616afc
https://hg.mozilla.org/mozilla-central/rev/153bf1967b81
https://hg.mozilla.org/mozilla-central/rev/1f74e04f0138

Comment 48

[Pulsebot]

Pushed by [e-mail]:
https://hg.mozilla.org/integration/autoland/rev/3391d02a28be
Add a way to synchronously return a pending client directory lock from OpenClientDirectory; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/c4b060098d06
Convert LSNG to use the new way to access a client directory; r=dom-storage-reviewers,jstutte

Comment 49

[Iulian Moraru]

https://hg.mozilla.org/mozilla-central/rev/3391d02a28be
https://hg.mozilla.org/mozilla-central/rev/c4b060098d06

Comment 50

[Jan Varga [:janv]]

https://treeherder.mozilla.org/jobs?repo=try&revision=7cdfe0a33275aa5500a59010eadd71e15caf2e0f

Comment 51

[Pulsebot]

Pushed by [e-mail]:
https://hg.mozilla.org/integration/autoland/rev/1e15a3b642f0
Convert SimpleDB to use the new way to access a client directory; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/745d8130d1ac
Convert Cache API to use the new way to access a client directory; r=dom-storage-reviewers,jstutte

Comment 52

[Narcis Beleuzu [:NarcisB]]

https://hg.mozilla.org/mozilla-central/rev/1e15a3b642f0
https://hg.mozilla.org/mozilla-central/rev/745d8130d1ac

Comment 53

[Jan Varga [:janv]]

https://treeherder.mozilla.org/jobs?repo=try&revision=8f78408954c7a51a43e3bba0051babf7b82f8a0d

Comment 54

[Pulsebot]

Pushed by [e-mail]:
https://hg.mozilla.org/integration/autoland/rev/504a86a4ec21
Convert IndexedDB to use the new way to access a client directory; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/14c85c87dd88
Introduce a new method QuotaManager::OpenStorageDirectory; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/d1558269e35b
Convert IndexedDB to use the new way to access the storage directory; r=dom-storage-reviewers,jstutte

Comment 55

[Noemi Erli[:noemi_erli]]

https://hg.mozilla.org/mozilla-central/rev/504a86a4ec21
https://hg.mozilla.org/mozilla-central/rev/14c85c87dd88
https://hg.mozilla.org/mozilla-central/rev/d1558269e35b

Comment 56

[Jan Varga [:janv]]

https://treeherder.mozilla.org/jobs?repo=try&revision=6ffff407d774a4dac7e935b83ee5904dc99aa5b7

Comment 57

[Pulsebot]

Pushed by [e-mail]:
https://hg.mozilla.org/integration/autoland/rev/d395f485b3a2
Add directory locking to origin operations which require storage initialization; r=dom-storage-reviewers,jstutte

Comment 58

[Iulian Moraru]

https://hg.mozilla.org/mozilla-central/rev/d395f485b3a2

Comment 59

[Jan Varga [:janv]]

https://treeherder.mozilla.org/jobs?repo=try&revision=1c5802fa635c7fef4ffdb7725aa1246afdbbc54a

Comment 60

[Jan Varga [:janv]]

https://treeherder.mozilla.org/jobs?repo=try&revision=1d0ad4ae744d6c4a296a108225adcb95a5253017

Comment 61

[Jan Varga [:janv]]

https://treeherder.mozilla.org/jobs?repo=try&revision=712df4051ca27e74e6117735cfbbf1ec4e1fc08a

Comment 62

[Pulsebot]

Pushed by [e-mail]:
https://hg.mozilla.org/integration/autoland/rev/8f5c717905b3
Make sure storage is initialized before saving origin access time; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/cd8e7260a31c
Convert origin operations which require storage initialization to use the new way to access the storage directory; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/7f067bde5ac6
Convert TestFileOutputStream to use the new way to access a client directory; r=dom-storage-reviewers,jstutte
https://hg.mozilla.org/integration/autoland/rev/e11a98968ec1
Change QuotaManager::EnsureStorageIsInitializedInternal to be a private method; r=dom-storage-reviewers,jstutte

Comment 63

[Iulian Moraru]

https://hg.mozilla.org/mozilla-central/rev/8f5c717905b3
https://hg.mozilla.org/mozilla-central/rev/cd8e7260a31c
https://hg.mozilla.org/mozilla-central/rev/7f067bde5ac6
https://hg.mozilla.org/mozilla-central/rev/e11a98968ec1