Remove HttpStreamFactory's NPN/SPDY globals, except for spdy_enabled.

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 <set>
 #include <string>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_export.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_auth_cache.h"
 #include "net/http/http_stream_factory.h"
 #include "net/quic/quic_stream_factory.h"
+#include "net/socket/next_proto.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/ssl/ssl_client_auth_cache.h"
 
 namespace base {
 class Value;
 }
 
 namespace net {
 
 class CertVerifier;
 class ClientSocketFactory;
 class ClientSocketPoolManager;
+class CTVerifier;
 class HostResolver;
 class HpackHuffmanAggregator;
 class HttpAuthHandlerFactory;
 class HttpNetworkSessionPeer;
 class HttpProxyClientSocketPool;
 class HttpResponseBodyDrainer;
 class HttpServerProperties;
 class NetLog;
 class NetworkDelegate;
 class ServerBoundCertService;
@@ skipping 28 matching lines @@
     HttpAuthHandlerFactory* http_auth_handler_factory;
     NetworkDelegate* network_delegate;
     base::WeakPtr<HttpServerProperties> http_server_properties;
     NetLog* net_log;
     HostMappingRules* host_mapping_rules;
     bool force_http_pipelining;
     bool ignore_certificate_errors;
     bool http_pipelining_enabled;
     uint16 testing_fixed_http_port;
     uint16 testing_fixed_https_port;
+
     bool force_spdy_single_domain;
     bool enable_spdy_compression;
     bool enable_spdy_ping_based_connection_checking;
     NextProto spdy_default_protocol;
+    // The protocols supported by NPN (next protocol negotiation) during the
+    // SSL handshake as well as by HTTP Alternate-Protocol.
+    // TODO(mmenke):  This is currently empty by default, and alternate
+    //                protocols are disabled.  We should use some reasonable
+    //                defaults.
+    NextProtoVector next_protos;
     size_t spdy_stream_initial_recv_window_size;
     size_t spdy_initial_max_concurrent_streams;
     size_t spdy_max_concurrent_streams_limit;
     SpdySessionPool::TimeFunc time_func;
     std::string trusted_spdy_proxy;
+    // Controls whether or not ssl is used when in SPDY mode.
+    bool force_spdy_over_ssl;
+    // Controls whether or not SPDY is used without NPN.
+    bool force_spdy_always;
+    // URLs to exclude from forced SPDY.
+    std::set<HostPortPair> forced_spdy_exclusions;
+    // Noe: Using this in the case of NPN for HTTP only results in the browser
+    // trying SSL and then falling back to http.
+    bool use_alternate_protocols;
+
     bool enable_quic;
     bool enable_quic_https;
     bool enable_quic_port_selection;
     bool enable_quic_pacing;
     bool enable_quic_time_based_loss_detection;
     bool enable_quic_persist_server_info;
     HostPortPair origin_to_force_quic_on;
     QuicClock* quic_clock;  // Will be owned by QuicStreamFactory.
     QuicRandom* quic_random;
     size_t quic_max_packet_length;
@@ skipping 75 matching lines @@
 
   bool force_http_pipelining() const { return force_http_pipelining_; }
 
   // Returns the original Params used to construct this session.
   const Params& params() const { return params_; }
 
   void set_http_pipelining_enabled(bool enable) {
     params_.http_pipelining_enabled = enable;
   }
 
+  bool IsProtocolEnabled(AlternateProtocol protocol) const;
+
+  void GetNextProtos(std::vector<std::string>* next_protos) const;
+
+  // Convenience function for searching through |params_| for
+  // |forced_spdy_exclusions|.
+  bool HasSpdyExclusion(HostPortPair host_port_pair) const;
+
  private:
   friend class base::RefCounted<HttpNetworkSession>;
   friend class HttpNetworkSessionPeer;
 
   ~HttpNetworkSession();
 
   ClientSocketPoolManager* GetSocketPoolManager(SocketPoolType pool_type);
 
   NetLog* const net_log_;
   NetworkDelegate* const network_delegate_;
@@ skipping 12 matching lines @@
   scoped_ptr<ClientSocketPoolManager> websocket_socket_pool_manager_;
   QuicStreamFactory quic_stream_factory_;
   SpdySessionPool spdy_session_pool_;
   scoped_ptr<HttpStreamFactory> http_stream_factory_;
   scoped_ptr<HttpStreamFactory> http_stream_factory_for_websocket_;
   std::set<HttpResponseBodyDrainer*> response_drainers_;
 
   // TODO(jgraettinger): Remove when Huffman collection is complete.
   scoped_ptr<HpackHuffmanAggregator> huffman_aggregator_;
 
+  std::vector<std::string> next_protos_;
+  bool enabled_protocols_[NUM_VALID_ALTERNATE_PROTOCOLS];
+
   Params params_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_NETWORK_SESSION_H_