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 "base/memory/scoped_vector.h"
 #include "base/run_loop.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 {
 
 namespace {
 
 class SimpleProxyConfigService : public ProxyConfigService {
  public:
   SimpleProxyConfigService() {
     // Any FTP requests that ever go through HTTP paths are proxied requests.
@@ skipping 19 matching lines @@
   void IncrementConfigId() {
     config_.set_id(config_.id() + 1);
     observer_->OnProxyConfigChanged(config_, ProxyConfigService::CONFIG_VALID);
   }
 
  private:
   ProxyConfig config_;
   Observer* observer_;
 };
 
+class MockFtpTransactionFactory : public FtpTransactionFactory {
+ public:
+  MOCK_METHOD0(CreateTransaction, FtpTransaction*());
+  MOCK_METHOD1(Suspend, void(bool suspend));
+};
+
 class FtpTestURLRequestContext : public TestURLRequestContext {
  public:
   FtpTestURLRequestContext(ClientSocketFactory* socket_factory,
                            ProxyService* proxy_service,
-                           NetworkDelegate* network_delegate)
+                           NetworkDelegate* network_delegate,
+                           FtpTransactionFactory* ftp_transaction_factory)
       : TestURLRequestContext(true) {
     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", new FtpProtocolHandler(ftp_transaction_factory));
+    context_storage_.set_job_factory(job_factory);
     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_; }
   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 239 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