Clean up FtpTransactionFacory ownership.

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 <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 46 matching lines @@
     *resolver = std::move(owned_resolver);
     return OK;
   }
 
   MockAsyncProxyResolver* resolver() { return resolver_; }
 
  private:
   MockAsyncProxyResolver* resolver_;
 };
 
+class MockFtpTransactionFactory : public FtpTransactionFactory {
+ public:
+  std::unique_ptr<FtpTransaction> CreateTransaction() override {
+    return std::unique_ptr<FtpTransaction>();
+  }
+
+  void Suspend(bool suspend) override {}
+};
+
 }  // namespace
 
 class FtpTestURLRequestContext : public TestURLRequestContext {
  public:
   FtpTestURLRequestContext(ClientSocketFactory* socket_factory,
                            std::unique_ptr<ProxyService> proxy_service,
-                           NetworkDelegate* network_delegate,
-                           FtpTransactionFactory* ftp_transaction_factory)
-      : TestURLRequestContext(true),
-        ftp_protocol_handler_(new FtpProtocolHandler(ftp_transaction_factory)) {
+                           NetworkDelegate* network_delegate)
+      : TestURLRequestContext(true) {
     set_client_socket_factory(socket_factory);
     context_storage_.set_proxy_service(std::move(proxy_service));
     set_network_delegate(network_delegate);
+    std::unique_ptr<FtpProtocolHandler> ftp_protocol_handler(
+        FtpProtocolHandler::CreateForTesting(
+            base::MakeUnique<MockFtpTransactionFactory>()));
+    auth_cache_ = ftp_protocol_handler->ftp_auth_cache_.get();
     std::unique_ptr<URLRequestJobFactoryImpl> job_factory =
         base::WrapUnique(new URLRequestJobFactoryImpl);
-    job_factory->SetProtocolHandler("ftp",
-                                    base::WrapUnique(ftp_protocol_handler_));
+    job_factory->SetProtocolHandler("ftp", std::move(ftp_protocol_handler));
     context_storage_.set_job_factory(std::move(job_factory));
     Init();
   }
 
-  FtpAuthCache* GetFtpAuthCache() {
-    return ftp_protocol_handler_->ftp_auth_cache_.get();
-  }
+  FtpAuthCache* GetFtpAuthCache() { return auth_cache_; }
 
   void set_proxy_service(std::unique_ptr<ProxyService> proxy_service) {
     context_storage_.set_proxy_service(std::move(proxy_service));
   }
 
  private:
-  FtpProtocolHandler* ftp_protocol_handler_;
+  // Owned by the JobFactory's FtpProtocolHandler.
+  FtpAuthCache* auth_cache_;
 };
 
 namespace {
 
 class SimpleProxyConfigService : public ProxyConfigService {
  public:
   SimpleProxyConfigService() {
     // Any FTP requests that ever go through HTTP paths are proxied requests.
     config_.proxy_rules().ParseFromString("ftp=localhost");
   }
@@ skipping 32 matching lines @@
   ~TestURLRequestFtpJob() override {}
 
   using URLRequestFtpJob::SetPriority;
   using URLRequestFtpJob::Start;
   using URLRequestFtpJob::Kill;
   using URLRequestFtpJob::priority;
 
  protected:
 };
 
-class MockFtpTransactionFactory : public FtpTransactionFactory {
- public:
-  std::unique_ptr<FtpTransaction> CreateTransaction() override {
-    return std::unique_ptr<FtpTransaction>();
-  }
-
-  void Suspend(bool suspend) override {}
-};
-
 // Fixture for priority-related tests. Priority matters when there is
 // an HTTP proxy.
 class URLRequestFtpJobPriorityTest : public testing::Test {
  protected:
   URLRequestFtpJobPriorityTest()
       : proxy_service_(base::WrapUnique(new SimpleProxyConfigService),
                        NULL,
                        NULL),
         req_(context_.CreateRequest(GURL("ftp://ftp.example.com"),
                                     DEFAULT_PRIORITY,
@@ skipping 81 matching lines @@
 }
 
 class URLRequestFtpJobTest : public testing::Test {
  public:
   URLRequestFtpJobTest()
       : request_context_(&socket_factory_,
                          base::MakeUnique<ProxyService>(
                              base::WrapUnique(new SimpleProxyConfigService),
                              nullptr,
                              nullptr),
-                         &network_delegate_,
-                         &ftp_transaction_factory_) {}
+                         &network_delegate_) {}
 
   ~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) {
     std::unique_ptr<SequencedSocketData> socket_data(
         base::MakeUnique<SequencedSocketData>(reads, reads_size, writes,
                                               writes_size));
     socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
     socket_factory_.AddSocketDataProvider(socket_data.get());
 
     socket_data_.push_back(std::move(socket_data));
   }
 
   FtpTestURLRequestContext* request_context() { return &request_context_; }
   TestNetworkDelegate* network_delegate() { return &network_delegate_; }
 
  private:
   std::vector<std::unique_ptr<SequencedSocketData>> socket_data_;
   MockClientSocketFactory socket_factory_;
   TestNetworkDelegate network_delegate_;
-  MockFtpTransactionFactory ftp_transaction_factory_;
 
   FtpTestURLRequestContext request_context_;
 };
 
 TEST_F(URLRequestFtpJobTest, FtpProxyRequest) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "GET ftp://ftp.example.com/ HTTP/1.1\r\n"
               "Host: ftp.example.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
@@ skipping 504 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