PseudoTcp to expose settings of nagling and ACK delay

remoting/protocol/jingle_session_unittest.cc

 // Copyright (c) 2011 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 "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/time.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
@@ skipping 305 matching lines @@
   scoped_refptr<Session> client_session_;
   net::Socket* socket_1_;
   net::Socket* socket_2_;
   base::WaitableEvent done_event_;
 };
 
 class TCPChannelTester : public ChannelTesterBase {
  public:
   TCPChannelTester(MessageLoop* message_loop,
                    Session* host_session,
-                   Session* client_session)
+                   Session* client_session,
+                   int message_size, int message_count)
       : ChannelTesterBase(message_loop, host_session, client_session),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             write_cb_(this, &TCPChannelTester::OnWritten)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             read_cb_(this, &TCPChannelTester::OnRead)),
         write_errors_(0),
-        read_errors_(0) {
+        read_errors_(0),
+        message_size_(message_size),
+        message_count_(message_count),
+        test_data_size_(message_size * message_count) {
   }
 
   virtual ~TCPChannelTester() { }
 
   virtual void CheckResults() {
     EXPECT_EQ(0, write_errors_);
     EXPECT_EQ(0, read_errors_);
 
-    ASSERT_EQ(kTestDataSize + kMessageSize, input_buffer_->capacity());
+    ASSERT_EQ(test_data_size_ + message_size_, input_buffer_->capacity());
 
     output_buffer_->SetOffset(0);
-    ASSERT_EQ(kTestDataSize, output_buffer_->size());
+    ASSERT_EQ(test_data_size_, output_buffer_->size());
 
     EXPECT_EQ(0, memcmp(output_buffer_->data(),
-                        input_buffer_->StartOfBuffer(), kTestDataSize));
+                        input_buffer_->StartOfBuffer(), test_data_size_));
   }
 
  protected:
   virtual void InitBuffers() {
     output_buffer_ = new net::DrainableIOBuffer(
-        new net::IOBuffer(kTestDataSize), kTestDataSize);
-    memset(output_buffer_->data(), 123, kTestDataSize);
+        new net::IOBuffer(test_data_size_), test_data_size_);
+    memset(output_buffer_->data(), 123, test_data_size_);
 
     input_buffer_ = new net::GrowableIOBuffer();
-    // Always keep kMessageSize bytes available at the end of the input buffer.
-    input_buffer_->SetCapacity(kMessageSize);
+    // Always keep message_size_ bytes available at the end of the input buffer.
+    input_buffer_->SetCapacity(message_size_);
   }
 
   virtual void DoWrite() {
     int result = 1;
     while (result > 0) {
       if (output_buffer_->BytesRemaining() == 0)
         break;
 
       int bytes_to_write = std::min(output_buffer_->BytesRemaining(),
-                                    kMessageSize);
+                                    message_size_);
       result = socket_1_->Write(output_buffer_, bytes_to_write, &write_cb_);
       HandleWriteResult(result);
     };
   }
 
   void OnWritten(int result) {
     HandleWriteResult(result);
     DoWrite();
   }
 
   void HandleWriteResult(int result) {
     if (result <= 0 && result != net::ERR_IO_PENDING) {
       LOG(ERROR) << "Received error " << result << " when trying to write";
       write_errors_++;
       done_event_.Signal();
     } else if (result > 0) {
       output_buffer_->DidConsume(result);
     }
   }
 
   virtual void DoRead() {
     int result = 1;
     while (result > 0) {
-      input_buffer_->set_offset(input_buffer_->capacity() - kMessageSize);
+      input_buffer_->set_offset(input_buffer_->capacity() - message_size_);
 
-      result = socket_2_->Read(input_buffer_, kMessageSize, &read_cb_);
+      result = socket_2_->Read(input_buffer_, message_size_, &read_cb_);
       HandleReadResult(result);
     };
   }
 
   void OnRead(int result) {
     HandleReadResult(result);
     if (!done_event_.IsSignaled())
       DoRead();  // Don't try to read again when we are done reading.
   }
 
   void HandleReadResult(int result) {
     if (result <= 0 && result != net::ERR_IO_PENDING) {
       if (!done_event_.IsSignaled()) {
         LOG(ERROR) << "Received error " << result << " when trying to read";
         read_errors_++;
         done_event_.Signal();
       }
     } else if (result > 0) {
       // Allocate memory for the next read.
       input_buffer_->SetCapacity(input_buffer_->capacity() + result);
-      if (input_buffer_->capacity() == kTestDataSize + kMessageSize)
+      if (input_buffer_->capacity() == test_data_size_ + message_size_)
         done_event_.Signal();
     }
   }
 
- private:
   scoped_refptr<net::DrainableIOBuffer> output_buffer_;
   scoped_refptr<net::GrowableIOBuffer> input_buffer_;
 
   net::CompletionCallbackImpl<TCPChannelTester> write_cb_;
   net::CompletionCallbackImpl<TCPChannelTester> read_cb_;
   int write_errors_;
   int read_errors_;
