Make QuicStreamFactory in QuicStreamFactoryTest configurable.

BUG=544156

Review URL: https://codereview.chromium.org/1419773002

Cr-Commit-Position: refs/heads/master@{#355453}

1 files changed, 437 insertions, 379 deletions

diff --git a/net/quic/quic_stream_factory_test.cc b/net/quic/quic_stream_factory_test.cc
index 2d61006..e3a6f45 100644
--- a/net/quic/quic_stream_factory_test.cc
+++ b/net/quic/quic_stream_factory_test.cc
@@ -118,31 +118,11 @@ class QuicStreamFactoryPeer {
     return false;
   }
 
-  static void DisableConnectionPooling(QuicStreamFactory* factory) {
-    factory->disable_connection_pooling_ = true;
-  }
-
   static void SetTaskRunner(QuicStreamFactory* factory,
                             base::TaskRunner* task_runner) {
     factory->task_runner_ = task_runner;
   }
 
-  static void SetEnableConnectionRacing(QuicStreamFactory* factory,
-                                        bool enable_connection_racing) {
-    factory->enable_connection_racing_ = enable_connection_racing;
-  }
-
-  static void SetDisableDiskCache(QuicStreamFactory* factory,
-                                  bool disable_disk_cache) {
-    factory->disable_disk_cache_ = disable_disk_cache;
-  }
-
-  static void SetMaxNumberOfLossyConnections(
-      QuicStreamFactory* factory,
-      int max_number_of_lossy_connections) {
-    factory->max_number_of_lossy_connections_ = max_number_of_lossy_connections;
-  }
-
   static int GetNumberOfLossyConnections(QuicStreamFactory* factory,
                                          uint16 port) {
     return factory->number_of_lossy_connections_[port];
@@ -175,24 +155,10 @@ class QuicStreamFactoryPeer {
     return (factory->active_jobs_[server_id]).size();
   }
 
-  static void SetThresholdTimeoutsWithOpenStreams(
-      QuicStreamFactory* factory,
-      int threshold_timeouts_with_open_streams) {
-    factory->threshold_timeouts_with_open_streams_ =
-        threshold_timeouts_with_open_streams;
-  }
-
   static int GetNumTimeoutsWithOpenStreams(QuicStreamFactory* factory) {
     return factory->num_timeouts_with_open_streams_;
   }
 
-  static void SetThresholdPublicResetsPostHandshake(
-      QuicStreamFactory* factory,
-      int threshold_public_resets_post_handshake) {
-    factory->threshold_public_resets_post_handshake_ =
-        threshold_public_resets_post_handshake;
-  }
-
   static int GetNumPublicResetsPostHandshake(QuicStreamFactory* factory) {
     return factory->num_public_resets_post_handshake_;
   }
@@ -215,10 +181,6 @@ class QuicStreamFactoryPeer {
                                        QuicServerId& quic_server_id) {
     return factory->CryptoConfigCacheIsEmpty(quic_server_id);
   }
-
-  static void EnableStoreServerConfigsInProperties(QuicStreamFactory* factory) {
-    factory->store_server_configs_in_properties_ = true;
-  }
 };
 
 class MockQuicServerInfo : public QuicServerInfo {
@@ -267,55 +229,58 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
         channel_id_service_(
             new ChannelIDService(new DefaultChannelIDStore(nullptr),
                                  base::ThreadTaskRunnerHandle::Get())),
-        factory_(&host_resolver_,
-                 &socket_factory_,
-                 http_server_properties_.GetWeakPtr(),
-                 cert_verifier_.get(),
-                 nullptr,
-                 channel_id_service_.get(),
-                 &transport_security_state_,
-                 /*SocketPerformanceWatcherFactory*/ nullptr,
-                 &crypto_client_stream_factory_,
-                 &random_generator_,
-                 clock_,
-                 kDefaultMaxPacketSize,
-                 std::string(),
-                 SupportedVersions(GetParam().version),
-                 /*enable_port_selection=*/true,
-                 /*always_require_handshake_confirmation=*/false,
-                 /*disable_connection_pooling=*/false,
-                 /*load_server_info_timeout_srtt_multiplier=*/0.0f,
-                 /*enable_connection_racing=*/false,
-                 /*enable_non_blocking_io=*/true,
-                 /*disable_disk_cache=*/false,
-                 /*prefer_aes=*/false,
-                 /*max_number_of_lossy_connections=*/0,
-                 /*packet_loss_threshold=*/1.0f,
-                 /*max_disabled_reasons=*/3,
-                 /*threshold_timeouts_with_open_streams=*/2,
-                 /*threshold_pulic_resets_post_handshake=*/2,
-                 /*receive_buffer_size=*/0,
-                 /*delay_tcp_race=*/false,
-                 /*store_server_configs_in_properties=*/false,
-                 QuicTagVector()),
+        factory_(nullptr),
         host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
-        privacy_mode_(PRIVACY_MODE_DISABLED) {
-    factory_.set_require_confirmation(false);
-    factory_.set_quic_server_info_factory(new MockQuicServerInfoFactory());
+        privacy_mode_(PRIVACY_MODE_DISABLED),
+        enable_port_selection_(true),
+        always_require_handshake_confirmation_(false),
+        disable_connection_pooling_(false),
+        load_server_info_timeout_srtt_multiplier_(0.0f),
+        enable_connection_racing_(true),
+        enable_non_blocking_io_(true),
+        disable_disk_cache_(false),
+        prefer_aes_(false),
+        max_number_of_lossy_connections_(0),
+        packet_loss_threshold_(1.0f),
+        max_disabled_reasons_(3),
+        threshold_timeouts_with_open_streams_(2),
+        threshold_public_resets_post_handshake_(2),
+        receive_buffer_size_(0),
+        delay_tcp_race_(false),
+        store_server_configs_in_properties_(false) {
     clock_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
-    QuicStreamFactoryPeer::SetEnableConnectionRacing(
-        &factory_, GetParam().enable_connection_racing);
+  }
+
+  void Initialize() {
+    factory_.reset(new QuicStreamFactory(
+        &host_resolver_, &socket_factory_, http_server_properties_.GetWeakPtr(),
+        cert_verifier_.get(), nullptr, channel_id_service_.get(),
+        &transport_security_state_,
+        /*SocketPerformanceWatcherFactory*/ nullptr,
+        &crypto_client_stream_factory_, &random_generator_, clock_,
+        kDefaultMaxPacketSize, std::string(),
+        SupportedVersions(GetParam().version), enable_port_selection_,
+        always_require_handshake_confirmation_, disable_connection_pooling_,
+        load_server_info_timeout_srtt_multiplier_, enable_connection_racing_,
+        enable_non_blocking_io_, disable_disk_cache_, prefer_aes_,
+        max_number_of_lossy_connections_, packet_loss_threshold_,
+        max_disabled_reasons_, threshold_timeouts_with_open_streams_,
+        threshold_public_resets_post_handshake_, receive_buffer_size_,
+        delay_tcp_race_, store_server_configs_in_properties_, QuicTagVector()));
+    factory_->set_require_confirmation(false);
+    factory_->set_quic_server_info_factory(new MockQuicServerInfoFactory());
   }
 
   bool HasActiveSession(const HostPortPair& host_port_pair) {
-    return QuicStreamFactoryPeer::HasActiveSession(&factory_, host_port_pair);
+    return QuicStreamFactoryPeer::HasActiveSession(factory_.get(),
+                                                   host_port_pair);
   }
 
   scoped_ptr<QuicHttpStream> CreateFromSession(
       const HostPortPair& host_port_pair) {
     QuicChromiumClientSession* session =
-        QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair);
-    return QuicStreamFactoryPeer::CreateFromSession(&factory_, session);
+        QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair);
+    return QuicStreamFactoryPeer::CreateFromSession(factory_.get(), session);
   }
 
   int GetSourcePortForNewSession(const HostPortPair& destination) {
@@ -340,7 +305,7 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
     socket_data.StopAfter(1);
     socket_factory_.AddSocketDataProvider(&socket_data);
 
-    QuicStreamRequest request(&factory_);
+    QuicStreamRequest request(factory_.get());
     EXPECT_EQ(ERR_IO_PENDING,
               request.Request(destination, privacy_mode_,
                               /*cert_verify_flags=*/0, destination.host(),
@@ -352,7 +317,7 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
     stream.reset();
 
     QuicChromiumClientSession* session =
-        QuicStreamFactoryPeer::GetActiveSession(&factory_, destination);
+        QuicStreamFactoryPeer::GetActiveSession(factory_.get(), destination);
 
     if (socket_count + 1 != socket_factory_.udp_client_sockets().size()) {
       EXPECT_TRUE(false);
@@ -368,7 +333,7 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
       session->connection()->OnGoAwayFrame(goaway);
     }
 
-    factory_.OnSessionClosed(session);
+    factory_->OnSessionClosed(session);
     EXPECT_FALSE(HasActiveSession(destination));
     EXPECT_TRUE(socket_data.AllReadDataConsumed());
     EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -410,11 +375,29 @@ class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
   scoped_ptr<CertVerifier> cert_verifier_;
   scoped_ptr<ChannelIDService> channel_id_service_;
   TransportSecurityState transport_security_state_;
-  QuicStreamFactory factory_;
+  scoped_ptr<QuicStreamFactory> factory_;
   HostPortPair host_port_pair_;
   PrivacyMode privacy_mode_;
   BoundNetLog net_log_;
   TestCompletionCallback callback_;
+
+  // Variables to configure QuicStreamFactory.
+  bool enable_port_selection_;
+  bool always_require_handshake_confirmation_;
+  bool disable_connection_pooling_;
+  double load_server_info_timeout_srtt_multiplier_;
+  bool enable_connection_racing_;
+  bool enable_non_blocking_io_;
+  bool disable_disk_cache_;
+  bool prefer_aes_;
+  int max_number_of_lossy_connections_;
+  double packet_loss_threshold_;
+  int max_disabled_reasons_;
+  int threshold_timeouts_with_open_streams_;
+  int threshold_public_resets_post_handshake_;
+  int receive_buffer_size_;
+  bool delay_tcp_race_;
+  bool store_server_configs_in_properties_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version,
@@ -422,6 +405,8 @@ INSTANTIATE_TEST_CASE_P(Version,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(QuicStreamFactoryTest, Create) {
+  Initialize();
+
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -429,7 +414,7 @@ TEST_P(QuicStreamFactoryTest, Create) {
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -445,7 +430,7 @@ TEST_P(QuicStreamFactoryTest, Create) {
 
   // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
   // in streams on different sessions.
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK,
             request2.Request(host_port_pair_, privacy_mode_,
                              /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -458,6 +443,8 @@ TEST_P(QuicStreamFactoryTest, Create) {
 }
 
 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
+  Initialize();
+
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -471,7 +458,7 @@ TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
@@ -483,6 +470,8 @@ TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
 }
 
 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
+  Initialize();
+
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -496,7 +485,7 @@ TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   // Posts require handshake confirmation, so this will return asynchronously.
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
@@ -515,6 +504,8 @@ TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
 }
 
 TEST_P(QuicStreamFactoryTest, NoZeroRttForDifferentHost) {
+  Initialize();
+
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0),
   };
@@ -528,7 +519,7 @@ TEST_P(QuicStreamFactoryTest, NoZeroRttForDifferentHost) {
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   int rv = request.Request(
       host_port_pair_, privacy_mode_, /*cert_verify_flags=*/0,
       "different.host.example.com", "GET", net_log_, callback_.callback());
@@ -547,6 +538,8 @@ TEST_P(QuicStreamFactoryTest, NoZeroRttForDifferentHost) {
 }
 
 TEST_P(QuicStreamFactoryTest, GoAway) {
+  Initialize();
+
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -554,7 +547,7 @@ TEST_P(QuicStreamFactoryTest, GoAway) {
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -565,18 +558,20 @@ TEST_P(QuicStreamFactoryTest, GoAway) {
   EXPECT_TRUE(stream.get());
 
   QuicChromiumClientSession* session =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
 
   session->OnGoAway(QuicGoAwayFrame());
 
   EXPECT_FALSE(
-      QuicStreamFactoryPeer::HasActiveSession(&factory_, host_port_pair_));
+      QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, Pooling) {
+  Initialize();
+
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -591,7 +586,7 @@ TEST_P(QuicStreamFactoryTest, Pooling) {
   host_resolver_.rules()->AddIPLiteralRule(
       "mail.google.com", "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
@@ -599,21 +594,25 @@ TEST_P(QuicStreamFactoryTest, Pooling) {
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_),
-            QuicStreamFactoryPeer::GetActiveSession(&factory_, server2));
+  EXPECT_EQ(
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_),
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, NoPoolingIfDisabled) {
+  disable_connection_pooling_ = true;
+  Initialize();
+
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -631,10 +630,7 @@ TEST_P(QuicStreamFactoryTest, NoPoolingIfDisabled) {
   host_resolver_.rules()->AddIPLiteralRule(
       "mail.google.com", "192.168.0.1", "");
 
-  // Disable connection pooling.
-  QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
-
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
@@ -642,15 +638,16 @@ TEST_P(QuicStreamFactoryTest, NoPoolingIfDisabled) {
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_),
-            QuicStreamFactoryPeer::GetActiveSession(&factory_, server2));
+  EXPECT_NE(
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_),
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
@@ -659,6 +656,8 @@ TEST_P(QuicStreamFactoryTest, NoPoolingIfDisabled) {
 }
 
 TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
+  Initialize();
+
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -676,7 +675,7 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
   host_resolver_.rules()->AddIPLiteralRule(
       "mail.google.com", "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
@@ -684,28 +683,29 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  factory_.OnSessionGoingAway(
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_));
+  factory_->OnSessionGoingAway(
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_));
+  EXPECT_FALSE(
+      QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
   EXPECT_FALSE(
-      QuicStreamFactoryPeer::HasActiveSession(&factory_, host_port_pair_));
-  EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(&factory_, server2));
+      QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server2));
 
   TestCompletionCallback callback3;
-  QuicStreamRequest request3(&factory_);
+  QuicStreamRequest request3(factory_.get());
   EXPECT_EQ(OK, request3.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback3.callback()));
   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
   EXPECT_TRUE(stream3.get());
 
-  EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(&factory_, server2));
+  EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server2));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
@@ -714,6 +714,7 @@ TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
 }
 
 TEST_P(QuicStreamFactoryTest, HttpsPooling) {
+  Initialize();
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -731,7 +732,7 @@ TEST_P(QuicStreamFactoryTest, HttpsPooling) {
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
                                 /*cert_verify_flags=*/0, server1.host(), "GET",
                                 net_log_, callback_.callback()));
@@ -739,21 +740,24 @@ TEST_P(QuicStreamFactoryTest, HttpsPooling) {
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(&factory_, server1),
-            QuicStreamFactoryPeer::GetActiveSession(&factory_, server2));
+  EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
+            QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) {
+  disable_connection_pooling_ = true;
+  Initialize();
+
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -774,10 +778,7 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) {
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
-  // Disable connection pooling.
-  QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
-
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
                                 /*cert_verify_flags=*/0, server1.host(), "GET",
                                 net_log_, callback_.callback()));
@@ -785,15 +786,15 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) {
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(&factory_, server1),
-            QuicStreamFactoryPeer::GetActiveSession(&factory_, server2));
+  EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
+            QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
@@ -833,14 +834,14 @@ class QuicAlternativeServiceCertificateValidationPooling
                                              "");
 
     // Open first stream to alternative.
