Remove static variables from HttpStreamFactory.

net/http/http_pipelined_network_transaction_unittest.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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stringprintf.h"
@@ skipping 54 matching lines @@
   Observer* observer_;
 };
 
 class HttpPipelinedNetworkTransactionTest : public testing::Test {
  public:
   HttpPipelinedNetworkTransactionTest()
       : histograms_("a"),
         pool_(1, 1, &histograms_, &factory_) {
   }
 
-  virtual void SetUp() OVERRIDE {
-    default_pipelining_enabled_ = HttpStreamFactory::http_pipelining_enabled();
-    HttpStreamFactory::set_http_pipelining_enabled(true);
-  }
-
-  virtual void TearDown() OVERRIDE {
-    MessageLoop::current()->RunAllPending();
-    HttpStreamFactory::set_http_pipelining_enabled(default_pipelining_enabled_);
-  }
-
   void Initialize(bool force_http_pipelining) {
     // Normally, this code could just go in SetUp(). For a few of these tests,
     // we change the default number of sockets per group. That needs to be done
     // before we construct the HttpNetworkSession.
     proxy_config_service_ = new SimpleProxyConfigService();
     proxy_service_.reset(new ProxyService(proxy_config_service_, NULL, NULL));
     ssl_config_ = new SSLConfigServiceDefaults;
     auth_handler_factory_.reset(new HttpAuthHandlerMock::Factory());
 
     HttpNetworkSession::Params session_params;
     session_params.client_socket_factory = &factory_;
     session_params.proxy_service = proxy_service_.get();
     session_params.host_resolver = &mock_resolver_;
     session_params.ssl_config_service = ssl_config_.get();
     session_params.http_auth_handler_factory = auth_handler_factory_.get();
     session_params.http_server_properties = &http_server_properties_;
     session_params.force_http_pipelining = force_http_pipelining;
+    session_params.http_pipelining_enabled = true;
     session_ = new HttpNetworkSession(session_params);
   }
 
   void AddExpectedConnection(MockRead* reads, size_t reads_count,
                              MockWrite* writes, size_t writes_count) {
     DeterministicSocketData* data = new DeterministicSocketData(
         reads, reads_count, writes, writes_count);
     data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
     if (reads_count || writes_count) {
       data->StopAfter(reads_count + writes_count);
@@ skipping 112 matching lines @@
     EXPECT_EQ(OK, four_callback.WaitForResult());
     ExpectResponse("four.html", four_transaction, SYNCHRONOUS);
   }
 
   DeterministicMockClientSocketFactory factory_;
   ClientSocketPoolHistograms histograms_;
   MockTransportClientSocketPool pool_;
   ScopedVector<DeterministicSocketData> data_vector_;
   TestCompletionCallback callback_;
   ScopedVector<HttpRequestInfo> request_info_vector_;
-  bool default_pipelining_enabled_;
 
   SimpleProxyConfigService* proxy_config_service_;
   scoped_ptr<ProxyService> proxy_service_;
   MockHostResolver mock_resolver_;
   scoped_refptr<SSLConfigService> ssl_config_;
   scoped_ptr<HttpAuthHandlerMock::Factory> auth_handler_factory_;
   HttpServerPropertiesImpl http_server_properties_;
   scoped_refptr<HttpNetworkSession> session_;
 };
 
@@ skipping 787 matching lines @@
   EXPECT_EQ(ERR_PIPELINE_EVICTION, two_callback.WaitForResult());
   two_transaction.reset();
   EXPECT_EQ(ERR_PIPELINE_EVICTION, three_callback.WaitForResult());
   three_transaction.reset();
   EXPECT_EQ(ERR_PIPELINE_EVICTION, four_callback.WaitForResult());
 }
 
 }  // anonymous namespace
 
 }  // namespace net