+  int message_size_;
+  int message_count_;
+  int test_data_size_;
+};
+
+class ChannelLatencyTester : public TCPChannelTester {
+ public:
+  ChannelLatencyTester(MessageLoop* message_loop,
+                       Session* host_session,
+                       Session* client_session,
+                       int message_size)
+      : TCPChannelTester(message_loop, host_session,
+                         client_session, message_size, 1) {
+    CHECK(message_size >= 8);
+  }
+
+  virtual ~ChannelLatencyTester() { }
+
+  virtual void CheckResults() {
+  }
+
+  base::TimeDelta GetLatency() {
+    return base::Time::Now() - start_time_;
+  }
+
+ protected:
+  virtual void InitBuffers() {
+    TCPChannelTester::InitBuffers();
+
+    start_time_ = base::Time::Now();
+  }
+
+  base::Time start_time_;
 };
 
 class UDPChannelTester : public ChannelTesterBase {
  public:
   UDPChannelTester(MessageLoop* message_loop,
                    Session* host_session,
                    Session* client_session)
       : ChannelTesterBase(message_loop, host_session, client_session),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             write_cb_(this, &UDPChannelTester::OnWritten)),
@@ skipping 160 matching lines @@
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection());
 }
 
 // Verify that data can be transmitted over the event channel.
 TEST_F(JingleSessionTest, TestControlChannel) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection());
   scoped_refptr<TCPChannelTester> tester(
       new TCPChannelTester(thread_.message_loop(), host_session_,
-                           client_session_));
+                           client_session_, kMessageSize, kMessages));
   tester->Start(ChannelTesterBase::CONTROL);
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 // Verify that data can be transmitted over the video channel.
 TEST_F(JingleSessionTest, TestVideoChannel) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection());
   scoped_refptr<TCPChannelTester> tester(
       new TCPChannelTester(thread_.message_loop(), host_session_,
-                           client_session_));
+                           client_session_, kMessageSize, kMessageSize));
   tester->Start(ChannelTesterBase::VIDEO);
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 // Verify that data can be transmitted over the event channel.
 TEST_F(JingleSessionTest, TestEventChannel) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection());
   scoped_refptr<TCPChannelTester> tester(
       new TCPChannelTester(thread_.message_loop(), host_session_,
-                           client_session_));
+                           client_session_, kMessageSize, kMessageSize));
   tester->Start(ChannelTesterBase::EVENT);
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
 // Verify that data can be transmitted over the video RTP channel.
 TEST_F(JingleSessionTest, TestVideoRtpChannel) {
   CreateServerPair();
   ASSERT_TRUE(InitiateConnection());
   scoped_refptr<UDPChannelTester> tester(
       new UDPChannelTester(thread_.message_loop(), host_session_,
                            client_session_));
   tester->Start(ChannelTesterBase::VIDEO_RTP);
   ASSERT_TRUE(tester->WaitFinished());
   tester->CheckResults();
 
   // Connections must be closed while |tester| still exists.
   CloseSessions();
 }
 
+TEST_F(JingleSessionTest, TestLatency) {

[Sergey Ulanov, 2011/06/28 18:34:26]

Add comment that explain what this test verifies.
Doest this really need to be a unittest? Maybe make a separate benchmarking
tool?

+  CreateServerPair();
+  ASSERT_TRUE(InitiateConnection());
+  scoped_refptr<ChannelLatencyTester> tester;
+
+  tester = new ChannelLatencyTester(thread_.message_loop(), host_session_,
+                                    client_session_, 512);
+  tester->Start(ChannelTesterBase::VIDEO);
+  ASSERT_TRUE(tester->WaitFinished());
+  LOG(INFO) << "Latency for 512 bytes "
+            << tester->GetLatency().InMilliseconds() << " ms.";
+
+  tester = new ChannelLatencyTester(thread_.message_loop(), host_session_,
+                                    client_session_, 1024);
+  tester->Start(ChannelTesterBase::VIDEO);
+  ASSERT_TRUE(tester->WaitFinished());
+  LOG(INFO) << "Latency for 1024 bytes "
+            << tester->GetLatency().InMilliseconds() << " ms.";
+
+  tester = new ChannelLatencyTester(thread_.message_loop(), host_session_,
+                                    client_session_, 51200);
+  tester->Start(ChannelTesterBase::VIDEO);
+  ASSERT_TRUE(tester->WaitFinished());
+  LOG(INFO) << "Latency for 50k bytes "
+            << tester->GetLatency().InMilliseconds() << " ms.";
+
+  tester = new ChannelLatencyTester(thread_.message_loop(), host_session_,
+                                    client_session_, 512000);
+  tester->Start(ChannelTesterBase::VIDEO);
+  ASSERT_TRUE(tester->WaitFinished());
+  LOG(INFO) << "Latency for 500k bytes "
+            << tester->GetLatency().InMilliseconds() << " ms.";
+
+  // Connections must be closed while |tester| still exists.
+  CloseSessions();
+}
+
 #endif
 
 }  // namespace protocol
 }  // namespace remoting