-    QuicStreamRequest request1(&factory_);
+    QuicStreamRequest request1(factory_.get());
     EXPECT_EQ(OK, request1.Request(alternative, privacy_mode_,
                                    /*cert_verify_flags=*/0, alternative.host(),
                                    "GET", net_log_, callback_.callback()));
     scoped_ptr<QuicHttpStream> stream1 = request1.ReleaseStream();
     EXPECT_TRUE(stream1.get());
 
-    QuicStreamRequest request2(&factory_);
+    QuicStreamRequest request2(factory_.get());
     int rv = request2.Request(alternative, privacy_mode_,
                               /*cert_verify_flags=*/0, origin_host, "GET",
                               net_log_, callback_.callback());
@@ -866,14 +867,17 @@ INSTANTIATE_TEST_CASE_P(Version,
                         ::testing::ValuesIn(GetTestParams()));
 
 TEST_P(QuicAlternativeServiceCertificateValidationPooling, Valid) {
+  Initialize();
   Run(true);
 }
 
 TEST_P(QuicAlternativeServiceCertificateValidationPooling, Invalid) {
+  Initialize();
   Run(false);
 }
 
 TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
+  Initialize();
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -897,7 +901,7 @@ TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
                                 /*cert_verify_flags=*/0, server1.host(), "GET",
                                 net_log_, callback_.callback()));
