From 33f69db1c8a51a212995a26e3b77d90cccc685c7 Mon Sep 17 00:00:00 2001 From: Steve Anton Date: Mon, 30 Oct 2017 10:01:15 -0700 Subject: [PATCH] Fix clang style warnings in p2p/base/packettransport files Bug: webrtc:163 Change-Id: I10fb72c1ae01b6715f4d13e43860c80a6dfc9d87 Reviewed-on: https://webrtc-review.googlesource.com/16362 Commit-Queue: Steve Anton Reviewed-by: Karl Wiberg Cr-Commit-Position: refs/heads/master@{#20485} --- p2p/BUILD.gn | 3 ++ p2p/base/dtlstransport.cc | 62 ++++++++++++++++++++++++++++- p2p/base/dtlstransport.h | 41 ++++++------------- p2p/base/dtlstransportinternal.cc | 23 +++++++++++ p2p/base/dtlstransportinternal.h | 8 ++-- p2p/base/icetransportinternal.cc | 33 +++++++++++++++ p2p/base/icetransportinternal.h | 15 +++---- p2p/base/p2ptransportchannel.cc | 30 +++++++++++++- p2p/base/p2ptransportchannel.h | 18 ++++----- p2p/base/packettransportinternal.cc | 27 +++++++++++++ p2p/base/packettransportinternal.h | 7 +++- p2p/base/udptransport.cc | 21 ++++++++++ p2p/base/udptransport.h | 15 +++---- 13 files changed, 237 insertions(+), 66 deletions(-) create mode 100644 p2p/base/dtlstransportinternal.cc create mode 100644 p2p/base/icetransportinternal.cc create mode 100644 p2p/base/packettransportinternal.cc diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn index dc5e6422ed..dba55777e4 100644 --- a/p2p/BUILD.gn +++ b/p2p/BUILD.gn @@ -30,7 +30,9 @@ rtc_static_library("rtc_p2p") { "base/common.h", "base/dtlstransport.cc", "base/dtlstransport.h", + "base/dtlstransportinternal.cc", "base/dtlstransportinternal.h", + "base/icetransportinternal.cc", "base/icetransportinternal.h", "base/jseptransport.cc", "base/jseptransport.h", @@ -43,6 +45,7 @@ rtc_static_library("rtc_p2p") { "base/packetsocketfactory.cc", "base/packetsocketfactory.h", "base/packettransportinterface.h", + "base/packettransportinternal.cc", "base/packettransportinternal.h", "base/port.cc", "base/port.h", diff --git a/p2p/base/dtlstransport.cc b/p2p/base/dtlstransport.cc index fbbb95840b..267d0c7b40 100644 --- a/p2p/base/dtlstransport.cc +++ b/p2p/base/dtlstransport.cc @@ -104,6 +104,10 @@ bool StreamInterfaceChannel::OnPacketReceived(const char* data, size_t size) { return ret; } +rtc::StreamState StreamInterfaceChannel::GetState() const { + return state_; +} + void StreamInterfaceChannel::Close() { packets_.Clear(); state_ = rtc::SS_CLOSED; @@ -130,7 +134,27 @@ DtlsTransport::DtlsTransport(IceTransportInternal* ice_transport, this, &DtlsTransport::OnReceivingState); } -DtlsTransport::~DtlsTransport() {} +DtlsTransport::~DtlsTransport() = default; + +const rtc::CryptoOptions& DtlsTransport::crypto_options() const { + return crypto_options_; +} + +DtlsTransportState DtlsTransport::dtls_state() const { + return dtls_state_; +} + +const std::string& DtlsTransport::transport_name() const { + return transport_name_; +} + +int DtlsTransport::component() const { + return component_; +} + +bool DtlsTransport::IsDtlsActive() const { + return dtls_active_; +} bool DtlsTransport::SetLocalCertificate( const rtc::scoped_refptr& certificate) { @@ -276,6 +300,18 @@ std::unique_ptr DtlsTransport::GetRemoteSSLCertificate() return dtls_->GetPeerCertificate(); } +bool DtlsTransport::ExportKeyingMaterial(const std::string& label, + const uint8_t* context, + size_t context_len, + bool use_context, + uint8_t* result, + size_t result_len) { + return (dtls_.get()) + ? dtls_->ExportKeyingMaterial(label, context, context_len, + use_context, result, result_len) + : false; +} + bool DtlsTransport::SetupDtls() { StreamInterfaceChannel* downward = new StreamInterfaceChannel(ice_transport_); @@ -371,10 +407,34 @@ int DtlsTransport::SendPacket(const char* data, } } +IceTransportInternal* DtlsTransport::ice_transport() { + return ice_transport_; +} + bool DtlsTransport::IsDtlsConnected() { return dtls_ && dtls_->IsTlsConnected(); } +bool DtlsTransport::receiving() const { + return receiving_; +} + +bool DtlsTransport::writable() const { + return writable_; +} + +int DtlsTransport::GetError() { + return ice_transport_->GetError(); +} + +bool DtlsTransport::GetOption(rtc::Socket::Option opt, int* value) { + return ice_transport_->GetOption(opt, value); +} + +int DtlsTransport::SetOption(rtc::Socket::Option opt, int value) { + return ice_transport_->SetOption(opt, value); +} + // The state transition logic here is as follows: // (1) If we're not doing DTLS-SRTP, then the state is just the // state of the underlying impl() diff --git a/p2p/base/dtlstransport.h b/p2p/base/dtlstransport.h index 00a4b4a303..eb86deb337 100644 --- a/p2p/base/dtlstransport.h +++ b/p2p/base/dtlstransport.h @@ -39,7 +39,7 @@ class StreamInterfaceChannel : public rtc::StreamInterface { bool OnPacketReceived(const char* data, size_t size); // Implementations of StreamInterface - rtc::StreamState GetState() const override { return state_; } + rtc::StreamState GetState() const override; void Close() override; rtc::StreamResult Read(void* buffer, size_t buffer_len, @@ -93,19 +93,14 @@ class DtlsTransport : public DtlsTransportInternal { const rtc::CryptoOptions& crypto_options); ~DtlsTransport() override; - const rtc::CryptoOptions& crypto_options() const override { - return crypto_options_; - } - - DtlsTransportState dtls_state() const override { return dtls_state_; } - - const std::string& transport_name() const override { return transport_name_; } - - int component() const override { return component_; } + const rtc::CryptoOptions& crypto_options() const override; + DtlsTransportState dtls_state() const override; + const std::string& transport_name() const override; + int component() const override; // Returns false if no local certificate was set, or if the peer doesn't // support DTLS. - bool IsDtlsActive() const override { return dtls_active_; } + bool IsDtlsActive() const override; bool SetLocalCertificate( const rtc::scoped_refptr& certificate) override; @@ -121,9 +116,7 @@ class DtlsTransport : public DtlsTransportInternal { const rtc::PacketOptions& options, int flags) override; - bool GetOption(rtc::Socket::Option opt, int* value) override { - return ice_transport_->GetOption(opt, value); - } + bool GetOption(rtc::Socket::Option opt, int* value) override; virtual bool SetSslMaxProtocolVersion(rtc::SSLProtocolVersion version); @@ -149,29 +142,21 @@ class DtlsTransport : public DtlsTransportInternal { size_t context_len, bool use_context, uint8_t* result, - size_t result_len) override { - return (dtls_.get()) - ? dtls_->ExportKeyingMaterial(label, context, context_len, - use_context, result, result_len) - : false; - } + size_t result_len) override; - IceTransportInternal* ice_transport() override { return ice_transport_; } + IceTransportInternal* ice_transport() override; // For informational purposes. Tells if the DTLS handshake has finished. // This may be true even if writable() is false, if the remote fingerprint // has not yet been verified. bool IsDtlsConnected(); - bool receiving() const override { return receiving_; } + bool receiving() const override; + bool writable() const override; - bool writable() const override { return writable_; } + int GetError() override; - int GetError() override { return ice_transport_->GetError(); } - - int SetOption(rtc::Socket::Option opt, int value) override { - return ice_transport_->SetOption(opt, value); - } + int SetOption(rtc::Socket::Option opt, int value) override; std::string ToString() const { const char RECEIVING_ABBREV[2] = {'_', 'R'}; diff --git a/p2p/base/dtlstransportinternal.cc b/p2p/base/dtlstransportinternal.cc new file mode 100644 index 0000000000..5e28cb0022 --- /dev/null +++ b/p2p/base/dtlstransportinternal.cc @@ -0,0 +1,23 @@ +/* + * Copyright 2017 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "p2p/base/dtlstransportinternal.h" + +namespace cricket { + +DtlsTransportInternal::DtlsTransportInternal() = default; + +DtlsTransportInternal::~DtlsTransportInternal() = default; + +std::string DtlsTransportInternal::debug_name() const { + return transport_name() + " " + rtc::ToString(component()); +} + +} // namespace cricket diff --git a/p2p/base/dtlstransportinternal.h b/p2p/base/dtlstransportinternal.h index e7343140ad..be3db6b663 100644 --- a/p2p/base/dtlstransportinternal.h +++ b/p2p/base/dtlstransportinternal.h @@ -37,7 +37,7 @@ enum PacketFlags { // the DtlsTransportInterface will be split from this class. class DtlsTransportInternal : public rtc::PacketTransportInternal { public: - virtual ~DtlsTransportInternal() {} + ~DtlsTransportInternal() override; virtual const rtc::CryptoOptions& crypto_options() const = 0; @@ -94,12 +94,10 @@ class DtlsTransportInternal : public rtc::PacketTransportInternal { sigslot::signal1 SignalDtlsHandshakeError; // Debugging description of this transport. - std::string debug_name() const override { - return transport_name() + " " + rtc::ToString(component()); - } + std::string debug_name() const override; protected: - DtlsTransportInternal() {} + DtlsTransportInternal(); private: RTC_DISALLOW_COPY_AND_ASSIGN(DtlsTransportInternal); diff --git a/p2p/base/icetransportinternal.cc b/p2p/base/icetransportinternal.cc new file mode 100644 index 0000000000..a741205c21 --- /dev/null +++ b/p2p/base/icetransportinternal.cc @@ -0,0 +1,33 @@ +/* + * Copyright 2017 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "p2p/base/icetransportinternal.h" + +namespace cricket { + +IceTransportInternal::IceTransportInternal() = default; + +IceTransportInternal::~IceTransportInternal() = default; + +void IceTransportInternal::SetIceCredentials(const std::string& ice_ufrag, + const std::string& ice_pwd) { + SetIceParameters(IceParameters(ice_ufrag, ice_pwd, false)); +} + +void IceTransportInternal::SetRemoteIceCredentials(const std::string& ice_ufrag, + const std::string& ice_pwd) { + SetRemoteIceParameters(IceParameters(ice_ufrag, ice_pwd, false)); +} + +std::string IceTransportInternal::debug_name() const { + return transport_name() + " " + rtc::ToString(component()); +} + +} // namespace cricket diff --git a/p2p/base/icetransportinternal.h b/p2p/base/icetransportinternal.h index 48f8806277..b7dfc42fed 100644 --- a/p2p/base/icetransportinternal.h +++ b/p2p/base/icetransportinternal.h @@ -47,7 +47,8 @@ enum IceProtocolType { // the IceTransportInterface will be split from this class. class IceTransportInternal : public rtc::PacketTransportInternal { public: - virtual ~IceTransportInternal(){}; + IceTransportInternal(); + ~IceTransportInternal() override; virtual IceTransportState GetState() const = 0; @@ -66,14 +67,10 @@ class IceTransportInternal : public rtc::PacketTransportInternal { virtual void SetIceProtocolType(IceProtocolType type) {} virtual void SetIceCredentials(const std::string& ice_ufrag, - const std::string& ice_pwd) { - SetIceParameters(IceParameters(ice_ufrag, ice_pwd, false)); - } + const std::string& ice_pwd); virtual void SetRemoteIceCredentials(const std::string& ice_ufrag, - const std::string& ice_pwd) { - SetRemoteIceParameters(IceParameters(ice_ufrag, ice_pwd, false)); - } + const std::string& ice_pwd); // The ufrag and pwd in |ice_params| must be set // before candidate gathering can start. @@ -140,9 +137,7 @@ class IceTransportInternal : public rtc::PacketTransportInternal { sigslot::signal1 SignalDestroyed; // Debugging description of this transport. - std::string debug_name() const override { - return transport_name() + " " + rtc::ToString(component()); - } + std::string debug_name() const override; }; } // namespace cricket diff --git a/p2p/base/p2ptransportchannel.cc b/p2p/base/p2ptransportchannel.cc index 0b3b073859..cebff9ee3d 100644 --- a/p2p/base/p2ptransportchannel.cc +++ b/p2p/base/p2ptransportchannel.cc @@ -264,6 +264,10 @@ void P2PTransportChannel::SetIceRole(IceRole ice_role) { } } +IceRole P2PTransportChannel::GetIceRole() const { + return ice_role_; +} + void P2PTransportChannel::SetIceTiebreaker(uint64_t tiebreaker) { RTC_DCHECK(network_thread_ == rtc::Thread::Current()); if (!ports_.empty() || !pruned_ports_.empty()) { @@ -279,6 +283,26 @@ IceTransportState P2PTransportChannel::GetState() const { return state_; } +const std::string& P2PTransportChannel::transport_name() const { + return transport_name_; +} + +int P2PTransportChannel::component() const { + return component_; +} + +bool P2PTransportChannel::writable() const { + return writable_; +} + +bool P2PTransportChannel::receiving() const { + return receiving_; +} + +IceGatheringState P2PTransportChannel::gathering_state() const { + return gathering_state_; +} + rtc::Optional P2PTransportChannel::GetRttEstimate() { if (selected_connection_ != nullptr && selected_connection_->rtt_samples() > 0) { @@ -1009,6 +1033,10 @@ bool P2PTransportChannel::GetOption(rtc::Socket::Option opt, int* value) { return true; } +int P2PTransportChannel::GetError() { + return error_; +} + // Send data to the other side, using our selected connection. int P2PTransportChannel::SendPacket(const char *data, size_t len, const rtc::PacketOptions& options, @@ -2032,7 +2060,7 @@ void P2PTransportChannel::OnReadyToSend(Connection* connection) { Connection* P2PTransportChannel::FindOldestConnectionNeedingTriggeredCheck( int64_t now) { Connection* oldest_needing_triggered_check = nullptr; - for (auto conn : connections_) { + for (auto* conn : connections_) { if (!IsPingable(conn, now)) { continue; } diff --git a/p2p/base/p2ptransportchannel.h b/p2p/base/p2ptransportchannel.h index 56ca57e11e..f9e9a53761 100644 --- a/p2p/base/p2ptransportchannel.h +++ b/p2p/base/p2ptransportchannel.h @@ -68,16 +68,16 @@ class P2PTransportChannel : public IceTransportInternal, P2PTransportChannel(const std::string& transport_name, int component, PortAllocator* allocator); - virtual ~P2PTransportChannel(); + ~P2PTransportChannel() override; // From TransportChannelImpl: IceTransportState GetState() const override; - const std::string& transport_name() const override { return transport_name_; } - int component() const override { return component_; } - bool writable() const override { return writable_; } - bool receiving() const override { return receiving_; } + const std::string& transport_name() const override; + int component() const override; + bool writable() const override; + bool receiving() const override; void SetIceRole(IceRole role) override; - IceRole GetIceRole() const override { return ice_role_; } + IceRole GetIceRole() const override; void SetIceTiebreaker(uint64_t tiebreaker) override; void SetIceParameters(const IceParameters& ice_params) override; void SetRemoteIceParameters(const IceParameters& ice_params) override; @@ -86,9 +86,7 @@ class P2PTransportChannel : public IceTransportInternal, // IceTransportChannel does not depend on this. void Connect() {} void MaybeStartGathering() override; - IceGatheringState gathering_state() const override { - return gathering_state_; - } + IceGatheringState gathering_state() const override; void AddRemoteCandidate(const Candidate& candidate) override; void RemoveRemoteCandidate(const Candidate& candidate) override; // Sets the parameters in IceConfig. We do not set them blindly. Instead, we @@ -107,7 +105,7 @@ class P2PTransportChannel : public IceTransportInternal, int flags) override; int SetOption(rtc::Socket::Option opt, int value) override; bool GetOption(rtc::Socket::Option opt, int* value) override; - int GetError() override { return error_; } + int GetError() override; bool GetStats(std::vector* stats) override; rtc::Optional GetRttEstimate() override; diff --git a/p2p/base/packettransportinternal.cc b/p2p/base/packettransportinternal.cc new file mode 100644 index 0000000000..0ecb2d1aed --- /dev/null +++ b/p2p/base/packettransportinternal.cc @@ -0,0 +1,27 @@ +/* + * Copyright 2017 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "p2p/base/packettransportinternal.h" + +namespace rtc { + +PacketTransportInternal::PacketTransportInternal() = default; + +PacketTransportInternal::~PacketTransportInternal() = default; + +PacketTransportInternal* PacketTransportInternal::GetInternal() { + return this; +} + +bool PacketTransportInternal::GetOption(rtc::Socket::Option opt, int* value) { + return false; +} + +} // namespace rtc diff --git a/p2p/base/packettransportinternal.h b/p2p/base/packettransportinternal.h index c5be54302f..41e9fbcfb9 100644 --- a/p2p/base/packettransportinternal.h +++ b/p2p/base/packettransportinternal.h @@ -61,7 +61,7 @@ class PacketTransportInternal : public virtual webrtc::PacketTransportInterface, // TODO(pthatcher): Once Chrome's MockPacketTransportInterface implements // this, remove the default implementation. - virtual bool GetOption(rtc::Socket::Option opt, int* value) { return false; } + virtual bool GetOption(rtc::Socket::Option opt, int* value); // Returns the most recent error that occurred on this channel. virtual int GetError() = 0; @@ -92,7 +92,10 @@ class PacketTransportInternal : public virtual webrtc::PacketTransportInterface, SignalSentPacket; protected: - PacketTransportInternal* GetInternal() override { return this; } + PacketTransportInternal(); + ~PacketTransportInternal() override; + + PacketTransportInternal* GetInternal() override; }; } // namespace rtc diff --git a/p2p/base/udptransport.cc b/p2p/base/udptransport.cc index de102e2a49..5925907232 100644 --- a/p2p/base/udptransport.cc +++ b/p2p/base/udptransport.cc @@ -63,6 +63,15 @@ rtc::SocketAddress UdpTransport::GetRemoteAddress() const { return remote_address_; } +std::string UdpTransport::debug_name() const { + return transport_name_; +} + +bool UdpTransport::receiving() const { + // TODO(johan): Implement method and signal. + return true; +} + bool UdpTransport::writable() const { RTC_DCHECK_RUN_ON(&network_thread_checker_); return !remote_address_.IsNil(); @@ -86,6 +95,18 @@ int UdpTransport::SendPacket(const char* data, return result; } +int UdpTransport::SetOption(rtc::Socket::Option opt, int value) { + return 0; +} + +int UdpTransport::GetError() { + return send_error_; +} + +rtc::PacketTransportInternal* UdpTransport::GetInternal() { + return this; +} + void UdpTransport::OnSocketReadPacket(rtc::AsyncPacketSocket* socket, const char* data, size_t len, diff --git a/p2p/base/udptransport.h b/p2p/base/udptransport.h index f1bf81008d..6a9d211ab9 100644 --- a/p2p/base/udptransport.h +++ b/p2p/base/udptransport.h @@ -38,7 +38,7 @@ class UdpTransport : public rtc::PacketTransportInternal, // |socket| must be non-null. UdpTransport(const std::string& transport_name, std::unique_ptr socket); - ~UdpTransport(); + ~UdpTransport() override; // Overrides of UdpTransportInterface, used by the API consumer. rtc::SocketAddress GetLocalAddress() const override; @@ -46,12 +46,9 @@ class UdpTransport : public rtc::PacketTransportInternal, rtc::SocketAddress GetRemoteAddress() const override; // Overrides of PacketTransportInternal, used by webrtc internally. - std::string debug_name() const override { return transport_name_; } + std::string debug_name() const override; - bool receiving() const override { - // TODO(johan): Implement method and signal. - return true; - } + bool receiving() const override; bool writable() const override; @@ -60,12 +57,12 @@ class UdpTransport : public rtc::PacketTransportInternal, const rtc::PacketOptions& options, int flags) override; - int SetOption(rtc::Socket::Option opt, int value) override { return 0; } + int SetOption(rtc::Socket::Option opt, int value) override; - int GetError() override { return send_error_; } + int GetError() override; protected: - PacketTransportInternal* GetInternal() override { return this; } + PacketTransportInternal* GetInternal() override; private: void OnSocketReadPacket(rtc::AsyncPacketSocket* socket,