Title: [228088] trunk
Revision
228088
Author
[email protected]
Date
2018-02-05 01:02:24 -0800 (Mon, 05 Feb 2018)

Log Message

[SOUP] WebSockets must use system proxy settings
https://bugs.webkit.org/show_bug.cgi?id=126384

Reviewed by Michael Catanzaro.

Source/WebCore:

Use soup_session_connect_async() when available to create the WebSockets connection instead of GSocketClient
directly.

* platform/network/soup/SocketStreamHandleImpl.h:
* platform/network/soup/SocketStreamHandleImplSoup.cpp:
(WebCore::wssSocketClientEventCallback):
(WebCore::SocketStreamHandleImpl::create):
(WebCore::SocketStreamHandleImpl::connected):
(WebCore::SocketStreamHandleImpl::connectedCallback):
(WebCore::SocketStreamHandleImpl::platformClose):

Tools:

Check also WebSockets in /webkit2/WebKitWebContext/proxy.

* TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp:
(ProxyTest::webSocketProxyServerCallback):
(ProxyTest::ProxyTest):
(ProxyTest::webSocketConnected):
(ProxyTest::createWebSocketAndWaitUntilConnected):
(webSocketServerCallback):
(testWebContextProxySettings):
* TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.cpp:
(WebKitTestServer::~WebKitTestServer):
(WebKitTestServer::addWebSocketHandler):
(WebKitTestServer::removeWebSocketHandler):
(WebKitTestServer::getWebSocketURIForPath const):
(WebKitTestServer::getURIForPath const):
* TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.h:
(WebKitTestServer::baseURI const):
(WebKitTestServer::baseWebSocketURI const):

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (228087 => 228088)


--- trunk/Source/WebCore/ChangeLog	2018-02-05 08:46:44 UTC (rev 228087)
+++ trunk/Source/WebCore/ChangeLog	2018-02-05 09:02:24 UTC (rev 228088)
@@ -1,5 +1,23 @@
 2018-02-05  Carlos Garcia Campos  <[email protected]>
 
+        [SOUP] WebSockets must use system proxy settings
+        https://bugs.webkit.org/show_bug.cgi?id=126384
+
+        Reviewed by Michael Catanzaro.
+
+        Use soup_session_connect_async() when available to create the WebSockets connection instead of GSocketClient
+        directly.
+
+        * platform/network/soup/SocketStreamHandleImpl.h:
+        * platform/network/soup/SocketStreamHandleImplSoup.cpp:
+        (WebCore::wssSocketClientEventCallback):
+        (WebCore::SocketStreamHandleImpl::create):
+        (WebCore::SocketStreamHandleImpl::connected):
+        (WebCore::SocketStreamHandleImpl::connectedCallback):
+        (WebCore::SocketStreamHandleImpl::platformClose):
+
+2018-02-05  Carlos Garcia Campos  <[email protected]>
+
         Add a way to check if a host is an IP address
         https://bugs.webkit.org/show_bug.cgi?id=182427
 

Modified: trunk/Source/WebCore/platform/network/soup/SocketStreamHandleImpl.h (228087 => 228088)


