Add support for dynamic channels in WebrtcTransport.

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 <string>
 #include <utility>
 #include <vector>
 
@@ skipping 128 matching lines @@
 }  // namespace
 
 WebrtcTransport::WebrtcTransport(
     rtc::Thread* worker_thread,
     scoped_refptr<TransportContext> transport_context,
     EventHandler* event_handler)
     : worker_thread_(worker_thread),
       transport_context_(transport_context),
       event_handler_(event_handler),
       handshake_hmac_(crypto::HMAC::SHA256),
-      outgoing_data_stream_adapter_(
-          true,
-          base::Bind(&WebrtcTransport::Close, base::Unretained(this))),
-      incoming_data_stream_adapter_(
-          false,
-          base::Bind(&WebrtcTransport::Close, base::Unretained(this))),
       weak_factory_(this) {
   transport_context_->set_relay_mode(TransportContext::RelayMode::TURN);
 }
 
 WebrtcTransport::~WebrtcTransport() {}
 
 void WebrtcTransport::Start(
     Authenticator* authenticator,
     SendTransportInfoCallback send_transport_info_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 26 matching lines @@
   webrtc::FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            webrtc::MediaConstraintsInterface::kValueTrue);
 
   std::unique_ptr<cricket::PortAllocator> port_allocator =
       transport_context_->port_allocator_factory()->CreatePortAllocator(
           transport_context_);
   peer_connection_ = peer_connection_factory_->CreatePeerConnection(
       rtc_config, &constraints, std::move(port_allocator), nullptr, this);
 
-  outgoing_data_stream_adapter_.Initialize(peer_connection_);
-  incoming_data_stream_adapter_.Initialize(peer_connection_);
+  data_stream_adapter_.reset(new WebrtcDataStreamAdapter(
+      base::Bind(&WebrtcTransport::Close, base::Unretained(this))));
+  data_stream_adapter_->Initialize(peer_connection_);
 
   event_handler_->OnWebrtcTransportConnecting();
 
   if (transport_context_->role() == TransportRole::SERVER)
     RequestNegotiation();
 }
 
 bool WebrtcTransport::ProcessTransportInfo(XmlElement* transport_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 219 matching lines @@
 
 void WebrtcTransport::OnRemoveStream(
     rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
   DCHECK(thread_checker_.CalledOnValidThread());
   event_handler_->OnWebrtcTransportMediaStreamRemoved(stream.get());
 }
 
 void WebrtcTransport::OnDataChannel(
     rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  incoming_data_stream_adapter_.OnIncomingDataChannel(data_channel);
+  data_stream_adapter_->WrapIncomingDataChannel(
+      data_channel,
+      base::Bind(&EventHandler::OnWebrtcTransportIncomingDataChannel,
+                 base::Unretained(event_handler_), data_channel->label()));
 }
 
 void WebrtcTransport::OnRenegotiationNeeded() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (transport_context_->role() == TransportRole::SERVER) {
     RequestNegotiation();
   } else {
     // TODO(sergeyu): Is it necessary to support renegotiation initiated by the
     // client?
@@ skipping 113 matching lines @@
     pending_incoming_candidates_.clear();
   }
 }
 
 void WebrtcTransport::Close(ErrorCode error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!peer_connection_)
     return;
 
   weak_factory_.InvalidateWeakPtrs();
+
+  data_stream_adapter_.reset();
+
   peer_connection_->Close();
   peer_connection_ = nullptr;
   peer_connection_factory_ = nullptr;
 
   if (error != OK)
     event_handler_->OnWebrtcTransportError(error);
 }
 
 }  // namespace protocol
 }  // namespace remoting