Killing off QUICv12, including cleaning out all of the code for handling

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 108 matching lines @@
     }
     IoMode mode;
     QuicEncryptedPacket* packet;
   };
 
   QuicHttpStreamTest()
       : net_log_(BoundNetLog()),
         use_closing_stream_(false),
         read_buffer_(new IOBufferWithSize(4096)),
         connection_id_(2),
-        stream_id_(GetParam() > QUIC_VERSION_12 ? 5 : 3),
+        stream_id_(5),
         maker_(GetParam(), connection_id_),
         random_generator_(0) {
     IPAddressNumber ip;
     CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
     peer_addr_ = IPEndPoint(ip, 443);
     self_addr_ = IPEndPoint(ip, 8435);
   }
 
   ~QuicHttpStreamTest() {
     session_->CloseSessionOnError(ERR_ABORTED);
@@ skipping 72 matching lines @@
     EXPECT_TRUE(session_->IsCryptoHandshakeConfirmed());
     stream_.reset(use_closing_stream_ ?
                   new AutoClosingStream(session_->GetWeakPtr()) :
                   new QuicHttpStream(session_->GetWeakPtr()));
   }
 
   void SetRequest(const std::string& method,
                   const std::string& path,
                   RequestPriority priority) {
     request_headers_ = maker_.GetRequestHeaders(method, "http", path);
-    request_data_ = GetParam() > QUIC_VERSION_12 ? "" :
-        SerializeHeaderBlock(request_headers_, true, priority);
   }
 
   void SetResponse(const std::string& status, const std::string& body) {
     response_headers_ = maker_.GetResponseHeaders(status);
-    if (GetParam() > QUIC_VERSION_12) {
-      response_data_ = body;
-    } else {
-      response_data_ =
-          SerializeHeaderBlock(response_headers_, false, DEFAULT_PRIORITY) +
-          body;
-    }
+    response_data_ = body;
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructDataPacket(
       QuicPacketSequenceNumber sequence_number,
       bool should_include_version,
       bool fin,
       QuicStreamOffset offset,
       base::StringPiece data) {
     return maker_.MakeDataPacket(
         sequence_number, stream_id_, should_include_version, fin, offset, data);
@@ skipping 52 matching lines @@
   HttpRequestInfo request_;
   HttpRequestHeaders headers_;
   HttpResponseInfo response_;
   scoped_refptr<IOBufferWithSize> read_buffer_;
   SpdyHeaderBlock request_headers_;
   SpdyHeaderBlock response_headers_;
   std::string request_data_;
   std::string response_data_;
 
  private:
-  std::string SerializeHeaderBlock(const SpdyHeaderBlock& headers,
-                                   bool write_priority,
-                                   RequestPriority priority) {
-    QuicSpdyCompressor compressor;
-    if (write_priority) {
-      return compressor.CompressHeadersWithPriority(
-          ConvertRequestPriorityToQuicPriority(priority), headers);
-    }
-    return compressor.CompressHeaders(headers);
-  }
-
   const QuicConnectionId connection_id_;
   const QuicStreamId stream_id_;
   QuicTestPacketMaker maker_;
   IPEndPoint self_addr_;
   IPEndPoint peer_addr_;
   MockRandom random_generator_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   scoped_ptr<StaticSocketDataProvider> socket_data_;
   std::vector<PacketToWrite> writes_;
 };
@@ skipping 11 matching lines @@
   EXPECT_TRUE(stream_->CanFindEndOfResponse());
 }
 
 TEST_P(QuicHttpStreamTest, IsConnectionReusable) {
   Initialize();
   EXPECT_FALSE(stream_->IsConnectionReusable());
 }
 
 TEST_P(QuicHttpStreamTest, GetRequest) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
-  if (GetParam() > QUIC_VERSION_12) {
-    AddWrite(ConstructRequestHeadersPacket(1, kFin));
-  } else {
-    AddWrite(ConstructDataPacket(1, kIncludeVersion, kFin, 0, request_data_));
-  }
+  AddWrite(ConstructRequestHeadersPacket(1, kFin));
   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()));
 
   SetResponse("404 Not Found", std::string());
