Update ICE protocol to handle closed channel

remoting/protocol/connection_tester.cc

 // Copyright (c) 2012 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/connection_tester.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
@@ skipping 242 matching lines @@
         bad_packets_received_++;
       } else {
         if (memcmp(read_buffer_->data(), sent_packets_[packet_id]->data(),
                    message_size_) != 0)
           bad_packets_received_++;
       }
     }
   }
 }
 
+class MessagePipeConnectionTester::MessageSender
+    : public MessagePipe::EventHandler {
+ public:
+  MessageSender(MessagePipe* pipe, int message_size, int message_count)
+      : pipe_(pipe),
+        message_size_(message_size),
+        message_count_(message_count) {}
+
+  void Start() { pipe_->Start(this); }
+
+  const std::vector<std::unique_ptr<VideoPacket>>& sent_messages() {
+    return sent_messages_;
+  }
+
+  // MessagePipe::EventHandler interface.
+  void OnMessagePipeOpen() override {
+    for (int i = 0; i < message_count_; ++i) {
+      std::unique_ptr<VideoPacket> message(new VideoPacket());
+      message->mutable_data()->resize(message_size_);
+      for (int p = 0; p < message_size_; ++p) {
+        message->mutable_data()[0] = static_cast<char>(i + p);
+      }
+      pipe_->Send(message.get(), base::Closure());
+      sent_messages_.push_back(std::move(message));
+    }
+  }
+  void OnMessageReceived(std::unique_ptr<CompoundBuffer> message) override {
+    NOTREACHED();
+  }
+  void OnMessagePipeClosed() override { NOTREACHED(); }
+
+ private:
+  MessagePipe* pipe_;
+  int message_size_;
+  int message_count_;
+
+  std::vector<std::unique_ptr<VideoPacket>> sent_messages_;
+};
+
 MessagePipeConnectionTester::MessagePipeConnectionTester(
+    MessagePipe* host_pipe,
     MessagePipe* client_pipe,

[joedow, 2017/03/17 15:13:28]

The order of host/client pipe args was changed in the CC file but not the
header.  Can you fix up the header (or the CC if the swap was not intentional)

[Sergey Ulanov, 2017/03/17 18:18:22]

Done. I swapped it here to match the order in the test, where this constructor
is used. Technically this order doesn't really matter (it just determines the
order in which test messages are sent, but both pipes are bi-directional).

-    MessagePipe* host_pipe,
     int message_size,
     int message_count)
-    : host_pipe_(host_pipe),
-      client_pipe_(client_pipe),
-      message_size_(message_size),
-      message_count_(message_count) {}
+    : client_pipe_(client_pipe),
+      sender_(new MessageSender(host_pipe, message_size, message_count)) {}
+
 MessagePipeConnectionTester::~MessagePipeConnectionTester() {}
 
 void MessagePipeConnectionTester::RunAndCheckResults() {
-  host_pipe_->Start(this);
-}
-
-void MessagePipeConnectionTester::OnMessagePipeOpen() {
-  for (int i = 0; i < message_count_; ++i) {
-    std::unique_ptr<VideoPacket> message(new VideoPacket());
-    message->mutable_data()->resize(message_size_);
-    for (int p = 0; p < message_size_; ++p) {
-      message->mutable_data()[0] = static_cast<char>(i + p);
-    }
-    client_pipe_->Send(message.get(), base::Closure());
-    sent_messages_.push_back(std::move(message));
-  }
+  sender_->Start();
+  client_pipe_->Start(this);
 
   run_loop_.Run();
 
-  ASSERT_EQ(sent_messages_.size(), received_messages_.size());
-  for (size_t i = 0; i < sent_messages_.size(); ++i) {
-    EXPECT_TRUE(sent_messages_[i]->data() == received_messages_[i]->data());
+  ASSERT_EQ(sender_->sent_messages().size(), received_messages_.size());
+  for (size_t i = 0; i < sender_->sent_messages().size(); ++i) {
+    EXPECT_TRUE(sender_->sent_messages()[i]->data() ==
+                received_messages_[i]->data());
   }
 }
 
+void MessagePipeConnectionTester::OnMessagePipeOpen() {}
+
 void MessagePipeConnectionTester::OnMessageReceived(
     std::unique_ptr<CompoundBuffer> message) {
   received_messages_.push_back(ParseMessage<VideoPacket>(message.get()));
-  if (received_messages_.size() >= sent_messages_.size()) {
+  if (received_messages_.size() >= sender_->sent_messages().size()) {
     run_loop_.Quit();
   }
 }
 
 void MessagePipeConnectionTester::OnMessagePipeClosed() {
   run_loop_.Quit();
   FAIL();
 }
 
 }  // namespace protocol
 }  // namespace remoting