[SPDY] Use WeakPtr<SpdySession> everywhere but SpdySessionPool

net/spdy/spdy_session_pool.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/spdy/spdy_session_pool.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "net/base/address_list.h"
@@ skipping 62 matching lines @@
     ssl_config_service_->RemoveObserver(this);
   NetworkChangeNotifier::RemoveIPAddressObserver(this);
   CertDatabase::GetInstance()->RemoveObserver(this);
 }
 
 net::Error SpdySessionPool::CreateAvailableSessionFromSocket(
     const SpdySessionKey& key,
     scoped_ptr<ClientSocketHandle> connection,
     const BoundNetLog& net_log,
     int certificate_error_code,
-    scoped_refptr<SpdySession>* available_session,
+    base::WeakPtr<SpdySession>* available_session,
     bool is_secure) {
   UMA_HISTOGRAM_ENUMERATION(
       "Net.SpdySessionGet", IMPORTED_FROM_SOCKET, SPDY_SESSION_GET_MAX);
 
   scoped_refptr<SpdySession> new_session(
       new SpdySession(key,
                       http_server_properties_,
                       verify_domain_authentication_,
                       enable_sending_initial_settings_,
                       enable_credential_frames_,
                       enable_compression_,
                       enable_ping_based_connection_checking_,
                       default_protocol_,
                       stream_initial_recv_window_size_,
                       initial_max_concurrent_streams_,
                       max_concurrent_streams_limit_,
                       time_func_,
                       trusted_spdy_proxy_,
                       net_log.net_log()));
 
   Error error =  new_session->InitializeWithSocket(
       connection.Pass(), this, is_secure, certificate_error_code);
   DCHECK_NE(error, ERR_IO_PENDING);
 
   if (error != OK) {
     new_session = NULL;
-    *available_session = NULL;
+    available_session->reset();
     return error;
   }
 
   sessions_.insert(new_session);
-  available_session->swap(new_session);
+  *available_session = new_session->GetWeakPtr();
   MapKeyToAvailableSession(key, *available_session);
 
   net_log.AddEvent(
       NetLog::TYPE_SPDY_SESSION_POOL_IMPORTED_SESSION_FROM_SOCKET,
       (*available_session)->net_log().source().ToEventParametersCallback());
 
   // Look up the IP address for this session so that we can match
   // future sessions (potentially to different domains) which can
   // potentially be pooled with this one. Because GetPeerAddress()
   // reports the proxy's address instead of the origin server, check
   // to see if this is a direct connection.
   if (enable_ip_pooling_  && key.proxy_server().is_direct()) {
     IPEndPoint address;
     if ((*available_session)->GetPeerAddress(&address) == OK)
       aliases_[address] = key;
   }
 
   return error;
 }
 
