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 <steveanton@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20485}

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",

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<rtc::RTCCertificate>& certificate) {
@@ -276,6 +300,18 @@ std::unique_ptr<rtc::SSLCertificate> 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()

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<rtc::RTCCertificate>& 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'};

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

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<rtc::SSLHandshakeError> 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);

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

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<IceTransportInternal*> 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

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<int> 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;
     }

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<ConnectionInfo>* stats) override;
   rtc::Optional<int> GetRttEstimate() override;
 

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

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

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,

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<rtc::AsyncPacketSocket> 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,