Land Recent QUIC Changes

net/quic/quic_http_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/quic_http_stream.h"
 
 #include <vector>
 
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 26 matching lines @@
 namespace test {
 namespace {
 
 const char kUploadData[] = "hello world!";
 
 class TestQuicConnection : public QuicConnection {
  public:
   TestQuicConnection(QuicGuid guid,
                      IPEndPoint address,
                      QuicConnectionHelper* helper)
-      : QuicConnection(guid, address, helper) {
+      : QuicConnection(guid, address, helper, false) {
   }
 
   void SetSendAlgorithm(SendAlgorithmInterface* send_algorithm) {
     QuicConnectionPeer::SetSendAlgorithm(this, send_algorithm);
   }
 
   void SetReceiveAlgorithm(ReceiveAlgorithmInterface* receive_algorithm) {
     QuicConnectionPeer::SetReceiveAlgorithm(this, receive_algorithm);
   }
 };
@@ skipping 53 matching lines @@
     QuicEncryptedPacket* packet;
   };
 
   QuicHttpStreamTest()
       : net_log_(BoundNetLog()),
         use_closing_stream_(false),
         read_buffer_(new IOBufferWithSize(4096)),
         guid_(2),
         framer_(kQuicVersion1,
                 QuicDecrypter::Create(kNULL),
-                QuicEncrypter::Create(kNULL)),
-        creator_(guid_, &framer_, &random_) {
+                QuicEncrypter::Create(kNULL),
+                false),
+        creator_(guid_, &framer_, &random_, false) {
     IPAddressNumber ip;
     CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
     peer_addr_ = IPEndPoint(ip, 443);
     self_addr_ = IPEndPoint(ip, 8435);
   }
 
   ~QuicHttpStreamTest() {
     for (size_t i = 0; i < writes_.size(); i++) {
       delete writes_[i].packet;
     }
@@ skipping 28 matching lines @@
 
     socket_data_.reset(new StaticSocketDataProvider(NULL, 0, mock_writes_.get(),
                                                     writes_.size()));
 
     MockUDPClientSocket* socket = new MockUDPClientSocket(socket_data_.get(),
                                                           net_log_.net_log());
     socket->Connect(peer_addr_);
     runner_ = new TestTaskRunner(&clock_);
     send_algorithm_ = new MockSendAlgorithm();
     receive_algorithm_ = new TestReceiveAlgorithm(NULL);
-    EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _)).
+    EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).
         WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
     helper_ = new QuicConnectionHelper(runner_.get(), &clock_,
                                        &random_generator_, socket);
     connection_ = new TestQuicConnection(guid_, peer_addr_, helper_);
     connection_->set_visitor(&visitor_);
     connection_->SetSendAlgorithm(send_algorithm_);
     connection_->SetReceiveAlgorithm(receive_algorithm_);
     session_.reset(new QuicClientSession(connection_, helper_, NULL,
                                          "www.google.com", NULL));
-    CryptoHandshakeMessage message =
-        CreateShloMessage(&clock_, &random_generator_, "www.google.com");
+    scoped_ptr<QuicPacket> shlo(ConstructServerHelloPacket(
+        guid_, &clock_, &random_generator_, "www.google.com"));
+    scoped_ptr<QuicEncryptedPacket> shlo_packet(
+        framer_.EncryptPacket(1, *shlo));
     session_->GetCryptoStream()->CryptoConnect();
