Revert of Make P2PTransportChannel inherit from IceTransportInternal.

webrtc/p2p/base/p2ptransportchannel.h

 /*
  *  Copyright 2004 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.
  */
 
 // P2PTransportChannel wraps up the state management of the connection between
 // two P2P clients.  Clients have candidate ports for connecting, and
 // connections which are combinations of candidates from each end (Alice and
 // Bob each have candidates, one candidate from Alice and one candidate from
 // Bob are used to make a connection, repeat to make many connections).
 //
 // When all of the available connections become invalid (non-writable), we
 // kick off a process of determining more candidates and more connections.
 //
 #ifndef WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_
 #define WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
-#include "webrtc/base/asyncpacketsocket.h"
 #include "webrtc/base/constructormagic.h"
-#include "webrtc/base/sigslot.h"
 #include "webrtc/p2p/base/candidate.h"
 #include "webrtc/p2p/base/candidatepairinterface.h"
-#include "webrtc/p2p/base/icetransportinternal.h"
 #include "webrtc/p2p/base/portallocator.h"
 #include "webrtc/p2p/base/portinterface.h"
+#include "webrtc/p2p/base/transportchannelimpl.h"
+#include "webrtc/base/asyncpacketsocket.h"
+#include "webrtc/base/sigslot.h"
 
 namespace cricket {
 
 // Enum for UMA metrics, used to record whether the channel is
 // connected/connecting/disconnected when ICE restart happens.
 enum class IceRestartState { CONNECTING, CONNECTED, DISCONNECTED, MAX_VALUE };
 
 extern const int WEAK_PING_INTERVAL;
 extern const int WEAK_OR_STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL;
 extern const int STRONG_AND_STABLE_WRITABLE_CONNECTION_PING_INTERVAL;
 static const int MIN_PINGS_AT_WEAK_PING_INTERVAL = 3;
 
 // Adds the port on which the candidate originated.
 class RemoteCandidate : public Candidate {
  public:
   RemoteCandidate(const Candidate& c, PortInterface* origin_port)
       : Candidate(c), origin_port_(origin_port) {}
 
   PortInterface* origin_port() { return origin_port_; }
 
  private:
   PortInterface* origin_port_;
 };
 
 // P2PTransportChannel manages the candidates and connection process to keep
 // two P2P clients connected to each other.
-class P2PTransportChannel : public IceTransportInternal,
+class P2PTransportChannel : public TransportChannelImpl,
                             public rtc::MessageHandler {
  public:
   P2PTransportChannel(const std::string& transport_name,
                       int component,
                       PortAllocator* allocator);
   virtual ~P2PTransportChannel();
 
   // 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_; }
+  TransportChannelState GetState() const override;
   void SetIceRole(IceRole role) override;
   IceRole GetIceRole() const override { return ice_role_; }
   void SetIceTiebreaker(uint64_t tiebreaker) override;
   void SetIceParameters(const IceParameters& ice_params) override;
   void SetRemoteIceParameters(const IceParameters& ice_params) override;
   void SetRemoteIceMode(IceMode mode) override;
   // TODO(deadbeef): Deprecated. Remove when Chromium's
   // IceTransportChannel does not depend on this.
   void Connect() {}
   void MaybeStartGathering() override;
@@ skipping 28 matching lines @@
   const Connection* selected_connection() const { return selected_connection_; }
   void set_incoming_only(bool value) { incoming_only_ = value; }
 
   // Note: These are only for testing purpose.
   // |ports_| and |pruned_ports| should not be changed from outside.
   const std::vector<PortInterface*>& ports() { return ports_; }
   const std::vector<PortInterface*>& pruned_ports() { return pruned_ports_; }
 
   IceMode remote_ice_mode() const { return remote_ice_mode_; }
 
+  // DTLS methods.
+  bool IsDtlsActive() const override { return false; }
+
+  // Default implementation.
+  bool GetSslRole(rtc::SSLRole* role) const override { return false; }
+
+  bool SetSslRole(rtc::SSLRole role) override { return false; }
+
+  // Set up the ciphers to use for DTLS-SRTP.
+  bool SetSrtpCryptoSuites(const std::vector<int>& ciphers) override {
+    return false;
+  }
+
+  // Find out which DTLS-SRTP cipher was negotiated.
+  bool GetSrtpCryptoSuite(int* cipher) override { return false; }
+
+  // Find out which DTLS cipher was negotiated.
+  bool GetSslCipherSuite(int* cipher) override { return false; }
+
+  // Returns null because the channel is not encrypted by default.
+  rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate() const override {
+    return nullptr;
+  }
+
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
+      const override {
+    return nullptr;
+  }
+
+  // Allows key material to be extracted for external encryption.
+  bool ExportKeyingMaterial(const std::string& label,
+                            const uint8_t* context,
+                            size_t context_len,
+                            bool use_context,
+                            uint8_t* result,
+                            size_t result_len) override {
+    return false;
+  }
+
+  bool SetLocalCertificate(
+      const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) override {
+    return false;
+  }
+
+  // Set DTLS Remote fingerprint. Must be after local identity set.
+  bool SetRemoteFingerprint(const std::string& digest_alg,
+                            const uint8_t* digest,
+                            size_t digest_len) override {
+    return false;
+  }
+
   void PruneAllPorts();
   int receiving_timeout() const { return config_.receiving_timeout; }
   int check_receiving_interval() const { return check_receiving_interval_; }
 
   // Helper method used only in unittest.
   rtc::DiffServCodePoint DefaultDscpValue() const;
 
   // Public for unit tests.
   Connection* FindNextPingableConnection();
   void MarkConnectionPinged(Connection* conn);
 
   // Public for unit tests.
   const std::vector<Connection*>& connections() const { return connections_; }
 
   // Public for unit tests.
   PortAllocatorSession* allocator_session() {
     return allocator_sessions_.back().get();
   }
 
   // Public for unit tests.
   const std::vector<RemoteCandidate>& remote_candidates() const {
     return remote_candidates_;
   }
 
-  std::string ToString() const {
-    const char RECEIVING_ABBREV[2] = {'_', 'R'};
-    const char WRITABLE_ABBREV[2] = {'_', 'W'};
-    std::stringstream ss;
-    ss << "Channel[" << transport_name_ << "|" << component_ << "|"
-       << RECEIVING_ABBREV[receiving_] << WRITABLE_ABBREV[writable_] << "]";
-    return ss.str();
-  }
-
  private:
   rtc::Thread* thread() const { return network_thread_; }
   bool IsGettingPorts() { return allocator_session()->IsGettingPorts(); }
 
   // A transport channel is weak if the current best connection is either
   // not receiving or not writable, or if there is no best connection at all.
   bool weak() const;
   // Returns true if it's possible to send packets on |connection|.
   bool ReadyToSend(Connection* connection) const;
   void UpdateConnectionStates();
@@ skipping 26 matching lines @@
                          rtc::Optional<int64_t> receiving_unchanged_threshold,
                          bool* missed_receiving_unchanged_threshold) const;
 
   bool PresumedWritable(const cricket::Connection* conn) const;
 
   void SortConnectionsAndUpdateState();
   void SwitchSelectedConnection(Connection* conn);
   void UpdateState();
   void HandleAllTimedOut();
   void MaybeStopPortAllocatorSessions();
-  IceTransportState ComputeState() const;
+  TransportChannelState ComputeState() const;
 
   Connection* GetBestConnectionOnNetwork(rtc::Network* network) const;
   bool CreateConnections(const Candidate& remote_candidate,
                          PortInterface* origin_port);
   bool CreateConnection(PortInterface* port,
                         const Candidate& remote_candidate,
                         PortInterface* origin_port);
   bool FindConnection(cricket::Connection* connection) const;
 
   uint32_t GetRemoteCandidateGeneration(const Candidate& candidate);
@@ skipping 87 matching lines @@
   const IceParameters* FindRemoteIceFromUfrag(const std::string& ufrag,
                                               uint32_t* generation);
   // Returns the index of the latest remote ICE parameters, or 0 if no remote
   // ICE parameters have been received.
   uint32_t remote_ice_generation() {
     return remote_ice_parameters_.empty()
                ? 0
                : static_cast<uint32_t>(remote_ice_parameters_.size() - 1);
   }
 
-  // Sets the writable state, signaling if necessary.
-  void set_writable(bool writable);
-  // Sets the receiving state, signaling if necessary.
-  void set_receiving(bool receiving);
-
-  std::string transport_name_;
-  int component_;
   PortAllocator* allocator_;
   rtc::Thread* network_thread_;
   bool incoming_only_;
   int error_;
   std::vector<std::unique_ptr<PortAllocatorSession>> allocator_sessions_;
   // |ports_| contains ports that are used to form new connections when
   // new remote candidates are added.
   std::vector<PortInterface*> ports_;
   // |pruned_ports_| contains ports that have been removed from |ports_| and
   // are not being used to form new connections, but that aren't yet destroyed.
@@ skipping 20 matching lines @@
   IceParameters ice_parameters_;
   std::vector<IceParameters> remote_ice_parameters_;
   IceMode remote_ice_mode_;
   IceRole ice_role_;
   uint64_t tiebreaker_;
   IceGatheringState gathering_state_;
 
   int check_receiving_interval_;
   int64_t last_ping_sent_ms_ = 0;
   int weak_ping_interval_ = WEAK_PING_INTERVAL;
-  IceTransportState state_ = IceTransportState::STATE_INIT;
+  TransportChannelState state_ = TransportChannelState::STATE_INIT;
   IceConfig config_;
   int last_sent_packet_id_ = -1;  // -1 indicates no packet was sent before.
   bool started_pinging_ = false;
   // The value put in the "nomination" attribute for the next nominated
   // connection. A zero-value indicates the connection will not be nominated.
   uint32_t nomination_ = 0;
-  bool receiving_ = false;
-  bool writable_ = false;
 
   webrtc::MetricsObserverInterface* metrics_observer_ = nullptr;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(P2PTransportChannel);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_P2PTRANSPORTCHANNEL_H_