Changeset 223191 in webkit


Ignore:
Timestamp:
Oct 11, 2017 10:27:08 AM (7 years ago)
Author:
beidson@apple.com
Message:

Add a SW context process (where SW scripts will actually execute).
​https://bugs.webkit.org/show_bug.cgi?id=178156
Source/WebCore:

Reviewed by Andy Estes.

No new tests (Covered by changes to existing tests).

This patch adds an auxiliary "ServiceWorker context" WebProcess to a WebProcessPool.

This process is where ServiceWorker scripts will execute, separate from the client WebProcess
hosting the page(s) they are serving.

This patch also adds all of the plumbing to pass along a fetched service worker script to this
context WebProcess, as well as message back failure to actually start the script so we can test.

Touches lots of code sites but is basically just a lot of plumbing.

  • WebCore.xcodeproj/project.pbxproj:
  • workers/service/ServiceWorkerContextData.h: Copied from Source/WebCore/workers/service/server/SWServerWorker.h.

(WebCore::ServiceWorkerContextData::encode const):
(WebCore::ServiceWorkerContextData::decode):

  • workers/service/server/SWServer.cpp:

(WebCore::SWServer::Connection::finishFetchingScriptInServer):
(WebCore::SWServer::Connection::scriptContextFailedToStart):
(WebCore::SWServer::scriptFetchFinished):
(WebCore::SWServer::scriptContextFailedToStart):
(WebCore::SWServer::createWorker):

  • workers/service/server/SWServer.h:
  • workers/service/server/SWServerRegistration.cpp:

(WebCore::SWServerRegistration::scriptFetchFinished):
(WebCore::SWServerRegistration::scriptContextFailedToStart):

  • workers/service/server/SWServerRegistration.h:
  • workers/service/server/SWServerWorker.cpp:

(WebCore::SWServerWorker::SWServerWorker):
(WebCore::SWServerWorker::~SWServerWorker):

  • workers/service/server/SWServerWorker.h:

(WebCore::SWServerWorker::create):
(WebCore::SWServerWorker::scriptURL const):
(WebCore::SWServerWorker::script const):
(WebCore::SWServerWorker::type const):
(WebCore::SWServerWorker::workerID const):

Source/WebKit:

Reviewed by Andy Estes.

This patch adds an auxiliary "ServiceWorker context" WebProcess to a WebProcessPool.

This process is where ServiceWorker scripts will execute, separate from the client WebProcess
hosting the page(s) they are serving.

This patch also adds all of the plumbing to pass along a fetched service worker script to this
context WebProcess, as well as message back failure to actually start the script so we can test.

Touches lots of code sites but is basically just a lot of plumbing.

  • StorageProcess/ServiceWorker/WebSWServerConnection.cpp:

(WebKit::WebSWServerConnection::WebSWServerConnection):
(WebKit::WebSWServerConnection::startServiceWorkerContext):
(WebKit::WebSWServerConnection::sendToContextProcess):
(WebKit::WebSWServerConnection::setContextConnection):

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

(WebKit::StorageProcess::workerContextProcessConnection):
(WebKit::StorageProcess::createWorkerContextProcessConnection):
(WebKit::StorageProcess::didGetWorkerContextProcessConnection):
(WebKit::StorageProcess::serviceWorkerContextFailedToStart):
(WebKit::StorageProcess::registerSWServerConnection):
(WebKit::StorageProcess::unregisterSWServerConnection):

  • StorageProcess/StorageProcess.h:
  • StorageProcess/StorageProcess.messages.in:
  • StorageProcess/StorageToWebProcessConnection.cpp:

(WebKit::StorageToWebProcessConnection::~StorageToWebProcessConnection):
(WebKit::StorageToWebProcessConnection::establishSWServerConnection):
(WebKit::StorageToWebProcessConnection::removeSWServerConnection):
(WebKit::StorageToWebProcessConnection::workerContextProcessConnectionCreated):

  • StorageProcess/StorageToWebProcessConnection.h:
  • UIProcess/Storage/StorageProcessProxy.cpp:

(WebKit::StorageProcessProxy::create):
(WebKit::StorageProcessProxy::StorageProcessProxy):
(WebKit::StorageProcessProxy::didClose):
(WebKit::StorageProcessProxy::getWorkerContextProcessConnection):
(WebKit::StorageProcessProxy::didGetWorkerContextProcessConnection):

  • UIProcess/Storage/StorageProcessProxy.h:
  • UIProcess/Storage/StorageProcessProxy.messages.in:
  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::ensureStorageProcessAndWebsiteDataStore):
(WebKit::WebProcessPool::getWorkerContextProcessConnection):
(WebKit::WebProcessPool::didGetWorkerContextProcessConnection):
(WebKit::WebProcessPool::disconnectProcess):
(WebKit::WebProcessPool::createWebPage):

  • UIProcess/WebProcessPool.h:
  • UIProcess/WebProcessProxy.cpp:

(WebKit::WebProcessProxy::didGetWorkerContextConnection):

  • UIProcess/WebProcessProxy.h:
  • UIProcess/WebProcessProxy.messages.in:
  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::getWorkerContextConnection):
(WebKit::WebProcess::startServiceWorkerContext):

  • WebProcess/WebProcess.h:
  • WebProcess/WebProcess.messages.in:

LayoutTests:

Reviewed by Andy Estes.

  • http/tests/workers/service/basic-register-exceptions-expected.txt:
  • http/tests/workers/service/basic-register-expected.txt:
  • http/tests/workers/service/registration-task-queue-scheduling-1-expected.txt:
