Remove many-many SpdyMajorVersion and NextProto arguments and members.

net/spdy/spdy_test_util_common.cc

 // 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.
 
 #include "net/spdy/spdy_test_util_common.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <utility>
@@ skipping 170 matching lines @@
   PriorityGetter() : priority_(0) {}
   ~PriorityGetter() override {}
 
   SpdyPriority priority() const {
     return priority_;
   }
 
   void OnError(SpdyFramer::SpdyError error_code) override {}
   void OnStreamError(SpdyStreamId stream_id,
                      const std::string& description) override {}
-  void OnSynStream(SpdyStreamId stream_id,
-                   SpdyStreamId associated_stream_id,
-                   SpdyPriority priority,
-                   bool fin,
-                   bool unidirectional,
-                   const SpdyHeaderBlock& headers) override {
-    priority_ = priority;
-  }
-  void OnSynReply(SpdyStreamId stream_id,
-                  bool fin,
-                  const SpdyHeaderBlock& headers) override {}
   void OnHeaders(SpdyStreamId stream_id,
                  bool has_priority,
                  int weight,
                  SpdyStreamId parent_stream_id,
                  bool exclusive,
                  bool fin,
                  const SpdyHeaderBlock& headers) override {
     if (has_priority) {
       priority_ = Http2WeightToSpdy3Priority(weight);
     }
@@ skipping 26 matching lines @@
     return false;
   }
 
  private:
   SpdyPriority priority_;
 };
 
 }  // namespace
 
 bool GetSpdyPriority(const SpdySerializedFrame& frame, SpdyPriority* priority) {
-  BufferedSpdyFramer framer(HTTP2);
+  BufferedSpdyFramer framer;
   PriorityGetter priority_getter;
   framer.set_visitor(&priority_getter);
   size_t frame_size = frame.size();
   if (framer.ProcessInput(frame.data(), frame_size) != frame_size) {
     return false;
   }
   *priority = priority_getter.priority();
   return true;
 }
 
@@ skipping 85 matching lines @@
       ssl_config_service(new SSLConfigServiceDefaults),
       socket_factory(new MockClientSocketFactory),
       http_auth_handler_factory(
           HttpAuthHandlerFactory::CreateDefault(host_resolver.get())),
       http_server_properties(new HttpServerPropertiesImpl),
       enable_ip_pooling(true),
       enable_ping(false),
       enable_user_alternate_protocol_ports(false),
       enable_priority_dependencies(true),
       enable_quic(false),
