zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Connect TurnPort and TCPPort to AsyncPacketSocket::SignalSentPacket.

Browse Source 
To reduce the risk of future mistakes when connecting Ports, Port::OnSentPacket was made pure virtual to ensure that new implementations take care of it.

BUG=4173
R=pthatcher@webrtc.org

Review URL: https://codereview.webrtc.org/1577873003 .

Cr-Commit-Position: refs/heads/master@{#11247}
This commit is contained in:
Stefan Holmer
2016-01-14 13:15:45 +01:00
parent 268493a96b
commit 7307952a5b
13 changed files with 39 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
webrtc/p2p/base/p2ptransportchannel.cc
View File

@ -1424,8 +1424,7 @@ void P2PTransportChannel::OnReadPacket(Connection* connection,
}
}
void P2PTransportChannel::OnSentPacket(PortInterface* port,
const rtc::SentPacket& sent_packet) {
void P2PTransportChannel::OnSentPacket(const rtc::SentPacket& sent_packet) {
ASSERT(worker_thread_ == rtc::Thread::Current());
SignalSentPacket(this, sent_packet);

2
webrtc/p2p/base/p2ptransportchannel.h
View File

@ -232,7 +232,7 @@ class P2PTransportChannel : public TransportChannelImpl,
void OnConnectionStateChange(Connection* connection);
void OnReadPacket(Connection *connection, const char *data, size_t len,
const rtc::PacketTime& packet_time);
void OnSentPacket(PortInterface* port, const rtc::SentPacket& sent_packet);
void OnSentPacket(const rtc::SentPacket& sent_packet);
void OnReadyToSend(Connection* connection);
void OnConnectionDestroyed(Connection *connection);

4
webrtc/p2p/base/port.cc
View File

@ -310,10 +310,6 @@ void Port::OnReadPacket(
}
}
void Port::OnSentPacket(const rtc::SentPacket& sent_packet) {
PortInterface::SignalSentPacket(this, sent_packet);
}
void Port::OnReadyToSend() {
AddressMap::iterator iter = connections_.begin();
for (; iter != connections_.end(); ++iter) {

6
webrtc/p2p/base/port.h
View File

@ -280,7 +280,11 @@ class Port : public PortInterface, public rtc::MessageHandler,
const std::string& remote_ufrag);
// Called when a packet has been sent to the socket.
void OnSentPacket(const rtc::SentPacket& sent_packet);
// This is made pure virtual to notify subclasses of Port that they MUST
// listen to AsyncPacketSocket::SignalSentPacket and then call
// PortInterface::OnSentPacket.
virtual void OnSentPacket(rtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) = 0;
// Called when the socket is currently able to send.
void OnReadyToSend();

4
webrtc/p2p/base/port_unittest.cc
View File

@ -204,6 +204,10 @@ class TestPort : public Port {
}
private:
void OnSentPacket(rtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) {
PortInterface::SignalSentPacket(sent_packet);
}
rtc::scoped_ptr<ByteBuffer> last_stun_buf_;
rtc::scoped_ptr<IceMessage> last_stun_msg_;
int type_preference_ = 0;

2
webrtc/p2p/base/portinterface.h
View File

@ -116,7 +116,7 @@ class PortInterface {
const rtc::SocketAddress&> SignalReadPacket;
// Emitted each time a packet is sent on this port.
sigslot::signal2<PortInterface*, const rtc::SentPacket&> SignalSentPacket;
sigslot::signal1<const rtc::SentPacket&> SignalSentPacket;
virtual std::string ToString() const = 0;

2
webrtc/p2p/base/relayport.cc
View File

@ -754,7 +754,7 @@ void RelayEntry::OnReadPacket(
void RelayEntry::OnSentPacket(rtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) {
port_->OnSentPacket(sent_packet);
port_->OnSentPacket(socket, sent_packet);
}
void RelayEntry::OnReadyToSend(rtc::AsyncPacketSocket* socket) {

7
webrtc/p2p/base/relayport.h
View File

@ -29,7 +29,7 @@ class RelayConnection;
// is created. The RelayEntry will try to reach the remote destination
// by connecting to all available server addresses in a pre defined
// order with a small delay in between. When a connection is
// successful all other connection attemts are aborted.
// successful all other connection attempts are aborted.
class RelayPort : public Port {
public:
typedef std::pair<rtc::Socket::Option, int> OptionValue;
@ -96,6 +96,11 @@ class RelayPort : public Port {
ProtocolType proto,
const rtc::PacketTime& packet_time);
// The OnSentPacket callback is left empty here since they are handled by
// RelayEntry.
void OnSentPacket(rtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) override {}
private:
friend class RelayEntry;

2
webrtc/p2p/base/stunport.cc
View File

@ -340,7 +340,7 @@ void UDPPort::OnReadPacket(rtc::AsyncPacketSocket* socket,
void UDPPort::OnSentPacket(rtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) {
Port::OnSentPacket(sent_packet);
PortInterface::SignalSentPacket(sent_packet);
}
void UDPPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {

7
webrtc/p2p/base/tcpport.cc
View File

@ -258,6 +258,7 @@ void TCPPort::OnNewConnection(rtc::AsyncPacketSocket* socket,
incoming.socket = new_socket;
incoming.socket->SignalReadPacket.connect(this, &TCPPort::OnReadPacket);
incoming.socket->SignalReadyToSend.connect(this, &TCPPort::OnReadyToSend);
incoming.socket->SignalSentPacket.connect(this, &TCPPort::OnSentPacket);
LOG_J(LS_VERBOSE, this) << "Accepted connection from "
<< incoming.addr.ToSensitiveString();
@ -286,6 +287,12 @@ void TCPPort::OnReadPacket(rtc::AsyncPacketSocket* socket,
Port::OnReadPacket(data, size, remote_addr, PROTO_TCP);
}
void TCPPort::OnSentPacket(rtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) {
ASSERT(socket == socket_);
PortInterface::SignalSentPacket(sent_packet);
}
void TCPPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
Port::OnReadyToSend();
}

3
webrtc/p2p/base/tcpport.h
View File

@ -96,6 +96,9 @@ class TCPPort : public Port {
const rtc::SocketAddress& remote_addr,
const rtc::PacketTime& packet_time);
void OnSentPacket(rtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) override;
void OnReadyToSend(rtc::AsyncPacketSocket* socket);
void OnAddressReady(rtc::AsyncPacketSocket* socket,

7
webrtc/p2p/base/turnport.cc
View File

@ -351,6 +351,8 @@ bool TurnPort::CreateTurnClientSocket() {
socket_->SignalReadyToSend.connect(this, &TurnPort::OnReadyToSend);
socket_->SignalSentPacket.connect(this, &TurnPort::OnSentPacket);
// TCP port is ready to send stun requests after the socket is connected,
// while UDP port is ready to do so once the socket is created.
if (server_address_.proto == PROTO_TCP) {
@ -582,6 +584,11 @@ void TurnPort::OnReadPacket(
}
}
void TurnPort::OnSentPacket(rtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) {
PortInterface::SignalSentPacket(sent_packet);
}
void TurnPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
if (ready()) {
Port::OnReadyToSend();

2
webrtc/p2p/base/turnport.h
View File

@ -106,6 +106,8 @@ class TurnPort : public Port {
const rtc::SocketAddress& remote_addr,
const rtc::PacketTime& packet_time);
virtual void OnSentPacket(rtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet);
virtual void OnReadyToSend(rtc::AsyncPacketSocket* socket);
virtual bool SupportsProtocol(const std::string& protocol) const {
// Turn port only connects to UDP candidates.