Break out the basic reliable QUIC stream functionality from the

net/quic/reliable_quic_stream_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/reliable_quic_stream.h"
 
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_spdy_compressor.h"
 #include "net/quic/quic_spdy_decompressor.h"
@@ skipping 25 matching lines @@
 const bool kShouldProcessData = true;
 
 class TestStream : public ReliableQuicStream {
  public:
   TestStream(QuicStreamId id,
              QuicSession* session,
              bool should_process_data)
       : ReliableQuicStream(id, session),
         should_process_data_(should_process_data) {}
 
-  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
+  virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE {
     EXPECT_NE(0u, data_len);
     DVLOG(1) << "ProcessData data_len: " << data_len;
     data_ += string(data, data_len);
     return should_process_data_ ? data_len : 0;
   }
 
+  virtual QuicPriority EffectivePriority() const OVERRIDE { return 0; }
+
   using ReliableQuicStream::WriteOrBufferData;
   using ReliableQuicStream::CloseReadSide;
   using ReliableQuicStream::CloseWriteSide;
 
   const string& data() const { return data_; }
 
  private:
   bool should_process_data_;
   string data_;
 };
@@ skipping 156 matching lines @@
 
   stream_->CloseReadSide();
   stream_->CloseWriteSide();
   EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
   EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
   stream_->OnConnectionClosed(QUIC_INTERNAL_ERROR, false);
   EXPECT_EQ(QUIC_STREAM_NO_ERROR, stream_->stream_error());
   EXPECT_EQ(QUIC_NO_ERROR, stream_->connection_error());
 }
 
