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"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/quic/congestion_control/receive_algorithm_interface.h"
 #include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/quic_client_session.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_connection_helper.h"
 #include "net/quic/test_tools/mock_clock.h"
+#include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/test_task_runner.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_protocol.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 77 matching lines @@
     IoMode mode;
     QuicEncryptedPacket* packet;
   };
 
   QuicHttpStreamTest()
       : net_log_(BoundNetLog()),
         use_closing_stream_(false),
         read_buffer_(new IOBufferWithSize(4096)),
         guid_(2),
         framer_(QuicDecrypter::Create(kNULL), QuicEncrypter::Create(kNULL)),
-        creator_(guid_, &framer_) {
+        creator_(guid_, &framer_, &random_) {
     IPAddressNumber ip;
     CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
     peer_addr_ = IPEndPoint(ip, 443);
     self_addr_ = IPEndPoint(ip, 8435);
     // Do null initialization for simple tests.
     Initialize();
   }
 
   ~QuicHttpStreamTest() {
     for (size_t i = 0; i < writes_.size(); i++) {
@@ skipping 30 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;
@@ skipping 54 matching lines @@
   }
 
   // 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);
+    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,
-      QuicStreamOffset offset) {
+      QuicStreamId stream_id) {
     InitializeHeader(sequence_number);
 
-    QuicRstStreamFrame rst(stream_id, offset, QUIC_NO_ERROR);
+    QuicRstStreamFrame rst(stream_id, QUIC_NO_ERROR);
     return ConstructPacket(header_, QuicFrame(&rst));
   }
 
   BoundNetLog net_log_;
   bool use_closing_stream_;
   MockSendAlgorithm* send_algorithm_;
   TestReceiveAlgorithm* receive_algorithm_;
   scoped_refptr<TestTaskRunner> runner_;
   scoped_array<MockWrite> mock_writes_;
   MockClock clock_;
   MockRandom random_generator_;
   TestQuicConnection* connection_;
   QuicConnectionHelper* helper_;
   testing::StrictMock<MockConnectionVisitor> visitor_;
   scoped_ptr<QuicHttpStream> stream_;
   scoped_ptr<QuicClientSession> session_;
   TestCompletionCallback callback_;
   HttpRequestInfo request_;
   HttpRequestHeaders headers_;
   HttpResponseInfo response_;
   scoped_refptr<IOBufferWithSize> read_buffer_;
   std::string request_data_;
   std::string response_data_;
 
  private:
   void InitializeHeader(QuicPacketSequenceNumber sequence_number) {
     header_.public_header.guid = guid_;
-    header_.public_header.flags = PACKET_PUBLIC_FLAGS_NONE;
+    header_.public_header.reset_flag = false;
+    header_.public_header.version_flag = false;
     header_.packet_sequence_number = sequence_number;
     header_.fec_group = 0;
-    header_.private_flags = PACKET_PRIVATE_FLAGS_NONE;
+    header_.fec_entropy_flag = false;
+    header_.entropy_flag = false;
+    header_.fec_flag = false;
   }
 
   QuicEncryptedPacket* ConstructPacket(const QuicPacketHeader& header,
                                        const QuicFrame& frame) {
     QuicFrames frames;
     frames.push_back(frame);
     scoped_ptr<QuicPacket> packet(
-        framer_.ConstructFrameDataPacket(header_, frames));
-    return framer_.EncryptPacket(*packet);
+        framer_.ConstructFrameDataPacket(header_, frames).packet);
+    return framer_.EncryptPacket(header.packet_sequence_number, *packet);
   }
 
   const QuicGuid guid_;
   QuicFramer framer_;
   IPEndPoint self_addr_;
   IPEndPoint peer_addr_;
+  MockRandom random_;
   QuicPacketCreator creator_;
   QuicPacketHeader header_;
   scoped_ptr<StaticSocketDataProvider> socket_data_;
   std::vector<PacketToWrite> writes_;
 };
 
 // All tests are run with two different serializations, HTTP/SPDY
 INSTANTIATE_TEST_CASE_P(QuicHttpStreamTests,
                         QuicHttpStreamTest,
                         ::testing::Values(true, false));
@@ skipping 151 matching lines @@
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_P(QuicHttpStreamTest, DestroyedEarly) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, kFin, 0, request_data_));
-  AddWrite(SYNCHRONOUS, ConstructRstPacket(2, 3, request_data_.length()));
+  AddWrite(SYNCHRONOUS, ConstructRstPacket(2, 3));
   AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 2));
   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_,
@@ skipping 14 matching lines @@
 
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(*resp);
 
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 
 }  // namespace net