Shift URLRequestContextStorage over to taking scoped_ptrs.

net/url_request/url_request_ftp_job_unittest.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_ftp_job.h"
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
@@ skipping 30 matching lines @@
     resolver->reset(new MockAsyncProxyResolver());
     return OK;
   }
 };
 
 }  // namespace
 
 class FtpTestURLRequestContext : public TestURLRequestContext {
  public:
   FtpTestURLRequestContext(ClientSocketFactory* socket_factory,
-                           ProxyService* proxy_service,
+                           scoped_ptr<ProxyService> proxy_service,
                            NetworkDelegate* network_delegate,
                            FtpTransactionFactory* ftp_transaction_factory)
       : TestURLRequestContext(true),
         ftp_protocol_handler_(new FtpProtocolHandler(ftp_transaction_factory)) {
     set_client_socket_factory(socket_factory);
-    context_storage_.set_proxy_service(proxy_service);
+    context_storage_.set_proxy_service(proxy_service.Pass());
     set_network_delegate(network_delegate);
-    URLRequestJobFactoryImpl* job_factory = new URLRequestJobFactoryImpl;
+    scoped_ptr<URLRequestJobFactoryImpl> job_factory =
+        make_scoped_ptr(new URLRequestJobFactoryImpl);
     job_factory->SetProtocolHandler("ftp",
                                     make_scoped_ptr(ftp_protocol_handler_));
-    context_storage_.set_job_factory(job_factory);
+    context_storage_.set_job_factory(job_factory.Pass());
     Init();
   }
 
   FtpAuthCache* GetFtpAuthCache() {
     return ftp_protocol_handler_->ftp_auth_cache_.get();
   }
 
-  void set_proxy_service(ProxyService* proxy_service) {
-    context_storage_.set_proxy_service(proxy_service);
+  void set_proxy_service(scoped_ptr<ProxyService> proxy_service) {
+    context_storage_.set_proxy_service(proxy_service.Pass());
   }
 
  private:
   FtpProtocolHandler* ftp_protocol_handler_;
 };
 
 namespace {
 
 class SimpleProxyConfigService : public ProxyConfigService {
  public:
@@ skipping 137 matching lines @@
 
   // Creates a second transaction.
   job->Start();
   ASSERT_TRUE(network_layer_.last_transaction());
   EXPECT_EQ(LOW, network_layer_.last_transaction()->priority());
 }
 
 class URLRequestFtpJobTest : public testing::Test {
  public:
   URLRequestFtpJobTest()
-      : request_context_(&socket_factory_,
-                         new ProxyService(
-                             new SimpleProxyConfigService, NULL, NULL),
-                         &network_delegate_,
-                         &ftp_transaction_factory_) {
-  }
+      : request_context_(
+            &socket_factory_,
+            make_scoped_ptr(
+                new ProxyService(new SimpleProxyConfigService, NULL, NULL)),
+            &network_delegate_,
+            &ftp_transaction_factory_) {}
 
   ~URLRequestFtpJobTest() override {
     // Clean up any remaining tasks that mess up unrelated tests.
     base::RunLoop().RunUntilIdle();
   }
 
   void AddSocket(MockRead* reads, size_t reads_size,
                  MockWrite* writes, size_t writes_size) {
     SequencedSocketData* socket_data =
         new SequencedSocketData(reads, reads_size, writes, writes_size);
@@ skipping 43 matching lines @@
       HostPortPair::FromString("localhost:80")));
   EXPECT_EQ(1, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate.auth_required_called());
   EXPECT_EQ("test.html", request_delegate.data_received());
 }
 
 // Regression test for http://crbug.com/237526 .
 TEST_F(URLRequestFtpJobTest, FtpProxyRequestOrphanJob) {
   // Use a PAC URL so that URLRequestFtpJob's |pac_request_| field is non-NULL.
-  request_context()->set_proxy_service(new ProxyService(
+  request_context()->set_proxy_service(make_scoped_ptr(new ProxyService(
       new ProxyConfigServiceFixed(
           ProxyConfig::CreateFromCustomPacURL(GURL("http://foo"))),
-      make_scoped_ptr(new MockProxyResolverFactory), NULL));
+      make_scoped_ptr(new MockProxyResolverFactory), NULL)));
 
   TestDelegate request_delegate;
   scoped_ptr<URLRequest> url_request(request_context()->CreateRequest(
       GURL("ftp://ftp.example.com/"), DEFAULT_PRIORITY, &request_delegate));
   url_request->Start();
 
   // Now |url_request| will be deleted before its completion,
   // resulting in it being orphaned. It should not crash.
 }
 
@@ skipping 415 matching lines @@
   EXPECT_TRUE(url_request2->status().is_success());
   EXPECT_EQ(2, network_delegate()->completed_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
   EXPECT_FALSE(request_delegate2.auth_required_called());
   EXPECT_EQ("test2.html", request_delegate2.data_received());
 }
 
 }  // namespace
 
 }  // namespace net