In QUIC, send data is copied to streams rather than frames. Protected by FLAGS_quic_reloadable_flag…

net/quic/core/quic_stream_send_buffer_test.cc

Index: net/quic/core/quic_stream_send_buffer_test.cc
diff --git a/net/quic/core/quic_stream_send_buffer_test.cc b/net/quic/core/quic_stream_send_buffer_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a75b7119be6b638d5e1df56cdef8789159a94908
--- /dev/null
+++ b/net/quic/core/quic_stream_send_buffer_test.cc
@@ -0,0 +1,112 @@
+// Copyright (c) 2017 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 "net/quic/core/quic_stream_send_buffer.h"
+
+#include "net/quic/core/quic_data_writer.h"
+#include "net/quic/core/quic_simple_buffer_allocator.h"
+#include "net/quic/core/quic_utils.h"
+#include "net/quic/platform/api/quic_test.h"
+#include "net/quic/test_tools/quic_test_utils.h"
+
+namespace net {
+namespace test {
+namespace {
+
+struct iovec MakeIovec(QuicStringPiece data) {
+  struct iovec iov = {const_cast<char*>(data.data()),
+                      static_cast<size_t>(data.size())};
+  return iov;
+}
+
+class QuicStreamSendBufferTest : public QuicTest {
+ public:
+  QuicStreamSendBufferTest() : send_buffer_(&allocator_) {
+    EXPECT_EQ(0u, send_buffer_.size());
+    std::string data1(1536, 'a');
+    std::string data2(256, 'b');
+    std::string data3(2048, 'c');
+    struct iovec iov[3];
+    iov[0] = MakeIovec(QuicStringPiece(data1));
+    iov[1] = MakeIovec(QuicStringPiece(data2));
+    iov[2] = MakeIovec(QuicStringPiece(data3));
+    QuicIOVector quic_iov(iov, 3, 3840);
+
+    // Add all data.
+    send_buffer_.SaveStreamData(quic_iov, /*iov_offset=*/0, /*offset=*/0, 1024);
+    send_buffer_.SaveStreamData(quic_iov, /*iov_offset=*/1024,
+                                /*offset=*/1024, 1024);
+    send_buffer_.SaveStreamData(quic_iov, /*iov_offset=*/2048,
+                                /*offset=*/2048, 1024);
+    send_buffer_.SaveStreamData(quic_iov, /*iov_offset=*/3072,
+                                /*offset=*/3072, 768);
+    EXPECT_EQ(4u, send_buffer_.size());
+  }
+
+  QuicStreamSendBuffer send_buffer_;
+  SimpleBufferAllocator allocator_;
+};
+
+TEST_F(QuicStreamSendBufferTest, CopyDataToBuffer) {
+  char buf[4000];
+  QuicDataWriter writer(4000, buf, Perspective::IS_CLIENT, HOST_BYTE_ORDER);
+  std::string copy1(1024, 'a');
+  std::string copy2 =
+      std::string(512, 'a') + std::string(256, 'b') + std::string(256, 'c');
+  std::string copy3(1024, 'c');
+  std::string copy4(768, 'c');
+
+  ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer));
+  EXPECT_EQ(copy1, QuicStringPiece(buf, 1024));
+  ASSERT_TRUE(send_buffer_.WriteStreamData(1024, 1024, &writer));
+  EXPECT_EQ(copy2, QuicStringPiece(buf + 1024, 1024));
+  ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 1024, &writer));
+  EXPECT_EQ(copy3, QuicStringPiece(buf + 2048, 1024));
+  ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 768, &writer));
+  EXPECT_EQ(copy4, QuicStringPiece(buf + 3072, 768));
+
+  // Test data piece across boundries.
+  QuicDataWriter writer2(4000, buf, Perspective::IS_CLIENT, HOST_BYTE_ORDER);
+  std::string copy5 =
+      std::string(536, 'a') + std::string(256, 'b') + std::string(232, 'c');
+  ASSERT_TRUE(send_buffer_.WriteStreamData(1000, 1024, &writer2));
+  EXPECT_EQ(copy5, QuicStringPiece(buf, 1024));
+  ASSERT_TRUE(send_buffer_.WriteStreamData(2500, 1024, &writer2));
+  EXPECT_EQ(copy3, QuicStringPiece(buf + 1024, 1024));
+
+  // Invalid data copy.
+  QuicDataWriter writer3(4000, buf, Perspective::IS_CLIENT, HOST_BYTE_ORDER);
+  EXPECT_FALSE(send_buffer_.WriteStreamData(3000, 1024, &writer3));
+  EXPECT_FALSE(send_buffer_.WriteStreamData(0, 4000, &writer3));
+}
+
+TEST_F(QuicStreamSendBufferTest, RemoveStreamFrame) {
+  send_buffer_.RemoveStreamFrame(1024, 1024);
+  EXPECT_EQ(4u, send_buffer_.size());
+  send_buffer_.RemoveStreamFrame(2048, 1024);
+  EXPECT_EQ(4u, send_buffer_.size());
+  send_buffer_.RemoveStreamFrame(0, 1024);
+  // Send buffer is cleaned up in order.
+  EXPECT_EQ(1u, send_buffer_.size());
+  send_buffer_.RemoveStreamFrame(3072, 768);
+  EXPECT_EQ(0u, send_buffer_.size());
+}
+
+TEST_F(QuicStreamSendBufferTest, RemoveStreamFrameAcrossBoundries) {
+  send_buffer_.RemoveStreamFrame(2024, 576);
+  EXPECT_EQ(4u, send_buffer_.size());
+  send_buffer_.RemoveStreamFrame(0, 1000);
+  EXPECT_EQ(4u, send_buffer_.size());
+  send_buffer_.RemoveStreamFrame(1000, 1024);
+  // Send buffer is cleaned up in order.
+  EXPECT_EQ(2u, send_buffer_.size());
+  send_buffer_.RemoveStreamFrame(2600, 1024);
+  EXPECT_EQ(1u, send_buffer_.size());
+  send_buffer_.RemoveStreamFrame(3624, 216);
+  EXPECT_EQ(0u, send_buffer_.size());
+}
+
+}  // namespace
+}  // namespace test
+}  // namespace net