Changeset 249376 in webkit


Ignore:
Timestamp:
Sep 1, 2019 11:20:18 PM (5 years ago)
Author:
youenn@apple.com
Message:

Abstract out LibWebRTCSocketClient so that rtc sockets can be implemented without libwebrtc sockets
https://bugs.webkit.org/show_bug.cgi?id=201302

Reviewed by Alex Christensen.

Introduce NetworkRTCProvider::Socket to be able to implement RTC socket support with non libwebrtc API

  • NetworkProcess/webrtc/LibWebRTCSocketClient.h:
  • NetworkProcess/webrtc/NetworkRTCProvider.cpp:

(WebKit::NetworkRTCProvider::createSocket):
(WebKit::NetworkRTCProvider::createUDPSocket):
(WebKit::NetworkRTCProvider::createServerTCPSocket):
(WebKit::NetworkRTCProvider::proxyInfoFromSession):
(WebKit::NetworkRTCProvider::createClientTCPSocket):
(WebKit::NetworkRTCProvider::wrapNewTCPConnection):
(WebKit::NetworkRTCProvider::addSocket):
(WebKit::NetworkRTCProvider::takeSocket):
(WebKit::NetworkRTCProvider::newConnection):
(WebKit::NetworkRTCProvider::closeListeningSockets):
(WebKit::NetworkRTCProvider::callSocket):

  • NetworkProcess/webrtc/NetworkRTCProvider.h:
  • NetworkProcess/webrtc/NetworkRTCProvider.mm:

(WebKit::NetworkRTCProvider::createClientTCPSocket):

  • NetworkProcess/webrtc/NetworkRTCSocket.cpp:

(WebKit::NetworkRTCSocket::sendTo):
(WebKit::NetworkRTCSocket::close):
(WebKit::NetworkRTCSocket::setOption):