-  if (GetParam() > QUIC_VERSION_12) {
-    ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
-  } else {
-    ProcessPacket(ConstructDataPacket(2, false, kFin, 0, response_data_));
-  }
+  ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
 
   // Now that the headers have been processed, the callback will return.
   EXPECT_EQ(OK, callback_.WaitForResult());
   ASSERT_TRUE(response_.headers.get());
   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());
 }
 
 // Regression test for http://crbug.com/288128
 TEST_P(QuicHttpStreamTest, GetRequestLargeResponse) {
   SetRequest("GET", "/", DEFAULT_PRIORITY);
-  if (GetParam() > QUIC_VERSION_12) {
-    AddWrite(ConstructRequestHeadersPacket(1, kFin));
-  } else {
-    AddWrite(ConstructDataPacket(1, kIncludeVersion, kFin, 0, request_data_));
-  }
+  AddWrite(ConstructRequestHeadersPacket(1, kFin));
   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());
@@ skipping 22 matching lines @@
   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());
 }
 
-TEST_P(QuicHttpStreamTest, GetRequestFullResponseInSinglePacket) {
-  SetRequest("GET", "/", DEFAULT_PRIORITY);
-  AddWrite(ConstructDataPacket(1, kIncludeVersion, kFin, 0, request_data_));
-  Initialize();
-
-  if (GetParam() > QUIC_VERSION_12) {
-    // we can't put the request and response into a single frame.
-    return;
-  }
-
-  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("200 OK", "hello world!");
-  ProcessPacket(ConstructDataPacket(2, false, kFin, 0, response_data_));
-
-  // Now that the headers have been processed, the callback will return.
-  EXPECT_EQ(OK, callback_.WaitForResult());
-  ASSERT_TRUE(response_.headers.get());
-  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());
-}
-
 TEST_P(QuicHttpStreamTest, SendPostRequest) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
-  if (GetParam() > QUIC_VERSION_12) {
-    AddWrite(ConstructRequestHeadersPacket(1, !kFin));
-    AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, kUploadData));
-  } else {
-    AddWrite(ConstructDataPacket(1, kIncludeVersion, !kFin, 0, request_data_));
-    AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin,
-                                 request_data_.length(), kUploadData));
-  }
+  AddWrite(ConstructRequestHeadersPacket(1, !kFin));
+  AddWrite(ConstructDataPacket(2, kIncludeVersion, kFin, 0, kUploadData));
   AddWrite(ConstructAckPacket(3, 3, 1));
 
   Initialize();
 
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
       new UploadBytesElementReader(kUploadData, strlen(kUploadData)));
   UploadDataStream upload_data_stream(element_readers.Pass(), 0);
   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()));
 
   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 both packets in the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", std::string());
-  if (GetParam() > QUIC_VERSION_12) {
-    ProcessPacket(ConstructResponseHeadersPacket(2, !kFin));
-  } else {
-    ProcessPacket(ConstructDataPacket(2, false, !kFin, 0, response_data_));
-  }
+  ProcessPacket(ConstructResponseHeadersPacket(2, !kFin));
 
   // Since the headers have already arrived, this should return immediately.
   EXPECT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback()));
   ASSERT_TRUE(response_.headers.get());
   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!";
-  if (GetParam() > QUIC_VERSION_12) {
-    ProcessPacket(ConstructDataPacket(3, false, kFin, 0, kResponseBody));
-  } else {
-    ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(),
-                                      kResponseBody));
-  }
+  ProcessPacket(ConstructDataPacket(3, false, kFin, 0, kResponseBody));
   // Since the body has already arrived, this should return immediately.
   EXPECT_EQ(static_cast<int>(strlen(kResponseBody)),
             stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(),
                                       callback_.callback()));
 
   EXPECT_TRUE(stream_->IsResponseBodyComplete());
   EXPECT_TRUE(AtEof());
 }
 
 TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t chunk_size = strlen(kUploadData);
