Revert of Make P2PTransportChannel inherit from IceTransportInternal.

webrtc/p2p/base/transportcontroller.cc

 /*
  *  Copyright 2015 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.
  */
 
@@ skipping 29 matching lines @@
 
 namespace cricket {
 
 // This class groups the DTLS and ICE channels, and helps keep track of
 // how many external objects (BaseChannels) reference each channel.
 class TransportController::ChannelPair {
  public:
   // TODO(deadbeef): Change the types of |dtls| and |ice| to
   // DtlsTransportChannelWrapper and P2PTransportChannelWrapper,
   // once TransportChannelImpl is removed.
-  ChannelPair(TransportChannelImpl* dtls, IceTransportInternal* ice)
+  ChannelPair(TransportChannelImpl* dtls, TransportChannelImpl* ice)
       : ice_(ice), dtls_(dtls) {}
 
   // Currently, all ICE-related calls still go through this DTLS channel. But
   // that will change once we get rid of TransportChannelImpl, and the DTLS
   // channel interface no longer includes ICE-specific methods.
   const TransportChannelImpl* dtls() const { return dtls_.get(); }
   TransportChannelImpl* dtls() { return dtls_.get(); }
-  const IceTransportInternal* ice() const { return ice_.get(); }
-  IceTransportInternal* ice() { return ice_.get(); }
+  const TransportChannelImpl* ice() const { return ice_.get(); }
+  TransportChannelImpl* ice() { return ice_.get(); }
 
  private:
-  std::unique_ptr<IceTransportInternal> ice_;
+  std::unique_ptr<TransportChannelImpl> ice_;
   std::unique_ptr<TransportChannelImpl> dtls_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(ChannelPair);
 };
 
 TransportController::TransportController(rtc::Thread* signaling_thread,
                                          rtc::Thread* network_thread,
                                          PortAllocator* port_allocator,
                                          bool redetermine_role_on_ice_restart)
     : signaling_thread_(signaling_thread),
@@ skipping 163 matching lines @@
   if (existing_channel) {
     // Channel already exists; increment reference count and return.
     existing_channel->AddRef();
     return existing_channel->dtls();
   }
 
   // Need to create a new channel.
   JsepTransport* transport = GetOrCreateJsepTransport(transport_name);
 
   // Create DTLS channel wrapping ICE channel, and configure it.
-  IceTransportInternal* ice =
+  TransportChannelImpl* ice =
       CreateIceTransportChannel_n(transport_name, component);
   // TODO(deadbeef): To support QUIC, would need to create a
   // QuicTransportChannel here. What is "dtls" in this file would then become
   // "dtls or quic".
   TransportChannelImpl* dtls =
       CreateDtlsTransportChannel_n(transport_name, component, ice);
   dtls->SetMetricsObserver(metrics_observer_);
   dtls->SetIceRole(ice_role_);
   dtls->SetIceTiebreaker(ice_tiebreaker_);
   dtls->SetIceConfig(ice_config_);
@@ skipping 77 matching lines @@
   return ret;
 }
 
 TransportChannelImpl* TransportController::get_channel_for_testing(
     const std::string& transport_name,
     int component) {
   RefCountedChannel* ch = GetChannel_n(transport_name, component);
   return ch ? ch->dtls() : nullptr;
 }
 
-IceTransportInternal* TransportController::CreateIceTransportChannel_n(
+TransportChannelImpl* TransportController::CreateIceTransportChannel_n(
     const std::string& transport_name,
     int component) {
   return new P2PTransportChannel(transport_name, component, port_allocator_);
 }
 
 TransportChannelImpl* TransportController::CreateDtlsTransportChannel_n(
     const std::string&,
     int,
-    IceTransportInternal* ice) {
+    TransportChannelImpl* ice) {
   DtlsTransportChannelWrapper* dtls = new DtlsTransportChannelWrapper(ice);
   dtls->SetSslMaxProtocolVersion(ssl_max_version_);
   return dtls;
 }
 
 void TransportController::OnMessage(rtc::Message* pmsg) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
 
   switch (pmsg->message_id) {
     case MSG_ICECONNECTIONSTATE: {
@@ skipping 451 matching lines @@
   IceConnectionState new_connection_state = kIceConnectionConnecting;
   IceGatheringState new_gathering_state = kIceGatheringNew;
   bool any_receiving = false;
   bool any_failed = false;
   bool all_connected = !channels_.empty();
   bool all_completed = !channels_.empty();
   bool any_gathering = false;
   bool all_done_gathering = !channels_.empty();
   for (const auto& channel : channels_) {
     any_receiving = any_receiving || channel->dtls()->receiving();
-    any_failed = any_failed ||
-                 channel->dtls()->GetState() == IceTransportState::STATE_FAILED;
+    any_failed =
+        any_failed ||
+        channel->dtls()->GetState() == TransportChannelState::STATE_FAILED;
     all_connected = all_connected && channel->dtls()->writable();
     all_completed =
         all_completed && channel->dtls()->writable() &&
-        channel->dtls()->GetState() == IceTransportState::STATE_COMPLETED &&
+        channel->dtls()->GetState() == TransportChannelState::STATE_COMPLETED &&
         channel->dtls()->GetIceRole() == ICEROLE_CONTROLLING &&
         channel->dtls()->gathering_state() == kIceGatheringComplete;
     any_gathering =
         any_gathering || channel->dtls()->gathering_state() != kIceGatheringNew;
     all_done_gathering =
         all_done_gathering &&
         channel->dtls()->gathering_state() == kIceGatheringComplete;
   }
 
   if (any_failed) {
@@ skipping 27 matching lines @@
         RTC_FROM_HERE, this, MSG_ICEGATHERINGSTATE,
         new rtc::TypedMessageData<IceGatheringState>(new_gathering_state));
   }
 }
 
 void TransportController::OnDtlsHandshakeError(rtc::SSLHandshakeError error) {
   SignalDtlsHandshakeError(error);
 }
 
 }  // namespace cricket