Update net/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

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/callback.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
@@ skipping 51 matching lines @@
       enable_ping_based_connection_checking_(
           enable_ping_based_connection_checking),
       default_protocol_(default_protocol),
       stream_initial_recv_window_size_(stream_initial_recv_window_size),
       initial_max_concurrent_streams_(initial_max_concurrent_streams),
       max_concurrent_streams_limit_(max_concurrent_streams_limit),
       time_func_(time_func),
       trusted_spdy_proxy_(
           HostPortPair::FromString(trusted_spdy_proxy)) {
   NetworkChangeNotifier::AddIPAddressObserver(this);
-  if (ssl_config_service_)
+  if (ssl_config_service_.get())
     ssl_config_service_->AddObserver(this);
   CertDatabase::GetInstance()->AddObserver(this);
 }
 
 SpdySessionPool::~SpdySessionPool() {
   CloseAllSessions();
 
-  if (ssl_config_service_)
+  if (ssl_config_service_.get())
     ssl_config_service_->RemoveObserver(this);
   NetworkChangeNotifier::RemoveIPAddressObserver(this);
   CertDatabase::GetInstance()->RemoveObserver(this);
 }
 
 scoped_refptr<SpdySession> SpdySessionPool::Get(
     const SpdySessionKey& spdy_session_key,
     const BoundNetLog& net_log) {
   return GetInternal(spdy_session_key, net_log, false);
 }
 
 scoped_refptr<SpdySession> SpdySessionPool::GetIfExists(
     const SpdySessionKey& spdy_session_key,
     const BoundNetLog& net_log) {
   return GetInternal(spdy_session_key, net_log, true);
 }
 
 scoped_refptr<SpdySession> SpdySessionPool::GetInternal(
     const SpdySessionKey& spdy_session_key,
     const BoundNetLog& net_log,
     bool only_use_existing_sessions) {
   scoped_refptr<SpdySession> spdy_session;
   SpdySessionList* list = GetSessionList(spdy_session_key);
   if (!list) {
     // Check if we have a Session through a domain alias.
     spdy_session = GetFromAlias(spdy_session_key, net_log, true);
-    if (spdy_session) {
+    if (spdy_session.get()) {
       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,
           spdy_session->net_log().source().ToEventParametersCallback());
       // Add this session to the map so that we can find it next time.
       list = AddSessionList(spdy_session_key);
       list->push_back(spdy_session);
       spdy_session->AddPooledAlias(spdy_session_key);
@@ skipping 314 matching lines @@
     }
     ++alias_it;
   }
 }
 
 void SpdySessionPool::CloseAllSessions() {
   while (!sessions_.empty()) {
     SpdySessionList* list = sessions_.begin()->second;
     CHECK(list);
     const scoped_refptr<SpdySession>& session = list->front();
-    CHECK(session);
+    CHECK(session.get());
     // This call takes care of removing the session from the pool, as well as
     // removing the session list if the list is empty.
     session->CloseSessionOnError(
         net::ERR_ABORTED, true, "Closing all sessions.");
   }
 }
 
 void SpdySessionPool::CloseCurrentSessions(net::Error error) {
   SpdySessionsMap old_map;
   old_map.swap(sessions_);
   for (SpdySessionsMap::const_iterator it = old_map.begin();
        it != old_map.end(); ++it) {
     SpdySessionList* list = it->second;
     CHECK(list);
     const scoped_refptr<SpdySession>& session = list->front();
-    CHECK(session);
+    CHECK(session.get());
     session->set_spdy_session_pool(NULL);
   }
 
   while (!old_map.empty()) {
     SpdySessionList* list = old_map.begin()->second;
     CHECK(list);
     const scoped_refptr<SpdySession>& session = list->front();
-    CHECK(session);
+    CHECK(session.get());
     session->CloseSessionOnError(error, false, "Closing current sessions.");
     list->pop_front();
     if (list->empty()) {
       delete list;
       RemoveAliases(old_map.begin()->first);
       old_map.erase(old_map.begin()->first);
     }
   }
   DCHECK(sessions_.empty());
   DCHECK(aliases_.empty());
 }
 
 void SpdySessionPool::CloseIdleSessions() {
   SpdySessionsMap::const_iterator map_it = sessions_.begin();
   while (map_it != sessions_.end()) {
     SpdySessionList* list = map_it->second;
     CHECK(list);
 
     // Assumes there is only 1 element in the list.
     SpdySessionList::iterator session_it = list->begin();
     const scoped_refptr<SpdySession>& session = *session_it;
-    CHECK(session);
+    CHECK(session.get());
     if (session->is_active()) {
       ++map_it;
       continue;
     }
 
     SpdySessionKey key(map_it->first);
     session->CloseSessionOnError(
         net::ERR_ABORTED, true, "Closing idle sessions.");
     // CloseSessionOnError can invalidate the iterator.
     map_it = sessions_.lower_bound(key);
   }
 }
 
 }  // namespace net