--- trunk/Source/WebCore/platform/network/soup/SocketStreamHandleImpl.h	2018-02-05 08:46:44 UTC (rev 228087)
+++ trunk/Source/WebCore/platform/network/soup/SocketStreamHandleImpl.h	2018-02-05 09:02:24 UTC (rev 228088)
@@ -48,8 +48,6 @@
 class SocketStreamHandleImpl final : public SocketStreamHandle {
 public:
     static Ref<SocketStreamHandleImpl> create(const URL&, SocketStreamHandleClient&, PAL::SessionID, const String&, SourceApplicationAuditToken&&);
-    static Ref<SocketStreamHandle> create(GSocketConnection*, SocketStreamHandleClient&);
-
     virtual ~SocketStreamHandleImpl();
 
     void platformSend(const char* data, size_t length, Function<void(bool)>&&) final;
@@ -64,16 +62,16 @@
     void beginWaitingForSocketWritability();
     void stopWaitingForSocketWritability();
 
-    static void connectedCallback(GSocketClient*, GAsyncResult*, SocketStreamHandleImpl*);
+    static void connectedCallback(GObject*, GAsyncResult*, SocketStreamHandleImpl*);
     static void readReadyCallback(GInputStream*, GAsyncResult*, SocketStreamHandleImpl*);
     static gboolean writeReadyCallback(GPollableOutputStream*, SocketStreamHandleImpl*);
 
-    void connected(GRefPtr<GSocketConnection>&&);
+    void connected(GRefPtr<GIOStream>&&);
     void readBytes(gssize);
     void didFail(SocketStreamError&&);
     void writeReady();
 
-    GRefPtr<GSocketConnection> m_socketConnection;
+    GRefPtr<GIOStream> m_stream;
     GRefPtr<GInputStream> m_inputStream;
     GRefPtr<GPollableOutputStream> m_outputStream;
     GRefPtr<GSource> m_writeReadySource;

Modified: trunk/Source/WebCore/platform/network/soup/SocketStreamHandleImplSoup.cpp (228087 => 228088)


--- trunk/Source/WebCore/platform/network/soup/SocketStreamHandleImplSoup.cpp	2018-02-05 08:46:44 UTC (rev 228087)
+++ trunk/Source/WebCore/platform/network/soup/SocketStreamHandleImplSoup.cpp	2018-02-05 09:02:24 UTC (rev 228088)
@@ -55,6 +55,15 @@
     return TRUE;
 }
 
+#if SOUP_CHECK_VERSION(2, 61, 90)
+static void wssSocketClientEventCallback(SoupSession*, GSocketClientEvent event, GIOStream* connection)
+{
+    if (event != G_SOCKET_CLIENT_TLS_HANDSHAKING)
+        return;
+
+    g_signal_connect(connection, "accept-certificate", G_CALLBACK(wssConnectionAcceptCertificateCallback), nullptr);
+}
+#else
 static void wssSocketClientEventCallback(GSocketClient*, GSocketClientEvent event, GSocketConnectable*, GIOStream* connection)
 {
     if (event != G_SOCKET_CLIENT_TLS_HANDSHAKING)
@@ -62,34 +71,42 @@
 
     g_signal_connect(connection, "accept-certificate", G_CALLBACK(wssConnectionAcceptCertificateCallback), nullptr);
 }
+#endif
 
-Ref<SocketStreamHandleImpl> SocketStreamHandleImpl::create(const URL& url, SocketStreamHandleClient& client, PAL::SessionID, const String&, SourceApplicationAuditToken&&)
+Ref<SocketStreamHandleImpl> SocketStreamHandleImpl::create(const URL& url, SocketStreamHandleClient& client, PAL::SessionID sessionID, const String&, SourceApplicationAuditToken&&)
 {
     Ref<SocketStreamHandleImpl> socket = adoptRef(*new SocketStreamHandleImpl(url, client));
 
+    // FIXME: Using DeprecatedGlobalSettings from here is a layering violation.
+    bool allowsAnySSLCertificate = url.protocolIs("wss") && DeprecatedGlobalSettings::allowsAnySSLCertificate();
+
+#if SOUP_CHECK_VERSION(2, 61, 90)
+    auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID);
+    if (!networkStorageSession)
+        return socket;
+
+    auto uri = url.createSoupURI();
+    Ref<SocketStreamHandle> protectedSocketStreamHandle = socket.copyRef();
+    soup_session_connect_async(networkStorageSession->getOrCreateSoupNetworkSession().soupSession(), uri.get(), socket->m_cancellable.get(),
+        allowsAnySSLCertificate ? reinterpret_cast<SoupSessionConnectProgressCallback>(wssSocketClientEventCallback) : nullptr,
+        reinterpret_cast<GAsyncReadyCallback>(connectedCallback), &protectedSocketStreamHandle.leakRef());
+#else
+    UNUSED_PARAM(sessionID);
     unsigned port = url.port() ? url.port().value() : (url.protocolIs("wss") ? 443 : 80);
     GRefPtr<GSocketClient> socketClient = adoptGRef(g_socket_client_new());
     if (url.protocolIs("wss")) {
         g_socket_client_set_tls(socketClient.get(), TRUE);
-        // FIXME: Using DeprecatedGlobalSettings from here is a layering violation.
-        if (DeprecatedGlobalSettings::allowsAnySSLCertificate())
+        if (allowsAnySSLCertificate)
             g_signal_connect(socketClient.get(), "event", G_CALLBACK(wssSocketClientEventCallback), nullptr);
     }
     Ref<SocketStreamHandle> protectedSocketStreamHandle = socket.copyRef();
     g_socket_client_connect_to_host_async(socketClient.get(), url.host().utf8().data(), port, socket->m_cancellable.get(),
         reinterpret_cast<GAsyncReadyCallback>(connectedCallback), &protectedSocketStreamHandle.leakRef());
