Land Recent QUIC changes.

net/quic/quic_session_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/quic_session.h"
 
 #include <set>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/spdy/spdy_framer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::hash_map;
 using std::set;
 using std::vector;
 using testing::_;
 using testing::InSequence;
+using testing::InvokeWithoutArgs;
 using testing::StrictMock;
 
 namespace net {
 namespace test {
 namespace {
 
+const QuicPriority kSomeMiddlePriority = 2;
+
 class TestCryptoStream : public QuicCryptoStream {
  public:
   explicit TestCryptoStream(QuicSession* session)
       : QuicCryptoStream(session) {
   }
 
   virtual void OnHandshakeMessage(
       const CryptoHandshakeMessage& message) OVERRIDE {
     encryption_established_ = true;
     handshake_confirmed_ = true;
     CryptoHandshakeMessage msg;
     string error_details;
     session()->config()->ToHandshakeMessage(&msg);
     const QuicErrorCode error = session()->config()->ProcessClientHello(
         msg, &error_details);
     EXPECT_EQ(QUIC_NO_ERROR, error);
     session()->OnCryptoHandshakeEvent(QuicSession::HANDSHAKE_CONFIRMED);
   }
+
+  MOCK_METHOD0(OnCanWrite, void());
 };
 
 class TestStream : public ReliableQuicStream {
  public:
   TestStream(QuicStreamId id, QuicSession* session)
       : ReliableQuicStream(id, session) {
   }
 
   using ReliableQuicStream::CloseWriteSide;
 
   virtual uint32 ProcessData(const char* data, uint32 data_len) {
     return data_len;
   }
 
   MOCK_METHOD0(OnCanWrite, void());
 };
 
+// Poor man's functor for use as callback in a mock.
+class StreamBlocker {
+ public:
+  StreamBlocker(QuicSession* session, QuicStreamId stream_id)
+      : session_(session),
+        stream_id_(stream_id) {
+  }
+
+  void MarkWriteBlocked() {
+    session_->MarkWriteBlocked(stream_id_, kSomeMiddlePriority);
+  }
+
+ private:
+  QuicSession* const session_;
+  const QuicStreamId stream_id_;
+};
+
 class TestSession : public QuicSession {
  public:
   TestSession(QuicConnection* connection, bool is_server)
       : QuicSession(connection, DefaultQuicConfig(), is_server),
         crypto_stream_(this) {
   }
 
-  virtual QuicCryptoStream* GetCryptoStream() OVERRIDE {
+  virtual TestCryptoStream* GetCryptoStream() OVERRIDE {
     return &crypto_stream_;
   }
 
   virtual TestStream* CreateOutgoingReliableStream() OVERRIDE {
     TestStream* stream = new TestStream(GetNextStreamId(), this);
     ActivateStream(stream);
     return stream;
   }
 
   virtual TestStream* CreateIncomingReliableStream(QuicStreamId id) OVERRIDE {
     return new TestStream(id, this);
   }
 
   bool IsClosedStream(QuicStreamId id) {
     return QuicSession::IsClosedStream(id);
   }
 
   ReliableQuicStream* GetIncomingReliableStream(QuicStreamId stream_id) {
     return QuicSession::GetIncomingReliableStream(stream_id);
   }
 
-  // Helper method for gmock
-  void MarkTwoWriteBlocked() {
-    this->MarkWriteBlocked(2, 0);
-  }
-
   TestCryptoStream crypto_stream_;
 };
 
 class QuicSessionTest : public ::testing::Test {
  protected:
   QuicSessionTest()
       : guid_(1),
         connection_(new MockConnection(guid_, IPEndPoint(), false)),
         session_(connection_, true) {
     headers_[":host"] = "www.google.com";
@@ skipping 122 matching lines @@
       "\0\0\0\4"   // length
       "abcd";      // invalid compressed data
   stream->ProcessRawData(data, arraysize(data));
 }
 
 TEST_F(QuicSessionTest, OnCanWrite) {
   TestStream* stream2 = session_.CreateOutgoingReliableStream();
   TestStream* stream4 = session_.CreateOutgoingReliableStream();
   TestStream* stream6 = session_.CreateOutgoingReliableStream();
 
-  session_.MarkWriteBlocked(2, 0);
-  session_.MarkWriteBlocked(6, 0);
-  session_.MarkWriteBlocked(4, 0);
+  session_.MarkWriteBlocked(stream2->id(), kSomeMiddlePriority);
+  session_.MarkWriteBlocked(stream6->id(), kSomeMiddlePriority);
+  session_.MarkWriteBlocked(stream4->id(), kSomeMiddlePriority);
 
   InSequence s;
+  StreamBlocker stream2_blocker(&session_, stream2->id());
   EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(
       // Reregister, to test the loop limit.
-      testing::InvokeWithoutArgs(&session_, &TestSession::MarkTwoWriteBlocked));
+      InvokeWithoutArgs(&stream2_blocker, &StreamBlocker::MarkWriteBlocked));
   EXPECT_CALL(*stream6, OnCanWrite());
   EXPECT_CALL(*stream4, OnCanWrite());
 
   EXPECT_FALSE(session_.OnCanWrite());
 }
 
+TEST_F(QuicSessionTest, BufferedHandshake) {
+  EXPECT_FALSE(session_.HasPendingHandshake());  // Default value.
+
+  // Test that blocking other streams does not change our status.
+  TestStream* stream2 = session_.CreateOutgoingReliableStream();
+  StreamBlocker stream2_blocker(&session_, stream2->id());
+  stream2_blocker.MarkWriteBlocked();
+  EXPECT_FALSE(session_.HasPendingHandshake());
+
+  TestStream* stream3 = session_.CreateOutgoingReliableStream();
+  StreamBlocker stream3_blocker(&session_, stream3->id());
+  stream3_blocker.MarkWriteBlocked();
+  EXPECT_FALSE(session_.HasPendingHandshake());
+
+  // Blocking (due to buffering of) the Crypto stream is detected.
+  session_.MarkWriteBlocked(kCryptoStreamId, kSomeMiddlePriority);
+  EXPECT_TRUE(session_.HasPendingHandshake());
+
+  TestStream* stream4 = session_.CreateOutgoingReliableStream();
+  StreamBlocker stream4_blocker(&session_, stream4->id());
+  stream4_blocker.MarkWriteBlocked();
+  EXPECT_TRUE(session_.HasPendingHandshake());
+
+  InSequence s;
+  // Force most streams to re-register, which is common scenario when we block
+  // the Crypto stream, and only the crypto stream can "really" write.
+
+  // Due to prioritization, we *should* be asked to write the crypto stream
+  // first.
+  // Don't re-register the crypto stream (which signals complete writing).
+  TestCryptoStream* crypto_stream = session_.GetCryptoStream();
+  EXPECT_CALL(*crypto_stream, OnCanWrite());
+
+  // Re-register all other streams, to show they weren't able to proceed.
+  EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(
+      InvokeWithoutArgs(&stream2_blocker, &StreamBlocker::MarkWriteBlocked));
+
+  EXPECT_CALL(*stream3, OnCanWrite()).WillOnce(
+      InvokeWithoutArgs(&stream3_blocker, &StreamBlocker::MarkWriteBlocked));
+
+  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(
+      InvokeWithoutArgs(&stream4_blocker, &StreamBlocker::MarkWriteBlocked));
+
+  EXPECT_FALSE(session_.OnCanWrite());
+  EXPECT_FALSE(session_.HasPendingHandshake());  // Crypto stream wrote.
+}
+
 TEST_F(QuicSessionTest, OnCanWriteWithClosedStream) {
   TestStream* stream2 = session_.CreateOutgoingReliableStream();
   TestStream* stream4 = session_.CreateOutgoingReliableStream();
-  session_.CreateOutgoingReliableStream();  // stream 6
+  TestStream* stream6 = session_.CreateOutgoingReliableStream();
 
-  session_.MarkWriteBlocked(2, 0);
-  session_.MarkWriteBlocked(6, 0);
-  session_.MarkWriteBlocked(4, 0);
-  CloseStream(6);
+  session_.MarkWriteBlocked(stream2->id(), kSomeMiddlePriority);
+  session_.MarkWriteBlocked(stream6->id(), kSomeMiddlePriority);
+  session_.MarkWriteBlocked(stream4->id(), kSomeMiddlePriority);
+  CloseStream(stream6->id());
 
   InSequence s;
   EXPECT_CALL(*stream2, OnCanWrite());
   EXPECT_CALL(*stream4, OnCanWrite());
   EXPECT_TRUE(session_.OnCanWrite());
 }
 
 // Regression test for http://crbug.com/248737
 TEST_F(QuicSessionTest, OutOfOrderHeaders) {
   QuicSpdyCompressor compressor;
@@ skipping 10 matching lines @@
   string compressed_headers1 = compressor.CompressHeaders(headers_);
   QuicStreamFrame frame1(stream2->id(), false, 0, compressed_headers1);
 
   // Create frame with headers for stream4.
   string compressed_headers2 = compressor.CompressHeaders(headers_);
   QuicStreamFrame frame2(stream4->id(), true, 0, compressed_headers2);
 
   // Process the second frame first.  This will cause the headers to
   // be queued up and processed after the first frame is processed.
   frames.push_back(frame2);
-  session_.OnPacket(IPEndPoint(), IPEndPoint(), header, frames);
+  session_.OnStreamFrames(frames);
 
   // Process the first frame, and un-cork the buffered headers.
   frames[0] = frame1;
-  session_.OnPacket(IPEndPoint(), IPEndPoint(), header, frames);
+  session_.OnStreamFrames(frames);
 
   // Ensure that the streams actually close and we don't DCHECK.
   connection_->CloseConnection(QUIC_CONNECTION_TIMED_OUT, true);
 }
 
 TEST_F(QuicSessionTest, SendGoAway) {
   // After sending a GoAway, ensure new incoming streams cannot be created and
   // result in a RST being sent.
   EXPECT_CALL(*connection_,
               SendGoAway(QUIC_PEER_GOING_AWAY, 0u, "Going Away."));
@@ skipping 38 matching lines @@
 
   // Create frame with headers for stream2.
   QuicSpdyCompressor compressor;
   string compressed_headers1 = compressor.CompressHeaders(headers_);
   QuicStreamFrame frame1(stream3->id(), false, 0, compressed_headers1);
 
   // Process the second frame first.  This will cause the headers to
   // be queued up and processed after the first frame is processed.
   frames.push_back(frame1);
   EXPECT_FALSE(stream3->headers_decompressed());
-  session.OnPacket(IPEndPoint(), IPEndPoint(), header, frames);
+
+  session.OnStreamFrames(frames);
   EXPECT_EQ(1u, session.GetNumOpenStreams());
 
   EXPECT_TRUE(connection->connected());
 }
 
 TEST_F(QuicSessionTest, ZombieStreamConnectionClose) {
   StrictMock<MockConnection>* connection =
       new StrictMock<MockConnection>(guid_, IPEndPoint(), false);
   TestSession session(connection, /*is_server=*/ false);
 
@@ skipping 13 matching lines @@
   EXPECT_EQ(1u, session.GetNumOpenStreams());
 
   connection->CloseConnection(QUIC_CONNECTION_TIMED_OUT, false);
 
   EXPECT_EQ(0u, session.GetNumOpenStreams());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net