-  if (GetParam() > QUIC_VERSION_12) {
-    AddWrite(ConstructRequestHeadersPacket(1, !kFin));
-    AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData));
-    AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size,
-                                 kUploadData));
-  } else {
-    AddWrite(ConstructDataPacket(1, kIncludeVersion, !kFin, 0, request_data_));
-    AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin,
-                                 request_data_.length(), kUploadData));
-    AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin,
-                                 request_data_.length() + chunk_size,
-                                 kUploadData));
-  }
+  AddWrite(ConstructRequestHeadersPacket(1, !kFin));
+  AddWrite(ConstructDataPacket(2, kIncludeVersion, !kFin, 0, kUploadData));
+  AddWrite(ConstructDataPacket(3, kIncludeVersion, kFin, chunk_size,
+                               kUploadData));
   AddWrite(ConstructAckPacket(4, 3, 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()));
 
   ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
                                                  callback_.callback()));
   EXPECT_EQ(&response_, stream_->GetResponseInfo());
 
   upload_data_stream.AppendChunk(kUploadData, chunk_size, true);
 
   // Ack both packets in the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", std::string());
-  if (GetParam() > QUIC_VERSION_12) {
-    ProcessPacket(ConstructResponseHeadersPacket(2, !kFin));
-  } else {
-    ProcessPacket(ConstructDataPacket(2, false, !kFin, 0, response_data_));
-  }
+  ProcessPacket(ConstructResponseHeadersPacket(2, !kFin));
 
   // Since the headers have already arrived, this should return immediately.
   ASSERT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback()));
   ASSERT_TRUE(response_.headers.get());
   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!";
   ProcessPacket(ConstructDataPacket(3, false, kFin, response_data_.length(),
                                     kResponseBody));
 
   // 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_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(ConstructRequestHeadersPacket(1, kFin));
   AddWrite(ConstructAckAndRstStreamPacket(2));
   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!");
   // 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_));
-  }
+  ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
 
   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(ConstructRequestHeadersPacket(1, kFin));
   AddWrite(ConstructAckAndRstStreamPacket(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()));
 
@@ skipping 13 matching lines @@
       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!");
   // 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_));
-  }
+  ProcessPacket(ConstructResponseHeadersPacket(2, kFin));
 
   EXPECT_TRUE(AtEof());
 }
 
 // Regression test for http://crbug.com/294870
 TEST_P(QuicHttpStreamTest, CheckPriorityWithNoDelegate) {
   SetRequest("GET", "/", MEDIUM);
   use_closing_stream_ = true;
 
   if (GetParam() > QUIC_VERSION_13) {
@@ skipping 18 matching lines @@
             reliable_stream->EffectivePriority());
 
   // Set Delegate to NULL and make sure EffectivePriority returns highest
   // priority.
   reliable_stream->SetDelegate(NULL);
   DCHECK_EQ(QuicWriteBlockedList::kHighestPriority,
             reliable_stream->EffectivePriority());
   reliable_stream->SetDelegate(delegate);
 }
 
-TEST_P(QuicHttpStreamTest, DontCompressHeadersWhenNotWritable) {
-  SetRequest("GET", "/", MEDIUM);
-  AddWrite(ConstructDataPacket(1, kIncludeVersion, kFin, 0, request_data_));
-  Initialize();
-
-  if (GetParam() > QUIC_VERSION_12) {
-    // The behavior tested here is obsolete.
-    return;
-  }
-  request_.method = "GET";
-  request_.url = GURL("http://www.google.com/");
-
-  EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _, _)).
-      WillRepeatedly(Return(QuicTime::Delta::Infinite()));
-  EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM,
-                                          net_log_, callback_.callback()));
-  EXPECT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
-                                                 callback_.callback()));
-
-  // Verify that the headers have not been compressed and buffered in
-  // the stream.
-  QuicReliableClientStream* reliable_stream =
-      QuicHttpStreamPeer::GetQuicReliableClientStream(stream_.get());
-  EXPECT_FALSE(reliable_stream->HasBufferedData());
-  EXPECT_FALSE(AtEof());
-
-  EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _, _)).
-      WillRepeatedly(Return(QuicTime::Delta::Zero()));
-
-  // Data should flush out now.
-  connection_->OnCanWrite();
-  EXPECT_FALSE(reliable_stream->HasBufferedData());
-  EXPECT_TRUE(AtEof());
-}
-
 }  // namespace test
 }  // namespace net