Landing Recent QUIC changes until Sat Apr 29 00:22:04 2017 +0000

net/quic/core/quic_server_session_base_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/quic/core/quic_server_session_base.h"
 
 #include <cstdint>
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 62 matching lines @@
                               connection,
                               visitor,
                               helper,
                               crypto_config,
                               compressed_certs_cache),
         response_cache_(response_cache) {}
 
   ~TestServerSession() override { delete connection(); };
 
  protected:
+  // TODO(ckrasic) - for two below, remove when
+  // quic_reloadable_flag_quic_refactor_stream_creation is deprecated.
   QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override {
     if (!ShouldCreateIncomingDynamicStream(id)) {
       return nullptr;
     }
     QuicSpdyStream* stream =
         new QuicSimpleServerStream(id, this, response_cache_);
     ActivateStream(QuicWrapUnique(stream));
     return stream;
   }
 
   QuicSpdyStream* CreateOutgoingDynamicStream(SpdyPriority priority) override {
     if (!ShouldCreateOutgoingDynamicStream()) {
       return nullptr;
     }
 
     QuicSpdyStream* stream = new QuicSimpleServerStream(
         GetNextOutgoingStreamId(), this, response_cache_);
     stream->SetPriority(priority);
     ActivateStream(QuicWrapUnique(stream));
     return stream;
   }
 
+  std::unique_ptr<QuicStream> CreateStream(QuicStreamId id) override {
+    return QuicMakeUnique<QuicSimpleServerStream>(id, this, response_cache_);
+  }
+
   QuicCryptoServerStreamBase* CreateQuicCryptoServerStream(
       const QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache) override {
     return new QuicCryptoServerStream(
         crypto_config, compressed_certs_cache,
         FLAGS_quic_reloadable_flag_enable_quic_stateless_reject_support, this,
         stream_helper());
   }
 
  private:
@@ skipping 29 matching lines @@
         config_, connection_, &owner_, &stream_helper_, &crypto_config_,
         &compressed_certs_cache_, &response_cache_));
     MockClock clock;
     handshake_message_.reset(crypto_config_.AddDefaultConfig(
         QuicRandom::GetInstance(), &clock,
         QuicCryptoServerConfig::ConfigOptions()));
     session_->Initialize();
     visitor_ = QuicConnectionPeer::GetVisitor(connection_);
   }
 
+  QuicStreamId GetNthClientInitiatedId(int n) {
+    return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(*session_, n);
+  }
+
+  QuicStreamId GetNthServerInitiatedId(int n) {
+    return QuicSpdySessionPeer::GetNthServerInitiatedStreamId(*session_, n);
+  }
+
   StrictMock<MockQuicSessionVisitor> owner_;
   StrictMock<MockQuicCryptoServerStreamHelper> stream_helper_;
   MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   StrictMock<MockQuicConnection>* connection_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
   QuicCompressedCertsCache compressed_certs_cache_;
   QuicHttpResponseCache response_cache_;
   std::unique_ptr<TestServerSession> session_;
@@ skipping 27 matching lines @@
   EXPECT_FALSE(
       session_->config()->HasReceivedConnectionOptions() &&
       ContainsQuicTag(session_->config()->ReceivedConnectionOptions(), kSPSH));
   session_->OnConfigNegotiated();
   EXPECT_TRUE(session_->server_push_enabled());
 }
 
 TEST_P(QuicServerSessionBaseTest, CloseStreamDueToReset) {
   // Open a stream, then reset it.
   // Send two bytes of payload to open it.
-  QuicStreamFrame data1(kClientDataStreamId1, false, 0, QuicStringPiece("HT"));
+  QuicStreamFrame data1(GetNthClientInitiatedId(0), false, 0,
+                        QuicStringPiece("HT"));
   session_->OnStreamFrame(data1);
   EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams());
 
   // Send a reset (and expect the peer to send a RST in response).
-  QuicRstStreamFrame rst1(kClientDataStreamId1, QUIC_ERROR_PROCESSING_STREAM,
-                          0);
+  QuicRstStreamFrame rst1(GetNthClientInitiatedId(0),
+                          QUIC_ERROR_PROCESSING_STREAM, 0);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
-  EXPECT_CALL(*connection_,
-              SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0));
+  EXPECT_CALL(*connection_, SendRstStream(GetNthClientInitiatedId(0),
+                                          QUIC_RST_ACKNOWLEDGEMENT, 0));
   visitor_->OnRstStream(rst1);
   EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams());
 
   // Send the same two bytes of payload in a new packet.
   visitor_->OnStreamFrame(data1);
 
   // The stream should not be re-opened.
   EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams());
   EXPECT_TRUE(connection_->connected());
 }
 
 TEST_P(QuicServerSessionBaseTest, NeverOpenStreamDueToReset) {
   // Send a reset (and expect the peer to send a RST in response).
-  QuicRstStreamFrame rst1(kClientDataStreamId1, QUIC_ERROR_PROCESSING_STREAM,
-                          0);
+  QuicRstStreamFrame rst1(GetNthClientInitiatedId(0),
+                          QUIC_ERROR_PROCESSING_STREAM, 0);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
-  EXPECT_CALL(*connection_,
-              SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0));
+  EXPECT_CALL(*connection_, SendRstStream(GetNthClientInitiatedId(0),
+                                          QUIC_RST_ACKNOWLEDGEMENT, 0));
   visitor_->OnRstStream(rst1);
   EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams());
 
   // Send two bytes of payload.
