QUIC - Minor clean up of QUIC Server Info memory cache.

net/quic/quic_stream_factory.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 "net/quic/quic_stream_factory.h"
 
 #include <set>
 
 #include "base/cpu.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 630 matching lines @@
       for (AliasSet::const_iterator alias_it = aliases.begin();
            alias_it != aliases.end(); ++alias_it) {
         hosts.insert(alias_it->host_port_pair());
       }
       list->Append(session->GetInfoAsValue(hosts));
     }
   }
   return list;
 }
 
-void QuicStreamFactory::ClearCachedStates() {
+void QuicStreamFactory::ClearCachedStatesInCryptoConfig() {
   crypto_config_.ClearCachedStates();
 }
 
 void QuicStreamFactory::OnIPAddressChanged() {
   CloseAllSessions(ERR_NETWORK_CHANGED);
   require_confirmation_ = true;
 }
 
 void QuicStreamFactory::OnCertAdded(const X509Certificate* cert) {
   CloseAllSessions(ERR_CERT_DATABASE_CHANGED);
@@ skipping 85 matching lines @@
         base::MessageLoop::current()->message_loop_proxy().get(),
         clock_.get(), random_generator_));
   }
 
   QuicConnection* connection =
       new QuicConnection(connection_id, addr, helper_.get(), writer.get(),
                          false, supported_versions_, kInitialReceiveWindowSize);
   writer->SetConnection(connection);
   connection->options()->max_packet_length = max_packet_length_;
 
-  InitializeCachedState(server_id, server_info);
+  InitializeCachedStateInCryptoConfig(server_id, server_info);
 
   QuicConfig config = config_;
   if (http_server_properties_) {
     const HttpServerProperties::NetworkStats* stats =
         http_server_properties_->GetServerNetworkStats(
             server_id.host_port_pair());
     if (stats != NULL) {
       config.SetInitialRoundTripTimeUsToSend(stats->srtt.InMicroseconds());
     }
   }
@@ skipping 15 matching lines @@
     QuicClientSession* session) {
   DCHECK(!HasActiveSession(server_id));
   active_sessions_[server_id] = session;
   session_aliases_[session].insert(server_id);
   const IpAliasKey ip_alias_key(session->connection()->peer_address(),
                                 server_id.is_https());
   DCHECK(!ContainsKey(ip_aliases_[ip_alias_key], session));
   ip_aliases_[ip_alias_key].insert(session);
 }
 
-void QuicStreamFactory::InitializeCachedState(
+void QuicStreamFactory::InitializeCachedStateInCryptoConfig(
     const QuicServerId& server_id,
     const scoped_ptr<QuicServerInfo>& server_info) {
   if (!server_info)
     return;
 
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_.LookupOrCreate(server_id);
   if (!cached->IsEmpty())
     return;
 
   if (!cached->Initialize(server_info->state().server_config,
                           server_info->state().source_address_token,
                           server_info->state().certs,
                           server_info->state().server_config_sig,
                           clock_->WallNow()))
     return;
 
   if (!server_id.is_https()) {
     // Don't check the certificates for insecure QUIC.
     cached->SetProofValid();
   }
 }
 
 }  // namespace net