-      session_max_recv_window_size(
-          SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2)),
-      stream_max_recv_window_size(
-          SpdySession::GetDefaultInitialWindowSize(kProtoHTTP2)),
+      session_max_recv_window_size(kDefaultInitialWindowSize),
+      stream_max_recv_window_size(kDefaultInitialWindowSize),
       time_func(&base::TimeTicks::Now),
       enable_http2_alternative_service_with_different_host(false),
       net_log(NULL) {
   // Note: The CancelledTransaction test does cleanup by running all
   // tasks in the message loop (RunAllPending).  Unfortunately, that
   // doesn't clean up tasks on the host resolver thread; and
   // TCPConnectJob is currently not cancellable.  Using synchronous
   // lookups allows the test to shutdown cleanly.  Until we have
   // cancellable TCPConnectJobs, use synchronous lookups.
   host_resolver->set_synchronous_mode(true);
@@ skipping 29 matching lines @@
   params.ssl_config_service = session_deps->ssl_config_service.get();
   params.http_auth_handler_factory =
       session_deps->http_auth_handler_factory.get();
   params.http_server_properties = session_deps->http_server_properties.get();
   params.enable_spdy_ping_based_connection_checking = session_deps->enable_ping;
   params.enable_user_alternate_protocol_ports =
       session_deps->enable_user_alternate_protocol_ports;
   params.enable_priority_dependencies =
       session_deps->enable_priority_dependencies;
   params.enable_quic = session_deps->enable_quic;
-  params.spdy_default_protocol = kProtoHTTP2;
   params.spdy_session_max_recv_window_size =
       session_deps->session_max_recv_window_size;
   params.spdy_stream_max_recv_window_size =
       session_deps->stream_max_recv_window_size;
   params.time_func = session_deps->time_func;
   params.proxy_delegate = session_deps->proxy_delegate.get();
   params.enable_http2_alternative_service_with_different_host =
       session_deps->enable_http2_alternative_service_with_different_host;
   params.net_log = session_deps->net_log;
   return params;
@@ skipping 14 matching lines @@
   storage_.set_job_factory(base::WrapUnique(new URLRequestJobFactoryImpl()));
   HttpNetworkSession::Params params;
   params.client_socket_factory = &socket_factory_;
   params.host_resolver = host_resolver();
   params.cert_verifier = cert_verifier();
   params.transport_security_state = transport_security_state();
   params.proxy_service = proxy_service();
   params.ssl_config_service = ssl_config_service();
   params.http_auth_handler_factory = http_auth_handler_factory();
   params.enable_spdy_ping_based_connection_checking = false;
-  params.spdy_default_protocol = kProtoHTTP2;
   params.http_server_properties = http_server_properties();
   storage_.set_http_network_session(
       base::WrapUnique(new HttpNetworkSession(params)));
   SpdySessionPoolPeer pool_peer(
       storage_.http_network_session()->spdy_session_pool());
   pool_peer.SetEnableSendingInitialData(false);
   storage_.set_http_transaction_factory(base::WrapUnique(
       new HttpCache(storage_.http_network_session(),
                     HttpCache::DefaultBackend::InMemory(0), false)));
 }
@@ skipping 248 matching lines @@
 
 SpdyHeaderBlock SpdyTestUtil::ConstructPutHeaderBlock(
     base::StringPiece url,
     int64_t content_length) const {
   return ConstructHeaderBlock("PUT", url, &content_length);
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyFrame(
     const SpdyHeaderInfo& header_info,
     SpdyHeaderBlock headers) const {
-  BufferedSpdyFramer framer(HTTP2);
+  BufferedSpdyFramer framer;
   SpdySerializedFrame* frame = NULL;
   switch (header_info.kind) {
     case DATA:
       frame = framer.CreateDataFrame(header_info.id, header_info.data,
                                      header_info.data_length,
                                      header_info.data_flags);
       break;
     case SYN_STREAM:
       frame = framer.CreateSynStream(
           header_info.id, header_info.assoc_id, header_info.priority,
@@ skipping 267 matching lines @@
       parent_stream_id = priority_to_stream_id_list_[q].back();
       break;
     }
   }
 
   priority_to_stream_id_list_[priority].push_back(stream_id);
 
   SpdyHeadersIR headers(stream_id, std::move(block));
   headers.set_has_priority(true);
   headers.set_weight(Spdy3PriorityToHttp2Weight(
-      ConvertRequestPriorityToSpdyPriority(priority, HTTP2)));
+      ConvertRequestPriorityToSpdyPriority(priority)));
   if (dependency_priorities_) {
     headers.set_parent_stream_id(parent_stream_id);
     headers.set_exclusive(true);
   }
   headers.set_fin(fin);
   return new SpdySerializedFrame(request_spdy_framer_.SerializeFrame(headers));
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyReply(int stream_id,
                                                       SpdyHeaderBlock headers) {
@@ skipping 157 matching lines @@
   headers[GetPathKey()] = path.c_str();
   if (content_length) {
     std::string length_str = base::Int64ToString(*content_length);
     headers["content-length"] = length_str;
   }
   return headers;
 }
 
 void SpdyTestUtil::SetPriority(RequestPriority priority,
                                SpdySynStreamIR* ir) const {
-  ir->set_priority(ConvertRequestPriorityToSpdyPriority(priority, HTTP2));
+  ir->set_priority(ConvertRequestPriorityToSpdyPriority(priority));
 }
 
 }  // namespace net