Changeset 225760 in webkit


Ignore:
Timestamp:
Dec 11, 2017 3:24:51 PM (6 years ago)
Author:
Chris Dumez
Message:

Merge ServiceWorkerClientIdentifier into ServiceWorkerClientData
​https://bugs.webkit.org/show_bug.cgi?id=180669

Reviewed by Youenn Fablet.

Merge ServiceWorkerClientIdentifier into ServiceWorkerClientData, for consistency with
ServiceWorkerIdentifier / ServiceWorkerData, and start simplifying the postMessage() code.

Source/WebCore:

  • WebCore.xcodeproj/project.pbxproj:
  • dom/Document.cpp:

(WebCore::Document::setServiceWorkerConnection):

  • workers/service/SWClientConnection.h:
  • workers/service/ServiceWorker.cpp:

(WebCore::ServiceWorker::postMessage):

  • workers/service/ServiceWorkerClient.cpp:

(WebCore::ServiceWorkerClient::getOrCreate):
(WebCore::ServiceWorkerClient::ServiceWorkerClient):

  • workers/service/ServiceWorkerClient.h:

(WebCore::ServiceWorkerClient::identifier const):

  • workers/service/ServiceWorkerClientData.cpp:

(WebCore::ServiceWorkerClientData::isolatedCopy const):
(WebCore::ServiceWorkerClientData::from):

  • workers/service/ServiceWorkerClientData.h:

(WebCore::ServiceWorkerClientData::encode const):
(WebCore::ServiceWorkerClientData::decode):

  • workers/service/ServiceWorkerClientInformation.h: Removed.
  • workers/service/ServiceWorkerClients.cpp:

(WebCore::didFinishGetRequest):
(WebCore::ServiceWorkerClients::get):
(WebCore::matchAllCompleted):

  • workers/service/ServiceWorkerTypes.h:
  • workers/service/ServiceWorkerWindowClient.cpp:

(WebCore::ServiceWorkerWindowClient::ServiceWorkerWindowClient):

  • workers/service/ServiceWorkerWindowClient.h:
  • workers/service/context/SWContextManager.cpp:

(WebCore::SWContextManager::postMessageToServiceWorker):

  • workers/service/context/SWContextManager.h:
  • workers/service/context/ServiceWorkerThread.cpp:

(WebCore::ServiceWorkerThread::postMessageToServiceWorker):

  • workers/service/context/ServiceWorkerThread.h:
  • workers/service/server/SWServer.cpp:

(WebCore::SWServer::findClientByIdentifier):
(WebCore::SWServer::matchAll):
(WebCore::SWServer::claim):
(WebCore::SWServer::registerServiceWorkerClient):

  • workers/service/server/SWServer.h:
  • workers/service/server/SWServerToContextConnection.h:
  • workers/service/server/SWServerWorker.h:

Source/WebKit:

  • Scripts/webkit/messages.py:

(forward_declarations_and_headers):
(headers_for_type):

  • Shared/WebCoreArgumentCoders.cpp:

(IPC::ArgumentCoder<ServiceWorkerOrClientData>::encode):
(IPC::ArgumentCoder<ServiceWorkerOrClientData>::decode):

  • Shared/WebCoreArgumentCoders.h:
  • StorageProcess/ServiceWorker/WebSWServerConnection.cpp:

(WebKit::WebSWServerConnection::~WebSWServerConnection):
(WebKit::WebSWServerConnection::postMessageToServiceWorkerFromClient):
(WebKit::WebSWServerConnection::postMessageToServiceWorkerFromServiceWorker):
(WebKit::WebSWServerConnection::registerServiceWorkerClient):
(WebKit::WebSWServerConnection::unregisterServiceWorkerClient):

  • StorageProcess/ServiceWorker/WebSWServerConnection.h:
  • StorageProcess/ServiceWorker/WebSWServerConnection.messages.in:
  • StorageProcess/ServiceWorker/WebSWServerToContextConnection.cpp:

(WebKit::WebSWServerToContextConnection::matchAllCompleted):

  • StorageProcess/ServiceWorker/WebSWServerToContextConnection.h:
  • WebProcess/Storage/WebSWClientConnection.cpp:

(WebKit::WebSWClientConnection::registerServiceWorkerClient):
(WebKit::WebSWClientConnection::unregisterServiceWorkerClient):

  • WebProcess/Storage/WebSWClientConnection.h:
  • WebProcess/Storage/WebSWContextManagerConnection.cpp:

(WebKit::WebSWContextManagerConnection::postMessageToServiceWorker):
(WebKit::WebSWContextManagerConnection::matchAllCompleted):

  • WebProcess/Storage/WebSWContextManagerConnection.h:
  • WebProcess/Storage/WebSWContextManagerConnection.messages.in:
