Remove the dependency of TransportChannel and TransportChannelImpl.

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, TransportChannelImpl* ice)
+  ChannelPair(DtlsTransportInternal* 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 DtlsTransportInternal* dtls() const { return dtls_.get(); }
+  DtlsTransportInternal* dtls() { return dtls_.get(); }
   const TransportChannelImpl* ice() const { return ice_.get(); }
   TransportChannelImpl* ice() { return ice_.get(); }
 
  private:
   std::unique_ptr<TransportChannelImpl> ice_;
-  std::unique_ptr<TransportChannelImpl> dtls_;
+  std::unique_ptr<DtlsTransportInternal> 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),
       network_thread_(network_thread),
@@ skipping 146 matching lines @@
       rtc::Bind(&TransportController::GetStats_n, this, transport_name, stats));
 }
 
 void TransportController::SetMetricsObserver(
     webrtc::MetricsObserverInterface* metrics_observer) {
   return network_thread_->Invoke<void>(
       RTC_FROM_HERE, rtc::Bind(&TransportController::SetMetricsObserver_n, this,
                                metrics_observer));
 }
 
-TransportChannel* TransportController::CreateTransportChannel_n(
+DtlsTransportInternal* TransportController::CreateTransportChannel_n(
     const std::string& transport_name,
     int component) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   RefCountedChannel* existing_channel = GetChannel_n(transport_name, component);
   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.
   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 =
+  DtlsTransportInternal* dtls =
       CreateDtlsTransportChannel_n(transport_name, component, ice);
-  dtls->SetMetricsObserver(metrics_observer_);
-  dtls->SetIceRole(ice_role_);
-  dtls->SetIceTiebreaker(ice_tiebreaker_);
-  dtls->SetIceConfig(ice_config_);
+  dtls->ice_transport()->SetMetricsObserver(metrics_observer_);
+  dtls->ice_transport()->SetIceRole(ice_role_);
+  dtls->ice_transport()->SetIceTiebreaker(ice_tiebreaker_);
+  dtls->ice_transport()->SetIceConfig(ice_config_);
   if (certificate_) {
     bool set_cert_success = dtls->SetLocalCertificate(certificate_);
     RTC_DCHECK(set_cert_success);
   }
 
   // Connect to signals offered by the channels. Currently, the DTLS channel
   // forwards signals from the ICE channel, so we only need to connect to the
   // DTLS channel. In the future this won't be the case.
   dtls->SignalWritableState.connect(
       this, &TransportController::OnChannelWritableState_n);
   dtls->SignalReceivingState.connect(
       this, &TransportController::OnChannelReceivingState_n);
-  dtls->SignalGatheringState.connect(
-      this, &TransportController::OnChannelGatheringState_n);
-  dtls->SignalCandidateGathered.connect(
-      this, &TransportController::OnChannelCandidateGathered_n);
-  dtls->SignalCandidatesRemoved.connect(
-      this, &TransportController::OnChannelCandidatesRemoved_n);
-  dtls->SignalRoleConflict.connect(
-      this, &TransportController::OnChannelRoleConflict_n);
-  dtls->SignalStateChanged.connect(
-      this, &TransportController::OnChannelStateChanged_n);
   dtls->SignalDtlsHandshakeError.connect(
       this, &TransportController::OnDtlsHandshakeError);
+  dtls->ice_transport()->SignalGatheringState.connect(
+      this, &TransportController::OnChannelGatheringState_n);
+  dtls->ice_transport()->SignalCandidateGathered.connect(
+      this, &TransportController::OnChannelCandidateGathered_n);
+  dtls->ice_transport()->SignalCandidatesRemoved.connect(
+      this, &TransportController::OnChannelCandidatesRemoved_n);
+  dtls->ice_transport()->SignalRoleConflict.connect(
+      this, &TransportController::OnChannelRoleConflict_n);
+  dtls->ice_transport()->SignalStateChanged.connect(
+      this, &TransportController::OnChannelStateChanged_n);
   RefCountedChannel* new_pair = new RefCountedChannel(dtls, ice);
   new_pair->AddRef();
   channels_.insert(channels_.end(), new_pair);
   bool channel_added = transport->AddChannel(dtls, component);
   RTC_DCHECK(channel_added);
   // Adding a channel could cause aggregate state to change.
   UpdateAggregateStates_n();
   return dtls;
 }
 
