Remove reference counting from HttpNetworkSession.

components/gcm_driver/gcm_client_impl.cc

 // Copyright 2014 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 "components/gcm_driver/gcm_client_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 237 matching lines @@
     ConnectionFactory* connection_factory,
     GCMStore* gcm_store,
     GCMStatsRecorder* recorder) {
   return scoped_ptr<MCSClient>(new MCSClient(
       version, clock, connection_factory, gcm_store, recorder));
 }
 
 scoped_ptr<ConnectionFactory> GCMInternalsBuilder::BuildConnectionFactory(
       const std::vector<GURL>& endpoints,
       const net::BackoffEntry::Policy& backoff_policy,
-      const scoped_refptr<net::HttpNetworkSession>& gcm_network_session,
-      const scoped_refptr<net::HttpNetworkSession>& http_network_session,
+      net::HttpNetworkSession* gcm_network_session,
+      net::HttpNetworkSession* http_network_session,
       net::NetLog* net_log,
       GCMStatsRecorder* recorder) {
   return make_scoped_ptr<ConnectionFactory>(
       new ConnectionFactoryImpl(endpoints,
                                 backoff_policy,
                                 gcm_network_session,
                                 http_network_session,
                                 net_log,
                                 recorder));
 }
@@ skipping 49 matching lines @@
     GCMClient::Delegate* delegate) {
   DCHECK_EQ(UNINITIALIZED, state_);
   DCHECK(url_request_context_getter.get());
   DCHECK(delegate);
 
   url_request_context_getter_ = url_request_context_getter;
   const net::HttpNetworkSession::Params* network_session_params =
       url_request_context_getter_->GetURLRequestContext()->
           GetNetworkSessionParams();
   DCHECK(network_session_params);
-  network_session_ = new net::HttpNetworkSession(*network_session_params);
+  network_session_.reset(new net::HttpNetworkSession(*network_session_params));
 
   chrome_build_info_ = chrome_build_info;
 
   gcm_store_.reset(
       new GCMStoreImpl(path, blocking_task_runner, encryptor.Pass()));
 
   delegate_ = delegate;
 
   recorder_.SetDelegate(this);
 
@@ skipping 136 matching lines @@
   StartCheckin();
 }
 
 void GCMClientImpl::InitializeMCSClient() {
   std::vector<GURL> endpoints;
   endpoints.push_back(gservices_settings_.GetMCSMainEndpoint());
   endpoints.push_back(gservices_settings_.GetMCSFallbackEndpoint());
   connection_factory_ = internals_builder_->BuildConnectionFactory(
       endpoints,
       GetGCMBackoffPolicy(),
-      network_session_,
+      network_session_.get(),
       url_request_context_getter_->GetURLRequestContext()
           ->http_transaction_factory()
           ->GetSession(),
-      net_log_.net_log(),
+      nullptr,

[Nicolas Zea, 2015/08/31 19:43:28]

Did you mean to change this?

[mmenke, 2015/08/31 19:48:51]

Yes.  The current code is creating a BoundNetLog with no arguments (Which has a
NULL net_log()), and then only using it to pass its NULL net_log() pointer to
this method.  Just a case of someone not familiar with net/ not doing stuff
correctly.

It's a bit removed from the CL, but I'm too lazy to make another CL that fixes
the code to be less silly.

If we want to hook up a non-NULL NetLog, we should grab the one from
HttpURLRequestContext - which even more removed from this CL, and not something
I'm all that sure we want to do.

[Nicolas Zea, 2015/08/31 22:26:49]

Got it. May as well just remove the net_log_ member variable then as it's never
actually used anymore.

[mmenke, 2015/09/01 17:20:52]

Done.

       &recorder_);
   connection_factory_->SetConnectionListener(this);
   mcs_client_ = internals_builder_->BuildMCSClient(
       chrome_build_info_.version,
       clock_.get(),
       connection_factory_.get(),
       gcm_store_.get(),
       &recorder_).Pass();
 
   mcs_client_->Initialize(
@@ skipping 872 matching lines @@
 bool GCMClientImpl::HasStandaloneRegisteredApp() const {
   if (registrations_.empty())
     return false;
   // Note that account mapper is not counted as a standalone app since it is
   // automatically started when other app uses GCM.
   return registrations_.size() > 1 ||
          !ExistsGCMRegistrationInMap(registrations_, kGCMAccountMapperAppId);
 }
 
 }  // namespace gcm