⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 283271 in webkit


Ignore:
Timestamp:
Sep 29, 2021, 3:45:23 PM (5 years ago)
Author:
sihui_liu@apple.com
Message:

Replace FileSystemHandleImpl with FileSystemStorageConnection
​https://bugs.webkit.org/show_bug.cgi?id=230861
<rdar://problem/83606465>

Reviewed by Youenn Fablet.

Source/WebCore:

Introduce WorkerStorageConnection class, which dispatches StorageManager task to main-thread StorageConnection
and dispatches result back to worker thread.

Rebaselined existing test.

  • Headers.cmake:
  • Modules/filesystemaccess/FileSystemDirectoryHandle.cpp:

(WebCore::FileSystemDirectoryHandle::create):
(WebCore::FileSystemDirectoryHandle::FileSystemDirectoryHandle):
(WebCore::FileSystemDirectoryHandle::getFileHandle):
(WebCore::FileSystemDirectoryHandle::getDirectoryHandle):
(WebCore::FileSystemDirectoryHandle::removeEntry):
(WebCore::FileSystemDirectoryHandle::resolve):

  • Modules/filesystemaccess/FileSystemDirectoryHandle.h:
  • Modules/filesystemaccess/FileSystemFileHandle.cpp:

(WebCore::FileSystemFileHandle::create):
(WebCore::FileSystemFileHandle::FileSystemFileHandle):

  • Modules/filesystemaccess/FileSystemFileHandle.h:
  • Modules/filesystemaccess/FileSystemHandle.cpp:

(WebCore::FileSystemHandle::FileSystemHandle):
(WebCore::FileSystemHandle::isSameEntry const):

  • Modules/filesystemaccess/FileSystemHandle.h:

(WebCore::FileSystemHandle::identifier const):
(WebCore::FileSystemHandle::connection):
(WebCore::FileSystemHandle::impl const): Deleted.

  • Modules/filesystemaccess/FileSystemHandleIdentifier.h: Renamed from Source/WebKit/NetworkProcess/storage/FileSystemStorageHandleIdentifier.h.
  • Modules/filesystemaccess/FileSystemStorageConnection.h: Renamed from Source/WebCore/Modules/filesystemaccess/FileSystemHandleImpl.h.

(WebCore::FileSystemStorageConnection::~FileSystemStorageConnection):

  • Modules/storage/DummyStorageProvider.h:
  • Modules/storage/StorageConnection.h:
  • Modules/storage/StorageManager.cpp:

(WebCore::StorageManager::fileSystemAccessGetDirectory):

  • Modules/storage/WorkerStorageConnection.cpp:
  • WebCore.xcodeproj/project.pbxproj:

Source/WebKit:

Replace FileSystemStorageHandleProxy with WebFileSystemStorageConnection.

  • NetworkProcess/storage/FileSystemStorageHandle.cpp:

(WebKit::FileSystemStorageHandle::FileSystemStorageHandle):
(WebKit::FileSystemStorageHandle::isSameEntry):
(WebKit::FileSystemStorageHandle::requestCreateHandle):
(WebKit::FileSystemStorageHandle::getFileHandle):
(WebKit::FileSystemStorageHandle::getDirectoryHandle):
(WebKit::FileSystemStorageHandle::resolve):

  • NetworkProcess/storage/FileSystemStorageHandle.h:

(WebKit::FileSystemStorageHandle::identifier const):

  • NetworkProcess/storage/FileSystemStorageHandleRegistry.cpp:

(WebKit::FileSystemStorageHandleRegistry::registerHandle):
(WebKit::FileSystemStorageHandleRegistry::unregisterHandle):
(WebKit::FileSystemStorageHandleRegistry::getHandle):

  • NetworkProcess/storage/FileSystemStorageHandleRegistry.h:
  • NetworkProcess/storage/FileSystemStorageManager.cpp:

(WebKit::FileSystemStorageManager::createHandle):
(WebKit::FileSystemStorageManager::getPath):
(WebKit::FileSystemStorageManager::getDirectory):

  • NetworkProcess/storage/FileSystemStorageManager.h:
  • NetworkProcess/storage/NetworkStorageManager.cpp:

(WebKit::NetworkStorageManager::fileSystemGetDirectory):
(WebKit::NetworkStorageManager::isSameEntry):
(WebKit::NetworkStorageManager::getFileHandle):
(WebKit::NetworkStorageManager::getDirectoryHandle):
(WebKit::NetworkStorageManager::removeEntry):
(WebKit::NetworkStorageManager::resolve):

  • NetworkProcess/storage/NetworkStorageManager.h:
  • NetworkProcess/storage/NetworkStorageManager.messages.in:
  • NetworkProcess/storage/OriginStorageManager.h:
  • Scripts/webkit/messages.py:

(types_that_cannot_be_forward_declared):

  • Sources.txt:
  • WebKit.xcodeproj/project.pbxproj:
  • WebProcess/WebCoreSupport/WebFileSystemStorageConnection.cpp: Renamed from Source/WebKit/WebProcess/WebCoreSupport/FileSystemStorageHandleProxy.cpp.

(WebKit::WebFileSystemStorageConnection::create):
(WebKit::WebFileSystemStorageConnection::WebFileSystemStorageConnection):
(WebKit::WebFileSystemStorageConnection::connectionClosed):
(WebKit::WebFileSystemStorageConnection::isSameEntry):
(WebKit::WebFileSystemStorageConnection::getFileHandle):
(WebKit::WebFileSystemStorageConnection::getDirectoryHandle):
(WebKit::WebFileSystemStorageConnection::removeEntry):
(WebKit::WebFileSystemStorageConnection::resolve):

  • WebProcess/WebCoreSupport/WebFileSystemStorageConnection.h: Renamed from Source/WebKit/WebProcess/WebCoreSupport/FileSystemStorageHandleProxy.h.
  • WebProcess/WebCoreSupport/WebStorageConnection.cpp:

(WebKit::WebStorageConnection::persist):
(WebKit::WebStorageConnection::fileSystemGetDirectory):

  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::networkProcessConnectionClosed):
(WebKit::WebProcess::fileSystemStorageConnection):

  • WebProcess/WebProcess.h:
