Remove SPDY/3.1 tests.

net/spdy/spdy_test_util_common.h

 // Copyright (c) 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.
 
 #ifndef NET_SPDY_SPDY_TEST_UTIL_COMMON_H_
 #define NET_SPDY_SPDY_TEST_UTIL_COMMON_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 11 matching lines @@
 #include "net/base/test_completion_callback.h"
 #include "net/cert/cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/transport_security_state.h"
 #include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_service.h"
-#include "net/socket/next_proto.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_storage.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class GURL;
 
 namespace net {
@@ skipping 47 matching lines @@
 
 // Combines the given SpdySerializedFrame into the given char array and returns
 // the total length.
 int CombineFrames(const SpdySerializedFrame** frames,
                   int num_frames,
                   char* buf,
                   int buf_len);
 
 // Returns the SpdyPriority embedded in the given frame.  Returns true
 // and fills in |priority| on success.
-bool GetSpdyPriority(SpdyMajorVersion version,
-                     const SpdySerializedFrame& frame,
-                     SpdyPriority* priority);
+bool GetSpdyPriority(const SpdySerializedFrame& frame, SpdyPriority* priority);
 
 // Tries to create a stream in |session| synchronously. Returns NULL
 // on failure.
 base::WeakPtr<SpdyStream> CreateStreamSynchronously(
     SpdyStreamType type,
     const base::WeakPtr<SpdySession>& session,
     const GURL& url,
     RequestPriority priority,
     const BoundNetLog& net_log);
 
@@ skipping 55 matching lines @@
       crypto::ECPrivateKey* key) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockECSignatureCreatorFactory);
 };
 
 // Helper to manage the lifetimes of the dependencies for a
 // HttpNetworkTransaction.
 struct SpdySessionDependencies {
   // Default set of dependencies -- "null" proxy service.
-  explicit SpdySessionDependencies(NextProto protocol);
+  SpdySessionDependencies();
 
   // Custom proxy service dependency.
-  SpdySessionDependencies(NextProto protocol,
-                          std::unique_ptr<ProxyService> proxy_service);
+  explicit SpdySessionDependencies(std::unique_ptr<ProxyService> proxy_service);
 
   ~SpdySessionDependencies();
 
   static std::unique_ptr<HttpNetworkSession> SpdyCreateSession(
       SpdySessionDependencies* session_deps);
   static HttpNetworkSession::Params CreateSessionParams(
       SpdySessionDependencies* session_deps);
 
   // NOTE: host_resolver must be ordered before http_auth_handler_factory.
   std::unique_ptr<MockHostResolverBase> host_resolver;
   std::unique_ptr<CertVerifier> cert_verifier;
   std::unique_ptr<ChannelIDService> channel_id_service;
   std::unique_ptr<TransportSecurityState> transport_security_state;
   std::unique_ptr<CTVerifier> cert_transparency_verifier;
   std::unique_ptr<CTPolicyEnforcer> ct_policy_enforcer;
   std::unique_ptr<ProxyService> proxy_service;
   scoped_refptr<SSLConfigService> ssl_config_service;
   std::unique_ptr<MockClientSocketFactory> socket_factory;
   std::unique_ptr<HttpAuthHandlerFactory> http_auth_handler_factory;
   std::unique_ptr<HttpServerPropertiesImpl> http_server_properties;
   bool enable_ip_pooling;
   bool enable_ping;
   bool enable_user_alternate_protocol_ports;
   bool enable_priority_dependencies;
   bool enable_quic;
-  NextProto protocol;
   size_t session_max_recv_window_size;
   size_t stream_max_recv_window_size;
   SpdySession::TimeFunc time_func;
   std::unique_ptr<ProxyDelegate> proxy_delegate;
   bool enable_http2_alternative_service_with_different_host;
   NetLog* net_log;
 };
 
 class SpdyURLRequestContext : public URLRequestContext {
  public:
-  explicit SpdyURLRequestContext(NextProto protocol);
+  SpdyURLRequestContext();
   ~SpdyURLRequestContext() override;
 
   MockClientSocketFactory& socket_factory() { return socket_factory_; }
 
  private:
   MockClientSocketFactory socket_factory_;
   URLRequestContextStorage storage_;
 };
 
 // Equivalent to pool->GetIfExists(spdy_session_key, BoundNetLog()) != NULL.
@@ skipping 50 matching lines @@
   void SetStreamInitialRecvWindowSize(size_t window);
 
  private:
   SpdySessionPool* const pool_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdySessionPoolPeer);
 };
 
 class SpdyTestUtil {
  public:
-  explicit SpdyTestUtil(NextProto protocol, bool dependency_priorities);
+  explicit SpdyTestUtil(bool dependency_priorities);
   ~SpdyTestUtil();
 
   // Add the appropriate headers to put |url| into |block|.
   void AddUrlToHeaderBlock(base::StringPiece url,
                            SpdyHeaderBlock* headers) const;
 
   SpdyHeaderBlock ConstructGetHeaderBlock(base::StringPiece url) const;
   SpdyHeaderBlock ConstructGetHeaderBlockForProxy(base::StringPiece url) const;
   SpdyHeaderBlock ConstructHeadHeaderBlock(base::StringPiece url,
                                            int64_t content_length) const;
@@ skipping 19 matching lines @@
                                           int tail_header_count) const;
 
   // Construct an expected SPDY reply string from the given headers.
   std::string ConstructSpdyReplyString(const SpdyHeaderBlock& headers) const;
 
   // Construct an expected SPDY SETTINGS frame.
   // |settings| are the settings to set.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdySerializedFrame* ConstructSpdySettings(const SettingsMap& settings);
 
