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

net/quic/core/quic_packet_creator_test.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 "net/quic/core/quic_packet_creator.h"
 
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <string>
 
 #include "base/macros.h"
 #include "net/quic/core/crypto/null_encrypter.h"
 #include "net/quic/core/crypto/quic_decrypter.h"
 #include "net/quic/core/crypto/quic_encrypter.h"
+#include "net/quic/core/quic_data_writer.h"
 #include "net/quic/core/quic_pending_retransmission.h"
 #include "net/quic/core/quic_simple_buffer_allocator.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_socket_address.h"
 #include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/api/quic_test.h"
 #include "net/quic/test_tools/quic_framer_peer.h"
 #include "net/quic/test_tools/quic_packet_creator_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
+#include "net/quic/test_tools/simple_data_producer.h"
 
 using std::string;
 using testing::DoAll;
 using testing::InSequence;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
 
 const QuicStreamId kGetNthClientInitiatedStreamId1 = kHeadersStreamId + 2;
 
 // Run tests with combinations of {QuicVersion, ToggleVersionSerialization}.
 struct TestParams {
   TestParams(QuicVersion version,
              bool version_serialization,
-             QuicConnectionIdLength length)
+             QuicConnectionIdLength length,
+             bool delegate_saves_data)
       : version(version),
         connection_id_length(length),
-        version_serialization(version_serialization) {}
+        version_serialization(version_serialization),
+        delegate_saves_data(delegate_saves_data) {}
 
   friend std::ostream& operator<<(std::ostream& os, const TestParams& p) {
     os << "{ client_version: " << QuicVersionToString(p.version)
        << " connection id length: " << p.connection_id_length
-       << " include version: " << p.version_serialization << " }";
+       << " include version: " << p.version_serialization
+       << " delegate_saves_data: " << p.delegate_saves_data << " }";
     return os;
   }
 
   QuicVersion version;
   QuicConnectionIdLength connection_id_length;
   bool version_serialization;
+  bool delegate_saves_data;
 };
 
 // Constructs various test permutations.
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
   constexpr QuicConnectionIdLength kMax = PACKET_8BYTE_CONNECTION_ID;
   QuicVersionVector all_supported_versions = AllSupportedVersions();
-  for (size_t i = 0; i < all_supported_versions.size(); ++i) {
-    params.push_back(TestParams(all_supported_versions[i], true, kMax));
-    params.push_back(TestParams(all_supported_versions[i], false, kMax));
+  for (bool delegate_saves_data : {true, false}) {
+    for (size_t i = 0; i < all_supported_versions.size(); ++i) {
+      params.push_back(TestParams(all_supported_versions[i], true, kMax,
+                                  delegate_saves_data));
+      params.push_back(TestParams(all_supported_versions[i], false, kMax,
+                                  delegate_saves_data));
+    }
+    params.push_back(TestParams(all_supported_versions[0], true,
+                                PACKET_0BYTE_CONNECTION_ID,
+                                delegate_saves_data));
+    params.push_back(
+        TestParams(all_supported_versions[0], true, kMax, delegate_saves_data));
   }
-  params.push_back(
-      TestParams(all_supported_versions[0], true, PACKET_0BYTE_CONNECTION_ID));
-  params.push_back(TestParams(all_supported_versions[0], true, kMax));
   return params;
 }
 
