Add TLS-SRP (RFC 5054) support

chrome/browser/ui/login/login_prompt.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 "chrome/browser/ui/login/login_prompt.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/synchronization/lock.h"
@@ skipping 332 matching lines @@
   handled_auth_ = true;
   return was_handled;
 }
 
 // Calls SetAuth from the IO loop.
 void LoginHandler::SetAuthDeferred(const std::wstring& username,
                                    const std::wstring& password) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (request_) {
-    request_->SetAuth(WideToUTF16Hack(username), WideToUTF16Hack(password));
+    if (auth_info_->scheme == ASCIIToWide("TLS-SRP")) {
+      // TODO(sqs): ensure that this only happens if we are indeed using TLS-SRP
+      // and that an HTTP scheme called "TLS-SRP" can't trigger this
+      request_->SetTLSLogin(WideToUTF16Hack(username),
+                            WideToUTF16Hack(password));
+      request_->ContinueWithTLSLogin();
+    } else {
+      request_->SetAuth(WideToUTF16Hack(username), WideToUTF16Hack(password));
+    }
     ResetLoginHandlerForRequest(request_);
   }
 }
 
 // Calls CancelAuth from the IO loop.
 void LoginHandler::CancelAuthDeferred() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (request_) {
-    request_->CancelAuth();
-    // Verify that CancelAuth doesn't destroy the request via our delegate.
+    if (auth_info_->scheme == ASCIIToWide("TLS-SRP")) {
+      request_->CancelTLSLogin();
+    } else {
+      request_->CancelAuth();
+    }
+    // Verify that CancelAuth/CancelTLSLogin doesn't destroy the request via
+    // our delegate.
     DCHECK(request_ != NULL);
     ResetLoginHandlerForRequest(request_);
   }
 }
 
 // Closes the view_contents from the UI loop.
 void LoginHandler::CloseContentsDeferred() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // The hosting ConstrainedWindow may have been freed.
@@ skipping 53 matching lines @@
  private:
   // Helper to create a PasswordForm and stuff it into a vector as input
   // for PasswordManager::PasswordFormsFound, the hook into PasswordManager.
   void MakeInputForPasswordManager(
       std::vector<PasswordForm>* password_manager_input) {
     PasswordForm dialog_form;
     if (LowerCaseEqualsASCII(auth_info_->scheme, "basic")) {
       dialog_form.scheme = PasswordForm::SCHEME_BASIC;
     } else if (LowerCaseEqualsASCII(auth_info_->scheme, "digest")) {
       dialog_form.scheme = PasswordForm::SCHEME_DIGEST;
+    } else if (LowerCaseEqualsASCII(auth_info_->scheme, "tls-srp")) {
+      dialog_form.scheme = PasswordForm::SCHEME_TLS_SRP;
     } else {
       dialog_form.scheme = PasswordForm::SCHEME_OTHER;
     }
     std::string host_and_port(WideToASCII(auth_info_->host_and_port));
     if (auth_info_->is_proxy) {
       std::string origin = host_and_port;
       // We don't expect this to already start with http:// or https://.
-      DCHECK(origin.find("http://") != 0 && origin.find("https://") != 0);
+      DCHECK(origin.find("http://") != 0 && origin.find("https://") != 0 &&
+             origin.find("httpsv://") != 0);
       origin = std::string("http://") + origin;
       dialog_form.origin = GURL(origin);
     } else if (net::GetHostAndPort(request_url_) != host_and_port) {
+      LOG(INFO) << net::GetHostAndPort(request_url_) << " vs " << host_and_port;
       dialog_form.origin = GURL();
       NOTREACHED();  // crbug.com/32718
     } else {
       dialog_form.origin = GURL(request_url_.scheme() + "://" + host_and_port);
     }
     dialog_form.signon_realm = GetSignonRealm(dialog_form.origin, *auth_info_);
     password_manager_input->push_back(dialog_form);
     // Set the password form for the handler (by copy).
     handler_->SetPasswordForm(dialog_form);
   }
@@ skipping 15 matching lines @@
 // Public API
 
 LoginHandler* CreateLoginPrompt(net::AuthChallengeInfo* auth_info,
                                 net::URLRequest* request) {
   LoginHandler* handler = LoginHandler::Create(auth_info, request);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, new LoginDialogTask(
           request->url(), auth_info, handler));
   return handler;
 }