+#endif
+
     return socket;
 }
 
-Ref<SocketStreamHandle> SocketStreamHandleImpl::create(GSocketConnection* socketConnection, SocketStreamHandleClient& client)
-{
-    Ref<SocketStreamHandleImpl> socket = adoptRef(*new SocketStreamHandleImpl(URL(), client));
-
-    GRefPtr<GSocketConnection> connection = socketConnection;
-    socket->connected(WTFMove(connection));
-    return WTFMove(socket);
-}
-
 SocketStreamHandleImpl::SocketStreamHandleImpl(const URL& url, SocketStreamHandleClient& client)
     : SocketStreamHandle(url, client)
     , m_cancellable(adoptGRef(g_cancellable_new()))
@@ -102,11 +119,11 @@
     LOG(Network, "SocketStreamHandle %p delete", this);
 }
 
-void SocketStreamHandleImpl::connected(GRefPtr<GSocketConnection>&& socketConnection)
+void SocketStreamHandleImpl::connected(GRefPtr<GIOStream>&& stream)
 {
-    m_socketConnection = WTFMove(socketConnection);
-    m_outputStream = G_POLLABLE_OUTPUT_STREAM(g_io_stream_get_output_stream(G_IO_STREAM(m_socketConnection.get())));
-    m_inputStream = g_io_stream_get_input_stream(G_IO_STREAM(m_socketConnection.get()));
+    m_stream = WTFMove(stream);
+    m_outputStream = G_POLLABLE_OUTPUT_STREAM(g_io_stream_get_output_stream(m_stream.get()));
+    m_inputStream = g_io_stream_get_input_stream(m_stream.get());
     m_readBuffer = std::make_unique<char[]>(READ_BUFFER_SIZE);
 
     RefPtr<SocketStreamHandleImpl> protectedThis(this);
@@ -117,25 +134,29 @@
     m_client.didOpenSocketStream(*this);
 }
 
-void SocketStreamHandleImpl::connectedCallback(GSocketClient* client, GAsyncResult* result, SocketStreamHandleImpl* handle)
+void SocketStreamHandleImpl::connectedCallback(GObject* object, GAsyncResult* result, SocketStreamHandleImpl* handle)
 {
     RefPtr<SocketStreamHandle> protectedThis = adoptRef(handle);
 
     // Always finish the connection, even if this SocketStreamHandle was cancelled earlier.
     GUniqueOutPtr<GError> error;
-    GRefPtr<GSocketConnection> socketConnection = adoptGRef(g_socket_client_connect_to_host_finish(client, result, &error.outPtr()));
+#if SOUP_CHECK_VERSION(2, 61, 90)
+    GRefPtr<GIOStream> stream = adoptGRef(soup_session_connect_finish(SOUP_SESSION(object), result, &error.outPtr()));
+#else
+    GRefPtr<GIOStream> stream = adoptGRef(G_IO_STREAM(g_socket_client_connect_to_host_finish(G_SOCKET_CLIENT(object), result, &error.outPtr())));
+#endif
 
     // The SocketStreamHandle has been cancelled, so just close the connection, ignoring errors.
     if (g_cancellable_is_cancelled(handle->m_cancellable.get())) {
-        if (socketConnection)
-            g_io_stream_close(G_IO_STREAM(socketConnection.get()), nullptr, nullptr);
+        if (stream)
+            g_io_stream_close(stream.get(), nullptr, nullptr);
         return;
     }
 
     if (error)
-        handle->didFail(SocketStreamError(error->code, String(), error->message));
+        handle->didFail(SocketStreamError(error->code, { }, error->message));
     else
-        handle->connected(WTFMove(socketConnection));
+        handle->connected(WTFMove(stream));
 }
 
 void SocketStreamHandleImpl::readBytes(gssize bytesRead)
