Landing Recent QUIC changes until 01/31/2016 05:22 UTC

net/tools/quic/quic_simple_server_session_test.cc

 // Copyright 2013 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/tools/quic/quic_simple_server_session.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 13 matching lines @@
 #include "net/quic/test_tools/quic_sustained_bandwidth_recorder_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/test/gtest_util.h"
 #include "net/tools/quic/quic_simple_server_stream.h"
 #include "net/tools/quic/test_tools/mock_quic_server_session_visitor.h"
 #include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::test::CryptoTestUtils;
+using net::test::GenerateBody;
 using net::test::MockConnection;
 using net::test::MockConnectionHelper;
 using net::test::QuicConfigPeer;
 using net::test::QuicConnectionPeer;
 using net::test::QuicSpdyStreamPeer;
 using net::test::QuicSentPacketManagerPeer;
 using net::test::QuicSessionPeer;
 using net::test::QuicSpdySessionPeer;
 using net::test::QuicSustainedBandwidthRecorderPeer;
 using net::test::SupportedVersions;
@@ skipping 125 matching lines @@
         QuicRandom::GetInstance(), &clock,
         QuicCryptoServerConfig::ConfigOptions()));
     session_->Initialize();
     visitor_ = QuicConnectionPeer::GetVisitor(connection_);
     headers_stream_ = new MockQuicHeadersStream(session_.get());
     QuicSpdySessionPeer::SetHeadersStream(session_.get(), headers_stream_);
     // TODO(jri): Remove this line once tests pass.
     FLAGS_quic_cede_correctly = false;
   }
 
-  // Given |num_resources|, create this number of fake push resources and push
-  // them by sending PUSH_PROMISE for all and sending push responses for as much
-  // as possible(limited by kMaxStreamsForTest).
-  // If |num_resources| > kMaxStreamsForTest, the left over will be queued.
-  void PromisePushResources(size_t num_resources) {
-    // Assume encryption already established.
-    MockQuicCryptoServerStream* crypto_stream =
-        new MockQuicCryptoServerStream(&crypto_config_, session_.get());
-    crypto_stream->set_encryption_established(true);
-    QuicSimpleServerSessionPeer::SetCryptoStream(session_.get(), crypto_stream);
-
-    QuicInMemoryCachePeer::ResetForTests();
-
-    string request_url = "mail.google.com/";
-    SpdyHeaderBlock request_headers;
-    string resource_host = "www.google.com";
-    string partial_push_resource_path = "/server_push_src";
-    string partial_push_response_body =
-        "Push resource body " + partial_push_resource_path;
-    list<QuicInMemoryCache::ServerPushInfo> push_resources;
-    string scheme = "http";
-    for (unsigned int i = 1; i <= num_resources; ++i) {
-      string path = partial_push_resource_path + base::UintToString(i);
-      string url = scheme + "://" + resource_host + path;
-      GURL resource_url = GURL(url);
-      string body = partial_push_response_body + base::UintToString(i);
-      SpdyHeaderBlock response_headers;
-      QuicInMemoryCache::GetInstance()->AddSimpleResponse(resource_host, path,
-                                                          200, body);
-      push_resources.push_back(QuicInMemoryCache::ServerPushInfo(
-          resource_url, response_headers, kDefaultPriority, body));
-      // PUSH_PROMISED are sent for all the resources.
-      EXPECT_CALL(*headers_stream_,
-                  WritePushPromise(kClientDataStreamId1, i * 2, _, nullptr));
-      if (i <= kMaxStreamsForTest) {
-        // |kMaxStreamsForTest| promised responses should be sent.
-        EXPECT_CALL(*headers_stream_,
-                    WriteHeaders(i * 2, _, false, kDefaultPriority, nullptr));
-        // Mock that SendStreamData() returns less than supposed to send to keep
-        // the stream open.
-        EXPECT_CALL(*connection_, SendStreamData(i * 2, _, 0, true, _, nullptr))
-            .WillOnce(Return(QuicConsumedData(0, false)));
-      }
-    }
-    session_->PromisePushResources(request_url, push_resources,
-                                   kClientDataStreamId1, request_headers);
-  }
-
   StrictMock<MockQuicServerSessionVisitor> owner_;
   MockConnectionHelper helper_;
   StrictMock<MockConnectionWithSendStreamData>* connection_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
   scoped_ptr<QuicSimpleServerSession> session_;
   scoped_ptr<CryptoHandshakeMessage> handshake_message_;
   QuicConnectionVisitorInterface* visitor_;
   MockQuicHeadersStream* headers_stream_;
 };
