1 files changed, 31 insertions, 22 deletions

diff --git a/chromium/net/third_party/quiche/src/quic/qbone/qbone_stream_test.cc b/chromium/net/third_party/quiche/src/quic/qbone/qbone_stream_test.cc
index cfe9645c1d4..18f48f7331b 100644
--- a/chromium/net/third_party/quiche/src/quic/qbone/qbone_stream_test.cc
+++ b/chromium/net/third_party/quiche/src/quic/qbone/qbone_stream_test.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
 #include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
@@ -16,7 +17,6 @@
 #include "net/third_party/quiche/src/quic/qbone/qbone_session_base.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
 
 namespace quic {
@@ -40,13 +40,12 @@ class MockQuicSession : public QboneSessionBase {
   ~MockQuicSession() override {}
 
   // Writes outgoing data from QuicStream to a string.
-  QuicConsumedData WritevData(
-      QuicStreamId id,
-      size_t write_length,
-      QuicStreamOffset offset,
-      StreamSendingState state,
-      TransmissionType type,
-      quiche::QuicheOptional<EncryptionLevel> level) override {
+  QuicConsumedData WritevData(QuicStreamId id,
+                              size_t write_length,
+                              QuicStreamOffset offset,
+                              StreamSendingState state,
+                              TransmissionType type,
+                              absl::optional<EncryptionLevel> level) override {
     if (!writable_) {
       return QuicConsumedData(0, false);
     }
@@ -58,14 +57,21 @@ class MockQuicSession : public QboneSessionBase {
     return nullptr;
   }
 
-  const QuicCryptoStream* GetCryptoStream() const override { return nullptr; }
-  QuicCryptoStream* GetMutableCryptoStream() override { return nullptr; }
-
   // Called by QuicStream when they want to close stream.
   MOCK_METHOD(void,
               SendRstStream,
               (QuicStreamId, QuicRstStreamErrorCode, QuicStreamOffset, bool),
               (override));
+  MOCK_METHOD(void,
+              MaybeSendRstStreamFrame,
+              (QuicStreamId stream_id,
+               QuicRstStreamErrorCode error,
+               QuicStreamOffset bytes_written),
+              (override));
+  MOCK_METHOD(void,
+              MaybeSendStopSendingFrame,
+              (QuicStreamId stream_id, QuicRstStreamErrorCode error),
+              (override));
 
   // Sets whether data is written to buffer, or else if this is write blocked.
   void set_writable(bool writable) { writable_ = writable; }
@@ -86,17 +92,11 @@ class MockQuicSession : public QboneSessionBase {
   }
 
   std::unique_ptr<QuicCryptoStream> CreateCryptoStream() override {
-    return nullptr;
+    return std::make_unique<test::MockQuicCryptoStream>(this);
   }
 
-  MOCK_METHOD(void,
-              ProcessPacketFromPeer,
-              (quiche::QuicheStringPiece),
-              (override));
-  MOCK_METHOD(void,
-              ProcessPacketFromNetwork,
-              (quiche::QuicheStringPiece),
-              (override));
+  MOCK_METHOD(void, ProcessPacketFromPeer, (absl::string_view), (override));
+  MOCK_METHOD(void, ProcessPacketFromNetwork, (absl::string_view), (override));
 
  private:
   // Whether data is written to write_buffer_.
@@ -152,12 +152,14 @@ class QboneReadOnlyStreamTest : public ::testing::Test,
 
     connection_.reset(new QuicConnection(
         test::TestConnectionId(0), QuicSocketAddress(TestLoopback(), 0),
+        QuicSocketAddress(TestLoopback(), 0),
         this /*QuicConnectionHelperInterface*/, alarm_factory_.get(),
         new DummyPacketWriter(), owns_writer, perspective,
         ParsedVersionOfIndex(CurrentSupportedVersions(), 0)));
     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
     session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_.get(),
                                                              QuicConfig());
+    session_->Initialize();
     stream_ = new QboneReadOnlyStream(kStreamId, session_.get());
     session_->ActivateReliableStream(
         std::unique_ptr<QboneReadOnlyStream>(stream_));
@@ -243,8 +245,15 @@ TEST_F(QboneReadOnlyStreamTest, ReadBufferedTooLarge) {
   CreateReliableQuicStream();
   std::string packet = "0123456789";
   int iterations = (QboneConstants::kMaxQbonePacketBytes / packet.size()) + 2;
-  EXPECT_CALL(*session_,
-              SendRstStream(kStreamId, QUIC_BAD_APPLICATION_PAYLOAD, _, _));
+  if (!session_->split_up_send_rst()) {
+    EXPECT_CALL(*session_,
+                SendRstStream(kStreamId, QUIC_BAD_APPLICATION_PAYLOAD, _, _));
+  } else {
+    EXPECT_CALL(*session_, MaybeSendStopSendingFrame(
+                               kStreamId, QUIC_BAD_APPLICATION_PAYLOAD));
+    EXPECT_CALL(*session_, MaybeSendRstStreamFrame(
+                               kStreamId, QUIC_BAD_APPLICATION_PAYLOAD, _));
+  }
   for (int i = 0; i < iterations; ++i) {
     QuicStreamFrame frame(kStreamId, i == (iterations - 1), i * packet.size(),
                           packet);