Removed static factories for data, ftp, file, and about jobs.

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_vector.h"
 #include "base/run_loop.h"
 #include "googleurl/src/gurl.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/socket/socket_test_util.h"
+#include "net/url_request/ftp_protocol_handler.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
+class FtpTestURLRequestContext : public TestURLRequestContext {
+ public:
+  FtpTestURLRequestContext(ClientSocketFactory* socket_factory,
+                           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);
+    set_network_delegate(network_delegate);
+    URLRequestJobFactoryImpl* job_factory = new URLRequestJobFactoryImpl;
+    job_factory->SetProtocolHandler("ftp", ftp_protocol_handler_);
+    context_storage_.set_job_factory(job_factory);
+    Init();
+  }
+
+  FtpAuthCache* GetFtpAuthCache() {
+    return &ftp_protocol_handler_->ftp_auth_cache_;
+  }
+
+ private:
+  FtpProtocolHandler* ftp_protocol_handler_;
+};
+
 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");
   }
 
   virtual void AddObserver(Observer* observer) OVERRIDE {
@@ skipping 19 matching lines @@
 
  private:
   ProxyConfig config_;
   Observer* observer_;
 };
 
 // Inherit from URLRequestFtpJob to expose the priority and some
 // other hidden functions.
 class TestURLRequestFtpJob : public URLRequestFtpJob {
  public:
-  explicit TestURLRequestFtpJob(URLRequest* request)
-      : URLRequestFtpJob(request, NULL,
-                         request->context()->ftp_transaction_factory(),
-                         request->context()->ftp_auth_cache()) {}
+  TestURLRequestFtpJob(URLRequest* request,
+                       FtpTransactionFactory* ftp_factory,
+                       FtpAuthCache* ftp_auth_cache)
+      : URLRequestFtpJob(request, NULL, ftp_factory, ftp_auth_cache) {}
 
   using URLRequestFtpJob::SetPriority;
   using URLRequestFtpJob::Start;
   using URLRequestFtpJob::Kill;
   using URLRequestFtpJob::priority;
 
  protected:
   virtual ~TestURLRequestFtpJob() {}
 };
 
+class MockFtpTransactionFactory : public FtpTransactionFactory {

[Paweł Hajdan Jr., 2013/04/29 18:45:26]

Please don't use gmock for FTP unit tests.

+ public:
+  MOCK_METHOD0(CreateTransaction, FtpTransaction*());
+  MOCK_METHOD1(Suspend, void(bool suspend));
+};
+
 // Fixture for priority-related tests. Priority matters when there is
 // an HTTP proxy.
 class URLRequestFtpJobPriorityTest : public testing::Test {
  protected:
   URLRequestFtpJobPriorityTest()
       : proxy_service_(new SimpleProxyConfigService, NULL, NULL),
         req_(GURL("ftp://ftp.example.com"), &delegate_, &context_, NULL) {
     context_.set_proxy_service(&proxy_service_);
     context_.set_http_transaction_factory(&network_layer_);
   }
 
   ProxyService proxy_service_;
   MockNetworkLayer network_layer_;
+  MockFtpTransactionFactory ftp_factory_;
+  FtpAuthCache ftp_auth_cache_;
   TestURLRequestContext context_;
   TestDelegate delegate_;
   TestURLRequest req_;
 };
 
 // Make sure that SetPriority actually sets the URLRequestFtpJob's
 // priority, both before and after start.
 TEST_F(URLRequestFtpJobPriorityTest, SetPriorityBasic) {
-  scoped_refptr<TestURLRequestFtpJob> job(new TestURLRequestFtpJob(&req_));
+  scoped_refptr<TestURLRequestFtpJob> job(new TestURLRequestFtpJob(
+      &req_, &ftp_factory_, &ftp_auth_cache_));
   EXPECT_EQ(DEFAULT_PRIORITY, job->priority());
 
   job->SetPriority(LOWEST);
   EXPECT_EQ(LOWEST, job->priority());
 
   job->SetPriority(LOW);
   EXPECT_EQ(LOW, job->priority());
 
   job->Start();
   EXPECT_EQ(LOW, job->priority());
 
   job->SetPriority(MEDIUM);
   EXPECT_EQ(MEDIUM, job->priority());
 }
 
 // Make sure that URLRequestFtpJob passes on its priority to its
 // transaction on start.
 TEST_F(URLRequestFtpJobPriorityTest, SetTransactionPriorityOnStart) {
-  scoped_refptr<TestURLRequestFtpJob> job(new TestURLRequestFtpJob(&req_));
+  scoped_refptr<TestURLRequestFtpJob> job(new TestURLRequestFtpJob(
+      &req_, &ftp_factory_, &ftp_auth_cache_));
   job->SetPriority(LOW);
 
   EXPECT_FALSE(network_layer_.last_transaction());
 
   job->Start();
 
   ASSERT_TRUE(network_layer_.last_transaction());
   EXPECT_EQ(LOW, network_layer_.last_transaction()->priority());
 }
 
 // Make sure that URLRequestFtpJob passes on its priority updates to
 // its transaction.
 TEST_F(URLRequestFtpJobPriorityTest, SetTransactionPriority) {
-  scoped_refptr<TestURLRequestFtpJob> job(new TestURLRequestFtpJob(&req_));
+  scoped_refptr<TestURLRequestFtpJob> job(new TestURLRequestFtpJob(
+      &req_, &ftp_factory_, &ftp_auth_cache_));
   job->SetPriority(LOW);
   job->Start();
   ASSERT_TRUE(network_layer_.last_transaction());
   EXPECT_EQ(LOW, network_layer_.last_transaction()->priority());
 
   job->SetPriority(HIGHEST);
   EXPECT_EQ(HIGHEST, network_layer_.last_transaction()->priority());
 }
 
 // Make sure that URLRequestFtpJob passes on its priority updates to
 // newly-created transactions after the first one.
 TEST_F(URLRequestFtpJobPriorityTest, SetSubsequentTransactionPriority) {
-  scoped_refptr<TestURLRequestFtpJob> job(new TestURLRequestFtpJob(&req_));
+  scoped_refptr<TestURLRequestFtpJob> job(new TestURLRequestFtpJob(
+      &req_, &ftp_factory_, &ftp_auth_cache_));
   job->Start();
 
   job->SetPriority(LOW);
   ASSERT_TRUE(network_layer_.last_transaction());
   EXPECT_EQ(LOW, network_layer_.last_transaction()->priority());
 
   job->Kill();
   network_layer_.ClearLastTransaction();
 
   // Creates a second transaction.
   job->Start();
   ASSERT_TRUE(network_layer_.last_transaction());
   EXPECT_EQ(LOW, network_layer_.last_transaction()->priority());
 }
 
