Add MessageChanneFactory interface and use it in ChannelDispatcherBase.

remoting/protocol/webrtc_transport_unittest.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/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/base/io_buffer.h"
 #include "net/url_request/url_request_context_getter.h"
-#include "remoting/protocol/chromium_port_allocator.h"
 #include "remoting/protocol/connection_tester.h"
 #include "remoting/protocol/fake_authenticator.h"
+#include "remoting/protocol/message_channel_factory.h"
+#include "remoting/protocol/message_pipe.h"
 #include "remoting/protocol/network_settings.h"
-#include "remoting/protocol/p2p_stream_socket.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/signaling/fake_signal_strategy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
@@ skipping 48 matching lines @@
 class WebrtcTransportTest : public testing::Test {
  public:
   WebrtcTransportTest() {
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
     network_settings_ =
         NetworkSettings(NetworkSettings::NAT_TRAVERSAL_OUTGOING);
   }
 
   void TearDown() override {
     run_loop_.reset();
-    client_socket_.reset();
+    client_message_pipe_.reset();
     client_transport_.reset();
-    host_socket_.reset();
+    host_message_pipe_.reset();
     host_transport_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
   void ProcessTransportInfo(scoped_ptr<WebrtcTransport>* target_transport,
                             scoped_ptr<buzz::XmlElement> transport_info) {
     ASSERT_TRUE(target_transport);
     EXPECT_TRUE((*target_transport)
                     ->ProcessTransportInfo(transport_info.get()));
   }
@@ skipping 57 matching lines @@
         kChannelName, base::Bind(&WebrtcTransportTest::OnClientChannelCreated,
                                  base::Unretained(this)));
   }
 
   void CreateHostDataStream() {
     host_transport_->outgoing_channel_factory()->CreateChannel(
         kChannelName, base::Bind(&WebrtcTransportTest::OnHostChannelCreated,
                                  base::Unretained(this)));
   }
 
-  void OnClientChannelCreated(scoped_ptr<P2PStreamSocket> socket) {
-    client_socket_ = std::move(socket);
-    if (run_loop_ && host_socket_)
+  void OnClientChannelCreated(scoped_ptr<MessagePipe> pipe) {
+    client_message_pipe_ = std::move(pipe);
+    if (run_loop_ && host_message_pipe_)
       run_loop_->Quit();
   }
 
-  void OnHostChannelCreated(scoped_ptr<P2PStreamSocket> socket) {
-    host_socket_ = std::move(socket);
-    if (run_loop_ && client_socket_)
+  void OnHostChannelCreated(scoped_ptr<MessagePipe> pipe) {
+    host_message_pipe_ = std::move(pipe);
+    if (run_loop_ && client_message_pipe_)
       run_loop_->Quit();
   }
 
   void OnSessionError(ErrorCode error) {
     error_ = error;
     run_loop_->Quit();
   }
 
   void QuitRunLoopOnCounter(int* counter) {
     --(*counter);
     if (*counter == 0)
       run_loop_->Quit();
   }
 
  protected:
   base::MessageLoopForIO message_loop_;
   scoped_ptr<base::RunLoop> run_loop_;
 
   NetworkSettings network_settings_;
 
   scoped_ptr<WebrtcTransport> host_transport_;
   TestTransportEventHandler host_event_handler_;
   scoped_ptr<FakeAuthenticator> host_authenticator_;
 
   scoped_ptr<WebrtcTransport> client_transport_;
   TestTransportEventHandler client_event_handler_;
   scoped_ptr<FakeAuthenticator> client_authenticator_;
 
-  scoped_ptr<P2PStreamSocket> client_socket_;
-  scoped_ptr<P2PStreamSocket> host_socket_;
+  scoped_ptr<MessagePipe> client_message_pipe_;
+  scoped_ptr<MessagePipe> host_message_pipe_;
 
   ErrorCode error_ = OK;
 };
 
 TEST_F(WebrtcTransportTest, Connects) {
   InitializeConnection();
   StartConnection();
   WaitUntilConnected();
 }
 
 TEST_F(WebrtcTransportTest, DataStream) {
   client_event_handler_.set_connecting_callback(base::Bind(
       &WebrtcTransportTest::CreateClientDataStream, base::Unretained(this)));
   host_event_handler_.set_connecting_callback(base::Bind(
       &WebrtcTransportTest::CreateHostDataStream, base::Unretained(this)));
 
   InitializeConnection();
   StartConnection();
 
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
-  EXPECT_TRUE(client_socket_);
-  EXPECT_TRUE(host_socket_);
+  EXPECT_TRUE(client_message_pipe_);
+  EXPECT_TRUE(host_message_pipe_);
 
   const int kMessageSize = 1024;
   const int kMessages = 100;
-  StreamConnectionTester tester(host_socket_.get(), client_socket_.get(),
-                                kMessageSize, kMessages);
-  tester.Start();
-  message_loop_.Run();
-  tester.CheckResults();
+  MessagePipeConnectionTester tester(host_message_pipe_.get(),
+                                     client_message_pipe_.get(), kMessageSize,
+                                     kMessages);
+  tester.RunAndCheckResults();
 }
 
 // Verify that data streams can be created after connection has been initiated.
 TEST_F(WebrtcTransportTest, DataStreamLate) {
   InitializeConnection();
   StartConnection();
   WaitUntilConnected();
 
   CreateClientDataStream();
   CreateHostDataStream();
 
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
-  EXPECT_TRUE(client_socket_);
-  EXPECT_TRUE(host_socket_);
+  EXPECT_TRUE(client_message_pipe_);
+  EXPECT_TRUE(host_message_pipe_);
 }
 
 }  // namespace protocol
 }  // namespace remoting