Location:
trunk/Source
Files:
1 deleted
35 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r225757 r225760  
     12017-12-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Merge ServiceWorkerClientIdentifier into ServiceWorkerClientData
     4        https://bugs.webkit.org/show_bug.cgi?id=180669
     5
     6        Reviewed by Youenn Fablet.
     7
     8        Merge ServiceWorkerClientIdentifier into ServiceWorkerClientData, for consistency with
     9        ServiceWorkerIdentifier / ServiceWorkerData, and start simplifying the postMessage() code.
     10
     11        * WebCore.xcodeproj/project.pbxproj:
     12        * dom/Document.cpp:
     13        (WebCore::Document::setServiceWorkerConnection):
     14        * workers/service/SWClientConnection.h:
     15        * workers/service/ServiceWorker.cpp:
     16        (WebCore::ServiceWorker::postMessage):
     17        * workers/service/ServiceWorkerClient.cpp:
     18        (WebCore::ServiceWorkerClient::getOrCreate):
     19        (WebCore::ServiceWorkerClient::ServiceWorkerClient):
     20        * workers/service/ServiceWorkerClient.h:
     21        (WebCore::ServiceWorkerClient::identifier const):
     22        * workers/service/ServiceWorkerClientData.cpp:
     23        (WebCore::ServiceWorkerClientData::isolatedCopy const):
     24        (WebCore::ServiceWorkerClientData::from):
     25        * workers/service/ServiceWorkerClientData.h:
     26        (WebCore::ServiceWorkerClientData::encode const):
     27        (WebCore::ServiceWorkerClientData::decode):
     28        * workers/service/ServiceWorkerClientInformation.h: Removed.
     29        * workers/service/ServiceWorkerClients.cpp:
     30        (WebCore::didFinishGetRequest):
     31        (WebCore::ServiceWorkerClients::get):
     32        (WebCore::matchAllCompleted):
     33        * workers/service/ServiceWorkerTypes.h:
     34        * workers/service/ServiceWorkerWindowClient.cpp:
     35        (WebCore::ServiceWorkerWindowClient::ServiceWorkerWindowClient):
     36        * workers/service/ServiceWorkerWindowClient.h:
     37        * workers/service/context/SWContextManager.cpp:
     38        (WebCore::SWContextManager::postMessageToServiceWorker):
     39        * workers/service/context/SWContextManager.h:
     40        * workers/service/context/ServiceWorkerThread.cpp:
     41        (WebCore::ServiceWorkerThread::postMessageToServiceWorker):
     42        * workers/service/context/ServiceWorkerThread.h:
     43        * workers/service/server/SWServer.cpp:
     44        (WebCore::SWServer::findClientByIdentifier):
     45        (WebCore::SWServer::matchAll):
     46        (WebCore::SWServer::claim):
     47        (WebCore::SWServer::registerServiceWorkerClient):
     48        * workers/service/server/SWServer.h:
     49        * workers/service/server/SWServerToContextConnection.h:
     50        * workers/service/server/SWServerWorker.h:
     51
    1522017-12-11  Daniel Bates  <dabates@apple.com>
    253

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

    r225745 r225760  
    10381038                41BF700C0FE86F49005E8DEC /* MessagePortChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 41BF700A0FE86F49005E8DEC /* MessagePortChannel.h */; settings = {ATTRIBUTES = (Private, ); }; };
    10391039                41BF70100FE86F61005E8DEC /* PlatformMessagePortChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 41BF700E0FE86F61005E8DEC /* PlatformMessagePortChannel.h */; };
    1040                 41C68AF51FD2279000AAA3B3 /* ServiceWorkerClientInformation.h in Headers */ = {isa = PBXBuildFile; fileRef = 41C68AF31FD21E8E00AAA3B3 /* ServiceWorkerClientInformation.h */; settings = {ATTRIBUTES = (Private, ); }; };
    10411040                41C760B10EDE03D300C1655F /* ScriptState.h in Headers */ = {isa = PBXBuildFile; fileRef = 41C760B00EDE03D300C1655F /* ScriptState.h */; settings = {ATTRIBUTES = (Private, ); }; };
    10421041                41CAD71E1EA090A100178164 /* VideoToolBoxEncoderFactory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 41CAD71C1EA0905700178164 /* VideoToolBoxEncoderFactory.cpp */; };
    … …  
    70527051                41BF700D0FE86F61005E8DEC /* PlatformMessagePortChannel.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = PlatformMessagePortChannel.cpp; path = default/PlatformMessagePortChannel.cpp; sourceTree = "<group>"; };
    70537052                41BF700E0FE86F61005E8DEC /* PlatformMessagePortChannel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = PlatformMessagePortChannel.h; path = default/PlatformMessagePortChannel.h; sourceTree = "<group>"; };
    7054                 41C68AF31FD21E8E00AAA3B3 /* ServiceWorkerClientInformation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ServiceWorkerClientInformation.h; sourceTree = "<group>"; };
    70557053                41C760B00EDE03D300C1655F /* ScriptState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScriptState.h; sourceTree = "<group>"; };
    70567054                41C7E1051E6A54360027B4DE /* CanvasCaptureMediaStreamTrack.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CanvasCaptureMediaStreamTrack.cpp; sourceTree = "<group>"; };
    … …  
    1733617334                                8379363E1FBBB0A500C8023C /* ServiceWorkerClientData.h */,
    1733717335                                837D46251FA2A8C50054E1FA /* ServiceWorkerClientIdentifier.h */,
    17338                                 41C68AF31FD21E8E00AAA3B3 /* ServiceWorkerClientInformation.h */,
    1733917336                                413FC4CD1FD1DD8C00541C4B /* ServiceWorkerClientQueryOptions.h */,
    1734017337                                46EF14211F97B7BA00C2A524 /* ServiceWorkerClients.cpp */,
    … …  
    2906429061                                8379363F1FBBB0B400C8023C /* ServiceWorkerClientData.h in Headers */,
    2906529062                                837D46271FA2A8CE0054E1FA /* ServiceWorkerClientIdentifier.h in Headers */,
    29066                                 41C68AF51FD2279000AAA3B3 /* ServiceWorkerClientInformation.h in Headers */,
    2906729063                                41519CB81FD1F02E007F623C /* ServiceWorkerClientQueryOptions.h in Headers */,
    2906829064                                46EF142C1F97B7D800C2A524 /* ServiceWorkerClients.h in Headers */,

  • trunk/Source/WebCore/dom/Document.cpp

    r225702 r225760  
    76367636
    76377637    auto controllingServiceWorkerIdentifier = activeServiceWorker() ? std::make_optional<ServiceWorkerIdentifier>(activeServiceWorker()->identifier()) : std::nullopt;
    7638     m_serviceWorkerConnection->registerServiceWorkerClient(topOrigin(), identifier(), ServiceWorkerClientData::from(*this), controllingServiceWorkerIdentifier);
     7638    m_serviceWorkerConnection->registerServiceWorkerClient(topOrigin(), ServiceWorkerClientData::from(*this, *serviceWorkerConnection), controllingServiceWorkerIdentifier);
    76397639}
    76407640#endif

  • trunk/Source/WebCore/workers/service/SWClientConnection.h

    r225531 r225760  
    8282    virtual void syncTerminateWorker(ServiceWorkerIdentifier) = 0;
    8383
    84     virtual void registerServiceWorkerClient(const SecurityOrigin& topOrigin, DocumentIdentifier, const ServiceWorkerClientData&, const std::optional<ServiceWorkerIdentifier>&) = 0;
     84    virtual void registerServiceWorkerClient(const SecurityOrigin& topOrigin, const ServiceWorkerClientData&, const std::optional<ServiceWorkerIdentifier>&) = 0;
    8585    virtual void unregisterServiceWorkerClient(DocumentIdentifier) = 0;
    8686

  • trunk/Source/WebCore/workers/service/ServiceWorker.cpp

    r225577 r225760  
    124124    }
    125125
    126     auto sourceClientData = ServiceWorkerClientData::from(context);
    127126    auto& connection = ServiceWorkerProvider::singleton().serviceWorkerConnectionForSession(context.sessionID());
     127    // FIXME: We should be able to send only the client identifier and look up the clientData on server side.
     128    auto sourceClientData = ServiceWorkerClientData::from(context, connection);
    128129    ServiceWorkerClientIdentifier sourceClientIdentifier { connection.serverConnectionIdentifier(), downcast<Document>(context).identifier() };
    129130    connection.postMessageToServiceWorker(identifier(), message.releaseReturnValue(), WTFMove(sourceClientIdentifier), WTFMove(sourceClientData));

  • trunk/Source/WebCore/workers/service/ServiceWorkerClient.cpp

    r225308 r225760  
    3939namespace WebCore {
    4040
    41 Ref<ServiceWorkerClient> ServiceWorkerClient::getOrCreate(ServiceWorkerGlobalScope& context, ServiceWorkerClientIdentifier identifier, ServiceWorkerClientData&& data)
     41Ref<ServiceWorkerClient> ServiceWorkerClient::getOrCreate(ServiceWorkerGlobalScope& context, ServiceWorkerClientData&& data)
    4242{
    43     if (auto* client = context.serviceWorkerClient(identifier))
     43    if (auto* client = context.serviceWorkerClient(data.identifier))
    4444        return *client;
    4545
    4646    if (data.type == ServiceWorkerClientType::Window)
    47         return ServiceWorkerWindowClient::create(context, identifier, WTFMove(data));
     47        return ServiceWorkerWindowClient::create(context, WTFMove(data));
    4848
    49     return adoptRef(*new ServiceWorkerClient { context, identifier, WTFMove(data) });
     49    return adoptRef(*new ServiceWorkerClient { context, WTFMove(data) });
    5050}
    5151
    52 ServiceWorkerClient::ServiceWorkerClient(ServiceWorkerGlobalScope& context, ServiceWorkerClientIdentifier identifier, ServiceWorkerClientData&& data)
     52ServiceWorkerClient::ServiceWorkerClient(ServiceWorkerGlobalScope& context, ServiceWorkerClientData&& data)
    5353    : ContextDestructionObserver(&context)
    54     , m_identifier(identifier)
    5554    , m_data(WTFMove(data))
    5655{

  • trunk/Source/WebCore/workers/service/ServiceWorkerClient.h

    r225308 r225760  
    4949    using FrameType = ServiceWorkerClientFrameType;
    5050
    51     static Ref<ServiceWorkerClient> getOrCreate(ServiceWorkerGlobalScope&, ServiceWorkerClientIdentifier, ServiceWorkerClientData&&);
     51    static Ref<ServiceWorkerClient> getOrCreate(ServiceWorkerGlobalScope&, ServiceWorkerClientData&&);
    5252
    5353    ~ServiceWorkerClient();
    … …  
    5858    String id() const;
    5959
    60     Identifier identifier() const { return m_identifier; }
     60    Identifier identifier() const { return m_data.identifier; }
    6161
    6262    ExceptionOr<void> postMessage(ScriptExecutionContext&, JSC::JSValue message, Vector<JSC::Strong<JSC::JSObject>>&& transfer);
    6363
    6464protected:
    65     ServiceWorkerClient(ServiceWorkerGlobalScope&, ServiceWorkerClientIdentifier, ServiceWorkerClientData&&);
     65    ServiceWorkerClient(ServiceWorkerGlobalScope&, ServiceWorkerClientData&&);
    6666
    67     ServiceWorkerClientIdentifier m_identifier;
    6867    ServiceWorkerClientData m_data;
    6968};

  • trunk/Source/WebCore/workers/service/ServiceWorkerClientData.cpp

    r225008 r225760  
    5757ServiceWorkerClientData ServiceWorkerClientData::isolatedCopy() const
    5858{
    59     return { type, frameType, url.isolatedCopy() };
     59    return { identifier, type, frameType, url.isolatedCopy() };
    6060}
    6161
    62 ServiceWorkerClientData ServiceWorkerClientData::from(ScriptExecutionContext& context)
     62ServiceWorkerClientData ServiceWorkerClientData::from(ScriptExecutionContext& context, SWClientConnection& connection)
    6363{
    6464    bool isDocument = is<Document>(context);
     65    RELEASE_ASSERT(isDocument); // We do not support dedicated workers as clients yet.
    6566
    6667    return {
     68        { connection.serverConnectionIdentifier(), downcast<Document>(context).identifier() },
    6769        isDocument ? ServiceWorkerClientType::Window : ServiceWorkerClientType::Worker,
    6870        toServiceWorkerClientFrameType(context),

  • trunk/Source/WebCore/workers/service/ServiceWorkerClientData.h

    r225008 r225760  
    3535namespace WebCore {
    3636
     37class SWClientConnection;
    3738class ScriptExecutionContext;
    3839
    3940struct ServiceWorkerClientData {
     41    ServiceWorkerClientIdentifier identifier;
    4042    ServiceWorkerClientType type;
    4143    ServiceWorkerClientFrameType frameType;
    … …  
    4446    ServiceWorkerClientData isolatedCopy() const;
    4547
    46     static ServiceWorkerClientData from(ScriptExecutionContext&);
     48    static ServiceWorkerClientData from(ScriptExecutionContext&, SWClientConnection&);
    4749
    4850    template<class Encoder> void encode(Encoder&) const;
    … …  
    5355void ServiceWorkerClientData::encode(Encoder& encoder) const
    5456{
    55     encoder << type << frameType << url;
     57    encoder << identifier << type << frameType << url;
    5658}
    5759
    … …  
    5961std::optional<ServiceWorkerClientData> ServiceWorkerClientData::decode(Decoder& decoder)
    6062{
     63    std::optional<ServiceWorkerClientIdentifier> identifier;
     64    decoder >> identifier;
     65    if (!identifier)
     66        return std::nullopt;
     67
    6168    std::optional<ServiceWorkerClientType> type;
    6269    decoder >> type;
    … …  
    7481        return std::nullopt;
    7582
    76     return { { WTFMove(*type), WTFMove(*frameType), WTFMove(*url) } };
     83    return { { WTFMove(*identifier), WTFMove(*type), WTFMove(*frameType), WTFMove(*url) } };
    7784}
     85
     86using ServiceWorkerClientsMatchAllCallback = WTF::CompletionHandler<void(Vector<ServiceWorkerClientData>&&)>;
    7887
    7988} // namespace WebCore

  • trunk/Source/WebCore/workers/service/ServiceWorkerClients.cpp

    r225537 r225760  
    3535namespace WebCore {
    3636
    37 static inline void didFinishGetRequest(ServiceWorkerGlobalScope& scope, DeferredPromise& promise, ServiceWorkerClientIdentifier identifier, ExceptionOr<std::optional<ServiceWorkerClientData>>&& clientData)
     37static inline void didFinishGetRequest(ServiceWorkerGlobalScope& scope, DeferredPromise& promise, ExceptionOr<std::optional<ServiceWorkerClientData>>&& clientData)
    3838{
    3939    if (clientData.hasException()) {
    … …  
    4747    }
    4848
    49     promise.resolve<IDLInterface<ServiceWorkerClient>>(ServiceWorkerClient::getOrCreate(scope, identifier, WTFMove(data.value())));
     49    promise.resolve<IDLInterface<ServiceWorkerClient>>(ServiceWorkerClient::getOrCreate(scope, WTFMove(data.value())));
    5050}
    5151
    … …  
    6666    callOnMainThread([promisePointer, serviceWorkerIdentifier, clientIdentifier] () {
    6767        auto connection = SWContextManager::singleton().connection();
    68         connection->findClientByIdentifier(serviceWorkerIdentifier, clientIdentifier, [promisePointer, serviceWorkerIdentifier, clientIdentifier] (auto&& clientData) {
    69             SWContextManager::singleton().postTaskToServiceWorker(serviceWorkerIdentifier, [promisePointer, clientIdentifier, data = crossThreadCopy(clientData)] (auto& context) mutable {
     68        connection->findClientByIdentifier(serviceWorkerIdentifier, clientIdentifier, [promisePointer, serviceWorkerIdentifier] (auto&& clientData) {
     69            SWContextManager::singleton().postTaskToServiceWorker(serviceWorkerIdentifier, [promisePointer, data = crossThreadCopy(clientData)] (auto& context) mutable {
    7070                if (auto promise = context.clients().m_pendingPromises.take(promisePointer))
    71                     didFinishGetRequest(context, *promise, clientIdentifier, WTFMove(data));
     71                    didFinishGetRequest(context, *promise, WTFMove(data));
    7272            });
    7373        });
    … …  
    7676
    7777
    78 static inline void matchAllCompleted(ServiceWorkerGlobalScope& scope, DeferredPromise& promise, Vector<ServiceWorkerClientInformation>&& clientsData)
     78static inline void matchAllCompleted(ServiceWorkerGlobalScope& scope, DeferredPromise& promise, Vector<ServiceWorkerClientData>&& clientsData)
    7979{
    80     auto clients = WTF::map(clientsData, [&] (auto&& client) {
    81         return ServiceWorkerClient::getOrCreate(scope, client.identifier, WTFMove(client.data));
     80    auto clients = WTF::map(clientsData, [&] (auto&& clientData) {
     81        return ServiceWorkerClient::getOrCreate(scope, WTFMove(clientData));
    8282    });
    8383    promise.resolve<IDLSequence<IDLInterface<ServiceWorkerClient>>>(WTFMove(clients));

  • trunk/Source/WebCore/workers/service/ServiceWorkerTypes.h

    r225455 r225760  
    3636namespace WebCore {
    3737
     38struct ServiceWorkerData;
     39struct ServiceWorkerClientData;
     40
    3841enum class ServiceWorkerRegistrationState {
    3942    Installing = 0,
    … …  
    7275
    7376using DocumentOrWorkerIdentifier = Variant<DocumentIdentifier, ServiceWorkerIdentifier>;
     77
     78using ServiceWorkerOrClientData = Variant<ServiceWorkerData, ServiceWorkerClientData>;
    7479
    7580} // namespace WebCore

  • trunk/Source/WebCore/workers/service/ServiceWorkerWindowClient.cpp

    r225308 r225760  
    3333namespace WebCore {
    3434
    35 ServiceWorkerWindowClient::ServiceWorkerWindowClient(ServiceWorkerGlobalScope& context, ServiceWorkerClientIdentifier identifier, ServiceWorkerClientData&& data)
    36     : ServiceWorkerClient(context, identifier, WTFMove(data))
     35ServiceWorkerWindowClient::ServiceWorkerWindowClient(ServiceWorkerGlobalScope& context, ServiceWorkerClientData&& data)
     36    : ServiceWorkerClient(context, WTFMove(data))
    3737{
    3838}

  • trunk/Source/WebCore/workers/service/ServiceWorkerWindowClient.h

    r225308 r225760  
    3838class ServiceWorkerWindowClient final : public ServiceWorkerClient {
    3939public:
    40     static Ref<ServiceWorkerWindowClient> create(ServiceWorkerGlobalScope& context, ServiceWorkerClientIdentifier identifier, ServiceWorkerClientData&& data)
     40    static Ref<ServiceWorkerWindowClient> create(ServiceWorkerGlobalScope& context, ServiceWorkerClientData&& data)
    4141    {
    42         return adoptRef(*new ServiceWorkerWindowClient(context, identifier, WTFMove(data)));
     42        return adoptRef(*new ServiceWorkerWindowClient(context, WTFMove(data)));
    4343    }
    4444
    … …  
    5050
    5151private:
    52     ServiceWorkerWindowClient(ServiceWorkerGlobalScope&, ServiceWorkerClientIdentifier, ServiceWorkerClientData&&);
     52    ServiceWorkerWindowClient(ServiceWorkerGlobalScope&, ServiceWorkerClientData&&);
    5353};
    5454

  • trunk/Source/WebCore/workers/service/context/SWContextManager.cpp

    r225462 r225760  
    6868}
    6969
    70 void SWContextManager::postMessageToServiceWorker(ServiceWorkerIdentifier destination, Ref<SerializedScriptValue>&& message, ServiceWorkerClientIdentifier sourceIdentifier, ServiceWorkerClientData&& sourceData)
    71 {
    72     auto* serviceWorker = m_workerMap.get(destination);
    73     ASSERT(serviceWorker);
    74     ASSERT(!serviceWorker->isTerminatingOrTerminated());
    75 
    76     // FIXME: We should pass valid MessagePortChannels.
    77     serviceWorker->thread().postMessageToServiceWorker(WTFMove(message), nullptr, sourceIdentifier, WTFMove(sourceData));
    78 }
    79 
    80 void SWContextManager::postMessageToServiceWorker(ServiceWorkerIdentifier destination, Ref<SerializedScriptValue>&& message, ServiceWorkerData&& sourceData)
     70void SWContextManager::postMessageToServiceWorker(ServiceWorkerIdentifier destination, Ref<SerializedScriptValue>&& message, ServiceWorkerOrClientData&& sourceData)
    8171{
    8272    auto* serviceWorker = m_workerMap.get(destination);

  • trunk/Source/WebCore/workers/service/context/SWContextManager.h

    r225537 r225760  
    2929
    3030#include "ExceptionOr.h"
    31 #include "ServiceWorkerClientInformation.h"
     31#include "ServiceWorkerClientData.h"
    3232#include "ServiceWorkerClientQueryOptions.h"
    3333#include "ServiceWorkerIdentifier.h"
    … …  
    6868    WEBCORE_EXPORT void registerServiceWorkerThreadForInstall(Ref<ServiceWorkerThreadProxy>&&);
    6969    WEBCORE_EXPORT ServiceWorkerThreadProxy* serviceWorkerThreadProxy(ServiceWorkerIdentifier) const;
    70     WEBCORE_EXPORT void postMessageToServiceWorker(ServiceWorkerIdentifier destination, Ref<SerializedScriptValue>&& message, ServiceWorkerClientIdentifier sourceIdentifier, ServiceWorkerClientData&& sourceData);
    71     WEBCORE_EXPORT void postMessageToServiceWorker(ServiceWorkerIdentifier destination, Ref<SerializedScriptValue>&& message, ServiceWorkerData&& sourceData);
     70    WEBCORE_EXPORT void postMessageToServiceWorker(ServiceWorkerIdentifier destination, Ref<SerializedScriptValue>&& message, ServiceWorkerOrClientData&& sourceData);
    7271    WEBCORE_EXPORT void fireInstallEvent(ServiceWorkerIdentifier);
    7372    WEBCORE_EXPORT void fireActivateEvent(ServiceWorkerIdentifier);

  • trunk/Source/WebCore/workers/service/context/ServiceWorkerThread.cpp

    r225716 r225760  
    112112}
    113113
    114 void ServiceWorkerThread::postMessageToServiceWorker(Ref<SerializedScriptValue>&& message, std::unique_ptr<MessagePortChannelArray>&& channels, ServiceWorkerClientIdentifier sourceIdentifier, ServiceWorkerClientData&& sourceData)
     114void ServiceWorkerThread::postMessageToServiceWorker(Ref<SerializedScriptValue>&& message, std::unique_ptr<MessagePortChannelArray>&& channels, ServiceWorkerOrClientData&& sourceData)
    115115{
    116     runLoop().postTask([channels = WTFMove(channels), message = WTFMove(message), sourceIdentifier, sourceData = sourceData.isolatedCopy()] (auto& context) mutable {
     116    runLoop().postTask([channels = WTFMove(channels), message = WTFMove(message), sourceData = WTFMove(sourceData)] (auto& context) mutable {
    117117        auto& serviceWorkerGlobalScope = downcast<ServiceWorkerGlobalScope>(context);
    118         RefPtr<ServiceWorkerClient> source = ServiceWorkerClient::getOrCreate(serviceWorkerGlobalScope, sourceIdentifier, WTFMove(sourceData));
    119         auto sourceOrigin = SecurityOrigin::create(source->url());
    120         fireMessageEvent(serviceWorkerGlobalScope, WTFMove(message), WTFMove(channels), ExtendableMessageEventSource { source }, WTFMove(sourceOrigin));
    121     });
    122 }
    123 
    124 void ServiceWorkerThread::postMessageToServiceWorker(Ref<SerializedScriptValue>&& message, std::unique_ptr<MessagePortChannelArray>&& channels, ServiceWorkerData&& sourceData)
    125 {
    126     runLoop().postTask([channels = WTFMove(channels), message = WTFMove(message), sourceData = sourceData.isolatedCopy()] (auto& context) mutable {
    127         auto& serviceWorkerGlobalScope = downcast<ServiceWorkerGlobalScope>(context);
    128         RefPtr<ServiceWorker> source = ServiceWorker::getOrCreate(serviceWorkerGlobalScope, WTFMove(sourceData));
    129         auto sourceOrigin = SecurityOrigin::create(source->scriptURL());
    130         fireMessageEvent(downcast<ServiceWorkerGlobalScope>(context), WTFMove(message), WTFMove(channels), ExtendableMessageEventSource { source }, WTFMove(sourceOrigin));
     118        RefPtr<SecurityOrigin> sourceOrigin;
     119        ExtendableMessageEventSource source;
     120        if (WTF::holds_alternative<ServiceWorkerClientData>(sourceData)) {
     121            RefPtr<ServiceWorkerClient> sourceClient = ServiceWorkerClient::getOrCreate(serviceWorkerGlobalScope, WTFMove(WTF::get<ServiceWorkerClientData>(sourceData)));
     122            sourceOrigin = SecurityOrigin::create(sourceClient->url());
     123            source = WTFMove(sourceClient);
     124        } else {
     125            RefPtr<ServiceWorker> sourceWorker = ServiceWorker::getOrCreate(serviceWorkerGlobalScope, WTFMove(WTF::get<ServiceWorkerData>(sourceData)));
     126            sourceOrigin = SecurityOrigin::create(sourceWorker->scriptURL());
     127            source = WTFMove(sourceWorker);
     128        }
     129        fireMessageEvent(serviceWorkerGlobalScope, WTFMove(message), WTFMove(channels), ExtendableMessageEventSource { source }, sourceOrigin.releaseNonNull());
    131130    });
    132131}

  • trunk/Source/WebCore/workers/service/context/ServiceWorkerThread.h

    r225716 r225760  
    5959    WEBCORE_EXPORT void postFetchTask(Ref<ServiceWorkerFetch::Client>&&, ResourceRequest&&, FetchOptions&&);
    6060    WEBCORE_EXPORT void postFetchTask(Ref<ServiceWorkerFetch::Client>&&, std::optional<ServiceWorkerClientIdentifier>&&, ResourceRequest&&, FetchOptions&&);
    61     WEBCORE_EXPORT void postMessageToServiceWorker(Ref<SerializedScriptValue>&&, std::unique_ptr<MessagePortChannelArray>&&, ServiceWorkerClientIdentifier sourceIdentifier, ServiceWorkerClientData&& sourceData);
    62     WEBCORE_EXPORT void postMessageToServiceWorker(Ref<SerializedScriptValue>&&, std::unique_ptr<MessagePortChannelArray>&&, ServiceWorkerData&& sourceData);
     61    WEBCORE_EXPORT void postMessageToServiceWorker(Ref<SerializedScriptValue>&&, std::unique_ptr<MessagePortChannelArray>&&, ServiceWorkerOrClientData&& sourceData);
    6362
    6463    void fireInstallEvent();

  • trunk/Source/WebCore/workers/service/server/SWServer.cpp

    r225717 r225760  
    347347    });
    348348
    349     return (position != notFound) ? std::make_optional(clients[position].data) : std::nullopt;
     349    return (position != notFound) ? std::make_optional(clients[position]) : std::nullopt;
    350350}
    351351
    … …  
    359359
    360360    if (!options.includeUncontrolled) {
    361         clients.removeAllMatching([&] (const auto& client) {
    362             return worker.identifier() != m_clientToControllingWorker.get(client.identifier);
     361        clients.removeAllMatching([&] (const auto& clientData) {
     362            return worker.identifier() != m_clientToControllingWorker.get(clientData.identifier);
    363363        });
    364364    }
    365365    if (options.type != ServiceWorkerClientType::All) {
    366         clients.removeAllMatching([&] (const auto& client) {
    367             return options.type != client.data.type;
     366        clients.removeAllMatching([&] (const auto& clientData) {
     367            return options.type != clientData.type;
    368368        });
    369369    }
    … …  
    379379
    380380    auto& clients = iterator->value.clients;
    381     for (auto& client : clients) {
    382         auto* registration = doRegistrationMatching(origin.topOrigin, client.data.url);
     381    for (auto& clientData : clients) {
     382        auto* registration = doRegistrationMatching(origin.topOrigin, clientData.url);
    383383        if (!(registration && registration->key() == worker.registrationKey()))
    384384            continue;
    385385
    386         auto result = m_clientToControllingWorker.add(client.identifier, worker.identifier());
     386        auto result = m_clientToControllingWorker.add(clientData.identifier, worker.identifier());
    387387        if (!result.isNewEntry) {
    388388            if (result.iterator->value == worker.identifier())
    389389                continue;
    390390            if (auto* controllingRegistration = registrationFromServiceWorkerIdentifier(result.iterator->value))
    391                 controllingRegistration->removeClientUsingRegistration(client.identifier);
     391                controllingRegistration->removeClientUsingRegistration(clientData.identifier);
    392392            result.iterator->value = worker.identifier();
    393393        }
    394         registration->controlClient(client.identifier);
     394        registration->controlClient(clientData.identifier);
    395395    }
    396396}
    … …  
    688688}
    689689
    690 void SWServer::registerServiceWorkerClient(ClientOrigin&& clientOrigin, ServiceWorkerClientIdentifier clientIdentifier, ServiceWorkerClientData&& data, const std::optional<ServiceWorkerIdentifier>& controllingServiceWorkerIdentifier)
     690void SWServer::registerServiceWorkerClient(ClientOrigin&& clientOrigin, ServiceWorkerClientData&& data, const std::optional<ServiceWorkerIdentifier>& controllingServiceWorkerIdentifier)
    691691{
    692692    auto& clientsData = m_clients.ensure(WTFMove(clientOrigin), [] {
    … …  
    694694    }).iterator->value;
    695695
    696     clientsData.clients.append(ServiceWorkerClientInformation { clientIdentifier, WTFMove(data) });
    697     if (clientsData.terminateServiceWorkersTimer)
    698         clientsData.terminateServiceWorkersTimer = nullptr;
     696    auto clientIdentifier = data.identifier;
     697    clientsData.clients.append(WTFMove(data));
     698    clientsData.terminateServiceWorkersTimer = nullptr;
    699699
    700700    if (!controllingServiceWorkerIdentifier)

  • trunk/Source/WebCore/workers/service/server/SWServer.h

    r225717 r225760  
    160160    WEBCORE_EXPORT static HashSet<SWServer*>& allServers();
    161161
    162     WEBCORE_EXPORT void registerServiceWorkerClient(ClientOrigin&&, ServiceWorkerClientIdentifier, ServiceWorkerClientData&&, const std::optional<ServiceWorkerIdentifier>& controllingServiceWorkerIdentifier);
     162    WEBCORE_EXPORT void registerServiceWorkerClient(ClientOrigin&&, ServiceWorkerClientData&&, const std::optional<ServiceWorkerIdentifier>& controllingServiceWorkerIdentifier);
    163163    WEBCORE_EXPORT void unregisterServiceWorkerClient(const ClientOrigin&, ServiceWorkerClientIdentifier);
    164164
    … …  
    208208
    209209    struct Clients {
    210         Vector<ServiceWorkerClientInformation> clients;
     210        Vector<ServiceWorkerClientData> clients;
    211211        std::unique_ptr<Timer> terminateServiceWorkersTimer;
    212212    };

  • trunk/Source/WebCore/workers/service/server/SWServerToContextConnection.h

    r225703 r225760  
    4242struct ServiceWorkerClientData;
    4343struct ServiceWorkerClientIdentifier;
    44 struct ServiceWorkerClientInformation;
    4544struct ServiceWorkerContextData;
    4645struct ServiceWorkerJobDataIdentifier;
    … …  
    5958    virtual void syncTerminateWorker(ServiceWorkerIdentifier) = 0;
    6059    virtual void findClientByIdentifierCompleted(uint64_t requestIdentifier, const std::optional<ServiceWorkerClientData>&, bool hasSecurityError) = 0;
    61     virtual void matchAllCompleted(uint64_t requestIdentifier, const Vector<ServiceWorkerClientInformation>&) = 0;
     60    virtual void matchAllCompleted(uint64_t requestIdentifier, const Vector<ServiceWorkerClientData>&) = 0;
    6261    virtual void claimCompleted(uint64_t requestIdentifier) = 0;
    6362    virtual void didFinishSkipWaiting(uint64_t callbackID) = 0;

  • trunk/Source/WebCore/workers/service/server/SWServerWorker.h

    r225537 r225760  
    2828#if ENABLE(SERVICE_WORKER)
    2929
    30 #include "ServiceWorkerClientInformation.h"
     30#include "ServiceWorkerClientData.h"
    3131#include "ServiceWorkerData.h"
    3232#include "ServiceWorkerIdentifier.h"

  • trunk/Source/WebKit/ChangeLog

    r225759 r225760  
     12017-12-11  Chris Dumez  <cdumez@apple.com>
     2
     3        Merge ServiceWorkerClientIdentifier into ServiceWorkerClientData
     4        https://bugs.webkit.org/show_bug.cgi?id=180669
     5
     6        Reviewed by Youenn Fablet.
     7
     8        Merge ServiceWorkerClientIdentifier into ServiceWorkerClientData, for consistency with
     9        ServiceWorkerIdentifier / ServiceWorkerData, and start simplifying the postMessage() code.
     10
     11        * Scripts/webkit/messages.py:
     12        (forward_declarations_and_headers):
     13        (headers_for_type):
     14        * Shared/WebCoreArgumentCoders.cpp:
     15        (IPC::ArgumentCoder<ServiceWorkerOrClientData>::encode):
     16        (IPC::ArgumentCoder<ServiceWorkerOrClientData>::decode):
     17        * Shared/WebCoreArgumentCoders.h:
     18        * StorageProcess/ServiceWorker/WebSWServerConnection.cpp:
     19        (WebKit::WebSWServerConnection::~WebSWServerConnection):
     20        (WebKit::WebSWServerConnection::postMessageToServiceWorkerFromClient):
     21        (WebKit::WebSWServerConnection::postMessageToServiceWorkerFromServiceWorker):
     22        (WebKit::WebSWServerConnection::registerServiceWorkerClient):
     23        (WebKit::WebSWServerConnection::unregisterServiceWorkerClient):
     24        * StorageProcess/ServiceWorker/WebSWServerConnection.h:
     25        * StorageProcess/ServiceWorker/WebSWServerConnection.messages.in:
     26        * StorageProcess/ServiceWorker/WebSWServerToContextConnection.cpp:
     27        (WebKit::WebSWServerToContextConnection::matchAllCompleted):
     28        * StorageProcess/ServiceWorker/WebSWServerToContextConnection.h:
     29        * WebProcess/Storage/WebSWClientConnection.cpp:
     30        (WebKit::WebSWClientConnection::registerServiceWorkerClient):
     31        (WebKit::WebSWClientConnection::unregisterServiceWorkerClient):
     32        * WebProcess/Storage/WebSWClientConnection.h:
     33        * WebProcess/Storage/WebSWContextManagerConnection.cpp:
     34        (WebKit::WebSWContextManagerConnection::postMessageToServiceWorker):
     35        (WebKit::WebSWContextManagerConnection::matchAllCompleted):
     36        * WebProcess/Storage/WebSWContextManagerConnection.h:
     37        * WebProcess/Storage/WebSWContextManagerConnection.messages.in:
     38
    1392017-12-11  Youenn Fablet  <youenn@apple.com>
    240

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

    r225311 r225760  
    187187        'WebCore::DocumentIdentifier',
    188188        'WebCore::ServiceWorkerIdentifier',
     189        'WebCore::ServiceWorkerOrClientData',
    189190        'WebCore::ServiceWorkerRegistrationIdentifier',
    190191        'WebCore::SWServerConnectionIdentifier',
    … …  
    383384        'WebCore::RecentSearch': ['<WebCore/SearchPopupMenu.h>'],
    384385        'WebCore::SWServerConnectionIdentifier': ['<WebCore/ServiceWorkerTypes.h>'],
     386        'WebCore::ServiceWorkerOrClientData': ['<WebCore/ServiceWorkerTypes.h>', '<WebCore/ServiceWorkerClientData.h>', '<WebCore/ServiceWorkerData.h>'],
    385387        'WebCore::ServiceWorkerRegistrationIdentifier': ['<WebCore/ServiceWorkerTypes.h>'],
    386388        'WebCore::ServiceWorkerRegistrationState': ['<WebCore/ServiceWorkerTypes.h>'],

  • trunk/Source/WebKit/Shared/WebCoreArgumentCoders.cpp

    r225294 r225760  
    6666#include <WebCore/ScrollingCoordinator.h>
    6767#include <WebCore/SearchPopupMenu.h>
     68#include <WebCore/ServiceWorkerClientData.h>
     69#include <WebCore/ServiceWorkerData.h>
    6870#include <WebCore/TextCheckerClient.h>
    6971#include <WebCore/TextIndicator.h>
    … …  
    26852687#endif
    26862688
     2689#if ENABLE(SERVICE_WORKER)
     2690void ArgumentCoder<ServiceWorkerOrClientData>::encode(Encoder& encoder, const ServiceWorkerOrClientData& data)
     2691{
     2692    bool isServiceWorkerData = WTF::holds_alternative<ServiceWorkerData>(data);
     2693    encoder << isServiceWorkerData;
     2694    if (isServiceWorkerData)
     2695        encoder << WTF::get<ServiceWorkerData>(data);
     2696    else
     2697        encoder << WTF::get<ServiceWorkerClientData>(data);
     2698}
     2699
     2700bool ArgumentCoder<ServiceWorkerOrClientData>::decode(Decoder& decoder, ServiceWorkerOrClientData& data)
     2701{
     2702    bool isServiceWorkerData;
     2703    if (!decoder.decode(isServiceWorkerData))
     2704        return false;
     2705    if (isServiceWorkerData) {
     2706        std::optional<ServiceWorkerData> workerData;
     2707        decoder >> workerData;
     2708        if (!workerData)
     2709            return false;
     2710
     2711        data = WTFMove(*workerData);
     2712    } else {
     2713        std::optional<ServiceWorkerClientData> clientData;
     2714        decoder >> clientData;
     2715        if (!clientData)
     2716            return false;
     2717
     2718        data = WTFMove(*clientData);
     2719    }
     2720    return true;
     2721}
     2722#endif
     2723
    26872724#if ENABLE(CSS_SCROLL_SNAP)
    26882725

  • trunk/Source/WebKit/Shared/WebCoreArgumentCoders.h

    r224880 r225760  
    4040#include <WebCore/RealtimeMediaSource.h>
    4141#include <WebCore/ScrollSnapOffsetsInfo.h>
     42#include <WebCore/ServiceWorkerTypes.h>
    4243#include <WebCore/StoredCredentialsPolicy.h>
    4344#include <WebCore/WorkerType.h>
    … …  
    668669#endif
    669670
     671#if ENABLE(SERVICE_WORKER)
     672
     673template<> struct ArgumentCoder<WebCore::ServiceWorkerOrClientData> {
     674    static void encode(Encoder&, const WebCore::ServiceWorkerOrClientData&);
     675    static bool decode(Decoder&, WebCore::ServiceWorkerOrClientData&);
     676};
     677
     678#endif
     679
    670680#if ENABLE(CSS_SCROLL_SNAP)
    671681

  • trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.cpp

    r225758 r225760  
    6969    StorageProcess::singleton().unregisterSWServerConnection(*this);
    7070    for (auto keyValue : m_clientOrigins)
    71         server().unregisterServiceWorkerClient(keyValue.value, ServiceWorkerClientIdentifier { identifier(), keyValue.key });
     71        server().unregisterServiceWorkerClient(keyValue.value, keyValue.key);
    7272}
    7373
    … …  
    128128}
    129129
    130 void WebSWServerConnection::postMessageToServiceWorkerFromClient(ServiceWorkerIdentifier destinationIdentifier, IPC::DataReference&& message, ServiceWorkerClientIdentifier sourceIdentifier, ServiceWorkerClientData&& sourceData)
     130// FIXME: We should be able to only pass in the ServiceWorkerClientIdentifier here and look up the clientData from the SWServer.
     131void WebSWServerConnection::postMessageToServiceWorkerFromClient(ServiceWorkerIdentifier destinationIdentifier, IPC::DataReference&& message, ServiceWorkerClientIdentifier, ServiceWorkerClientData&& sourceData)
    131132{
    132133    // It's possible this specific worker cannot be re-run (e.g. its registration has been removed)
    133     server().runServiceWorkerIfNecessary(destinationIdentifier, [destinationIdentifier, message = message.vector(), sourceIdentifier, sourceData = WTFMove(sourceData)](bool success, auto& contextConnection) mutable {
     134    server().runServiceWorkerIfNecessary(destinationIdentifier, [destinationIdentifier, message = message.vector(), sourceData = WTFMove(sourceData)](bool success, auto& contextConnection) mutable {
    134135        if (success)
    135             sendToContextProcess(contextConnection, Messages::WebSWContextManagerConnection::PostMessageToServiceWorkerFromClient { destinationIdentifier, message, sourceIdentifier, WTFMove(sourceData) });
     136            sendToContextProcess(contextConnection, Messages::WebSWContextManagerConnection::PostMessageToServiceWorker { destinationIdentifier, message, WTFMove(sourceData) });
    136137    });
    137138}
    … …  
    148149            return;
    149150
    150         sendToContextProcess(contextConnection, Messages::WebSWContextManagerConnection::PostMessageToServiceWorkerFromServiceWorker { destinationIdentifier, message, WTFMove(sourceData) });
     151        sendToContextProcess(contextConnection, Messages::WebSWContextManagerConnection::PostMessageToServiceWorker { destinationIdentifier, message, WTFMove(sourceData) });
    151152    });
    152153}
    … …  
    211212}
    212213
    213 void WebSWServerConnection::registerServiceWorkerClient(SecurityOriginData&& topOrigin, DocumentIdentifier contextIdentifier, ServiceWorkerClientData&& data, const std::optional<ServiceWorkerIdentifier>& controllingServiceWorkerIdentifier)
     214void WebSWServerConnection::registerServiceWorkerClient(SecurityOriginData&& topOrigin, ServiceWorkerClientData&& data, const std::optional<ServiceWorkerIdentifier>& controllingServiceWorkerIdentifier)
    214215{
    215216    auto clientOrigin = ClientOrigin { WTFMove(topOrigin), SecurityOriginData::fromSecurityOrigin(SecurityOrigin::create(data.url)) };
    216     m_clientOrigins.add(contextIdentifier, clientOrigin);
    217     server().registerServiceWorkerClient(WTFMove(clientOrigin), ServiceWorkerClientIdentifier { this->identifier(), contextIdentifier } , WTFMove(data), controllingServiceWorkerIdentifier);
    218 }
    219 
    220 void WebSWServerConnection::unregisterServiceWorkerClient(DocumentIdentifier contextIdentifier)
    221 {
    222     auto iterator = m_clientOrigins.find(contextIdentifier);
     217    m_clientOrigins.add(data.identifier, clientOrigin);
     218    server().registerServiceWorkerClient(WTFMove(clientOrigin), WTFMove(data), controllingServiceWorkerIdentifier);
     219}
     220
     221void WebSWServerConnection::unregisterServiceWorkerClient(const ServiceWorkerClientIdentifier& clientIdentifier)
     222{
     223    auto iterator = m_clientOrigins.find(clientIdentifier);
    223224    if (iterator == m_clientOrigins.end())
    224225        return;
    225226
    226     server().unregisterServiceWorkerClient(iterator->value, ServiceWorkerClientIdentifier { this->identifier(), contextIdentifier });
     227    server().unregisterServiceWorkerClient(iterator->value, clientIdentifier);
    227228    m_clientOrigins.remove(iterator);
    228229}

  • trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.h

    r225665 r225760  
    9090    void getRegistrations(uint64_t registrationMatchRequestIdentifier, const WebCore::SecurityOriginData& topOrigin, const WebCore::URL& clientURL);
    9191
    92     void registerServiceWorkerClient(WebCore::SecurityOriginData&& topOrigin, WebCore::DocumentIdentifier, WebCore::ServiceWorkerClientData&&, const std::optional<WebCore::ServiceWorkerIdentifier>&);
    93     void unregisterServiceWorkerClient(WebCore::DocumentIdentifier);
     92    void registerServiceWorkerClient(WebCore::SecurityOriginData&& topOrigin, WebCore::ServiceWorkerClientData&&, const std::optional<WebCore::ServiceWorkerIdentifier>&);
     93    void unregisterServiceWorkerClient(const WebCore::ServiceWorkerClientIdentifier&);
    9494
    9595    IPC::Connection* messageSenderConnection() final { return m_contentConnection.ptr(); }
    … …  
    101101    PAL::SessionID m_sessionID;
    102102    Ref<IPC::Connection> m_contentConnection;
    103     HashMap<WebCore::DocumentIdentifier, WebCore::ClientOrigin> m_clientOrigins;
     103    HashMap<WebCore::ServiceWorkerClientIdentifier, WebCore::ClientOrigin> m_clientOrigins;
    104104};
    105105

  • trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerConnection.messages.in

    r225665 r225760  
    3131
    3232    StartFetch(uint64_t identifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody)
     33
     34    # FIXME: We should be able to merge the 2 following messages and use a DocumentOrWorkerIdentifier as source identifier.
    3335    PostMessageToServiceWorkerFromClient(WebCore::ServiceWorkerIdentifier destinationServiceWorkerIdentifier, IPC::DataReference message, struct WebCore::ServiceWorkerClientIdentifier sourceIdentifier, struct WebCore::ServiceWorkerClientData sourceData)
    3436    PostMessageToServiceWorkerFromServiceWorker(WebCore::ServiceWorkerIdentifier destinationServiceWorkerIdentifier, IPC::DataReference message, struct WebCore::ServiceWorkerIdentifier sourceIdentifier)
    … …  
    3941    WhenRegistrationReady(uint64_t serviceRegistrationMatchRequestIdentifier, struct WebCore::SecurityOriginData topOrigin, WebCore::URL clientURL)
    4042    GetRegistrations(uint64_t serviceRegistrationMatchRequestIdentifier, struct WebCore::SecurityOriginData topOrigin, WebCore::URL clientURL)
    41     RegisterServiceWorkerClient(struct WebCore::SecurityOriginData topOrigin, WebCore::DocumentIdentifier identifier, struct WebCore::ServiceWorkerClientData data, std::optional<WebCore::ServiceWorkerIdentifier> controllingServiceWorkerIdentifier)
    42     UnregisterServiceWorkerClient(WebCore::DocumentIdentifier identifier)
     43    RegisterServiceWorkerClient(struct WebCore::SecurityOriginData topOrigin, struct WebCore::ServiceWorkerClientData data, std::optional<WebCore::ServiceWorkerIdentifier> controllingServiceWorkerIdentifier)
     44    UnregisterServiceWorkerClient(struct WebCore::ServiceWorkerClientIdentifier identifier)
    4345
    4446    SyncTerminateWorker(WebCore::ServiceWorkerIdentifier workerIdentifier) -> ()

  • trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerToContextConnection.cpp

    r225703 r225760  
    8787}
    8888
    89 void WebSWServerToContextConnection::matchAllCompleted(uint64_t requestIdentifier, const Vector<ServiceWorkerClientInformation>& clientsData)
     89void WebSWServerToContextConnection::matchAllCompleted(uint64_t requestIdentifier, const Vector<ServiceWorkerClientData>& clientsData)
    9090{
    9191    send(Messages::WebSWContextManagerConnection::MatchAllCompleted { requestIdentifier, clientsData });

  • trunk/Source/WebKit/StorageProcess/ServiceWorker/WebSWServerToContextConnection.h

    r225703 r225760  
    6262    void syncTerminateWorker(WebCore::ServiceWorkerIdentifier) final;
    6363    void findClientByIdentifierCompleted(uint64_t requestIdentifier, const std::optional<WebCore::ServiceWorkerClientData>&, bool hasSecurityError) final;
    64     void matchAllCompleted(uint64_t requestIdentifier, const Vector<WebCore::ServiceWorkerClientInformation>&) final;
     64    void matchAllCompleted(uint64_t requestIdentifier, const Vector<WebCore::ServiceWorkerClientData>&) final;
    6565    void claimCompleted(uint64_t requestIdentifier) final;
    6666    void didFinishSkipWaiting(uint64_t callbackID) final;

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

    r225717 r225760  
    9393}
    9494
    95 void WebSWClientConnection::registerServiceWorkerClient(const SecurityOrigin& topOrigin, WebCore::DocumentIdentifier contextIdentifier, const WebCore::ServiceWorkerClientData& data, const std::optional<WebCore::ServiceWorkerIdentifier>& controllingServiceWorkerIdentifier)
    96 {
    97     send(Messages::WebSWServerConnection::RegisterServiceWorkerClient { SecurityOriginData::fromSecurityOrigin(topOrigin), contextIdentifier, data, controllingServiceWorkerIdentifier });
    98 }
    99 
    100 void WebSWClientConnection::unregisterServiceWorkerClient(WebCore::DocumentIdentifier contextIdentifier)
    101 {
    102     send(Messages::WebSWServerConnection::UnregisterServiceWorkerClient { contextIdentifier });
     95void WebSWClientConnection::registerServiceWorkerClient(const SecurityOrigin& topOrigin, const WebCore::ServiceWorkerClientData& data, const std::optional<WebCore::ServiceWorkerIdentifier>& controllingServiceWorkerIdentifier)
     96{
     97    send(Messages::WebSWServerConnection::RegisterServiceWorkerClient { SecurityOriginData::fromSecurityOrigin(topOrigin), data, controllingServiceWorkerIdentifier });
     98}
     99
     100void WebSWClientConnection::unregisterServiceWorkerClient(DocumentIdentifier contextIdentifier)
     101{
     102    send(Messages::WebSWServerConnection::UnregisterServiceWorkerClient { ServiceWorkerClientIdentifier { serverConnectionIdentifier(), contextIdentifier } });
    103103}
    104104

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

    r225717 r225760  
    7676    void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, Ref<WebCore::SerializedScriptValue>&&, WebCore::ServiceWorkerClientIdentifier sourceIdentifier, WebCore::ServiceWorkerClientData&& source) final;
    7777    void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, Ref<WebCore::SerializedScriptValue>&&, WebCore::ServiceWorkerIdentifier sourceWorkerIdentifier) final;
    78     void registerServiceWorkerClient(const WebCore::SecurityOrigin& topOrigin, WebCore::DocumentIdentifier, const WebCore::ServiceWorkerClientData&, const std::optional<WebCore::ServiceWorkerIdentifier>&) final;
     78    void registerServiceWorkerClient(const WebCore::SecurityOrigin& topOrigin, const WebCore::ServiceWorkerClientData&, const std::optional<WebCore::ServiceWorkerIdentifier>&) final;
    7979    void unregisterServiceWorkerClient(WebCore::DocumentIdentifier) final;
    8080

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

    r225716 r225760  
    173173}
    174174
    175 void WebSWContextManagerConnection::postMessageToServiceWorkerFromClient(ServiceWorkerIdentifier destinationIdentifier, const IPC::DataReference& message, ServiceWorkerClientIdentifier sourceIdentifier, ServiceWorkerClientData&& sourceData)
    176 {
    177     SWContextManager::singleton().postMessageToServiceWorker(destinationIdentifier, SerializedScriptValue::adopt(message.vector()), sourceIdentifier, WTFMove(sourceData));
    178 }
    179 
    180 void WebSWContextManagerConnection::postMessageToServiceWorkerFromServiceWorker(ServiceWorkerIdentifier destinationIdentifier, const IPC::DataReference& message, ServiceWorkerData&& sourceData)
     175void WebSWContextManagerConnection::postMessageToServiceWorker(ServiceWorkerIdentifier destinationIdentifier, const IPC::DataReference& message, ServiceWorkerOrClientData&& sourceData)
    181176{
    182177    SWContextManager::singleton().postMessageToServiceWorker(destinationIdentifier, SerializedScriptValue::adopt(message.vector()), WTFMove(sourceData));
    … …  
    262257}
    263258
    264 void WebSWContextManagerConnection::matchAllCompleted(uint64_t requestIdentifier, Vector<ServiceWorkerClientInformation>&& clientsData)
     259void WebSWContextManagerConnection::matchAllCompleted(uint64_t requestIdentifier, Vector<ServiceWorkerClientData>&& clientsData)
    265260{
    266261    if (auto callback = m_matchAllRequests.take(requestIdentifier))

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

    r225716 r225760  
    3232#include "WebSWContextManagerConnectionMessages.h"
    3333#include <WebCore/SWContextManager.h>
    34 #include <WebCore/ServiceWorkerClientInformation.h>
     34#include <WebCore/ServiceWorkerClientData.h>
    3535#include <WebCore/ServiceWorkerTypes.h>
    3636
    … …  
    7878    void installServiceWorker(const WebCore::ServiceWorkerContextData&, PAL::SessionID);
    7979    void startFetch(WebCore::SWServerConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier, WebCore::ResourceRequest&&, WebCore::FetchOptions&&, IPC::FormDataReference&&);
    80     void postMessageToServiceWorkerFromClient(WebCore::ServiceWorkerIdentifier destinationIdentifier, const IPC::DataReference& message, WebCore::ServiceWorkerClientIdentifier sourceIdentifier, WebCore::ServiceWorkerClientData&& sourceData);
    81     void postMessageToServiceWorkerFromServiceWorker(WebCore::ServiceWorkerIdentifier destination, const IPC::DataReference& message, WebCore::ServiceWorkerData&& sourceData);
     80    void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, const IPC::DataReference& message, WebCore::ServiceWorkerOrClientData&& sourceData);
    8281    void fireInstallEvent(WebCore::ServiceWorkerIdentifier);
    8382    void fireActivateEvent(WebCore::ServiceWorkerIdentifier);
    … …  
    8584    void syncTerminateWorker(WebCore::ServiceWorkerIdentifier, Ref<Messages::WebSWContextManagerConnection::SyncTerminateWorker::DelayedReply>&&);
    8685    void findClientByIdentifierCompleted(uint64_t requestIdentifier, std::optional<WebCore::ServiceWorkerClientData>&&, bool hasSecurityError);
    87     void matchAllCompleted(uint64_t matchAllRequestIdentifier, Vector<WebCore::ServiceWorkerClientInformation>&&);
     86    void matchAllCompleted(uint64_t matchAllRequestIdentifier, Vector<WebCore::ServiceWorkerClientData>&&);
    8887    void claimCompleted(uint64_t claimRequestIdentifier);
    8988    void didFinishSkipWaiting(uint64_t callbackID);

  • trunk/Source/WebKit/WebProcess/Storage/WebSWContextManagerConnection.messages.in

    r225716 r225760  
    2626    InstallServiceWorker(struct WebCore::ServiceWorkerContextData contextData, PAL::SessionID sessionID)
    2727    StartFetch(WebCore::SWServerConnectionIdentifier serverConnectionIdentifier, uint64_t fetchIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier, WebCore::ResourceRequest request, struct WebCore::FetchOptions options, IPC::FormDataReference requestBody)
    28     PostMessageToServiceWorkerFromClient(WebCore::ServiceWorkerIdentifier destinationIdentifier, IPC::DataReference message, struct WebCore::ServiceWorkerClientIdentifier sourceIdentifier, struct WebCore::ServiceWorkerClientData sourceData)
    29     PostMessageToServiceWorkerFromServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, IPC::DataReference message, struct WebCore::ServiceWorkerData sourceData)
     28    PostMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destinationIdentifier, IPC::DataReference message, WebCore::ServiceWorkerOrClientData sourceData)
    3029    FireInstallEvent(WebCore::ServiceWorkerIdentifier identifier)
    3130    FireActivateEvent(WebCore::ServiceWorkerIdentifier identifier)
    … …  
    3332    SyncTerminateWorker(WebCore::ServiceWorkerIdentifier identifier) -> () Delayed
    3433    FindClientByIdentifierCompleted(uint64_t clientIdRequestIdentifier, std::optional<WebCore::ServiceWorkerClientData> data, bool hasSecurityError)
    35     MatchAllCompleted(uint64_t matchAllRequestIdentifier, Vector<WebCore::ServiceWorkerClientInformation> clientsData)
     34    MatchAllCompleted(uint64_t matchAllRequestIdentifier, Vector<WebCore::ServiceWorkerClientData> clientsData)
    3635    ClaimCompleted(uint64_t claimRequestIdentifier)
    3736    DidFinishSkipWaiting(uint64_t callbackID)
Note: See TracChangeset for help on using the changeset viewer.