Split HttpNetworkSession::Params into two structs.

net/http/http_network_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_HTTP_HTTP_NETWORK_SESSION_H_
 #define NET_HTTP_HTTP_NETWORK_SESSION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 60 matching lines @@
 const uint32_t kSpdyMaxHeaderTableSize = 64 * 1024;
 
 // Specifies the maximum concurrent streams server could send (via push).
 const uint32_t kSpdyMaxConcurrentPushedStreams = 1000;
 
 // This class holds session objects used by HttpNetworkTransaction objects.
 class NET_EXPORT HttpNetworkSession
     : NON_EXPORTED_BASE(public base::NonThreadSafe),
       public base::MemoryCoordinatorClient {
  public:
+  // Self-contained structure with all the simple configuration options
+  // supported by the HttpNetworkSession.
   struct NET_EXPORT Params {
     Params();
     Params(const Params& other);
     ~Params();
 
-    ClientSocketFactory* client_socket_factory;
-    HostResolver* host_resolver;
-    CertVerifier* cert_verifier;
     bool enable_server_push_cancellation;
-    ChannelIDService* channel_id_service;
-    TransportSecurityState* transport_security_state;
-    CTVerifier* cert_transparency_verifier;
-    CTPolicyEnforcer* ct_policy_enforcer;
-    ProxyService* proxy_service;
-    SSLConfigService* ssl_config_service;
-    HttpAuthHandlerFactory* http_auth_handler_factory;
-    HttpServerProperties* http_server_properties;
-    NetLog* net_log;
     HostMappingRules host_mapping_rules;
-    SocketPerformanceWatcherFactory* socket_performance_watcher_factory;
     bool ignore_certificate_errors;
     uint16_t testing_fixed_http_port;
     uint16_t testing_fixed_https_port;
     bool enable_tcp_fast_open_for_ssl;
     bool enable_user_alternate_protocol_ports;
 
     // Use SPDY ping frames to test for connection health after idle.
     bool enable_spdy_ping_based_connection_checking;
     bool enable_http2;
     size_t spdy_session_max_recv_window_size;
     // HTTP/2 connection settings.
     // Unknown settings will still be sent to the server.
     SettingsMap http2_settings;
     // Source of time for SPDY connections.
     SpdySessionPool::TimeFunc time_func;
     // Whether to enable HTTP/2 Alt-Svc entries.
     bool enable_http2_alternative_service;
 
     // Enables QUIC support.
     bool enable_quic;
 
     // QUIC runtime configuration options.
 
     // Versions of QUIC which may be used.
     QuicVersionVector quic_supported_versions;
     // User agent description to send in the QUIC handshake.
     std::string quic_user_agent_id;
     // Limit on the size of QUIC packets.
     size_t quic_max_packet_length;
-    // Source of time for QUIC connections.
-    QuicClock* quic_clock;
-    // Source of entropy for QUIC connections.
-    QuicRandom* quic_random;
-    // Optional factory to use for creating QuicCryptoClientStreams.
-    QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory;
     // Maximum number of server configs that are to be stored in
     // HttpServerProperties, instead of the disk cache.
     size_t quic_max_server_configs_stored_in_properties;
     // QUIC will be used for all connections in this set.
     std::set<HostPortPair> origins_to_force_quic_on;
     // Set of QUIC tags to send in the handshake's connection options.
     QuicTagVector quic_connection_options;
 
     // Active QUIC experiments
 
@@ skipping 26 matching lines @@
     bool quic_disable_bidirectional_streams;
     // If true, enable force HOL blocking.  For measurement purposes.
     bool quic_force_hol_blocking;
     // If true, race cert verification with host resolution.
     bool quic_race_cert_verification;
     // If true, configure QUIC sockets to not fragment packets.
     bool quic_do_not_fragment;
     // If true, estimate the initial RTT for QUIC connections based on network.
     bool quic_estimate_initial_rtt;
 
-    ProxyDelegate* proxy_delegate;
     // Enable support for Token Binding.
     bool enable_token_binding;
 
     // Enable HTTP/0.9 for HTTP/HTTPS on ports other than the default one for
     // each protocol.
     bool http_09_on_non_default_ports_enabled;
   };
 
+  // Structure with pointers to the dependencies of the HttpNetworkSession.
+  // These objects must all outlive the HttpNetworkSession.
+  struct NET_EXPORT Context {
+    Context();
+    Context(const Context& other);
+    ~Context();
+
+    ClientSocketFactory* client_socket_factory;
+    HostResolver* host_resolver;
+    CertVerifier* cert_verifier;
+    ChannelIDService* channel_id_service;
+    TransportSecurityState* transport_security_state;
+    CTVerifier* cert_transparency_verifier;
+    CTPolicyEnforcer* ct_policy_enforcer;
+    ProxyService* proxy_service;
+    SSLConfigService* ssl_config_service;
+    HttpAuthHandlerFactory* http_auth_handler_factory;
+    HttpServerProperties* http_server_properties;
+    NetLog* net_log;
+    SocketPerformanceWatcherFactory* socket_performance_watcher_factory;
+
+    // Source of time for QUIC connections.
+    QuicClock* quic_clock;
+    // Source of entropy for QUIC connections.
+    QuicRandom* quic_random;
+    // Optional factory to use for creating QuicCryptoClientStreams.
+    QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory;
+
+    ProxyDelegate* proxy_delegate;
+  };
+
   enum SocketPoolType {
     NORMAL_SOCKET_POOL,
     WEBSOCKET_SOCKET_POOL,
     NUM_SOCKET_POOL_TYPES
   };
 
-  explicit HttpNetworkSession(const Params& params);
+  HttpNetworkSession(const Params& params, const Context& context);
   ~HttpNetworkSession() override;
 
   HttpAuthCache* http_auth_cache() { return &http_auth_cache_; }
   SSLClientAuthCache* ssl_client_auth_cache() {
     return &ssl_client_auth_cache_;
   }
 
   void AddResponseDrainer(std::unique_ptr<HttpResponseBodyDrainer> drainer);
 
   // Removes the drainer from the session. Does not dispose of it.
@@ skipping 43 matching lines @@
 
   // Creates a Value summary of the state of the QUIC sessions and
   // configuration.
   std::unique_ptr<base::Value> QuicInfoToValue() const;
 
   void CloseAllConnections();
   void CloseIdleConnections();
 
   // Returns the original Params used to construct this session.
   const Params& params() const { return params_; }
+  // Returns the original Context used to construct this session.
+  const Context& context() const { return context_; }
 
   bool IsProtocolEnabled(NextProto protocol) const;
 
   void SetServerPushDelegate(std::unique_ptr<ServerPushDelegate> push_delegate);
 
   // Populates |*alpn_protos| with protocols to be used with ALPN.
   void GetAlpnProtos(NextProtoVector* alpn_protos) const;
 
   // Populates |server_config| and |proxy_config| based on this session and
   // |request|.
@@ skipping 42 matching lines @@
   SpdySessionPool spdy_session_pool_;
   std::unique_ptr<HttpStreamFactory> http_stream_factory_;
   std::unique_ptr<HttpStreamFactory> http_stream_factory_for_websocket_;
   std::map<HttpResponseBodyDrainer*, std::unique_ptr<HttpResponseBodyDrainer>>
       response_drainers_;
   std::unique_ptr<NetworkThrottleManager> network_stream_throttler_;
 
   NextProtoVector next_protos_;
 
   Params params_;
+  Context context_;
 
   std::unique_ptr<base::MemoryPressureListener> memory_pressure_listener_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_NETWORK_SESSION_H_