Make UrlRequestContextBuilder take scoped_ptr's

net/url_request/url_request_context_builder.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/url_request/url_request_context_builder.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 111 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BasicNetworkDelegate);
 };
 
 // Define a context class that can self-manage the ownership of its components
 // via a UrlRequestContextStorage object.
 class ContainerURLRequestContext : public URLRequestContext {
  public:
   explicit ContainerURLRequestContext(
       const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
       : file_task_runner_(file_task_runner), storage_(this) {}
+  ~ContainerURLRequestContext() override { AssertNoURLRequests(); }
 
   URLRequestContextStorage* storage() {
     return &storage_;
   }
 
   scoped_refptr<base::SingleThreadTaskRunner>& GetFileTaskRunner() {
     // Create a new thread to run file tasks, if needed.
     if (!file_task_runner_) {
       DCHECK(!file_thread_);
       file_thread_.reset(new base::Thread("Network File Thread"));
       file_thread_->StartWithOptions(
           base::Thread::Options(base::MessageLoop::TYPE_DEFAULT, 0));
       file_task_runner_ = file_thread_->task_runner();
     }
     return file_task_runner_;
   }
 
   void set_transport_security_persister(
       scoped_ptr<TransportSecurityPersister> transport_security_persister) {
     transport_security_persister = transport_security_persister.Pass();
   }
 
- protected:
-  ~ContainerURLRequestContext() override { AssertNoURLRequests(); }
-
  private:
   // The thread should be torn down last.
   scoped_ptr<base::Thread> file_thread_;
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
 
   URLRequestContextStorage storage_;
   scoped_ptr<TransportSecurityPersister> transport_security_persister_;
 
   DISALLOW_COPY_AND_ASSIGN(ContainerURLRequestContext);
 };
@@ skipping 31 matching lines @@
     : data_enabled_(false),
 #if !defined(DISABLE_FILE_SUPPORT)
       file_enabled_(false),
 #endif
 #if !defined(DISABLE_FTP_SUPPORT)
       ftp_enabled_(false),
 #endif
       http_cache_enabled_(true),
       throttling_enabled_(false),
       backoff_enabled_(false),
-      sdch_enabled_(false) {
+      sdch_enabled_(false),
+      net_log_(nullptr) {
 }
 
 URLRequestContextBuilder::~URLRequestContextBuilder() {}
 
 void URLRequestContextBuilder::SetHttpNetworkSessionComponents(
     const URLRequestContext* context,
     HttpNetworkSession::Params* params) {
   params->host_resolver = context->host_resolver();
   params->cert_verifier = context->cert_verifier();
   params->transport_security_state = context->transport_security_state();
@@ skipping 40 matching lines @@
 void URLRequestContextBuilder::SetFileTaskRunner(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
   file_task_runner_ = task_runner;
 }
 
 void URLRequestContextBuilder::SetHttpServerProperties(
     scoped_ptr<HttpServerProperties> http_server_properties) {
   http_server_properties_ = http_server_properties.Pass();
 }
 
-URLRequestContext* URLRequestContextBuilder::Build() {
-  ContainerURLRequestContext* context =
-      new ContainerURLRequestContext(file_task_runner_);
+scoped_ptr<URLRequestContext> URLRequestContextBuilder::Build() {
+  scoped_ptr<ContainerURLRequestContext> context(
+      new ContainerURLRequestContext(file_task_runner_));
   URLRequestContextStorage* storage = context->storage();
 
   storage->set_http_user_agent_settings(new StaticHttpUserAgentSettings(
       accept_language_, user_agent_));
 
   if (!network_delegate_)
     network_delegate_.reset(new BasicNetworkDelegate);
   NetworkDelegate* network_delegate = network_delegate_.release();
   storage->set_network_delegate(network_delegate);
 
   if (net_log_) {
-    storage->set_net_log(net_log_.release());
+    // Unlike the other builder parameters, |net_log_| is not owned by the
+    // builder or resulting context.
+    context->set_net_log(net_log_);
   } else {
     storage->set_net_log(new NetLog);
   }
 
   if (!host_resolver_) {
     host_resolver_ = HostResolver::CreateDefaultResolver(context->net_log());
   }
   storage->set_host_resolver(host_resolver_.Pass());
 
   if (!proxy_service_) {
@@ skipping 64 matching lines @@
 
   storage->set_cert_verifier(CertVerifier::CreateDefault());
 
   if (throttling_enabled_)
     storage->set_throttler_manager(new URLRequestThrottlerManager());
 
   if (backoff_enabled_)
     storage->set_backoff_manager(new URLRequestBackoffManager());
 
   HttpNetworkSession::Params network_session_params;
-  SetHttpNetworkSessionComponents(context, &network_session_params);
+  SetHttpNetworkSessionComponents(context.get(), &network_session_params);
 
   network_session_params.ignore_certificate_errors =
       http_network_session_params_.ignore_certificate_errors;
   network_session_params.host_mapping_rules =
       http_network_session_params_.host_mapping_rules;
   network_session_params.testing_fixed_http_port =
       http_network_session_params_.testing_fixed_http_port;
   network_session_params.testing_fixed_https_port =
       http_network_session_params_.testing_fixed_https_port;
   network_session_params.use_alternative_services =
@@ skipping 60 matching lines @@
              url_request_interceptors_.rbegin();
          i != url_request_interceptors_.rend(); ++i) {
       top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
           top_job_factory.Pass(), make_scoped_ptr(*i)));
     }
     url_request_interceptors_.weak_clear();
   }
   storage->set_job_factory(top_job_factory.release());
   // TODO(willchan): Support sdch.
 
-  return context;
+  return context.Pass();
 }
 
 }  // namespace net