Move a number of static variables SPDY to HttpNetworkSession::Params.

net/spdy/spdy_session.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 
 #include <algorithm>
 #include <list>
 #include <map>
@@ skipping 76 matching lines @@
                SpdyProtocolErrorDetails_SpdyErrors_mismatch);
 
 COMPILE_ASSERT(PROTOCOL_ERROR_UNEXPECTED_PING ==
                static_cast<SpdyProtocolErrorDetails>(NUM_STATUS_CODES +
                                                      STATUS_CODE_INVALID),
                SpdyProtocolErrorDetails_SpdyErrors_mismatch);
 
 class NET_EXPORT SpdySession : public base::RefCounted<SpdySession>,
                                public BufferedSpdyFramerVisitorInterface {
  public:
+  typedef base::TimeTicks (*TimeFunc)(void);
+
   // Defines an interface for producing SpdyIOBuffers.
   class NET_EXPORT_PRIVATE SpdyIOBufferProducer {
    public:
     SpdyIOBufferProducer() {}
 
     // Returns a newly created SpdyIOBuffer, owned by the caller, or NULL
     // if not buffer is ready to be produced.
     virtual SpdyIOBuffer* ProduceNextBuffer(SpdySession* session) = 0;
 
     virtual RequestPriority GetPriority() const = 0;
@@ skipping 18 matching lines @@
   // the proxy configuration settings that it's using.
   // |spdy_session_pool| is the SpdySessionPool that owns us.  Its lifetime must
   // strictly be greater than |this|.
   // |session| is the HttpNetworkSession.  |net_log| is the NetLog that we log
   // network events to.
   SpdySession(const HostPortProxyPair& host_port_proxy_pair,
               SpdySessionPool* spdy_session_pool,
               HttpServerProperties* http_server_properties,
               bool verify_domain_authentication,
               bool enable_sending_initial_settings,
+              bool enable_credential_frames,
+              bool enable_compression,
+              bool enable_ping_based_connection_checking,
+              NextProto default_protocol_,
+              size_t initial_recv_window_size,
+              size_t initial_max_concurrent_streams,
+              size_t max_concurrent_streams_limit,
+              TimeFunc time_func,
               const HostPortPair& trusted_spdy_proxy,
               NetLog* net_log);
 
   const HostPortPair& host_port_pair() const {
     return host_port_proxy_pair_.first;
   }
   const HostPortProxyPair& host_port_proxy_pair() const {
     return host_port_proxy_pair_;
   }
 
@@ skipping 97 matching lines @@
                   NextProto* protocol_negotiated);
 
   // Fills SSL Certificate Request info |cert_request_info| and returns
   // true when SSL is in use.
   bool GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
 
   // Returns the ServerBoundCertService used by this Socket, or NULL
   // if server bound certs are not supported in this session.
   ServerBoundCertService* GetServerBoundCertService() const;
 
-  // Reset all static settings to initialized values. Used to init test suite.
-  static void ResetStaticSettingsToInit();
-
-  // Specify the SPDY protocol to be used for SPDY session which do not use NPN
-  // to negotiate a particular protocol.
-  static void set_default_protocol(NextProto default_protocol);
-
-  // Sets the max concurrent streams per session, as a ceiling on any server
-  // specific SETTINGS value.
-  static void set_max_concurrent_streams(size_t value);
-
-  // Enable sending of PING frame with each request.
-  static void set_enable_ping_based_connection_checking(bool enable);
-
-  // Enable the sending of CREDENTIAL frames.
-  static void set_enable_credential_frames(bool enable);
-
-  // The initial max concurrent streams per session, can be overridden by the
-  // server via SETTINGS.
-  static void set_init_max_concurrent_streams(size_t value);
-
-  // Sets the initial receive window size for newly created sessions.
-  static void set_default_initial_recv_window_size(size_t value);
-
   // Send WINDOW_UPDATE frame, called by a stream whenever receive window
   // size is increased.
   void SendWindowUpdate(SpdyStreamId stream_id, int32 delta_window_size);
 
   // If session is closed, no new streams/transactions should be created.
   bool IsClosed() const { return state_ == CLOSED; }
 
   // Closes this session.  This will close all active streams and mark
   // the session as permanently closed.
   // |err| should not be OK; this function is intended to be called on
@@ skipping 132 matching lines @@
   typedef std::map<const scoped_refptr<SpdyStream>*, CallbackResultPair>
       PendingCallbackMap;
 
   enum State {
     IDLE,
     CONNECTING,
     CONNECTED,
     CLOSED
   };
 
-  typedef base::TimeTicks (*TimeFunc)(void);
-
   virtual ~SpdySession();
 
   void ProcessPendingCreateStreams();
   int CreateStreamImpl(
       const GURL& url,
       RequestPriority priority,
       scoped_refptr<SpdyStream>* spdy_stream,
       const BoundNetLog& stream_net_log);
 
   // IO Callbacks
@@ skipping 113 matching lines @@
       const SpdyHeaderBlock& headers) OVERRIDE;
   virtual void OnHeaders(
       SpdyStreamId stream_id,
       bool fin,
       const SpdyHeaderBlock& headers) OVERRIDE;
 
   // --------------------------
   // Helper methods for testing
   // --------------------------
 
