diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn
index f6077ff..dc5e642 100644
--- a/p2p/BUILD.gn
+++ b/p2p/BUILD.gn
@@ -48,6 +48,7 @@
     "base/port.h",
     "base/portallocator.cc",
     "base/portallocator.h",
+    "base/portinterface.cc",
     "base/portinterface.h",
     "base/pseudotcp.cc",
     "base/pseudotcp.h",
diff --git a/p2p/base/port.cc b/p2p/base/port.cc
index 81aa0aa..b16c3ea 100644
--- a/p2p/base/port.cc
+++ b/p2p/base/port.cc
@@ -229,6 +229,32 @@
     delete list[i];
 }
 
+const std::string& Port::Type() const {
+  return type_;
+}
+rtc::Network* Port::Network() const {
+  return network_;
+}
+
+IceRole Port::GetIceRole() const {
+  return ice_role_;
+}
+
+void Port::SetIceRole(IceRole role) {
+  ice_role_ = role;
+}
+
+void Port::SetIceTiebreaker(uint64_t tiebreaker) {
+  tiebreaker_ = tiebreaker;
+}
+uint64_t Port::IceTiebreaker() const {
+  return tiebreaker_;
+}
+
+bool Port::SharedSocket() const {
+  return shared_socket_;
+}
+
 void Port::SetIceParameters(int component,
                             const std::string& username_fragment,
                             const std::string& password) {
@@ -242,6 +268,10 @@
   }
 }
 
+const std::vector<Candidate>& Port::Candidates() const {
+  return candidates_;
+}
+
 Connection* Port::GetConnection(const rtc::SocketAddress& remote_addr) {
   AddressMap::const_iterator iter = connections_.find(remote_addr);
   if (iter != connections_.end())
@@ -577,6 +607,15 @@
   stun_username_attr_str->append(username_fragment());
 }
 
+bool Port::HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+                                const char* data,
+                                size_t size,
+                                const rtc::SocketAddress& remote_addr,
+                                const rtc::PacketTime& packet_time) {
+  RTC_NOTREACHED();
+  return false;
+}
+
 void Port::SendBindingResponse(StunMessage* request,
                                const rtc::SocketAddress& addr) {
   RTC_DCHECK(request->type() == STUN_BINDING_REQUEST);
@@ -775,9 +814,6 @@
         connection_(connection) {
   }
 
-  virtual ~ConnectionRequest() {
-  }
-
   void Prepare(StunMessage* request) override {
     request->SetType(STUN_BINDING_REQUEST);
     std::string username;
@@ -1638,4 +1674,8 @@
   return sent;
 }
 
+int ProxyConnection::GetError() {
+  return error_;
+}
+
 }  // namespace cricket
diff --git a/p2p/base/port.h b/p2p/base/port.h
index 9e5c223..e7254e8 100644
--- a/p2p/base/port.h
+++ b/p2p/base/port.h
@@ -161,19 +161,19 @@
        uint16_t max_port,
        const std::string& username_fragment,
        const std::string& password);
-  virtual ~Port();
+  ~Port() override;
 
-  virtual const std::string& Type() const { return type_; }
-  virtual rtc::Network* Network() const { return network_; }
+  const std::string& Type() const override;
+  rtc::Network* Network() const override;
 
   // Methods to set/get ICE role and tiebreaker values.
-  IceRole GetIceRole() const { return ice_role_; }
-  void SetIceRole(IceRole role) { ice_role_ = role; }
+  IceRole GetIceRole() const override;
+  void SetIceRole(IceRole role) override;
 
-  void SetIceTiebreaker(uint64_t tiebreaker) { tiebreaker_ = tiebreaker; }
-  uint64_t IceTiebreaker() const { return tiebreaker_; }
+  void SetIceTiebreaker(uint64_t tiebreaker) override;
+  uint64_t IceTiebreaker() const override;
 
-  virtual bool SharedSocket() const { return shared_socket_; }
+  bool SharedSocket() const override;
   void ResetSharedSocket() { shared_socket_ = false; }
 
   // Should not destroy the port even if no connection is using it. Called when
