Modified: trunk/Source/WebKit/NetworkProcess/webrtc/NetworkRTCMonitor.cpp (264813 => 264814)
--- trunk/Source/WebKit/NetworkProcess/webrtc/NetworkRTCMonitor.cpp 2020-07-24 07:30:32 UTC (rev 264813)
+++ trunk/Source/WebKit/NetworkProcess/webrtc/NetworkRTCMonitor.cpp 2020-07-24 09:58:46 UTC (rev 264814)
@@ -32,7 +32,9 @@
#include "Logging.h"
#include "NetworkRTCProvider.h"
#include "WebRTCMonitorMessages.h"
+#include <webrtc/rtc_base/third_party/sigslot/sigslot.h>
#include <wtf/Function.h>
+#include <wtf/WeakHashSet.h>
namespace WebKit {
@@ -40,47 +42,73 @@
#define RELEASE_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(m_rtcProvider.canLog(), Network, "%p - NetworkRTCMonitor::" fmt, this, ##__VA_ARGS__)
-NetworkRTCMonitor::~NetworkRTCMonitor()
+class NetworkManagerWrapper final : public sigslot::has_slots<> {
+public:
+ void addListener(NetworkRTCMonitor&);
+ void removeListener(NetworkRTCMonitor&);
+
+private:
+ void onNetworksChanged();
+
+ std::unique_ptr<rtc::BasicNetworkManager> m_manager;
+ WeakHashSet<NetworkRTCMonitor> m_observers;
+
+ bool m_didReceiveResults { false };
+ Vector<RTCNetwork> m_networkList;
+ RTCNetwork::IPAddress m_ipv4;
+ RTCNetwork::IPAddress m_ipv6;
+};
+
+static NetworkManagerWrapper& networkManager()
{
- ASSERT(!m_manager);
+ static NeverDestroyed<NetworkManagerWrapper> networkManager;
+ return networkManager.get();
}
-void NetworkRTCMonitor::startUpdatingIfNeeded()
+void NetworkManagerWrapper::addListener(NetworkRTCMonitor& monitor)
{
- RELEASE_LOG_IF_ALLOWED("startUpdatingIfNeeded %d", m_isStarted);
- if (m_isStarted)
+ bool shouldStart = m_observers.computesEmpty();
+ m_observers.add(monitor);
+ if (!shouldStart) {
+ if (m_didReceiveResults)
+ monitor.onNetworksChanged(m_networkList, m_ipv4, m_ipv6);
return;
+ }
- m_isStarted = true;
- m_rtcProvider.callOnRTCNetworkThread([this]() {
- RELEASE_LOG_IF_ALLOWED("startUpdating from network thread");
+ monitor.rtcProvider().callOnRTCNetworkThread([this]() {
+ if (m_manager)
+ return;
+ RELEASE_LOG(WebRTC, "NetworkManagerWrapper startUpdating");
m_manager = makeUniqueWithoutFastMallocCheck<rtc::BasicNetworkManager>();
- m_manager->SignalNetworksChanged.connect(this, &NetworkRTCMonitor::onNetworksChanged);
+ m_manager->SignalNetworksChanged.connect(this, &NetworkManagerWrapper::onNetworksChanged);
m_manager->StartUpdating();
});
}
-void NetworkRTCMonitor::stopUpdating()
+void NetworkManagerWrapper::removeListener(NetworkRTCMonitor& monitor)
{
- RELEASE_LOG_IF_ALLOWED("stopUpdating");
- m_isStarted = false;
- m_rtcProvider.callOnRTCNetworkThread([this]() {
- RELEASE_LOG_IF_ALLOWED("stopUpdating from network thread %p", m_manager.get());
+ m_observers.remove(monitor);
+ if (!m_observers.computesEmpty())
+ return;
+ monitor.rtcProvider().callOnRTCNetworkThread([this]() {
if (!m_manager)
return;
+
+ RELEASE_LOG(WebRTC, "NetworkManagerWrapper stopUpdating");
m_manager->StopUpdating();
m_manager = nullptr;
});
}
-void NetworkRTCMonitor::onNetworksChanged()
+void NetworkManagerWrapper::onNetworksChanged()
{
- RELEASE_LOG_IF_ALLOWED("onNetworksChanged");
+ RELEASE_LOG(WebRTC, "NetworkManagerWrapper::onNetworksChanged");
rtc::BasicNetworkManager::NetworkList networks;
m_manager->GetNetworks(&networks);
+ auto networkList = WTF::map(networks, [](auto& network) { return RTCNetwork { *network }; });
RTCNetwork::IPAddress ipv4;
m_manager->GetDefaultLocalAddress(AF_INET, &ipv4.value);
@@ -87,19 +115,42 @@
RTCNetwork::IPAddress ipv6;
m_manager->GetDefaultLocalAddress(AF_INET6, &ipv6.value);
- Vector<RTCNetwork> networkList;
- networkList.reserveInitialCapacity(networks.size());
- for (auto* network : networks) {
- ASSERT(network);
- networkList.uncheckedAppend(RTCNetwork { *network });
- }
+ callOnMainThread([this, networkList = WTFMove(networkList), ipv4 = WTFMove(ipv4), ipv6 = WTFMove(ipv6)]() mutable {
+ m_didReceiveResults = true;
- m_rtcProvider.sendFromMainThread([this, networkList = WTFMove(networkList), ipv4 = WTFMove(ipv4), ipv6 = WTFMove(ipv6)](IPC::Connection& connection) {
- RELEASE_LOG_IF_ALLOWED("onNetworksChanged sent");
- connection.send(Messages::WebRTCMonitor::NetworksChanged(networkList, ipv4, ipv6), 0);
+ m_networkList = WTFMove(networkList);
+ m_ipv4 = WTFMove(ipv4);
+ m_ipv6 = WTFMove(ipv6);
+
+ m_observers.forEach([this](auto& observer) {
+ observer.onNetworksChanged(m_networkList, m_ipv4, m_ipv6);
+ });
});
}
+NetworkRTCMonitor::~NetworkRTCMonitor()
+{
+ ASSERT(!m_manager);
+}
+
+void NetworkRTCMonitor::startUpdatingIfNeeded()
+{
+ RELEASE_LOG_IF_ALLOWED("startUpdatingIfNeeded %d", m_isStarted);
+ networkManager().addListener(*this);
+}
+
+void NetworkRTCMonitor::stopUpdating()
+{
+ RELEASE_LOG_IF_ALLOWED("stopUpdating");
+ networkManager().removeListener(*this);
+}
+
+void NetworkRTCMonitor::onNetworksChanged(const Vector<RTCNetwork>& networkList, const RTCNetwork::IPAddress& ipv4, const RTCNetwork::IPAddress& ipv6)
+{
+ RELEASE_LOG_IF_ALLOWED("onNetworksChanged sent");
+ m_rtcProvider.connection().send(Messages::WebRTCMonitor::NetworksChanged(networkList, ipv4, ipv6), 0);
+}
+
} // namespace WebKit
#endif // USE(LIBWEBRTC)
Modified: trunk/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.cpp (264813 => 264814)
--- trunk/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.cpp 2020-07-24 07:30:32 UTC (rev 264813)
+++ trunk/Source/WebKit/NetworkProcess/webrtc/NetworkRTCProvider.cpp 2020-07-24 09:58:46 UTC (rev 264814)
@@ -56,13 +56,18 @@
#define RELEASE_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(canLog(), Network, "%p - NetworkRTCProvider::" fmt, this, ##__VA_ARGS__)
#define RELEASE_LOG_ERROR_IF_ALLOWED(fmt, ...) RELEASE_LOG_ERROR_IF(canLog(), Network, "%p - NetworkRTCProvider::" fmt, this, ##__VA_ARGS__)
-static inline std::unique_ptr<rtc::Thread> createThread()
+static rtc::Thread& rtcNetworkThread()
{
- auto thread = rtc::Thread::CreateWithSocketServer();
- auto result = thread->Start();
- ASSERT_UNUSED(result, result);
- // FIXME: Set thread name.
- return thread;
+ static NeverDestroyed<std::unique_ptr<rtc::Thread>> networkThread;
+ static std::once_flag onceKey;
+ std::call_once(onceKey, [] {
+ networkThread.get() = rtc::Thread::CreateWithSocketServer();
+ networkThread.get()->SetName("RTC Network Thread", nullptr);
+
+ auto result = networkThread.get()->Start();
+ ASSERT_UNUSED(result, result);
+ });
+ return *networkThread.get();
}
#if !RELEASE_LOG_DISABLED
@@ -79,8 +84,8 @@
: m_connection(&connection)
, m_ipcConnection(makeRef(connection.connection()))
, m_rtcMonitor(*this)
- , m_rtcNetworkThread(createThread())
- , m_packetSocketFactory(makeUniqueRefWithoutFastMallocCheck<rtc::BasicPacketSocketFactory>(m_rtcNetworkThread.get()))
+ , m_rtcNetworkThread(rtcNetworkThread())
+ , m_packetSocketFactory(makeUniqueRefWithoutFastMallocCheck<rtc::BasicPacketSocketFactory>(&m_rtcNetworkThread))
, m_canLog(connection.sessionID().isAlwaysOnLoggingAllowed())
{
#if !RELEASE_LOG_DISABLED
@@ -110,16 +115,12 @@
callOnRTCNetworkThread([this]() {
m_sockets.clear();
- callOnMainThread([provider = makeRef(*this)]() {
- if (provider->m_rtcNetworkThread)
- provider->m_rtcNetworkThread->Stop();
- });
});
}
void NetworkRTCProvider::createSocket(LibWebRTCSocketIdentifier identifier, std::unique_ptr<rtc::AsyncPacketSocket>&& socket, Socket::Type type, Ref<IPC::Connection>&& connection)
{
- ASSERT(m_rtcNetworkThread->IsCurrent());
+ ASSERT(m_rtcNetworkThread.IsCurrent());
if (!socket) {
RELEASE_LOG_ERROR_IF_ALLOWED("createSocket with %u sockets is unable to create a new socket", m_sockets.size());
connection->send(Messages::LibWebRTCNetwork::SignalClose(identifier, 1), 0);
@@ -130,7 +131,7 @@
void NetworkRTCProvider::createUDPSocket(LibWebRTCSocketIdentifier identifier, const RTCNetwork::SocketAddress& address, uint16_t minPort, uint16_t maxPort)
{
- ASSERT(m_rtcNetworkThread->IsCurrent());
+ ASSERT(m_rtcNetworkThread.IsCurrent());
std::unique_ptr<rtc::AsyncPacketSocket> socket(m_packetSocketFactory->CreateUdpSocket(address.value, minPort, maxPort));
createSocket(identifier, WTFMove(socket), Socket::Type::UDP, m_ipcConnection.copyRef());
}
@@ -137,7 +138,7 @@
void NetworkRTCProvider::createServerTCPSocket(LibWebRTCSocketIdentifier identifier, const RTCNetwork::SocketAddress& address, uint16_t minPort, uint16_t maxPort, int options)
{
- ASSERT(m_rtcNetworkThread->IsCurrent());
+ ASSERT(m_rtcNetworkThread.IsCurrent());
callOnMainThread([this, protectedThis = makeRef(*this), identifier, address, minPort, maxPort, options] {
if (!m_isListeningSocketAuthorized) {
if (m_connection)
@@ -178,7 +179,7 @@
void NetworkRTCProvider::wrapNewTCPConnection(LibWebRTCSocketIdentifier identifier, LibWebRTCSocketIdentifier newConnectionSocketIdentifier)
{
- ASSERT(m_rtcNetworkThread->IsCurrent());
+ ASSERT(m_rtcNetworkThread.IsCurrent());
auto socket = m_pendingIncomingSockets.take(newConnectionSocketIdentifier);
RELEASE_LOG_IF(!socket, WebRTC, "NetworkRTCProvider::wrapNewTCPConnection received an invalid socket identifier");
if (socket)
@@ -187,7 +188,7 @@
void NetworkRTCProvider::sendToSocket(LibWebRTCSocketIdentifier identifier, const IPC::DataReference& data, RTCNetwork::SocketAddress&& address, RTCPacketOptions&& options)
{
- ASSERT(m_rtcNetworkThread->IsCurrent());
+ ASSERT(m_rtcNetworkThread.IsCurrent());
auto* socket = m_sockets.get(identifier);
if (!socket)
return;
@@ -197,7 +198,7 @@
void NetworkRTCProvider::closeSocket(LibWebRTCSocketIdentifier identifier)
{
- ASSERT(m_rtcNetworkThread->IsCurrent());
+ ASSERT(m_rtcNetworkThread.IsCurrent());
auto* socket = m_sockets.get(identifier);
if (!socket)
return;
@@ -206,7 +207,7 @@
void NetworkRTCProvider::setSocketOption(LibWebRTCSocketIdentifier identifier, int option, int value)
{
- ASSERT(m_rtcNetworkThread->IsCurrent());
+ ASSERT(m_rtcNetworkThread.IsCurrent());
auto* socket = m_sockets.get(identifier);
if (!socket)
return;
@@ -215,19 +216,19 @@
void NetworkRTCProvider::addSocket(LibWebRTCSocketIdentifier identifier, std::unique_ptr<Socket>&& socket)
{
- ASSERT(m_rtcNetworkThread->IsCurrent());
+ ASSERT(m_rtcNetworkThread.IsCurrent());
m_sockets.add(identifier, WTFMove(socket));
}
std::unique_ptr<NetworkRTCProvider::Socket> NetworkRTCProvider::takeSocket(LibWebRTCSocketIdentifier identifier)
{
- ASSERT(m_rtcNetworkThread->IsCurrent());
+ ASSERT(m_rtcNetworkThread.IsCurrent());
return m_sockets.take(identifier);
}
void NetworkRTCProvider::newConnection(Socket& serverSocket, std::unique_ptr<rtc::AsyncPacketSocket>&& newSocket)
{
- ASSERT(m_rtcNetworkThread->IsCurrent());
+ ASSERT(m_rtcNetworkThread.IsCurrent());
auto incomingSocketIdentifier = LibWebRTCSocketIdentifier::generate();
m_ipcConnection->send(Messages::LibWebRTCNetwork::SignalNewConnection(serverSocket.identifier(), incomingSocketIdentifier, RTCNetwork::SocketAddress(newSocket->GetRemoteAddress())), 0);
m_pendingIncomingSockets.add(incomingSocketIdentifier, WTFMove(newSocket));
@@ -337,7 +338,7 @@
void NetworkRTCProvider::callOnRTCNetworkThread(Function<void()>&& callback)
{
- m_rtcNetworkThread->Post(RTC_FROM_HERE, this, 1, new NetworkMessageData(*this, WTFMove(callback)));
+ m_rtcNetworkThread.Post(RTC_FROM_HERE, this, 1, new NetworkMessageData(*this, WTFMove(callback)));
}
void NetworkRTCProvider::sendFromMainThread(Function<void(IPC::Connection&)>&& callback)