@@ skipping 28 matching lines @@
 }
 
 std::vector<std::string> TransportController::transport_names_for_testing() {
   std::vector<std::string> ret;
   for (const auto& kv : transports_) {
     ret.push_back(kv.first);
   }
   return ret;
 }
 
-std::vector<TransportChannelImpl*> TransportController::channels_for_testing() {
-  std::vector<TransportChannelImpl*> ret;
+std::vector<DtlsTransportInternal*>
+TransportController::channels_for_testing() {
+  std::vector<DtlsTransportInternal*> ret;
   for (RefCountedChannel* channel : channels_) {
     ret.push_back(channel->dtls());
   }
   return ret;
 }
 
-TransportChannelImpl* TransportController::get_channel_for_testing(
+DtlsTransportInternal* TransportController::get_channel_for_testing(
     const std::string& transport_name,
     int component) {
   RefCountedChannel* ch = GetChannel_n(transport_name, component);
   return ch ? ch->dtls() : nullptr;
 }
 
 TransportChannelImpl* TransportController::CreateIceTransportChannel_n(
     const std::string& transport_name,
     int component) {
   return new P2PTransportChannel(transport_name, component, port_allocator_);
 }
 
-TransportChannelImpl* TransportController::CreateDtlsTransportChannel_n(
+DtlsTransportInternal* TransportController::CreateDtlsTransportChannel_n(
     const std::string&,
     int,
     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());
@@ skipping 121 matching lines @@
 
   ssl_max_version_ = version;
   return true;
 }
 
 void TransportController::SetIceConfig_n(const IceConfig& config) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   ice_config_ = config;
   for (auto& channel : channels_) {
-    channel->dtls()->SetIceConfig(ice_config_);
+    channel->dtls()->ice_transport()->SetIceConfig(ice_config_);
   }
 }
 
 void TransportController::SetIceRole_n(IceRole ice_role) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   ice_role_ = ice_role;
   for (auto& channel : channels_) {
-    channel->dtls()->SetIceRole(ice_role_);
+    channel->dtls()->ice_transport()->SetIceRole(ice_role_);
   }
 }
 
 bool TransportController::GetSslRole_n(const std::string& transport_name,
                                        rtc::SSLRole* role) const {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   const JsepTransport* t = GetJsepTransport(transport_name);
   if (!t) {
     return false;
@@ skipping 111 matching lines @@
     // description on a deleted transport.
     return true;
   }
 
   LOG(LS_INFO) << "Set remote transport description on " << transport_name;
   return transport->SetRemoteTransportDescription(tdesc, action, err);
 }
 
 void TransportController::MaybeStartGathering_n() {
   for (auto& channel : channels_) {
-    channel->dtls()->MaybeStartGathering();
+    channel->dtls()->ice_transport()->MaybeStartGathering();
   }
 }
 
 bool TransportController::AddRemoteCandidates_n(
     const std::string& transport_name,
     const Candidates& candidates,
     std::string* err) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   // Verify each candidate before passing down to the transport layer.
   if (!VerifyCandidates(candidates, err)) {
     return false;
   }
 
   JsepTransport* transport = GetJsepTransport(transport_name);
   if (!transport) {
     // If we didn't find a transport, that's not an error;
     // it could have been deleted as a result of bundling.
     return true;
   }
 
   for (const Candidate& candidate : candidates) {
     RefCountedChannel* channel =
         GetChannel_n(transport_name, candidate.component());
     if (!channel) {
       *err = "Candidate has an unknown component: " + candidate.ToString() +
              " for content: " + transport_name;
       return false;
     }
-    channel->dtls()->AddRemoteCandidate(candidate);
+    channel->dtls()->ice_transport()->AddRemoteCandidate(candidate);
   }
   return true;
 }
 
 bool TransportController::RemoveRemoteCandidates_n(const Candidates& candidates,
                                                    std::string* err) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   // Verify each candidate before passing down to the transport layer.
   if (!VerifyCandidates(candidates, err)) {
@@ skipping 13 matching lines @@
     JsepTransport* transport = GetJsepTransport(transport_name);
     if (!transport) {
       // If we didn't find a transport, that's not an error;
       // it could have been deleted as a result of bundling.
       continue;
     }
     for (const Candidate& candidate : candidates) {
       RefCountedChannel* channel =
           GetChannel_n(transport_name, candidate.component());
       if (channel) {
-        channel->dtls()->RemoveRemoteCandidate(candidate);
+        channel->dtls()->ice_transport()->RemoveRemoteCandidate(candidate);
       }
     }
   }
   return result;
 }
 
 bool TransportController::ReadyForRemoteCandidates_n(
     const std::string& transport_name) const {
   RTC_DCHECK(network_thread_->IsCurrent());
 
@@ skipping 13 matching lines @@
     return false;
   }
   return transport->GetStats(stats);
 }
 
 void TransportController::SetMetricsObserver_n(
     webrtc::MetricsObserverInterface* metrics_observer) {
   RTC_DCHECK(network_thread_->IsCurrent());
   metrics_observer_ = metrics_observer;
   for (auto& channel : channels_) {
-    channel->dtls()->SetMetricsObserver(metrics_observer);
+    channel->dtls()->ice_transport()->SetMetricsObserver(metrics_observer);
   }
 }
 
 void TransportController::OnChannelWritableState_n(
     rtc::PacketTransportInterface* transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
   LOG(LS_INFO) << " TransportChannel " << transport->debug_name()
                << " writability changed to " << transport->writable() << ".";
   UpdateAggregateStates_n();
 }
