Simplify test http_server_properties member access.

net/quic/quic_network_transaction_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 224 matching lines @@
     params_.quic_clock = clock_;
     params_.quic_random = &random_generator_;
     params_.client_socket_factory = socket_factory;
     params_.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
     params_.host_resolver = &host_resolver_;
     params_.cert_verifier = &cert_verifier_;
     params_.transport_security_state = &transport_security_state_;
     params_.proxy_service = proxy_service_.get();
     params_.ssl_config_service = ssl_config_service_.get();
     params_.http_auth_handler_factory = auth_handler_factory_.get();
-    params_.http_server_properties = http_server_properties.GetWeakPtr();
+    params_.http_server_properties = http_server_properties_.GetWeakPtr();
     params_.quic_supported_versions = SupportedVersions(GetParam());
 
     if (use_next_protos) {
       params_.use_alternate_protocols = true;
       params_.next_protos = NextProtosWithSpdyAndQuic(true, true);
     }
 
     session_ = new HttpNetworkSession(params_);
     session_->quic_stream_factory()->set_require_confirmation(false);
   }
@@ skipping 62 matching lines @@
       const std::string& expected,
       uint16 port) {
     SendRequestAndExpectQuicResponseMaybeFromProxy(expected, true, port);
   }
 
   void AddQuicAlternateProtocolMapping(
       MockCryptoClientStream::HandshakeMode handshake_mode) {
     crypto_client_stream_factory_.set_handshake_mode(handshake_mode);
     HostPortPair host_port_pair = HostPortPair::FromURL(request_.url);
     AlternativeService alternative_service(QUIC, host_port_pair.host(), 80);
-    session_->http_server_properties()->SetAlternativeService(
-        host_port_pair, alternative_service, 1.0);
+    http_server_properties_.SetAlternativeService(host_port_pair,
+                                                  alternative_service, 1.0);
   }
 
   void ExpectBrokenAlternateProtocolMapping() {
     const HostPortPair origin = HostPortPair::FromURL(request_.url);
     const AlternativeService alternative_service =
-        session_->http_server_properties()->GetAlternativeService(origin);
+        http_server_properties_.GetAlternativeService(origin);
     EXPECT_NE(UNINITIALIZED_ALTERNATE_PROTOCOL, alternative_service.protocol);
-    EXPECT_TRUE(session_->http_server_properties()->IsAlternativeServiceBroken(
+    EXPECT_TRUE(http_server_properties_.IsAlternativeServiceBroken(
         alternative_service));
   }
 
   void ExpectQuicAlternateProtocolMapping() {
     const AlternativeService alternative_service =
-        session_->http_server_properties()->GetAlternativeService(
+        http_server_properties_.GetAlternativeService(
             HostPortPair::FromURL(request_.url));
     EXPECT_EQ(QUIC, alternative_service.protocol);
   }
 
   void AddHangingNonAlternateProtocolSocketData() {
     MockConnect hanging_connect(SYNCHRONOUS, ERR_IO_PENDING);
     hanging_data_.set_connect_data(hanging_connect);
     socket_factory_.AddSocketDataProvider(&hanging_data_);
   }
 
   MockClock* clock_;  // Owned by QuicStreamFactory after CreateSession.
   QuicTestPacketMaker maker_;
   scoped_refptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
   TransportSecurityState transport_security_state_;
   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
   scoped_ptr<ProxyService> proxy_service_;
   scoped_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
   MockRandom random_generator_;
-  HttpServerPropertiesImpl http_server_properties;
+  HttpServerPropertiesImpl http_server_properties_;
   HttpNetworkSession::Params params_;
   HttpRequestInfo request_;
   BoundTestNetLog net_log_;
   StaticSocketDataProvider hanging_data_;
 
  private:
   void SendRequestAndExpectQuicResponseMaybeFromProxy(
       const std::string& expected,
       bool used_proxy,
       uint16 port) {
@@ skipping 239 matching lines @@
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSessionWithNextProtos();
 
   AlternativeService alternative_service(QUIC,
                                          HostPortPair::FromURL(request_.url));
-  session_->http_server_properties()->MarkAlternativeServiceRecentlyBroken(
+  http_server_properties_.MarkAlternativeServiceRecentlyBroken(
       alternative_service);
-  EXPECT_TRUE(
-      session_->http_server_properties()->WasAlternativeServiceRecentlyBroken(
-          alternative_service));
+  EXPECT_TRUE(http_server_properties_.WasAlternativeServiceRecentlyBroken(
+      alternative_service));
 
   SendRequestAndExpectHttpResponse("hello world");
   SendRequestAndExpectQuicResponse("hello!");
 
-  EXPECT_FALSE(
-      session_->http_server_properties()->WasAlternativeServiceRecentlyBroken(
-          alternative_service));
+  EXPECT_FALSE(http_server_properties_.WasAlternativeServiceRecentlyBroken(
+      alternative_service));
 }
 
 TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolProbabilityForQuic) {
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kQuicAlternateProtocol50pctHttpHeader),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
@@ skipping 612 matching lines @@
 
   request_.url = GURL("https://www.example.org:443");
   AddHangingNonAlternateProtocolSocketData();
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 }  // namespace test
 }  // namespace net