Merge r25564 and r26588 from the trunk....

net/http/http_auth_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/ref_counted.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_handler.h"
 #include "net/http/http_response_headers.h"
@@ skipping 30 matching lines @@
       "DigestRealm",
     },
     {
       "Y: Digest realm=\"X\", nonce=\"aaaaaaaaaa\"\n"
       "www-authenticate:\n",
 
       // Handle null header value.
       "",
     }
   };
+  GURL origin("http://www.example.com");
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     // Make a HttpResponseHeaders object.
     std::string headers_with_status_line("HTTP/1.1 401 Unauthorized\n");
     headers_with_status_line += tests[i].headers;
     scoped_refptr<net::HttpResponseHeaders> headers(
        new net::HttpResponseHeaders(
             net::HttpUtil::AssembleRawHeaders(
                 headers_with_status_line.c_str(),
                 headers_with_status_line.length())));
 
     scoped_refptr<HttpAuthHandler> handler;
     HttpAuth::ChooseBestChallenge(headers.get(),
                                   HttpAuth::AUTH_SERVER,
+                                  origin,
                                   &handler);
 
     if (handler) {
       EXPECT_STREQ(tests[i].challenge_realm, handler->realm().c_str());
     } else {
       EXPECT_STREQ("", tests[i].challenge_realm);
     }
   }
 }
 
@@ skipping 17 matching lines @@
       "UAAQAaAEEASwBFAEUAUwBBAFIAQQAtAEMATwBSAFAABAAeAGMAbwByA"
       "HAALgBnAG8AbwBnAGwAZQAuAGMAbwBtAAMAQABhAGsAZQBlAHMAYQBy"
       "AGEALQBjAG8AcgBwAC4AYQBkAC4AYwBvAHIAcAAuAGcAbwBvAGcAbAB"
       "lAC4AYwBvAG0ABQAeAGMAbwByAHAALgBnAG8AbwBnAGwAZQAuAGMAbw"
       "BtAAAAAAA=\r\n",
 
       // Realm is empty.
       "",
     }
   };
+  GURL origin("http://www.example.com");
 
   scoped_refptr<HttpAuthHandler> handler;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     // Make a HttpResponseHeaders object.
     std::string headers_with_status_line("HTTP/1.1 401 Unauthorized\n");
     headers_with_status_line += tests[i].headers;
     scoped_refptr<net::HttpResponseHeaders> headers(
        new net::HttpResponseHeaders(
             net::HttpUtil::AssembleRawHeaders(
                 headers_with_status_line.c_str(),
                 headers_with_status_line.length())));
 
     scoped_refptr<HttpAuthHandler> old_handler = handler;
     HttpAuth::ChooseBestChallenge(headers.get(),
                                   HttpAuth::AUTH_SERVER,
+                                  origin,
                                   &handler);
 
     EXPECT_TRUE(handler != NULL);
     // Since NTLM is connection-based, we should continue to use the existing
     // handler rather than creating a new one.
     if (i != 0)
       EXPECT_EQ(old_handler, handler);
 
     EXPECT_STREQ(tests[i].challenge_realm, handler->realm().c_str());
   }
@@ skipping 95 matching lines @@
   std::string name;
 
   name = HttpAuth::GetAuthorizationHeaderName(HttpAuth::AUTH_SERVER);
   EXPECT_STREQ("Authorization", name.c_str());
 
   name = HttpAuth::GetAuthorizationHeaderName(HttpAuth::AUTH_PROXY);
   EXPECT_STREQ("Proxy-Authorization", name.c_str());
 }
 
 TEST(HttpAuthTest, CreateAuthHandler) {
+  GURL server_origin("http://www.example.com");
+  GURL proxy_origin("http://cache.example.com:3128");
   {
     scoped_refptr<HttpAuthHandler> handler;
     HttpAuth::CreateAuthHandler("Basic realm=\"FooBar\"",
                                 HttpAuth::AUTH_SERVER,
+                                server_origin,
                                 &handler);
     EXPECT_FALSE(handler.get() == NULL);
     EXPECT_STREQ("basic", handler->scheme().c_str());
     EXPECT_STREQ("FooBar", handler->realm().c_str());
     EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target());
     EXPECT_FALSE(handler->encrypts_identity());
     EXPECT_FALSE(handler->is_connection_based());
   }
   {
     scoped_refptr<HttpAuthHandler> handler;
     HttpAuth::CreateAuthHandler("UNSUPPORTED realm=\"FooBar\"",
                                 HttpAuth::AUTH_SERVER,
+                                server_origin,
                                 &handler);
     EXPECT_TRUE(handler.get() == NULL);
   }
   {
     scoped_refptr<HttpAuthHandler> handler;
     HttpAuth::CreateAuthHandler("Digest realm=\"FooBar\", nonce=\"xyz\"",
                                 HttpAuth::AUTH_PROXY,
+                                proxy_origin,
                                 &handler);
     EXPECT_FALSE(handler.get() == NULL);
     EXPECT_STREQ("digest", handler->scheme().c_str());
     EXPECT_STREQ("FooBar", handler->realm().c_str());
     EXPECT_EQ(HttpAuth::AUTH_PROXY, handler->target());
     EXPECT_TRUE(handler->encrypts_identity());
     EXPECT_FALSE(handler->is_connection_based());
   }
   {
     scoped_refptr<HttpAuthHandler> handler;
     HttpAuth::CreateAuthHandler("NTLM",
                                 HttpAuth::AUTH_SERVER,
+                                server_origin,
                                 &handler);
     EXPECT_FALSE(handler.get() == NULL);
     EXPECT_STREQ("ntlm", handler->scheme().c_str());
     EXPECT_STREQ("", handler->realm().c_str());
     EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target());
     EXPECT_TRUE(handler->encrypts_identity());
     EXPECT_TRUE(handler->is_connection_based());
   }
 }
 
 }  // namespace net