Replaced static URLRequestFtpJob factory with non-static protocol handler for FTP jobs.

net/url_request/url_request_ftp_job.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/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/auth.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/ftp/ftp_response_info.h"
 #include "net/ftp/ftp_transaction_factory.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 
 namespace net {
 
-URLRequestFtpJob::URLRequestFtpJob(URLRequest* request)
-    : URLRequestJob(request, request->context()->network_delegate()),
+URLRequestFtpJob::URLRequestFtpJob(
+    URLRequest* request,
+    NetworkDelegate* network_delegate,
+    FtpTransactionFactory* ftp_transaction_factory,
+    FtpAuthCache* ftp_auth_cache)
+    : URLRequestJob(request, network_delegate),
       read_in_progress_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
+      ftp_transaction_factory_(ftp_transaction_factory),
+      ftp_auth_cache_(ftp_auth_cache) {
+  DCHECK(ftp_transaction_factory);
+  DCHECK(ftp_auth_cache);
 }
 
 // static
 URLRequestJob* URLRequestFtpJob::Factory(URLRequest* request,
                                          const std::string& scheme) {
   DCHECK_EQ(scheme, "ftp");
 
   int port = request->url().IntPort();
   if (request->url().has_port() &&
-    !IsPortAllowedByFtp(port) && !IsPortAllowedByOverride(port))
+      !IsPortAllowedByFtp(port) && !IsPortAllowedByOverride(port)) {
     return new URLRequestErrorJob(request, ERR_UNSAFE_PORT);
+  }
 
-  DCHECK(request->context());
-  DCHECK(request->context()->ftp_transaction_factory());
-  return new URLRequestFtpJob(request);
+  return new URLRequestFtpJob(request,
+                              request->context()->network_delegate(),
+                              request->context()->ftp_transaction_factory(),
+                              request->context()->ftp_auth_cache());
 }
 
 bool URLRequestFtpJob::GetMimeType(std::string* mime_type) const {
   if (transaction_->GetResponseInfo()->is_directory_listing) {
     *mime_type = "text/vnd.chromium.ftp-dir";
     return true;
   }
   return false;
 }
 
 HostPortPair URLRequestFtpJob::GetSocketAddress() const {
   if (!transaction_.get()) {
     return HostPortPair();
   }
   return transaction_->GetResponseInfo()->socket_address;
 }
 
 URLRequestFtpJob::~URLRequestFtpJob() {
 }
 
 void URLRequestFtpJob::StartTransaction() {
   // Create a transaction.
   DCHECK(!transaction_.get());
-  DCHECK(request_->context());
-  DCHECK(request_->context()->ftp_transaction_factory());
 
-  transaction_.reset(
-      request_->context()->ftp_transaction_factory()->CreateTransaction());
+  transaction_.reset(ftp_transaction_factory_->CreateTransaction());
 
   // No matter what, we want to report our status as IO pending since we will
   // be notifying our consumer asynchronously via OnStartCompleted.
   SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
   int rv;
   if (transaction_.get()) {
     rv = transaction_->Start(
         &request_info_,
         base::Bind(&URLRequestFtpJob::OnStartCompleted,
                    base::Unretained(this)),
@@ skipping 18 matching lines @@
   // FTP obviously doesn't have HTTP Content-Length header. We have to pass
   // the content size information manually.
   set_expected_content_size(
       transaction_->GetResponseInfo()->expected_content_size);
 
   if (result == OK) {
     NotifyHeadersComplete();
   } else if (transaction_->GetResponseInfo()->needs_auth) {
     GURL origin = request_->url().GetOrigin();
     if (server_auth_ && server_auth_->state == AUTH_STATE_HAVE_AUTH) {
-      request_->context()->ftp_auth_cache()->Remove(
-          origin, server_auth_->credentials);
+      ftp_auth_cache_->Remove(origin, server_auth_->credentials);
     } else if (!server_auth_) {
       server_auth_ = new AuthData();
     }
     server_auth_->state = AUTH_STATE_NEED_AUTH;
 
-    FtpAuthCache::Entry* cached_auth =
-        request_->context()->ftp_auth_cache()->Lookup(origin);
-
+    FtpAuthCache::Entry* cached_auth = ftp_auth_cache_->Lookup(origin);
     if (cached_auth) {
       // Retry using cached auth data.
       SetAuth(cached_auth->credentials);
     } else {
       // Prompt for a username/password.
       NotifyHeadersComplete();
     }
   } else {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
@@ skipping 70 matching lines @@
   DCHECK(auth_info->scheme.empty());
   DCHECK(auth_info->realm.empty());
   result->swap(auth_info);
 }
 
 void URLRequestFtpJob::SetAuth(const AuthCredentials& credentials) {
   DCHECK(NeedsAuth());
   server_auth_->state = AUTH_STATE_HAVE_AUTH;
   server_auth_->credentials = credentials;
 
-  request_->context()->ftp_auth_cache()->Add(request_->url().GetOrigin(),
-                                             server_auth_->credentials);
+  ftp_auth_cache_->Add(request_->url().GetOrigin(), server_auth_->credentials);
 
   RestartTransactionWithAuth();
 }
 
 void URLRequestFtpJob::CancelAuth() {
   DCHECK(NeedsAuth());
   server_auth_->state = AUTH_STATE_CANCELED;
 
   // Once the auth is cancelled, we proceed with the request as though
   // there were no auth.  Schedule this for later so that we don't cause
@@ skipping 26 matching lines @@
   if (rv == ERR_IO_PENDING) {
     read_in_progress_ = true;
     SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
   } else {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
   }
   return false;
 }
 
 }  // namespace net