@@ -225,12 +246,12 @@
     g_cancellable_cancel(m_cancellable.get());
     stopWaitingForSocketWritability();
 
-    if (m_socketConnection) {
+    if (m_stream) {
         GUniqueOutPtr<GError> error;
-        g_io_stream_close(G_IO_STREAM(m_socketConnection.get()), nullptr, &error.outPtr());
+        g_io_stream_close(m_stream.get(), nullptr, &error.outPtr());
         if (error)
-            didFail(SocketStreamError(error->code, String(), error->message));
-        m_socketConnection = nullptr;
+            didFail(SocketStreamError(error->code, { }, error->message));
+        m_stream = nullptr;
     }
 
     m_outputStream = nullptr;

Modified: trunk/Tools/ChangeLog (228087 => 228088)


--- trunk/Tools/ChangeLog	2018-02-05 08:46:44 UTC (rev 228087)
+++ trunk/Tools/ChangeLog	2018-02-05 09:02:24 UTC (rev 228088)
@@ -1,5 +1,31 @@
 2018-02-05  Carlos Garcia Campos  <[email protected]>
 
+        [SOUP] WebSockets must use system proxy settings
+        https://bugs.webkit.org/show_bug.cgi?id=126384
+
+        Reviewed by Michael Catanzaro.
+
+        Check also WebSockets in /webkit2/WebKitWebContext/proxy.
+
+        * TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp:
+        (ProxyTest::webSocketProxyServerCallback):
+        (ProxyTest::ProxyTest):
+        (ProxyTest::webSocketConnected):
+        (ProxyTest::createWebSocketAndWaitUntilConnected):
+        (webSocketServerCallback):
+        (testWebContextProxySettings):
+        * TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.cpp:
+        (WebKitTestServer::~WebKitTestServer):
+        (WebKitTestServer::addWebSocketHandler):
+        (WebKitTestServer::removeWebSocketHandler):
+        (WebKitTestServer::getWebSocketURIForPath const):
+        (WebKitTestServer::getURIForPath const):
+        * TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.h:
+        (WebKitTestServer::baseURI const):
+        (WebKitTestServer::baseWebSocketURI const):
+
+2018-02-05  Carlos Garcia Campos  <[email protected]>
+
         Add a way to check if a host is an IP address
         https://bugs.webkit.org/show_bug.cgi?id=182427
 

Modified: trunk/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp (228087 => 228088)


--- trunk/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp	2018-02-05 08:46:44 UTC (rev 228087)
+++ trunk/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp	2018-02-05 09:02:24 UTC (rev 228088)
@@ -653,6 +653,19 @@
 public:
     MAKE_GLIB_TEST_FIXTURE(ProxyTest);
 
+#if SOUP_CHECK_VERSION(2, 61, 90)
+    enum class WebSocketServerType {
+        Unknown,
+        NoProxy,
+        Proxy
+    };
+
+    static void webSocketProxyServerCallback(SoupServer*, SoupWebsocketConnection*, const char* path, SoupClientContext*, gpointer userData)
+    {
+        static_cast<ProxyTest*>(userData)->webSocketConnected(ProxyTest::WebSocketServerType::Proxy);
+    }
+#endif
+
     ProxyTest()
     {
         // This "proxy server" is actually just a different instance of the main
@@ -662,6 +675,10 @@
         // work, not whether we can write a soup proxy server.
         m_proxyServer.run(serverCallback);
         g_assert(m_proxyServer.baseURI());
+#if SOUP_CHECK_VERSION(2, 61, 90)
+        m_proxyServer.addWebSocketHandler(webSocketProxyServerCallback, this);
+        g_assert(m_proxyServer.baseWebSocketURI());
+#endif
     }
 
     CString loadURIAndGetMainResourceData(const char* uri)
@@ -679,9 +696,37 @@
         return port;
     }
 
