Cache login identity for NewFTP transactions.

net/url_request/url_request_new_ftp_job.cc

 // Copyright (c) 2009 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_new_ftp_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_version_info.h"
 #include "base/message_loop.h"
 #include "base/sys_string_conversions.h"
@@ skipping 118 matching lines @@
   result->swap(auth_info);
 }
 
 void URLRequestNewFtpJob::SetAuth(const std::wstring& username,
                                   const std::wstring& password) {
   DCHECK(NeedsAuth());
   server_auth_->state = net::AUTH_STATE_HAVE_AUTH;
   server_auth_->username = username;
   server_auth_->password = password;
 
+  request_->context()->ftp_auth_cache()->Add(request_->url().GetOrigin(),
+                                             username, password);
+
   RestartTransactionWithAuth();
 }
 
 void URLRequestNewFtpJob::CancelAuth() {
   DCHECK(NeedsAuth());
   server_auth_->state = net::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
   // any recursing into the caller as a result of this call.
@@ skipping 196 matching lines @@
     default:
       net::UpdateFtpServerTypeHistograms(net::SERVER_UNKNOWN);
       break;
   }
 }
 
 void URLRequestNewFtpJob::OnStartCompleted(int result) {
   // If the request was destroyed, then there is no more work to do.
   if (!request_ || !request_->delegate())
     return;
+
   // If the transaction was destroyed, then the job was cancelled, and
   // we can just ignore this notification.
   if (!transaction_.get())
     return;
+
   // Clear the IO_PENDING status
   SetStatus(URLRequestStatus());
+
+  GURL origin = request_->url().GetOrigin();
   if (result == net::OK) {
+    if (!server_auth_ && request_->url().has_username()) {
+      std::wstring username, password;
+      net::GetIdentityFromURL(request_->url(), &username, &password);
+      request_->context()->ftp_auth_cache()->Add(origin, username, password);

[eroman, 2009/09/22 07:42:24]

Ok. Note that for HTTP we only save it to the cache if a challenge was received
(we do all of the auth cache logic as part of the transaction rather than the
job).

+    }
     NotifyHeadersComplete();
   } else if (transaction_->GetResponseInfo()->needs_auth) {
-    server_auth_ = new net::AuthData();
+    if (server_auth_ && server_auth_->state == net::AUTH_STATE_HAVE_AUTH) {
+      request_->context()->ftp_auth_cache()->Remove(origin,
+                                                    server_auth_->username,
+                                                    server_auth_->password);
+    } else if (!server_auth_) {
+      server_auth_ = new net::AuthData();
+    }
     server_auth_->state = net::AUTH_STATE_NEED_AUTH;
-    NotifyHeadersComplete();
+
+    net::FtpAuthCache::Entry* cached_auth =
+        request_->context()->ftp_auth_cache()->Lookup(origin);
+
+    if (cached_auth) {
+      // Retry using cached auth data.
+      SetAuth(cached_auth->username, cached_auth->password);

[eroman, 2009/09/22 07:42:24]

This is kind of awkward that we set it in the cache twice.

(i.e we have either j added it to the cache, or we have just retrieved it from
the cache).

+    } else {
+      // Prompt for a username/password.
+      NotifyHeadersComplete();
+    }
   } else {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
   }
 }
 
 void URLRequestNewFtpJob::OnReadCompleted(int result) {
   read_in_progress_ = false;
   if (result == 0) {
     NotifyDone(URLRequestStatus());
   } else if (result < 0) {
@@ skipping 28 matching lines @@
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &URLRequestNewFtpJob::OnStartCompleted, rv));
 }
 
 void URLRequestNewFtpJob::StartTransaction() {
   // Create a transaction.
   DCHECK(!transaction_.get());
   DCHECK(request_->context());
   DCHECK(request_->context()->ftp_transaction_factory());
 
+  DCHECK(!server_auth_);
+
   transaction_.reset(
-  request_->context()->ftp_transaction_factory()->CreateTransaction());
+      request_->context()->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_, &start_callback_, request_->load_log());
     if (rv == net::ERR_IO_PENDING)
       return;
   } else {
     rv = net::ERR_FAILED;
   }
   // The transaction started synchronously, but we need to notify the
   // URLRequest delegate via the message loop.
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &URLRequestNewFtpJob::OnStartCompleted, rv));
 }
 
 void URLRequestNewFtpJob::DestroyTransaction() {
   DCHECK(transaction_.get());
 
   transaction_.reset();
   response_info_ = NULL;
 }