Support tls-server-end-point channel bindings for HTTP authentication.

net/http/http_auth_handler_factory.cc

 // Copyright (c) 2010 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/http/http_auth_handler_factory.h"
 
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_auth_challenge_tokenizer.h"
 #include "net/http/http_auth_filter.h"
 #include "net/http/http_auth_handler_basic.h"
 #include "net/http/http_auth_handler_digest.h"
 #include "net/http/http_auth_handler_ntlm.h"
 #include "net/http/http_auth_preferences.h"
 #include "net/http/http_auth_scheme.h"
+#include "net/ssl/ssl_info.h"
 
 #if defined(USE_KERBEROS)
 #include "net/http/http_auth_handler_negotiate.h"
 #endif
 
 namespace net {
 
 int HttpAuthHandlerFactory::CreateAuthHandlerFromString(
     const std::string& challenge,
     HttpAuth::Target target,
+    const SSLInfo& ssl_info,
     const GURL& origin,
     const BoundNetLog& net_log,
     scoped_ptr<HttpAuthHandler>* handler) {
   HttpAuthChallengeTokenizer props(challenge.begin(), challenge.end());
-  return CreateAuthHandler(&props, target, origin, CREATE_CHALLENGE, 1,
-                           net_log, handler);
+  return CreateAuthHandler(&props, target, ssl_info, origin, CREATE_CHALLENGE,
+                           1, net_log, handler);
 }
 
 int HttpAuthHandlerFactory::CreatePreemptiveAuthHandlerFromString(
     const std::string& challenge,
     HttpAuth::Target target,
     const GURL& origin,
     int digest_nonce_count,
     const BoundNetLog& net_log,
     scoped_ptr<HttpAuthHandler>* handler) {
   HttpAuthChallengeTokenizer props(challenge.begin(), challenge.end());
-  return CreateAuthHandler(&props, target, origin, CREATE_PREEMPTIVE,
-                           digest_nonce_count, net_log, handler);
+  SSLInfo null_ssl_info;
+  return CreateAuthHandler(&props, target, null_ssl_info, origin,
+                           CREATE_PREEMPTIVE, digest_nonce_count, net_log,
+                           handler);
 }
 
 namespace {
 
 const char* const kDefaultAuthSchemes[] = {kBasicAuthScheme, kDigestAuthScheme,
 #if defined(USE_KERBEROS) && !defined(OS_ANDROID)
                                            kNegotiateAuthScheme,
 #endif
                                            kNtlmAuthScheme};
 
@@ skipping 99 matching lines @@
   registry_factory->set_http_auth_preferences(prefs);
   for (auto& factory_entry : registry_factory->factory_map_) {
     factory_entry.second->set_http_auth_preferences(prefs);
   }
   return registry_factory;
 }
 
 int HttpAuthHandlerRegistryFactory::CreateAuthHandler(
     HttpAuthChallengeTokenizer* challenge,
     HttpAuth::Target target,
+    const SSLInfo& ssl_info,
     const GURL& origin,
     CreateReason reason,
     int digest_nonce_count,
     const BoundNetLog& net_log,
     scoped_ptr<HttpAuthHandler>* handler) {
   std::string scheme = challenge->scheme();
   if (scheme.empty()) {
     handler->reset();
     return ERR_INVALID_RESPONSE;
   }
   std::string lower_scheme = base::ToLowerASCII(scheme);
   FactoryMap::iterator it = factory_map_.find(lower_scheme);
   if (it == factory_map_.end()) {
     handler->reset();
     return ERR_UNSUPPORTED_AUTH_SCHEME;
   }
   DCHECK(it->second);
-  return it->second->CreateAuthHandler(challenge, target, origin, reason,
-                                       digest_nonce_count, net_log, handler);
+  return it->second->CreateAuthHandler(challenge, target, ssl_info, origin,
+                                       reason, digest_nonce_count, net_log,
+                                       handler);
 }
 
 }  // namespace net