-  // Constructs an expected SPDY SETTINGS acknowledgement frame, if the protocol
-  // version is SPDY4 or higher, or an empty placeholder frame otherwise.
+  // Constructs an expected SPDY SETTINGS acknowledgement frame.
   SpdySerializedFrame* ConstructSpdySettingsAck();
 
   // Construct a SPDY PING frame.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdySerializedFrame* ConstructSpdyPing(uint32_t ping_id, bool is_ack);
 
   // Construct a SPDY GOAWAY frame with last_good_stream_id = 0.
   // Returns the constructed frame.  The caller takes ownership of the frame.
   SpdySerializedFrame* ConstructSpdyGoAway();
 
@@ skipping 63 matching lines @@
 
   SpdySerializedFrame* ConstructInitialSpdyPushFrame(SpdyHeaderBlock headers,
                                                      int stream_id,
                                                      int associated_stream_id);
 
   SpdySerializedFrame* ConstructSpdyPushHeaders(
       int stream_id,
       const char* const extra_headers[],
       int extra_header_count);
 
-  // Constructs a SPDY header frame with the request header compression context
-  // with END_STREAM flag set to |fin|.
+  // Constructs a HEADERS frame with the request header compression context with
+  // END_STREAM flag set to |fin|.
   SpdySerializedFrame* ConstructSpdyResponseHeaders(int stream_id,
                                                     SpdyHeaderBlock headers,
                                                     bool fin);
 
-  // Construct a SPDY syn (HEADERS or SYN_STREAM, depending on protocol
-  // version) carrying exactly the given headers and priority.
+  // Construct a HEADERS frame carrying exactly the given headers and priority.
   SpdySerializedFrame* ConstructSpdySyn(int stream_id,
                                         SpdyHeaderBlock headers,
                                         RequestPriority priority,
                                         bool fin);
 
-  // Construct a SPDY reply (HEADERS or SYN_REPLY, depending on protocol
-  // version) carrying exactly the given headers, and the default priority
-  // (or no priority, depending on protocol version).
+  // Construct a reply HEADERS frame carrying exactly the given headers and the
+  // default priority.
   SpdySerializedFrame* ConstructSpdyReply(int stream_id,
                                           SpdyHeaderBlock headers);
 
   // Constructs a standard SPDY SYN_REPLY frame to match the SPDY GET.
   // |extra_headers| are the extra header-value pairs, which typically
   // will vary the most between calls.
   // Returns a SpdySerializedFrame.
   SpdySerializedFrame* ConstructSpdyGetSynReply(
       const char* const extra_headers[],
       int extra_header_count,
@@ skipping 67 matching lines @@
       int stream_id);
 
   // Serialize a SpdyFrameIR with |headerless_spdy_framer_|.
   SpdySerializedFrame SerializeFrame(const SpdyFrameIR& frame_ir);
 
   // Called when necessary (when it will affect stream dependency specification
   // when setting dependencies based on priorioties) to notify the utility
   // class of stream destruction.
   void UpdateWithStreamDestruction(int stream_id);
 
-  // For versions below SPDY4, adds the version HTTP/1.1 header.
-  void MaybeAddVersionHeader(SpdyHeaderBlock* block) const;
-
-  // Maps |priority| to SPDY version priority, and sets it on |frame_ir|.
+  // Maps |priority| to SPDY priority, and sets it on |frame_ir|.
   void SetPriority(RequestPriority priority, SpdySynStreamIR* frame_ir) const;
 
-  NextProto protocol() const { return protocol_; }
-  SpdyMajorVersion spdy_version() const { return spdy_version_; }
-  bool include_version_header() const { return protocol_ < kProtoHTTP2; }
-
   void set_default_url(const GURL& url) { default_url_ = url; }
 
   const char* GetMethodKey() const;
   const char* GetStatusKey() const;
   const char* GetHostKey() const;
   const char* GetSchemeKey() const;
-  const char* GetVersionKey() const;
   const char* GetPathKey() const;
 
  private:
   // |content_length| may be NULL, in which case the content-length
   // header will be omitted.
   SpdyHeaderBlock ConstructHeaderBlock(base::StringPiece method,
                                        base::StringPiece url,
                                        int64_t* content_length) const;
 
-  const NextProto protocol_;
-  const SpdyMajorVersion spdy_version_;
-
   // Multiple SpdyFramers are required to keep track of header compression
   // state.
   // Use to serialize frames (request or response) without headers.
   SpdyFramer headerless_spdy_framer_;
   // Use to serialize request frames with headers.
   SpdyFramer request_spdy_framer_;
   // Use to serialize response frames with headers.
   SpdyFramer response_spdy_framer_;
 
   GURL default_url_;
   bool dependency_priorities_;
 
   // Track a FIFO list of the stream_id of all created requests by priority.
   std::map<int, std::vector<int>> priority_to_stream_id_list_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_TEST_UTIL_COMMON_H_