Add MessageChanneFactory interface and use it in ChannelDispatcherBase.

remoting/protocol/ice_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/ice_transport.h"
 
 #include "base/bind.h"
 #include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/channel_multiplexer.h"
 #include "remoting/protocol/pseudotcp_channel_factory.h"
 #include "remoting/protocol/secure_channel_factory.h"
 #include "remoting/protocol/stream_channel_factory.h"
+#include "remoting/protocol/stream_message_pipe_adapter.h"
 #include "remoting/protocol/transport_context.h"
 
 namespace remoting {
 namespace protocol {
 
 // Delay after candidate creation before sending transport-info message to
 // accumulate multiple candidates. This is an optimization to reduce number of
 // transport-info messages.
 const int kTransportInfoSendDelayMs = 20;
 
@@ skipping 15 matching lines @@
 
 void IceTransport::Start(
     Authenticator* authenticator,
     SendTransportInfoCallback send_transport_info_callback) {
   DCHECK(!pseudotcp_channel_factory_);
 
   send_transport_info_callback_ = std::move(send_transport_info_callback);
   pseudotcp_channel_factory_.reset(new PseudoTcpChannelFactory(this));
   secure_channel_factory_.reset(new SecureChannelFactory(
       pseudotcp_channel_factory_.get(), authenticator));
+  message_channel_factory_.reset(new StreamMessageChannelFactoryAdapter(
+      secure_channel_factory_.get(),
+      base::Bind(&IceTransport::OnChannelError, weak_factory_.GetWeakPtr())));
 }
 
 bool IceTransport::ProcessTransportInfo(buzz::XmlElement* transport_info_xml) {
   IceTransportInfo transport_info;
   if (!transport_info.ParseXml(transport_info_xml))
     return false;
 
   for (auto it = transport_info.ice_credentials.begin();
        it != transport_info.ice_credentials.end(); ++it) {
     ChannelsMap::iterator channel = channels_.find(it->channel);
@@ skipping 14 matching lines @@
     } else {
       // Transport info was received before the channel was created.
       // This could happen due to messages being reordered on the wire.
       pending_remote_candidates_.push_back(*it);
     }
   }
 
   return true;
 }
 
-StreamChannelFactory* IceTransport::GetStreamChannelFactory() {
-  return secure_channel_factory_.get();
+MessageChannelFactory* IceTransport::GetChannelFactory() {
+  return message_channel_factory_.get();
 }
 
-StreamChannelFactory* IceTransport::GetMultiplexedChannelFactory() {
-  if (!channel_multiplexer_.get()) {
+MessageChannelFactory* IceTransport::GetMultiplexedChannelFactory() {
+  if (!channel_multiplexer_) {
     channel_multiplexer_.reset(
-        new ChannelMultiplexer(GetStreamChannelFactory(), kMuxChannelName));
+        new ChannelMultiplexer(secure_channel_factory_.get(), kMuxChannelName));
+    mux_channel_factory_.reset(new StreamMessageChannelFactoryAdapter(
+        channel_multiplexer_.get(),
+        base::Bind(&IceTransport::OnChannelError, weak_factory_.GetWeakPtr())));
   }
-  return channel_multiplexer_.get();
+  return mux_channel_factory_.get();
 }
 
 void IceTransport::CreateChannel(const std::string& name,
                                  const ChannelCreatedCallback& callback) {
   DCHECK(!channels_[name]);
 
   scoped_ptr<IceTransportChannel> channel(
       new IceTransportChannel(transport_context_));
   channel->Connect(name, this, callback);
   AddPendingRemoteTransportInfo(channel.get());
@@ skipping 82 matching lines @@
 
 void IceTransport::SendTransportInfo() {
   DCHECK(pending_transport_info_message_);
 
   scoped_ptr<buzz::XmlElement> transport_info_xml =
       pending_transport_info_message_->ToXml();
   pending_transport_info_message_.reset();
   send_transport_info_callback_.Run(std::move(transport_info_xml));
 }
 
+void IceTransport::OnChannelError(int error) {
+  LOG(ERROR) << "Data channel failed, error=" << error;
+  event_handler_->OnIceTransportError(CHANNEL_CONNECTION_ERROR);
+}
+
 }  // namespace protocol
 }  // namespace remoting