-class FtpTestURLRequestContext : public TestURLRequestContext {
- public:
-  FtpTestURLRequestContext(ClientSocketFactory* socket_factory,
-                           ProxyService* proxy_service,
-                           NetworkDelegate* network_delegate)
-      : TestURLRequestContext(true) {
-    set_client_socket_factory(socket_factory);
-    context_storage_.set_proxy_service(proxy_service);
-    set_network_delegate(network_delegate);
-    Init();
-  }
-};
-
 class URLRequestFtpJobTest : public testing::Test {
  public:
   URLRequestFtpJobTest()
       : proxy_service_(new ProxyService(
                            new SimpleProxyConfigService, NULL, NULL)),
         request_context_(&socket_factory_,
                          proxy_service_,
-                         &network_delegate_) {
+                         &network_delegate_,
+                         &ftp_transaction_factory_) {
   }
 
   virtual ~URLRequestFtpJobTest() {
     // Clean up any remaining tasks that mess up unrelated tests.
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   void AddSocket(MockRead* reads, size_t reads_size,
                  MockWrite* writes, size_t writes_size) {
     DeterministicSocketData* socket_data = new DeterministicSocketData(
         reads, reads_size, writes, writes_size);
     socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
     socket_data->StopAfter(reads_size + writes_size - 1);
     socket_factory_.AddSocketDataProvider(socket_data);
 
     socket_data_.push_back(socket_data);
   }
 
-  URLRequestContext* request_context() { return &request_context_; }
+  FtpTestURLRequestContext* request_context() { return &request_context_; }
   TestNetworkDelegate* network_delegate() { return &network_delegate_; }
   DeterministicSocketData* socket_data(size_t index) {
     return socket_data_[index];
   }
 
  private:
   ScopedVector<DeterministicSocketData> socket_data_;
   DeterministicMockClientSocketFactory socket_factory_;
   TestNetworkDelegate network_delegate_;
+  ::testing::StrictMock<MockFtpTransactionFactory> ftp_transaction_factory_;
 
   // Owned by |request_context_|:
   ProxyService* proxy_service_;
 
   FtpTestURLRequestContext request_context_;
 };
 
 TEST_F(URLRequestFtpJobTest, FtpProxyRequest) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "GET ftp://ftp.example.com/ HTTP/1.1\r\n"
@@ skipping 214 matching lines @@
     MockRead(ASYNC, 11, "HTTP/1.1 200 OK\r\n"),
     MockRead(ASYNC, 12, "Content-Length: 10\r\n\r\n"),
     MockRead(ASYNC, 13, "test2.html"),
   };
 
   AddSocket(reads, arraysize(reads), writes, arraysize(writes));
 
   GURL url("ftp://ftp.example.com");
 
   // Make sure cached FTP credentials are not used for proxy authentication.
-  request_context()->ftp_auth_cache()->Add(
+  request_context()->GetFtpAuthCache()->Add(
       url.GetOrigin(),
       AuthCredentials(ASCIIToUTF16("userdonotuse"),
                       ASCIIToUTF16("passworddonotuse")));
 
   TestDelegate request_delegate;
   request_delegate.set_credentials(
       AuthCredentials(ASCIIToUTF16("proxyuser"), ASCIIToUTF16("proxypass")));
   URLRequest url_request(url,
                          &request_delegate,
                          request_context(),
@@ skipping 194 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