@@ -226,9 +226,7 @@
   sigslot::signal2<Port*, const Candidate&> SignalCandidateReady;
 
   // Provides all of the above information in one handy object.
-  virtual const std::vector<Candidate>& Candidates() const {
-    return candidates_;
-  }
+  const std::vector<Candidate>& Candidates() const override;
 
   // SignalPortComplete is sent when port completes the task of candidates
   // allocation.
@@ -246,8 +244,7 @@
   const AddressMap& connections() { return connections_; }
 
   // Returns the connection to the given address or NULL if none exists.
-  virtual Connection* GetConnection(
-      const rtc::SocketAddress& remote_addr);
+  Connection* GetConnection(const rtc::SocketAddress& remote_addr) override;
 
   // Called each time a connection is created.
   sigslot::signal2<Port*, Connection*> SignalConnectionCreated;
@@ -256,22 +253,21 @@
   // to accept the packet based on the |remote_addr|. Currently only UDP
   // port implemented this method.
   // TODO(mallinath) - Make it pure virtual.
-  virtual bool HandleIncomingPacket(
-      rtc::AsyncPacketSocket* socket, const char* data, size_t size,
-      const rtc::SocketAddress& remote_addr,
-      const rtc::PacketTime& packet_time) {
-    RTC_NOTREACHED();
-    return false;
-  }
+  virtual bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+                                    const char* data,
+                                    size_t size,
+                                    const rtc::SocketAddress& remote_addr,
+                                    const rtc::PacketTime& packet_time);
 
   // Sends a response message (normal or error) to the given request.  One of
   // these methods should be called as a response to SignalUnknownAddress.
   // NOTE: You MUST call CreateConnection BEFORE SendBindingResponse.
-  virtual void SendBindingResponse(StunMessage* request,
-                                   const rtc::SocketAddress& addr);
-  virtual void SendBindingErrorResponse(
-      StunMessage* request, const rtc::SocketAddress& addr,
-      int error_code, const std::string& reason);
+  void SendBindingResponse(StunMessage* request,
+                           const rtc::SocketAddress& addr) override;
+  void SendBindingErrorResponse(StunMessage* request,
+                                const rtc::SocketAddress& addr,
+                                int error_code,
+                                const std::string& reason) override;
 
   void set_proxy(const std::string& user_agent,
                  const rtc::ProxyInfo& proxy) {
@@ -281,15 +277,15 @@
   const std::string& user_agent() { return user_agent_; }
   const rtc::ProxyInfo& proxy() { return proxy_; }
 
-  virtual void EnablePortPackets();
+  void EnablePortPackets() override;
 
   // Called if the port has no connections and is no longer useful.
   void Destroy();
 
-  virtual void OnMessage(rtc::Message *pmsg);
+  void OnMessage(rtc::Message* pmsg) override;
 
   // Debugging description of this port
-  virtual std::string ToString() const;
+  std::string ToString() const override;
   uint16_t min_port() { return min_port_; }
   uint16_t max_port() { return max_port_; }
 
@@ -454,7 +450,7 @@
     uint32_t nomination;
   };
 
-  virtual ~Connection();
+  ~Connection() override;
 
   // The local port where this connection sends and receives packets.
   Port* port() { return port_; }
@@ -462,9 +458,9 @@
 
   // Implementation of virtual methods in CandidatePairInterface.
   // Returns the description of the local port
-  virtual const Candidate& local_candidate() const;
+  const Candidate& local_candidate() const override;
   // Returns the description of the remote port to which we communicate.
-  virtual const Candidate& remote_candidate() const;
+  const Candidate& remote_candidate() const override;
 
   // Returns the pair priority.
   uint64_t priority() const;
@@ -671,7 +667,7 @@
 
   uint32_t nomination() const { return nomination_; }
 
-  void OnMessage(rtc::Message *pmsg);
+  void OnMessage(rtc::Message* pmsg) override;
 
   Port* port_;
   size_t local_candidate_index_;
@@ -746,7 +742,7 @@
   int Send(const void* data,
            size_t size,
            const rtc::PacketOptions& options) override;
