Land Recent QUIC changes.

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_connection.h"
 #include "net/quic/quic_spdy_compressor.h"
 #include "net/quic/quic_spdy_decompressor.h"
 #include "net/quic/quic_utils.h"
@@ skipping 26 matching lines @@
 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 {
+    EXPECT_NE(0u, data_len);
     DVLOG(1) << "ProcessData data_len: " << data_len;
     data_ += string(data, data_len);
     return should_process_data_ ? data_len : 0;
   }
 
   using ReliableQuicStream::WriteData;
   using ReliableQuicStream::CloseReadSide;
   using ReliableQuicStream::CloseWriteSide;
 
   const string& data() const { return data_; }
 
  private:
   bool should_process_data_;
   string data_;
 };
 
 class ReliableQuicStreamTest : public ::testing::TestWithParam<bool> {
  public:
   ReliableQuicStreamTest() {
     headers_[":host"] = "www.google.com";
     headers_[":path"] = "/index.hml";
     headers_[":scheme"] = "https";
+    headers_["cookie"] =
+        "__utma=208381060.1228362404.1372200928.1372200928.1372200928.1; "
+        "__utmc=160408618; "
+        "GX=DQAAAOEAAACWJYdewdE9rIrW6qw3PtVi2-d729qaa-74KqOsM1NVQblK4VhX"
+        "hoALMsy6HOdDad2Sz0flUByv7etmo3mLMidGrBoljqO9hSVA40SLqpG_iuKKSHX"
+        "RW3Np4bq0F0SDGDNsW0DSmTS9ufMRrlpARJDS7qAI6M3bghqJp4eABKZiRqebHT"
+        "pMU-RXvTI5D5oCF1vYxYofH_l1Kviuiy3oQ1kS1enqWgbhJ2t61_SNdv-1XJIS0"
+        "O3YeHLmVCs62O6zp89QwakfAWK9d3IDQvVSJzCQsvxvNIvaZFa567MawWlXg0Rh"
+        "1zFMi5vzcns38-8_Sns; "
+        "GA=v*2%2Fmem*57968640*47239936%2Fmem*57968640*47114716%2Fno-nm-"
+        "yj*15%2Fno-cc-yj*5%2Fpc-ch*133685%2Fpc-s-cr*133947%2Fpc-s-t*1339"
+        "47%2Fno-nm-yj*4%2Fno-cc-yj*1%2Fceft-as*1%2Fceft-nqas*0%2Fad-ra-c"
+        "v_p%2Fad-nr-cv_p-f*1%2Fad-v-cv_p*859%2Fad-ns-cv_p-f*1%2Ffn-v-ad%"
+        "2Fpc-t*250%2Fpc-cm*461%2Fpc-s-cr*722%2Fpc-s-t*722%2Fau_p*4"
+        "SICAID=AJKiYcHdKgxum7KMXG0ei2t1-W4OD1uW-ecNsCqC0wDuAXiDGIcT_HA2o1"
+        "3Rs1UKCuBAF9g8rWNOFbxt8PSNSHFuIhOo2t6bJAVpCsMU5Laa6lewuTMYI8MzdQP"
+        "ARHKyW-koxuhMZHUnGBJAM1gJODe0cATO_KGoX4pbbFxxJ5IicRxOrWK_5rU3cdy6"
+        "edlR9FsEdH6iujMcHkbE5l18ehJDwTWmBKBzVD87naobhMMrF6VvnDGxQVGp9Ir_b"
+        "Rgj3RWUoPumQVCxtSOBdX0GlJOEcDTNCzQIm9BSfetog_eP_TfYubKudt5eMsXmN6"
+        "QnyXHeGeK2UINUzJ-D30AFcpqYgH9_1BvYSpi7fc7_ydBU8TaD8ZRxvtnzXqj0RfG"
+        "tuHghmv3aD-uzSYJ75XDdzKdizZ86IG6Fbn1XFhYZM-fbHhm3mVEXnyRW4ZuNOLFk"
+        "Fas6LMcVC6Q8QLlHYbXBpdNFuGbuZGUnav5C-2I_-46lL0NGg3GewxGKGHvHEfoyn"
+        "EFFlEYHsBQ98rXImL8ySDycdLEFvBPdtctPmWCfTxwmoSMLHU2SCVDhbqMWU5b0yr"
+        "JBCScs_ejbKaqBDoB7ZGxTvqlrB__2ZmnHHjCr8RgMRtKNtIeuZAo ";
   }
 
   void Initialize(bool stream_should_process_data) {
     connection_ = new testing::StrictMock<MockConnection>(
         kGuid, IPEndPoint(), kIsServer);
     session_.reset(new testing::StrictMock<MockSession>(
         connection_, kIsServer));
     stream_.reset(new TestStream(kStreamId, session_.get(),
                                  stream_should_process_data));
     stream2_.reset(new TestStream(kStreamId + 2, session_.get(),
@@ skipping 177 matching lines @@
       size_t remaining_data = data.length() - offset;
       StringPiece fragment(data.data() + offset,
                            min(fragment_size, remaining_data));
       QuicStreamFrame frame(kStreamId, false, offset, 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, fragment1);
+    stream_->OnStreamFrame(frame1);
+
+    StringPiece fragment2(data.data() + split_point, data.size() - split_point);
+    QuicStreamFrame frame2(kStreamId, false, split_point, fragment2);
+    stream_->OnStreamFrame(frame2);
+
+    ASSERT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body,
+              stream_->data()) << "split_point: " << split_point;
+  }
 }
 
 TEST_F(ReliableQuicStreamTest, ProcessHeadersAndBodyReadv) {
   Initialize(!kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeaders(headers_);
   string body = "this is the body";
   string data = compressed_headers + body;
   QuicStreamFrame frame(kStreamId, false, 0, data);
   string uncompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
   string uncompressed_data = uncompressed_headers + body;
 
   stream_->OnStreamFrame(frame);
   EXPECT_EQ(uncompressed_headers, stream_->data());
 
-  char buffer[1024];
+  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);
@@ skipping 48 matching lines @@
   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_->CompressHeaders(headers_);
+  QuicStreamFrame frame1(stream_->id(), false, 0, compressed_headers1);
+  string decompressed_headers1 =
+      SpdyUtils::SerializeUncompressedHeaders(headers_);
+
+  headers_["content-type"] = "text/plain";
+  string compressed_headers2 = compressor_->CompressHeaders(headers_);
+  compressed_headers2[4] ^= 0xA1;  // Corrupt the comressed data.
+  QuicStreamFrame frame2(stream2_->id(), false, 0, 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, ProcessHeadersEarly) {
   Initialize(kShouldProcessData);
 
   string compressed_headers1 = compressor_->CompressHeaders(headers_);
   QuicStreamFrame frame1(stream_->id(), false, 0, compressed_headers1);
   string decompressed_headers1 =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
 
   headers_["content-type"] = "text/plain";
   string compressed_headers2 = compressor_->CompressHeaders(headers_);
   QuicStreamFrame frame2(stream2_->id(), false, 0, 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("", stream_->data());
+  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_->CompressHeaders(headers_);
   QuicStreamFrame frame1(stream_->id(), false, 0, 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(),
                          "body data");
   stream_->OnStreamFrame(frame2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net