Remove the --use-spdy-over-quic command line option. Always use SPDY over QUIC.

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 65 matching lines @@
   MockClock clock_;
   QuicCongestionFeedbackFrame* feedback_;
 
   DISALLOW_COPY_AND_ASSIGN(TestReceiveAlgorithm);
 };
 
 // Subclass of QuicHttpStream that closes itself when the first piece of data
 // is received.
 class AutoClosingStream : public QuicHttpStream {
  public:
-  AutoClosingStream(QuicReliableClientStream* stream, bool use_spdy)
-      : QuicHttpStream(stream, use_spdy) {
+  explicit AutoClosingStream(QuicReliableClientStream* stream)
+      : QuicHttpStream(stream) {
   }
 
   virtual int OnDataReceived(const char* data, int length) OVERRIDE {
     Close(false);
     return OK;
   }
 };
 
 }  // namespace
 
@@ skipping 78 matching lines @@
     connection_->SetReceiveAlgorithm(receive_algorithm_);
     session_.reset(new QuicClientSession(connection_, helper_, NULL,
                                          "www.google.com", NULL));
     CryptoHandshakeMessage message;
     message.tag = kSHLO;
     session_->GetCryptoStream()->OnHandshakeMessage(message);
     EXPECT_TRUE(session_->IsCryptoHandshakeComplete());
     QuicReliableClientStream* stream =
         session_->CreateOutgoingReliableStream();
     stream_.reset(use_closing_stream_ ?
-                  new AutoClosingStream(stream, GetParam()) :
-                  new QuicHttpStream(stream, GetParam()));
+                  new AutoClosingStream(stream) :
+                  new QuicHttpStream(stream));
   }
 
   void SetRequestString(const std::string& method, const std::string& path) {
-    if (GetParam() == true) {
-      SpdyHeaderBlock headers;
-      headers[":method"] = method;
-      headers[":host"] = "www.google.com";
-      headers[":path"] = path;
-      headers[":scheme"] = "http";
-      headers[":version"] = "HTTP/1.1";
-      request_data_ = SerializeHeaderBlock(headers);
-    } else {
-      request_data_ = method + " " + path + " HTTP/1.1\r\n\r\n";
-    }
+    SpdyHeaderBlock headers;
+    headers[":method"] = method;
+    headers[":host"] = "www.google.com";
+    headers[":path"] = path;
+    headers[":scheme"] = "http";
+    headers[":version"] = "HTTP/1.1";
+    request_data_ = SerializeHeaderBlock(headers);
   }
 
   void SetResponseString(const std::string& status, const std::string& body) {
-    if (GetParam() == true) {
-      SpdyHeaderBlock headers;
-      headers[":status"] = status;
-      headers[":version"] = "HTTP/1.1";
-      headers["content-type"] = "text/plain";
-      response_data_ = SerializeHeaderBlock(headers) + body;
-    } else {
-      response_data_ = "HTTP/1.1 " + status + " \r\n"
-          "Content-Type: text/plain\r\n\r\n" + body;
-    }
+    SpdyHeaderBlock headers;
+    headers[":status"] = status;
+    headers[":version"] = "HTTP/1.1";
+    headers["content-type"] = "text/plain";
+    response_data_ = SerializeHeaderBlock(headers) + body;
   }
 
   std::string SerializeHeaderBlock(const SpdyHeaderBlock& headers) {
     size_t len = SpdyFramer::GetSerializedLength(3, &headers);
     SpdyFrameBuilder builder(len);
     SpdyFramer::WriteHeaderBlock(&builder, 3, &headers);
     scoped_ptr<SpdyFrame> frame(builder.take());
     return std::string(frame->data(), len);
   }
 
@@ skipping 78 matching lines @@
   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));
-
-TEST_P(QuicHttpStreamTest, RenewStreamForAuth) {
+TEST_F(QuicHttpStreamTest, RenewStreamForAuth) {
   EXPECT_EQ(NULL, stream_->RenewStreamForAuth());
 }
 
-TEST_P(QuicHttpStreamTest, CanFindEndOfResponse) {
+TEST_F(QuicHttpStreamTest, CanFindEndOfResponse) {
   EXPECT_TRUE(stream_->CanFindEndOfResponse());
 }
 
-TEST_P(QuicHttpStreamTest, IsMoreDataBuffered) {
+TEST_F(QuicHttpStreamTest, IsMoreDataBuffered) {
   EXPECT_FALSE(stream_->IsMoreDataBuffered());
 }
 
-TEST_P(QuicHttpStreamTest, IsConnectionReusable) {
+TEST_F(QuicHttpStreamTest, IsConnectionReusable) {
   EXPECT_FALSE(stream_->IsConnectionReusable());
 }
 
-TEST_P(QuicHttpStreamTest, GetRequest) {
+TEST_F(QuicHttpStreamTest, GetRequest) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, kFin, 0,
                                             request_data_));
   AddWrite(SYNCHRONOUS, ConstructAckPacket(2, 2, 2));
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, net_log_,
@@ 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) {
+TEST_F(QuicHttpStreamTest, GetRequestFullResponseInSinglePacket) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, kFin, 0, request_data_));
   AddWrite(SYNCHRONOUS, ConstructAckPacket(2, 2, 2));
   Initialize();
 
   request_.method = "GET";
   request_.url = GURL("http://www.google.com/");
 
   EXPECT_EQ(OK, stream_->InitializeStream(&request_, net_log_,
                                           callback_.callback()));
@@ skipping 22 matching lines @@
 
   // 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) {
+TEST_F(QuicHttpStreamTest, SendPostRequest) {
   SetRequestString("POST", "/");
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, !kFin, 0, request_data_));
   AddWrite(SYNCHRONOUS, ConstructDataPacket(2, kFin, request_data_.length(),
                                             kUploadData));
   AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 3));
 
   Initialize();
 
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
@@ skipping 34 matching lines @@
 
   // 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, DestroyedEarly) {
+TEST_F(QuicHttpStreamTest, DestroyedEarly) {
   SetRequestString("GET", "/");
   AddWrite(SYNCHRONOUS, ConstructDataPacket(1, kFin, 0, request_data_));
   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/");
 
@@ skipping 17 matching lines @@
 
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(*resp);
 
   EXPECT_TRUE(AtEof());
 }
 
 }  // namespace test
 
 }  // namespace net