Move ownership of Transport out of Session.

remoting/protocol/ice_transport_channel.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/protocol/ice_transport_channel.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 43 matching lines @@
       ice_username_fragment_(
           rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH)),
       connect_attempts_left_(kMaxReconnectAttempts),
       weak_factory_(this) {
   DCHECK(!ice_username_fragment_.empty());
 }
 
 IceTransportChannel::~IceTransportChannel() {
   DCHECK(delegate_);
 
-  delegate_->OnTransportDeleted(this);
+  delegate_->OnChannelDeleted(this);
 
   auto task_runner = base::ThreadTaskRunnerHandle::Get();
   if (channel_)
     task_runner->DeleteSoon(FROM_HERE, channel_.release());
   if (port_allocator_)
     task_runner->DeleteSoon(FROM_HERE, port_allocator_.release());
 }
 
 void IceTransportChannel::Connect(const std::string& name,
                                   Delegate* delegate,
@@ skipping 21 matching lines @@
 
   // Create P2PTransportChannel, attach signal handlers and connect it.
   // TODO(sergeyu): Specify correct component ID for the channel.
   channel_.reset(new cricket::P2PTransportChannel(
       std::string(), 0, nullptr, port_allocator_.get()));
   std::string ice_password = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
   channel_->SetIceProtocolType(cricket::ICEPROTO_RFC5245);
   channel_->SetIceRole((transport_context_->role() == TransportRole::CLIENT)
                            ? cricket::ICEROLE_CONTROLLING
                            : cricket::ICEROLE_CONTROLLED);
-  delegate_->OnTransportIceCredentials(this, ice_username_fragment_,
-                                            ice_password);
+  delegate_->OnChannelIceCredentials(this, ice_username_fragment_,
+                                     ice_password);
   channel_->SetIceCredentials(ice_username_fragment_, ice_password);
   channel_->SignalCandidateGathered.connect(
       this, &IceTransportChannel::OnCandidateGathered);
   channel_->SignalRouteChange.connect(
       this, &IceTransportChannel::OnRouteChange);
   channel_->SignalReceivingState.connect(
       this, &IceTransportChannel::OnReceivingState);
   channel_->SignalWritableState.connect(
       this, &IceTransportChannel::OnWritableState);
   channel_->set_incoming_only(!(transport_context_->network_settings().flags &
@@ skipping 66 matching lines @@
 
 bool IceTransportChannel::is_connected() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return callback_.is_null();
 }
 
 void IceTransportChannel::OnCandidateGathered(
     cricket::TransportChannelImpl* channel,
     const cricket::Candidate& candidate) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  delegate_->OnTransportCandidate(this, candidate);
+  delegate_->OnChannelCandidate(this, candidate);
 }
 
 void IceTransportChannel::OnRouteChange(
     cricket::TransportChannel* channel,
     const cricket::Candidate& candidate) {
   // Ignore notifications if the channel is not writable.
   if (channel_->writable())
     NotifyRouteChanged();
 }
 
@@ skipping 49 matching lines @@
     LOG(FATAL) << "Failed to convert peer IP address.";
   }
 
   const cricket::Candidate& local_candidate =
       channel_->best_connection()->local_candidate();
   if (!jingle_glue::SocketAddressToIPEndPoint(
           local_candidate.address(), &route.local_address)) {
     LOG(FATAL) << "Failed to convert local IP address.";
   }
 
-  delegate_->OnTransportRouteChange(this, route);
+  delegate_->OnChannelRouteChange(this, route);
 }
 
 void IceTransportChannel::TryReconnect() {
   DCHECK(!channel_->writable());
 
   if (connect_attempts_left_ <= 0) {
     reconnect_timer_.Stop();
 
     // Notify the caller that ICE connection has failed - normally that will
     // terminate Jingle connection (i.e. the transport will be destroyed).
-    delegate_->OnTransportFailed(this);
+    delegate_->OnChannelFailed(this);
     return;
   }
   --connect_attempts_left_;
 
   // Restart ICE by resetting ICE password.
   std::string ice_password = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH);
-  delegate_->OnTransportIceCredentials(this, ice_username_fragment_,
-                                            ice_password);
+  delegate_->OnChannelIceCredentials(this, ice_username_fragment_,
+                                     ice_password);
   channel_->SetIceCredentials(ice_username_fragment_, ice_password);
 }
 
 }  // namespace protocol
 }  // namespace remoting