-  static TimeFunc set_time_func(TimeFunc new_time_func);
-
   void set_connection_at_risk_of_loss_time(base::TimeDelta duration) {
     connection_at_risk_of_loss_time_ = duration;
   }
 
   void set_hung_interval(base::TimeDelta duration) {
     hung_interval_ = duration;
   }
 
   int64 pings_in_flight() const { return pings_in_flight_; }
 
@@ skipping 84 matching lines @@
   scoped_ptr<BufferedSpdyFramer> buffered_spdy_framer_;
 
   // If an error has occurred on the session, the session is effectively
   // dead.  Record this error here.  When no error has occurred, |error_| will
   // be OK.
   net::Error error_;
   State state_;
 
   // Limits
   size_t max_concurrent_streams_;  // 0 if no limit
+  size_t max_concurrent_streams_limit_;
 
   // Some statistics counters for the session.
   int streams_initiated_count_;
   int streams_pushed_count_;
   int streams_pushed_and_claimed_count_;
   int streams_abandoned_count_;
   int bytes_received_;
   bool sent_settings_;      // Did this session send settings when it started.
   bool received_settings_;  // Did this session receive at least one settings
                             // frame.
@@ skipping 31 matching lines @@
   // command line switch that would cause a SETTINGS frame with window size
   // announcement to be sent on startup; newly created streams will use
   // this value for the initial receive window size.
   int32 initial_recv_window_size_;
 
   BoundNetLog net_log_;
 
   // Outside of tests, these should always be true.
   bool verify_domain_authentication_;
   bool enable_sending_initial_settings_;
+  bool enable_credential_frames_;
+  bool enable_compression_;
+  bool enable_ping_based_connection_checking_;
+  NextProto default_protocol_;
 
   SpdyCredentialState credential_state_;
 
   // |connection_at_risk_of_loss_time_| is an optimization to avoid sending
   // wasteful preface pings (when we just got some data).
   //
   // If it is zero (the most conservative figure), then we always send the
   // preface ping (when none are in flight).
   //
   // It is common for TCP/IP sessions to time out in about 3-5 minutes.
   // Certainly if it has been more than 3 minutes, we do want to send a preface
   // ping.
   //
   // We don't think any connection will time out in under about 10 seconds. So
   // this might as well be set to something conservative like 10 seconds. Later,
   // we could adjust it to send fewer pings perhaps.
   base::TimeDelta connection_at_risk_of_loss_time_;
 
   // The amount of time that we are willing to tolerate with no activity (of any
   // form), while there is a ping in flight, before we declare the connection to
   // be hung. TODO(rtenneti): When hung, instead of resetting connection, race
   // to build a new connection, and see if that completes before we (finally)
   // get a PING response (http://crbug.com/127812).
   base::TimeDelta hung_interval_;
 
   // This SPDY proxy is allowed to push resources from origins that are
   // different from those of their associated streams.
   HostPortPair trusted_spdy_proxy_;
+
+  TimeFunc time_func_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_