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 593 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));
+  // TODO(rtenneti): Looks like the following is not needed.
+  // AddWrite(ConstructRstStreamPacket(2));

[Ryan Hamilton, 2014/01/27 19:08:02]

Do you understand why the RST_STREAM packet is not sent?

[ramant (doing other things), 2014/01/29 00:40:19]

Thanks for your help. Undid this change. Replaced it with sending ACK and RST
frames in one packet.

   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()));
   EXPECT_EQ(&response_, stream_->GetResponseInfo());
 
   // Ack the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
   EXPECT_EQ(ERR_IO_PENDING,
             stream_->ReadResponseHeaders(callback_.callback()));
 
   // Send the response with a body.
   SetResponse("404 OK", "hello world!");
+  ProcessPacket(ConstructAckPacket(2, 0, 0));
   // In the course of processing this packet, the QuicHttpStream close itself.
   if (GetParam() > QUIC_VERSION_12) {
     ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
   } else {
     ProcessPacket(ConstructDataPacket(2, false, kFin, 0, response_data_));
   }
 
   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));
+  // TODO(rtenneti): Looks like the following is not needed.
+  // AddWrite(ConstructRstStreamPacket(2));
   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 11 matching lines @@
   DCHECK_EQ(MEDIUM, ConvertQuicPriorityToRequestPriority(
       reliable_stream->EffectivePriority()));
 
   // Ack the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
   EXPECT_EQ(ERR_IO_PENDING,
             stream_->ReadResponseHeaders(callback_.callback()));
 
   // Send the response with a body.
   SetResponse("404 OK", "hello world!");
+  ProcessPacket(ConstructAckPacket(2, 0, 0));
   // In the course of processing this packet, the QuicHttpStream close itself.
   if (GetParam() > QUIC_VERSION_12) {
     ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
   } else {
     ProcessPacket(ConstructDataPacket(2, !kIncludeVersion, kFin, 0,
                                       response_data_));
   }
 
   EXPECT_TRUE(AtEof());
 }
@@ skipping 57 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