Add support for dynamic channels in WebrtcTransport.

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 "base/strings/string_util.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/base/io_buffer.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "remoting/base/compound_buffer.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/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 {
 
 const char kChannelName[] = "test_channel";
 const char kAuthKey[] = "test_auth_key";
 
 class TestTransportEventHandler : public WebrtcTransport::EventHandler {
  public:
   typedef base::Callback<void(ErrorCode error)> ErrorCallback;
+  typedef base::Callback<void(const std::string& name,
+                              std::unique_ptr<MessagePipe> pipe)>
+      IncomingChannelCallback;
 
   TestTransportEventHandler() {}
-  ~TestTransportEventHandler() {}
+  ~TestTransportEventHandler() override {}
 
   // All callbacks must be set before the test handler is passed to a Transport
   // object.
   void set_connecting_callback(const base::Closure& callback) {
     connecting_callback_ = callback;
   }
   void set_connected_callback(const base::Closure& callback) {
     connected_callback_ = callback;
   }
   void set_error_callback(const ErrorCallback& callback) {
     error_callback_ = callback;
   }
+  void set_incoming_channel_callback(const IncomingChannelCallback& callback) {
+    incoming_channel_callback_ = callback;
+  }
 
   // WebrtcTransport::EventHandler interface.
   void OnWebrtcTransportConnecting() override {
     if (!connecting_callback_.is_null())
       connecting_callback_.Run();
   }
   void OnWebrtcTransportConnected() override {
     if (!connected_callback_.is_null())
       connected_callback_.Run();
   }
   void OnWebrtcTransportError(ErrorCode error) override {
     error_callback_.Run(error);
   }
+  void OnWebrtcTransportIncomingDataChannel(
+      const std::string& name,
+      std::unique_ptr<MessagePipe> pipe) override {
+    if (!incoming_channel_callback_.is_null()) {
+      incoming_channel_callback_.Run(name, std::move(pipe));
+    } else {
+      FAIL() << "Received unexpected incoming channel.";
+    }
+  }
   void OnWebrtcTransportMediaStreamAdded(
       scoped_refptr<webrtc::MediaStreamInterface> stream) override {}
   void OnWebrtcTransportMediaStreamRemoved(
       scoped_refptr<webrtc::MediaStreamInterface> stream) override {}
 
  private:
   base::Closure connecting_callback_;
   base::Closure connected_callback_;
   ErrorCallback error_callback_;
+  IncomingChannelCallback incoming_channel_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTransportEventHandler);
 };
 
+class TestMessagePipeEventHandler : public MessagePipe::EventHandler {
+ public:
+  TestMessagePipeEventHandler() {}
+  ~TestMessagePipeEventHandler() override {}
+
+  void set_closed_callback(const base::Closure& callback) {
+    closed_callback_ = callback;
+  }
+
+  // MessagePipe::EventHandler interface.
+  void OnMessageReceived(std::unique_ptr<CompoundBuffer> message) override {
+    NOTREACHED();
+  }
+
+  void OnMessagePipeClosed() override {
+    if (!closed_callback_.is_null()) {
+      closed_callback_.Run();
+    } else {
+      FAIL() << "Channel closed unexpectedly.";
+    }
+  }
+
+ private:
+  base::Closure closed_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestMessagePipeEventHandler);
+};
+
 }  // namespace
 
 class WebrtcTransportTest : public testing::Test {
  public:
   WebrtcTransportTest() {
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
     network_settings_ =
         NetworkSettings(NetworkSettings::NAT_TRAVERSAL_OUTGOING);
   }
 
@@ skipping 74 matching lines @@
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
 
     host_event_handler_.set_connected_callback(base::Closure());
     client_event_handler_.set_connected_callback(base::Closure());
 
     EXPECT_EQ(OK, client_error_);
     EXPECT_EQ(OK, host_error_);
   }
 