+#if SOUP_CHECK_VERSION(2, 61, 90)
+    void webSocketConnected(WebSocketServerType serverType)
+    {
+        m_webSocketRequestReceived = serverType;
+        quitMainLoop();
+    }
+
+    WebSocketServerType createWebSocketAndWaitUntilConnected()
+    {
+        m_webSocketRequestReceived = WebSocketServerType::Unknown;
+        GUniquePtr<char> createWebSocket(g_strdup_printf("var ws = new WebSocket('%s');", kServer->getWebSocketURIForPath("/foo").data()));
+        webkit_web_view_run_javascript(m_webView, createWebSocket.get(), nullptr, nullptr, nullptr);
+        g_main_loop_run(m_mainLoop);
+        return m_webSocketRequestReceived;
+    }
+#endif
+
     WebKitTestServer m_proxyServer;
+
+#if SOUP_CHECK_VERSION(2, 61, 90)
+    WebSocketServerType m_webSocketRequestReceived { WebSocketServerType::Unknown };
+#endif
 };
 
+#if SOUP_CHECK_VERSION(2, 61, 90)
+static void webSocketServerCallback(SoupServer*, SoupWebsocketConnection*, const char*, SoupClientContext*, gpointer userData)
+{
+    static_cast<ProxyTest*>(userData)->webSocketConnected(ProxyTest::WebSocketServerType::NoProxy);
+}
+#endif
+
 static void ephemeralViewloadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent, WebViewTest* test)
 {
     if (loadEvent != WEBKIT_LOAD_FINISHED)
@@ -697,6 +742,13 @@
     auto mainResourceData = test->loadURIAndGetMainResourceData(kServer->getURIForPath("/echoPort").data());
     ASSERT_CMP_CSTRING(mainResourceData, ==, serverPortAsString.get());
 
+#if SOUP_CHECK_VERSION(2, 61, 90)
+    // WebSocket requests should also be received by kServer.
+    kServer->addWebSocketHandler(webSocketServerCallback, test);
+    auto serverType = test->createWebSocketAndWaitUntilConnected();
+    g_assert(serverType == ProxyTest::WebSocketServerType::NoProxy);
+#endif
+
     // Set default proxy URI to point to proxyServer. Requests to kServer should be received by proxyServer instead.
     GUniquePtr<char> proxyURI(soup_uri_to_string(test->m_proxyServer.baseURI(), FALSE));
     WebKitNetworkProxySettings* settings = webkit_network_proxy_settings_new(proxyURI.get(), nullptr);
@@ -706,6 +758,12 @@
     ASSERT_CMP_CSTRING(mainResourceData, ==, proxyServerPortAsString.get());
     webkit_network_proxy_settings_free(settings);
 
+#if SOUP_CHECK_VERSION(2, 61, 90)
+    // WebSocket requests should also be received by proxyServer.
+    serverType = test->createWebSocketAndWaitUntilConnected();
+    g_assert(serverType == ProxyTest::WebSocketServerType::Proxy);
+#endif
+
     // Proxy settings also affect ephemeral web views.
     auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
 #if PLATFORM(WPE)
@@ -766,6 +824,10 @@
     webkit_web_context_set_network_proxy_settings(test->m_webContext.get(), WEBKIT_NETWORK_PROXY_MODE_DEFAULT, nullptr);
     mainResourceData = test->loadURIAndGetMainResourceData(kServer->getURIForPath("/echoPort").data());
     ASSERT_CMP_CSTRING(mainResourceData, ==, serverPortAsString.get());
+
+#if SOUP_CHECK_VERSION(2, 61, 90)
+    kServer->removeWebSocketHandler();
+#endif
 }
 
 void beforeAll()

Modified: trunk/Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.cpp (228087 => 228088)


