Simplify data channel creation logic in WebRTC-based protocol

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/proto/event.pb.h"
 #include "remoting/protocol/fake_authenticator.h"
 #include "remoting/protocol/message_channel_factory.h"
 #include "remoting/protocol/message_pipe.h"
+#include "remoting/protocol/message_serialization.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 {
@@ skipping 59 matching lines @@
   IncomingChannelCallback incoming_channel_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTransportEventHandler);
 };
 
 class TestMessagePipeEventHandler : public MessagePipe::EventHandler {
  public:
   TestMessagePipeEventHandler() {}
   ~TestMessagePipeEventHandler() override {}
 
+  void set_open_callback(const base::Closure& callback) {
+    open_callback_ = callback;
+  }
+  void set_message_callback(const base::Closure& callback) {
+    message_callback_ = callback;
+  }
   void set_closed_callback(const base::Closure& callback) {
     closed_callback_ = callback;
   }
 
-  // MessagePipe::EventHandler interface.
-  void OnMessageReceived(std::unique_ptr<CompoundBuffer> message) override {
-    NOTREACHED();
+  bool is_open() { return is_open_; }
+  const std::list<std::unique_ptr<CompoundBuffer>>& received_messages() {
+    return received_messages_;
   }
 
+  // MessagePipe::EventHandler interface.
+  void OnMessagePipeOpen() override {
+    is_open_ = true;
+    if (!open_callback_.is_null())
+      open_callback_.Run();
+  }
+  void OnMessageReceived(std::unique_ptr<CompoundBuffer> message) override {
+    received_messages_.push_back(std::move(message));
+    if (!message_callback_.is_null())
+      message_callback_.Run();
+  }
   void OnMessagePipeClosed() override {
     if (!closed_callback_.is_null()) {
       closed_callback_.Run();
     } else {
       FAIL() << "Channel closed unexpectedly.";
     }
   }
 
  private:
+  bool is_open_ = false;
+  base::Closure open_callback_;
+  base::Closure message_callback_;
   base::Closure closed_callback_;
 
+  std::list<std::unique_ptr<CompoundBuffer>> received_messages_;
+
   DISALLOW_COPY_AND_ASSIGN(TestMessagePipeEventHandler);
 };
 
 }  // namespace
 
 class WebrtcTransportTest : public testing::Test {
  public:
   WebrtcTransportTest() {
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
     network_settings_ =
@@ skipping 83 matching lines @@
     EXPECT_EQ(OK, client_error_);
     EXPECT_EQ(OK, host_error_);
   }
 
   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)));
+    host_message_pipe_ = host_transport_->CreateOutgoingChannel(kChannelName);
+    host_message_pipe_->Start(&host_message_pipe_event_handler_);
+    host_message_pipe_event_handler_.set_open_callback(base::Bind(
+        &WebrtcTransportTest::OnHostChannelConnected, base::Unretained(this)));
   }
 
   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_)
+    client_message_pipe_->Start(&client_message_pipe_event_handler_);
+
+    if (run_loop_ && host_message_pipe_event_handler_.is_open())
       run_loop_->Quit();
   }
 
-  void OnHostChannelCreated(std::unique_ptr<MessagePipe> pipe) {
-    host_message_pipe_ = std::move(pipe);
-    if (run_loop_ && client_message_pipe_)
+  void OnHostChannelConnected() {
+    if (run_loop_ && client_message_pipe_event_handler_.is_open())
       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();
       }
@@ skipping 27 matching lines @@
 
   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_;
+  TestMessagePipeEventHandler client_message_pipe_event_handler_;
   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) {
@@ skipping 21 matching lines @@
 
   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();
+  TextEvent message;
+  message.set_text("Hello");
+  host_message_pipe_->Send(&message, base::Closure());
+
+  run_loop_.reset(new base::RunLoop());
+  client_message_pipe_event_handler_.set_message_callback(
+      base::Bind(&base::RunLoop::Quit, base::Unretained(run_loop_.get())));
+  run_loop_->Run();
+
+  ASSERT_EQ(1U, client_message_pipe_event_handler_.received_messages().size());
+
+  std::unique_ptr<TextEvent> received_message = ParseMessage<TextEvent>(
+      client_message_pipe_event_handler_.received_messages().front().get());
+  EXPECT_EQ(message.text(), received_message->text());
 }
 
 // Verify that data streams can be created after connection has been initiated.
 TEST_F(WebrtcTransportTest, DataStreamLate) {
   InitializeConnection();
   StartConnection();
   WaitUntilConnected();
 
   ExpectClientDataStream();
   CreateHostDataStream();
@@ skipping 16 matching lines @@
   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 OnHostChannelClosed() has been called.
   EXPECT_EQ(OK, host_error_);
   EXPECT_FALSE(host_message_pipe_);
 }
 
 }  // namespace protocol
 }  // namespace remoting