Remove static variables from HttpStreamFactory.

jingle/glue/proxy_resolving_client_socket.cc

 // 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.
 
 #include "jingle/glue/proxy_resolving_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_network_session.h"
+#include "net/http/http_transaction_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_manager.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace jingle_glue {
 
 ProxyResolvingClientSocket::ProxyResolvingClientSocket(
     net::ClientSocketFactory* socket_factory,
     const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
@@ skipping 29 matching lines @@
   // transport_security_state is NULL because it's not thread safe.
   session_params.transport_security_state = NULL;
   session_params.proxy_service = request_context->proxy_service();
   session_params.ssl_config_service = request_context->ssl_config_service();
   session_params.http_auth_handler_factory =
       request_context->http_auth_handler_factory();
   session_params.network_delegate = request_context->network_delegate();
   session_params.http_server_properties =
       request_context->http_server_properties();
   session_params.net_log = request_context->net_log();
+
+  net::HttpTransactionFactory* transaction_factory =

[akalin, 2012/08/31 19:44:48]

This seems to violate the principle of least knowledge, since this code has to
reach into the guts of the request context to build session params.  Would it be
possible for RequestContext to expose a GetReferenceParams() method or
something?

Ideally, this code would look like:

SessionParams session_params = context->GetReferenceParams();
session_params.socket_factory = socket_factory;
// Any other overrides here...
network_session_ = new net::HttpNetworkSession(session_params);

If that's too much to do for this CL, perhaps a TODO for the above?

[szager1, 2012/08/31 19:59:16]

That's kind of at odds with comment #15.  Maybe something like this:

net::HttpNetworkSession::Params reference_params;
// GetReferenceParams returns a bool, true iff it was able
// to populate the argument Params.
if (request_context->GetReferenceParams(reference_params)) {
  session_params.host_mapping_rules = reference_params.host_mapping_rules;
  ...
}

WDYT?

+      request_context->http_transaction_factory();
+  if (transaction_factory) {
+    net::HttpNetworkSession* network_session =
+        transaction_factory->GetSession();
+    if (network_session) {
+      const net::HttpNetworkSession::Params& reference_params =
+          network_session->params();
+      session_params.host_mapping_rules = reference_params.host_mapping_rules;
+      session_params.ignore_certificate_errors =
+          reference_params.ignore_certificate_errors;
+      session_params.http_pipelining_enabled =
+          reference_params.http_pipelining_enabled;
+      session_params.testing_fixed_http_port =
+          reference_params.testing_fixed_http_port;
+      session_params.testing_fixed_https_port =
+          reference_params.testing_fixed_https_port;
+      session_params.trusted_spdy_proxy =
+          reference_params.trusted_spdy_proxy;
+    }
+  }
+
   network_session_ = new net::HttpNetworkSession(session_params);
 }
 
 ProxyResolvingClientSocket::~ProxyResolvingClientSocket() {
   Disconnect();
 }
 
 int ProxyResolvingClientSocket::Read(net::IOBuffer* buf, int buf_len,
                                      const net::CompletionCallback& callback) {
   if (transport_.get() && transport_->socket())
@@ skipping 310 matching lines @@
   return false;
 }
 
 void ProxyResolvingClientSocket::CloseTransportSocket() {
   if (transport_.get() && transport_->socket())
     transport_->socket()->Disconnect();
   transport_.reset();
 }
 
 }  // namespace jingle_glue