@@ -905,21 +909,24 @@ TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(&factory_, server1),
-            QuicStreamFactoryPeer::GetActiveSession(&factory_, server2));
+  EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
+            QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) {
+  disable_connection_pooling_ = true;
+  Initialize();
+
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -946,10 +953,7 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) {
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
-  // Disable connection pooling.
-  QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
-
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
                                 /*cert_verify_flags=*/0, server1.host(), "GET",
                                 net_log_, callback_.callback()));
@@ -957,15 +961,15 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) {
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(&factory_, server1),
-            QuicStreamFactoryPeer::GetActiveSession(&factory_, server2));
+  EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
+            QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
@@ -974,6 +978,7 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) {
 }
 
 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
+  Initialize();
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -1006,7 +1011,7 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
                                 /*cert_verify_flags=*/0, server1.host(), "GET",
                                 net_log_, callback_.callback()));
@@ -1014,15 +1019,15 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
   EXPECT_TRUE(stream.get());
 
   TestCompletionCallback callback;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(&factory_, server1),
-            QuicStreamFactoryPeer::GetActiveSession(&factory_, server2));
+  EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
+            QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
 
   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
@@ -1031,6 +1036,7 @@ TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
 }
 
 TEST_P(QuicStreamFactoryTest, Goaway) {
+  Initialize();
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -1041,7 +1047,7 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
   socket_data2.StopAfter(1);
   socket_factory_.AddSocketDataProvider(&socket_data2);
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1054,16 +1060,17 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
   // Mark the session as going away.  Ensure that while it is still alive
   // that it is no longer active.
   QuicChromiumClientSession* session =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_);
-  factory_.OnSessionGoingAway(session);
-  EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
+  factory_->OnSessionGoingAway(session);
+  EXPECT_EQ(true,
+            QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
   EXPECT_FALSE(
-      QuicStreamFactoryPeer::HasActiveSession(&factory_, host_port_pair_));
+      QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
   EXPECT_FALSE(HasActiveSession(host_port_pair_));
 
   // Create a new request for the same destination and verify that a
   // new session is created.
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(host_port_pair_, privacy_mode_,
                              /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1073,10 +1080,11 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
   EXPECT_TRUE(stream2.get());
 
   EXPECT_TRUE(
-      QuicStreamFactoryPeer::HasActiveSession(&factory_, host_port_pair_));
-  EXPECT_NE(session, QuicStreamFactoryPeer::GetActiveSession(&factory_,
+      QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
+  EXPECT_NE(session, QuicStreamFactoryPeer::GetActiveSession(factory_.get(),
                                                              host_port_pair_));
-  EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
+  EXPECT_EQ(true,
+            QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
 
   stream2.reset();
   stream.reset();
@@ -1088,6 +1096,7 @@ TEST_P(QuicStreamFactoryTest, Goaway) {
 }
 
 TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
+  Initialize();
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
@@ -1107,7 +1116,7 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
   // The MockCryptoClientStream sets max_open_streams to be
   // kDefaultMaxStreamsPerConnection / 2.
   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection / 2; i++) {
-    QuicStreamRequest request(&factory_);
+    QuicStreamRequest request(factory_.get());
     int rv = request.Request(host_port_pair_, privacy_mode_,
                              /*cert_verify_flags=*/0, host_port_pair_.host(),
                              "GET", net_log_, callback_.callback());
@@ -1124,7 +1133,7 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
     streams.push_back(stream.release());
   }
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, CompletionCallback()));
@@ -1146,12 +1155,13 @@ TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
 }
 
 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
+  Initialize();
   DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName);
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1164,13 +1174,14 @@ TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
 }
 
 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
+  Initialize();
   MockConnect connect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
   DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
   socket_data.set_connect_data(connect);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1183,13 +1194,14 @@ TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
 }
 
 TEST_P(QuicStreamFactoryTest, CancelCreate) {
+  Initialize();
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   {
-    QuicStreamRequest request(&factory_);
+    QuicStreamRequest request(factory_.get());
     EXPECT_EQ(ERR_IO_PENDING,
               request.Request(host_port_pair_, privacy_mode_,
                               /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1209,6 +1221,8 @@ TEST_P(QuicStreamFactoryTest, CancelCreate) {
 }
 
 TEST_P(QuicStreamFactoryTest, CreateConsistentEphemeralPort) {
+  Initialize();
+
   // Sequentially connect to the default host, then another host, and then the
   // default host.  Verify that the default host gets a consistent ephemeral
   // port, that is different from the other host's connection.
@@ -1223,6 +1237,8 @@ TEST_P(QuicStreamFactoryTest, CreateConsistentEphemeralPort) {
 }
 
 TEST_P(QuicStreamFactoryTest, GoAwayDisablesConsistentEphemeralPort) {
+  Initialize();
+
   // Get a session to the host using the port suggester.
   int original_port =
       GetSourcePortForNewSessionAndGoAway(host_port_pair_);
@@ -1233,6 +1249,7 @@ TEST_P(QuicStreamFactoryTest, GoAwayDisablesConsistentEphemeralPort) {
 }
 
 TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
+  Initialize();
   MockRead reads[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
@@ -1252,7 +1269,7 @@ TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1266,14 +1283,14 @@ TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
                                          net_log_, CompletionCallback()));
 
   // Close the session and verify that stream saw the error.
-  factory_.CloseAllSessions(ERR_INTERNET_DISCONNECTED);
+  factory_->CloseAllSessions(ERR_INTERNET_DISCONNECTED);
   EXPECT_EQ(ERR_INTERNET_DISCONNECTED,
             stream->ReadResponseHeaders(callback_.callback()));
 
   // Now attempting to request a stream to the same origin should create
   // a new session.
 
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(host_port_pair_, privacy_mode_,
                              /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1290,6 +1307,7 @@ TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
 }
 
 TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
+  Initialize();
   MockRead reads[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
@@ -1309,7 +1327,7 @@ TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1323,15 +1341,15 @@ TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
                                          net_log_, CompletionCallback()));
 
   // Change the IP address and verify that stream saw the error.
-  factory_.OnIPAddressChanged();
+  factory_->OnIPAddressChanged();
   EXPECT_EQ(ERR_NETWORK_CHANGED,
             stream->ReadResponseHeaders(callback_.callback()));
-  EXPECT_TRUE(factory_.require_confirmation());
+  EXPECT_TRUE(factory_->require_confirmation());
 
   // Now attempting to request a stream to the same origin should create
   // a new session.
 
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(host_port_pair_, privacy_mode_,
                              /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1348,6 +1366,7 @@ TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
 }
 
 TEST_P(QuicStreamFactoryTest, OnSSLConfigChanged) {
+  Initialize();
   MockRead reads[] = {
       MockRead(ASYNC, 0, 0)  // EOF
   };
@@ -1367,7 +1386,7 @@ TEST_P(QuicStreamFactoryTest, OnSSLConfigChanged) {
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1379,15 +1398,15 @@ TEST_P(QuicStreamFactoryTest, OnSSLConfigChanged) {
   EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
                                          net_log_, CompletionCallback()));
 
-  factory_.OnSSLConfigChanged();
+  factory_->OnSSLConfigChanged();
   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
             stream->ReadResponseHeaders(callback_.callback()));
-  EXPECT_FALSE(factory_.require_confirmation());
+  EXPECT_FALSE(factory_->require_confirmation());
 
   // Now attempting to request a stream to the same origin should create
   // a new session.
 
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(host_port_pair_, privacy_mode_,
                              /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1404,6 +1423,7 @@ TEST_P(QuicStreamFactoryTest, OnSSLConfigChanged) {
 }
 
 TEST_P(QuicStreamFactoryTest, OnCertAdded) {
+  Initialize();
   MockRead reads[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
@@ -1423,7 +1443,7 @@ TEST_P(QuicStreamFactoryTest, OnCertAdded) {
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1437,15 +1457,15 @@ TEST_P(QuicStreamFactoryTest, OnCertAdded) {
                                          net_log_, CompletionCallback()));
 
   // Add a cert and verify that stream saw the event.
-  factory_.OnCertAdded(nullptr);
+  factory_->OnCertAdded(nullptr);
   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
             stream->ReadResponseHeaders(callback_.callback()));
-  EXPECT_FALSE(factory_.require_confirmation());
+  EXPECT_FALSE(factory_->require_confirmation());
 
   // Now attempting to request a stream to the same origin should create
   // a new session.
 
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(host_port_pair_, privacy_mode_,
                              /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1462,6 +1482,7 @@ TEST_P(QuicStreamFactoryTest, OnCertAdded) {
 }
 
 TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
+  Initialize();
   MockRead reads[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
@@ -1481,7 +1502,7 @@ TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
   socket_factory_.AddSocketDataProvider(&socket_data2);
   socket_data2.StopAfter(1);
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1495,15 +1516,15 @@ TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
                                          net_log_, CompletionCallback()));
 
   // Change the CA cert and verify that stream saw the event.
-  factory_.OnCACertChanged(nullptr);
+  factory_->OnCACertChanged(nullptr);
   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
             stream->ReadResponseHeaders(callback_.callback()));
-  EXPECT_FALSE(factory_.require_confirmation());
+  EXPECT_FALSE(factory_->require_confirmation());
 
   // Now attempting to request a stream to the same origin should create
   // a new session.
 
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(host_port_pair_, privacy_mode_,
                              /*cert_verify_flags=*/0, host_port_pair_.host(),
@@ -1520,6 +1541,7 @@ TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
 }
 
 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) {
+  Initialize();
   vector<string> cannoncial_suffixes;
   cannoncial_suffixes.push_back(string(".c.youtube.com"));
   cannoncial_suffixes.push_back(string(".googlevideo.com"));
@@ -1532,7 +1554,7 @@ TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) {
 
     HostPortPair host_port_pair1(r1_host_name, 80);
     QuicCryptoClientConfig* crypto_config =
-        QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
+        QuicStreamFactoryPeer::GetCryptoConfig(factory_.get());
     QuicServerId server_id1(host_port_pair1, /*is_https=*/true, privacy_mode_);
     QuicCryptoClientConfig::CachedState* cached1 =
         crypto_config->LookupOrCreate(server_id1);
@@ -1554,6 +1576,7 @@ TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) {
 }
 
 TEST_P(QuicStreamFactoryTest, CryptoConfigWhenProofIsInvalid) {
+  Initialize();
   vector<string> cannoncial_suffixes;
   cannoncial_suffixes.push_back(string(".c.youtube.com"));
   cannoncial_suffixes.push_back(string(".googlevideo.com"));
@@ -1566,7 +1589,7 @@ TEST_P(QuicStreamFactoryTest, CryptoConfigWhenProofIsInvalid) {
 
     HostPortPair host_port_pair1(r3_host_name, 80);
     QuicCryptoClientConfig* crypto_config =
-        QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
+        QuicStreamFactoryPeer::GetCryptoConfig(factory_.get());
     QuicServerId server_id1(host_port_pair1, /*is_https=*/true, privacy_mode_);
     QuicCryptoClientConfig::CachedState* cached1 =
         crypto_config->LookupOrCreate(server_id1);
@@ -1589,10 +1612,13 @@ TEST_P(QuicStreamFactoryTest, CryptoConfigWhenProofIsInvalid) {
 }
 
 TEST_P(QuicStreamFactoryTest, RacingConnections) {
+  disable_disk_cache_ = false;
+  Initialize();
+
   if (!GetParam().enable_connection_racing)
     return;
-  QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, false);
-  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
+
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
 
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
@@ -1624,14 +1650,14 @@ TEST_P(QuicStreamFactoryTest, RacingConnections) {
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   QuicServerId server_id(host_port_pair_, /*is_https=*/true, privacy_mode_);
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
                             "GET", net_log_, callback_.callback()));
-  EXPECT_EQ(2u,
-            QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
+  EXPECT_EQ(2u, QuicStreamFactoryPeer::GetNumberOfActiveJobs(factory_.get(),
+                                                             server_id));
 
   runner_->RunNextTask();
 
@@ -1639,13 +1665,14 @@ TEST_P(QuicStreamFactoryTest, RacingConnections) {
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
-  EXPECT_EQ(0u,
-            QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
+  EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumberOfActiveJobs(factory_.get(),
+                                                             server_id));
 }
 
 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
-  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
+  disable_disk_cache_ = true;
+  Initialize();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
 
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
@@ -1660,7 +1687,7 @@ TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
@@ -1676,13 +1703,15 @@ TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
 }
 
 TEST_P(QuicStreamFactoryTest, BadPacketLoss) {
-  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
-  QuicStreamFactoryPeer::SetMaxNumberOfLossyConnections(&factory_, 2);
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  disable_disk_cache_ = false;
+  max_number_of_lossy_connections_ = 2;
+  Initialize();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
+
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, host_port_pair_.port()));
+                   factory_.get(), host_port_pair_.port()));
 
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
@@ -1716,112 +1745,116 @@ TEST_P(QuicStreamFactoryTest, BadPacketLoss) {
   host_resolver_.rules()->AddIPLiteralRule(server3.host(), "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server4.host(), "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
 
   QuicChromiumClientSession* session =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
 
   DVLOG(1) << "Create 1st session and test packet loss";
 
   // Set packet_loss_rate to a lower value than packet_loss_threshold.
   EXPECT_FALSE(
-      factory_.OnHandshakeConfirmed(session, /*packet_loss_rate=*/0.9f));
+      factory_->OnHandshakeConfirmed(session, /*packet_loss_rate=*/0.9f));
   EXPECT_TRUE(session->connection()->connected());
   EXPECT_TRUE(
-      QuicStreamFactoryPeer::HasActiveSession(&factory_, host_port_pair_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+      QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, host_port_pair_.port()));
+                   factory_.get(), host_port_pair_.port()));
 
   // Set packet_loss_rate to a higher value than packet_loss_threshold only once
   // and that shouldn't close the session and it shouldn't disable QUIC.
   EXPECT_FALSE(
-      factory_.OnHandshakeConfirmed(session, /*packet_loss_rate=*/1.0f));
+      factory_->OnHandshakeConfirmed(session, /*packet_loss_rate=*/1.0f));
   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, host_port_pair_.port()));
