Move ownership of Transport out of Session.

remoting/protocol/webrtc_transport.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/webrtc_transport.h"
 
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
@@ skipping 84 matching lines @@
  private:
   ResultCallback result_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetSessionDescriptionObserver);
 };
 
 }  // namespace
 
 WebrtcTransport::WebrtcTransport(
     rtc::Thread* worker_thread,
-    scoped_refptr<TransportContext> transport_context)
-    : transport_context_(transport_context),
-      worker_thread_(worker_thread),
+    scoped_refptr<TransportContext> transport_context,
+    EventHandler* event_handler)
+    : worker_thread_(worker_thread),
+      transport_context_(transport_context),
+      event_handler_(event_handler),
       weak_factory_(this) {}
 
 WebrtcTransport::~WebrtcTransport() {}
 
-void WebrtcTransport::Start(EventHandler* event_handler,
-                            Authenticator* authenticator) {
+void WebrtcTransport::Start(
+    Authenticator* authenticator,
+    SendTransportInfoCallback send_transport_info_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(send_transport_info_callback_.is_null());
 
-  event_handler_ = event_handler;
+  send_transport_info_callback_ = std::move(send_transport_info_callback);
+
   // TODO(sergeyu): Use the |authenticator| to authenticate PeerConnection.
 
   transport_context_->CreatePortAllocator(base::Bind(
       &WebrtcTransport::OnPortAllocatorCreated, weak_factory_.GetWeakPtr()));
 }
 
 void WebrtcTransport::OnPortAllocatorCreated(
     scoped_ptr<cricket::PortAllocator> port_allocator) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
@@ skipping 111 matching lines @@
   }
 
   return true;
 }
 
 StreamChannelFactory* WebrtcTransport::GetStreamChannelFactory() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return &data_stream_adapter_;
 }
 
-StreamChannelFactory* WebrtcTransport::GetMultiplexedChannelFactory() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  return GetStreamChannelFactory();
-}
-
-WebrtcTransport* WebrtcTransport::AsWebrtcTransport() {
-  return this;
-}
-
 void WebrtcTransport::OnLocalSessionDescriptionCreated(
     scoped_ptr<webrtc::SessionDescriptionInterface> description,
     const std::string& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!peer_connection_)
     return;
 
   if (!description) {
     LOG(ERROR) << "PeerConnection offer creation failed: " << error;
@@ skipping 10 matching lines @@
 
   // Format and send the session description to the peer.
   scoped_ptr<XmlElement> transport_info(
       new XmlElement(QName(kTransportNamespace, "transport"), true));
   XmlElement* offer_tag =
       new XmlElement(QName(kTransportNamespace, "session-description"));
   transport_info->AddElement(offer_tag);
   offer_tag->SetAttr(QName(std::string(), "type"), description->type());
   offer_tag->SetBodyText(description_sdp);
 
-  event_handler_->OnOutgoingTransportInfo(std::move(transport_info));
+  send_transport_info_callback_.Run(std::move(transport_info));
 
   peer_connection_->SetLocalDescription(
       SetSessionDescriptionObserver::Create(base::Bind(
           &WebrtcTransport::OnLocalDescriptionSet, weak_factory_.GetWeakPtr())),
       description.release());
 }
 
 void WebrtcTransport::OnLocalDescriptionSet(bool success,
                                             const std::string& error) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 38 matching lines @@
 
 void WebrtcTransport::Close(ErrorCode error) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   weak_factory_.InvalidateWeakPtrs();
   peer_connection_->Close();
   peer_connection_ = nullptr;
   peer_connection_factory_ = nullptr;
 
   if (error != OK)
-    event_handler_->OnTransportError(error);
+    event_handler_->OnWebrtcTransportError(error);
 }
 
 void WebrtcTransport::OnSignalingChange(
     webrtc::PeerConnectionInterface::SignalingState new_state) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebrtcTransport::OnAddStream(webrtc::MediaStreamInterface* stream) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG(ERROR) << "Stream added " << stream->label();
@@ skipping 31 matching lines @@
         FROM_HERE,
         base::Bind(&WebrtcTransport::SendOffer, weak_factory_.GetWeakPtr()));
   }
 }
 
 void WebrtcTransport::OnIceConnectionChange(
     webrtc::PeerConnectionInterface::IceConnectionState new_state) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (new_state == webrtc::PeerConnectionInterface::kIceConnectionConnected)
-    event_handler_->OnTransportConnected();
+    event_handler_->OnWebrtcTransportConnected();
 }
 
 void WebrtcTransport::OnIceGatheringChange(
     webrtc::PeerConnectionInterface::IceGatheringState new_state) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebrtcTransport::OnIceCandidate(
     const webrtc::IceCandidateInterface* candidate) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 54 matching lines @@
       CreateSessionDescriptionObserver::Create(
           base::Bind(&WebrtcTransport::OnLocalSessionDescriptionCreated,
                      weak_factory_.GetWeakPtr())),
       &offer_config);
 }
 
 void WebrtcTransport::SendTransportInfo() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(pending_transport_info_message_);
 
-  event_handler_->OnOutgoingTransportInfo(
-      std::move(pending_transport_info_message_));
-  pending_transport_info_message_.reset();
+  send_transport_info_callback_.Run(std::move(pending_transport_info_message_));
 }
 
 void WebrtcTransport::AddPendingCandidatesIfPossible() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (peer_connection_->signaling_state() ==
       webrtc::PeerConnectionInterface::kStable) {
     for (auto candidate : pending_incoming_candidates_) {
       if (!peer_connection_->AddIceCandidate(candidate)) {
         LOG(ERROR) << "Failed to add incoming candidate";
         Close(INCOMPATIBLE_PROTOCOL);
         return;
       }
     }
     pending_incoming_candidates_.clear();
   }
 }
 
-WebrtcTransportFactory::WebrtcTransportFactory(
-    rtc::Thread* worker_thread,
-    scoped_refptr<TransportContext> transport_context)
-    : worker_thread_(worker_thread),
-      transport_context_(transport_context) {}
-
-WebrtcTransportFactory::~WebrtcTransportFactory() {}
-
-scoped_ptr<Transport> WebrtcTransportFactory::CreateTransport() {
-  return make_scoped_ptr(
-      new WebrtcTransport(worker_thread_, transport_context_.get()));
-}
-
 }  // namespace protocol
 }  // namespace remoting