Add support for dynamic channels in WebrtcTransport.

remoting/protocol/webrtc_connection_to_host.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_connection_to_host.h"
 
 #include <utility>
 
 #include "jingle/glue/thread_wrapper.h"
 #include "remoting/protocol/client_control_dispatcher.h"
 #include "remoting/protocol/client_event_dispatcher.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_stub.h"
+#include "remoting/protocol/message_pipe.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/video_renderer.h"
 #include "remoting/protocol/webrtc_transport.h"
 #include "remoting/protocol/webrtc_video_renderer_adapter.h"
 
 namespace remoting {
 namespace protocol {
 
 WebrtcConnectionToHost::WebrtcConnectionToHost() {}
 WebrtcConnectionToHost::~WebrtcConnectionToHost() {}
@@ skipping 71 matching lines @@
       break;
 
     case Session::FAILED:
       CloseChannels();
       SetState(FAILED, session_->error());
       break;
   }
 }
 
 void WebrtcConnectionToHost::OnWebrtcTransportConnecting() {
-  control_dispatcher_.reset(new ClientControlDispatcher());
-  control_dispatcher_->Init(transport_->incoming_channel_factory(), this);
-  control_dispatcher_->set_client_stub(client_stub_);
-  control_dispatcher_->set_clipboard_stub(clipboard_stub_);
-
   event_dispatcher_.reset(new ClientEventDispatcher());
   event_dispatcher_->Init(transport_->outgoing_channel_factory(), this);
 }
 
 void WebrtcConnectionToHost::OnWebrtcTransportConnected() {}
 
 void WebrtcConnectionToHost::OnWebrtcTransportError(ErrorCode error) {
   CloseChannels();
   SetState(FAILED, error);
 }
 
+void WebrtcConnectionToHost::OnWebrtcTransportIncomingDataChannel(
+    const std::string& name,
+    std::unique_ptr<MessagePipe> pipe) {
+  if (!control_dispatcher_)
+    control_dispatcher_.reset(new ClientControlDispatcher());
+  if (name == control_dispatcher_->channel_name() &&
+      !control_dispatcher_->is_connected()) {
+    control_dispatcher_->set_client_stub(client_stub_);
+    control_dispatcher_->set_clipboard_stub(clipboard_stub_);
+    control_dispatcher_->Init(std::move(pipe), this);
+  }
+}
+
 void WebrtcConnectionToHost::OnWebrtcTransportMediaStreamAdded(
     scoped_refptr<webrtc::MediaStreamInterface> stream) {
   if (video_adapter_) {
     LOG(WARNING)
         << "Received multiple media streams. Ignoring all except the last one.";
   }
   video_adapter_.reset(new WebrtcVideoRendererAdapter(stream, video_renderer_));
 }
 
 void WebrtcConnectionToHost::OnWebrtcTransportMediaStreamRemoved(
     scoped_refptr<webrtc::MediaStreamInterface> stream) {
   if (video_adapter_ && video_adapter_->label() == stream->label())
     video_adapter_.reset();
 }
 
 void WebrtcConnectionToHost::OnChannelInitialized(
     ChannelDispatcherBase* channel_dispatcher) {
   NotifyIfChannelsReady();
 }
 
+void WebrtcConnectionToHost::OnChannelClosed(
+    ChannelDispatcherBase* channel_dispatcher) {
+  LOG(ERROR) << "Channel " << channel_dispatcher->channel_name()
+             << " was closed unexpectedly.";
+  SetState(FAILED, INCOMPATIBLE_PROTOCOL);
+}
+
 ConnectionToHost::State WebrtcConnectionToHost::state() const {
   return state_;
 }
 
 void WebrtcConnectionToHost::NotifyIfChannelsReady() {
   if (!control_dispatcher_.get() || !control_dispatcher_->is_connected())
     return;
   if (!event_dispatcher_.get() || !event_dispatcher_->is_connected())
     return;
 
@@ skipping 16 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting