Stop refcounting URLRequestContext.

chrome/browser/net/connection_tester.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 "chrome/browser/net/connection_tester.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 35 matching lines @@
 // run by ConnectionTester. The class initializes network dependencies according
 // to the specified "experiment".
 class ExperimentURLRequestContext : public net::URLRequestContext {
  public:
   explicit ExperimentURLRequestContext(
       net::URLRequestContext* proxy_request_context)
       : proxy_request_context_(proxy_request_context),
         ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this)),
         ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 
+  virtual ~ExperimentURLRequestContext() {}
+
   // Creates a proxy config service for |experiment|. On success returns net::OK
   // and fills |config_service| with a new pointer. Otherwise returns a network
   // error code.
   int CreateProxyConfigService(
       ConnectionTester::ProxySettingsExperiment experiment,
       scoped_ptr<net::ProxyConfigService>* config_service,
       base::Callback<void(int)> callback) {
     switch (experiment) {
       case ConnectionTester::PROXY_EXPERIMENT_USE_SYSTEM_SETTINGS:
         return CreateSystemProxyConfigService(config_service);
@@ skipping 54 matching lines @@
         new net::HttpNetworkSession(session_params));
     storage_.set_http_transaction_factory(new net::HttpCache(
         network_session,
         net::HttpCache::DefaultBackend::InMemory(0)));
     // In-memory cookie store.
     storage_.set_cookie_store(new net::CookieMonster(NULL, NULL));
 
     return net::OK;
   }
 
- protected:
-  virtual ~ExperimentURLRequestContext() {
-  }
-
  private:
   // Creates a host resolver for |experiment|. On success returns net::OK and
   // fills |host_resolver| with a new pointer. Otherwise returns a network
   // error code.
   int CreateHostResolver(
       ConnectionTester::HostResolverExperiment experiment,
       scoped_ptr<net::HostResolver>* host_resolver) {
     // Create a vanilla HostResolver that disables caching.
     const size_t kMaxJobs = 50u;
     const size_t kMaxRetryAttempts = 4u;
@@ skipping 121 matching lines @@
         &ExperimentURLRequestContext::FirefoxProxySettingsReply,
         weak_factory_.GetWeakPtr(), config_service,
         base::Owned(ff_settings), callback);
     if (!content::BrowserThread::PostTaskAndReplyWithResult<int>(
             content::BrowserThread::FILE, FROM_HERE, task, reply))
       return net::ERR_FAILED;
     return net::ERR_IO_PENDING;
 #endif
   }
 
-  const scoped_refptr<net::URLRequestContext> proxy_request_context_;
+  net::URLRequestContext* const proxy_request_context_;
   net::URLRequestContextStorage storage_;
   base::WeakPtrFactory<ExperimentURLRequestContext> weak_factory_;
 };
 
 }  // namespace
 
 // ConnectionTester::TestRunner ----------------------------------------------
 
 // TestRunner is a helper class for running an individual experiment. It can
 // be deleted any time after it is started, and this will abort the request.
 class ConnectionTester::TestRunner : public net::URLRequest::Delegate {
  public:
   // |tester| must remain alive throughout the TestRunner's lifetime.
   // |tester| will be notified of completion.
   explicit TestRunner(ConnectionTester* tester)
       : tester_(tester),
         ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 
   // Finish running |experiment| once a ProxyConfigService has been created.
   // In the case of a FirefoxProxyConfigService, this will be called back
   // after disk access has completed.
   void ProxyConfigServiceCreated(
     const Experiment& experiment,
-    scoped_refptr<ExperimentURLRequestContext> context,
     scoped_ptr<net::ProxyConfigService>* proxy_config_service, int status);
 
   // Starts running |experiment|. Notifies tester->OnExperimentCompleted() when
   // it is done.
   void Run(const Experiment& experiment);
 
   // Overridden from net::URLRequest::Delegate:
   virtual void OnResponseStarted(net::URLRequest* request);
   virtual void OnReadCompleted(net::URLRequest* request, int bytes_read);
   // TODO(eroman): handle cases requiring authentication.
 
  private:
   // The number of bytes to read each response body chunk.
   static const int kReadBufferSize = 1024;
 
   // Starts reading the response's body (and keeps reading until an error or
   // end of stream).
   void ReadBody(net::URLRequest* request);
 
   // Called when the request has completed (for both success and failure).
   void OnResponseCompleted(net::URLRequest* request);
   void OnExperimentCompletedWithResult(int result);
 
   ConnectionTester* tester_;
+  scoped_ptr<ExperimentURLRequestContext> request_context_;
   scoped_ptr<net::URLRequest> request_;
 
   base::WeakPtrFactory<TestRunner> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRunner);
 };
 
 void ConnectionTester::TestRunner::OnResponseStarted(net::URLRequest* request) {
   if (!request->status().is_success()) {
     OnResponseCompleted(request);
@@ skipping 44 matching lines @@
       base::Bind(&TestRunner::OnExperimentCompletedWithResult,
                  weak_factory_.GetWeakPtr(), result));
 }
 
 void ConnectionTester::TestRunner::OnExperimentCompletedWithResult(int result) {
   tester_->OnExperimentCompleted(result);
 }
 
 void ConnectionTester::TestRunner::ProxyConfigServiceCreated(
     const Experiment& experiment,
-    scoped_refptr<ExperimentURLRequestContext> context,
     scoped_ptr<net::ProxyConfigService>* proxy_config_service,
     int status) {
   if (status == net::OK)
-    status = context->Init(experiment, proxy_config_service);
+    status = request_context_->Init(experiment, proxy_config_service);
   if (status != net::OK) {
     tester_->OnExperimentCompleted(status);
     return;
   }
   // Fetch a request using the experimental context.
   request_.reset(new net::URLRequest(experiment.url, this));
-  request_->set_context(context);
+  request_->set_context(request_context_.get());
   request_->Start();
 }
 
 void ConnectionTester::TestRunner::Run(const Experiment& experiment) {
   // Try to create a net::URLRequestContext for this experiment.
-  scoped_refptr<ExperimentURLRequestContext> context(
+  request_context_.reset(
       new ExperimentURLRequestContext(tester_->proxy_request_context_));
   scoped_ptr<net::ProxyConfigService>* proxy_config_service =
       new scoped_ptr<net::ProxyConfigService>();
   base::Callback<void(int)> config_service_callback =
       base::Bind(
           &TestRunner::ProxyConfigServiceCreated, weak_factory_.GetWeakPtr(),
-          experiment, context, base::Owned(proxy_config_service));
-  int rv = context->CreateProxyConfigService(
+          experiment, base::Owned(proxy_config_service));
+  int rv = request_context_->CreateProxyConfigService(
       experiment.proxy_settings_experiment,
       proxy_config_service, config_service_callback);
   if (rv != net::ERR_IO_PENDING)
-    ProxyConfigServiceCreated(experiment, context, proxy_config_service, rv);
+    ProxyConfigServiceCreated(experiment, proxy_config_service, rv);
 }
 
 // ConnectionTester ----------------------------------------------------------
 
 ConnectionTester::ConnectionTester(
     Delegate* delegate,
     net::URLRequestContext* proxy_request_context)
     : delegate_(delegate), proxy_request_context_(proxy_request_context) {
   DCHECK(delegate);
   DCHECK(proxy_request_context);
@@ skipping 87 matching lines @@
 
   // Notify the delegate of completion.
   delegate_->OnCompletedConnectionTestExperiment(current, result);
 
   if (remaining_experiments_.empty()) {
     delegate_->OnCompletedConnectionTestSuite();
   } else {
     StartNextExperiment();
   }
 }