@@ skipping 73 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() == TransportChannelState::STATE_FAILED;
+    any_failed = any_failed ||
+                 channel->dtls()->ice_transport()->GetState() ==
+                     TransportChannelState::STATE_FAILED;
     all_connected = all_connected && channel->dtls()->writable();
     all_completed =
         all_completed && channel->dtls()->writable() &&
-        channel->dtls()->GetState() == TransportChannelState::STATE_COMPLETED &&
-        channel->dtls()->GetIceRole() == ICEROLE_CONTROLLING &&
-        channel->dtls()->gathering_state() == kIceGatheringComplete;
+        channel->dtls()->ice_transport()->GetState() ==
+            TransportChannelState::STATE_COMPLETED &&
+        channel->dtls()->ice_transport()->GetIceRole() == ICEROLE_CONTROLLING &&
+        channel->dtls()->ice_transport()->gathering_state() ==
+            kIceGatheringComplete;
     any_gathering =
-        any_gathering || channel->dtls()->gathering_state() != kIceGatheringNew;
-    all_done_gathering =
-        all_done_gathering &&
-        channel->dtls()->gathering_state() == kIceGatheringComplete;
+        any_gathering ||
+        channel->dtls()->ice_transport()->gathering_state() != kIceGatheringNew;
+    all_done_gathering = all_done_gathering &&
+                         channel->dtls()->ice_transport()->gathering_state() ==
+                             kIceGatheringComplete;
   }
-
   if (any_failed) {
     new_connection_state = kIceConnectionFailed;
   } else if (all_completed) {
     new_connection_state = kIceConnectionCompleted;
   } else if (all_connected) {
     new_connection_state = kIceConnectionConnected;
   }
   if (connection_state_ != new_connection_state) {
     connection_state_ = new_connection_state;
     signaling_thread_->Post(
@@ skipping 18 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