Fix a QUIC bug where previously undecryptable packets were not decrypted

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 245 matching lines @@
     return maker_.MakeResponseHeadersPacket(
         sequence_number, stream_id_, !kIncludeVersion, fin, response_headers_);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstStreamPacket(
       QuicPacketSequenceNumber sequence_number) {
     return maker_.MakeRstPacket(
         sequence_number, !kIncludeVersion, stream_id_, QUIC_STREAM_CANCELLED);
   }
 
+  scoped_ptr<QuicEncryptedPacket> ConstructAckAndRstStreamPacket(
+      QuicPacketSequenceNumber sequence_number,

[Ryan Hamilton, 2014/01/29 00:52:52]

nit: Since the final 2 args are always 1, I'd remove them from this method so it
only takes sequence_number.  If we ever need to use different values, we can add
them back.

[ramant (doing other things), 2014/01/29 02:45:38]

Done.

+      QuicPacketSequenceNumber largest_received,
+      QuicPacketSequenceNumber least_unacked) {
+    return maker_.MakeAckAndRstPacket(
+        sequence_number, !kIncludeVersion, stream_id_, QUIC_STREAM_CANCELLED,
+        largest_received, least_unacked, !kIncludeCongestionFeedback);
+  }
+
   scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
       QuicPacketSequenceNumber sequence_number,
       QuicPacketSequenceNumber largest_received,
       QuicPacketSequenceNumber least_unacked) {
     return maker_.MakeAckPacket(sequence_number, largest_received,
                                 least_unacked, !kIncludeCongestionFeedback);
   }
 
   BoundNetLog net_log_;
   bool use_closing_stream_;
@@ skipping 328 matching lines @@
   EXPECT_TRUE(AtEof());
 }
 
 TEST_P(QuicHttpStreamTest, DestroyedEarly) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
   if (GetParam() > QUIC_VERSION_12) {
     AddWrite(ConstructRequestHeadersPacket(1, kFin));
   } else {
     AddWrite(ConstructDataPacket(1, kIncludeVersion, kFin, 0, request_data_));
   }
-  AddWrite(ConstructRstStreamPacket(2));
+  AddWrite(ConstructAckAndRstStreamPacket(2, 1, 1));
   use_closing_stream_ = true;
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   EXPECT_EQ(OK, stream_->SendRequest(headers_, &response_,
                                      callback_.callback()));
@@ skipping 16 matching lines @@
   EXPECT_TRUE(AtEof());
 }
 
 TEST_P(QuicHttpStreamTest, Priority) {
   SetRequest("GET", "/", MEDIUM);
   if (GetParam() > QUIC_VERSION_12) {
     AddWrite(ConstructRequestHeadersPacket(1, kFin));
   } else {
     AddWrite(ConstructDataPacket(1, kIncludeVersion, kFin, 0, request_data_));
   }
-  AddWrite(ConstructRstStreamPacket(2));
+  AddWrite(ConstructAckAndRstStreamPacket(2, 1, 1));
   use_closing_stream_ = true;
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM,
                                           net_log_, callback_.callback()));
 
   // Check that priority is highest.
@@ skipping 88 matching lines @@
       WillRepeatedly(Return(QuicTime::Delta::Zero()));
 
   // Data should flush out now.
   connection_->OnCanWrite();
   EXPECT_FALSE(reliable_stream->HasBufferedData());
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 }  // namespace net