+                   factory_.get(), host_port_pair_.port()));
   EXPECT_TRUE(session->connection()->connected());
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
   EXPECT_TRUE(
-      QuicStreamFactoryPeer::HasActiveSession(&factory_, host_port_pair_));
+      QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
 
   // Test N-in-a-row high packet loss connections.
 
   DVLOG(1) << "Create 2nd session and test packet loss";
 
   TestCompletionCallback callback2;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback2.callback()));
   QuicChromiumClientSession* session2 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server2);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2);
 
   // If there is no packet loss during handshake confirmation, number of lossy
   // connections for the port should be 0.
   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, server2.port()));
+                   factory_.get(), server2.port()));
   EXPECT_FALSE(
-      factory_.OnHandshakeConfirmed(session2, /*packet_loss_rate=*/0.9f));
+      factory_->OnHandshakeConfirmed(session2, /*packet_loss_rate=*/0.9f));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, server2.port()));
+                   factory_.get(), server2.port()));
   EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server2.port()));
+      QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), server2.port()));
 
   // Set packet_loss_rate to a higher value than packet_loss_threshold only once
   // and that shouldn't close the session and it shouldn't disable QUIC.
   EXPECT_FALSE(
-      factory_.OnHandshakeConfirmed(session2, /*packet_loss_rate=*/1.0f));
+      factory_->OnHandshakeConfirmed(session2, /*packet_loss_rate=*/1.0f));
   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, server2.port()));
+                   factory_.get(), server2.port()));
   EXPECT_TRUE(session2->connection()->connected());
   EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server2.port()));
-  EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(&factory_, server2));
+      QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), server2.port()));
+  EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server2));
 
   DVLOG(1) << "Create 3rd session which also has packet loss";
 
   TestCompletionCallback callback3;
-  QuicStreamRequest request3(&factory_);
+  QuicStreamRequest request3(factory_.get());
   EXPECT_EQ(OK, request3.Request(server3, privacy_mode_,
                                  /*cert_verify_flags=*/0, server3.host(), "GET",
                                  net_log_, callback3.callback()));
   QuicChromiumClientSession* session3 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server3);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server3);
 
   DVLOG(1) << "Create 4th session with packet loss and test IsQuicDisabled()";
   TestCompletionCallback callback4;
-  QuicStreamRequest request4(&factory_);
+  QuicStreamRequest request4(factory_.get());
   EXPECT_EQ(OK, request4.Request(server4, privacy_mode_,
                                  /*cert_verify_flags=*/0, server4.host(), "GET",
                                  net_log_, callback4.callback()));
   QuicChromiumClientSession* session4 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server4);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server4);
 
   // Set packet_loss_rate to higher value than packet_loss_threshold 2nd time in
   // a row and that should close the session and disable QUIC.
   EXPECT_TRUE(
-      factory_.OnHandshakeConfirmed(session3, /*packet_loss_rate=*/1.0f));
+      factory_->OnHandshakeConfirmed(session3, /*packet_loss_rate=*/1.0f));
   EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, server3.port()));