--- trunk/Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.cpp	2018-02-05 08:46:44 UTC (rev 228087)
+++ trunk/Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.cpp	2018-02-05 09:02:24 UTC (rev 228088)
@@ -53,6 +53,10 @@
 WebKitTestServer::~WebKitTestServer()
 {
     soup_uri_free(m_baseURI);
+#if SOUP_CHECK_VERSION(2, 50, 0)
+    if (m_baseWebSocketURI)
+        soup_uri_free(m_baseWebSocketURI);
+#endif
 }
 
 void WebKitTestServer::run(SoupServerCallback serverCallback)
@@ -68,11 +72,48 @@
     }
 }
 
-CString WebKitTestServer::getURIForPath(const char* path)
+#if SOUP_CHECK_VERSION(2, 50, 0)
+void WebKitTestServer::addWebSocketHandler(SoupServerWebsocketCallback callback, gpointer userData)
 {
+    m_baseWebSocketURI = soup_uri_new_with_base(m_baseURI, "/websocket/");
+    m_baseWebSocketURI->scheme = m_baseWebSocketURI->scheme == SOUP_URI_SCHEME_HTTP ? SOUP_URI_SCHEME_WS : SOUP_URI_SCHEME_WSS;
+
+    if (m_queue) {
+        m_queue->dispatch([this, callback, userData] {
+            soup_server_add_websocket_handler(m_soupServer.get(), "/websocket", nullptr, nullptr, callback, userData, nullptr);
+        });
+    } else
+        soup_server_add_websocket_handler(m_soupServer.get(), "/websocket", nullptr, nullptr, callback, userData, nullptr);
+}
+
+void WebKitTestServer::removeWebSocketHandler()
+{
+    soup_uri_free(m_baseWebSocketURI);
+    m_baseWebSocketURI = nullptr;
+
+    if (m_queue) {
+        m_queue->dispatch([this] {
+            soup_server_remove_handler(m_soupServer.get(), "/websocket");
+        });
+    } else
+        soup_server_remove_handler(m_soupServer.get(), "/websocket");
+}
+
+CString WebKitTestServer::getWebSocketURIForPath(const char* path) const
+{
+    g_assert(m_baseWebSocketURI);
+    g_assert(path && *path == '/');
+    SoupURI* uri = soup_uri_new_with_base(m_baseWebSocketURI, path + 1); // Ignore the leading slash.
+    GUniquePtr<gchar> uriString(soup_uri_to_string(uri, FALSE));
+    soup_uri_free(uri);
+    return uriString.get();
+}
+#endif // SOUP_CHECK_VERSION(2, 50, 0)
+
+CString WebKitTestServer::getURIForPath(const char* path) const
+{
     SoupURI* uri = soup_uri_new_with_base(m_baseURI, path);
     GUniquePtr<gchar> uriString(soup_uri_to_string(uri, FALSE));
     soup_uri_free(uri);
     return uriString.get();
 }
-

Modified: trunk/Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.h (228087 => 228088)


--- trunk/Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.h	2018-02-05 08:46:44 UTC (rev 228087)
+++ trunk/Tools/TestWebKitAPI/glib/WebKitGLib/WebKitTestServer.h	2018-02-05 09:02:24 UTC (rev 228088)
@@ -36,13 +36,22 @@
     WebKitTestServer(ServerOptions = ServerHTTP);
     virtual ~WebKitTestServer();
 
-    SoupURI* baseURI() { return m_baseURI; }
-
-    CString getURIForPath(const char* path);
+    SoupURI* baseURI() const { return m_baseURI; }
+    CString getURIForPath(const char* path) const;
     void run(SoupServerCallback);
 
+#if SOUP_CHECK_VERSION(2, 50, 0)
+    void addWebSocketHandler(SoupServerWebsocketCallback, gpointer userData);
+    void removeWebSocketHandler();
+    SoupURI* baseWebSocketURI() const { return m_baseWebSocketURI; }
+    CString getWebSocketURIForPath(const char* path) const;
+#endif
+
 private:
     GRefPtr<SoupServer> m_soupServer;
-    SoupURI* m_baseURI;
+    SoupURI* m_baseURI { nullptr };
+#if SOUP_CHECK_VERSION(2, 50, 0)
+    SoupURI* m_baseWebSocketURI { nullptr };
+#endif
     RefPtr<WorkQueue> m_queue;
 };
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to