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 25 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 {
-    LOG(INFO) << "data_len: " << 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";
   }
 
   void Initialize(bool stream_should_process_data) {
-    connection_ = new MockConnection(kGuid, IPEndPoint(), kIsServer);
-    session_.reset(new MockSession(connection_, kIsServer));
+    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(),
                                  stream_should_process_data));
     compressor_.reset(new QuicSpdyCompressor());
     decompressor_.reset(new QuicSpdyDecompressor);
   }
 
  protected:
   MockConnection* connection_;
@@ skipping 217 matching lines @@
   stream2_->OnStreamFrame(frame2);
   EXPECT_EQ("", stream_->data());
 
   stream_->OnStreamFrame(frame1);
   EXPECT_EQ(decompressed_headers1, stream_->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