Add support for dynamic channels in WebrtcTransport.

remoting/protocol/webrtc_connection_to_client.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_client.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/base/io_buffer.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/codec/webrtc_video_encoder_vpx.h"
 #include "remoting/protocol/audio_writer.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/host_control_dispatcher.h"
 #include "remoting/protocol/host_event_dispatcher.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
+#include "remoting/protocol/message_pipe.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/webrtc_transport.h"
 #include "remoting/protocol/webrtc_video_stream.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
 #include "third_party/webrtc/api/peerconnectioninterface.h"
 #include "third_party/webrtc/api/test/fakeconstraints.h"
 
 namespace remoting {
 namespace protocol {
 
@@ skipping 116 matching lines @@
       transport_->Close(state == Session::CLOSED ? OK : session_->error());
       control_dispatcher_.reset();
       event_dispatcher_.reset();
       event_handler_->OnConnectionClosed(
           this, state == Session::CLOSED ? OK : session_->error());
       break;
   }
 }
 
 void WebrtcConnectionToClient::OnWebrtcTransportConnecting() {
   control_dispatcher_->Init(transport_->outgoing_channel_factory(), this);

[Jamie, 2016/07/19 18:24:47]

Could this be initialized in OnWebrtcTransportIncomingDataChannel so that the
treatment of the control and event channels is symmetric? If not, please add a
comment explaining why the two channels are treated differently.

[Sergey Ulanov, 2016/07/19 23:38:43]

Control channel is created by the host, while event channel is created by the
client.

[Jamie, 2016/07/20 00:31:39]

It's beyond the scope of this CL, but would it be possible to have all channels
created by the same endpoint?

[Sergey Ulanov, 2016/07/20 01:18:22]

I think we want to support creation of channels in both directions, so that
either end can create channels it needs. For example the host will create a
separate video_stats channels (adding in a separate CL) for each video stream
because the host controls the set of video streams. Similarly the client may
create channels for any new feature we add in the future. Pontially control
channel could be created by the client as well, but I wanted to create on the
host to make sure we support channel creation in both directions.

-
-  event_dispatcher_->Init(transport_->incoming_channel_factory(), this);
-  event_dispatcher_->set_on_input_event_callback(base::Bind(
-      &ConnectionToClient::OnInputEventReceived, base::Unretained(this)));
 }
 
 void WebrtcConnectionToClient::OnWebrtcTransportConnected() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void WebrtcConnectionToClient::OnWebrtcTransportError(ErrorCode error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   Disconnect(error);
 }
 
+void WebrtcConnectionToClient::OnWebrtcTransportIncomingDataChannel(
+    const std::string& name,
+    std::unique_ptr<MessagePipe> pipe) {
+  if (name == event_dispatcher_->channel_name() &&
+      !event_dispatcher_->is_connected()) {
+    event_dispatcher_->set_on_input_event_callback(base::Bind(
+        &ConnectionToClient::OnInputEventReceived, base::Unretained(this)));
+    event_dispatcher_->Init(std::move(pipe), this);
+  }
+}
+
 void WebrtcConnectionToClient::OnWebrtcTransportMediaStreamAdded(
     scoped_refptr<webrtc::MediaStreamInterface> stream) {
   LOG(WARNING) << "The client created an unexpected media stream.";
 }
 
 void WebrtcConnectionToClient::OnWebrtcTransportMediaStreamRemoved(
     scoped_refptr<webrtc::MediaStreamInterface> stream) {}
 
 void WebrtcConnectionToClient::OnChannelInitialized(
     ChannelDispatcherBase* channel_dispatcher) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (control_dispatcher_ && control_dispatcher_->is_connected() &&
       event_dispatcher_ && event_dispatcher_->is_connected()) {
     event_handler_->OnConnectionChannelsConnected(this);
   }
 }
 
+void WebrtcConnectionToClient::OnChannelClosed(
+    ChannelDispatcherBase* channel_dispatcher) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  LOG(ERROR) << "Channel " << channel_dispatcher->channel_name()
+             << " was closed unexpectedly.";
+  Disconnect(INCOMPATIBLE_PROTOCOL);
+}
+
 }  // namespace protocol
 }  // namespace remoting