+                   factory_.get(), server3.port()));
   EXPECT_FALSE(session3->connection()->connected());
-  EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server3.port()));
-  EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(&factory_, server3));
+  EXPECT_TRUE(
+      QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), server3.port()));
+  EXPECT_FALSE(
+      QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server3));
   EXPECT_FALSE(HasActiveSession(server3));
 
   // Set packet_loss_rate to higher value than packet_loss_threshold 3rd time in
   // a row and IsQuicDisabled() should close the session.
   EXPECT_TRUE(
-      factory_.OnHandshakeConfirmed(session4, /*packet_loss_rate=*/1.0f));
+      factory_->OnHandshakeConfirmed(session4, /*packet_loss_rate=*/1.0f));
   EXPECT_EQ(3, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, server4.port()));
+                   factory_.get(), server4.port()));
   EXPECT_FALSE(session4->connection()->connected());
-  EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server4.port()));
-  EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(&factory_, server4));
+  EXPECT_TRUE(
+      QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), server4.port()));
+  EXPECT_FALSE(
+      QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server4));
   EXPECT_FALSE(HasActiveSession(server4));
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
@@ -1843,13 +1876,15 @@ TEST_P(QuicStreamFactoryTest, BadPacketLoss) {
 }
 
 TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfTwo) {
-  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
-  QuicStreamFactoryPeer::SetThresholdPublicResetsPostHandshake(&factory_, 2);
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  disable_disk_cache_ = false;
+  threshold_public_resets_post_handshake_ = 2;
+  Initialize();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
+
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, host_port_pair_.port()));
+                   factory_.get(), host_port_pair_.port()));
 
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
@@ -1871,13 +1906,13 @@ TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfTwo) {
                                            "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
 
   QuicChromiumClientSession* session =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
 
   DVLOG(1) << "Created 1st session. Now trigger public reset post handshake";
   session->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
@@ -1886,33 +1921,33 @@ TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfTwo) {
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 
-  EXPECT_EQ(1,
-            QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
+                   factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   // Test two-in-a-row public reset post handshakes..
   DVLOG(1) << "Create 2nd session and trigger public reset post handshake";
   TestCompletionCallback callback2;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback2.callback()));
   QuicChromiumClientSession* session2 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server2);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2);
 
   session2->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
   // Need to spin the loop now to ensure that
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop2;
   run_loop2.RunUntilIdle();
-  EXPECT_EQ(2,
-            QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
-  EXPECT_TRUE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
+                   factory_.get()));
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                    host_port_pair_.port()));
   EXPECT_EQ(
       QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE,
-      factory_.QuicDisabledReason(host_port_pair_.port()));
+      factory_->QuicDisabledReason(host_port_pair_.port()));
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
@@ -1925,13 +1960,15 @@ TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfTwo) {
 }
 
 TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfTwo) {
-  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
-  QuicStreamFactoryPeer::SetThresholdTimeoutsWithOpenStreams(&factory_, 2);
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  disable_disk_cache_ = true;
+  threshold_timeouts_with_open_streams_ = 2;
+  Initialize();
+
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, host_port_pair_.port()));
+                   factory_.get(), host_port_pair_.port()));
 
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
@@ -1953,13 +1990,13 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfTwo) {
                                            "192.168.0.1", "");
   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
 
   QuicChromiumClientSession* session =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
@@ -1975,19 +2012,20 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfTwo) {
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 
-  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(
+      1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   // Test two-in-a-row timeouts with open streams.
   DVLOG(1) << "Create 2nd session and timeout with open stream";
   TestCompletionCallback callback2;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback2.callback()));
   QuicChromiumClientSession* session2 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server2);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2);
 
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
@@ -1999,11 +2037,12 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfTwo) {
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop2;
   run_loop2.RunUntilIdle();
-  EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
-  EXPECT_TRUE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(
+      2, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                    host_port_pair_.port()));
   EXPECT_EQ(QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS,
-            factory_.QuicDisabledReason(host_port_pair_.port()));
+            factory_->QuicDisabledReason(host_port_pair_.port()));
 
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
@@ -2012,12 +2051,14 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfTwo) {
 }
 
 TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfThree) {
-  QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
-  QuicStreamFactoryPeer::SetThresholdPublicResetsPostHandshake(&factory_, 2);
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  disable_disk_cache_ = true;
+  threshold_public_resets_post_handshake_ = 2;
+  Initialize();
+
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, host_port_pair_.port()));
+                   factory_.get(), host_port_pair_.port()));
 
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
@@ -2046,13 +2087,13 @@ TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfThree) {
   host_resolver_.rules()->AddIPLiteralRule(server3.host(), "192.168.0.1", "");
 
   // Test first and third out of three public reset post handshakes.
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
 
   QuicChromiumClientSession* session =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
 
   DVLOG(1) << "Created 1st session. Now trigger public reset post handshake";
   session->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
@@ -2061,52 +2102,52 @@ TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfThree) {
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 
-  EXPECT_EQ(1,
-            QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
+                   factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   DVLOG(1) << "Create 2nd session without disable trigger";
   TestCompletionCallback callback2;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback2.callback()));
   QuicChromiumClientSession* session2 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server2);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2);
 
   session2->connection()->CloseConnection(QUIC_NO_ERROR, false);
   // Need to spin the loop now to ensure that
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop2;
   run_loop2.RunUntilIdle();
-  EXPECT_EQ(1,
-            QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
+                   factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   DVLOG(1) << "Create 3rd session with public reset post handshake,"
            << " will disable QUIC";
   TestCompletionCallback callback3;
-  QuicStreamRequest request3(&factory_);
+  QuicStreamRequest request3(factory_.get());
   EXPECT_EQ(OK, request3.Request(server3, privacy_mode_,
                                  /*cert_verify_flags=*/0, server3.host(), "GET",
                                  net_log_, callback3.callback()));
   QuicChromiumClientSession* session3 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server3);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server3);
 
   session3->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
   // Need to spin the loop now to ensure that
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop3;
   run_loop3.RunUntilIdle();
-  EXPECT_EQ(2,
-            QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
-  EXPECT_TRUE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
+                   factory_.get()));
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                    host_port_pair_.port()));
   EXPECT_EQ(
       QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE,
-      factory_.QuicDisabledReason(host_port_pair_.port()));
+      factory_->QuicDisabledReason(host_port_pair_.port()));
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
@@ -2124,13 +2165,15 @@ TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfThree) {
 }
 
 TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfThree) {
-  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
-  QuicStreamFactoryPeer::SetThresholdTimeoutsWithOpenStreams(&factory_, 2);
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  disable_disk_cache_ = true;
+  threshold_public_resets_post_handshake_ = 2;
+  Initialize();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
+
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, host_port_pair_.port()));
+                   factory_.get(), host_port_pair_.port()));
 
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
@@ -2160,13 +2203,13 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfThree) {
   host_resolver_.rules()->AddIPLiteralRule(server3.host(), "192.168.0.1", "");
 
   // Test first and third out of three timeouts with open streams.
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
 
   QuicChromiumClientSession* session =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
@@ -2182,39 +2225,41 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfThree) {
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 
-  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(
+      1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   // Test two-in-a-row timeouts with open streams.
   DVLOG(1) << "Create 2nd session without timeout";
   TestCompletionCallback callback2;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback2.callback()));
   QuicChromiumClientSession* session2 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server2);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2);
 
   session2->connection()->CloseConnection(QUIC_NO_ERROR, true);
   // Need to spin the loop now to ensure that
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop2;
   run_loop2.RunUntilIdle();