Location:
trunk/Source/WebKit
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebKit/ChangeLog

    r249375 r249376  
     12019-09-01  Youenn Fablet  <youenn@apple.com>
     2
     3        Abstract out LibWebRTCSocketClient so that rtc sockets can be implemented without libwebrtc sockets
     4        https://bugs.webkit.org/show_bug.cgi?id=201302
     5
     6        Reviewed by Alex Christensen.
     7
     8        Introduce NetworkRTCProvider::Socket to be able to implement RTC socket support with non libwebrtc API
     9
     10        * NetworkProcess/webrtc/LibWebRTCSocketClient.h:
     11        * NetworkProcess/webrtc/NetworkRTCProvider.cpp:
     12        (WebKit::NetworkRTCProvider::createSocket):
     13        (WebKit::NetworkRTCProvider::createUDPSocket):
     14        (WebKit::NetworkRTCProvider::createServerTCPSocket):
     15        (WebKit::NetworkRTCProvider::proxyInfoFromSession):
     16        (WebKit::NetworkRTCProvider::createClientTCPSocket):
     17        (WebKit::NetworkRTCProvider::wrapNewTCPConnection):
     18        (WebKit::NetworkRTCProvider::addSocket):
     19        (WebKit::NetworkRTCProvider::takeSocket):
     20        (WebKit::NetworkRTCProvider::newConnection):
     21        (WebKit::NetworkRTCProvider::closeListeningSockets):
     22        (WebKit::NetworkRTCProvider::callSocket):
     23        * NetworkProcess/webrtc/NetworkRTCProvider.h:
     24        * NetworkProcess/webrtc/NetworkRTCProvider.mm:
     25        (WebKit::NetworkRTCProvider::createClientTCPSocket):
     26        * NetworkProcess/webrtc/NetworkRTCSocket.cpp:
     27        (WebKit::NetworkRTCSocket::sendTo):
     28        (WebKit::NetworkRTCSocket::close):
     29        (WebKit::NetworkRTCSocket::setOption):
     30
    1312019-09-01  Fujii Hironori  <Hironori.Fujii@sony.com>
    232
  • trunk/Source/WebKit/NetworkProcess/webrtc/LibWebRTCSocketClient.h

    r248762 r249376  
    2828#if USE(LIBWEBRTC)
    2929
    30 #include <WebCore/LibWebRTCMacros.h>
     30#include "NetworkRTCProvider.h"
    3131#include <webrtc/rtc_base/asyncpacketsocket.h>
    32 #include <webrtc/rtc_base/third_party/sigslot/sigslot.h>
    3332
    3433namespace rtc {
    3534class AsyncPacketSocket;
    36 class SocketAddress;
    37 struct PacketOptions;
    3835struct SentPacket;
    3936typedef int64_t PacketTime;
    4037}
    4138
    42 namespace WebCore {
    43 class SharedBuffer;
    44 }
    45 
    4639namespace WebKit {
    4740
    48 class NetworkRTCProvider;
    49 
    50 class LibWebRTCSocketClient final : public sigslot::has_slots<> {
     41class LibWebRTCSocketClient final : public NetworkRTCProvider::Socket, public sigslot::has_slots<> {
    5142    WTF_MAKE_FAST_ALLOCATED;
    5243public:
    53     enum class Type { UDP, ServerTCP, ClientTCP, ServerConnectionTCP };
    54 
    5544    LibWebRTCSocketClient(uint64_t identifier, NetworkRTCProvider&, std::unique_ptr<rtc::AsyncPacketSocket>&&, Type);
    5645
    57     uint64_t identifier() const { return m_identifier; }
    58     Type type() const { return m_type; }
    59     void close();
     46private:
     47    uint64_t identifier() const final { return m_identifier; }
     48    Type type() const final { return m_type; }
     49    void close() final;
    6050
    61 private:
    62     friend class NetworkRTCSocket;
    63 
    64     void setOption(int option, int value);
    65     void sendTo(const WebCore::SharedBuffer&, const rtc::SocketAddress&, const rtc::PacketOptions&);
     51    void setOption(int option, int value) final;
     52    void sendTo(const WebCore::SharedBuffer&, const rtc::SocketAddress&, const rtc::PacketOptions&) final;
    6653
    6754    void signalReadPacket(rtc::AsyncPacketSocket*, const char*, size_t, const rtc::SocketAddress&, const rtc::PacketTime&);
  • trunk/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.cpp

    r248846 r249376  
    2929#if USE(LIBWEBRTC)
    3030
     31#include "LibWebRTCSocketClient.h"
    3132#include "Logging.h"
    3233#include "NetworkConnectionToWebProcess.h"
     
    9697}
    9798
    98 void NetworkRTCProvider::createSocket(uint64_t identifier, std::unique_ptr<rtc::AsyncPacketSocket>&& socket, LibWebRTCSocketClient::Type type)
     99void NetworkRTCProvider::createSocket(uint64_t identifier, std::unique_ptr<rtc::AsyncPacketSocket>&& socket, Socket::Type type)
    99100{
    100101    if (!socket) {
     
    112113    callOnRTCNetworkThread([this, identifier, address = RTCNetwork::isolatedCopy(address.value), minPort, maxPort]() {
    113114        std::unique_ptr<rtc::AsyncPacketSocket> socket(m_packetSocketFactory->CreateUdpSocket(address, minPort, maxPort));
    114         createSocket(identifier, WTFMove(socket), LibWebRTCSocketClient::Type::UDP);
     115        createSocket(identifier, WTFMove(socket), Socket::Type::UDP);
    115116    });
    116117}
     
    126127    callOnRTCNetworkThread([this, identifier, address = RTCNetwork::isolatedCopy(address.value), minPort, maxPort, options]() {
    127128        std::unique_ptr<rtc::AsyncPacketSocket> socket(m_packetSocketFactory->CreateServerTcpSocket(address, minPort, maxPort, options));
    128         createSocket(identifier, WTFMove(socket), LibWebRTCSocketClient::Type::ServerTCP);
     129        createSocket(identifier, WTFMove(socket), Socket::Type::ServerTCP);
    129130    });
    130131}
     
    146147    callOnRTCNetworkThread([this, identifier, localAddress = RTCNetwork::isolatedCopy(localAddress.value), remoteAddress = RTCNetwork::isolatedCopy(remoteAddress.value), proxyInfo = proxyInfoFromSession(remoteAddress, *session), userAgent = WTFMove(userAgent).isolatedCopy(), options]() {
    147148        std::unique_ptr<rtc::AsyncPacketSocket> socket(m_packetSocketFactory->CreateClientTcpSocket(localAddress, remoteAddress, proxyInfo, userAgent.utf8().data(), options));
    148         createSocket(identifier, WTFMove(socket), LibWebRTCSocketClient::Type::ClientTCP);
     149        createSocket(identifier, WTFMove(socket), Socket::Type::ClientTCP);
    149150    });
    150151}
     
    154155    callOnRTCNetworkThread([this, identifier, newConnectionSocketIdentifier]() {
    155156        std::unique_ptr<rtc::AsyncPacketSocket> socket = m_pendingIncomingSockets.take(newConnectionSocketIdentifier);
    156         addSocket(identifier, makeUnique<LibWebRTCSocketClient>(identifier, *this, WTFMove(socket), LibWebRTCSocketClient::Type::ServerConnectionTCP));
    157     });
    158 }
    159 
    160 void NetworkRTCProvider::addSocket(uint64_t identifier, std::unique_ptr<LibWebRTCSocketClient>&& socket)
     157        addSocket(identifier, makeUnique<LibWebRTCSocketClient>(identifier, *this, WTFMove(socket), Socket::Type::ServerConnectionTCP));
     158    });
     159}
     160
     161void NetworkRTCProvider::addSocket(uint64_t identifier, std::unique_ptr<Socket>&& socket)
    161162{
    162163    m_sockets.add(identifier, WTFMove(socket));
    163164}
    164165
    165 std::unique_ptr<LibWebRTCSocketClient> NetworkRTCProvider::takeSocket(uint64_t identifier)
     166std::unique_ptr<NetworkRTCProvider::Socket> NetworkRTCProvider::takeSocket(uint64_t identifier)
    166167{
    167168    return m_sockets.take(identifier);
    168169}
    169170
    170 void NetworkRTCProvider::newConnection(LibWebRTCSocketClient& serverSocket, std::unique_ptr<rtc::AsyncPacketSocket>&& newSocket)
     171void NetworkRTCProvider::newConnection(Socket& serverSocket, std::unique_ptr<rtc::AsyncPacketSocket>&& newSocket)
    171172{
    172173    sendFromMainThread([identifier = serverSocket.identifier(), incomingSocketIdentifier = ++m_incomingSocketIdentifier, remoteAddress = RTCNetwork::isolatedCopy(newSocket->GetRemoteAddress())](IPC::Connection& connection) {
     
    247248        Vector<uint64_t> listeningSocketIdentifiers;
    248249        for (auto& keyValue : m_sockets) {
    249             if (keyValue.value->type() == LibWebRTCSocketClient::Type::ServerTCP)
     250            if (keyValue.value->type() == Socket::Type::ServerTCP)
    250251                listeningSocketIdentifiers.append(keyValue.key);
    251252        }
     
    285286}
    286287
    287 void NetworkRTCProvider::callSocket(uint64_t identifier, Function<void(LibWebRTCSocketClient&)>&& callback)
     288void NetworkRTCProvider::callSocket(uint64_t identifier, Function<void(Socket&)>&& callback)
    288289{
    289290    callOnRTCNetworkThread([this, identifier, callback = WTFMove(callback)]() {
  • trunk/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.h

    r248592 r249376  
    2828#if USE(LIBWEBRTC)
    2929
    30 #include "LibWebRTCSocketClient.h"
    3130#include "NetworkRTCMonitor.h"
    3231#include "RTCNetwork.h"
     
    4342class Connection;
    4443class Decoder;
     44}
     45
     46namespace rtc {
     47class SocketAddress;
     48struct PacketOptions;
     49}
     50
     51namespace WebCore {
     52class SharedBuffer;
    4553}
    4654
     
    6068    void didReceiveNetworkRTCSocketMessage(IPC::Connection&, IPC::Decoder&);
    6169
    62     std::unique_ptr<LibWebRTCSocketClient> takeSocket(uint64_t);
     70    class Socket {
     71    public:
     72        virtual ~Socket() = default;
     73
     74        enum class Type : uint8_t { UDP, ServerTCP, ClientTCP, ServerConnectionTCP };
     75        virtual Type type() const  = 0;
     76        virtual uint64_t identifier() const = 0;
     77
     78        virtual void close() = 0;
     79        virtual void setOption(int option, int value) = 0;
     80        virtual void sendTo(const WebCore::SharedBuffer&, const rtc::SocketAddress&, const rtc::PacketOptions&) = 0;
     81    };
     82
     83    std::unique_ptr<Socket> takeSocket(uint64_t);
    6384    void resolverDone(uint64_t);
    6485
    6586    void close();
    6687
    67     void callSocket(uint64_t, Function<void(LibWebRTCSocketClient&)>&&);
     88    void callSocket(uint64_t, Function<void(Socket&)>&&);
    6889    void callOnRTCNetworkThread(Function<void()>&&);
    6990    void sendFromMainThread(Function<void(IPC::Connection&)>&&);
    7091
    71     void newConnection(LibWebRTCSocketClient&, std::unique_ptr<rtc::AsyncPacketSocket>&&);
     92    void newConnection(Socket&, std::unique_ptr<rtc::AsyncPacketSocket>&&);
    7293
    7394    void closeListeningSockets(Function<void()>&&);
     
    85106    void stopResolver(uint64_t);
    86107
    87     void addSocket(uint64_t, std::unique_ptr<LibWebRTCSocketClient>&&);
     108    void addSocket(uint64_t, std::unique_ptr<Socket>&&);
    88109
    89     void createSocket(uint64_t identifier, std::unique_ptr<rtc::AsyncPacketSocket>&&, LibWebRTCSocketClient::Type);
     110    void createSocket(uint64_t identifier, std::unique_ptr<rtc::AsyncPacketSocket>&&, Socket::Type);
    90111
    91112    void OnMessage(rtc::Message*);
     
    94115
    95116    HashMap<uint64_t, std::unique_ptr<NetworkRTCResolver>> m_resolvers;
    96     HashMap<uint64_t, std::unique_ptr<LibWebRTCSocketClient>> m_sockets;
     117    HashMap<uint64_t, std::unique_ptr<Socket>> m_sockets;
    97118    NetworkConnectionToWebProcess* m_connection;
    98119    bool m_isStarted { true };
  • trunk/Source/WebKit/NetworkProcess/webrtc/NetworkRTCSocket.cpp

    r222894 r249376  
    3030
    3131#include "DataReference.h"
    32 #include "LibWebRTCSocketClient.h"
    3332#include "NetworkRTCProvider.h"
    3433#include "RTCPacketOptions.h"
     
    4746{
    4847    auto buffer = WebCore::SharedBuffer::create(data.data(), data.size());
    49     m_rtcProvider.callSocket(m_identifier, [buffer = WTFMove(buffer), socketAddress = WTFMove(socketAddress), options = WTFMove(options.options)](LibWebRTCSocketClient& client) {
    50         client.sendTo(buffer.get(), socketAddress.value, options);
     48    m_rtcProvider.callSocket(m_identifier, [buffer = WTFMove(buffer), socketAddress = WTFMove(socketAddress), options = WTFMove(options.options)](auto& socket) {
     49        socket.sendTo(buffer.get(), socketAddress.value, options);
    5150    });
    5251}
     
    5453void NetworkRTCSocket::close()
    5554{
    56     m_rtcProvider.callSocket(m_identifier, [](LibWebRTCSocketClient& socket) {
     55    m_rtcProvider.callSocket(m_identifier, [](auto& socket) {
    5756        socket.close();
    5857    });
     
    6160void NetworkRTCSocket::setOption(int option, int value)
    6261{
    63     m_rtcProvider.callSocket(m_identifier, [option, value](LibWebRTCSocketClient& socket) {
     62    m_rtcProvider.callSocket(m_identifier, [option, value](auto& socket) {
    6463        socket.setOption(option, value);
    6564    });
Note: See TracChangeset for help on using the changeset viewer.