-class MockDelegate : public QuicPacketCreator::DelegateInterface {
- public:
-  MockDelegate() {}
-  ~MockDelegate() override {}
-
-  MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet));
-  MOCK_METHOD3(OnUnrecoverableError,
-               void(QuicErrorCode,
-                    const string&,
-                    ConnectionCloseSource source));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockDelegate);
-};
-
 class QuicPacketCreatorTest : public QuicTestWithParam<TestParams> {
  public:
   void ClearSerializedPacketForTests(SerializedPacket* serialized_packet) {
     if (serialized_packet == nullptr) {
       return;
     }
     ClearSerializedPacket(serialized_packet);
   }
 
   void SaveSerializedPacket(SerializedPacket* serialized_packet) {
@@ skipping 28 matching lines @@
                  &delegate_),
         serialized_packet_(creator_.NoPacket()) {
     creator_.set_connection_id_length(GetParam().connection_id_length);
 
     creator_.SetEncrypter(ENCRYPTION_INITIAL,
                           new NullEncrypter(Perspective::IS_CLIENT));
     creator_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
                           new NullEncrypter(Perspective::IS_CLIENT));
     client_framer_.set_visitor(&framer_visitor_);
     server_framer_.set_visitor(&framer_visitor_);
+    if (GetParam().delegate_saves_data) {
+      creator_.set_delegate_saves_data(true);
+    }
   }
 
   ~QuicPacketCreatorTest() override {
     delete[] serialized_packet_.encrypted_buffer;
     ClearSerializedPacket(&serialized_packet_);
   }
 
   SerializedPacket SerializeAllFrames(const QuicFrames& frames) {
     SerializedPacket packet = QuicPacketCreatorPeer::SerializeAllFrames(
         &creator_, frames, buffer_, kMaxPacketSize);
     EXPECT_EQ(QuicPacketCreatorPeer::GetEncryptionLevel(&creator_),
               packet.encryption_level);
     return packet;
   }
 
   void ProcessPacket(const SerializedPacket& packet) {
     QuicEncryptedPacket encrypted_packet(packet.encrypted_buffer,
                                          packet.encrypted_length);
     server_framer_.ProcessPacket(encrypted_packet);
   }
 
   void CheckStreamFrame(const QuicFrame& frame,
                         QuicStreamId stream_id,
                         const string& data,
                         QuicStreamOffset offset,
                         bool fin) {
     EXPECT_EQ(STREAM_FRAME, frame.type);
     ASSERT_TRUE(frame.stream_frame);
     EXPECT_EQ(stream_id, frame.stream_frame->stream_id);
-    EXPECT_EQ(data, QuicStringPiece(frame.stream_frame->data_buffer,
-                                    frame.stream_frame->data_length));
+    if (GetParam().delegate_saves_data) {
+      char buf[kMaxPacketSize];
+      QuicDataWriter writer(kMaxPacketSize, buf, Perspective::IS_CLIENT,
+                            HOST_BYTE_ORDER);
+      if (frame.stream_frame->data_length > 0) {
+        delegate_.WriteStreamData(stream_id, frame.stream_frame->offset,
+                                  frame.stream_frame->data_length, &writer);
+      }
+      EXPECT_EQ(data, QuicStringPiece(buf, frame.stream_frame->data_length));
+    } else {
+      EXPECT_EQ(data, QuicStringPiece(frame.stream_frame->data_buffer,
+                                      frame.stream_frame->data_length));
+    }
     EXPECT_EQ(offset, frame.stream_frame->offset);
     EXPECT_EQ(fin, frame.stream_frame->fin);
   }
 
   // Returns the number of bytes consumed by the header of packet, including
   // the version.
   size_t GetPacketHeaderOverhead(QuicVersion version) {
     return GetPacketHeaderSize(
         version, creator_.connection_id_length(), kIncludeVersion,
         !kIncludeDiversificationNonce,
@@ skipping 29 matching lines @@
         num_padding_bytes, encryption_level, packet_number_length);
   }
 
   static const QuicStreamOffset kOffset = 1u;
 
   char buffer_[kMaxPacketSize];
   QuicFrames frames_;
   QuicFramer server_framer_;
   QuicFramer client_framer_;
   StrictMock<MockFramerVisitor> framer_visitor_;
-  StrictMock<MockDelegate> delegate_;
+  StrictMock<MockPacketCreatorDelegate> delegate_;
   QuicConnectionId connection_id_;
   string data_;
   struct iovec iov_;
   SimpleBufferAllocator buffer_allocator_;
   QuicPacketCreator creator_;
   SerializedPacket serialized_packet_;
+  SimpleDataProducer producer_;
 };
 
 // Run all packet creator tests with all supported versions of QUIC, and with
 // and without version in the packet header, as well as doing a run for each
 // length of truncated connection id.
 INSTANTIATE_TEST_CASE_P(QuicPacketCreatorTests,
                         QuicPacketCreatorTest,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(QuicPacketCreatorTest, SerializeFrames) {
@@ skipping 790 matching lines @@
   // Flush all paddings.
   while (creator_.pending_padding_bytes() > 0) {
     creator_.Flush();
   }
   EXPECT_EQ(0u, creator_.pending_padding_bytes());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net