Location:
trunk
Files:
31 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r223190 r223191  
     12017-10-11  Brady Eidson  <beidson@apple.com>
     2
     3        Add a SW context process (where SW scripts will actually execute).
     4        https://bugs.webkit.org/show_bug.cgi?id=178156
     5
     6        Reviewed by Andy Estes.
     7
     8        * http/tests/workers/service/basic-register-exceptions-expected.txt:
     9        * http/tests/workers/service/basic-register-expected.txt:
     10        * http/tests/workers/service/registration-task-queue-scheduling-1-expected.txt:
     11
    1122017-10-11  Joanmarie Diggs  <jdiggs@igalia.com>
    213

  • trunk/LayoutTests/http/tests/workers/service/basic-register-exceptions-expected.txt

    r222980 r223191  
    55CONSOLE MESSAGE: line 60: Registration failed with error: TypeError: Scope URL provided to serviceWorker.register() must be either HTTP or HTTPS
    66CONSOLE MESSAGE: line 70: Registration failed with error: TypeError: Scope URL provided to serviceWorker.register() cannot have a path that contains '%2f' or '%5c'
    7 CONSOLE MESSAGE: line 10: Registration failed with error: UnknownError: Script URL http://127.0.0.1:8000/workers/service/image-mime-type.php fetched with 0 characters, but we're not using the result yet
     7CONSOLE MESSAGE: line 10: Registration failed with error: UnknownError: Failed to start service worker script of length 0
    88CONSOLE MESSAGE: line 80: Registration failed with error: SecurityError: Script origin does not match the registering client's origin
    99CONSOLE MESSAGE: line 91: Registration failed with error: SecurityError: Scope origin does not match the registering client's origin

  • trunk/LayoutTests/http/tests/workers/service/basic-register-expected.txt

    r222980 r223191  
    1 CONSOLE MESSAGE: line 10: Registration failed with error: UnknownError: Script URL http://127.0.0.1:8000/workers/service/resources/empty-worker.js fetched with 41 characters, but we're not using the result yet
    2 CONSOLE MESSAGE: line 21: Registration failed with error: UnknownError: Script URL http://127.0.0.1:8000/workers/service/resources/empty-worker-doesnt-exist.js fetched with 0 characters, but we're not using the result yet
     1CONSOLE MESSAGE: line 10: Registration failed with error: UnknownError: Failed to start service worker script of length 41
     2CONSOLE MESSAGE: line 21: Registration failed with error: UnknownError: Failed to start service worker script of length 0
    33

  • trunk/LayoutTests/http/tests/workers/service/registration-task-queue-scheduling-1-expected.txt

    r221198 r223191  
    1 ALERT: Done
     1ALERT: Unexpected error received from server: UnknownError: Failed to start service worker script of length 41
    22

  • trunk/Source/WebCore/ChangeLog

    r223190 r223191  
     12017-10-11  Brady Eidson  <beidson@apple.com>
     2
     3        Add a SW context process (where SW scripts will actually execute).
     4        https://bugs.webkit.org/show_bug.cgi?id=178156
     5       
     6        Reviewed by Andy Estes.
     7
     8        No new tests (Covered by changes to existing tests).
     9
     10        This patch adds an auxiliary "ServiceWorker context" WebProcess to a WebProcessPool.
     11
     12        This process is where ServiceWorker scripts will execute, separate from the client WebProcess
     13        hosting the page(s) they are serving.
     14
     15        This patch also adds all of the plumbing to pass along a fetched service worker script to this
     16        context WebProcess, as well as message back failure to actually start the script so we can test.
     17
     18        Touches lots of code sites but is basically just a lot of plumbing.
     19
     20        * WebCore.xcodeproj/project.pbxproj:
     21
     22        * workers/service/ServiceWorkerContextData.h: Copied from Source/WebCore/workers/service/server/SWServerWorker.h.
     23        (WebCore::ServiceWorkerContextData::encode const):
     24        (WebCore::ServiceWorkerContextData::decode):
     25
     26        * workers/service/server/SWServer.cpp:
     27        (WebCore::SWServer::Connection::finishFetchingScriptInServer):
     28        (WebCore::SWServer::Connection::scriptContextFailedToStart):
     29        (WebCore::SWServer::scriptFetchFinished):
     30        (WebCore::SWServer::scriptContextFailedToStart):
     31        (WebCore::SWServer::createWorker):
     32        * workers/service/server/SWServer.h:
     33
     34        * workers/service/server/SWServerRegistration.cpp:
     35        (WebCore::SWServerRegistration::scriptFetchFinished):
     36        (WebCore::SWServerRegistration::scriptContextFailedToStart):
     37        * workers/service/server/SWServerRegistration.h:
     38
     39        * workers/service/server/SWServerWorker.cpp:
     40        (WebCore::SWServerWorker::SWServerWorker):
     41        (WebCore::SWServerWorker::~SWServerWorker):
     42        * workers/service/server/SWServerWorker.h:
     43        (WebCore::SWServerWorker::create):
     44        (WebCore::SWServerWorker::scriptURL const):
     45        (WebCore::SWServerWorker::script const):
     46        (WebCore::SWServerWorker::type const):
     47        (WebCore::SWServerWorker::workerID const):
     48
    1492017-10-11  Joanmarie Diggs  <jdiggs@igalia.com>
    250

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

    r223076 r223191  
    24652465                51C81B890C4422F70019ECE3 /* FTPDirectoryParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51C81B870C4422F70019ECE3 /* FTPDirectoryParser.cpp */; };
    24662466                51C81B8A0C4422F70019ECE3 /* FTPDirectoryParser.h in Headers */ = {isa = PBXBuildFile; fileRef = 51C81B880C4422F70019ECE3 /* FTPDirectoryParser.h */; };
     2467                51CA7EE91F883390003D3131 /* ServiceWorkerContextData.h in Headers */ = {isa = PBXBuildFile; fileRef = 51CA7EE71F8832E0003D3131 /* ServiceWorkerContextData.h */; settings = {ATTRIBUTES = (Private, ); }; };
    24672468                51CBFC990D10E483002DBF51 /* CachedFramePlatformData.h in Headers */ = {isa = PBXBuildFile; fileRef = 51CBFC980D10E483002DBF51 /* CachedFramePlatformData.h */; settings = {ATTRIBUTES = (Private, ); }; };
    24682469                51D1248B1E73627F002B2820 /* NetworkStorageSessionCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = 51D1248A1E73625C002B2820 /* NetworkStorageSessionCocoa.mm */; };
    … …  
    1036410365                51C81B870C4422F70019ECE3 /* FTPDirectoryParser.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = FTPDirectoryParser.cpp; sourceTree = "<group>"; };
    1036510366                51C81B880C4422F70019ECE3 /* FTPDirectoryParser.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = FTPDirectoryParser.h; sourceTree = "<group>"; };
     10367                51CA7EE71F8832E0003D3131 /* ServiceWorkerContextData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ServiceWorkerContextData.h; sourceTree = "<group>"; };
    1036610368                51CBFC980D10E483002DBF51 /* CachedFramePlatformData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CachedFramePlatformData.h; sourceTree = "<group>"; };
    1036710369                51D1248A1E73625C002B2820 /* NetworkStorageSessionCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = NetworkStorageSessionCocoa.mm; sourceTree = "<group>"; };
    … …  
    1921319215                                51F175571F3EBC0C00C74950 /* ServiceWorkerContainer.h */,
    1921419216                                51F175561F3EBC0C00C74950 /* ServiceWorkerContainer.idl */,
     19217                                51CA7EE71F8832E0003D3131 /* ServiceWorkerContextData.h */,
    1921519218                                517A535C1F5899F200DCDC0A /* ServiceWorkerFetchResult.h */,
    1921619219                                51F175551F3EBC0C00C74950 /* ServiceWorkerGlobalScope.cpp */,
    … …  
    3015330156                                51F1755D1F3EBC8300C74950 /* ServiceWorker.h in Headers */,
    3015430157                                51F1755F1F3EBC8300C74950 /* ServiceWorkerContainer.h in Headers */,
     30158                                51CA7EE91F883390003D3131 /* ServiceWorkerContextData.h in Headers */,
    3015530159                                517A535D1F5899FE00DCDC0A /* ServiceWorkerFetchResult.h in Headers */,
    3015630160                                51F175611F3EBC8300C74950 /* ServiceWorkerGlobalScope.h in Headers */,

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

    r223190 r223191  
    2626#pragma once
    2727
     28#include "ServiceWorkerRegistrationKey.h"
     29
    2830#if ENABLE(SERVICE_WORKER)
    29 
    30 #include "URL.h"
    3131
    3232namespace WebCore {
    3333
    34 class SWServerWorker {
    35 public:
    36     SWServerWorker(const URL&);
    37     SWServerWorker(const SWServerWorker&) = delete;
    38     ~SWServerWorker();
    39     const URL& scriptURL() const { return m_scriptURL; }
     34struct ServiceWorkerContextData {
     35    ServiceWorkerRegistrationKey registrationKey;
     36    String workerID;
     37    String script;
     38   
     39    template<class Encoder> void encode(Encoder&) const;
     40    template<class Decoder> static std::optional<ServiceWorkerContextData> decode(Decoder&);
     41};
    4042
    41 private:
    42     URL m_scriptURL;
    43 };
     43template<class Encoder>
     44void ServiceWorkerContextData::encode(Encoder& encoder) const
     45{
     46    encoder << registrationKey << workerID << script;
     47}
     48
     49template<class Decoder>
     50std::optional<ServiceWorkerContextData> ServiceWorkerContextData::decode(Decoder& decoder)
     51{
     52    auto registrationKey = ServiceWorkerRegistrationKey::decode(decoder);
     53    if (!registrationKey)
     54        return std::nullopt;
     55
     56    String workerID;
     57    if (!decoder.decode(workerID))
     58        return std::nullopt;
     59
     60    String script;
     61    if (!decoder.decode(script))
     62        return std::nullopt;
     63   
     64    return {{ WTFMove(*registrationKey), WTFMove(workerID), WTFMove(script) }};
     65}
    4466
    4567} // namespace WebCore

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

    r222980 r223191  
    3333#include "Logging.h"
    3434#include "SWServerRegistration.h"
     35#include "SWServerWorker.h"
     36#include "ServiceWorkerContextData.h"
    3537#include "ServiceWorkerFetchResult.h"
    3638#include "ServiceWorkerJobData.h"
     39#include <wtf/UUID.h>
    3740#include <wtf/text/WTFString.h>
    3841
    … …  
    7679void SWServer::Connection::finishFetchingScriptInServer(const ServiceWorkerFetchResult& result)
    7780{
    78     m_server.scriptFetchFinished(result);
     81    m_server.scriptFetchFinished(*this, result);
     82}
     83
     84void SWServer::Connection::scriptContextFailedToStart(const ServiceWorkerRegistrationKey& registrationKey, const String& workerID, const String& message)
     85{
     86    m_server.scriptContextFailedToStart(*this, registrationKey, workerID, message);
    7987}
    8088
    … …  
    129137}
    130138
    131 void SWServer::scriptFetchFinished(const ServiceWorkerFetchResult& result)
     139void SWServer::scriptFetchFinished(Connection& connection, const ServiceWorkerFetchResult& result)
    132140{
    133141    LOG(ServiceWorker, "Server handling scriptFetchFinished for current job %" PRIu64 "-%" PRIu64 " in client", result.connectionIdentifier, result.jobIdentifier);
    … …  
    139147        return;
    140148
    141     registration->scriptFetchFinished(result);
     149    registration->scriptFetchFinished(connection, result);
     150}
     151
     152void SWServer::scriptContextFailedToStart(Connection& connection, const ServiceWorkerRegistrationKey& registrationKey, const String& workerID, const String& message)
     153{
     154    ASSERT(m_connections.contains(connection.identifier()));
     155   
     156    if (auto* registration = m_registrations.get(registrationKey))
     157        registration->scriptContextFailedToStart(connection, workerID, message);
     158}
     159
     160Ref<SWServerWorker> SWServer::createWorker(Connection& connection, const ServiceWorkerRegistrationKey& registrationKey, const URL& url, const String& script, WorkerType type)
     161{
     162    String workerID = createCanonicalUUIDString();
     163   
     164    auto result = m_workersByID.add(workerID, SWServerWorker::create(registrationKey, url, script, type, workerID));
     165    ASSERT(result.isNewEntry);
     166   
     167    connection.startServiceWorkerContext({ registrationKey, workerID, script });
     168   
     169    return result.iterator->value.get();
    142170}
    143171

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

    r222980 r223191  
    2828#if ENABLE(SERVICE_WORKER)
    2929
    30 #include "SWServerRegistration.h"
    3130#include "ServiceWorkerJob.h"
    3231#include "ServiceWorkerRegistrationKey.h"
    … …  
    4342
    4443class SWServerRegistration;
     44class SWServerWorker;
    4545struct ExceptionData;
     46struct ServiceWorkerContextData;
    4647struct ServiceWorkerFetchResult;
    4748struct ServiceWorkerRegistrationData;
    … …  
    5455        WEBCORE_EXPORT virtual ~Connection();
    5556
     57        WEBCORE_EXPORT void scriptContextFailedToStart(const ServiceWorkerRegistrationKey&, const String& workerID, const String& message);
     58
    5659    protected:
    5760        WEBCORE_EXPORT Connection(SWServer&, uint64_t identifier);
    … …  
    6265
    6366    private:
     67        // Messages to the client WebProcess
    6468        virtual void rejectJobInClient(uint64_t jobIdentifier, const ExceptionData&) = 0;
    6569        virtual void resolveJobInClient(uint64_t jobIdentifier, const ServiceWorkerRegistrationData&) = 0;
    6670        virtual void startScriptFetchInClient(uint64_t jobIdentifier) = 0;
     71
     72        // Messages to the SW host WebProcess
     73        virtual void startServiceWorkerContext(const ServiceWorkerContextData&) = 0;
    6774
    6875        SWServer& m_server;
    … …  
    8087    void postTaskReply(CrossThreadTask&&);
    8188
     89    Ref<SWServerWorker> createWorker(Connection&, const ServiceWorkerRegistrationKey&, const URL&, const String& script, WorkerType);
     90   
    8291private:
    8392    void registerConnection(Connection&);
    … …  
    8796    void handleTaskRepliesOnMainThread();
    8897
    89     void scriptFetchFinished(const ServiceWorkerFetchResult&);
     98    void scriptFetchFinished(Connection&, const ServiceWorkerFetchResult&);
     99    void scriptContextFailedToStart(Connection&, const ServiceWorkerRegistrationKey&, const String& workerID, const String& message);
    90100
    91101    HashMap<uint64_t, Connection*> m_connections;
    92102    HashMap<ServiceWorkerRegistrationKey, std::unique_ptr<SWServerRegistration>> m_registrations;
     103
     104    HashMap<String, Ref<SWServerWorker>> m_workersByID;
    93105
    94106    RefPtr<Thread> m_taskThread;

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

    r222980 r223191  
    6565}
    6666
    67 void SWServerRegistration::scriptFetchFinished(const ServiceWorkerFetchResult& result)
     67void SWServerRegistration::scriptFetchFinished(SWServer::Connection& connection, const ServiceWorkerFetchResult& result)
    6868{
    6969    ASSERT(m_currentJob && m_currentJob->identifier() == result.jobIdentifier);
    7070
    71     // FIXME: We fetched the script contents but don't do anything with them yet.
    72     // These errors are for testing the current state of the feature.
    73 
    74     String message;
    75     if (result.scriptError.isNull())
    76         message = makeString("Script URL ", m_currentJob->scriptURL.string(), " fetched with ", String::number(result.script.length()), " characters, but we're not using the result yet");
    77     else
    78         message = makeString("Script URL ", m_currentJob->scriptURL.string(), " fetch resulted in error: ", result.scriptError.localizedDescription());
     71    if (!result.scriptError.isNull()) {
     72        rejectCurrentJob(ExceptionData { UnknownError, makeString("Script URL ", m_currentJob->scriptURL.string(), " fetch resulted in error: ", result.scriptError.localizedDescription()) });
     73       
     74        // If newestWorker is null, invoke Clear Registration algorithm passing this registration as its argument.
     75        // FIXME: We don't have "clear registration" yet.
     76
     77        return;
     78    }
     79
     80    m_lastUpdateTime = currentTime();
     81   
     82    // FIXME: If the script data matches byte-for-byte with the existing newestWorker,
     83    // then resolve and finish the job without doing anything further.
     84
     85    // FIXME: Support the proper worker type (classic vs module)
     86    m_server.createWorker(connection, m_registrationKey, m_currentJob->scriptURL, result.script, WorkerType::Classic);
     87}
     88
     89void SWServerRegistration::scriptContextFailedToStart(SWServer::Connection&, const String& workerID, const String& message)
     90{
     91    ASSERT(m_currentJob);
     92    UNUSED_PARAM(workerID);
    7993
    8094    rejectCurrentJob(ExceptionData { UnknownError, message });

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

    r222980 r223191  
    2828#if ENABLE(SERVICE_WORKER)
    2929
     30#include "SWServer.h"
    3031#include "ServiceWorkerJobData.h"
    3132#include "ServiceWorkerRegistrationData.h"
    … …  
    4849
    4950    void enqueueJob(const ServiceWorkerJobData&);
    50     void scriptFetchFinished(const ServiceWorkerFetchResult&);
    51 
     51    void scriptFetchFinished(SWServer::Connection&, const ServiceWorkerFetchResult&);
     52    void scriptContextFailedToStart(SWServer::Connection&, const String& workerID, const String& message);
     53   
    5254    ServiceWorkerRegistrationData data() const;
    5355
    … …  
    7880    URL m_scopeURL;
    7981    std::optional<ServiceWorkerUpdateViaCache> m_updateViaCache;
     82   
     83    double m_lastUpdateTime { 0 };
    8084
    8185    Timer m_jobTimer;

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

    r221392 r223191  
    2929#if ENABLE(SERVICE_WORKER)
    3030
    31 #include <wtf/MainThread.h>
    32 
    3331namespace WebCore {
    3432
    35 SWServerWorker::SWServerWorker(const URL& url)
    36     : m_scriptURL(url)
     33SWServerWorker::SWServerWorker(const ServiceWorkerRegistrationKey& registrationKey, const URL& url, const String& script, WorkerType type, const String& workerID)
     34    : m_registrationKey(registrationKey)
     35    , m_scriptURL(url)
     36    , m_script(script)
     37    , m_workerID(workerID)
     38    , m_type(type)
    3739{
    38     ASSERT(!isMainThread());
    3940}
    4041
    4142SWServerWorker::~SWServerWorker()
    4243{
    43     ASSERT(!isMainThread());
    4444}
    4545

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

    r221392 r223191  
    2828#if ENABLE(SERVICE_WORKER)
    2929
     30#include "ServiceWorkerRegistrationKey.h"
    3031#include "URL.h"
     32#include <wtf/ThreadSafeRefCounted.h>
    3133
    3234namespace WebCore {
    3335
    34 class SWServerWorker {
     36enum class WorkerType;
     37
     38class SWServerWorker : public ThreadSafeRefCounted<SWServerWorker> {
    3539public:
    36     SWServerWorker(const URL&);
     40    static Ref<SWServerWorker> create(const ServiceWorkerRegistrationKey& registrationKey, const URL& url, const String& script, WorkerType type, const String& workerID)
     41    {
     42        return adoptRef(*new SWServerWorker(registrationKey, url, script, type, workerID));
     43    }
     44   
    3745    SWServerWorker(const SWServerWorker&) = delete;
    3846    ~SWServerWorker();
     47
    3948    const URL& scriptURL() const { return m_scriptURL; }
     49    const String& script() const { return m_script; }
     50    WorkerType type() const { return m_type; }
     51    const String& workerID() const { return m_workerID; }
     52   
     53private:
     54    SWServerWorker(const ServiceWorkerRegistrationKey&, const URL&, const String& script, WorkerType, const String& workerID);
    4055
    41 private:
     56    ServiceWorkerRegistrationKey m_registrationKey;
    4257    URL m_scriptURL;
     58    String m_script;
     59    String m_workerID;
     60    WorkerType m_type;
    4361};
    4462

  • trunk/Source/WebKit/ChangeLog

    r223179 r223191  
     12017-10-11  Brady Eidson  <beidson@apple.com>
     2
     3        Add a SW context process (where SW scripts will actually execute).
     4        https://bugs.webkit.org/show_bug.cgi?id=178156
     5
     6        Reviewed by Andy Estes.
     7
     8        This patch adds an auxiliary "ServiceWorker context" WebProcess to a WebProcessPool.
     9
     10        This process is where ServiceWorker scripts will execute, separate from the client WebProcess
     11        hosting the page(s) they are serving.
     12
     13        This patch also adds all of the plumbing to pass along a fetched service worker script to this
     14        context WebProcess, as well as message back failure to actually start the script so we can test.
     15
     16        Touches lots of code sites but is basically just a lot of plumbing.
     17
     18        * StorageProcess/ServiceWorker/WebSWServerConnection.cpp:
     19        (WebKit::WebSWServerConnection::WebSWServerConnection):
     20        (WebKit::WebSWServerConnection::startServiceWorkerContext):
     21        (WebKit::WebSWServerConnection::sendToContextProcess):
     22        (WebKit::WebSWServerConnection::setContextConnection):
     23        * StorageProcess/ServiceWorker/WebSWServerConnection.h:
     24
     25        * StorageProcess/StorageProcess.cpp:
     26        (WebKit::StorageProcess::workerContextProcessConnection):
     27        (WebKit::StorageProcess::createWorkerContextProcessConnection):
     28        (WebKit::StorageProcess::didGetWorkerContextProcessConnection):
     29        (WebKit::StorageProcess::serviceWorkerContextFailedToStart):
     30        (WebKit::StorageProcess::registerSWServerConnection):
     31        (WebKit::StorageProcess::unregisterSWServerConnection):
     32        * StorageProcess/StorageProcess.h:
     33        * StorageProcess/StorageProcess.messages.in:
     34
     35        * StorageProcess/StorageToWebProcessConnection.cpp:
     36        (WebKit::StorageToWebProcessConnection::~StorageToWebProcessConnection):
     37        (WebKit::StorageToWebProcessConnection::establishSWServerConnection):
     38        (WebKit::StorageToWebProcessConnection::removeSWServerConnection):
     39        (WebKit::StorageToWebProcessConnection::workerContextProcessConnectionCreated):
     40        * StorageProcess/StorageToWebProcessConnection.h:
     41
     42        * UIProcess/Storage/StorageProcessProxy.cpp:
     43        (WebKit::StorageProcessProxy::create):
     44        (WebKit::StorageProcessProxy::StorageProcessProxy):
     45        (WebKit::StorageProcessProxy::didClose):
     46        (WebKit::StorageProcessProxy::getWorkerContextProcessConnection):
     47        (WebKit::StorageProcessProxy::didGetWorkerContextProcessConnection):
     48        * UIProcess/Storage/StorageProcessProxy.h:
     49        * UIProcess/Storage/StorageProcessProxy.messages.in:
     50
     51        * UIProcess/WebProcessPool.cpp:
     52        (WebKit::WebProcessPool::ensureStorageProcessAndWebsiteDataStore):
     53        (WebKit::WebProcessPool::getWorkerContextProcessConnection):
     54        (WebKit::WebProcessPool::didGetWorkerContextProcessConnection):
     55        (WebKit::WebProcessPool::disconnectProcess):
     56        (WebKit::WebProcessPool::createWebPage):
     57        * UIProcess/WebProcessPool.h:
     58
     59        * UIProcess/WebProcessProxy.cpp:
     60        (WebKit::WebProcessProxy::didGetWorkerContextConnection):
     61        * UIProcess/WebProcessProxy.h:
     62        * UIProcess/WebProcessProxy.messages.in:
     63
     64        * WebProcess/WebProcess.cpp:
     65        (WebKit::WebProcess::getWorkerContextConnection):
     66        (WebKit::WebProcess::startServiceWorkerContext):
     67        * WebProcess/WebProcess.h:
     68        * WebProcess/WebProcess.messages.in:
     69
    1702017-10-11  Don Olmstead  <don.olmstead@sony.com>
    271

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

    r222980 r223191  
    3333#include "StorageToWebProcessConnectionMessages.h"
    3434#include "WebProcess.h"
     35#include "WebProcessMessages.h"
    3536#include "WebSWClientConnectionMessages.h"
    3637#include "WebSWServerConnectionMessages.h"
    … …  
    3839#include <WebCore/ExceptionData.h>
    3940#include <WebCore/NotImplemented.h>
     41#include <WebCore/ServiceWorkerContextData.h>
    4042#include <WebCore/ServiceWorkerJobData.h>
     43#include <WebCore/ServiceWorkerRegistrationData.h>
    4144#include <wtf/MainThread.h>
    4245
    … …  
    4952    : SWServer::Connection(server, connectionIdentifier)
    5053    , m_sessionID(sessionID)
    51     , m_connection(connection)
     54    , m_contentConnection(connection)
    5255{
    5356}
    … …  
    7780}
    7881
     82void WebSWServerConnection::startServiceWorkerContext(const ServiceWorkerContextData& data)
     83{
     84    if (sendToContextProcess(Messages::WebProcess::StartServiceWorkerContext(identifier(), data)))
     85        return;
     86
     87    m_pendingContextDatas.append(data);
     88}
     89
     90template<typename U> bool WebSWServerConnection::sendToContextProcess(U&& message)
     91{
     92    if (!m_contextConnection)
     93        return false;
     94
     95    return m_contextConnection->send<U>(WTFMove(message), 0);
     96}
     97
     98void WebSWServerConnection::setContextConnection(IPC::Connection* connection)
     99{
     100    m_contextConnection = connection;
     101
     102    // We can now start any pending service worker contexts.
     103    for (auto& pendingContextData : m_pendingContextDatas)
     104        startServiceWorkerContext(pendingContextData);
     105   
     106    m_pendingContextDatas.clear();
     107}
     108   
    79109} // namespace WebKit
    80110

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

    r222980 r223191  
    3535namespace WebCore {
    3636struct ExceptionData;
     37struct ServiceWorkerRegistrationKey;
    3738}
    3839
    … …  
    4647
    4748    void disconnectedFromWebProcess();
     49    void setContextConnection(IPC::Connection*);
    4850    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
    4951
    5052private:
    51     // Implement SWServer::Connection
     53    // Implement SWServer::Connection (Messages to the client WebProcess)
    5254    void rejectJobInClient(uint64_t jobIdentifier, const WebCore::ExceptionData&) final;
    5355    void resolveJobInClient(uint64_t jobIdentifier, const WebCore::ServiceWorkerRegistrationData&) final;
    5456    void startScriptFetchInClient(uint64_t jobIdentifier) final;
    5557
    56     IPC::Connection* messageSenderConnection() final { return m_connection.ptr(); }
     58    // Messages to the SW context WebProcess
     59    void startServiceWorkerContext(const WebCore::ServiceWorkerContextData&) final;
     60   
     61    IPC::Connection* messageSenderConnection() final { return m_contentConnection.ptr(); }
    5762    uint64_t messageSenderDestinationID() final { return identifier(); }
    5863
     64    template<typename U> bool sendToContextProcess(U&& message);
     65   
    5966    PAL::SessionID m_sessionID;
    6067
    61     Ref<IPC::Connection> m_connection;
     68    Ref<IPC::Connection> m_contentConnection;
     69    RefPtr<IPC::Connection> m_contextConnection;
     70   
     71    Deque<WebCore::ServiceWorkerContextData> m_pendingContextDatas;
    6272}; // class WebSWServerConnection
    6373

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

    r223158 r223191  
    3232#include "StorageToWebProcessConnection.h"
    3333#include "WebCoreArgumentCoders.h"
     34#include "WebSWServerConnection.h"
    3435#include "WebsiteData.h"
    3536#include <WebCore/FileSystem.h>
    … …  
    330331    return *result.iterator->value;
    331332}
     333
     334IPC::Connection* StorageProcess::workerContextProcessConnection()
     335{
     336    return m_workerContextProcessConnection.get();
     337}
     338
     339void StorageProcess::createWorkerContextProcessConnection()
     340{
     341    if (m_waitingForWorkerContextProcessConnection)
     342        return;
     343   
     344    m_waitingForWorkerContextProcessConnection = true;
     345    parentProcessConnection()->send(Messages::StorageProcessProxy::GetWorkerContextProcessConnection(), 0);
     346}
     347
     348void StorageProcess::didGetWorkerContextProcessConnection(const IPC::Attachment& encodedConnectionIdentifier)
     349{
     350    ASSERT(m_waitingForWorkerContextProcessConnection);
     351    m_waitingForWorkerContextProcessConnection = false;
     352
     353#if USE(UNIX_DOMAIN_SOCKETS)
     354    IPC::Connection::Identifier connectionIdentifier = encodedConnectionIdentifier.releaseFileDescriptor();
     355#elif OS(DARWIN)
     356    IPC::Connection::Identifier connectionIdentifier(encodedConnectionIdentifier.port());
     357#else
     358    ASSERT_NOT_REACHED();
     359#endif
     360
     361    if (IPC::Connection::identifierIsNull(connectionIdentifier)) {
     362        LOG_ERROR("StorageProcess::didGetWorkerContextProcessConnection - Received null connection identifier");
     363        return;
     364    }
     365
     366    m_workerContextProcessConnection = IPC::Connection::createClientConnection(connectionIdentifier, *this);
     367    m_workerContextProcessConnection->open();
     368   
     369    for (auto& connection : m_storageToWebProcessConnections)
     370        connection->workerContextProcessConnectionCreated();
     371}
     372
     373void StorageProcess::serviceWorkerContextFailedToStart(uint64_t serverConnectionIdentifier, const ServiceWorkerRegistrationKey& registrationKey, const String& workerID, const String& message)
     374{
     375    if (auto* connection = m_swServerConnections.get(serverConnectionIdentifier))
     376        connection->scriptContextFailedToStart(registrationKey, workerID, message);
     377}
     378
     379void StorageProcess::registerSWServerConnection(WebSWServerConnection& connection)
     380{
     381    ASSERT(!m_swServerConnections.contains(connection.identifier()));
     382    m_swServerConnections.add(connection.identifier(), &connection);
     383}
     384
     385void StorageProcess::unregisterSWServerConnection(WebSWServerConnection& connection)
     386{
     387    ASSERT(m_swServerConnections.get(connection.identifier()) == &connection);
     388    m_swServerConnections.remove(connection.identifier());
     389}
    332390#endif
    333391

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

    r223141 r223191  
    3838class SWServer;
    3939struct SecurityOriginData;
     40struct ServiceWorkerRegistrationKey;
    4041}
    4142
    … …  
    4344
    4445class StorageToWebProcessConnection;
     46class WebSWServerConnection;
    4547enum class WebsiteDataType;
    4648struct StorageProcessCreationParameters;
    … …  
    6870#endif
    6971
     72#if ENABLE(SERVICE_WORKER)
     73    IPC::Connection* workerContextProcessConnection();
     74    void createWorkerContextProcessConnection();
     75#endif
     76
    7077#if ENABLE(SANDBOX_EXTENSIONS)
    7178    void getSandboxExtensionsForBlobFiles(const Vector<String>& filenames, WTF::Function<void (SandboxExtension::HandleArray&&)>&& completionHandler);
    … …  
    7481#if ENABLE(SERVICE_WORKER)
    7582    WebCore::SWServer& swServerForSession(PAL::SessionID);
     83    void registerSWServerConnection(WebSWServerConnection&);
     84    void unregisterSWServerConnection(WebSWServerConnection&);
    7685#endif
    7786
    … …  
    102111    void didGetSandboxExtensionsForBlobFiles(uint64_t requestID, SandboxExtension::HandleArray&&);
    103112#endif
    104 
     113#if ENABLE(SERVICE_WORKER)
     114    void didGetWorkerContextProcessConnection(const IPC::Attachment& encodedConnectionIdentifier);
     115    void serviceWorkerContextFailedToStart(uint64_t serverConnectionIdentifier, const WebCore::ServiceWorkerRegistrationKey&, const String& workerID, const String& message);
     116#endif
    105117#if ENABLE(INDEXED_DATABASE)
    106118    Vector<WebCore::SecurityOriginData> indexedDatabaseOrigins(const String& path);
    … …  
    126138   
    127139#if ENABLE(SERVICE_WORKER)
     140    void didCreateWorkerContextProcessConnection(const IPC::Attachment&);
     141
     142    RefPtr<IPC::Connection> m_workerContextProcessConnection;
     143    bool m_waitingForWorkerContextProcessConnection { false };
    128144    HashMap<PAL::SessionID, std::unique_ptr<WebCore::SWServer>> m_swServers;
     145    HashMap<uint64_t, WebSWServerConnection*> m_swServerConnections;
    129146#endif
    130147};

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

    r220857 r223191  
    3535    DidGetSandboxExtensionsForBlobFiles(uint64_t requestID, WebKit::SandboxExtension::HandleArray extensions)
    3636#endif
     37
     38#if ENABLE(SERVICE_WORKER)
     39    DidGetWorkerContextProcessConnection(IPC::Attachment connectionHandle)
     40    ServiceWorkerContextFailedToStart(uint64_t serverConnectionIdentifier, struct WebCore::ServiceWorkerRegistrationKey registrationKey, String workerID, String message)
     41#endif
    3742}

  • trunk/Source/WebKit/StorageProcess/StorageToWebProcessConnection.cpp

    r223141 r223191  
    5656{
    5757    m_connection->invalidate();
     58
     59#if ENABLE(SERVICE_WORKER)
     60    for (auto& connection : m_swConnections.values())
     61        StorageProcess::singleton().unregisterSWServerConnection(*connection);
     62#endif
    5863}
    5964
    … …  
    139144
    140145    auto& server = StorageProcess::singleton().swServerForSession(sessionID);
    141     m_swConnections.set(serverConnectionIdentifier, std::make_unique<WebSWServerConnection>(server, m_connection.get(), serverConnectionIdentifier, sessionID));
     146    auto connectionResult = m_swConnections.add(serverConnectionIdentifier, std::make_unique<WebSWServerConnection>(server, m_connection.get(), serverConnectionIdentifier, sessionID));
     147    ASSERT(connectionResult.isNewEntry);
     148
     149    StorageProcess::singleton().registerSWServerConnection(*(connectionResult.iterator->value));
     150
     151    if (auto* connection = StorageProcess::singleton().workerContextProcessConnection())
     152        connectionResult.iterator->value->setContextConnection(connection);
     153    else
     154        StorageProcess::singleton().createWorkerContextProcessConnection();
    142155}
    143156
    … …  
    147160
    148161    auto connection = m_swConnections.take(serverConnectionIdentifier);
     162    StorageProcess::singleton().unregisterSWServerConnection(*connection);
    149163    connection->disconnectedFromWebProcess();
     164}
     165
     166void StorageToWebProcessConnection::workerContextProcessConnectionCreated()
     167{
     168    auto* ipcConnection = StorageProcess::singleton().workerContextProcessConnection();
     169    ASSERT(ipcConnection);
     170
     171    for (auto& swConnection : m_swConnections.values())
     172        swConnection->setContextConnection(ipcConnection);
    150173}
    151174#endif
    … …  
    170193#endif
    171194
    172 
    173195} // namespace WebKit

  • trunk/Source/WebKit/StorageProcess/StorageToWebProcessConnection.h

    r223141 r223191  
    4545    IPC::Connection& connection() { return m_connection.get(); }
    4646
     47#if ENABLE(SERVICE_WORKER)
     48    void workerContextProcessConnectionCreated();
     49#endif
     50
    4751private:
    4852    StorageToWebProcessConnection(IPC::Connection::Identifier);

  • trunk/Source/WebKit/UIProcess/Storage/StorageProcessProxy.cpp

    r222183 r223191  
    4545}
    4646
    47 Ref<StorageProcessProxy> StorageProcessProxy::create(WebProcessPool* processPool)
     47Ref<StorageProcessProxy> StorageProcessProxy::create(WebProcessPool& processPool)
    4848{
    4949    return adoptRef(*new StorageProcessProxy(processPool));
    5050}
    5151
    52 StorageProcessProxy::StorageProcessProxy(WebProcessPool* processPool)
    53     : ChildProcessProxy(processPool->alwaysRunsAtBackgroundPriority())
     52StorageProcessProxy::StorageProcessProxy(WebProcessPool& processPool)
     53    : ChildProcessProxy(processPool.alwaysRunsAtBackgroundPriority())
    5454    , m_processPool(processPool)
    5555    , m_numPendingConnectionRequests(0)
    … …  
    152152
    153153    // Tell ProcessPool to forget about this storage process. This may cause us to be deleted.
    154     m_processPool->storageProcessCrashed(this);
     154    m_processPool.storageProcessCrashed(this);
    155155}
    156156
    … …  
    221221}
    222222
     223#if ENABLE(SERVICE_WORKER)
     224void StorageProcessProxy::getWorkerContextProcessConnection()
     225{
     226    ASSERT(!m_waitingOnWorkerContextProcessConnection);
     227    m_waitingOnWorkerContextProcessConnection = true;
     228   
     229    m_processPool.getWorkerContextProcessConnection(*this);
     230}
     231
     232void StorageProcessProxy::didGetWorkerContextProcessConnection(const IPC::Attachment& connection)
     233{
     234    send(Messages::StorageProcess::DidGetWorkerContextProcessConnection(connection), 0);
     235}
     236
     237#endif
     238
    223239} // namespace WebKit

  • trunk/Source/WebKit/UIProcess/Storage/StorageProcessProxy.h

    r220857 r223191  
    4949class StorageProcessProxy : public ChildProcessProxy {
    5050public:
    51     static Ref<StorageProcessProxy> create(WebProcessPool*);
     51    static Ref<StorageProcessProxy> create(WebProcessPool&);
    5252    ~StorageProcessProxy();
    5353
    … …  
    5858    void getStorageProcessConnection(Ref<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply>&&);
    5959
     60#if ENABLE(SERVICE_WORKER)
     61    void didGetWorkerContextProcessConnection(const IPC::Attachment& connection);
     62#endif
     63
    6064private:
    61     StorageProcessProxy(WebProcessPool*);
     65    StorageProcessProxy(WebProcessPool&);
    6266
    6367    // ChildProcessProxy
    … …  
    8084    void getSandboxExtensionsForBlobFiles(uint64_t requestID, const Vector<String>& paths);
    8185#endif
     86#if ENABLE(SERVICE_WORKER)
     87    void getWorkerContextProcessConnection();
     88    bool m_waitingOnWorkerContextProcessConnection { false };
     89#endif
    8290
    8391    // ProcessLauncher::Client
    8492    void didFinishLaunching(ProcessLauncher*, IPC::Connection::Identifier) override;
    8593
    86     WebProcessPool* m_processPool;
     94    WebProcessPool& m_processPool;
    8795
    8896    unsigned m_numPendingConnectionRequests;

  • trunk/Source/WebKit/UIProcess/Storage/StorageProcessProxy.messages.in

    r220105 r223191  
    3131    GetSandboxExtensionsForBlobFiles(uint64_t requestID, Vector<String> paths)
    3232#endif
     33
     34#if ENABLE(SERVICE_WORKER)
     35    GetWorkerContextProcessConnection()
     36#endif
    3337}

  • trunk/Source/WebKit/UIProcess/WebProcessPool.cpp

    r223073 r223191  
    546546#endif
    547547
    548         m_storageProcess = StorageProcessProxy::create(this);
     548        m_storageProcess = StorageProcessProxy::create(*this);
    549549        m_storageProcess->send(Messages::StorageProcess::InitializeWebsiteDataStore(parameters), 0);
    550550    }
    … …  
    574574    m_storageProcess = nullptr;
    575575}
     576
     577#if ENABLE(SERVICE_WORKER)
     578void WebProcessPool::getWorkerContextProcessConnection(StorageProcessProxy& proxy)
     579{
     580    ASSERT_UNUSED(proxy, &proxy == m_storageProcess);
     581   
     582    if (!m_workerContextProcess) {
     583        if (!m_websiteDataStore)
     584            m_websiteDataStore = API::WebsiteDataStore::defaultDataStore().ptr();
     585        auto& newProcess = createNewWebProcess(m_websiteDataStore->websiteDataStore());
     586        m_workerContextProcess = &newProcess;
     587    }
     588   
     589    m_workerContextProcess->send(Messages::WebProcess::GetWorkerContextConnection(), 0);
     590}
     591
     592void WebProcessPool::didGetWorkerContextProcessConnection(const IPC::Attachment& connection)
     593{
     594    if (!m_storageProcess)
     595        return;
     596    m_storageProcess->didGetWorkerContextProcessConnection(connection);
     597}
     598#endif
    576599
    577600void WebProcessPool::willStartUsingPrivateBrowsing()
    … …  
    883906    if (m_processWithPageCache == process)
    884907        m_processWithPageCache = nullptr;
     908#if ENABLE(SERVICE_WORKER)
     909    if (m_workerContextProcess == process)
     910        m_workerContextProcess = nullptr;
     911#endif
    885912
    886913    static_cast<WebContextSupplement*>(supplement<WebGeolocationManagerProxy>())->processDidClose(process);
    … …  
    960987    } else
    961988        process = &createNewWebProcessRespectingProcessCountLimit(pageConfiguration->websiteDataStore()->websiteDataStore());
     989
     990    ASSERT(process.get() != m_workerContextProcess);
    962991
    963992    return process->createWebPage(pageClient, WTFMove(pageConfiguration));

  • trunk/Source/WebKit/UIProcess/WebProcessPool.h

    r222664 r223191  
    320320    void getStorageProcessConnection(Ref<Messages::WebProcessProxy::GetStorageProcessConnection::DelayedReply>&&);
    321321    void storageProcessCrashed(StorageProcessProxy*);
     322#if ENABLE(SERVICE_WORKER)
     323    void getWorkerContextProcessConnection(StorageProcessProxy&);
     324#endif
    322325
    323326#if PLATFORM(COCOA)
    … …  
    413416    static void unregisterProcessPoolCreationListener(uint64_t identifier);
    414417
     418#if ENABLE(SERVICE_WORKER)
     419    void didGetWorkerContextProcessConnection(const IPC::Attachment& connection);
     420#endif
     421
    415422private:
    416423    void platformInitialize();
    … …  
    478485
    479486    WebProcessProxy* m_processWithPageCache;
     487#if ENABLE(SERVICE_WORKER)
     488    WebProcessProxy* m_workerContextProcess { nullptr };
     489    bool m_waitingForWorkerContextProcessConnection { false };
     490#endif
    480491
    481492    Ref<WebPageGroup> m_defaultPageGroup;

  • trunk/Source/WebKit/UIProcess/WebProcessProxy.cpp

    r223149 r223191  
    12181218#endif
    12191219
     1220#if ENABLE(SERVICE_WORKER)
     1221void WebProcessProxy::didGetWorkerContextConnection(const IPC::Attachment& connection)
     1222{
     1223    m_processPool->didGetWorkerContextProcessConnection(connection);
     1224}
     1225#endif
     1226
    12201227} // namespace WebKit

  • trunk/Source/WebKit/UIProcess/WebProcessProxy.h

    r223061 r223191  
    182182    void didExceedInactiveMemoryLimitWhileActive();
    183183
     184#if ENABLE(SERVICE_WORKER)
     185    void didGetWorkerContextConnection(const IPC::Attachment& connection);
     186#endif
     187
    184188    void processTerminated();
    185189

  • trunk/Source/WebKit/UIProcess/WebProcessProxy.messages.in

    r220105 r223191  
    5555    MemoryPressureStatusChanged(bool isUnderMemoryPressure)
    5656    DidExceedInactiveMemoryLimitWhileActive()
     57
     58#if ENABLE(SERVICE_WORKER)
     59    DidGetWorkerContextConnection(IPC::Attachment connection)
     60#endif
    5761}

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

    r223149 r223191  
    4343#include "SessionTracker.h"
    4444#include "StatisticsData.h"
     45#include "StorageProcessMessages.h"
    4546#include "UserData.h"
    4647#include "WebAutomationSessionProxy.h"
    … …  
    106107#include <WebCore/SchemeRegistry.h>
    107108#include <WebCore/SecurityOrigin.h>
     109#include <WebCore/ServiceWorkerContextData.h>
    108110#include <WebCore/Settings.h>
    109111#include <WebCore/URLParser.h>
    … …  
    16151617#endif
    16161618
     1619#if ENABLE(SERVICE_WORKER)
     1620void WebProcess::getWorkerContextConnection()
     1621{
     1622    ASSERT(!m_workerContextConnection);
     1623
     1624#if USE(UNIX_DOMAIN_SOCKETS)
     1625    IPC::Connection::SocketPair socketPair = IPC::Connection::createPlatformConnection();
     1626    IPC::Connection::Identifier connectionIdentifier(socketPair.server);
     1627    IPC::Attachment connectionClientPort(socketPair.client);
     1628#elif OS(DARWIN)
     1629    mach_port_t listeningPort;
     1630    if (mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &listeningPort) != KERN_SUCCESS)
     1631        CRASH();
     1632
     1633    if (mach_port_insert_right(mach_task_self(), listeningPort, listeningPort, MACH_MSG_TYPE_MAKE_SEND) != KERN_SUCCESS)
     1634        CRASH();
     1635
     1636    IPC::Connection::Identifier connectionIdentifier(listeningPort);
     1637    IPC::Attachment connectionClientPort(listeningPort, MACH_MSG_TYPE_MOVE_SEND);
     1638#else
     1639    RELEASE_ASSERT_NOT_REACHED();
     1640#endif
     1641
     1642    m_workerContextConnection = IPC::Connection::createServerConnection(connectionIdentifier, *this);
     1643    m_workerContextConnection->open();
     1644
     1645    WebProcess::singleton().parentProcessConnection()->send(Messages::WebProcessProxy::DidGetWorkerContextConnection(connectionClientPort), 0);
     1646}
     1647
     1648void WebProcess::startServiceWorkerContext(uint64_t serverConnectionIdentifier, const ServiceWorkerContextData& data)
     1649{
     1650    // FIXME: Here is where we will actually start the script.
     1651    // For now we bounce back a failure message to the requesting process for test coverage.
     1652
     1653    auto message = makeString("Failed to start service worker script of length ", String::number(data.script.length()));
     1654    m_workerContextConnection->send(Messages::StorageProcess::ServiceWorkerContextFailedToStart(serverConnectionIdentifier, data.registrationKey, data.workerID, message), 0);
     1655}
     1656
     1657#endif
     1658
    16171659} // namespace WebKit

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

    r222619 r223191  
    7272struct SecurityOriginData;
    7373struct SoupNetworkProxySettings;
     74
     75#if ENABLE(SERVICE_WORKER)
     76struct ServiceWorkerContextData;
     77#endif
    7478}
    7579
    … …  
    291295    void gamepadDisconnected(unsigned index);
    292296#endif
    293 
    294297#if USE(SOUP)
    295298    void setNetworkProxySettings(const WebCore::SoupNetworkProxySettings&);
     299#endif
     300#if ENABLE(SERVICE_WORKER)
     301    void getWorkerContextConnection();
     302    void startServiceWorkerContext(uint64_t serverConnectionIdentifier, const WebCore::ServiceWorkerContextData&);
     303    RefPtr<IPC::Connection> m_workerContextConnection;
    296304#endif
    297305

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

    r220857 r223191  
    114114    SetNetworkProxySettings(struct WebCore::SoupNetworkProxySettings settings)
    115115#endif
     116
     117#if ENABLE(SERVICE_WORKER)
     118    GetWorkerContextConnection()
     119    StartServiceWorkerContext(uint64_t serverConnectionIdentifier, struct WebCore::ServiceWorkerContextData contextData)
     120#endif
    116121}
Note: See TracChangeset for help on using the changeset viewer.