Location:
trunk/Source
Files:
30 edited
4 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r283269 r283271  
     12021-09-29  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Replace FileSystemHandleImpl with FileSystemStorageConnection
     4        https://bugs.webkit.org/show_bug.cgi?id=230861
     5        <rdar://problem/83606465>
     6
     7        Reviewed by Youenn Fablet.
     8
     9        Introduce WorkerStorageConnection class, which dispatches StorageManager task to main-thread StorageConnection
     10        and dispatches result back to worker thread.
     11
     12        Rebaselined existing test.
     13
     14        * Headers.cmake:
     15        * Modules/filesystemaccess/FileSystemDirectoryHandle.cpp:
     16        (WebCore::FileSystemDirectoryHandle::create):
     17        (WebCore::FileSystemDirectoryHandle::FileSystemDirectoryHandle):
     18        (WebCore::FileSystemDirectoryHandle::getFileHandle):
     19        (WebCore::FileSystemDirectoryHandle::getDirectoryHandle):
     20        (WebCore::FileSystemDirectoryHandle::removeEntry):
     21        (WebCore::FileSystemDirectoryHandle::resolve):
     22        * Modules/filesystemaccess/FileSystemDirectoryHandle.h:
     23        * Modules/filesystemaccess/FileSystemFileHandle.cpp:
     24        (WebCore::FileSystemFileHandle::create):
     25        (WebCore::FileSystemFileHandle::FileSystemFileHandle):
     26        * Modules/filesystemaccess/FileSystemFileHandle.h:
     27        * Modules/filesystemaccess/FileSystemHandle.cpp:
     28        (WebCore::FileSystemHandle::FileSystemHandle):
     29        (WebCore::FileSystemHandle::isSameEntry const):
     30        * Modules/filesystemaccess/FileSystemHandle.h:
     31        (WebCore::FileSystemHandle::identifier const):
     32        (WebCore::FileSystemHandle::connection):
     33        (WebCore::FileSystemHandle::impl const): Deleted.
     34        * Modules/filesystemaccess/FileSystemHandleIdentifier.h: Renamed from Source/WebKit/NetworkProcess/storage/FileSystemStorageHandleIdentifier.h.
     35        * Modules/filesystemaccess/FileSystemStorageConnection.h: Renamed from Source/WebCore/Modules/filesystemaccess/FileSystemHandleImpl.h.
     36        (WebCore::FileSystemStorageConnection::~FileSystemStorageConnection):
     37        * Modules/storage/DummyStorageProvider.h:
     38        * Modules/storage/StorageConnection.h:
     39        * Modules/storage/StorageManager.cpp:
     40        (WebCore::StorageManager::fileSystemAccessGetDirectory):
     41        * Modules/storage/WorkerStorageConnection.cpp:
     42        * WebCore.xcodeproj/project.pbxproj:
     43
    1442021-09-29  Aditya Keerthi  <akeerthi@apple.com>
    245

  • trunk/Source/WebCore/Headers.cmake

    r283237 r283271  
    4141    Modules/filesystemaccess/FileSystemFileHandle.h
    4242    Modules/filesystemaccess/FileSystemHandle.h
    43     Modules/filesystemaccess/FileSystemHandleImpl.h
     43    Modules/filesystemaccess/FileSystemHandleIdentifier.h
     44    Modules/filesystemaccess/FileSystemStorageConnection.h
    4445    Modules/filesystemaccess/StorageManagerFileSystemAccess.h
    4546

  • trunk/Source/WebCore/Modules/filesystemaccess/FileSystemDirectoryHandle.cpp

    r283029 r283271  
    2727#include "FileSystemDirectoryHandle.h"
    2828
    29 #include "FileSystemHandleImpl.h"
     29#include "FileSystemStorageConnection.h"
    3030#include "JSDOMPromiseDeferred.h"
    3131#include "JSFileSystemDirectoryHandle.h"
    … …  
    3737WTF_MAKE_ISO_ALLOCATED_IMPL(FileSystemDirectoryHandle);
    3838
    39 Ref<FileSystemDirectoryHandle> FileSystemDirectoryHandle::create(String&& name, Ref<FileSystemHandleImpl>&& impl)
     39Ref<FileSystemDirectoryHandle> FileSystemDirectoryHandle::create(String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
    4040{
    41     return adoptRef(*new FileSystemDirectoryHandle(WTFMove(name), WTFMove(impl)));
     41    return adoptRef(*new FileSystemDirectoryHandle(WTFMove(name), identifier, WTFMove(connection)));
    4242}
    4343
    44 FileSystemDirectoryHandle::FileSystemDirectoryHandle(String&& name, Ref<FileSystemHandleImpl>&& impl)
    45     : FileSystemHandle(FileSystemHandle::Kind::Directory, WTFMove(name), WTFMove(impl))
     44FileSystemDirectoryHandle::FileSystemDirectoryHandle(String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
     45    : FileSystemHandle(FileSystemHandle::Kind::Directory, WTFMove(name), identifier, WTFMove(connection))
    4646{
    4747}
    … …  
    5050{
    5151    bool createIfNecessary = options ? options->create : false;
    52     impl().getFileHandle(name, createIfNecessary, [name, promise = WTFMove(promise)](auto result) mutable {
     52    connection().getFileHandle(identifier(), name, createIfNecessary, [connection = Ref { connection() }, name, promise = WTFMove(promise)](auto result) mutable {
    5353        if (result.hasException())
    5454            return promise.reject(result.releaseException());
    5555
    56         promise.resolve(FileSystemFileHandle::create(String { name }, result.releaseReturnValue()));
     56        promise.settle(FileSystemFileHandle::create(String { name }, result.returnValue(), WTFMove(connection)));
    5757    });
    5858}
    … …  
    6161{
    6262    bool createIfNecessary = options ? options->create : false;
    63     impl().getDirectoryHandle(name, createIfNecessary, [name, promise = WTFMove(promise)](auto result) mutable {
     63    connection().getDirectoryHandle(identifier(), name, createIfNecessary, [connection = Ref { connection() }, name, promise = WTFMove(promise)](auto result) mutable {
    6464        if (result.hasException())
    6565            return promise.reject(result.releaseException());
    6666
    67         promise.resolve(FileSystemDirectoryHandle::create(String { name }, result.releaseReturnValue()));
     67        promise.settle(FileSystemDirectoryHandle::create(String { name }, result.returnValue(), WTFMove(connection)));
    6868    });
    6969}
    … …  
    7272{
    7373    bool deleteRecursively = options ? options->recursive : false;
    74     impl().removeEntry(name, deleteRecursively, [promise = WTFMove(promise)](auto result) mutable {
     74    connection().removeEntry(identifier(), name, deleteRecursively, [promise = WTFMove(promise)](auto result) mutable {
    7575        promise.settle(WTFMove(result));
    7676    });
    … …  
    7979void FileSystemDirectoryHandle::resolve(const FileSystemHandle& handle, DOMPromiseDeferred<IDLSequence<IDLUSVString>>&& promise)
    8080{
    81     impl().resolve(handle.impl(), [promise = WTFMove(promise)](auto result) mutable {
     81    connection().resolve(identifier(), handle.identifier(), [promise = WTFMove(promise)](auto result) mutable {
    8282        if (result.hasException())
    8383            return promise.reject(result.releaseException());

  • trunk/Source/WebCore/Modules/filesystemaccess/FileSystemDirectoryHandle.h

    r283029 r283271  
    4747    };
    4848
    49     WEBCORE_EXPORT static Ref<FileSystemDirectoryHandle> create(String&&, Ref<FileSystemHandleImpl>&&);
     49    WEBCORE_EXPORT static Ref<FileSystemDirectoryHandle> create(String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
    5050    void getFileHandle(const String& name, std::optional<GetFileOptions>, DOMPromiseDeferred<IDLInterface<FileSystemFileHandle>>&&);
    5151    void getDirectoryHandle(const String& name, std::optional<GetDirectoryOptions>, DOMPromiseDeferred<IDLInterface<FileSystemDirectoryHandle>>&&);
    … …  
    5454
    5555private:
    56     FileSystemDirectoryHandle(String&&, Ref<FileSystemHandleImpl>&&);
     56    FileSystemDirectoryHandle(String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
    5757};
    5858

  • trunk/Source/WebCore/Modules/filesystemaccess/FileSystemFileHandle.cpp

    r283029 r283271  
    2727#include "FileSystemFileHandle.h"
    2828
    29 #include "FileSystemHandleImpl.h"
     29#include "FileSystemStorageConnection.h"
    3030#include "JSDOMPromiseDeferred.h"
    3131#include <wtf/IsoMallocInlines.h>
    … …  
    3535WTF_MAKE_ISO_ALLOCATED_IMPL(FileSystemFileHandle);
    3636
    37 Ref<FileSystemFileHandle> FileSystemFileHandle::create(String&& name, Ref<FileSystemHandleImpl>&& impl)
     37Ref<FileSystemFileHandle> FileSystemFileHandle::create(String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
    3838{
    39     return adoptRef(*new FileSystemFileHandle(WTFMove(name), WTFMove(impl)));
     39    return adoptRef(*new FileSystemFileHandle(WTFMove(name), identifier, WTFMove(connection)));
    4040}
    4141
    42 FileSystemFileHandle::FileSystemFileHandle(String&& name, Ref<FileSystemHandleImpl>&& impl)
    43     : FileSystemHandle(FileSystemHandle::Kind::File, WTFMove(name), WTFMove(impl))
     42FileSystemFileHandle::FileSystemFileHandle(String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
     43    : FileSystemHandle(FileSystemHandle::Kind::File, WTFMove(name), identifier, WTFMove(connection))
    4444{
    4545}

  • trunk/Source/WebCore/Modules/filesystemaccess/FileSystemFileHandle.h

    r283029 r283271  
    3535    WTF_MAKE_ISO_ALLOCATED(FileSystemFileHandle);
    3636public:
    37     WEBCORE_EXPORT static Ref<FileSystemFileHandle> create(String&&, Ref<FileSystemHandleImpl>&&);
     37    WEBCORE_EXPORT static Ref<FileSystemFileHandle> create(String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
    3838    void getFile(DOMPromiseDeferred<IDLInterface<File>>&&);
    3939
    4040private:
    41     FileSystemFileHandle(String&&, Ref<FileSystemHandleImpl>&&);
     41    FileSystemFileHandle(String&&, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
    4242};
    4343

  • trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.cpp

    r283069 r283271  
    2727#include "FileSystemHandle.h"
    2828
    29 #include "FileSystemHandleImpl.h"
    3029#include "JSDOMPromiseDeferred.h"
    3130#include <wtf/IsoMallocInlines.h>
    … …  
    3534WTF_MAKE_ISO_ALLOCATED_IMPL(FileSystemHandle);
    3635
    37 FileSystemHandle::FileSystemHandle(FileSystemHandle::Kind kind, String&& name, Ref<FileSystemHandleImpl>&& impl)
     36FileSystemHandle::FileSystemHandle(FileSystemHandle::Kind kind, String&& name, FileSystemHandleIdentifier identifier, Ref<FileSystemStorageConnection>&& connection)
    3837    : m_kind(kind)
    3938    , m_name(WTFMove(name))
    40     , m_impl(WTFMove(impl))
     39    , m_identifier(identifier)
     40    , m_connection(WTFMove(connection))
    4141{
    4242}
    … …  
    4949        return promise.resolve(false);
    5050
    51     m_impl->isSameEntry(handle.impl(), [promise = WTFMove(promise)](auto result) mutable {
     51    m_connection->isSameEntry(m_identifier, handle.identifier(), [promise = WTFMove(promise)](auto result) mutable {
    5252        promise.settle(WTFMove(result));
    5353    });

  • trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandle.h

    r283029 r283271  
    2626#pragma once
    2727
     28#include "FileSystemHandleIdentifier.h"
    2829#include "IDLTypes.h"
    2930#include <wtf/IsoMalloc.h>
    … …  
    3334template<typename> class DOMPromiseDeferred;
    3435
    35 class FileSystemHandleImpl;
     36class FileSystemStorageConnection;
    3637enum class PermissionState : uint8_t;
    3738
    … …  
    4748    Kind kind() const { return m_kind; }
    4849    const String& name() const { return m_name; }
    49     FileSystemHandleImpl& impl() const { return m_impl.get(); }
     50    FileSystemHandleIdentifier identifier() const { return m_identifier; }
    5051
    5152    void isSameEntry(FileSystemHandle&, DOMPromiseDeferred<IDLBoolean>&&) const;
    5253
    5354protected:
    54     FileSystemHandle(Kind, String&& name, Ref<FileSystemHandleImpl>&&);
     55    FileSystemHandle(Kind, String&& name, FileSystemHandleIdentifier, Ref<FileSystemStorageConnection>&&);
     56    FileSystemStorageConnection& connection() { return m_connection.get(); }
    5557
    5658private:
    5759    Kind m_kind { Kind::File };
    5860    String m_name;
    59     Ref<FileSystemHandleImpl> m_impl;
     61    FileSystemHandleIdentifier m_identifier;
     62    Ref<FileSystemStorageConnection> m_connection;
    6063};
    6164

  • trunk/Source/WebCore/Modules/filesystemaccess/FileSystemHandleIdentifier.h

    r283270 r283271  
    2828#include <wtf/ObjectIdentifier.h>
    2929
    30 namespace WebKit {
     30namespace WebCore {
    3131
    32 enum FileSystemStorageHandleIdentifierType { };
    33 using FileSystemStorageHandleIdentifier = ObjectIdentifier<FileSystemStorageHandleIdentifierType>;
     32enum FileSystemHandleIdentifierType { };
     33using FileSystemHandleIdentifier = ObjectIdentifier<FileSystemHandleIdentifierType>;
    3434
    35 } // namespace WebKit
     35} // namespace WebCore

  • trunk/Source/WebCore/Modules/filesystemaccess/FileSystemStorageConnection.h

    r283270 r283271  
    2626#pragma once
    2727
     28#include "FileSystemHandleIdentifier.h"
    2829#include <wtf/CompletionHandler.h>
     30#include <wtf/ThreadSafeRefCounted.h>
    2931
    3032namespace WebCore {
    … …  
    3436template<typename> class ExceptionOr;
    3537
    36 class FileSystemHandleImpl : public RefCounted<FileSystemHandleImpl> {
     38class FileSystemStorageConnection : public ThreadSafeRefCounted<FileSystemStorageConnection> {
    3739public:
    38     virtual ~FileSystemHandleImpl() { }
    39     virtual std::optional<uint64_t> storageHandleIdentifier() = 0;
    40     virtual void isSameEntry(FileSystemHandleImpl&, CompletionHandler<void(ExceptionOr<bool>&&)>&&) = 0;
    41     virtual void getFileHandle(const String& name, bool createIfNecessary, CompletionHandler<void(ExceptionOr<Ref<FileSystemHandleImpl>>&&)>&&) = 0;
    42     virtual void getDirectoryHandle(const String& name, bool createIfNecessary, CompletionHandler<void(ExceptionOr<Ref<FileSystemHandleImpl>>&&)>&&) = 0;
    43     virtual void removeEntry(const String& name, bool recursive, CompletionHandler<void(ExceptionOr<void>&&)>&&) = 0;
    44     virtual void resolve(FileSystemHandleImpl&, CompletionHandler<void(ExceptionOr<Vector<String>>&&)>&&) = 0;
     40    virtual ~FileSystemStorageConnection() { }
     41    using SameEntryCallback = CompletionHandler<void(ExceptionOr<bool>&&)>;
     42    using GetHandleCallback = CompletionHandler<void(ExceptionOr<FileSystemHandleIdentifier>&&)>;
     43    using RemoveEntryCallback = CompletionHandler<void(ExceptionOr<void>&&)>;
     44    using ResolveCallback = CompletionHandler<void(ExceptionOr<Vector<String>>&&)>;
     45    virtual void isSameEntry(FileSystemHandleIdentifier, FileSystemHandleIdentifier, SameEntryCallback&&) = 0;
     46    virtual void getFileHandle(FileSystemHandleIdentifier, const String& name, bool createIfNecessary, GetHandleCallback&&) = 0;
     47    virtual void getDirectoryHandle(FileSystemHandleIdentifier, const String& name, bool createIfNecessary, GetHandleCallback&&) = 0;
     48    virtual void removeEntry(FileSystemHandleIdentifier, const String& name, bool deleteRecursively, RemoveEntryCallback&&) = 0;
     49    virtual void resolve(FileSystemHandleIdentifier, FileSystemHandleIdentifier, ResolveCallback&&) = 0;
    4550};
    4651

  • trunk/Source/WebCore/Modules/storage/DummyStorageProvider.h

    r283184 r283271  
    2626#pragma once
    2727
    28 #include "FileSystemHandleImpl.h"
     28#include "FileSystemStorageConnection.h"
    2929#include "StorageProvider.h"
    3030

  • trunk/Source/WebCore/Modules/storage/StorageConnection.h

    r283184 r283271  
    2626#pragma once
    2727
     28#include "FileSystemHandleIdentifier.h"
    2829#include <wtf/CompletionHandler.h>
    2930#include <wtf/ThreadSafeRefCounted.h>
    … …  
    3132namespace WebCore {
    3233
    33 class FileSystemHandleImpl;
     34class FileSystemStorageConnection;
    3435template<typename> class ExceptionOr;
    3536struct ClientOrigin;
    … …  
    4142    virtual void getPersisted(const ClientOrigin&, PersistCallback&&) = 0;
    4243    virtual void persist(const ClientOrigin&, PersistCallback&& completionHandler) { completionHandler(false); }
    43     using GetDirectoryCallback = CompletionHandler<void(ExceptionOr<Ref<FileSystemHandleImpl>>&&)>;
     44    using GetDirectoryCallback = CompletionHandler<void(ExceptionOr<std::pair<FileSystemHandleIdentifier, RefPtr<FileSystemStorageConnection>>>)>;
    4445    virtual void fileSystemGetDirectory(const ClientOrigin&, GetDirectoryCallback&&) = 0;
    4546};

  • trunk/Source/WebCore/Modules/storage/StorageManager.cpp

    r283184 r283271  
    3131#include "ExceptionOr.h"
    3232#include "FileSystemDirectoryHandle.h"
    33 #include "FileSystemHandleImpl.h"
     33#include "FileSystemStorageConnection.h"
    3434#include "JSDOMPromiseDeferred.h"
    3535#include "JSFileSystemDirectoryHandle.h"
    … …  
    120120            return promise.reject(result.releaseException());
    121121
    122         promise.resolve(FileSystemDirectoryHandle::create({ }, result.releaseReturnValue()));
     122        auto identifierConnectionPair = result.releaseReturnValue();
     123        promise.resolve(FileSystemDirectoryHandle::create({ }, identifierConnectionPair.first, Ref { * identifierConnectionPair.second }));
    123124    });
    124125}

  • trunk/Source/WebCore/Modules/storage/WorkerStorageConnection.cpp

    r283184 r283271  
    2828
    2929#include "ClientOrigin.h"
    30 #include "FileSystemHandleImpl.h"
    3130#include "WorkerGlobalScope.h"
    3231#include "WorkerLoaderProxy.h"

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r283237 r283271  
    28082808                930AAC9F250ED4090013DA9F /* JSCSSConditionRule.h in Headers */ = {isa = PBXBuildFile; fileRef = 930AAC9D250ED4090013DA9F /* JSCSSConditionRule.h */; };
    28092809                930AACA2250ED4110013DA9F /* JSCSSGroupingRule.h in Headers */ = {isa = PBXBuildFile; fileRef = 930AACA0250ED4110013DA9F /* JSCSSGroupingRule.h */; };
    2810                 9312BAD926F3AC9A00FDDF5F /* FileSystemHandleImpl.h in Headers */ = {isa = PBXBuildFile; fileRef = 931A075826F1B44F004474CD /* FileSystemHandleImpl.h */; settings = {ATTRIBUTES = (Private, ); }; };
    28112810                93153BDA14181F7A00FCF5BE /* missingImage@2x.png in Resources */ = {isa = PBXBuildFile; fileRef = 93153BD914181F7A00FCF5BE /* missingImage@2x.png */; };
    28122811                93153BDC141959BC00FCF5BE /* textAreaResizeCorner.png in Resources */ = {isa = PBXBuildFile; fileRef = 93153BDB141959BB00FCF5BE /* textAreaResizeCorner.png */; };
    … …  
    28782877                93500F3213FDE3BE0099EC24 /* NSScrollerImpDetails.h in Headers */ = {isa = PBXBuildFile; fileRef = 93500F3113FDE3BE0099EC24 /* NSScrollerImpDetails.h */; settings = {ATTRIBUTES = (Private, ); }; };
    28792878                935207BE09BD410A00F2038D /* LocalizedStrings.h in Headers */ = {isa = PBXBuildFile; fileRef = 935207BD09BD410A00F2038D /* LocalizedStrings.h */; settings = {ATTRIBUTES = (Private, ); }; };
     2879                9354242F2703CA51005CA72C /* FileSystemHandleIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 935424272703BC88005CA72C /* FileSystemHandleIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
     2880                935424302703CB86005CA72C /* FileSystemStorageConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 935424292703BCAD005CA72C /* FileSystemStorageConnection.h */; settings = {ATTRIBUTES = (Private, ); }; };
    28802881                9355EF51253A4279006FF4A4 /* JSAbstractRange.h in Headers */ = {isa = PBXBuildFile; fileRef = 9355EF4F253A4278006FF4A4 /* JSAbstractRange.h */; settings = {ATTRIBUTES = (Private, ); }; };
    28812882                935C476309AC4CE600A6AAB4 /* MouseEventWithHitTestResults.h in Headers */ = {isa = PBXBuildFile; fileRef = 935C476209AC4CE600A6AAB4 /* MouseEventWithHitTestResults.h */; };
    … …  
    1167811679                9316DDFA240C64B3009340AA /* SimpleRange.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SimpleRange.cpp; sourceTree = "<group>"; };
    1167911680                9316DDFE240C64F8009340AA /* BoundaryPoint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BoundaryPoint.h; sourceTree = "<group>"; };
    11680                 931A075826F1B44F004474CD /* FileSystemHandleImpl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FileSystemHandleImpl.h; sourceTree = "<group>"; };
    1168111681                931A1BDD26F7ED090081A7E5 /* JSFileSystemHandleCustom.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = JSFileSystemHandleCustom.cpp; sourceTree = "<group>"; };
    1168211682                931AE3B81FB80EAE00F5EFB2 /* JSValueInWrappedObject.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = JSValueInWrappedObject.h; sourceTree = "<group>"; };
    … …  
    1182411824                935207BD09BD410A00F2038D /* LocalizedStrings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalizedStrings.h; sourceTree = "<group>"; };
    1182511825                9353676A09AED88B00D35CD6 /* ScrollViewMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ScrollViewMac.mm; sourceTree = "<group>"; };
     11826                935424272703BC88005CA72C /* FileSystemHandleIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FileSystemHandleIdentifier.h; sourceTree = "<group>"; };
     11827                935424292703BCAD005CA72C /* FileSystemStorageConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FileSystemStorageConnection.h; sourceTree = "<group>"; };
    1182611828                9355EF4F253A4278006FF4A4 /* JSAbstractRange.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSAbstractRange.h; sourceTree = "<group>"; };
    1182711829                9355EF50253A4279006FF4A4 /* JSAbstractRange.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSAbstractRange.cpp; sourceTree = "<group>"; };
    … …  
    2338123383                                932C9BDA26DD62610053B3DB /* FileSystemHandle.h */,
    2338223384                                932C9BD926DD62600053B3DB /* FileSystemHandle.idl */,
    23383                                 931A075826F1B44F004474CD /* FileSystemHandleImpl.h */,
     23385                                935424272703BC88005CA72C /* FileSystemHandleIdentifier.h */,
     23386                                935424292703BCAD005CA72C /* FileSystemStorageConnection.h */,
    2338423387                                93443E7B26E8A6BC0058538F /* StorageManager+FileSystemAccess.idl */,
    2338523388                                93443E7D26E8A6BC0058538F /* StorageManagerFileSystemAccess.h */,
    … …  
    3248732490                                93443E8726E995C00058538F /* FileSystemFileHandle.h in Headers */,
    3248832491                                93443E8826E995C40058538F /* FileSystemHandle.h in Headers */,
    32489                                 9312BAD926F3AC9A00FDDF5F /* FileSystemHandleImpl.h in Headers */,
     32492                                9354242F2703CA51005CA72C /* FileSystemHandleIdentifier.h in Headers */,
     32493                                935424302703CB86005CA72C /* FileSystemStorageConnection.h in Headers */,
    3249032494                                BC5EB69F0E81DAEB00B25965 /* FillLayer.h in Headers */,
    3249132495                                712BE4831FE865DD002031CC /* FillMode.h in Headers */,

  • trunk/Source/WebKit/ChangeLog

    r283253 r283271  
     12021-09-29  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Replace FileSystemHandleImpl with FileSystemStorageConnection
     4        https://bugs.webkit.org/show_bug.cgi?id=230861
     5        <rdar://problem/83606465>
     6
     7        Reviewed by Youenn Fablet.
     8
     9        Replace FileSystemStorageHandleProxy with WebFileSystemStorageConnection.
     10
     11        * NetworkProcess/storage/FileSystemStorageHandle.cpp:
     12        (WebKit::FileSystemStorageHandle::FileSystemStorageHandle):
     13        (WebKit::FileSystemStorageHandle::isSameEntry):
     14        (WebKit::FileSystemStorageHandle::requestCreateHandle):
     15        (WebKit::FileSystemStorageHandle::getFileHandle):
     16        (WebKit::FileSystemStorageHandle::getDirectoryHandle):
     17        (WebKit::FileSystemStorageHandle::resolve):
     18        * NetworkProcess/storage/FileSystemStorageHandle.h:
     19        (WebKit::FileSystemStorageHandle::identifier const):
     20        * NetworkProcess/storage/FileSystemStorageHandleRegistry.cpp:
     21        (WebKit::FileSystemStorageHandleRegistry::registerHandle):
     22        (WebKit::FileSystemStorageHandleRegistry::unregisterHandle):
     23        (WebKit::FileSystemStorageHandleRegistry::getHandle):
     24        * NetworkProcess/storage/FileSystemStorageHandleRegistry.h:
     25        * NetworkProcess/storage/FileSystemStorageManager.cpp:
     26        (WebKit::FileSystemStorageManager::createHandle):
     27        (WebKit::FileSystemStorageManager::getPath):
     28        (WebKit::FileSystemStorageManager::getDirectory):
     29        * NetworkProcess/storage/FileSystemStorageManager.h:
     30        * NetworkProcess/storage/NetworkStorageManager.cpp:
     31        (WebKit::NetworkStorageManager::fileSystemGetDirectory):
     32        (WebKit::NetworkStorageManager::isSameEntry):
     33        (WebKit::NetworkStorageManager::getFileHandle):
     34        (WebKit::NetworkStorageManager::getDirectoryHandle):
     35        (WebKit::NetworkStorageManager::removeEntry):
     36        (WebKit::NetworkStorageManager::resolve):
     37        * NetworkProcess/storage/NetworkStorageManager.h:
     38        * NetworkProcess/storage/NetworkStorageManager.messages.in:
     39        * NetworkProcess/storage/OriginStorageManager.h:
     40        * Scripts/webkit/messages.py:
     41        (types_that_cannot_be_forward_declared):
     42        * Sources.txt:
     43        * WebKit.xcodeproj/project.pbxproj:
     44        * WebProcess/WebCoreSupport/WebFileSystemStorageConnection.cpp: Renamed from Source/WebKit/WebProcess/WebCoreSupport/FileSystemStorageHandleProxy.cpp.
     45        (WebKit::WebFileSystemStorageConnection::create):
     46        (WebKit::WebFileSystemStorageConnection::WebFileSystemStorageConnection):
     47        (WebKit::WebFileSystemStorageConnection::connectionClosed):
     48        (WebKit::WebFileSystemStorageConnection::isSameEntry):
     49        (WebKit::WebFileSystemStorageConnection::getFileHandle):
     50        (WebKit::WebFileSystemStorageConnection::getDirectoryHandle):
     51        (WebKit::WebFileSystemStorageConnection::removeEntry):
     52        (WebKit::WebFileSystemStorageConnection::resolve):
     53        * WebProcess/WebCoreSupport/WebFileSystemStorageConnection.h: Renamed from Source/WebKit/WebProcess/WebCoreSupport/FileSystemStorageHandleProxy.h.
     54        * WebProcess/WebCoreSupport/WebStorageConnection.cpp:
     55        (WebKit::WebStorageConnection::persist):
     56        (WebKit::WebStorageConnection::fileSystemGetDirectory):
     57        * WebProcess/WebProcess.cpp:
     58        (WebKit::WebProcess::networkProcessConnectionClosed):
     59        (WebKit::WebProcess::fileSystemStorageConnection):
     60        * WebProcess/WebProcess.h:
     61
    1622021-09-29  Per Arne  <pvollan@apple.com>
    263

  • trunk/Source/WebKit/NetworkProcess/storage/FileSystemStorageHandle.cpp

    r283029 r283271  
    3939
    4040FileSystemStorageHandle::FileSystemStorageHandle(FileSystemStorageManager& manager, Type type, String&& path, String&& name)
    41     : m_identifier(FileSystemStorageHandleIdentifier::generateThreadSafe())
     41    : m_identifier(WebCore::FileSystemHandleIdentifier::generateThreadSafe())
    4242    , m_manager(makeWeakPtr(manager))
    4343    , m_type(type)
    … …  
    5959}
    6060
    61 bool FileSystemStorageHandle::isSameEntry(FileSystemStorageHandleIdentifier identifier)
     61bool FileSystemStorageHandle::isSameEntry(WebCore::FileSystemHandleIdentifier identifier)
    6262{
    6363    auto path = m_manager->getPath(identifier);
    … …  
    6868}
    6969
    70 Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError> FileSystemStorageHandle::requestCreateHandle(IPC::Connection::UniqueID connection, Type type, String&& name, bool createIfNecessary)
     70Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError> FileSystemStorageHandle::requestCreateHandle(IPC::Connection::UniqueID connection, Type type, String&& name, bool createIfNecessary)
    7171{
    7272    if (m_type != FileSystemStorageHandle::Type::Directory)
    … …  
    8484}
    8585
    86 Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError> FileSystemStorageHandle::getFileHandle(IPC::Connection::UniqueID connection, String&& name, bool createIfNecessary)
     86Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError> FileSystemStorageHandle::getFileHandle(IPC::Connection::UniqueID connection, String&& name, bool createIfNecessary)
    8787{
    8888    return requestCreateHandle(connection, FileSystemStorageHandle::Type::File, WTFMove(name), createIfNecessary);
    8989}
    9090
    91 Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError> FileSystemStorageHandle::getDirectoryHandle(IPC::Connection::UniqueID connection, String&& name, bool createIfNecessary)
     91Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError> FileSystemStorageHandle::getDirectoryHandle(IPC::Connection::UniqueID connection, String&& name, bool createIfNecessary)
    9292{
    9393    return requestCreateHandle(connection, FileSystemStorageHandle::Type::Directory, WTFMove(name), createIfNecessary);
    … …  
    124124}
    125125
    126 Expected<Vector<String>, FileSystemStorageError> FileSystemStorageHandle::resolve(FileSystemStorageHandleIdentifier identifier)
     126Expected<Vector<String>, FileSystemStorageError> FileSystemStorageHandle::resolve(WebCore::FileSystemHandleIdentifier identifier)
    127127{
    128128    if (!m_manager)

  • trunk/Source/WebKit/NetworkProcess/storage/FileSystemStorageHandle.h

    r283029 r283271  
    2727
    2828#include "Connection.h"
    29 #include "FileSystemStorageHandleIdentifier.h"
    30 
     29#include <WebCore/FileSystemHandleIdentifier.h>
    3130#include <wtf/WeakPtr.h>
    3231
    … …  
    4241    FileSystemStorageHandle(FileSystemStorageManager&, Type, String&& path, String&& name);
    4342
    44     FileSystemStorageHandleIdentifier identifier() const { return m_identifier; }
     43    WebCore::FileSystemHandleIdentifier identifier() const { return m_identifier; }
    4544    const String& path() const { return m_path; }
    4645
    47     bool isSameEntry(FileSystemStorageHandleIdentifier);
    48     Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError> getFileHandle(IPC::Connection::UniqueID, String&& name, bool createIfNecessary);
    49     Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError> getDirectoryHandle(IPC::Connection::UniqueID, String&& name, bool createIfNecessary);
     46    bool isSameEntry(WebCore::FileSystemHandleIdentifier);
     47    Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError> getFileHandle(IPC::Connection::UniqueID, String&& name, bool createIfNecessary);
     48    Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError> getDirectoryHandle(IPC::Connection::UniqueID, String&& name, bool createIfNecessary);
    5049    std::optional<FileSystemStorageError> removeEntry(const String& name, bool deleteRecursively);
    51     Expected<Vector<String>, FileSystemStorageError> resolve(FileSystemStorageHandleIdentifier);
     50    Expected<Vector<String>, FileSystemStorageError> resolve(WebCore::FileSystemHandleIdentifier);
    5251
    5352private:
    54     Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError> requestCreateHandle(IPC::Connection::UniqueID, Type, String&& name, bool createIfNecessary);
     53    Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError> requestCreateHandle(IPC::Connection::UniqueID, Type, String&& name, bool createIfNecessary);
    5554
    56     FileSystemStorageHandleIdentifier m_identifier;
     55    WebCore::FileSystemHandleIdentifier m_identifier;
    5756    WeakPtr<FileSystemStorageManager> m_manager;
    5857    Type m_type;

  • trunk/Source/WebKit/NetworkProcess/storage/FileSystemStorageHandleRegistry.cpp

    r283069 r283271  
    3333FileSystemStorageHandleRegistry::FileSystemStorageHandleRegistry() = default;
    3434
    35 void FileSystemStorageHandleRegistry::registerHandle(FileSystemStorageHandleIdentifier identifier, FileSystemStorageHandle& handle)
     35void FileSystemStorageHandleRegistry::registerHandle(WebCore::FileSystemHandleIdentifier identifier, FileSystemStorageHandle& handle)
    3636{
    3737    ASSERT(!m_handles.contains(identifier));
    … …  
    4040}
    4141
    42 void FileSystemStorageHandleRegistry::unregisterHandle(FileSystemStorageHandleIdentifier identifier)
     42void FileSystemStorageHandleRegistry::unregisterHandle(WebCore::FileSystemHandleIdentifier identifier)
    4343{
    4444    ASSERT(m_handles.contains(identifier));
    … …  
    4747}
    4848
    49 FileSystemStorageHandle* FileSystemStorageHandleRegistry::getHandle(FileSystemStorageHandleIdentifier identifier)
     49FileSystemStorageHandle* FileSystemStorageHandleRegistry::getHandle(WebCore::FileSystemHandleIdentifier identifier)
    5050{
    5151    if (auto handle = m_handles.get(identifier))

  • trunk/Source/WebKit/NetworkProcess/storage/FileSystemStorageHandleRegistry.h

    r283029 r283271  
    2727
    2828#include "Connection.h"
    29 #include "FileSystemStorageHandleIdentifier.h"
     29#include <WebCore/FileSystemHandleIdentifier.h>
    3030#include <wtf/WeakPtr.h>
    3131
    … …  
    3838public:
    3939    FileSystemStorageHandleRegistry();
    40     void registerHandle(FileSystemStorageHandleIdentifier, FileSystemStorageHandle&);
    41     void unregisterHandle(FileSystemStorageHandleIdentifier);
    42     FileSystemStorageHandle* getHandle(FileSystemStorageHandleIdentifier);
     40    void registerHandle(WebCore::FileSystemHandleIdentifier, FileSystemStorageHandle&);
     41    void unregisterHandle(WebCore::FileSystemHandleIdentifier);
     42    FileSystemStorageHandle* getHandle(WebCore::FileSystemHandleIdentifier);
    4343
    4444private:
    45     HashMap<FileSystemStorageHandleIdentifier, WeakPtr<FileSystemStorageHandle>> m_handles;
     45    HashMap<WebCore::FileSystemHandleIdentifier, WeakPtr<FileSystemStorageHandle>> m_handles;
    4646};
    4747

  • trunk/Source/WebKit/NetworkProcess/storage/FileSystemStorageManager.cpp

    r283069 r283271  
    4747}
    4848
    49 Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError> FileSystemStorageManager::createHandle(IPC::Connection::UniqueID connection, FileSystemStorageHandle::Type type, String&& path, String&& name, bool createIfNecessary)
     49Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError> FileSystemStorageManager::createHandle(IPC::Connection::UniqueID connection, FileSystemStorageHandle::Type type, String&& path, String&& name, bool createIfNecessary)
    5050{
    5151    ASSERT(!RunLoop::isMain());
    … …  
    7171    auto newHandleIdentifier = newHandle->identifier();
    7272    m_handlesByConnection.ensure(connection, [&] {
    73         return HashSet<FileSystemStorageHandleIdentifier> { };
     73        return HashSet<WebCore::FileSystemHandleIdentifier> { };
    7474    }).iterator->value.add(newHandleIdentifier);
    7575    m_registry.registerHandle(newHandleIdentifier, *newHandle);
    … …  
    7878}
    7979
    80 const String& FileSystemStorageManager::getPath(FileSystemStorageHandleIdentifier identifier)
     80const String& FileSystemStorageManager::getPath(WebCore::FileSystemHandleIdentifier identifier)
    8181{
    8282    auto handle = m_handles.find(identifier);
    … …  
    9999}
    100100
    101 Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError> FileSystemStorageManager::getDirectory(IPC::Connection::UniqueID connection)
     101Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError> FileSystemStorageManager::getDirectory(IPC::Connection::UniqueID connection)
    102102{
    103103    ASSERT(!RunLoop::isMain());

  • trunk/Source/WebKit/NetworkProcess/storage/FileSystemStorageManager.h

    r283029 r283271  
    2727
    2828#include "FileSystemStorageHandle.h"
    29 #include "FileSystemStorageHandleIdentifier.h"
     29#include <WebCore/FileSystemHandleIdentifier.h>
    3030
    3131namespace WebKit {
    … …  
    4040    ~FileSystemStorageManager();
    4141
    42     Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError> createHandle(IPC::Connection::UniqueID, FileSystemStorageHandle::Type, String&& path, String&& name, bool createIfNecessary);
    43     const String& getPath(FileSystemStorageHandleIdentifier);
     42    Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError> createHandle(IPC::Connection::UniqueID, FileSystemStorageHandle::Type, String&& path, String&& name, bool createIfNecessary);
     43    const String& getPath(WebCore::FileSystemHandleIdentifier);
    4444    void connectionClosed(IPC::Connection::UniqueID);
    45     Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError> getDirectory(IPC::Connection::UniqueID);
     45    Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError> getDirectory(IPC::Connection::UniqueID);
    4646
    4747private:
    4848    String m_path;
    4949    FileSystemStorageHandleRegistry& m_registry;
    50     HashMap<IPC::Connection::UniqueID, HashSet<FileSystemStorageHandleIdentifier>> m_handlesByConnection;
    51     HashMap<FileSystemStorageHandleIdentifier, std::unique_ptr<FileSystemStorageHandle>> m_handles;
     50    HashMap<IPC::Connection::UniqueID, HashSet<WebCore::FileSystemHandleIdentifier>> m_handlesByConnection;
     51    HashMap<WebCore::FileSystemHandleIdentifier, std::unique_ptr<FileSystemStorageHandle>> m_handles;
    5252};
    5353

  • trunk/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.cpp

    r283029 r283271  
    165165}
    166166
    167 void NetworkStorageManager::fileSystemGetDirectory(IPC::Connection& connection, const WebCore::ClientOrigin& origin, CompletionHandler<void(Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError>)>&& completionHandler)
     167void NetworkStorageManager::fileSystemGetDirectory(IPC::Connection& connection, const WebCore::ClientOrigin& origin, CompletionHandler<void(Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError>)>&& completionHandler)
    168168{
    169169    ASSERT(!RunLoop::isMain());
    … …  
    172172}
    173173
    174 void NetworkStorageManager::isSameEntry(FileSystemStorageHandleIdentifier identifier, FileSystemStorageHandleIdentifier targetIdentifier, CompletionHandler<void(bool)>&& completionHandler)
     174void NetworkStorageManager::isSameEntry(WebCore::FileSystemHandleIdentifier identifier, WebCore::FileSystemHandleIdentifier targetIdentifier, CompletionHandler<void(bool)>&& completionHandler)
    175175{
    176176    ASSERT(!RunLoop::isMain());
    … …  
    183183}
    184184
    185 void NetworkStorageManager::getFileHandle(IPC::Connection& connection, FileSystemStorageHandleIdentifier identifier, String&& name, bool createIfNecessary, CompletionHandler<void(Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError>)>&& completionHandler)
     185void NetworkStorageManager::getFileHandle(IPC::Connection& connection, WebCore::FileSystemHandleIdentifier identifier, String&& name, bool createIfNecessary, CompletionHandler<void(Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError>)>&& completionHandler)
    186186{
    187187    ASSERT(!RunLoop::isMain());
    … …  
    194194}
    195195
    196 void NetworkStorageManager::getDirectoryHandle(IPC::Connection& connection, FileSystemStorageHandleIdentifier identifier, String&& name, bool createIfNecessary, CompletionHandler<void(Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError>)>&& completionHandler)
     196void NetworkStorageManager::getDirectoryHandle(IPC::Connection& connection, WebCore::FileSystemHandleIdentifier identifier, String&& name, bool createIfNecessary, CompletionHandler<void(Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError>)>&& completionHandler)
    197197{
    198198    ASSERT(!RunLoop::isMain());
    … …  
    205205}
    206206
    207 void NetworkStorageManager::removeEntry(FileSystemStorageHandleIdentifier identifier, const String& name, bool deleteRecursively, CompletionHandler<void(std::optional<FileSystemStorageError>)>&& completionHandler)
     207void NetworkStorageManager::removeEntry(WebCore::FileSystemHandleIdentifier identifier, const String& name, bool deleteRecursively, CompletionHandler<void(std::optional<FileSystemStorageError>)>&& completionHandler)
    208208{
    209209    ASSERT(!RunLoop::isMain());
    … …  
    216216}
    217217
    218 void NetworkStorageManager::resolve(FileSystemStorageHandleIdentifier identifier, FileSystemStorageHandleIdentifier targetIdentifier, CompletionHandler<void(Expected<Vector<String>, FileSystemStorageError>)>&& completionHandler)
     218void NetworkStorageManager::resolve(WebCore::FileSystemHandleIdentifier identifier, WebCore::FileSystemHandleIdentifier targetIdentifier, CompletionHandler<void(Expected<Vector<String>, FileSystemStorageError>)>&& completionHandler)
    219219{
    220220    ASSERT(!RunLoop::isMain());

  • trunk/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.h

    r283029 r283271  
    2828#include "Connection.h"
    2929#include "FileSystemStorageError.h"
    30 #include "FileSystemStorageHandleIdentifier.h"
    3130#include "OriginStorageManager.h"
    3231#include <WebCore/ClientOrigin.h>
     32#include <WebCore/FileSystemHandleIdentifier.h>
    3333#include <pal/SessionID.h>
    3434
    … …  
    6464    void persisted(const WebCore::ClientOrigin&, CompletionHandler<void(bool)>&&);
    6565    void persist(const WebCore::ClientOrigin&, CompletionHandler<void(bool)>&&);
    66     void fileSystemGetDirectory(IPC::Connection&, const WebCore::ClientOrigin&, CompletionHandler<void(Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError>)>&&);
    67     void isSameEntry(FileSystemStorageHandleIdentifier, FileSystemStorageHandleIdentifier, CompletionHandler<void(bool)>&&);
    68     void getFileHandle(IPC::Connection&, FileSystemStorageHandleIdentifier, String&& name, bool createIfNecessary, CompletionHandler<void(Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError>)>&&);
    69     void getDirectoryHandle(IPC::Connection&, FileSystemStorageHandleIdentifier, String&& name, bool createIfNecessary, CompletionHandler<void(Expected<FileSystemStorageHandleIdentifier, FileSystemStorageError>)>&&);
    70     void removeEntry(FileSystemStorageHandleIdentifier, const String& name, bool deleteRecursively, CompletionHandler<void(std::optional<FileSystemStorageError>)>&&);
    71     void resolve(FileSystemStorageHandleIdentifier, FileSystemStorageHandleIdentifier, CompletionHandler<void(Expected<Vector<String>, FileSystemStorageError>)>&&);
     66    void fileSystemGetDirectory(IPC::Connection&, const WebCore::ClientOrigin&, CompletionHandler<void(Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError>)>&&);
     67    void isSameEntry(WebCore::FileSystemHandleIdentifier, WebCore::FileSystemHandleIdentifier, CompletionHandler<void(bool)>&&);
     68    void getFileHandle(IPC::Connection&, WebCore::FileSystemHandleIdentifier, String&& name, bool createIfNecessary, CompletionHandler<void(Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError>)>&&);
     69    void getDirectoryHandle(IPC::Connection&, WebCore::FileSystemHandleIdentifier, String&& name, bool createIfNecessary, CompletionHandler<void(Expected<WebCore::FileSystemHandleIdentifier, FileSystemStorageError>)>&&);
     70    void removeEntry(WebCore::FileSystemHandleIdentifier, const String& name, bool deleteRecursively, CompletionHandler<void(std::optional<FileSystemStorageError>)>&&);
     71    void resolve(WebCore::FileSystemHandleIdentifier, WebCore::FileSystemHandleIdentifier, CompletionHandler<void(Expected<Vector<String>, FileSystemStorageError>)>&&);
    7272
    7373    PAL::SessionID m_sessionID;

  • trunk/Source/WebKit/NetworkProcess/storage/NetworkStorageManager.messages.in

    r283029 r283271  
    2727    Persisted(struct WebCore::ClientOrigin origin) -> (bool persisted) Async
    2828    Persist(struct WebCore::ClientOrigin origin) -> (bool persisted) Async
    29     FileSystemGetDirectory(struct WebCore::ClientOrigin origin) -> (Expected<WebKit::FileSystemStorageHandleIdentifier, WebKit::FileSystemStorageError> result) Async WantsConnection
    30     IsSameEntry(WebKit::FileSystemStorageHandleIdentifier identifier, WebKit::FileSystemStorageHandleIdentifier targetIdentifier) -> (bool result) Async
    31     GetFileHandle(WebKit::FileSystemStorageHandleIdentifier identifier, String name, bool createIfNecessary) -> (Expected<WebKit::FileSystemStorageHandleIdentifier, WebKit::FileSystemStorageError> result) Async WantsConnection
    32     GetDirectoryHandle(WebKit::FileSystemStorageHandleIdentifier identifier, String name, bool createIfNecessary) -> (Expected<WebKit::FileSystemStorageHandleIdentifier, WebKit::FileSystemStorageError> result) Async WantsConnection
    33     RemoveEntry(WebKit::FileSystemStorageHandleIdentifier identifier, String name, bool deleteRecursively) -> (std::optional<WebKit::FileSystemStorageError> result) Async
    34     Resolve(WebKit::FileSystemStorageHandleIdentifier identifier, WebKit::FileSystemStorageHandleIdentifier targetIdentifier) -> (Expected<Vector<String>, WebKit::FileSystemStorageError> result) Async
     29    FileSystemGetDirectory(struct WebCore::ClientOrigin origin) -> (Expected<WebCore::FileSystemHandleIdentifier, WebKit::FileSystemStorageError> result) Async WantsConnection
     30    IsSameEntry(WebCore::FileSystemHandleIdentifier identifier, WebCore::FileSystemHandleIdentifier targetIdentifier) -> (bool result) Async
     31    GetFileHandle(WebCore::FileSystemHandleIdentifier identifier, String name, bool createIfNecessary) -> (Expected<WebCore::FileSystemHandleIdentifier, WebKit::FileSystemStorageError> result) Async WantsConnection
     32    GetDirectoryHandle(WebCore::FileSystemHandleIdentifier identifier, String name, bool createIfNecessary) -> (Expected<WebCore::FileSystemHandleIdentifier, WebKit::FileSystemStorageError> result) Async WantsConnection
     33    RemoveEntry(WebCore::FileSystemHandleIdentifier identifier, String name, bool deleteRecursively) -> (std::optional<WebKit::FileSystemStorageError> result) Async
     34    Resolve(WebCore::FileSystemHandleIdentifier identifier, WebCore::FileSystemHandleIdentifier targetIdentifier) -> (Expected<Vector<String>, WebKit::FileSystemStorageError> result) Async
    3535}

  • trunk/Source/WebKit/NetworkProcess/storage/OriginStorageManager.h

    r283069 r283271  
    2727
    2828#include "Connection.h"
    29 #include "FileSystemStorageHandleIdentifier.h"
    3029#include <wtf/text/WTFString.h>
    3130

  • trunk/Source/WebKit/Scripts/webkit/messages.py

    r283179 r283271  
    282282        'WebCore::DragApplicationFlags',
    283283        'WebCore::FetchIdentifier',
     284        'WebCore::FileSystemHandleIdentifier',
    284285        'WebCore::FrameIdentifier',
    285286        'WebCore::GraphicsContextGLAttributes',
    … …  
    318319        'WebKit::DownloadID',
    319320        'WebKit::FileSystemStorageError',
    320         'WebKit::FileSystemStorageHandleIdentifier',
    321321        'WebKit::FormSubmitListenerIdentifier',
    322322        'WebKit::GeolocationIdentifier',

  • trunk/Source/WebKit/Sources.txt

    r283029 r283271  
    696696WebProcess/WebAuthentication/WebAuthnProcessConnection.cpp
    697697
    698 WebProcess/WebCoreSupport/FileSystemStorageHandleProxy.cpp
    699698WebProcess/WebCoreSupport/SessionStateConversion.cpp
    700699WebProcess/WebCoreSupport/ShareableBitmapUtilities.cpp
    … …  
    708707WebProcess/WebCoreSupport/WebDragClient.cpp
    709708WebProcess/WebCoreSupport/WebEditorClient.cpp
     709WebProcess/WebCoreSupport/WebFileSystemStorageConnection.cpp
    710710WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp
    711711WebProcess/WebCoreSupport/WebGeolocationClient.cpp

  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r283119 r283271  
    14861486                9342589A255B535A0059EEDD /* MediaPermissionUtilities.h in Headers */ = {isa = PBXBuildFile; fileRef = 93425898255B534B0059EEDD /* MediaPermissionUtilities.h */; };
    14871487                934B724419F5B9BE00AE96D6 /* WKActionMenuItemTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 934B724319F5B9BE00AE96D6 /* WKActionMenuItemTypes.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1488                9354242C2703BDCB005CA72C /* WebFileSystemStorageConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 9354242A2703BDCB005CA72C /* WebFileSystemStorageConnection.h */; };
    14881489                9356F2DC2152B6B500E6D5DF /* WebSWClientConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 517A53021F4793B200DCDC0A /* WebSWClientConnection.h */; };
    14891490                9356F2DD2152B6F600E6D5DF /* WebSWServerConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 93BA04E02151ADF4007F455F /* WebSWServerConnection.h */; };
    … …  
    49434944                931A075226F06AB4004474CD /* FileSystemStorageHandle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FileSystemStorageHandle.cpp; sourceTree = "<group>"; };
    49444945                931A075326F06AB4004474CD /* FileSystemStorageHandle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FileSystemStorageHandle.h; sourceTree = "<group>"; };
    4945                 931A075726F125A3004474CD /* FileSystemStorageHandleIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FileSystemStorageHandleIdentifier.h; sourceTree = "<group>"; };
    4946                 931A075926F1B967004474CD /* FileSystemStorageHandleProxy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FileSystemStorageHandleProxy.cpp; sourceTree = "<group>"; };
    4947                 931A075A26F1B968004474CD /* FileSystemStorageHandleProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FileSystemStorageHandleProxy.h; sourceTree = "<group>"; };
    49484946                931A1BE026F85C320081A7E5 /* FileSystemStorageError.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FileSystemStorageError.h; sourceTree = "<group>"; };
    49494947                9321D5851A38EE3C008052BE /* WKImmediateActionController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKImmediateActionController.h; sourceTree = "<group>"; };
    … …  
    49614959                93425898255B534B0059EEDD /* MediaPermissionUtilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaPermissionUtilities.h; sourceTree = "<group>"; };
    49624960                934B724319F5B9BE00AE96D6 /* WKActionMenuItemTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKActionMenuItemTypes.h; sourceTree = "<group>"; };
     4961                9354242A2703BDCB005CA72C /* WebFileSystemStorageConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebFileSystemStorageConnection.h; sourceTree = "<group>"; };
     4962                9354242B2703BDCB005CA72C /* WebFileSystemStorageConnection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebFileSystemStorageConnection.cpp; sourceTree = "<group>"; };
    49634963                935B579826F51270008B48AC /* FileSystemStorageHandleRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FileSystemStorageHandleRegistry.h; sourceTree = "<group>"; };
    49644964                935B579926F5192F008B48AC /* FileSystemStorageHandleRegistry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FileSystemStorageHandleRegistry.cpp; sourceTree = "<group>"; };
    … …  
    97559755                                931A075226F06AB4004474CD /* FileSystemStorageHandle.cpp */,
    97569756                                931A075326F06AB4004474CD /* FileSystemStorageHandle.h */,
    9757                                 931A075726F125A3004474CD /* FileSystemStorageHandleIdentifier.h */,
    97589757                                935B579926F5192F008B48AC /* FileSystemStorageHandleRegistry.cpp */,
    97599758                                935B579826F51270008B48AC /* FileSystemStorageHandleRegistry.h */,
    … …  
    1007510074                                2D28F3DF1885CCB4004B9EAE /* ios */,
    1007610075                                BC111ADE112F5B9A00337BAB /* mac */,
    10077                                 931A075926F1B967004474CD /* FileSystemStorageHandleProxy.cpp */,
    10078                                 931A075A26F1B968004474CD /* FileSystemStorageHandleProxy.h */,
    1007910076                                1A7284441959ED100007BCE5 /* SessionStateConversion.cpp */,
    1008010077                                1A7284451959ED100007BCE5 /* SessionStateConversion.h */,
    … …  
    1010210099                                BC111A57112F4FBB00337BAB /* WebEditorClient.cpp */,
    1010310100                                BC032D6810F4378D0058C15A /* WebEditorClient.h */,
     10101                                9354242B2703BDCB005CA72C /* WebFileSystemStorageConnection.cpp */,
     10102                                9354242A2703BDCB005CA72C /* WebFileSystemStorageConnection.h */,
    1010410103                                BC111A58112F4FBB00337BAB /* WebFrameLoaderClient.cpp */,
    1010510104                                BC032D6A10F4378D0058C15A /* WebFrameLoaderClient.h */,
    … …  
    1278512784                                BC032DBB10F4380F0058C15A /* WebEventConversion.h in Headers */,
    1278612785                                BC111B5D112F629800337BAB /* WebEventFactory.h in Headers */,
     12786                                9354242C2703BDCB005CA72C /* WebFileSystemStorageConnection.h in Headers */,
    1278712787                                1A90C1EE1264FD50003E44D4 /* WebFindOptions.h in Headers */,
    1278812788                                BCE469541214E6CB000B98EB /* WebFormClient.h in Headers */,

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebFileSystemStorageConnection.cpp

    r283270 r283271  
    2525
    2626#include "config.h"
    27 #include "FileSystemStorageHandleProxy.h"
     27#include "WebFileSystemStorageConnection.h"
    2828
    2929#include "FileSystemStorageError.h"
    … …  
    3535namespace WebKit {
    3636
    37 Ref<FileSystemStorageHandleProxy> FileSystemStorageHandleProxy::create(FileSystemStorageHandleIdentifier identifier, IPC::Connection& connection)
     37Ref<WebFileSystemStorageConnection> WebFileSystemStorageConnection::create(IPC::Connection& connection)
    3838{
    39     return adoptRef(*new FileSystemStorageHandleProxy(identifier, connection));
     39    return adoptRef(*new WebFileSystemStorageConnection(connection));
    4040}
    4141
    42 FileSystemStorageHandleProxy::FileSystemStorageHandleProxy(FileSystemStorageHandleIdentifier identifier, IPC::Connection& connection)
    43     : m_identifier(identifier)
    44     , m_connection(&connection)
     42WebFileSystemStorageConnection::WebFileSystemStorageConnection(IPC::Connection& connection)
     43    : m_connection(&connection)
    4544{
    4645}
    4746
    48 void FileSystemStorageHandleProxy::connectionClosed()
     47void WebFileSystemStorageConnection::connectionClosed()
    4948{
    5049    m_connection = nullptr;
    5150}
    5251
    53 void FileSystemStorageHandleProxy::isSameEntry(FileSystemHandleImpl& handle, CompletionHandler<void(WebCore::ExceptionOr<bool>&&)>&& completionHandler)
     52void WebFileSystemStorageConnection::isSameEntry(WebCore::FileSystemHandleIdentifier identifier, WebCore::FileSystemHandleIdentifier otherIdentifier, WebCore::FileSystemStorageConnection::SameEntryCallback&& completionHandler)
    5453{
    5554    if (!m_connection)
    5655        return completionHandler(WebCore::Exception { WebCore::UnknownError, "Connection is lost" });
    5756
    58     auto identifier = handle.storageHandleIdentifier();
    59     if (!identifier)
    60         return completionHandler(false);
    61 
    62     if (m_identifier.toUInt64() == *identifier)
     57    if (identifier == otherIdentifier)
    6358        return completionHandler(true);
    6459
    65     m_connection->sendWithAsyncReply(Messages::NetworkStorageManager::IsSameEntry(m_identifier, makeObjectIdentifier<FileSystemStorageHandleIdentifierType>(*identifier)), [completionHandler = WTFMove(completionHandler)](bool result) mutable {
    66         completionHandler(result);
    67     });
     60    m_connection->sendWithAsyncReply(Messages::NetworkStorageManager::IsSameEntry(identifier, otherIdentifier), WTFMove(completionHandler));
    6861}
    6962
    70 void FileSystemStorageHandleProxy::getFileHandle(const String& name, bool createIfNecessary, CompletionHandler<void(WebCore::ExceptionOr<Ref<WebCore::FileSystemHandleImpl>>&&)>&& completionHandler)
     63void WebFileSystemStorageConnection::getFileHandle(WebCore::FileSystemHandleIdentifier identifier, const String& name, bool createIfNecessary, WebCore::FileSystemStorageConnection::GetHandleCallback&& completionHandler)
    7164{
    7265    if (!m_connection)
    7366        return completionHandler(WebCore::Exception { WebCore::UnknownError, "Connection is lost" });
    7467
    75     m_connection->sendWithAsyncReply(Messages::NetworkStorageManager::GetFileHandle(m_identifier, name, createIfNecessary), [connection = m_connection, name, completionHandler = WTFMove(completionHandler)](auto result) mutable {
     68    m_connection->sendWithAsyncReply(Messages::NetworkStorageManager::GetFileHandle(identifier, name, createIfNecessary), [name, completionHandler = WTFMove(completionHandler)](auto result) mutable {
    7669        if (!result)
    7770            return completionHandler(WebCore::Exception { convertToExceptionCode(result.error()) });
    78    
    79         auto handleIdentifier = result.value();
    80         if (!handleIdentifier.isValid())
     71
     72        auto identifier = result.value();
     73        if (!identifier.isValid())
    8174            return completionHandler(WebCore::Exception { WebCore::UnknownError, "Connection is lost"_s });
    8275
    83         Ref<WebCore::FileSystemHandleImpl> impl = FileSystemStorageHandleProxy::create(handleIdentifier, *connection);
    84         completionHandler(WTFMove(impl));
     76        completionHandler(WTFMove(identifier));
    8577    });
    8678}
    8779
    88 void FileSystemStorageHandleProxy::getDirectoryHandle(const String& name, bool createIfNecessary, CompletionHandler<void(WebCore::ExceptionOr<Ref<WebCore::FileSystemHandleImpl>>&&)>&& completionHandler)
     80void WebFileSystemStorageConnection::getDirectoryHandle(WebCore::FileSystemHandleIdentifier identifier, const String& name, bool createIfNecessary, WebCore::FileSystemStorageConnection::GetHandleCallback&& completionHandler)
    8981{
    9082    if (!m_connection)
    9183        return completionHandler(WebCore::Exception { WebCore::UnknownError, "Connection is lost" });
    9284
    93     m_connection->sendWithAsyncReply(Messages::NetworkStorageManager::GetDirectoryHandle(m_identifier, name, createIfNecessary), [connection = m_connection, name, completionHandler = WTFMove(completionHandler)](auto result) mutable {
     85    m_connection->sendWithAsyncReply(Messages::NetworkStorageManager::GetDirectoryHandle(identifier, name, createIfNecessary), [name, completionHandler = WTFMove(completionHandler)](auto result) mutable {
    9486        if (!result)
    9587            return completionHandler(WebCore::Exception { convertToExceptionCode(result.error()) });
    96    
    97         auto handleIdentifier = result.value();
    98         if (!handleIdentifier.isValid())
     88
     89        auto identifier = result.value();
     90        if (!identifier.isValid())
    9991            return completionHandler(WebCore::Exception { WebCore::UnknownError, "Connection is lost"_s });
    10092
    101         Ref<WebCore::FileSystemHandleImpl> impl = FileSystemStorageHandleProxy::create(handleIdentifier, *connection);
    102         completionHandler(WTFMove(impl));
     93        completionHandler(WTFMove(identifier));
    10394    });
    10495}
    10596
    106 void FileSystemStorageHandleProxy::removeEntry(const String& name, bool deleteRecursively, CompletionHandler<void(WebCore::ExceptionOr<void>&&)>&& completionHandler)
     97void WebFileSystemStorageConnection::removeEntry(WebCore::FileSystemHandleIdentifier identifier, const String& name, bool deleteRecursively, WebCore::FileSystemStorageConnection::RemoveEntryCallback&& completionHandler)
    10798{
    10899    if (!m_connection)
    109100        return completionHandler(WebCore::Exception { WebCore::UnknownError, "Connection is lost" });
    110101
    111     m_connection->sendWithAsyncReply(Messages::NetworkStorageManager::RemoveEntry(m_identifier, name, deleteRecursively), [completionHandler = WTFMove(completionHandler)](auto error) mutable {
     102    m_connection->sendWithAsyncReply(Messages::NetworkStorageManager::RemoveEntry(identifier, name, deleteRecursively), [completionHandler = WTFMove(completionHandler)](auto error) mutable {
    112103        if (error)
    113104            return completionHandler(WebCore::Exception { convertToExceptionCode(error.value()) });
    … …  
    117108}
    118109
    119 void FileSystemStorageHandleProxy::resolve(FileSystemHandleImpl& handle, CompletionHandler<void(WebCore::ExceptionOr<Vector<String>>&&)>&& completionHandler)
     110void WebFileSystemStorageConnection::resolve(WebCore::FileSystemHandleIdentifier identifier, WebCore::FileSystemHandleIdentifier otherIdentifier, WebCore::FileSystemStorageConnection::ResolveCallback&& completionHandler)
    120111{
    121112    if (!m_connection)
    122113        return completionHandler(WebCore::Exception { WebCore::UnknownError, "Connection is lost" });
    123114
    124     auto identifier = handle.storageHandleIdentifier();
    125     if (!identifier)
    126         return completionHandler(Vector<String> { });
    127 
    128     m_connection->sendWithAsyncReply(Messages::NetworkStorageManager::Resolve(m_identifier, makeObjectIdentifier<FileSystemStorageHandleIdentifierType>(*identifier)), [completionHandler = WTFMove(completionHandler)](auto result) mutable {
     115    m_connection->sendWithAsyncReply(Messages::NetworkStorageManager::Resolve(identifier, otherIdentifier), [completionHandler = WTFMove(completionHandler)](auto result) mutable {
    129116        if (!result)
    130117            return completionHandler(WebCore::Exception { convertToExceptionCode(result.error()) });
    … …  
    135122
    136123} // namespace WebKit
    137 

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebFileSystemStorageConnection.h

    r283270 r283271  
    2626#pragma once
    2727
    28 #include "FileSystemStorageHandleIdentifier.h"
    29 #include <WebCore/FileSystemHandleImpl.h>
     28#include <WebCore/FileSystemStorageConnection.h>
    3029
    3130namespace IPC {
    … …  
    4140namespace WebKit {
    4241
    43 class FileSystemStorageHandleProxy final : public WebCore::FileSystemHandleImpl {
     42class WebFileSystemStorageConnection final : public WebCore::FileSystemStorageConnection {
    4443public:
    45     static Ref<FileSystemStorageHandleProxy> create(FileSystemStorageHandleIdentifier, IPC::Connection&);
     44    static Ref<WebFileSystemStorageConnection> create(IPC::Connection&);
    4645    void connectionClosed();
    4746
    4847private:
    49     FileSystemStorageHandleProxy(FileSystemStorageHandleIdentifier, IPC::Connection&);
     48    explicit WebFileSystemStorageConnection(IPC::Connection&);
    5049
    51     // FileSystemHandleImpl
    52     std::optional<uint64_t> storageHandleIdentifier() { return m_identifier.toUInt64(); }
    53     void isSameEntry(FileSystemHandleImpl&, CompletionHandler<void(WebCore::ExceptionOr<bool>&&)>&&) final;
    54     void getFileHandle(const String& name, bool createIfNecessary, CompletionHandler<void(WebCore::ExceptionOr<Ref<WebCore::FileSystemHandleImpl>>&&)>&&) final;
    55     void getDirectoryHandle(const String& name, bool createIfNecessary, CompletionHandler<void(WebCore::ExceptionOr<Ref<WebCore::FileSystemHandleImpl>>&&)>&&) final;
    56     void removeEntry(const String& name, bool deleteRecursively, CompletionHandler<void(WebCore::ExceptionOr<void>&&)>&&) final;
    57     void resolve(FileSystemHandleImpl&, CompletionHandler<void(WebCore::ExceptionOr<Vector<String>>&&)>&&) final;
     50    // FileSystemStorageConnection
     51    void isSameEntry(WebCore::FileSystemHandleIdentifier, WebCore::FileSystemHandleIdentifier, WebCore::FileSystemStorageConnection::SameEntryCallback&&);
     52    void getFileHandle(WebCore::FileSystemHandleIdentifier, const String& name, bool createIfNecessary, WebCore::FileSystemStorageConnection::GetHandleCallback&&);
     53    void getDirectoryHandle(WebCore::FileSystemHandleIdentifier, const String& name, bool createIfNecessary, WebCore::FileSystemStorageConnection::GetHandleCallback&&);
     54    void removeEntry(WebCore::FileSystemHandleIdentifier, const String& name, bool deleteRecursively, WebCore::FileSystemStorageConnection::RemoveEntryCallback&&);
     55    void resolve(WebCore::FileSystemHandleIdentifier, WebCore::FileSystemHandleIdentifier, WebCore::FileSystemStorageConnection::ResolveCallback&&);
    5856
    59     FileSystemStorageHandleIdentifier m_identifier;
    6057    RefPtr<IPC::Connection> m_connection;
    6158};

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebStorageConnection.cpp

    r283184 r283271  
    2727#include "WebStorageConnection.h"
    2828
    29 #include "FileSystemStorageHandleProxy.h"
    3029#include "NetworkProcessConnection.h"
    3130#include "NetworkStorageManagerMessages.h"
     31#include "WebFileSystemStorageConnection.h"
    3232#include "WebProcess.h"
    3333#include <WebCore/ClientOrigin.h>
    3434#include <WebCore/ExceptionOr.h>
     35#include <WebCore/FileSystemHandleIdentifier.h>
    3536
    3637namespace WebKit {
    … …  
    4647}
    4748
    48 void WebStorageConnection::persist(const WebCore::ClientOrigin& origin, CompletionHandler<void(bool)>&& completionHandler)
     49void WebStorageConnection::persist(const WebCore::ClientOrigin& origin, StorageConnection::PersistCallback&& completionHandler)
    4950{
    5051    connection().sendWithAsyncReply(Messages::NetworkStorageManager::Persist(origin), WTFMove(completionHandler));
    5152}
    5253
    53 void WebStorageConnection::fileSystemGetDirectory(const WebCore::ClientOrigin& origin, CompletionHandler<void(WebCore::ExceptionOr<Ref<WebCore::FileSystemHandleImpl>>&&)>&& completionHandler)
     54void WebStorageConnection::fileSystemGetDirectory(const WebCore::ClientOrigin& origin, StorageConnection::GetDirectoryCallback&& completionHandler)
    5455{
    5556    auto& connection = WebProcess::singleton().ensureNetworkProcessConnection().connection();
    56     connection.sendWithAsyncReply(Messages::NetworkStorageManager::FileSystemGetDirectory(origin), [weakConnection = makeWeakPtr(connection), completionHandler = WTFMove(completionHandler)](auto result) mutable {
     57    connection.sendWithAsyncReply(Messages::NetworkStorageManager::FileSystemGetDirectory(origin), [completionHandler = WTFMove(completionHandler)](auto result) mutable {
    5758        if (!result)
    5859            return completionHandler(WebCore::Exception { convertToExceptionCode(result.error()) });
    5960
    60         if (!weakConnection || !result.value().isValid())
     61        auto identifier = result.value();
     62        if (!identifier.isValid())
    6163            return completionHandler(WebCore::Exception { WebCore::UnknownError, "Connection is lost"_s });
    6264
    63         Ref<WebCore::FileSystemHandleImpl> impl = FileSystemStorageHandleProxy::create(result.value(), *weakConnection);
    64         return completionHandler(WTFMove(impl));
     65        auto connection = RefPtr<WebCore::FileSystemStorageConnection> { &WebProcess::singleton().fileSystemStorageConnection() };
     66        return completionHandler(std::pair { identifier, WTFMove(connection) });
    6567    });
    6668}

  • trunk/Source/WebKit/WebProcess/WebProcess.cpp

    r283116 r283271  
    6060#include "WebCookieJar.h"
    6161#include "WebCoreArgumentCoders.h"
     62#include "WebFileSystemStorageConnection.h"
    6263#include "WebFrame.h"
    6364#include "WebFrameNetworkingContext.h"
    … …  
    12081209#endif
    12091210    }
     1211
     1212    // Recreate a new connection with valid IPC connection on next operation.
     1213    if (m_fileSystemStorageConnection) {
     1214        m_fileSystemStorageConnection->connectionClosed();
     1215        m_fileSystemStorageConnection = nullptr;
     1216    }
     1217}
     1218
     1219WebFileSystemStorageConnection& WebProcess::fileSystemStorageConnection()
     1220{
     1221    if (!m_fileSystemStorageConnection)
     1222        m_fileSystemStorageConnection = WebFileSystemStorageConnection::create(ensureNetworkProcessConnection().connection());
     1223
     1224    return *m_fileSystemStorageConnection;
    12101225}
    12111226

  • trunk/Source/WebKit/WebProcess/WebProcess.h

    r282669 r283271  
    141141class WebCompiledContentRuleListData;
    142142class WebConnectionToUIProcess;
     143class WebFileSystemStorageConnection;
    143144class WebFrame;
    144145class WebLoaderStrategy;
    … …  
    246247    NetworkProcessConnection* existingNetworkProcessConnection() { return m_networkProcessConnection.get(); }
    247248    WebLoaderStrategy& webLoaderStrategy();
     249    WebFileSystemStorageConnection& fileSystemStorageConnection();
    248250
    249251#if ENABLE(GPU_PROCESS)
    … …  
    652654    RefPtr<NetworkProcessConnection> m_networkProcessConnection;
    653655    WebLoaderStrategy& m_webLoaderStrategy;
     656    RefPtr<WebFileSystemStorageConnection> m_fileSystemStorageConnection;
    654657
    655658#if ENABLE(GPU_PROCESS)
Note: See TracChangeset for help on using the changeset viewer.