@@ skipping 159 matching lines @@
 }
 
 TEST_P(QuicSimpleServerSessionTest, OnStreamFrameWithEvenStreamId) {
   QuicStreamFrame frame(2, false, 0, StringPiece());
   EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
                                 QUIC_INVALID_STREAM_ID,
                                 "Client sent data on server push stream"));
   session_->OnStreamFrame(frame);
 }
 
-TEST_P(QuicSimpleServerSessionTest, TestPromisePushResources) {
+TEST_P(QuicSimpleServerSessionTest, GetEvenIncomingError) {
+  // Tests that calling GetOrCreateDynamicStream() on an outgoing stream not
+  // promised yet should result close connection.
+  EXPECT_CALL(*connection_,
+              SendConnectionCloseWithDetails(QUIC_INVALID_STREAM_ID,
+                                             "Data for nonexistent stream"));
+  EXPECT_EQ(nullptr,
+            QuicSessionPeer::GetOrCreateDynamicStream(session_.get(), 4));
+}
+
+// In order to test the case where server push stream creation goes beyond
+// limit, server push streams need to be hanging there instead of
+// immediately closing after sending back response.
+// To achieve this goal, this class resets flow control windows so that large
+// responses will not be sent fully in order to prevent push streams from being
+// closed immediately.
+// Also adjust connection-level flow control window to ensure a large response
+// can cause stream-level flow control blocked but not connection-level.
+class QuicSimpleServerSessionServerPushTest
+    : public QuicSimpleServerSessionTest {
+ protected:
+  const size_t kStreamFlowControlWindowSize = 32 * 1024;  // 32KB.
+
+  QuicSimpleServerSessionServerPushTest() : QuicSimpleServerSessionTest() {
+    // This flag has to be true for negotiation of max number of outgoing
+    // streams to work correctly.
+    FLAGS_quic_different_max_num_open_streams = true;
+
+    config_.SetMaxStreamsPerConnection(kMaxStreamsForTest, kMaxStreamsForTest);
+
+    // Reset stream level flow control window to be 32KB.
+    QuicConfigPeer::SetReceivedInitialStreamFlowControlWindow(
+        &config_, kStreamFlowControlWindowSize);
+    // Reset connection level flow control window to be 1.5 MB which is large
+    // enough that it won't block any stream to write before stream level flow
+    // control blocks it.
+    QuicConfigPeer::SetReceivedInitialSessionFlowControlWindow(
+        &config_, kInitialSessionFlowControlWindowForTest);
+
+    connection_ = new StrictMock<MockConnectionWithSendStreamData>(
+        &helper_, Perspective::IS_SERVER, SupportedVersions(GetParam()));
+    session_.reset(new QuicSimpleServerSession(config_, connection_, &owner_,
+                                               &crypto_config_));
+    session_->Initialize();
+    // Needed to make new session flow control window work.
+    session_->OnConfigNegotiated();
+
+    visitor_ = QuicConnectionPeer::GetVisitor(connection_);
+    headers_stream_ = new MockQuicHeadersStream(session_.get());
+    QuicSpdySessionPeer::SetHeadersStream(session_.get(), headers_stream_);
+
+    // Assume encryption already established.
+    MockQuicCryptoServerStream* crypto_stream =
+        new MockQuicCryptoServerStream(&crypto_config_, session_.get());
+    crypto_stream->set_encryption_established(true);
+    QuicSimpleServerSessionPeer::SetCryptoStream(session_.get(), crypto_stream);
+  }
+
+  // Given |num_resources|, create this number of fake push resources and push
+  // them by sending PUSH_PROMISE for all and sending push responses for as much
+  // as possible(limited by kMaxStreamsForTest).
+  // If |num_resources| > kMaxStreamsForTest, the left over will be queued.
+  void PromisePushResources(size_t num_resources) {
+    // To prevent push streams from being closed the response need to be larger
+    // than stream flow control window so stream won't send the full body.
+    size_t body_size = 2 * kStreamFlowControlWindowSize;  // 64KB.
+
+    config_.SetMaxStreamsPerConnection(kMaxStreamsForTest, kMaxStreamsForTest);
+
+    QuicInMemoryCachePeer::ResetForTests();
+
+    string request_url = "mail.google.com/";
+    SpdyHeaderBlock request_headers;
+    string resource_host = "www.google.com";
+    string partial_push_resource_path = "/server_push_src";
+    list<QuicInMemoryCache::ServerPushInfo> push_resources;
+    string scheme = "http";
+    for (unsigned int i = 1; i <= num_resources; ++i) {
+      QuicStreamId stream_id = i * 2;
+      string path = partial_push_resource_path + base::UintToString(i);
+      string url = scheme + "://" + resource_host + path;
+      GURL resource_url = GURL(url);
+      string body;
+      GenerateBody(&body, body_size);
+      SpdyHeaderBlock response_headers;
+      QuicInMemoryCache::GetInstance()->AddSimpleResponse(resource_host, path,
+                                                          200, body);
+      push_resources.push_back(QuicInMemoryCache::ServerPushInfo(
+          resource_url, response_headers, kDefaultPriority, body));
+      // PUSH_PROMISED are sent for all the resources.
+      EXPECT_CALL(*headers_stream_, WritePushPromise(kClientDataStreamId1,
+                                                     stream_id, _, nullptr));
+      if (i <= kMaxStreamsForTest) {
+        // |kMaxStreamsForTest| promised responses should be sent.
+        EXPECT_CALL(*headers_stream_, WriteHeaders(stream_id, _, false,
+                                                   kDefaultPriority, nullptr));
+        // Since flow control window is smaller than response body, not the
+        // whole body will be sent.
+        EXPECT_CALL(*connection_,
+                    SendStreamData(stream_id, _, 0, false, _, nullptr))
+            .WillOnce(
+                Return(QuicConsumedData(kStreamFlowControlWindowSize, false)));
+        EXPECT_CALL(*connection_, SendBlocked(stream_id));
+      }
+    }
+    session_->PromisePushResources(request_url, push_resources,
+                                   kClientDataStreamId1, request_headers);
+  }
+};
+
+INSTANTIATE_TEST_CASE_P(Tests,
+                        QuicSimpleServerSessionServerPushTest,
+                        ::testing::ValuesIn(QuicSupportedVersions()));
+
+TEST_P(QuicSimpleServerSessionServerPushTest, TestPromisePushResources) {
   // Tests that given more than kMaxOpenStreamForTest resources, all their
   // PUSH_PROMISE's will be sent out and only |kMaxOpenStreamForTest| streams
   // will be opened and send push response.
   size_t num_resources = kMaxStreamsForTest + 5;
   PromisePushResources(num_resources);
   EXPECT_EQ(kMaxStreamsForTest, session_->GetNumOpenOutgoingStreams());
 }
 
-TEST_P(QuicSimpleServerSessionTest,
+TEST_P(QuicSimpleServerSessionServerPushTest,
        HandlePromisedPushRequestsAfterStreamDraining) {
   // Tests that after promised stream queued up, when an opened stream is marked
   // draining, a queued promised stream will become open and send push response.
   size_t num_resources = kMaxStreamsForTest + 1;
   PromisePushResources(num_resources);
   QuicStreamId next_out_going_stream_id = num_resources * 2;
 
   // After an open stream is marked draining, a new stream is expected to be
   // created and a response sent on the stream.
   EXPECT_CALL(*headers_stream_, WriteHeaders(next_out_going_stream_id, _, false,
                                              kDefaultPriority, nullptr));
   EXPECT_CALL(*connection_,
-              SendStreamData(next_out_going_stream_id, _, 0, true, _, nullptr))
-      .WillOnce(Return(QuicConsumedData(0, false)));
+              SendStreamData(next_out_going_stream_id, _, 0, false, _, nullptr))
+      .WillOnce(Return(QuicConsumedData(kStreamFlowControlWindowSize, false)));
+  EXPECT_CALL(*connection_, SendBlocked(next_out_going_stream_id));
   session_->StreamDraining(2);
   // Number of open outgoing streams should still be the same, because a new
   // stream is opened. And the queue should be empty.
   EXPECT_EQ(kMaxStreamsForTest, session_->GetNumOpenOutgoingStreams());
 }
 
-TEST_P(QuicSimpleServerSessionTest, GetEvenIncomingError) {
-  // Tests that calling GetOrCreateDynamicStream() on an outgoing stream not
-  // promised yet should result close connection.
-  EXPECT_CALL(*connection_,
-              SendConnectionCloseWithDetails(QUIC_INVALID_STREAM_ID,
-                                             "Data for nonexistent stream"));
-  EXPECT_EQ(nullptr,
-            QuicSessionPeer::GetOrCreateDynamicStream(session_.get(), 4));
-}
-
-TEST_P(QuicSimpleServerSessionTest, ResetPromisedStreamToCancelServerPush) {
+TEST_P(QuicSimpleServerSessionServerPushTest,
+       ResetPromisedStreamToCancelServerPush) {
   // Tests that after all resources are promised, a RST frame from client can
   // prevent a promised resource to be send out.
 
   // Having two extra resources to be send later. One of them will be reset, so
   // when opened stream become close, only one will become open.
   size_t num_resources = kMaxStreamsForTest + 2;
   PromisePushResources(num_resources);
 
   // Reset the last stream in the queue. It should be marked cancelled.
   QuicStreamId stream_got_reset = num_resources * 2;
   QuicRstStreamFrame rst(stream_got_reset, QUIC_STREAM_CANCELLED, 0);
   EXPECT_CALL(*connection_,
               SendRstStream(stream_got_reset, QUIC_RST_ACKNOWLEDGEMENT, 0));
   visitor_->OnRstStream(rst);
 
   // When the first 2 streams becomes draining, the two queued up stream could
   // be created. But since one of them was marked cancelled due to RST frame,
   // only one queued resource will be sent out.
   QuicStreamId stream_not_reset = (kMaxStreamsForTest + 1) * 2;
   InSequence s;
   EXPECT_CALL(*headers_stream_, WriteHeaders(stream_not_reset, _, false,
                                              kDefaultPriority, nullptr));
   EXPECT_CALL(*connection_,
-              SendStreamData(stream_not_reset, _, 0, true, _, nullptr))
-      .WillOnce(Return(QuicConsumedData(0, false)));
+              SendStreamData(stream_not_reset, _, 0, false, _, nullptr))
+      .WillOnce(Return(QuicConsumedData(kStreamFlowControlWindowSize, false)));
+  EXPECT_CALL(*connection_, SendBlocked(stream_not_reset));
   EXPECT_CALL(*headers_stream_, WriteHeaders(stream_got_reset, _, false,
                                              kDefaultPriority, nullptr))
       .Times(0);
 
   session_->StreamDraining(2);
   session_->StreamDraining(4);
 }
 
-TEST_P(QuicSimpleServerSessionTest, CloseStreamToHandleMorePromisedStream) {
+TEST_P(QuicSimpleServerSessionServerPushTest,
+       CloseStreamToHandleMorePromisedStream) {
   // Tests that closing a open outgoing stream can trigger a promised resource
   // in the queue to be send out.
   size_t num_resources = kMaxStreamsForTest + 1;
   PromisePushResources(num_resources);
   QuicStreamId stream_to_open = num_resources * 2;
 
   // Resetting 1st open stream will close the stream and give space for extra
   // stream to be opened.
   QuicStreamId stream_got_reset = 2;
   EXPECT_CALL(*connection_,
               SendRstStream(stream_got_reset, QUIC_RST_ACKNOWLEDGEMENT, _));
   EXPECT_CALL(*headers_stream_, WriteHeaders(stream_to_open, _, false,
                                              kDefaultPriority, nullptr));
   EXPECT_CALL(*connection_,
-              SendStreamData(stream_to_open, _, 0, true, _, nullptr))
-      .WillOnce(Return(QuicConsumedData(0, false)));
+              SendStreamData(stream_to_open, _, 0, false, _, nullptr))
+      .WillOnce(Return(QuicConsumedData(kStreamFlowControlWindowSize, false)));
 
+  EXPECT_CALL(*connection_, SendBlocked(stream_to_open));
   QuicRstStreamFrame rst(stream_got_reset, QUIC_STREAM_CANCELLED, 0);
   visitor_->OnRstStream(rst);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net