-  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(
+      1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   DVLOG(1) << "Create 3rd session with timeout with open streams,"
            << " will disable QUIC";
 
   TestCompletionCallback callback3;
-  QuicStreamRequest request3(&factory_);
+  QuicStreamRequest request3(factory_.get());
   EXPECT_EQ(OK, request3.Request(server3, privacy_mode_,
                                  /*cert_verify_flags=*/0, server3.host(), "GET",
                                  net_log_, callback3.callback()));
   QuicChromiumClientSession* session3 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server3);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server3);
 
   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
   EXPECT_TRUE(stream3.get());
@@ -2225,11 +2270,12 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfThree) {
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop3;
   run_loop3.RunUntilIdle();
-  EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
-  EXPECT_TRUE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(
+      2, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
+  EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                    host_port_pair_.port()));
   EXPECT_EQ(QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS,
-            factory_.QuicDisabledReason(host_port_pair_.port()));
+            factory_->QuicDisabledReason(host_port_pair_.port()));
 
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
@@ -2242,13 +2288,15 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfThree) {
 }
 
 TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfFour) {
-  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
-  QuicStreamFactoryPeer::SetThresholdPublicResetsPostHandshake(&factory_, 2);
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  disable_disk_cache_ = true;
+  threshold_public_resets_post_handshake_ = 2;
+  Initialize();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
+
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, host_port_pair_.port()));
+                   factory_.get(), host_port_pair_.port()));
 
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
@@ -2283,13 +2331,13 @@ TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfFour) {
   host_resolver_.rules()->AddIPLiteralRule(server4.host(), "192.168.0.1", "");
 
   // Test first and fourth out of four public reset post handshakes.
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
 
   QuicChromiumClientSession* session =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
 
   DVLOG(1) << "Created 1st session. Now trigger public reset post handshake";
   session->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
@@ -2298,67 +2346,67 @@ TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfFour) {
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 
-  EXPECT_EQ(1,
-            QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
+                   factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   DVLOG(1) << "Create 2nd and 3rd sessions without disable trigger";
   TestCompletionCallback callback2;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback2.callback()));
   QuicChromiumClientSession* session2 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server2);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2);
 
   session2->connection()->CloseConnection(QUIC_NO_ERROR, false);
   // Need to spin the loop now to ensure that
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop2;
   run_loop2.RunUntilIdle();
-  EXPECT_EQ(1,
-            QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
+                   factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   TestCompletionCallback callback3;
-  QuicStreamRequest request3(&factory_);
+  QuicStreamRequest request3(factory_.get());
   EXPECT_EQ(OK, request3.Request(server3, privacy_mode_,
                                  /*cert_verify_flags=*/0, server3.host(), "GET",
                                  net_log_, callback3.callback()));
   QuicChromiumClientSession* session3 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server3);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server3);
 
   session3->connection()->CloseConnection(QUIC_NO_ERROR, false);
   // Need to spin the loop now to ensure that
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop3;
   run_loop3.RunUntilIdle();
-  EXPECT_EQ(1,
-            QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
+                   factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   DVLOG(1) << "Create 4rd session with public reset post handshake,"
            << " will not disable QUIC";
   TestCompletionCallback callback4;
-  QuicStreamRequest request4(&factory_);
+  QuicStreamRequest request4(factory_.get());
   EXPECT_EQ(OK, request4.Request(server4, privacy_mode_,
                                  /*cert_verify_flags=*/0, server4.host(), "GET",
                                  net_log_, callback4.callback()));
   QuicChromiumClientSession* session4 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server4);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server4);
 
   session4->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
   // Need to spin the loop now to ensure that
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop4;
   run_loop4.RunUntilIdle();
-  EXPECT_EQ(1,
-            QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
+                   factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
@@ -2380,13 +2428,15 @@ TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfFour) {
 }
 
 TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfFour) {
-  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
-  QuicStreamFactoryPeer::SetThresholdTimeoutsWithOpenStreams(&factory_, 2);
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  disable_disk_cache_ = true;
+  threshold_public_resets_post_handshake_ = 2;
+  Initialize();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
+
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
-                   &factory_, host_port_pair_.port()));
+                   factory_.get(), host_port_pair_.port()));
 
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
@@ -2422,13 +2472,13 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfFour) {
   host_resolver_.rules()->AddIPLiteralRule(server4.host(), "192.168.0.1", "");
 
   // Test first and fourth out of three timeouts with open streams.
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
 
   QuicChromiumClientSession* session =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair_);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
@@ -2444,55 +2494,58 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfFour) {
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 
-  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(
+      1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   DVLOG(1) << "Create 2nd and 3rd sessions without timeout";
   TestCompletionCallback callback2;
-  QuicStreamRequest request2(&factory_);
+  QuicStreamRequest request2(factory_.get());
   EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
                                  /*cert_verify_flags=*/0, server2.host(), "GET",
                                  net_log_, callback2.callback()));
   QuicChromiumClientSession* session2 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server2);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2);
 
   session2->connection()->CloseConnection(QUIC_NO_ERROR, true);
   // Need to spin the loop now to ensure that
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop2;
   run_loop2.RunUntilIdle();
-  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(
+      1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   TestCompletionCallback callback3;
-  QuicStreamRequest request3(&factory_);
+  QuicStreamRequest request3(factory_.get());
   EXPECT_EQ(OK, request3.Request(server3, privacy_mode_,
                                  /*cert_verify_flags=*/0, server3.host(), "GET",
                                  net_log_, callback3.callback()));
   QuicChromiumClientSession* session3 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server3);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server3);
 
   session3->connection()->CloseConnection(QUIC_NO_ERROR, true);
   // Need to spin the loop now to ensure that
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop3;
   run_loop3.RunUntilIdle();
-  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(
+      1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   DVLOG(1) << "Create 4th session with timeout with open streams,"
            << " will not disable QUIC";
 
   TestCompletionCallback callback4;
-  QuicStreamRequest request4(&factory_);
+  QuicStreamRequest request4(factory_.get());
   EXPECT_EQ(OK, request4.Request(server4, privacy_mode_,
                                  /*cert_verify_flags=*/0, server4.host(), "GET",
                                  net_log_, callback4.callback()));
   QuicChromiumClientSession* session4 =
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server4);
+      QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server4);
 
   scoped_ptr<QuicHttpStream> stream4 = request4.ReleaseStream();
   EXPECT_TRUE(stream4.get());
