Remove SPDY/3.1 tests.

net/spdy/spdy_proxy_client_socket_unittest.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/spdy/spdy_proxy_client_socket.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 25 matching lines @@
 #include "testing/platform_test.h"
 
 using net::test::IsError;
 using net::test::IsOk;
 
 //-----------------------------------------------------------------------------
 
 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
 };
 
 static const char kRequestUrl[] = "https://www.google.com/";
 static const char kOriginHost[] = "www.google.com";
 static const int kOriginPort = 443;
 static const char kOriginHostPort[] = "www.google.com:443";
 static const char kProxyUrl[] = "https://myproxy:6121/";
 static const char kProxyHost[] = "myproxy";
 static const int kProxyPort = 6121;
 static const char kUserAgent[] = "Mozilla/1.0";
@@ skipping 19 matching lines @@
 
 class SpdyProxyClientSocketTest : public PlatformTest,
                                   public testing::WithParamInterface<TestCase> {
  public:
   SpdyProxyClientSocketTest();
   ~SpdyProxyClientSocketTest();
 
   void TearDown() override;
 
  protected:
-  NextProto GetProtocol() const;
   bool GetDependenciesFromPriority() const;
 
   void Initialize(MockRead* reads, size_t reads_count, MockWrite* writes,
                   size_t writes_count);
   void PopulateConnectRequestIR(SpdyHeaderBlock* syn_ir);
   void PopulateConnectReplyIR(SpdyHeaderBlock* block, const char* status);
   SpdySerializedFrame* ConstructConnectRequestFrame();
   SpdySerializedFrame* ConstructConnectAuthRequestFrame();
   SpdySerializedFrame* ConstructConnectReplyFrame();
   SpdySerializedFrame* ConstructConnectAuthReplyFrame();
@@ skipping 54 matching lines @@
   HostPortPair proxy_host_port_;
   HostPortPair endpoint_host_port_pair_;
   ProxyServer proxy_;
   SpdySessionKey endpoint_spdy_session_key_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketTest);
 };
 
 INSTANTIATE_TEST_CASE_P(ProtoPlusDepend,
                         SpdyProxyClientSocketTest,
-                        testing::Values(kTestCaseSPDY31,
-                                        kTestCaseHTTP2NoPriorityDependencies,
-                                        kTestCaseHTTP2PriorityDependencies));
+                        testing::Values(kTestCaseNoPriorityDependencies,
+                                        kTestCasePriorityDependencies));
 
 SpdyProxyClientSocketTest::SpdyProxyClientSocketTest()
-    : spdy_util_(GetProtocol(), GetDependenciesFromPriority()),
+    : spdy_util_(GetDependenciesFromPriority()),
       read_buf_(NULL),
-      session_deps_(GetProtocol()),
       connect_data_(SYNCHRONOUS, OK),
-      framer_(spdy_util_.spdy_version()),
+      framer_(HTTP2),
       user_agent_(kUserAgent),
       url_(kRequestUrl),
       proxy_host_port_(kProxyHost, kProxyPort),
       endpoint_host_port_pair_(kOriginHost, kOriginPort),
       proxy_(ProxyServer::SCHEME_HTTPS, proxy_host_port_),
       endpoint_spdy_session_key_(endpoint_host_port_pair_,
                                  proxy_,
                                  PRIVACY_MODE_DISABLED) {
   session_deps_.net_log = net_log_.bound().net_log();
   session_deps_.enable_priority_dependencies = GetDependenciesFromPriority();
 }
 
 SpdyProxyClientSocketTest::~SpdyProxyClientSocketTest() {
   EXPECT_TRUE(data_->AllWriteDataConsumed());
   EXPECT_TRUE(data_->AllReadDataConsumed());
 }
 
 void SpdyProxyClientSocketTest::TearDown() {
   if (session_.get() != NULL)
     session_->spdy_session_pool()->CloseAllSessions();
 
   // Empty the current queue.
   base::RunLoop().RunUntilIdle();
   PlatformTest::TearDown();
 }
 
-NextProto SpdyProxyClientSocketTest::GetProtocol() const {
-  return GetParam() == kTestCaseSPDY31 ? kProtoSPDY31 : kProtoHTTP2;
-}
-
 bool SpdyProxyClientSocketTest::GetDependenciesFromPriority() const {
-  return GetParam() == kTestCaseHTTP2PriorityDependencies;
+  return GetParam() == kTestCasePriorityDependencies;
 }
 
 void SpdyProxyClientSocketTest::Initialize(MockRead* reads,
                                            size_t reads_count,
                                            MockWrite* writes,
                                            size_t writes_count) {
   data_.reset(
       new SequencedSocketData(reads, reads_count, writes, writes_count));
   data_->set_connect_data(connect_data_);
 
@@ skipping 97 matching lines @@
   EXPECT_EQ(rv,
             sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
 }
 
 void SpdyProxyClientSocketTest::AssertWriteLength(int len) {
   EXPECT_EQ(len, write_callback_.WaitForResult());
 }
 
 void SpdyProxyClientSocketTest::PopulateConnectRequestIR(
     SpdyHeaderBlock* block) {
-  spdy_util_.MaybeAddVersionHeader(block);
   (*block)[spdy_util_.GetMethodKey()] = "CONNECT";
-  if (spdy_util_.spdy_version() == HTTP2) {
-    (*block)[spdy_util_.GetHostKey()] = kOriginHostPort;
-  } else {
-    (*block)[spdy_util_.GetHostKey()] = kOriginHost;
-    (*block)[spdy_util_.GetPathKey()] = kOriginHostPort;
-  }
+  (*block)[spdy_util_.GetHostKey()] = kOriginHostPort;
   (*block)["user-agent"] = kUserAgent;
 }
 
 void SpdyProxyClientSocketTest::PopulateConnectReplyIR(SpdyHeaderBlock* block,
                                                        const char* status) {
   (*block)[spdy_util_.GetStatusKey()] = status;
-  spdy_util_.MaybeAddVersionHeader(block);
 }
 
 // Constructs a standard SPDY SYN_STREAM frame for a CONNECT request.
 SpdySerializedFrame* SpdyProxyClientSocketTest::ConstructConnectRequestFrame() {
   SpdyHeaderBlock block;
   PopulateConnectRequestIR(&block);
   return spdy_util_.ConstructSpdySyn(kStreamId, std::move(block), LOWEST,
                                      false);
 }
 
@@ skipping 1040 matching lines @@
 
   EXPECT_FALSE(sock_.get());
   EXPECT_TRUE(read_callback.have_result());
   EXPECT_FALSE(write_callback_.have_result());
 
   // Let the RST_STREAM write while |rst| is in-scope.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace net