Remove SPDY/3.1 tests.

net/spdy/spdy_stream_unittest.cc

 // Copyright 2013 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/spdy/spdy_stream.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <limits>
@@ skipping 27 matching lines @@
 
 // TODO(ukai): factor out common part with spdy_http_stream_unittest.cc
 //
 namespace net {
 
 namespace test {
 
 namespace {
 
 enum TestCase {
-  // Test using the SPDY/3.1 protocol.
-  kTestCaseSPDY31,
+  // Test without specifying a stream dependency based on the RequestPriority.
+  kTestCaseNoPriorityDependencies,
 
-  // Test using the HTTP/2 protocol, without specifying a stream
-  // dependency based on the RequestPriority.
-  kTestCaseHTTP2NoPriorityDependencies,
-
-  // Test using the HTTP/2 protocol, specifying a stream
-  // dependency based on the RequestPriority.
-  kTestCaseHTTP2PriorityDependencies
+  // Test specifying a stream dependency based on the RequestPriority.
+  kTestCasePriorityDependencies
 };
 
 const char kStreamUrl[] = "http://www.example.org/";
 const char kPostBody[] = "\0hello!\xff";
 const size_t kPostBodyLength = arraysize(kPostBody);
 const base::StringPiece kPostBodyStringPiece(kPostBody, kPostBodyLength);
 
 }  // namespace
 
 class SpdyStreamTest : public ::testing::Test,
                        public ::testing::WithParamInterface<TestCase> {
  protected:
   // A function that takes a SpdyStream and the number of bytes which
   // will unstall the next frame completely.
   typedef base::Callback<void(const base::WeakPtr<SpdyStream>&, int32_t)>
       UnstallFunction;
 
-  SpdyStreamTest()
-      : spdy_util_(GetProtocol(), GetDependenciesFromPriority()),
-        session_deps_(GetProtocol()),
-        offset_(0) {
+  SpdyStreamTest() : spdy_util_(GetDependenciesFromPriority()), offset_(0) {
     spdy_util_.set_default_url(GURL(kStreamUrl));
     session_deps_.enable_priority_dependencies = GetDependenciesFromPriority();
     session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
   }
 
   ~SpdyStreamTest() {
   }
 
   base::WeakPtr<SpdySession> CreateDefaultSpdySession() {
     SpdySessionKey key(HostPortPair("www.example.org", 80),
                        ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
     return CreateInsecureSpdySession(session_.get(), key, BoundNetLog());
   }
 
   void TearDown() override { base::RunLoop().RunUntilIdle(); }
 
-  NextProto GetProtocol() const {
-    return GetParam() == kTestCaseSPDY31 ? kProtoSPDY31 : kProtoHTTP2;
-  }
-
   bool GetDependenciesFromPriority() const {
-    return GetParam() == kTestCaseHTTP2PriorityDependencies;
+    return GetParam() == kTestCasePriorityDependencies;
   }
 
   void RunResumeAfterUnstallRequestResponseTest(
       const UnstallFunction& unstall_function);
 
   void RunResumeAfterUnstallBidirectionalTest(
       const UnstallFunction& unstall_function);
 
   // Add{Read,Write}() populates lists that are eventually passed to a
   // SocketData class. |frame| must live for the whole test.
@@ skipping 43 matching lines @@
 
  private:
   // Used by Add{Read,Write}() above.
   std::vector<MockWrite> writes_;
   std::vector<MockRead> reads_;
   int offset_;
 };
 
 INSTANTIATE_TEST_CASE_P(ProtoPlusDepend,
                         SpdyStreamTest,
-                        testing::Values(kTestCaseSPDY31,
-                                        kTestCaseHTTP2NoPriorityDependencies,
-                                        kTestCaseHTTP2PriorityDependencies));
+                        testing::Values(kTestCaseNoPriorityDependencies,
+                                        kTestCasePriorityDependencies));
 
 TEST_P(SpdyStreamTest, SendDataAfterOpen) {
   GURL url(kStreamUrl);
 
   std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
       kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
   AddWrite(*req);
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
@@ skipping 155 matching lines @@
   // Set required request headers.
   SpdyHeaderBlock request_headers;
   spdy_util_.AddUrlToHeaderBlock(kStreamUrl, &request_headers);
   stream->OnPushPromiseHeadersReceived(request_headers);
 
   base::Time response_time = base::Time::Now();
   base::TimeTicks first_byte_time = base::TimeTicks::Now();
   // Send some basic response headers.
   SpdyHeaderBlock response;
   response[spdy_util_.GetStatusKey()] = "200";
-  response[spdy_util_.GetVersionKey()] = "OK";
   stream->OnInitialResponseHeadersReceived(response, response_time,
                                            first_byte_time);
 
   // And some more headers.
   // TODO(baranovich): not valid for HTTP 2.
   SpdyHeaderBlock headers;
   headers["alpha"] = "beta";
   stream->OnAdditionalResponseHeadersReceived(headers);
 
   EXPECT_TRUE(stream->HasUrlFromHeaders());
@@ skipping 774 matching lines @@
 
   std::unique_ptr<SpdyHeaderBlock> headers(
       new SpdyHeaderBlock(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)));
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers),
                                                        NO_MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrlFromHeaders());
   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 
   int64_t reply_frame_len = reply->size();
   int64_t data_header_len = SpdyConstants::GetDataFrameMinimumSize(
-      NextProtoToSpdyMajorVersion(GetProtocol()));
+      NextProtoToSpdyMajorVersion(kProtoHTTP2));
   int64_t data_frame_len = data_header_len + kPostBodyLength;
   int64_t response_len = reply_frame_len + data_frame_len;
 
   EXPECT_EQ(0, stream->raw_received_bytes());
 
   // SYN
   data.RunUntilPaused();
   EXPECT_EQ(0, stream->raw_received_bytes());
 
   // REPLY
   data.Resume();
   data.RunUntilPaused();
   EXPECT_EQ(reply_frame_len, stream->raw_received_bytes());
 
   // DATA
   data.Resume();
   data.RunUntilPaused();
   EXPECT_EQ(response_len, stream->raw_received_bytes());
 
   // FIN
   data.Resume();
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 }
 
 }  // namespace test
 
 }  // namespace net