-TEST_F(ReliableQuicStreamTest, ProcessHeaders) {
-  Initialize(kShouldProcessData);
-
-  string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(compressed_headers));
-
-  stream_->OnStreamFrame(frame);
-  EXPECT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_), stream_->data());
-  EXPECT_EQ(static_cast<QuicPriority>(kHighestPriority),
-            stream_->EffectivePriority());
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessHeadersWithInvalidHeaderId) {
-  Initialize(kShouldProcessData);
-
-  string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  compressed_headers[4] = '\xFF';  // Illegal  header id.
-  QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(compressed_headers));
-
-  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID));
-  stream_->OnStreamFrame(frame);
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessHeadersWithInvalidPriority) {
-  Initialize(kShouldProcessData);
-
-  string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  compressed_headers[0] = '\xFF';  // Illegal priority.
-  QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(compressed_headers));
-
-  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_PRIORITY));
-  stream_->OnStreamFrame(frame);
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBody) {
-  Initialize(kShouldProcessData);
-
-  string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  string body = "this is the body";
-  string data = compressed_headers + body;
-  QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data));
-
-  stream_->OnStreamFrame(frame);
-  EXPECT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body,
-            stream_->data());
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyFragments) {
-  Initialize(kShouldProcessData);
-
-  string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kLowestPriority, headers_);
-  string body = "this is the body";
-  string data = compressed_headers + body;
-
-  for (size_t fragment_size = 1; fragment_size < data.size(); ++fragment_size) {
-    Initialize(kShouldProcessData);
-    for (size_t offset = 0; offset < data.size(); offset += fragment_size) {
-      size_t remaining_data = data.length() - offset;
-      StringPiece fragment(data.data() + offset,
-                           min(fragment_size, remaining_data));
-      QuicStreamFrame frame(kStreamId, false, offset, MakeIOVector(fragment));
-
-      stream_->OnStreamFrame(frame);
-    }
-    ASSERT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body,
-              stream_->data()) << "fragment_size: " << fragment_size;
-  }
-
-  for (size_t split_point = 1; split_point < data.size() - 1; ++split_point) {
-    Initialize(kShouldProcessData);
-
-    StringPiece fragment1(data.data(), split_point);
-    QuicStreamFrame frame1(kStreamId, false, 0, MakeIOVector(fragment1));
-    stream_->OnStreamFrame(frame1);
-
-    StringPiece fragment2(data.data() + split_point, data.size() - split_point);
-    QuicStreamFrame frame2(
-        kStreamId, false, split_point, MakeIOVector(fragment2));
-    stream_->OnStreamFrame(frame2);
-
-    ASSERT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body,
-              stream_->data()) << "split_point: " << split_point;
-  }
-  EXPECT_EQ(static_cast<QuicPriority>(kLowestPriority),
-            stream_->EffectivePriority());
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyReadv) {
-  Initialize(!kShouldProcessData);
-
-  string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  string body = "this is the body";
-  string data = compressed_headers + body;
-  QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data));
-  string uncompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string uncompressed_data = uncompressed_headers + body;
-
-  stream_->OnStreamFrame(frame);
-  EXPECT_EQ(uncompressed_headers, stream_->data());
-
-  char buffer[2048];
-  ASSERT_LT(data.length(), arraysize(buffer));
-  struct iovec vec;
-  vec.iov_base = buffer;
-  vec.iov_len = arraysize(buffer);
-
-  size_t bytes_read = stream_->Readv(&vec, 1);
-  EXPECT_EQ(uncompressed_headers.length(), bytes_read);
-  EXPECT_EQ(uncompressed_headers, string(buffer, bytes_read));
-
-  bytes_read = stream_->Readv(&vec, 1);
-  EXPECT_EQ(body.length(), bytes_read);
-  EXPECT_EQ(body, string(buffer, bytes_read));
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
-  Initialize(!kShouldProcessData);
-
-  string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  string body = "this is the body";
-  string data = compressed_headers + body;
-  QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data));
-  string uncompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string uncompressed_data = uncompressed_headers + body;
-
-  stream_->OnStreamFrame(frame);
-  EXPECT_EQ(uncompressed_headers, stream_->data());
-
-  char buffer[1];
-  struct iovec vec;
-  vec.iov_base = buffer;
-  vec.iov_len = arraysize(buffer);
-  for (size_t i = 0; i < uncompressed_data.length(); ++i) {
-    size_t bytes_read = stream_->Readv(&vec, 1);
-    ASSERT_EQ(1u, bytes_read);
-    EXPECT_EQ(uncompressed_data.data()[i], buffer[0]);
-  }
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
-  Initialize(!kShouldProcessData);
-
-  string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  string body = "this is the body";
-  string data = compressed_headers + body;
-  QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data));
-  string uncompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-  string uncompressed_data = uncompressed_headers + body;
-
-  stream_->OnStreamFrame(frame);
-  EXPECT_EQ(uncompressed_headers, stream_->data());
-
-  char buffer1[1];
-  char buffer2[1];
-  struct iovec vec[2];
-  vec[0].iov_base = buffer1;
-  vec[0].iov_len = arraysize(buffer1);
-  vec[1].iov_base = buffer2;
-  vec[1].iov_len = arraysize(buffer2);
-  for (size_t i = 0; i < uncompressed_data.length(); i += 2) {
-    size_t bytes_read = stream_->Readv(vec, 2);
-    ASSERT_EQ(2u, bytes_read) << i;
-    ASSERT_EQ(uncompressed_data.data()[i], buffer1[0]) << i;
-    ASSERT_EQ(uncompressed_data.data()[i + 1], buffer2[0]) << i;
-  }
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessCorruptHeadersEarly) {
-  Initialize(kShouldProcessData);
-
-  string compressed_headers1 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  QuicStreamFrame frame1(
-      stream_->id(), false, 0, MakeIOVector(compressed_headers1));
-  string decompressed_headers1 =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-
-  headers_["content-type"] = "text/plain";
-  string compressed_headers2 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  // Corrupt the compressed data.
-  compressed_headers2[compressed_headers2.length() - 1] ^= 0xA1;
-  QuicStreamFrame frame2(
-      stream2_->id(), false, 0, MakeIOVector(compressed_headers2));
-  string decompressed_headers2 =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-
-  // Deliver frame2 to stream2 out of order.  The decompressor is not
-  // available yet, so no data will be processed.  The compressed data
-  // will be buffered until OnDecompressorAvailable() is called
-  // to process it.
-  stream2_->OnStreamFrame(frame2);
-  EXPECT_EQ("", stream2_->data());
-
-  // Now deliver frame1 to stream1.  The decompressor is available so
-  // the data will be processed, and the decompressor will become
-  // available for stream2.
-  stream_->OnStreamFrame(frame1);
-  EXPECT_EQ(decompressed_headers1, stream_->data());
-
-  // Verify that the decompressor is available, and inform stream2
-  // that it can now decompress the buffered compressed data.    Since
-  // the compressed data is corrupt, the stream will shutdown the session.
-  EXPECT_EQ(2u, session_->decompressor()->current_header_id());
-  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_DECOMPRESSION_FAILURE));
-  stream2_->OnDecompressorAvailable();
-  EXPECT_EQ("", stream2_->data());
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessPartialHeadersEarly) {
-  Initialize(kShouldProcessData);
-
-  string compressed_headers1 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  QuicStreamFrame frame1(
-      stream_->id(), false, 0, MakeIOVector(compressed_headers1));
-  string decompressed_headers1 =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-
-  headers_["content-type"] = "text/plain";
-  string compressed_headers2 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  string partial_compressed_headers =
-      compressed_headers2.substr(0, compressed_headers2.length() / 2);
-  QuicStreamFrame frame2(
-      stream2_->id(), false, 0, MakeIOVector(partial_compressed_headers));
-  string decompressed_headers2 =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-
-  // Deliver frame2 to stream2 out of order.  The decompressor is not
-  // available yet, so no data will be processed.  The compressed data
-  // will be buffered until OnDecompressorAvailable() is called
-  // to process it.
-  stream2_->OnStreamFrame(frame2);
-  EXPECT_EQ("", stream2_->data());
-
-  // Now deliver frame1 to stream1.  The decompressor is available so
-  // the data will be processed, and the decompressor will become
-  // available for stream2.
-  stream_->OnStreamFrame(frame1);
-  EXPECT_EQ(decompressed_headers1, stream_->data());
-
-  // Verify that the decompressor is available, and inform stream2
-  // that it can now decompress the buffered compressed data.  Since
-  // the compressed data is incomplete it will not be passed to
-  // the stream.
-  EXPECT_EQ(2u, session_->decompressor()->current_header_id());
-  stream2_->OnDecompressorAvailable();
-  EXPECT_EQ("", stream2_->data());
-
-  // Now send remaining data and verify that we have now received the
-  // compressed headers.
-  string remaining_compressed_headers =
-      compressed_headers2.substr(partial_compressed_headers.length());
-
-  QuicStreamFrame frame3(stream2_->id(), false,
-                         partial_compressed_headers.length(),
-                         MakeIOVector(remaining_compressed_headers));
-  stream2_->OnStreamFrame(frame3);
-  EXPECT_EQ(decompressed_headers2, stream2_->data());
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessHeadersEarly) {
-  Initialize(kShouldProcessData);
-
-  string compressed_headers1 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  QuicStreamFrame frame1(
-      stream_->id(), false, 0, MakeIOVector(compressed_headers1));
-  string decompressed_headers1 =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-
-  headers_["content-type"] = "text/plain";
-  string compressed_headers2 = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  QuicStreamFrame frame2(
-      stream2_->id(), false, 0, MakeIOVector(compressed_headers2));
-  string decompressed_headers2 =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-
-  // Deliver frame2 to stream2 out of order.  The decompressor is not
-  // available yet, so no data will be processed.  The compressed data
-  // will be buffered until OnDecompressorAvailable() is called
-  // to process it.
-  stream2_->OnStreamFrame(frame2);
-  EXPECT_EQ("", stream2_->data());
-
-  // Now deliver frame1 to stream1.  The decompressor is available so
-  // the data will be processed, and the decompressor will become
-  // available for stream2.
-  stream_->OnStreamFrame(frame1);
-  EXPECT_EQ(decompressed_headers1, stream_->data());
-
-  // Verify that the decompressor is available, and inform stream2
-  // that it can now decompress the buffered compressed data.
-  EXPECT_EQ(2u, session_->decompressor()->current_header_id());
-  stream2_->OnDecompressorAvailable();
-  EXPECT_EQ(decompressed_headers2, stream2_->data());
-}
-
-TEST_F(ReliableQuicStreamTest, ProcessHeadersDelay) {
-  Initialize(!kShouldProcessData);
-
-  string compressed_headers = compressor_->CompressHeadersWithPriority(
-      kHighestPriority, headers_);
-  QuicStreamFrame frame1(
-      stream_->id(), false, 0, MakeIOVector(compressed_headers));
-  string decompressed_headers =
-      SpdyUtils::SerializeUncompressedHeaders(headers_);
-
-  // Send the headers to the stream and verify they were decompressed.
-  stream_->OnStreamFrame(frame1);
-  EXPECT_EQ(2u, session_->decompressor()->current_header_id());
-
-  // Verify that we are now able to handle the body data,
-  // even though the stream has not processed the headers.
-  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID))
-      .Times(0);
-  QuicStreamFrame frame2(stream_->id(), false, compressed_headers.length(),
-                         MakeIOVector("body data"));
-  stream_->OnStreamFrame(frame2);
-}
-
 }  // namespace
 }  // namespace test
 }  // namespace net