@@ -2503,9 +2556,10 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfFour) {
   // QuicStreamFactory::OnSessionClosed() runs.
   base::RunLoop run_loop4;
   run_loop4.RunUntilIdle();
-  EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
-  EXPECT_FALSE(
-      QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
+  EXPECT_EQ(
+      1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
+  EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
+                                                     host_port_pair_.port()));
 
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
@@ -2522,8 +2576,9 @@ TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfFour) {
 }
 
 TEST_P(QuicStreamFactoryTest, EnableDelayTcpRace) {
-  bool delay_tcp_race = QuicStreamFactoryPeer::GetDelayTcpRace(&factory_);
-  QuicStreamFactoryPeer::SetDelayTcpRace(&factory_, false);
+  Initialize();
+  bool delay_tcp_race = QuicStreamFactoryPeer::GetDelayTcpRace(factory_.get());
+  QuicStreamFactoryPeer::SetDelayTcpRace(factory_.get(), false);
   MockRead reads[] = {
       MockRead(ASYNC, OK, 0),
   };
@@ -2541,20 +2596,20 @@ TEST_P(QuicStreamFactoryTest, EnableDelayTcpRace) {
   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
                                            "192.168.0.1", "");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_pair_, privacy_mode_,
                             /*cert_verify_flags=*/0, host_port_pair_.host(),
                             "POST", net_log_, callback_.callback()));
 
   // If we don't delay TCP connection, then time delay should be 0.
-  EXPECT_FALSE(factory_.delay_tcp_race());
+  EXPECT_FALSE(factory_->delay_tcp_race());
   EXPECT_EQ(base::TimeDelta(), request.GetTimeDelayForWaitingJob());
 
   // Enable |delay_tcp_race_| param and verify delay is one RTT and that
   // server supports QUIC.
-  QuicStreamFactoryPeer::SetDelayTcpRace(&factory_, true);
-  EXPECT_TRUE(factory_.delay_tcp_race());
+  QuicStreamFactoryPeer::SetDelayTcpRace(factory_.get(), true);
+  EXPECT_TRUE(factory_->delay_tcp_race());
   EXPECT_EQ(base::TimeDelta::FromMicroseconds(15),
             request.GetTimeDelayForWaitingJob());
 
@@ -2568,12 +2623,13 @@ TEST_P(QuicStreamFactoryTest, EnableDelayTcpRace) {
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
-  QuicStreamFactoryPeer::SetDelayTcpRace(&factory_, delay_tcp_race);
+  QuicStreamFactoryPeer::SetDelayTcpRace(factory_.get(), delay_tcp_race);
 }
 
 TEST_P(QuicStreamFactoryTest, MaybeInitialize) {
-  QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
-  QuicStreamFactoryPeer::EnableStoreServerConfigsInProperties(&factory_);
+  store_server_configs_in_properties_ = true;
+  Initialize();
+  QuicStreamFactoryPeer::SetTaskRunner(factory_.get(), runner_.get());
 
   const AlternativeService alternative_service1(QUIC, host_port_pair_.host(),
                                                 host_port_pair_.port());
@@ -2590,7 +2646,7 @@ TEST_P(QuicStreamFactoryTest, MaybeInitialize) {
   QuicServerInfoFactory* quic_server_info_factory =
       new PropertiesBasedQuicServerInfoFactory(
           http_server_properties_.GetWeakPtr());
-  factory_.set_quic_server_info_factory(quic_server_info_factory);
+  factory_->set_quic_server_info_factory(quic_server_info_factory);
 
   scoped_ptr<QuicServerInfo> quic_server_info(
       quic_server_info_factory->GetForServer(quic_server_id));
@@ -2625,14 +2681,14 @@ TEST_P(QuicStreamFactoryTest, MaybeInitialize) {
 
   quic_server_info->Persist();
 
-  QuicStreamFactoryPeer::MaybeInitialize(&factory_);
-  EXPECT_TRUE(QuicStreamFactoryPeer::HasInitializedData(&factory_));
-  EXPECT_TRUE(
-      QuicStreamFactoryPeer::SupportsQuicAtStartUp(&factory_, host_port_pair_));
-  EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty(&factory_,
+  QuicStreamFactoryPeer::MaybeInitialize(factory_.get());
+  EXPECT_TRUE(QuicStreamFactoryPeer::HasInitializedData(factory_.get()));
+  EXPECT_TRUE(QuicStreamFactoryPeer::SupportsQuicAtStartUp(factory_.get(),
+                                                           host_port_pair_));
+  EXPECT_FALSE(QuicStreamFactoryPeer::CryptoConfigCacheIsEmpty(factory_.get(),
                                                                quic_server_id));
   QuicCryptoClientConfig* crypto_config =
-      QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
+      QuicStreamFactoryPeer::GetCryptoConfig(factory_.get());
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config->LookupOrCreate(quic_server_id);
   EXPECT_FALSE(cached->server_config().empty());
@@ -2645,7 +2701,8 @@ TEST_P(QuicStreamFactoryTest, MaybeInitialize) {
 }
 
 TEST_P(QuicStreamFactoryTest, YieldAfterPackets) {
-  QuicStreamFactoryPeer::SetYieldAfterPackets(&factory_, 0);
+  Initialize();
+  QuicStreamFactoryPeer::SetYieldAfterPackets(factory_.get(), 0);
 
   scoped_ptr<QuicEncryptedPacket> close_packet(
       ConstructConnectionClosePacket(0));
@@ -2668,7 +2725,7 @@ TEST_P(QuicStreamFactoryTest, YieldAfterPackets) {
   // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver??
   SpdySessionTestTaskObserver observer("quic_packet_reader.cc", "StartReading");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));
@@ -2689,8 +2746,9 @@ TEST_P(QuicStreamFactoryTest, YieldAfterPackets) {
 }
 
 TEST_P(QuicStreamFactoryTest, YieldAfterDuration) {
+  Initialize();
   QuicStreamFactoryPeer::SetYieldAfterDuration(
-      &factory_, QuicTime::Delta::FromMilliseconds(-1));
+      factory_.get(), QuicTime::Delta::FromMilliseconds(-1));
 
   scoped_ptr<QuicEncryptedPacket> close_packet(
       ConstructConnectionClosePacket(0));
@@ -2713,7 +2771,7 @@ TEST_P(QuicStreamFactoryTest, YieldAfterDuration) {
   // TODO(rtenneti): Change SpdySessionTestTaskObserver to NetTestTaskObserver??
   SpdySessionTestTaskObserver observer("quic_packet_reader.cc", "StartReading");
 
-  QuicStreamRequest request(&factory_);
+  QuicStreamRequest request(factory_.get());
   EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
                                 "GET", net_log_, callback_.callback()));