Add MessageChanneFactory interface and use it in ChannelDispatcherBase.

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 <utility>
 
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
+#include "remoting/protocol/stream_message_pipe_adapter.h"
 #include "remoting/protocol/transport_context.h"
 #include "third_party/libjingle/source/talk/app/webrtc/test/fakeconstraints.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 #include "third_party/webrtc/modules/audio_device/include/fake_audio_device.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
@@ skipping 68 matching lines @@
   SetSessionDescriptionObserver(const ResultCallback& result_callback)
       : result_callback_(result_callback) {}
   ~SetSessionDescriptionObserver() override {}
 
  private:
   ResultCallback result_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetSessionDescriptionObserver);
 };
 
+void OnChannelErrorHandler(int error) {
+  // WebrtcDataStreamAdapter never returns an error.
+  NOTREACHED();
+}
+
 }  // 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),
       outgoing_data_stream_adapter_(true),
@@ skipping 34 matching lines @@
 
   scoped_ptr<cricket::PortAllocator> port_allocator =
       transport_context_->port_allocator_factory()->CreatePortAllocator(
           transport_context_);
   peer_connection_ = peer_connection_factory_->CreatePeerConnection(
       rtc_config, &constraints,
       rtc::scoped_ptr<cricket::PortAllocator>(port_allocator.release()),
       nullptr, this);
 
   outgoing_data_stream_adapter_.Initialize(peer_connection_);
+  outgoing_channel_factory_.reset(new StreamMessageChannelFactoryAdapter(
+      &outgoing_data_stream_adapter_, base::Bind(&OnChannelErrorHandler)));
+
   incoming_data_stream_adapter_.Initialize(peer_connection_);
+  incoming_channel_factory_.reset(new StreamMessageChannelFactoryAdapter(
+      &incoming_data_stream_adapter_, base::Bind(&OnChannelErrorHandler)));
 
   event_handler_->OnWebrtcTransportConnecting();
 
   if (transport_context_->role() == TransportRole::SERVER)
     RequestNegotiation();
 }
 
 bool WebrtcTransport::ProcessTransportInfo(XmlElement* transport_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 313 matching lines @@
         Close(INCOMPATIBLE_PROTOCOL);
         return;
       }
     }
     pending_incoming_candidates_.clear();
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting