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 333 matching lines @@
             stream_->ReadResponseHeaders(callback_.callback()));
 
   // Send the response without a body.
   SetResponseString("404 Not Found", std::string());
   scoped_ptr<QuicEncryptedPacket> resp(
       ConstructDataPacket(2, false, kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Now that the headers have been processed, the callback will return.
   EXPECT_EQ(OK, callback_.WaitForResult());
-  ASSERT_TRUE(response_.headers.get() != NULL);
+  ASSERT_TRUE(response_.headers);
   EXPECT_EQ(404, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // There is no body, so this should return immediately.
   EXPECT_EQ(0, stream_->ReadResponseBody(read_buffer_.get(),
                                          read_buffer_->size(),
                                          callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
@@ skipping 21 matching lines @@
             stream_->ReadResponseHeaders(callback_.callback()));
 
   // Send the response with a body.
   SetResponseString("200 OK", "hello world!");
   scoped_ptr<QuicEncryptedPacket> resp(
       ConstructDataPacket(2, false, kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Now that the headers have been processed, the callback will return.
   EXPECT_EQ(OK, callback_.WaitForResult());
-  ASSERT_TRUE(response_.headers.get() != NULL);
+  ASSERT_TRUE(response_.headers);
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // There is no body, so this should return immediately.
   // Since the body has already arrived, this should return immediately.
   EXPECT_EQ(12, stream_->ReadResponseBody(read_buffer_.get(),
                                           read_buffer_->size(),
                                           callback_.callback()));
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
@@ skipping 29 matching lines @@
   ProcessPacket(*ack);
 
   // Send the response headers (but not the body).
   SetResponseString("200 OK", std::string());
   scoped_ptr<QuicEncryptedPacket> resp(
       ConstructDataPacket(2, false, !kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Since the headers have already arrived, this should return immediately.
   EXPECT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback()));
-  ASSERT_TRUE(response_.headers.get() != NULL);
+  ASSERT_TRUE(response_.headers);
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   scoped_ptr<QuicEncryptedPacket> resp_body(
       ConstructDataPacket(3, false, kFin, response_data_.length(),
                           kResponseBody));
   ProcessPacket(*resp_body);
 
@@ skipping 41 matching lines @@
   ProcessPacket(*ack);
 
   // Send the response headers (but not the body).
   SetResponseString("200 OK", std::string());
   scoped_ptr<QuicEncryptedPacket> resp(
       ConstructDataPacket(2, false, !kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Since the headers have already arrived, this should return immediately.
   ASSERT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback()));
-  ASSERT_TRUE(response_.headers.get() != NULL);
+  ASSERT_TRUE(response_.headers);
   EXPECT_EQ(200, response_.headers->response_code());
   EXPECT_TRUE(response_.headers->HasHeaderValue("Content-Type", "text/plain"));
 
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   scoped_ptr<QuicEncryptedPacket> resp_body(
       ConstructDataPacket(3, false, kFin, response_data_.length(),
                           kResponseBody));
   ProcessPacket(*resp_body);
 
   // Since the body has already arrived, this should return immediately.
   ASSERT_EQ(static_cast<int>(strlen(kResponseBody)),
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_F(QuicHttpStreamTest, DestroyedEarly) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, kFin, 0, request_data_));
-  AddWrite(SYNCHRONOUS, ConstructRstPacket(2, 3));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(2, 2, 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 12 matching lines @@
 
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(*resp);
 
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 
 }  // namespace net