Land Recent QUIC changes.

net/tools/quic/quic_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_server_session.h"
 
 
 #include "net/quic/crypto/crypto_server_config.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_connection.h"
@@ skipping 112 matching lines @@
 TEST_F(QuicServerSessionTest, CloseStreamDueToReset) {
   // Open a stream, then reset it.
   // Send two bytes of payload to open it.
   QuicPacketHeader header;
   header.public_header.guid = guid_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   QuicStreamFrame data1(3, false, 0, "HT");
   vector<QuicStreamFrame> frames;
   frames.push_back(data1);
-  EXPECT_TRUE(visitor_->OnPacket(IPEndPoint(), IPEndPoint(),
-                                 header, frames));
+  EXPECT_TRUE(visitor_->OnStreamFrames(frames));
   EXPECT_EQ(1u, session_->GetNumOpenStreams());
 
   // Pretend we got full headers, so we won't trigger the 'unrecoverable
   // compression context' state.
   MarkHeadersReadForStream(3);
 
   // Send a reset.
   QuicRstStreamFrame rst1(3, QUIC_STREAM_NO_ERROR);
   visitor_->OnRstStream(rst1);
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
 
   // Send the same two bytes of payload in a new packet.
-  EXPECT_TRUE(visitor_->OnPacket(IPEndPoint(), IPEndPoint(),
-                                 header, frames));
+  EXPECT_TRUE(visitor_->OnStreamFrames(frames));
 
   // The stream should not be re-opened.
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
 }
 
 TEST_F(QuicServerSessionTest, NeverOpenStreamDueToReset) {
   // Send a reset.
   QuicRstStreamFrame rst1(3, QUIC_STREAM_NO_ERROR);
   visitor_->OnRstStream(rst1);
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
 
   // Send two bytes of payload.
   QuicPacketHeader header;
   header.public_header.guid = guid_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   QuicStreamFrame data1(3, false, 0, "HT");
   vector<QuicStreamFrame> frames;
   frames.push_back(data1);
 
   // When we get data for the closed stream, it implies the far side has
   // compressed some headers.  As a result we're going to bail due to
   // unrecoverable compression context state.
   EXPECT_CALL(*connection_, SendConnectionClose(
       QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED));
-  EXPECT_FALSE(visitor_->OnPacket(IPEndPoint(), IPEndPoint(),
-                                  header, frames));
+  EXPECT_FALSE(visitor_->OnStreamFrames(frames));
 
   // The stream should never be opened, now that the reset is received.
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
 }
 
 TEST_F(QuicServerSessionTest, GoOverPrematureClosedStreamLimit) {
   QuicPacketHeader header;
   header.public_header.guid = guid_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   QuicStreamFrame data1(3, false, 0, "H");
   vector<QuicStreamFrame> frames;
   frames.push_back(data1);
 
   // Set up the stream such that it's open in OnPacket, but closes half way
   // through while on the decompression blocked list.
   session_->CloseStreamOnData();
 
   EXPECT_CALL(*connection_, SendConnectionClose(
       QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED));
-  EXPECT_FALSE(visitor_->OnPacket(IPEndPoint(), IPEndPoint(),
-                                  header, frames));
+  EXPECT_FALSE(visitor_->OnStreamFrames(frames));
 }
 
 TEST_F(QuicServerSessionTest, AcceptClosedStream) {
   QuicPacketHeader header;
   header.public_header.guid = guid_;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   vector<QuicStreamFrame> frames;
   // Send (empty) compressed headers followed by two bytes of data.
   frames.push_back(QuicStreamFrame(3, false, 0, "\1\0\0\0\0\0\0\0HT"));
   frames.push_back(QuicStreamFrame(5, false, 0, "\2\0\0\0\0\0\0\0HT"));
-  EXPECT_TRUE(visitor_->OnPacket(IPEndPoint(), IPEndPoint(),
-                                 header, frames));
+  EXPECT_TRUE(visitor_->OnStreamFrames(frames));
 
   // Pretend we got full headers, so we won't trigger the 'unercoverable
   // compression context' state.
   MarkHeadersReadForStream(3);
 
   // Send a reset.
   QuicRstStreamFrame rst(3, QUIC_STREAM_NO_ERROR);
   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.
   frames.clear();
   frames.push_back(QuicStreamFrame(3, false, 2, "TP"));
   frames.push_back(QuicStreamFrame(5, false, 2, "TP"));
-  EXPECT_TRUE(visitor_->OnPacket(IPEndPoint(), IPEndPoint(),
-                                 header, frames));
+  EXPECT_TRUE(visitor_->OnStreamFrames(frames));
 }
 
 TEST_F(QuicServerSessionTest, MaxNumConnections) {
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
   EXPECT_TRUE(
       QuicServerSessionPeer::GetIncomingReliableStream(session_.get(), 3));
   EXPECT_TRUE(
       QuicServerSessionPeer::GetIncomingReliableStream(session_.get(), 5));
   EXPECT_TRUE(
       QuicServerSessionPeer::GetIncomingReliableStream(session_.get(), 7));
@@ skipping 14 matching lines @@
   // Incoming streams on the server session must be odd.
   EXPECT_EQ(NULL,
             QuicServerSessionPeer::GetIncomingReliableStream(
                 session_.get(), 2));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net