-scoped_refptr<SpdySession> SpdySessionPool::FindAvailableSession(
+base::WeakPtr<SpdySession> SpdySessionPool::FindAvailableSession(
     const SpdySessionKey& key,
     const BoundNetLog& net_log) {
   AvailableSessionMap::iterator it = LookupAvailableSessionByKey(key);
   if (it != available_sessions_.end()) {
     UMA_HISTOGRAM_ENUMERATION(
         "Net.SpdySessionGet", FOUND_EXISTING, SPDY_SESSION_GET_MAX);
     net_log.AddEvent(
         NetLog::TYPE_SPDY_SESSION_POOL_FOUND_EXISTING_SESSION,
         it->second->net_log().source().ToEventParametersCallback());
     return it->second;
   }
 
   if (!enable_ip_pooling_)
-    return scoped_refptr<SpdySession>();
+    return base::WeakPtr<SpdySession>();
 
   // Look up the key's from the resolver's cache.
   net::HostResolver::RequestInfo resolve_info(key.host_port_pair());
   AddressList addresses;
   int rv = resolver_->ResolveFromCache(resolve_info, &addresses, net_log);
   DCHECK_NE(rv, ERR_IO_PENDING);
   if (rv != OK)
-    return scoped_refptr<SpdySession>();
+    return base::WeakPtr<SpdySession>();
 
   // Check if we have a session through a domain alias.
   for (AddressList::const_iterator address_it = addresses.begin();
        address_it != addresses.end();
        ++address_it) {
     AliasMap::const_iterator alias_it = aliases_.find(*address_it);
     if (alias_it == aliases_.end())
       continue;
 
     // We found an alias.
     const SpdySessionKey& alias_key = alias_it->second;
 
     // We can reuse this session only if the proxy and privacy
     // settings match.
     if (!(alias_key.proxy_server() == key.proxy_server()) ||
         !(alias_key.privacy_mode() == key.privacy_mode()))
       continue;
 
     AvailableSessionMap::iterator available_session_it =
         LookupAvailableSessionByKey(alias_key);
     if (available_session_it == available_sessions_.end()) {
       NOTREACHED();  // It shouldn't be in the aliases table if we can't get it!
       continue;
     }
 
-    const scoped_refptr<SpdySession>& available_session =
+    const base::WeakPtr<SpdySession>& available_session =
         available_session_it->second;
-    DCHECK(ContainsKey(sessions_, available_session));
+    DCHECK(ContainsKey(sessions_, available_session.get()));
     // If the session is a secure one, we need to verify that the
     // server is authenticated to serve traffic for |host_port_proxy_pair| too.
     if (!available_session->VerifyDomainAuthentication(
             key.host_port_pair().host())) {
       UMA_HISTOGRAM_ENUMERATION("Net.SpdyIPPoolDomainMatch", 0, 2);
       continue;
     }
 
     UMA_HISTOGRAM_ENUMERATION("Net.SpdyIPPoolDomainMatch", 1, 2);
     UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet",
                               FOUND_EXISTING_FROM_IP_POOL,
                               SPDY_SESSION_GET_MAX);
     net_log.AddEvent(
         NetLog::TYPE_SPDY_SESSION_POOL_FOUND_EXISTING_SESSION_FROM_IP_POOL,
         available_session->net_log().source().ToEventParametersCallback());
     // Add this session to the map so that we can find it next time.
     MapKeyToAvailableSession(key, available_session);
     available_session->AddPooledAlias(key);
     return available_session;
   }
 
-  return scoped_refptr<SpdySession>();
+  return base::WeakPtr<SpdySession>();
 }
 
 void SpdySessionPool::MakeSessionUnavailable(
-    const scoped_refptr<SpdySession>& available_session) {
+    const base::WeakPtr<SpdySession>& available_session) {
   UnmapKey(available_session->spdy_session_key());
   RemoveAliases(available_session->spdy_session_key());
   const std::set<SpdySessionKey>& aliases = available_session->pooled_aliases();
   for (std::set<SpdySessionKey>::const_iterator it = aliases.begin();
        it != aliases.end(); ++it) {
     UnmapKey(*it);
     RemoveAliases(*it);
   }
   DCHECK(!IsSessionAvailable(available_session));
 }
 
 void SpdySessionPool::RemoveUnavailableSession(
-    const scoped_refptr<SpdySession>& unavailable_session) {
+    const base::WeakPtr<SpdySession>& unavailable_session) {
   DCHECK(!IsSessionAvailable(unavailable_session));
 
   unavailable_session->net_log().AddEvent(
       NetLog::TYPE_SPDY_SESSION_POOL_REMOVE_SESSION,
       unavailable_session->net_log().source().ToEventParametersCallback());
 
-  SessionSet::iterator it = sessions_.find(unavailable_session);
+  SessionSet::iterator it = sessions_.find(unavailable_session.get());
   CHECK(it != sessions_.end());
   sessions_.erase(it);
 }
 
 // Make a copy of |sessions_| in the Close* functions below to avoid
 // reentrancy problems. Since arbitrary functions get called by close
 // handlers, it doesn't suffice to simply increment the iterator
 // before closing.
 
 void SpdySessionPool::CloseCurrentSessions(net::Error error) {
@@ skipping 43 matching lines @@
 
 void SpdySessionPool::OnCertTrustChanged(const X509Certificate* cert) {
   // Per wtc, we actually only need to CloseCurrentSessions when trust is
   // reduced. CloseCurrentSessions now because OnCertTrustChanged does not
   // tell us this.
   // See comments in ClientSocketPoolManager::OnCertTrustChanged.
   CloseCurrentSessions(ERR_NETWORK_CHANGED);
 }
 
 bool SpdySessionPool::IsSessionAvailable(
-    const scoped_refptr<SpdySession>& session) const {
+    const base::WeakPtr<SpdySession>& session) const {
   for (AvailableSessionMap::const_iterator it = available_sessions_.begin();
        it != available_sessions_.end(); ++it) {
-    if (it->second == session)
+    if (it->second.get() == session.get())
       return true;
   }
   return false;
 }
 
 const SpdySessionKey& SpdySessionPool::NormalizeListKey(
     const SpdySessionKey& key) const {
   if (!force_single_domain_)
     return key;
 
   static SpdySessionKey* single_domain_key = NULL;
   if (!single_domain_key) {
     HostPortPair single_domain = HostPortPair("singledomain.com", 80);
     single_domain_key = new SpdySessionKey(single_domain,
                                            ProxyServer::Direct(),
                                            kPrivacyModeDisabled);
   }
   return *single_domain_key;
 }
 
 void SpdySessionPool::MapKeyToAvailableSession(
     const SpdySessionKey& key,
-    const scoped_refptr<SpdySession>& session) {
-  DCHECK(ContainsKey(sessions_, session));
+    const base::WeakPtr<SpdySession>& session) {
+  DCHECK(ContainsKey(sessions_, scoped_refptr<SpdySession>(session.get())));
   const SpdySessionKey& normalized_key = NormalizeListKey(key);
   std::pair<AvailableSessionMap::iterator, bool> result =
       available_sessions_.insert(std::make_pair(normalized_key, session));
   CHECK(result.second);
 }
 
 SpdySessionPool::AvailableSessionMap::iterator
 SpdySessionPool::LookupAvailableSessionByKey(
     const SpdySessionKey& key) {
   const SpdySessionKey& normalized_key = NormalizeListKey(key);
@@ skipping 27 matching lines @@
   SessionSet current_sessions = sessions_;
   for (SessionSet::const_iterator it = current_sessions.begin();
        it != current_sessions.end(); ++it) {
     if (!ContainsKey(sessions_, *it))
       continue;
 
     if (idle_only && (*it)->is_active())
       continue;
 
     (*it)->CloseSessionOnError(error, description);
-    DCHECK(!IsSessionAvailable(*it));
+    DCHECK(!IsSessionAvailable((*it)->GetWeakPtr()));
     DCHECK(!ContainsKey(sessions_, *it));
   }
 }
 
 }  // namespace net