Implement RestartWithAuth for NewFtpTransaction.

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"
+#include "net/base/auth.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/ftp/ftp_directory_parser.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"
 #include "unicode/ucsdet.h"
@@ skipping 32 matching lines @@
   if (!CodepageToUTF16(raw_filename, encoding.c_str(),
                        OnStringUtilConversionError::SUBSTITUTE, &filename))
     filename = WideToUTF16Hack(base::SysNativeMBToWide(raw_filename));
   return filename;
 }
 
 }  // namespace
 
 URLRequestNewFtpJob::URLRequestNewFtpJob(URLRequest* request)
     : URLRequestJob(request),
-      server_auth_state_(net::AUTH_STATE_DONT_NEED_AUTH),
       response_info_(NULL),
       dir_listing_buf_size_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           start_callback_(this, &URLRequestNewFtpJob::OnStartCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           read_callback_(this, &URLRequestNewFtpJob::OnReadCompleted)),
       read_in_progress_(false),
       context_(request->context()) {
 }
 
@@ skipping 25 matching lines @@
     return;
   DestroyTransaction();
   URLRequestJob::Kill();
 }
 
 net::LoadState URLRequestNewFtpJob::GetLoadState() const {
   return transaction_.get() ?
       transaction_->GetLoadState() : net::LOAD_STATE_IDLE;
 }
 
+bool URLRequestNewFtpJob::NeedsAuth() {
+  // Note that we only have to worry about cases where an actual FTP server
+  // requires auth (and not a proxy), because connecting to FTP via proxy
+  // effectively means the browser communicates via HTTP, and uses HTTP's
+  // Proxy-Authenticate protocol when proxy servers require auth.
+  return server_auth_ && server_auth_->state == net::AUTH_STATE_NEED_AUTH;

[wtc, 2009/08/25 20:52:50]

Just FYI: URLRequestHttpJob::NeedsAuth sets
the auth state to AUTH_STATE_NEED_AUTH in this method.
I remember that part of the HTTP code is not perfect, so we
don't need to imitate it blindly.

+}
+
+void URLRequestNewFtpJob::GetAuthChallengeInfo(
+    scoped_refptr<net::AuthChallengeInfo>* result) {
+  DCHECK((server_auth_ != NULL) &&
+         (server_auth_->state == net::AUTH_STATE_NEED_AUTH));
+  scoped_refptr<net::AuthChallengeInfo> auth_info = new net::AuthChallengeInfo;
+  auth_info->is_proxy = false;
+  auth_info->host_and_port = ASCIIToWide(
+      net::GetHostAndPort(request_->url()));
+  auth_info->scheme = L"";
+  auth_info->realm = L"";
+  result->swap(auth_info);
+}
+
+void URLRequestNewFtpJob::SetAuth(const std::wstring& username,
+                                  const std::wstring& password) {
+  DCHECK(server_auth_ && server_auth_->state == net::AUTH_STATE_NEED_AUTH);

[wtc, 2009/08/25 20:52:50]

This conditional expression is equivalent to NeedsAuth().

+  server_auth_->state = net::AUTH_STATE_HAVE_AUTH;
+  server_auth_->username = username;
+  server_auth_->password = password;
+
+  // Resend the request with the new username and password.
+  // Do this asynchronously in case we were called from within a
+  // NotifyDataAvailable callback.
+  // TODO(mpcomplete): hmm... is it possible 'this' gets deleted before the task
+  // is run?
+  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(

[wtc, 2009/08/25 20:52:50]

URLRequestHttpJob just call RestartTransactionWithAuth
synchronously here.  So maybe it's now OK to do that.

+      this, &URLRequestNewFtpJob::RestartWithAuth));
+}
+
+void URLRequestNewFtpJob::CancelAuth() {
+  DCHECK(server_auth_ && server_auth_->state == net::AUTH_STATE_NEED_AUTH);

[wtc, 2009/08/25 20:52:50]

This conditional expression is equivalent to 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.
+  MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(

[wtc, 2009/08/25 20:52:50]

URLRequestHttpJob::CancelAuth posts a task for
OnStartCompleted(net::OK), which is equivalent to
NotifyHeadersComplete).

It would be nice to make the two classes use the same
code.

+      this, &URLRequestNewFtpJob::NotifyHeadersComplete));
+}
+
 bool URLRequestNewFtpJob::ReadRawData(net::IOBuffer* buf,
                                       int buf_size,
                                       int *bytes_read) {
   DCHECK_NE(buf_size, 0);
   DCHECK(bytes_read);
   DCHECK(!read_in_progress_);
   if (response_info_ == NULL) {
      response_info_ = transaction_->GetResponseInfo();
     if (response_info_->is_directory_listing) {
       std::string escaped_path =
@@ skipping 124 matching lines @@
   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());
   if (result == net::OK) {
     NotifyHeadersComplete();
   } else {

[wtc, 2009/08/25 20:52:50]

Use "else if" here.

-    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
+    if (transaction_->GetResponseInfo()->auth_needed) {
+      server_auth_ = new net::AuthData();
+      server_auth_->state = net::AUTH_STATE_NEED_AUTH;
+      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) {
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, result));
   } else {
     // TODO(ibrar): find the best place to delete dir_listing_buf_
     // Filter for Directory listing.
     if (response_info_->is_directory_listing)
       result = ProcessFtpDir(dir_listing_buf_, dir_listing_buf_size_, result);
 
     // Clear the IO_PENDING status
     SetStatus(URLRequestStatus());
   }
   NotifyReadComplete(result);
 }
 
+void URLRequestNewFtpJob::RestartWithAuth() {

[wtc, 2009/08/25 20:52:50]

Perhaps rename this method RestartTransactionWithAuth to
be consistent with URLRequestHttpJob?

+  DCHECK(server_auth_ && server_auth_->state == net::AUTH_STATE_HAVE_AUTH);
+

[wtc, 2009/08/25 20:52:50]

URLRequestHttpJob::RestartTransactionWithAuth also sets
response_info_ to NULL.

+  // 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 = transaction_->RestartWithAuth(server_auth_->username,
+                                         server_auth_->password,
+                                         &start_callback_);
+  if (rv == net::ERR_IO_PENDING)
+    return;
+
+  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());
 
   transaction_.reset(
   request_->context()->ftp_transaction_factory()->CreateTransaction());
 
   // No matter what, we want to report our status as IO pending since we will
@@ skipping 13 matching lines @@
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &URLRequestNewFtpJob::OnStartCompleted, rv));
 }
 
 void URLRequestNewFtpJob::DestroyTransaction() {
   DCHECK(transaction_.get());
 
   transaction_.reset();
   response_info_ = NULL;
 }