Diff
Modified: trunk/Source/WebCore/ChangeLog (284899 => 284900)
--- trunk/Source/WebCore/ChangeLog 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/ChangeLog 2021-10-26 21:42:08 UTC (rev 284900)
@@ -1,3 +1,56 @@
+2021-10-26 Sihui Liu <[email protected]>
+
+ FileSystemHandle should be ContextDestructionObserver
+ https://bugs.webkit.org/show_bug.cgi?id=231250
+ <rdar://problem/84164797>
+
+ Reviewed by Youenn Fablet.
+
+ Make FileSystemHandle and FileSystemSyncAccessHandle ActiveDOMObject to close them when context stops.
+
+ * Modules/filesystemaccess/FileSystemDirectoryHandle.cpp:
+ (WebCore::FileSystemDirectoryHandle::create):
+ (WebCore::FileSystemDirectoryHandle::FileSystemDirectoryHandle):
+ (WebCore::FileSystemDirectoryHandle::getFileHandle):
+ (WebCore::FileSystemDirectoryHandle::getDirectoryHandle):
+ (WebCore::FileSystemDirectoryHandle::removeEntry):
+ (WebCore::FileSystemDirectoryHandle::resolve):
+ (WebCore::FileSystemDirectoryHandle::getHandleNames):
+ (WebCore::FileSystemDirectoryHandle::getHandle):
+ * Modules/filesystemaccess/FileSystemDirectoryHandle.h:
+ * Modules/filesystemaccess/FileSystemFileHandle.cpp:
+ (WebCore::FileSystemFileHandle::create):
+ (WebCore::FileSystemFileHandle::FileSystemFileHandle):
+ (WebCore::FileSystemFileHandle::createSyncAccessHandle):
+ (WebCore::FileSystemFileHandle::getSize):
+ (WebCore::FileSystemFileHandle::truncate):
+ (WebCore::FileSystemFileHandle::flush):
+ (WebCore::FileSystemFileHandle::close):
+ * Modules/filesystemaccess/FileSystemFileHandle.h:
+ * Modules/filesystemaccess/FileSystemHandle.cpp:
+ (WebCore::FileSystemHandle::FileSystemHandle):
+ (WebCore::FileSystemHandle::isSameEntry const):
+ (WebCore::FileSystemHandle::move):
+ (WebCore::FileSystemHandle::activeDOMObjectName const):
+ (WebCore::FileSystemHandle::stop):
+ * Modules/filesystemaccess/FileSystemHandle.h:
+ (WebCore::FileSystemHandle::isClosed const):
+ * Modules/filesystemaccess/FileSystemHandle.idl:
+ * Modules/filesystemaccess/FileSystemSyncAccessHandle.cpp:
+ (WebCore::FileSystemSyncAccessHandle::create):
+ (WebCore::FileSystemSyncAccessHandle::FileSystemSyncAccessHandle):
+ (WebCore::FileSystemSyncAccessHandle::~FileSystemSyncAccessHandle):
+ (WebCore::FileSystemSyncAccessHandle::isClosingOrClosed const):
+ (WebCore::FileSystemSyncAccessHandle::close):
+ (WebCore::FileSystemSyncAccessHandle::closeInternal):
+ (WebCore::FileSystemSyncAccessHandle::didClose):
+ (WebCore::FileSystemSyncAccessHandle::activeDOMObjectName const):
+ (WebCore::FileSystemSyncAccessHandle::stop):
+ * Modules/filesystemaccess/FileSystemSyncAccessHandle.h:
+ * Modules/filesystemaccess/FileSystemSyncAccessHandle.idl:
+ * Modules/storage/StorageManager.cpp:
+ (WebCore::StorageManager::fileSystemAccessGetDirectory):
+
2021-10-26 Chris Dumez <[email protected]>
error event should be fired at <style> element when @import rule fails parsing due to MIME type
Modified: trunk/Source/WebCore/Modules/filesystemaccess/FileSystemDirectoryHandle.cpp (284899 => 284900)
--- trunk/Source/WebCore/Modules/filesystemaccess/FileSystemDirectoryHandle.cpp 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/filesystemaccess/FileSystemDirectoryHandle.cpp 2021-10-26 21:42:08 UTC (rev 284900)
@@ -36,40 +36,51 @@
WTF_MAKE_ISO_ALLOCATED_IMPL(FileSystemDirectoryHandle);
-Ref<FileSystemDirectoryHandle> FileSystemDirectoryHandle::create(String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
+Ref<FileSystemDirectoryHandle> FileSystemDirectoryHandle::create(ScriptExecutionContext* context, String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
{
- return adoptRef(*new FileSystemDirectoryHandle(WTFMove(name), identifier, WTFMove(connection)));
+ return adoptRef(*new FileSystemDirectoryHandle(context, WTFMove(name), identifier, WTFMove(connection)));
}
-FileSystemDirectoryHandle::FileSystemDirectoryHandle(String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
- : FileSystemHandle(FileSystemHandle::Kind::Directory, WTFMove(name), identifier, WTFMove(connection))
+FileSystemDirectoryHandle::FileSystemDirectoryHandle(ScriptExecutionContext* context, String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
+ : FileSystemHandle(context, FileSystemHandle::Kind::Directory, WTFMove(name), identifier, WTFMove(connection))
{
}
void FileSystemDirectoryHandle::getFileHandle(const String& name, std::optional<FileSystemDirectoryHandle::GetFileOptions> options, DOMPromiseDeferred<IDLInterface<FileSystemFileHandle>>&& promise)
{
+ if (isClosed())
+ return promise.reject(Exception { InvalidStateError, "Handle is closed"_s });
+
bool createIfNecessary = options ? options->create : false;
- connection().getFileHandle(identifier(), name, createIfNecessary, [connection = Ref { connection() }, name, promise = WTFMove(promise)](auto result) mutable {
+ connection().getFileHandle(identifier(), name, createIfNecessary, [weakThis = WeakPtr { *this }, connection = Ref { connection() }, name, promise = WTFMove(promise)](auto result) mutable {
if (result.hasException())
return promise.reject(result.releaseException());
- promise.settle(FileSystemFileHandle::create(String { name }, result.returnValue(), WTFMove(connection)));
+ auto* context = weakThis ? weakThis->scriptExecutionContext() : nullptr;
+ promise.settle(FileSystemFileHandle::create(context, String { name }, result.returnValue(), WTFMove(connection)));
});
}
void FileSystemDirectoryHandle::getDirectoryHandle(const String& name, std::optional<FileSystemDirectoryHandle::GetDirectoryOptions> options, DOMPromiseDeferred<IDLInterface<FileSystemDirectoryHandle>>&& promise)
{
+ if (isClosed())
+ return promise.reject(Exception { InvalidStateError, "Handle is closed"_s });
+
bool createIfNecessary = options ? options->create : false;
- connection().getDirectoryHandle(identifier(), name, createIfNecessary, [connection = Ref { connection() }, name, promise = WTFMove(promise)](auto result) mutable {
+ connection().getDirectoryHandle(identifier(), name, createIfNecessary, [weakThis = WeakPtr { *this }, connection = Ref { connection() }, name, promise = WTFMove(promise)](auto result) mutable {
if (result.hasException())
return promise.reject(result.releaseException());
- promise.settle(FileSystemDirectoryHandle::create(String { name }, result.returnValue(), WTFMove(connection)));
+ auto* context = weakThis ? weakThis->scriptExecutionContext() : nullptr;
+ promise.settle(FileSystemDirectoryHandle::create(context, String { name }, result.returnValue(), WTFMove(connection)));
});
}
void FileSystemDirectoryHandle::removeEntry(const String& name, std::optional<FileSystemDirectoryHandle::RemoveOptions> options, DOMPromiseDeferred<void>&& promise)
{
+ if (isClosed())
+ return promise.reject(Exception { InvalidStateError, "Handle is closed"_s });
+
bool deleteRecursively = options ? options->recursive : false;
connection().removeEntry(identifier(), name, deleteRecursively, [promise = WTFMove(promise)](auto result) mutable {
promise.settle(WTFMove(result));
@@ -78,6 +89,9 @@
void FileSystemDirectoryHandle::resolve(const FileSystemHandle& handle, DOMPromiseDeferred<IDLSequence<IDLUSVString>>&& promise)
{
+ if (isClosed())
+ return promise.reject(Exception { InvalidStateError, "Handle is closed"_s });
+
connection().resolve(identifier(), handle.identifier(), [promise = WTFMove(promise)](auto result) mutable {
if (result.hasException())
return promise.reject(result.releaseException());
@@ -88,22 +102,29 @@
void FileSystemDirectoryHandle::getHandleNames(CompletionHandler<void(ExceptionOr<Vector<String>>&&)>&& completionHandler)
{
+ if (isClosed())
+ return completionHandler(Exception { InvalidStateError, "Handle is closed"_s });
+
connection().getHandleNames(identifier(), WTFMove(completionHandler));
}
void FileSystemDirectoryHandle::getHandle(const String& name, CompletionHandler<void(ExceptionOr<Ref<FileSystemHandle>>&&)>&& completionHandler)
{
- connection().getHandle(identifier(), name, [name, connection = Ref { connection() }, completionHandler = WTFMove(completionHandler)](auto result) mutable {
+ if (isClosed())
+ return completionHandler(Exception { InvalidStateError, "Handle is closed"_s });
+
+ connection().getHandle(identifier(), name, [weakThis = WeakPtr { *this }, name, connection = Ref { connection() }, completionHandler = WTFMove(completionHandler)](auto result) mutable {
if (result.hasException())
return completionHandler(result.releaseException());
auto [identifier, isDirectory] = result.releaseReturnValue();
+ auto* context = weakThis ? weakThis->scriptExecutionContext() : nullptr;
if (isDirectory) {
- Ref<FileSystemHandle> handle = FileSystemDirectoryHandle::create(String { name }, identifier, WTFMove(connection));
+ Ref<FileSystemHandle> handle = FileSystemDirectoryHandle::create(context, String { name }, identifier, WTFMove(connection));
return completionHandler(WTFMove(handle));
}
- Ref<FileSystemHandle> handle = FileSystemFileHandle::create(String { name }, identifier, WTFMove(connection));
+ Ref<FileSystemHandle> handle = FileSystemFileHandle::create(context, String { name }, identifier, WTFMove(connection));
completionHandler(WTFMove(handle));
});
}
Modified: trunk/Source/WebCore/Modules/filesystemaccess/FileSystemDirectoryHandle.h (284899 => 284900)
--- trunk/Source/WebCore/Modules/filesystemaccess/FileSystemDirectoryHandle.h 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/filesystemaccess/FileSystemDirectoryHandle.h 2021-10-26 21:42:08 UTC (rev 284900)
@@ -47,7 +47,7 @@
bool recursive { false };
};
- WEBCORE_EXPORT static Ref<FileSystemDirectoryHandle> create(String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
+ WEBCORE_EXPORT static Ref<FileSystemDirectoryHandle> create(ScriptExecutionContext*, String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
void getFileHandle(const String& name, std::optional<GetFileOptions>, DOMPromiseDeferred<IDLInterface<FileSystemFileHandle>>&&);
void getDirectoryHandle(const String& name, std::optional<GetDirectoryOptions>, DOMPromiseDeferred<IDLInterface<FileSystemDirectoryHandle>>&&);
void removeEntry(const String& name, std::optional<RemoveOptions>, DOMPromiseDeferred<void>&&);
@@ -77,7 +77,7 @@
Ref<Iterator> createIterator();
private:
- FileSystemDirectoryHandle(String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
+ FileSystemDirectoryHandle(ScriptExecutionContext*, String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
};
} // namespace WebCore
Modified: trunk/Source/WebCore/Modules/filesystemaccess/FileSystemFileHandle.cpp (284899 => 284900)
--- trunk/Source/WebCore/Modules/filesystemaccess/FileSystemFileHandle.cpp 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/filesystemaccess/FileSystemFileHandle.cpp 2021-10-26 21:42:08 UTC (rev 284900)
@@ -36,13 +36,13 @@
WTF_MAKE_ISO_ALLOCATED_IMPL(FileSystemFileHandle);
-Ref<FileSystemFileHandle> FileSystemFileHandle::create(String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
+Ref<FileSystemFileHandle> FileSystemFileHandle::create(ScriptExecutionContext* context, String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
{
- return adoptRef(*new FileSystemFileHandle(WTFMove(name), identifier, WTFMove(connection)));
+ return adoptRef(*new FileSystemFileHandle(context, WTFMove(name), identifier, WTFMove(connection)));
}
-FileSystemFileHandle::FileSystemFileHandle(String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
- : FileSystemHandle(FileSystemHandle::Kind::File, WTFMove(name), identifier, WTFMove(connection))
+FileSystemFileHandle::FileSystemFileHandle(ScriptExecutionContext* context, String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
+ : FileSystemHandle(context, FileSystemHandle::Kind::File, WTFMove(name), identifier, WTFMove(connection))
{
}
@@ -53,6 +53,9 @@
void FileSystemFileHandle::createSyncAccessHandle(DOMPromiseDeferred<IDLInterface<FileSystemSyncAccessHandle>>&& promise)
{
+ if (isClosed())
+ return promise.reject(Exception { InvalidStateError, "Handle is closed" });
+
connection().createSyncAccessHandle(identifier(), [protectedThis = Ref { *this }, promise = WTFMove(promise)](auto result) mutable {
if (result.hasException())
return promise.reject(result.releaseException());
@@ -61,27 +64,39 @@
if (resultValue.second == FileSystem::invalidPlatformFileHandle)
return promise.reject(Exception { UnknownError, "Invalid platform file handle"_s });
- promise.settle(FileSystemSyncAccessHandle::create(protectedThis.get(), resultValue.first, resultValue.second));
+ promise.settle(FileSystemSyncAccessHandle::create(protectedThis->scriptExecutionContext(), protectedThis.get(), resultValue.first, resultValue.second));
});
}
void FileSystemFileHandle::getSize(FileSystemSyncAccessHandleIdentifier accessHandleIdentifier, CompletionHandler<void(ExceptionOr<uint64_t>&&)>&& completionHandler)
{
+ if (isClosed())
+ return completionHandler(Exception { InvalidStateError, "Handle is closed"_s });
+
connection().getSize(identifier(), accessHandleIdentifier, WTFMove(completionHandler));
}
void FileSystemFileHandle::truncate(FileSystemSyncAccessHandleIdentifier accessHandleIdentifier, unsigned long long size, CompletionHandler<void(ExceptionOr<void>&&)>&& completionHandler)
{
+ if (isClosed())
+ return completionHandler(Exception { InvalidStateError, "Handle is closed"_s });
+
connection().truncate(identifier(), accessHandleIdentifier, size, WTFMove(completionHandler));
}
void FileSystemFileHandle::flush(FileSystemSyncAccessHandleIdentifier accessHandleIdentifier, CompletionHandler<void(ExceptionOr<void>&&)>&& completionHandler)
{
+ if (isClosed())
+ return completionHandler(Exception { InvalidStateError, "Handle is closed"_s });
+
connection().flush(identifier(), accessHandleIdentifier, WTFMove(completionHandler));
}
void FileSystemFileHandle::close(FileSystemSyncAccessHandleIdentifier accessHandleIdentifier, CompletionHandler<void(ExceptionOr<void>&&)>&& completionHandler)
{
+ if (isClosed())
+ return completionHandler(Exception { InvalidStateError, "Handle is closed"_s });
+
connection().close(identifier(), accessHandleIdentifier, WTFMove(completionHandler));
}
Modified: trunk/Source/WebCore/Modules/filesystemaccess/FileSystemFileHandle.h (284899 => 284900)
--- trunk/Source/WebCore/Modules/filesystemaccess/FileSystemFileHandle.h 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/filesystemaccess/FileSystemFileHandle.h 2021-10-26 21:42:08 UTC (rev 284900)
@@ -37,7 +37,7 @@
class FileSystemFileHandle final : public FileSystemHandle {
WTF_MAKE_ISO_ALLOCATED(FileSystemFileHandle);
public:
- WEBCORE_EXPORT static Ref<FileSystemFileHandle> create(String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
+ WEBCORE_EXPORT static Ref<FileSystemFileHandle> create(ScriptExecutionContext*, String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
void getFile(DOMPromiseDeferred<IDLInterface<File>>&&);
void createSyncAccessHandle(DOMPromiseDeferred<IDLInterface<FileSystemSyncAccessHandle>>&&);
@@ -47,7 +47,7 @@
void close(FileSystemSyncAccessHandleIdentifier, CompletionHandler<void(ExceptionOr<void>&&)>&&);
private:
- FileSystemFileHandle(String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
+ FileSystemFileHandle(ScriptExecutionContext*, String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
};
} // namespace WebCore
Modified: trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.cpp (284899 => 284900)
--- trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.cpp 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.cpp 2021-10-26 21:42:08 UTC (rev 284900)
@@ -34,12 +34,14 @@
WTF_MAKE_ISO_ALLOCATED_IMPL(FileSystemHandle);
-FileSystemHandle::FileSystemHandle(FileSystemHandle::Kind kind, String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
- : m_kind(kind)
+FileSystemHandle::FileSystemHandle(ScriptExecutionContext* context, FileSystemHandle::Kind kind, String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
+ : ActiveDOMObject(context)
+ , m_kind(kind)
, m_name(WTFMove(name))
, m_identifier(identifier)
, m_connection(WTFMove(connection))
{
+ suspendIfNeeded();
}
FileSystemHandle::~FileSystemHandle() = default;
@@ -46,6 +48,9 @@
void FileSystemHandle::isSameEntry(FileSystemHandle& handle, DOMPromiseDeferred<IDLBoolean>&& promise) const
{
+ if (isClosed())
+ return promise.reject(Exception { InvalidStateError, "Handle is closed" });
+
if (m_kind != handle.kind() || m_name != handle.name())
return promise.resolve(false);
@@ -56,6 +61,9 @@
void FileSystemHandle::move(FileSystemHandle& destinationHandle, const String& newName, DOMPromiseDeferred<void>&& promise)
{
+ if (isClosed())
+ return promise.reject(Exception { InvalidStateError, "Handle is closed" });
+
if (destinationHandle.kind() != Kind::Directory)
return promise.reject(Exception { TypeMismatchError });
@@ -67,4 +75,14 @@
});
}
+const char* FileSystemHandle::activeDOMObjectName() const
+{
+ return "FileSystemHandle";
+}
+
+void FileSystemHandle::stop()
+{
+ m_isClosed = true;
+}
+
} // namespace WebCore
Modified: trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.h (284899 => 284900)
--- trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.h 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.h 2021-10-26 21:42:08 UTC (rev 284900)
@@ -25,6 +25,7 @@
#pragma once
+#include "ActiveDOMObject.h"
#include "FileSystemHandleIdentifier.h"
#include "IDLTypes.h"
#include <wtf/IsoMalloc.h>
@@ -35,7 +36,7 @@
class FileSystemStorageConnection;
-class FileSystemHandle : public RefCounted<FileSystemHandle> {
+class FileSystemHandle : public ActiveDOMObject, public CanMakeWeakPtr<FileSystemHandle>, public RefCounted<FileSystemHandle> {
WTF_MAKE_ISO_ALLOCATED(FileSystemHandle);
public:
virtual ~FileSystemHandle();
@@ -47,19 +48,25 @@
Kind kind() const { return m_kind; }
const String& name() const { return m_name; }
FileSystemHandleIdentifier identifier() const { return m_identifier; }
+ bool isClosed() const { return m_isClosed; }
void isSameEntry(FileSystemHandle&, DOMPromiseDeferred<IDLBoolean>&&) const;
void move(FileSystemHandle&, const String& newName, DOMPromiseDeferred<void>&&);
protected:
- FileSystemHandle(Kind, String&& name, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
+ FileSystemHandle(ScriptExecutionContext*, Kind, String&& name, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
FileSystemStorageConnection& connection() { return m_connection.get(); }
private:
+ // ActiveDOMObject
+ const char* activeDOMObjectName() const final;
+ void stop() final;
+
Kind m_kind { Kind::File };
String m_name;
FileSystemHandleIdentifier m_identifier;
Ref<FileSystemStorageConnection> m_connection;
+ bool m_isClosed { false };
};
} // namespace WebCore
Modified: trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.idl (284899 => 284900)
--- trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.idl 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.idl 2021-10-26 21:42:08 UTC (rev 284900)
@@ -29,6 +29,7 @@
};
[
+ ActiveDOMObject,
CustomToJSObject,
Exposed=(Window,Worker),
EnabledBySetting=FileSystemAccessEnabled,
Modified: trunk/Source/WebCore/Modules/filesystemaccess/FileSystemSyncAccessHandle.cpp (284899 => 284900)
--- trunk/Source/WebCore/Modules/filesystemaccess/FileSystemSyncAccessHandle.cpp 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/filesystemaccess/FileSystemSyncAccessHandle.cpp 2021-10-26 21:42:08 UTC (rev 284900)
@@ -33,39 +33,31 @@
namespace WebCore {
-Ref<FileSystemSyncAccessHandle> FileSystemSyncAccessHandle::create(FileSystemFileHandle& source, FileSystemSyncAccessHandleIdentifier identifier, FileSystem::PlatformFileHandle file)
+Ref<FileSystemSyncAccessHandle> FileSystemSyncAccessHandle::create(ScriptExecutionContext* context, FileSystemFileHandle& source, FileSystemSyncAccessHandleIdentifier identifier, FileSystem::PlatformFileHandle file)
{
- return adoptRef(*new FileSystemSyncAccessHandle(source, identifier, file));
+ return adoptRef(*new FileSystemSyncAccessHandle(context, source, identifier, file));
}
-FileSystemSyncAccessHandle::FileSystemSyncAccessHandle(FileSystemFileHandle& source, FileSystemSyncAccessHandleIdentifier identifier, FileSystem::PlatformFileHandle file)
- : m_source(source)
+FileSystemSyncAccessHandle::FileSystemSyncAccessHandle(ScriptExecutionContext* context, FileSystemFileHandle& source, FileSystemSyncAccessHandleIdentifier identifier, FileSystem::PlatformFileHandle file)
+ : ActiveDOMObject(context)
+ , m_source(source)
, m_identifier(identifier)
, m_file(file)
{
ASSERT(m_file != FileSystem::invalidPlatformFileHandle);
+ suspendIfNeeded();
}
FileSystemSyncAccessHandle::~FileSystemSyncAccessHandle()
{
- if (m_closeResult)
- return;
-
- ASSERT(m_closePromises.isEmpty());
- closeInternal([](auto) { });
+ ASSERT(m_closeResult);
}
bool FileSystemSyncAccessHandle::isClosingOrClosed() const
{
- return m_closeResult || !m_closePromises.isEmpty();
+ return m_closeResult || !m_closeCallbacks.isEmpty();
}
-void FileSystemSyncAccessHandle::closeInternal(CompletionHandler<void(ExceptionOr<void>&&)>&& completionHandler)
-{
- FileSystem::closeFile(m_file);
- m_source->close(m_identifier, WTFMove(completionHandler));
-}
-
void FileSystemSyncAccessHandle::truncate(unsigned long long size, DOMPromiseDeferred<void>&& promise)
{
if (isClosingOrClosed())
@@ -110,17 +102,25 @@
void FileSystemSyncAccessHandle::close(DOMPromiseDeferred<void>&& promise)
{
+ m_pendingOperationCount++;
+ closeInternal([weakThis = WeakPtr { *this }, promise = WTFMove(promise)](auto result) mutable {
+ weakThis->m_pendingOperationCount--;
+ promise.settle(WTFMove(result));
+ });
+}
+
+void FileSystemSyncAccessHandle::closeInternal(CloseCallback&& callback)
+{
if (m_closeResult)
- return promise.settle(ExceptionOr<void> { *m_closeResult });
-
- auto isClosing = !m_closePromises.isEmpty();
- m_closePromises.append(WTFMove(promise));
+ return callback(ExceptionOr<void> { *m_closeResult });
+
+ auto isClosing = !m_closeCallbacks.isEmpty();
+ m_closeCallbacks.append(WTFMove(callback));
if (isClosing)
return;
- m_pendingOperationCount++;
- closeInternal([this, protectedThis = Ref { *this }](auto result) mutable {
- m_pendingOperationCount--;
+ FileSystem::closeFile(m_file);
+ m_source->close(m_identifier, [this, protectedThis = Ref { *this }](auto result) {
didClose(WTFMove(result));
});
}
@@ -127,11 +127,12 @@
void FileSystemSyncAccessHandle::didClose(ExceptionOr<void>&& result)
{
+ ASSERT(!m_closeResult);
+
m_closeResult = WTFMove(result);
-
- auto promises = std::exchange(m_closePromises, { });
- for (auto promise : promises)
- promise.settle(ExceptionOr<void> { *m_closeResult });
+ auto callbacks = std::exchange(m_closeCallbacks, { });
+ for (auto& callback : callbacks)
+ callback(ExceptionOr<void> { *m_closeResult });
}
ExceptionOr<unsigned long long> FileSystemSyncAccessHandle::read(BufferSource&& buffer, FileSystemSyncAccessHandle::FilesystemReadWriteOptions options)
@@ -176,4 +177,14 @@
return result;
}
+const char* FileSystemSyncAccessHandle::activeDOMObjectName() const
+{
+ return "FileSystemSyncAccessHandle";
+}
+
+void FileSystemSyncAccessHandle::stop()
+{
+ closeInternal([](auto) { });
+}
+
} // namespace WebCore
Modified: trunk/Source/WebCore/Modules/filesystemaccess/FileSystemSyncAccessHandle.h (284899 => 284900)
--- trunk/Source/WebCore/Modules/filesystemaccess/FileSystemSyncAccessHandle.h 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/filesystemaccess/FileSystemSyncAccessHandle.h 2021-10-26 21:42:08 UTC (rev 284900)
@@ -25,6 +25,7 @@
#pragma once
+#include "ActiveDOMObject.h"
#include "BufferSource.h"
#include "ExceptionOr.h"
#include "FileSystemSyncAccessHandleIdentifier.h"
@@ -37,13 +38,13 @@
class FileSystemFileHandle;
template<typename> class DOMPromiseDeferred;
-class FileSystemSyncAccessHandle : public RefCounted<FileSystemSyncAccessHandle>, public CanMakeWeakPtr<FileSystemSyncAccessHandle> {
+class FileSystemSyncAccessHandle : public ActiveDOMObject, public RefCounted<FileSystemSyncAccessHandle>, public CanMakeWeakPtr<FileSystemSyncAccessHandle> {
public:
struct FilesystemReadWriteOptions {
unsigned long long at;
};
- static Ref<FileSystemSyncAccessHandle> create(FileSystemFileHandle&, FileSystemSyncAccessHandleIdentifier, FileSystem::PlatformFileHandle);
+ static Ref<FileSystemSyncAccessHandle> create(ScriptExecutionContext*, FileSystemFileHandle&, FileSystemSyncAccessHandleIdentifier, FileSystem::PlatformFileHandle);
~FileSystemSyncAccessHandle();
void truncate(unsigned long long size, DOMPromiseDeferred<void>&&);
@@ -55,16 +56,21 @@
ExceptionOr<unsigned long long> write(BufferSource&&, FilesystemReadWriteOptions);
private:
- FileSystemSyncAccessHandle(FileSystemFileHandle&, FileSystemSyncAccessHandleIdentifier, FileSystem::PlatformFileHandle);
+ FileSystemSyncAccessHandle(ScriptExecutionContext*, FileSystemFileHandle&, FileSystemSyncAccessHandleIdentifier, FileSystem::PlatformFileHandle);
bool isClosingOrClosed() const;
- void closeInternal(CompletionHandler<void(ExceptionOr<void>&&)>&&);
+ using CloseCallback = CompletionHandler<void(ExceptionOr<void>&&)>;
+ void closeInternal(CloseCallback&&);
+ // ActiveDOMObject
+ const char* activeDOMObjectName() const final;
+ void stop() final;
+
Ref<FileSystemFileHandle> m_source;
FileSystemSyncAccessHandleIdentifier m_identifier;
uint64_t m_pendingOperationCount { 0 };
FileSystem::PlatformFileHandle m_file;
std::optional<ExceptionOr<void>> m_closeResult;
- Vector<DOMPromiseDeferred<void>> m_closePromises;
+ Vector<CloseCallback> m_closeCallbacks;
};
} // namespace WebCore
Modified: trunk/Source/WebCore/Modules/filesystemaccess/FileSystemSyncAccessHandle.idl (284899 => 284900)
--- trunk/Source/WebCore/Modules/filesystemaccess/FileSystemSyncAccessHandle.idl 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/filesystemaccess/FileSystemSyncAccessHandle.idl 2021-10-26 21:42:08 UTC (rev 284900)
@@ -24,8 +24,8 @@
*/
[
+ ActiveDOMObject,
EnabledBySetting=AccessHandleEnabled,
- ImplementationLacksVTable,
Exposed=DedicatedWorker,
SecureContext
] interface FileSystemSyncAccessHandle {
Modified: trunk/Source/WebCore/Modules/storage/StorageManager.cpp (284899 => 284900)
--- trunk/Source/WebCore/Modules/storage/StorageManager.cpp 2021-10-26 21:39:45 UTC (rev 284899)
+++ trunk/Source/WebCore/Modules/storage/StorageManager.cpp 2021-10-26 21:42:08 UTC (rev 284900)
@@ -115,12 +115,13 @@
return promise.reject(connectionInfoOrException.releaseException());
auto connectionInfo = connectionInfoOrException.releaseReturnValue();
- connectionInfo.connection.fileSystemGetDirectory(connectionInfo.origin, [promise = WTFMove(promise)](auto result) mutable {
+ connectionInfo.connection.fileSystemGetDirectory(connectionInfo.origin, [promise = WTFMove(promise), weakNavigator = m_navigator](auto result) mutable {
if (result.hasException())
return promise.reject(result.releaseException());
+ auto* context = weakNavigator ? weakNavigator->scriptExecutionContext() : nullptr;
auto identifierConnectionPair = result.releaseReturnValue();
- promise.resolve(FileSystemDirectoryHandle::create({ }, identifierConnectionPair.first, Ref { * identifierConnectionPair.second }));
+ promise.resolve(FileSystemDirectoryHandle::create(context, { }, identifierConnectionPair.first, Ref { * identifierConnectionPair.second }));
});
}