-  void CreateClientDataStream() {
-    client_transport_->incoming_channel_factory()->CreateChannel(
-        kChannelName, base::Bind(&WebrtcTransportTest::OnClientChannelCreated,
-                                 base::Unretained(this)));
+  void ExpectClientDataStream() {
+    client_event_handler_.set_incoming_channel_callback(base::Bind(
+        &WebrtcTransportTest::OnIncomingChannel, base::Unretained(this)));
   }
 
   void CreateHostDataStream() {
     host_transport_->outgoing_channel_factory()->CreateChannel(
         kChannelName, base::Bind(&WebrtcTransportTest::OnHostChannelCreated,
                                  base::Unretained(this)));
   }
 
-  void OnClientChannelCreated(std::unique_ptr<MessagePipe> pipe) {
+  void OnIncomingChannel(const std::string& name,
+                         std::unique_ptr<MessagePipe> pipe) {
+    EXPECT_EQ(kChannelName, name);
     client_message_pipe_ = std::move(pipe);
     if (run_loop_ && host_message_pipe_)
       run_loop_->Quit();
   }
 
   void OnHostChannelCreated(std::unique_ptr<MessagePipe> pipe) {
     host_message_pipe_ = std::move(pipe);
     if (run_loop_ && client_message_pipe_)
       run_loop_->Quit();
   }
 
   void OnSessionError(TransportRole role, ErrorCode error) {
     if (role == TransportRole::SERVER) {
       host_error_ = error;
       if (destroy_on_error_) {
         host_message_pipe_.reset();
         host_transport_.reset();
       }
     } else {
       CHECK(role == TransportRole::CLIENT);
       client_error_ = error;
       if (destroy_on_error_) {
         client_message_pipe_.reset();
         client_transport_.reset();
       }
     }
     run_loop_->Quit();
   }
 
+  void OnHostChannelClosed() {
+    host_message_pipe_.reset();
+    run_loop_->Quit();
+  }
+
   void QuitRunLoopOnCounter(int* counter) {
     --(*counter);
     if (*counter == 0)
       run_loop_->Quit();
   }
 
  protected:
   base::MessageLoopForIO message_loop_;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   NetworkSettings network_settings_;
 
   std::unique_ptr<WebrtcTransport> host_transport_;
   TestTransportEventHandler host_event_handler_;
   std::unique_ptr<FakeAuthenticator> host_authenticator_;
 
   std::unique_ptr<WebrtcTransport> client_transport_;
   TestTransportEventHandler client_event_handler_;
   std::unique_ptr<FakeAuthenticator> client_authenticator_;
 
   std::unique_ptr<MessagePipe> client_message_pipe_;
   std::unique_ptr<MessagePipe> host_message_pipe_;
+  TestMessagePipeEventHandler host_message_pipe_event_handler_;
 
   ErrorCode client_error_ = OK;
   ErrorCode host_error_ = OK;
 
   bool destroy_on_error_ = false;
 };
 
 TEST_F(WebrtcTransportTest, Connects) {
   InitializeConnection();
   StartConnection();
   WaitUntilConnected();
 }
 
 TEST_F(WebrtcTransportTest, InvalidAuthKey) {
   InitializeConnection();
   client_authenticator_->set_auth_key("Incorrect Key");
   StartConnection();
 
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
   EXPECT_EQ(AUTHENTICATION_FAILED, client_error_);
 }
 
 TEST_F(WebrtcTransportTest, DataStream) {
   client_event_handler_.set_connecting_callback(base::Bind(
-      &WebrtcTransportTest::CreateClientDataStream, base::Unretained(this)));
+      &WebrtcTransportTest::ExpectClientDataStream, 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_message_pipe_);
   EXPECT_TRUE(host_message_pipe_);
 
   const int kMessageSize = 1024;
   const int kMessages = 100;
   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();
+  ExpectClientDataStream();
   CreateHostDataStream();
 
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
   EXPECT_TRUE(client_message_pipe_);
   EXPECT_TRUE(host_message_pipe_);
 }
 
 TEST_F(WebrtcTransportTest, TerminateDataChannel) {
   InitializeConnection();
   StartConnection();
   WaitUntilConnected();
 
-  CreateClientDataStream();
+  ExpectClientDataStream();
   CreateHostDataStream();
 
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
   EXPECT_TRUE(client_message_pipe_);
   EXPECT_TRUE(host_message_pipe_);
 
   destroy_on_error_ = true;
 
+  // Expect that the channel is closed on the host side once the client closes
+  // the channel.
+  host_message_pipe_->Start(&host_message_pipe_event_handler_);
+  host_message_pipe_event_handler_.set_closed_callback(base::Bind(
+      &WebrtcTransportTest::OnHostChannelClosed, base::Unretained(this)));
+
   // Destroy pipe on one side of the of the connection. It should get closed on
   // the other side.
   client_message_pipe_.reset();
 
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
-  // Check that OnSessionError() has been called.
-  EXPECT_EQ(CHANNEL_CONNECTION_ERROR, host_error_);
-  EXPECT_FALSE(host_transport_);
+  // Check that OnHostChannelClosed() has been called.
+  EXPECT_EQ(OK, host_error_);
+  EXPECT_FALSE(host_message_pipe_);
 }
 
 }  // namespace protocol
 }  // namespace remoting