Merge r25564 and r26588 from the trunk....

net/http/http_auth.cc

 // Copyright (c) 2006-2008 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.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/string_util.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_response_headers.h"
 #include "net/http/http_util.h"
 
 namespace net {
 
 // static
 void HttpAuth::ChooseBestChallenge(const HttpResponseHeaders* headers,
                                    Target target,
+                                   const GURL& origin,
                                    scoped_refptr<HttpAuthHandler>* handler) {
   // A connection-based authentication scheme must continue to use the
   // existing handler object in |*handler|.
   if (*handler && (*handler)->is_connection_based()) {
     const std::string header_name = GetChallengeHeaderName(target);
     std::string challenge;
     void* iter = NULL;
     while (headers->EnumerateHeader(&iter, header_name, &challenge)) {
       ChallengeTokenizer props(challenge.begin(), challenge.end());
       if (LowerCaseEqualsASCII(props.scheme(), (*handler)->scheme().c_str()) &&
           (*handler)->InitFromChallenge(challenge.begin(), challenge.end(),
-                                        target))
+                                        target, origin))
         return;
     }
   }
 
   // Choose the challenge whose authentication handler gives the maximum score.
   scoped_refptr<HttpAuthHandler> best;
   const std::string header_name = GetChallengeHeaderName(target);
   std::string cur_challenge;
   void* iter = NULL;
   while (headers->EnumerateHeader(&iter, header_name, &cur_challenge)) {
     scoped_refptr<HttpAuthHandler> cur;
-    CreateAuthHandler(cur_challenge, target, &cur);
+    CreateAuthHandler(cur_challenge, target, origin, &cur);
     if (cur && (!best || best->score() < cur->score()))
       best.swap(cur);
   }
   handler->swap(best);
 }
 
 // static
 void HttpAuth::CreateAuthHandler(const std::string& challenge,
                                  Target target,
+                                 const GURL& origin,
                                  scoped_refptr<HttpAuthHandler>* handler) {
   // Find the right auth handler for the challenge's scheme.
   ChallengeTokenizer props(challenge.begin(), challenge.end());
   if (!props.valid()) {
     *handler = NULL;
     return;
   }
 
   scoped_refptr<HttpAuthHandler> tmp_handler;
   if (LowerCaseEqualsASCII(props.scheme(), "basic")) {
     tmp_handler = new HttpAuthHandlerBasic();
   } else if (LowerCaseEqualsASCII(props.scheme(), "digest")) {
     tmp_handler = new HttpAuthHandlerDigest();
   } else if (LowerCaseEqualsASCII(props.scheme(), "ntlm")) {
     tmp_handler = new HttpAuthHandlerNTLM();
   }
   if (tmp_handler) {
     if (!tmp_handler->InitFromChallenge(challenge.begin(), challenge.end(),
-                                        target)) {
+                                        target, origin)) {
       // Invalid/unsupported challenge.
       tmp_handler = NULL;
     }
   }
   handler->swap(tmp_handler);
 }
 
 void HttpAuth::ChallengeTokenizer::Init(std::string::const_iterator begin,
                                         std::string::const_iterator end) {
   // The first space-separated token is the auth-scheme.
@@ skipping 77 matching lines @@
       return "Proxy-Authorization";
     case AUTH_SERVER:
       return "Authorization";
     default:
       NOTREACHED();
       return "";
   }
 }
 
 }  // namespace net