-  QuicStreamFrame data1(kClientDataStreamId1, false, 0, QuicStringPiece("HT"));
+  QuicStreamFrame data1(GetNthClientInitiatedId(0), false, 0,
+                        QuicStringPiece("HT"));
   visitor_->OnStreamFrame(data1);
 
   // The stream should never be opened, now that the reset is received.
   EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams());
   EXPECT_TRUE(connection_->connected());
 }
 
 TEST_P(QuicServerSessionBaseTest, AcceptClosedStream) {
   // Send (empty) compressed headers followed by two bytes of data.
-  QuicStreamFrame frame1(kClientDataStreamId1, false, 0,
+  QuicStreamFrame frame1(GetNthClientInitiatedId(0), false, 0,
                          QuicStringPiece("\1\0\0\0\0\0\0\0HT"));
-  QuicStreamFrame frame2(kClientDataStreamId2, false, 0,
+  QuicStreamFrame frame2(GetNthClientInitiatedId(1), false, 0,
                          QuicStringPiece("\2\0\0\0\0\0\0\0HT"));
   visitor_->OnStreamFrame(frame1);
   visitor_->OnStreamFrame(frame2);
   EXPECT_EQ(2u, session_->GetNumOpenIncomingStreams());
 
   // Send a reset (and expect the peer to send a RST in response).
-  QuicRstStreamFrame rst(kClientDataStreamId1, QUIC_ERROR_PROCESSING_STREAM, 0);
+  QuicRstStreamFrame rst(GetNthClientInitiatedId(0),
+                         QUIC_ERROR_PROCESSING_STREAM, 0);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
-  EXPECT_CALL(*connection_,
-              SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0));
+  EXPECT_CALL(*connection_, SendRstStream(GetNthClientInitiatedId(0),
+                                          QUIC_RST_ACKNOWLEDGEMENT, 0));
   visitor_->OnRstStream(rst);
 
   // If we were tracking, we'd probably want to reject this because it's data
   // past the reset point of stream 3.  As it's a closed stream we just drop the
   // data on the floor, but accept the packet because it has data for stream 5.
-  QuicStreamFrame frame3(kClientDataStreamId1, false, 2, QuicStringPiece("TP"));
-  QuicStreamFrame frame4(kClientDataStreamId2, false, 2, QuicStringPiece("TP"));
+  QuicStreamFrame frame3(GetNthClientInitiatedId(0), false, 2,
+                         QuicStringPiece("TP"));
+  QuicStreamFrame frame4(GetNthClientInitiatedId(1), false, 2,
+                         QuicStringPiece("TP"));
   visitor_->OnStreamFrame(frame3);
   visitor_->OnStreamFrame(frame4);
   // The stream should never be opened, now that the reset is received.
   EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams());
   EXPECT_TRUE(connection_->connected());
 }
 
 TEST_P(QuicServerSessionBaseTest, MaxOpenStreams) {
   // Test that the server refuses if a client attempts to open too many data
   // streams.  The server accepts slightly more than the negotiated stream limit
   // to deal with rare cases where a client FIN/RST is lost.
 
   // The slightly increased stream limit is set during config negotiation.  It
   // is either an increase of 10 over negotiated limit, or a fixed percentage
   // scaling, whichever is larger. Test both before continuing.
   session_->OnConfigNegotiated();
   EXPECT_LT(kMaxStreamsMultiplier * kMaxStreamsForTest,
             kMaxStreamsForTest + kMaxStreamsMinimumIncrement);
   EXPECT_EQ(kMaxStreamsForTest + kMaxStreamsMinimumIncrement,
             session_->max_open_incoming_streams());
   EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams());
-  QuicStreamId stream_id = kClientDataStreamId1;
+  QuicStreamId stream_id = GetNthClientInitiatedId(0);
   // Open the max configured number of streams, should be no problem.
   for (size_t i = 0; i < kMaxStreamsForTest; ++i) {
     EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream(
         session_.get(), stream_id));
-    stream_id += 2;
+    stream_id += QuicSpdySessionPeer::NextStreamId(*session_);
   }
 
   // Open more streams: server should accept slightly more than the limit.
   for (size_t i = 0; i < kMaxStreamsMinimumIncrement; ++i) {
     EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream(
         session_.get(), stream_id));