-  int GetError() override { return error_; }
+  int GetError() override;
 
  private:
   int error_ = 0;
diff --git a/p2p/base/portinterface.cc b/p2p/base/portinterface.cc
new file mode 100644
index 0000000..73fe296
--- /dev/null
+++ b/p2p/base/portinterface.cc
@@ -0,0 +1,19 @@
+/*
+ *  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/portinterface.h"
+
+namespace cricket {
+
+PortInterface::PortInterface() = default;
+
+PortInterface::~PortInterface() = default;
+
+}  // namespace cricket
diff --git a/p2p/base/portinterface.h b/p2p/base/portinterface.h
index 2da8e21..ea2601c 100644
--- a/p2p/base/portinterface.h
+++ b/p2p/base/portinterface.h
@@ -40,7 +40,7 @@
 // the other client. Various types of ports will implement this interface.
 class PortInterface {
  public:
-  virtual ~PortInterface() {}
+  virtual ~PortInterface();
 
   virtual const std::string& Type() const = 0;
   virtual rtc::Network* Network() const = 0;
@@ -124,7 +124,7 @@
   virtual std::string ToString() const = 0;
 
  protected:
-  PortInterface() {}
+  PortInterface();
 };
 
 }  // namespace cricket
diff --git a/p2p/base/relayport.cc b/p2p/base/relayport.cc
index 0742b54..7d5c9a8 100644
--- a/p2p/base/relayport.cc
+++ b/p2p/base/relayport.cc
@@ -31,7 +31,7 @@
   RelayConnection(const ProtocolAddress* protocol_address,
                   rtc::AsyncPacketSocket* socket,
                   rtc::Thread* thread);
-  ~RelayConnection();
+  ~RelayConnection() override;
   rtc::AsyncPacketSocket* socket() const { return socket_; }
 
   const ProtocolAddress* protocol_address() {
@@ -78,7 +78,7 @@
                    public sigslot::has_slots<> {
  public:
   RelayEntry(RelayPort* port, const rtc::SocketAddress& ext_addr);
-  ~RelayEntry();
+  ~RelayEntry() override;
 
   RelayPort* port() { return port_; }
 
@@ -125,7 +125,7 @@
   void HandleConnectFailure(rtc::AsyncPacketSocket* socket);
 
   // Implementation of the MessageHandler Interface.
-  virtual void OnMessage(rtc::Message *pmsg);
+  void OnMessage(rtc::Message* pmsg) override;
 
  private:
   RelayPort* port_;
@@ -162,7 +162,7 @@
 class AllocateRequest : public StunRequest {
  public:
   AllocateRequest(RelayEntry* entry, RelayConnection* connection);
-  virtual ~AllocateRequest() {}
+  ~AllocateRequest() override = default;
 
   void Prepare(StunMessage* request) override;
 
@@ -387,6 +387,17 @@
   return error_;
 }
 
+bool RelayPort::SupportsProtocol(const std::string& protocol) const {
+  // Relay port may create both TCP and UDP connections.
+  return true;
+}
+
+ProtocolType RelayPort::GetProtocol() const {
+  // We shouldn't be using RelayPort, but we need to provide an implementation
+  // here.
+  return PROTO_UDP;
+}
+
 void RelayPort::OnReadPacket(
     const char* data, size_t size,
     const rtc::SocketAddress& remote_addr,
diff --git a/p2p/base/relayport.h b/p2p/base/relayport.h
index f12ba11..3e1416d 100644
--- a/p2p/base/relayport.h
+++ b/p2p/base/relayport.h
@@ -59,20 +59,12 @@
   int SetOption(rtc::Socket::Option opt, int value) override;
   int GetOption(rtc::Socket::Option opt, int* value) override;
   int GetError() override;
-  bool SupportsProtocol(const std::string& protocol) const override {
-    // Relay port may create both TCP and UDP connections.
-    return true;
-  }
+  bool SupportsProtocol(const std::string& protocol) const override;
+  ProtocolType GetProtocol() const override;
 
   const ProtocolAddress * ServerAddress(size_t index) const;
   bool IsReady() { return ready_; }
 
-  ProtocolType GetProtocol() const override {
-    // We shouldn't be using RelayPort, but we need to provide an
-    // implementation here.
-    return PROTO_UDP;
-  }
-
   // Used for testing.
   sigslot::signal1<const ProtocolAddress*> SignalConnectFailure;
   sigslot::signal1<const ProtocolAddress*> SignalSoftTimeout;
diff --git a/p2p/base/stunport.cc b/p2p/base/stunport.cc
index a5765fa..d06ad69 100644
--- a/p2p/base/stunport.cc
+++ b/p2p/base/stunport.cc
@@ -33,16 +33,13 @@
                      int64_t start_time)
       : port_(port), server_addr_(addr), start_time_(start_time) {}
 
-  virtual ~StunBindingRequest() {
-  }
-
   const rtc::SocketAddress& server_addr() const { return server_addr_; }
 
-  virtual void Prepare(StunMessage* request) override {
+  void Prepare(StunMessage* request) override {
     request->SetType(STUN_BINDING_REQUEST);
   }
 
-  virtual void OnResponse(StunMessage* response) override {
+  void OnResponse(StunMessage* response) override {
     const StunAddressAttribute* addr_attr =
         response->GetAddress(STUN_ATTR_MAPPED_ADDRESS);
     if (!addr_attr) {
@@ -63,7 +60,7 @@
     }
   }
 
-  virtual void OnErrorResponse(StunMessage* response) override {
+  void OnErrorResponse(StunMessage* response) override {
     const StunErrorCodeAttribute* attr = response->GetErrorCode();
     if (!attr) {
       LOG(LS_ERROR) << "Missing binding response error code.";
@@ -84,7 +81,7 @@
           port_->stun_keepalive_delay());
     }
   }
-  virtual void OnTimeout() override {
+  void OnTimeout() override {
     LOG(LS_ERROR) << "Binding request timed out from "
                   << port_->GetLocalAddress().ToSensitiveString() << " ("
                   << port_->Network()->name() << ")";
@@ -299,6 +296,24 @@
   return error_;
 }
 
+bool UDPPort::HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+                                   const char* data,
+                                   size_t size,
+                                   const rtc::SocketAddress& remote_addr,
+                                   const rtc::PacketTime& packet_time) {
+  // All packets given to UDP port will be consumed.
+  OnReadPacket(socket, data, size, remote_addr, packet_time);
+  return true;
+}
+
+bool UDPPort::SupportsProtocol(const std::string& protocol) const {
+  return protocol == UDP_PROTOCOL_NAME;
+}
+
+ProtocolType UDPPort::GetProtocol() const {
+  return PROTO_UDP;
+}
+
 void UDPPort::OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
                                   const rtc::SocketAddress& address) {
   // When adapter enumeration is disabled and binding to the any address, the
@@ -513,4 +528,49 @@
   return false;
 }
 
+StunPort* StunPort::Create(rtc::Thread* thread,
+                           rtc::PacketSocketFactory* factory,
+                           rtc::Network* network,
+                           uint16_t min_port,
+                           uint16_t max_port,
+                           const std::string& username,
+                           const std::string& password,
+                           const ServerAddresses& servers,
+                           const std::string& origin) {
+  StunPort* port = new StunPort(thread, factory, network, min_port, max_port,
+                                username, password, servers, origin);
+  if (!port->Init()) {
+    delete port;
+    port = NULL;
+  }
+  return port;
+}
+
+StunPort::StunPort(rtc::Thread* thread,
+                   rtc::PacketSocketFactory* factory,
+                   rtc::Network* network,
+                   uint16_t min_port,
+                   uint16_t max_port,
+                   const std::string& username,
+                   const std::string& password,
+                   const ServerAddresses& servers,
+                   const std::string& origin)
+    : UDPPort(thread,
+              factory,
+              network,
+              min_port,
+              max_port,
+              username,
+              password,
+              origin,
+              false) {
+  // UDPPort will set these to local udp, updating these to STUN.
+  set_type(STUN_PORT_TYPE);
+  set_server_addresses(servers);
+}
+
+void StunPort::PrepareAddress() {
+  SendStunBindingRequests();
+}
+
 }  // namespace cricket
diff --git a/p2p/base/stunport.h b/p2p/base/stunport.h
index 53fc125..cc2e25a 100644
--- a/p2p/base/stunport.h
+++ b/p2p/base/stunport.h
@@ -70,7 +70,7 @@
     return port;
   }
 
-  virtual ~UDPPort();
+  ~UDPPort() override;
 
   rtc::SocketAddress GetLocalAddress() const {
     return socket_->GetLocalAddress();
@@ -83,27 +83,22 @@
     server_addresses_ = addresses;
   }
 
-  virtual void PrepareAddress();
+  void PrepareAddress() override;
 
-  virtual Connection* CreateConnection(const Candidate& address,
-                                       CandidateOrigin origin);
-  virtual int SetOption(rtc::Socket::Option opt, int value);
-  virtual int GetOption(rtc::Socket::Option opt, int* value);
-  virtual int GetError();
+  Connection* CreateConnection(const Candidate& address,
+                               CandidateOrigin origin) override;
+  int SetOption(rtc::Socket::Option opt, int value) override;
+  int GetOption(rtc::Socket::Option opt, int* value) override;
+  int GetError() override;
 
-  virtual bool HandleIncomingPacket(
-      rtc::AsyncPacketSocket* socket, const char* data, size_t size,
-      const rtc::SocketAddress& remote_addr,
-      const rtc::PacketTime& packet_time) {
-    // All packets given to UDP port will be consumed.
-    OnReadPacket(socket, data, size, remote_addr, packet_time);
-    return true;
-  }
-  virtual bool SupportsProtocol(const std::string& protocol) const {
-    return protocol == UDP_PROTOCOL_NAME;
-  }
+  bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+                            const char* data,
+                            size_t size,
+                            const rtc::SocketAddress& remote_addr,
+                            const rtc::PacketTime& packet_time) override;
 
-  virtual ProtocolType GetProtocol() const { return PROTO_UDP; }
+  bool SupportsProtocol(const std::string& protocol) const override;
+  ProtocolType GetProtocol() const override;
 
   void set_stun_keepalive_delay(int delay) {
     stun_keepalive_delay_ = delay;
@@ -144,12 +139,13 @@
 
   bool Init();
 
-  virtual int SendTo(const void* data, size_t size,
-                     const rtc::SocketAddress& addr,
-                     const rtc::PacketOptions& options,
-                     bool payload);
+  int SendTo(const void* data,
+             size_t size,
+             const rtc::SocketAddress& addr,
+             const rtc::PacketOptions& options,
+             bool payload) override;
 
-  virtual void UpdateNetworkCost();
+  void UpdateNetworkCost() override;
 
   void OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
                            const rtc::SocketAddress& address);
@@ -159,7 +155,7 @@
                     const rtc::PacketTime& packet_time);
 
   void OnSentPacket(rtc::AsyncPacketSocket* socket,
-                    const rtc::SentPacket& sent_packet);
+                    const rtc::SentPacket& sent_packet) override;
 
   void OnReadyToSend(rtc::AsyncPacketSocket* socket);
 
@@ -181,7 +177,7 @@
   class AddressResolver : public sigslot::has_slots<> {
    public:
     explicit AddressResolver(rtc::PacketSocketFactory* factory);
-    ~AddressResolver();
+    ~AddressResolver() override;
 
     void Resolve(const rtc::SocketAddress& address);
     bool GetResolvedAddress(const rtc::SocketAddress& input,
@@ -262,21 +258,9 @@
                           const std::string& username,
                           const std::string& password,
                           const ServerAddresses& servers,
-                          const std::string& origin) {
-    StunPort* port = new StunPort(thread, factory, network, min_port, max_port,
-                                  username, password, servers, origin);
-    if (!port->Init()) {
-      delete port;
-      port = NULL;
-    }
-    return port;
-  }
+                          const std::string& origin);
 
-  virtual ~StunPort() {}
-
-  virtual void PrepareAddress() {
-    SendStunBindingRequests();
-  }
+  void PrepareAddress() override;
 
  protected:
   StunPort(rtc::Thread* thread,
@@ -287,20 +271,7 @@
            const std::string& username,
            const std::string& password,
            const ServerAddresses& servers,
-           const std::string& origin)
-      : UDPPort(thread,
-                factory,
-                network,
-                min_port,
-                max_port,
-                username,
-                password,
-                origin,
-                false) {
-    // UDPPort will set these to local udp, updating these to STUN.
-    set_type(STUN_PORT_TYPE);
-    set_server_addresses(servers);
-  }
+           const std::string& origin);
 };
 
 }  // namespace cricket
diff --git a/p2p/base/tcpport.cc b/p2p/base/tcpport.cc
index 31abf4b..cf1eb7a 100644
--- a/p2p/base/tcpport.cc
+++ b/p2p/base/tcpport.cc
@@ -246,6 +246,14 @@
   return error_;
 }
 
+bool TCPPort::SupportsProtocol(const std::string& protocol) const {
+  return protocol == TCP_PROTOCOL_NAME || protocol == SSLTCP_PROTOCOL_NAME;
+}
+
+ProtocolType TCPPort::GetProtocol() const {
+  return PROTO_TCP;
+}
+
 void TCPPort::OnNewConnection(rtc::AsyncPacketSocket* socket,
                               rtc::AsyncPacketSocket* new_socket) {
   RTC_DCHECK(socket == socket_);
diff --git a/p2p/base/tcpport.h b/p2p/base/tcpport.h
index 4a2b5f8..11a8e2d 100644
--- a/p2p/base/tcpport.h
+++ b/p2p/base/tcpport.h
@@ -51,11 +51,8 @@
   int GetOption(rtc::Socket::Option opt, int* value) override;
   int SetOption(rtc::Socket::Option opt, int value) override;
   int GetError() override;
-  bool SupportsProtocol(const std::string& protocol) const override {
-    return protocol == TCP_PROTOCOL_NAME || protocol == SSLTCP_PROTOCOL_NAME;
-  }
-
-  ProtocolType GetProtocol() const override { return PROTO_TCP; }
+  bool SupportsProtocol(const std::string& protocol) const override;
+  ProtocolType GetProtocol() const override;
 
  protected:
   TCPPort(rtc::Thread* thread,
diff --git a/p2p/base/turnport.cc b/p2p/base/turnport.cc
index 6c8f3e5..0e7c0b1 100644
--- a/p2p/base/turnport.cc
+++ b/p2p/base/turnport.cc
@@ -284,6 +284,26 @@
   return socket_ ? socket_->GetLocalAddress() : rtc::SocketAddress();
 }
 
+ProtocolType TurnPort::GetProtocol() const {
+  return server_address_.proto;
+}
+
+TlsCertPolicy TurnPort::GetTlsCertPolicy() const {
+  return tls_cert_policy_;
+}
+
+void TurnPort::SetTlsCertPolicy(TlsCertPolicy tls_cert_policy) {
+  tls_cert_policy_ = tls_cert_policy;
+}
+
+std::vector<std::string> TurnPort::GetTlsAlpnProtocols() const {
+  return tls_alpn_protocols_;
+}
+
+std::vector<std::string> TurnPort::GetTlsEllipticCurves() const {
+  return tls_elliptic_curves_;
+}
+
 void TurnPort::PrepareAddress() {
   if (credentials_.username.empty() ||
       credentials_.password.empty()) {
@@ -660,6 +680,10 @@
   }
 }
 
+bool TurnPort::SupportsProtocol(const std::string& protocol) const {
+  // Turn port only connects to UDP candidates.
+  return protocol == UDP_PROTOCOL_NAME;
+}
 
 // Update current server address port with the alternate server address port.
 bool TurnPort::SetAlternateServer(const rtc::SocketAddress& address) {
diff --git a/p2p/base/turnport.h b/p2p/base/turnport.h
index 1d1ffe2..3d34d46 100644
--- a/p2p/base/turnport.h
+++ b/p2p/base/turnport.h
@@ -85,7 +85,7 @@
                         customizer);
   }
 
-  virtual ~TurnPort();
+  ~TurnPort() override;
 
   const ProtocolAddress& server_address() const { return server_address_; }
   // Returns an empty address if the local address has not been assigned.
@@ -97,49 +97,40 @@
   }
   const RelayCredentials& credentials() const { return credentials_; }
 
-  virtual ProtocolType GetProtocol() const { return server_address_.proto; }
+  ProtocolType GetProtocol() const override;
 
-  virtual TlsCertPolicy GetTlsCertPolicy() const { return tls_cert_policy_; }
+  virtual TlsCertPolicy GetTlsCertPolicy() const;
+  virtual void SetTlsCertPolicy(TlsCertPolicy tls_cert_policy);
 
-  virtual void SetTlsCertPolicy(TlsCertPolicy tls_cert_policy) {
-    tls_cert_policy_ = tls_cert_policy;
-  }
+  virtual std::vector<std::string> GetTlsAlpnProtocols() const;
+  virtual std::vector<std::string> GetTlsEllipticCurves() const;
 
-  virtual std::vector<std::string> GetTlsAlpnProtocols() const {
-    return tls_alpn_protocols_;
-  }
+  void PrepareAddress() override;
+  Connection* CreateConnection(const Candidate& c,
+                               PortInterface::CandidateOrigin origin) override;
+  int SendTo(const void* data,
+             size_t size,
+             const rtc::SocketAddress& addr,
+             const rtc::PacketOptions& options,
+             bool payload) override;
+  int SetOption(rtc::Socket::Option opt, int value) override;
+  int GetOption(rtc::Socket::Option opt, int* value) override;
+  int GetError() override;
 
-  virtual std::vector<std::string> GetTlsEllipticCurves() const {
-    return tls_elliptic_curves_;
-  }
-
-  virtual void PrepareAddress();
-  virtual Connection* CreateConnection(
-      const Candidate& c, PortInterface::CandidateOrigin origin);
-  virtual int SendTo(const void* data, size_t size,
-                     const rtc::SocketAddress& addr,
-                     const rtc::PacketOptions& options,
-                     bool payload);
-  virtual int SetOption(rtc::Socket::Option opt, int value);
-  virtual int GetOption(rtc::Socket::Option opt, int* value);
-  virtual int GetError();
-
-  virtual bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
-                                    const char* data, size_t size,
-                                    const rtc::SocketAddress& remote_addr,
-                                    const rtc::PacketTime& packet_time);
+  bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+                            const char* data,
+                            size_t size,
+                            const rtc::SocketAddress& remote_addr,
+                            const rtc::PacketTime& packet_time) override;
   virtual void OnReadPacket(rtc::AsyncPacketSocket* socket,
                             const char* data, size_t size,
                             const rtc::SocketAddress& remote_addr,
                             const rtc::PacketTime& packet_time);
 
-  virtual void OnSentPacket(rtc::AsyncPacketSocket* socket,
-                            const rtc::SentPacket& sent_packet);
+  void OnSentPacket(rtc::AsyncPacketSocket* socket,
+                    const rtc::SentPacket& sent_packet) override;
   virtual void OnReadyToSend(rtc::AsyncPacketSocket* socket);
-  virtual bool SupportsProtocol(const std::string& protocol) const {
-    // Turn port only connects to UDP candidates.
-    return protocol == UDP_PROTOCOL_NAME;
-  }
+  bool SupportsProtocol(const std::string& protocol) const override;
 
   void OnSocketConnect(rtc::AsyncPacketSocket* socket);
   void OnSocketClose(rtc::AsyncPacketSocket* socket, int error);
@@ -222,8 +213,8 @@
   typedef std::map<rtc::Socket::Option, int> SocketOptionsMap;
   typedef std::set<rtc::SocketAddress> AttemptedServerSet;
 
-  virtual void OnMessage(rtc::Message* pmsg);
-  virtual void HandleConnectionDestroyed(Connection* conn);
+  void OnMessage(rtc::Message* pmsg) override;
+  void HandleConnectionDestroyed(Connection* conn) override;
 
   bool CreateTurnClientSocket();