Add TLS-SRP (RFC 5054) support

net/url_request/url_request.h

 // Copyright (c) 2011 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
+#include "net/base/auth.h"
 #include "base/debug/leak_tracker.h"
 #include "base/linked_ptr.h"
 #include "base/logging.h"
 #include "base/ref_counted.h"
 #include "base/string16.h"
 #include "base/threading/non_thread_safe.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_states.h"
 #include "net/base/net_log.h"
 #include "net/base/request_priority.h"
@@ skipping 92 matching lines @@
   // The delegate's methods are called from the message loop of the thread
   // on which the request's Start() method is called. See above for the
   // ordering of callbacks.
   //
   // The callbacks will be called in the following order:
   //   Start()
   //    - OnCertificateRequested* (zero or one call, if the SSL server
   //      requests a client certificate for authentication)
   //    - OnSSLCertificateError* (zero or one call, if the SSL server's
   //      certificate has an error)
+  //    - OnSSLAuthRequired* (zero or one call, if the SSL server requests
+  //      client login credentials for authentication)
   //    - OnReceivedRedirect* (zero or more calls, for the number of redirects)
   //    - OnAuthRequired* (zero or more calls, for the number of
   //      authentication failures)
   //    - OnResponseStarted
   //   Read() initiated by delegate
   //    - OnReadCompleted* (zero or more calls until all data is read)
   //
   // Read() must be called at least once. Read() returns true when it completed
   // immediately, and false if an IO is pending or if there is an error.  When
   // Read() returns false, the caller can check the Request's status() to see
@@ skipping 25 matching lines @@
                                     bool* defer_redirect);
 
     // Called when we receive an authentication failure.  The delegate should
     // call request->SetAuth() with the user's credentials once it obtains them,
     // or request->CancelAuth() to cancel the login and display the error page.
     // When it does so, the request will be reissued, restarting the sequence
     // of On* callbacks.
     virtual void OnAuthRequired(URLRequest* request,
                                 net::AuthChallengeInfo* auth_info);
 
+    // Called when we need to provide TLS client login credentials.
+    virtual void OnTLSLoginRequired(URLRequest* request,
+                                    net::AuthChallengeInfo* login_request_info);
+
     // Called when we receive an SSL CertificateRequest message for client
     // authentication.  The delegate should call
     // request->ContinueWithCertificate() with the client certificate the user
     // selected, or request->ContinueWithCertificate(NULL) to continue the SSL
     // handshake without a client certificate.
     virtual void OnCertificateRequested(
         URLRequest* request,
         net::SSLCertRequestInfo* cert_request_info);
 
     // Called when using SSL and the server responds with a certificate with
@@ skipping 339 matching lines @@
   // SetAuth will reissue the request with the given credentials.
   // CancelAuth will give up and display the error page.
   void SetAuth(const string16& username, const string16& password);
   void CancelAuth();
 
   // This method can be called after the user selects a client certificate to
   // instruct this URLRequest to continue with the request with the
   // certificate.  Pass NULL if the user doesn't have a client certificate.
   void ContinueWithCertificate(net::X509Certificate* client_cert);
 
+  // One of the following two methods should be called in response to an
+  // OnTLSLoginRequired() callback.
+  void CancelTLSLogin();
+  void SetTLSLogin(const string16& username,
+                   const string16& password);
+  AuthData* GetTLSLoginAuthData();
+
+  void ContinueWithTLSLogin();
+
   // This method can be called after some error notifications to instruct this
   // URLRequest to ignore the current error and continue with the request.  To
   // cancel the request instead, call Cancel().
   void ContinueDespiteLastError();
 
   // Returns true if performance profiling should be enabled on the
   // URLRequestJob serving this request.
   bool enable_profiling() const { return enable_profiling_; }
 
   void set_enable_profiling(bool profiling) { enable_profiling_ = profiling; }
@@ skipping 106 matching lines @@
   int redirect_limit_;
 
   // Cached value for use after we've orphaned the job handling the
   // first transaction in a request involving redirects.
   uint64 final_upload_progress_;
 
   // The priority level for this request.  Objects like ClientSocketPool use
   // this to determine which URLRequest to allocate sockets to first.
   net::RequestPriority priority_;
 
+  // TLS login data.
+  scoped_refptr<net::AuthData> tls_login_auth_data_;
+
   base::debug::LeakTracker<URLRequest> leak_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_