-    stream_id += 2;
+    stream_id += QuicSpdySessionPeer::NextStreamId(*session_);
   }
 
   // Now violate the server's internal stream limit.
-  stream_id += 2;
+  stream_id += QuicSpdySessionPeer::NextStreamId(*session_);
   EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
   EXPECT_CALL(*connection_, SendRstStream(stream_id, QUIC_REFUSED_STREAM, 0));
   // Even if the connection remains open, the stream creation should fail.
   EXPECT_FALSE(QuicServerSessionBasePeer::GetOrCreateDynamicStream(
       session_.get(), stream_id));
 }
 
 TEST_P(QuicServerSessionBaseTest, MaxAvailableStreams) {
   // Test that the server closes the connection if a client makes too many data
   // streams available.  The server accepts slightly more than the negotiated
   // stream limit to deal with rare cases where a client FIN/RST is lost.
 
   session_->OnConfigNegotiated();
   const size_t kAvailableStreamLimit = session_->MaxAvailableStreams();
   EXPECT_EQ(
       session_->max_open_incoming_streams() * kMaxAvailableStreamsMultiplier,
       session_->MaxAvailableStreams());
   // The protocol specification requires that there can be at least 10 times
   // as many available streams as the connection's maximum open streams.
   EXPECT_LE(10 * kMaxStreamsForTest, kAvailableStreamLimit);
 
   EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams());
   EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream(
-      session_.get(), kClientDataStreamId1));
+      session_.get(), GetNthClientInitiatedId(0)));
 
   // Establish available streams up to the server's limit.
+  QuicStreamId next_id = QuicSpdySessionPeer::NextStreamId(*session_);
   const int kLimitingStreamId =
-      kClientDataStreamId1 + (kAvailableStreamLimit)*2 + 2;
+      GetNthClientInitiatedId(kAvailableStreamLimit + 1);
   EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream(
       session_.get(), kLimitingStreamId));
 
   // A further available stream will result in connection close.
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_TOO_MANY_AVAILABLE_STREAMS, _, _));
   // This forces stream kLimitingStreamId + 2 to become available, which
   // violates the quota.
   EXPECT_FALSE(QuicServerSessionBasePeer::GetOrCreateDynamicStream(
-      session_.get(), kLimitingStreamId + 4));
+      session_.get(), kLimitingStreamId + 2 * next_id));
 }
 
 // TODO(ckrasic): remove this when
 // FLAGS_quic_reloadable_flag_quic_enable_server_push_by_default is
 // deprecated.
 TEST_P(QuicServerSessionBaseTest, EnableServerPushThroughConnectionOption) {
   FLAGS_quic_reloadable_flag_quic_enable_server_push_by_default = false;
   // Assume server received server push connection option.
   QuicTagVector copt;
   copt.push_back(kSPSH);
   QuicConfigPeer::SetReceivedConnectionOptions(session_->config(), copt);
   session_->OnConfigNegotiated();
   EXPECT_TRUE(session_->server_push_enabled());
 }
 
 TEST_P(QuicServerSessionBaseTest, GetEvenIncomingError) {
   // Incoming streams on the server session must be odd.
   EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_STREAM_ID, _, _));
   EXPECT_EQ(nullptr, QuicServerSessionBasePeer::GetOrCreateDynamicStream(
-                         session_.get(), 4));
+                         session_.get(), GetNthServerInitiatedId(0)));
 }
 
 TEST_P(QuicServerSessionBaseTest, GetStreamDisconnected) {
   // Don't create new streams if the connection is disconnected.
   QuicConnectionPeer::TearDownLocalConnectionState(connection_);
-  EXPECT_QUIC_BUG(
-      QuicServerSessionBasePeer::GetOrCreateDynamicStream(session_.get(), 5),
-      "ShouldCreateIncomingDynamicStream called when disconnected");
+  if (FLAGS_quic_reloadable_flag_quic_refactor_stream_creation) {
+    EXPECT_EQ(nullptr, QuicServerSessionBasePeer::GetOrCreateDynamicStream(
+                           session_.get(), GetNthClientInitiatedId(0)));
+  } else {
+    EXPECT_QUIC_BUG(
+        QuicServerSessionBasePeer::GetOrCreateDynamicStream(
+            session_.get(), GetNthClientInitiatedId(0)),
+        "ShouldCreateIncomingDynamicStream called when disconnected");
+  }
 }
 
 class MockQuicCryptoServerStream : public QuicCryptoServerStream {
  public:
   explicit MockQuicCryptoServerStream(
       const QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache,
       QuicServerSessionBase* session,
       QuicCryptoServerStream::Helper* helper)
       : QuicCryptoServerStream(
@@ skipping 255 matching lines @@
 
   // Allow the async ProofSource::GetProof call to complete.  Verify (under
   // asan) that this does not result in accesses to any freed memory from the
   // session or its subobjects.
   GetFakeProofSource()->InvokePendingCallback(0);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net