-    session_->GetCryptoStream()->OnHandshakeMessage(message);
+    ProcessPacket(*shlo_packet);
     EXPECT_TRUE(session_->IsCryptoHandshakeComplete());
     QuicReliableClientStream* stream =
         session_->CreateOutgoingReliableStream();
     stream_.reset(use_closing_stream_ ?
                   new AutoClosingStream(stream) :
                   new QuicHttpStream(stream));
   }
 
   void SetRequestString(const std::string& method, const std::string& path) {
     SpdyHeaderBlock headers;
@@ skipping 17 matching lines @@
     size_t len = SpdyFramer::GetSerializedLength(3, &headers);
     SpdyFrameBuilder builder(len);
     SpdyFramer::WriteHeaderBlock(&builder, 3, &headers);
     scoped_ptr<SpdyFrame> frame(builder.take());
     return std::string(frame->data(), len);
   }
 
   QuicEncryptedPacket* ConstructChloPacket() {
     scoped_ptr<QuicPacket> chlo(
         ConstructClientHelloPacket(guid_, &clock_, &random_generator_,
-                                   "www.google.com"));
+                                   "www.google.com", true));
     return framer_.EncryptPacket(1, *chlo);
   }
 
   // Returns a newly created packet to send kData on stream 1.
   QuicEncryptedPacket* ConstructDataPacket(
       QuicPacketSequenceNumber sequence_number,
       bool fin,
       QuicStreamOffset offset,
       base::StringPiece data) {
     InitializeHeader(sequence_number);
     QuicStreamFrame frame(3, fin, offset, data);
     return ConstructPacket(header_, QuicFrame(&frame));
   }
 
   // Returns a newly created packet to send ack data.
   QuicEncryptedPacket* ConstructAckPacket(
       QuicPacketSequenceNumber sequence_number,
       QuicPacketSequenceNumber largest_received,
       QuicPacketSequenceNumber least_unacked) {
     InitializeHeader(sequence_number);
 
-    QuicAckFrame ack(largest_received, least_unacked);
+    QuicAckFrame ack(largest_received, QuicTime::Zero(), least_unacked);
     ack.sent_info.entropy_hash = 0;
     ack.received_info.entropy_hash = 0;
 
     return ConstructPacket(header_, QuicFrame(&ack));
   }
 
   // Returns a newly created packet to send ack data.
   QuicEncryptedPacket* ConstructRstPacket(
       QuicPacketSequenceNumber sequence_number,
       QuicStreamId stream_id) {
@@ skipping 78 matching lines @@
   AddWrite(SYNCHRONOUS, ConstructChloPacket());
   Initialize();
   EXPECT_FALSE(stream_->IsConnectionReusable());
 }
 
 TEST_F(QuicHttpStreamTest, GetRequest) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructChloPacket());
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2, kFin, 0,
                                             request_data_));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 2));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1));
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, net_log_,
                                           callback_.callback()));
   EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
                                      callback_.callback()));
   EXPECT_EQ(&response_, stream_->GetResponseInfo());
@@ skipping 22 matching lines @@
                                          read_buffer_->size(),
                                          callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicHttpStreamTest, GetRequestFullResponseInSinglePacket) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructChloPacket());
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2, kFin, 0, request_data_));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 2));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1));
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, net_log_,
                                           callback_.callback()));
   EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
                                      callback_.callback()));
   EXPECT_EQ(&response_, stream_->GetResponseInfo());
@@ skipping 25 matching lines @@
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicHttpStreamTest, SendPostRequest) {
   SetRequestString("POST", "/");
   AddWrite(SYNCHRONOUS, ConstructChloPacket());
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2, !kFin, 0, request_data_));
   AddWrite(SYNCHRONOUS, ConstructDataPacket(3, kFin, request_data_.length(),
                                             kUploadData));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(4, 2, 3));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(4, 2, 1));
 
   Initialize();
 
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
       new UploadBytesElementReader(kUploadData, strlen(kUploadData)));
   UploadDataStream upload_data_stream(&element_readers, 0);
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
@@ skipping 39 matching lines @@
 TEST_F(QuicHttpStreamTest, SendChunkedPostRequest) {
   SetRequestString("POST", "/");
   size_t chunk_size = strlen(kUploadData);
   AddWrite(SYNCHRONOUS, ConstructChloPacket());
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2, !kFin, 0, request_data_));
   AddWrite(SYNCHRONOUS, ConstructDataPacket(3, !kFin, request_data_.length(),
                                             kUploadData));
   AddWrite(SYNCHRONOUS, ConstructDataPacket(4, kFin,
                                             request_data_.length() + chunk_size,
                                             kUploadData));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(5, 2, 3));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(5, 2, 1));
 
   Initialize();
 
   UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0);
   upload_data_stream.AppendChunk(kUploadData, chunk_size, false);
 
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
   ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
@@ skipping 35 matching lines @@
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicHttpStreamTest, DestroyedEarly) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructChloPacket());
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2, kFin, 0, request_data_));
   AddWrite(SYNCHRONOUS, ConstructRstPacket(3, 3));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(4, 2, 2));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(4, 2, 1));
   use_closing_stream_ = true;
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, net_log_,
                                          callback_.callback()));
   EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
                                     callback_.callback()));
@@ skipping 13 matching lines @@
 
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(*resp);
 
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 
 }  // namespace net