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

net/quic/test_tools/quic_test_utils.h

 // 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.
 //
 // Common utilities for Quic tests
 
 #ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 #define NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 
 #include <cstdint>
@@ skipping 10 matching lines @@
 #include "net/quic/core/quic_connection_close_delegate_interface.h"
 #include "net/quic/core/quic_framer.h"
 #include "net/quic/core/quic_iovector.h"
 #include "net/quic/core/quic_sent_packet_manager.h"
 #include "net/quic/core/quic_server_session_base.h"
 #include "net/quic/core/quic_simple_buffer_allocator.h"
 #include "net/quic/platform/api/quic_ptr_util.h"
 #include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_random.h"
+#include "net/quic/test_tools/simple_data_producer.h"
 #include "net/test/gtest_util.h"
 #include "net/tools/quic/quic_per_connection_packet_writer.h"
 #include "net/tools/quic/test_tools/mock_quic_session_visitor.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 // EXPECT_QUIC_BUG is like EXPECT_DFATAL, except it ensures that no DFATAL
 // logging is skipped due to exponential backoff.
 //
 // For external QUIC, EXPECT_QUIC_BUG should be #defined to EXPECT_DFATAL.
 #define EXPECT_QUIC_BUG EXPECT_DFATAL
@@ skipping 247 matching lines @@
   MOCK_METHOD1(OnConnectionMigration, void(PeerAddressChangeType type));
   MOCK_METHOD0(OnPathDegrading, void());
   MOCK_CONST_METHOD0(WillingAndAbleToWrite, bool());
   MOCK_CONST_METHOD0(HasPendingHandshake, bool());
   MOCK_CONST_METHOD0(HasOpenDynamicStreams, bool());
   MOCK_METHOD1(OnSuccessfulVersionNegotiation,
                void(const QuicVersion& version));
   MOCK_METHOD0(OnConfigNegotiated, void());
   MOCK_METHOD0(PostProcessAfterData, void());
   MOCK_METHOD0(OnAckNeedsRetransmittableFrame, void());
+  void SaveStreamData(QuicStreamId id,
+                      QuicIOVector iov,
+                      size_t iov_offset,
+                      QuicStreamOffset offset,
+                      QuicByteCount data_length) override;
+  bool WriteStreamData(QuicStreamId id,
+                       QuicStreamOffset offset,
+                       QuicByteCount data_length,
+                       QuicDataWriter* writer) override;
 
  private:
+  SimpleDataProducer producer_;
+
   DISALLOW_COPY_AND_ASSIGN(MockQuicConnectionVisitor);
 };
 
 class MockQuicConnectionHelper : public QuicConnectionHelperInterface {
  public:
   MockQuicConnectionHelper();
   ~MockQuicConnectionHelper() override;
   const QuicClock* GetClock() const override;
   QuicRandom* GetRandomGenerator() override;
   QuicBufferAllocator* GetBufferAllocator() override;
@@ skipping 194 matching lines @@
   // has been consumed.
   static QuicConsumedData ConsumeAllData(
       QuicStream* stream,
       QuicStreamId id,
       const QuicIOVector& data,
       QuicStreamOffset offset,
       StreamSendingState state,
       const QuicReferenceCountedPointer<QuicAckListenerInterface>&
           ack_listener);
 
+  QuicConsumedData ConsumeAndSaveAllData(
+      QuicStream* stream,
+      QuicStreamId id,
+      const QuicIOVector& data,
+      QuicStreamOffset offset,
+      StreamSendingState state,
+      const QuicReferenceCountedPointer<QuicAckListenerInterface>&
+          ack_listener);
+
  private:
   std::unique_ptr<QuicCryptoStream> crypto_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(MockQuicSession);
 };
 
 class MockQuicSpdySession : public QuicSpdySession {
  public:
   // Takes ownership of |connection|.
   explicit MockQuicSpdySession(QuicConnection* connection);
@@ skipping 84 matching lines @@
 
   QuicSpdyStream* QuicSpdySessionMaybeCreateOutgoingDynamicStream(
       SpdyPriority priority) {
     return QuicSpdySession::MaybeCreateOutgoingDynamicStream(priority);
   }
 
   bool QuicSpdySessionShouldCreateOutgoingDynamicStream2() {
     return QuicSpdySession::ShouldCreateOutgoingDynamicStream2();
   }
 
+  QuicConsumedData ConsumeAndSaveAllData(
+      QuicStream* stream,
+      QuicStreamId id,
+      const QuicIOVector& data,
+      QuicStreamOffset offset,
+      StreamSendingState state,
+      const QuicReferenceCountedPointer<QuicAckListenerInterface>&
+          ack_listener);
+
   using QuicSession::ActivateStream;
 
  private:
   std::unique_ptr<QuicCryptoStream> crypto_stream_;
   SpdyHeaderBlock write_headers_;
 
   DISALLOW_COPY_AND_ASSIGN(MockQuicSpdySession);
 };
 
 class TestQuicSpdyServerSession : public QuicServerSessionBase {
@@ skipping 267 matching lines @@
  public:
   MockConnectionCloseDelegate();
   ~MockConnectionCloseDelegate() override;
 
   MOCK_METHOD3(OnUnrecoverableError,
                void(QuicErrorCode,
                     const std::string&,
                     ConnectionCloseSource source));
 };
 
+class MockPacketCreatorDelegate : public QuicPacketCreator::DelegateInterface {
+ public:
+  MockPacketCreatorDelegate();
+  ~MockPacketCreatorDelegate() override;
+
+  MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet));
+  MOCK_METHOD3(OnUnrecoverableError,
+               void(QuicErrorCode,
+                    const std::string&,
+                    ConnectionCloseSource source));
+
+  void SaveStreamData(QuicStreamId id,
+                      QuicIOVector iov,
+                      size_t iov_offset,
+                      QuicStreamOffset offset,
+                      QuicByteCount data_length) override;
+  bool WriteStreamData(QuicStreamId id,
+                       QuicStreamOffset offset,
+                       QuicByteCount data_length,
+                       QuicDataWriter* writer) override;
+
+ private:
+  SimpleDataProducer producer_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockPacketCreatorDelegate);
+};
+
 // Creates a client session for testing.
 //
 // server_id: The server id associated with this stream.
 // supports_stateless_rejects:  Does this client support stateless rejects.
 // connection_start_time: The time to set for the connection clock.
 //   Needed for strike-register nonce verification.  The client
 //   connection_start_time should be synchronized witht the server
 //   start time, otherwise nonce verification will fail.
 // supported_versions: Set of QUIC versions this client supports.
 // helper: Pointer to the MockQuicConnectionHelper to use for the session.
@@ skipping 80 matching lines @@
 // Utilities that will adapt stream ids when http stream pairs are
 // enabled.
 QuicStreamId NextStreamId(QuicVersion version);
 QuicStreamId GetNthClientInitiatedStreamId(QuicVersion version, int n);
 QuicStreamId GetNthServerInitiatedStreamId(QuicVersion version, int n);
 
 }  // namespace test
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_