[net/http auth] Split HttpAuthHandler creation from initialization.

net/http/http_auth_handler_digest_unittest.cc

 // 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.
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
@@ skipping 32 matching lines @@
   EXPECT_TRUE(target != HttpAuth::AUTH_PROXY || !proxy_name.empty());
   EXPECT_FALSE(request_url.empty());
   EXPECT_FALSE(challenge.empty());
 
   token->clear();
   scoped_ptr<HttpAuthHandlerDigest::Factory> factory(
       new HttpAuthHandlerDigest::Factory());
   HttpAuthHandlerDigest::NonceGenerator* nonce_generator =
       new HttpAuthHandlerDigest::FixedNonceGenerator("client_nonce");
   factory->set_nonce_generator(nonce_generator);
-  scoped_ptr<HttpAuthHandler> handler;
 
   // Create a handler for a particular challenge.
   GURL url_origin(target == HttpAuth::AUTH_SERVER ? request_url : proxy_name);
-  int rv_create = factory->CreateAuthHandlerFromString(
-    challenge, target, url_origin.GetOrigin(), BoundNetLog(), &handler);
-  if (rv_create != OK || handler.get() == NULL) {
+  HttpAuthChallengeTokenizer tokenizer(challenge.begin(), challenge.end());
+  scoped_ptr<HttpAuthHandler> handler =
+      factory->CreateAuthHandlerForScheme(tokenizer.NormalizedScheme());
+  int rv = handler->HandleInitialChallenge(
+      tokenizer, target, url_origin.GetOrigin(), BoundNetLog());
+  if (rv != OK || handler.get() == NULL) {
     ADD_FAILURE() << "Unable to create auth handler.";
     return false;
   }
 
   // Create a token in response to the challenge.
   // NOTE: HttpAuthHandlerDigest's implementation of GenerateAuthToken always
   // completes synchronously. That's why this test can get away with a
   // TestCompletionCallback without an IO thread.
   TestCompletionCallback callback;
   scoped_ptr<HttpRequestInfo> request(new HttpRequestInfo());
   request->url = GURL(request_url);
   AuthCredentials credentials(base::ASCIIToUTF16("foo"),
                               base::ASCIIToUTF16("bar"));
-  int rv_generate = handler->GenerateAuthToken(&credentials, *request,
-                                               callback.callback(), token);
-  if (rv_generate != OK) {
+  rv = handler->GenerateAuthToken(&credentials, *request, callback.callback(),
+                                  token);
+  if (rv != OK) {
     ADD_FAILURE() << "Problems generating auth token";
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
+TEST(HttpAuthHandlerDigestTest, CreateAuthHandlerForScheme) {
+  HttpAuthHandlerDigest::Factory digest_factory;
+
+  EXPECT_TRUE(digest_factory.CreateAuthHandlerForScheme("digest"));
+  EXPECT_FALSE(digest_factory.CreateAuthHandlerForScheme("bogus"));
+}
+
+TEST(HttpAuthHandlerDigestTest, CreateAndInitPreemptiveAuthHandler_Valid) {
+  HttpAuthHandlerDigest::Factory digest_factory;
+  HttpAuthCache auth_cache;
+  std::string challenge(kSimpleChallenge);
+  HttpAuthChallengeTokenizer tokenizer(challenge.begin(), challenge.end());
+
+  HttpAuthCache::Entry* entry =
+      auth_cache.Add(GURL("http://example.com/foo").GetOrigin(), "foo",
+                     "digest", challenge, AuthCredentials(), "/foo");
+  EXPECT_TRUE(digest_factory.CreateAndInitPreemptiveAuthHandler(
+      entry, tokenizer, HttpAuth::AUTH_SERVER, BoundNetLog()));
+}
+
+TEST(HttpAuthHandlerDigestTest, CreateAndInitPreemptiveAuthHandler_Invalid) {
+  HttpAuthHandlerDigest::Factory digest_factory;
+  HttpAuthCache auth_cache;
+  std::string challenge("Basic realm=\"bar\"");
+  HttpAuthChallengeTokenizer tokenizer(challenge.begin(), challenge.end());
+
+  HttpAuthCache::Entry* entry =
+      auth_cache.Add(GURL("http://example.com").GetOrigin(), "bar", "basic",
+                     challenge, AuthCredentials(), "/bar");
+  EXPECT_FALSE(digest_factory.CreateAndInitPreemptiveAuthHandler(
+      entry, tokenizer, HttpAuth::AUTH_SERVER, BoundNetLog()));
+}
 
 TEST(HttpAuthHandlerDigestTest, ParseChallenge) {
   static const struct {
     // The challenge string.
     const char* challenge;
     // Expected return value of ParseChallenge.
     bool parsed_success;
     // The expected values that were parsed.
     const char* parsed_realm;
     const char* parsed_nonce;
@@ skipping 232 matching lines @@
       "domain=\"http://intranet.example.com/protection http://www.google.com\"",
       true,
       "Thunder Bluff",
       "xyz",
       "http://intranet.example.com/protection http://www.google.com",
       "",
       false,
       HttpAuthHandlerDigest::ALGORITHM_UNSPECIFIED,
       HttpAuthHandlerDigest::QOP_UNSPECIFIED
     },
-
-    { // If a non-Digest scheme is somehow passed in, it should be rejected.
-      "Basic realm=\"foo\"",
-      false,
-      "",
-      "",
-      "",
-      "",
-      false,
-      HttpAuthHandlerDigest::ALGORITHM_UNSPECIFIED,
-      HttpAuthHandlerDigest::QOP_UNSPECIFIED
-    },
   };
 
   GURL origin("http://www.example.com");
   scoped_ptr<HttpAuthHandlerDigest::Factory> factory(
       new HttpAuthHandlerDigest::Factory());
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    scoped_ptr<HttpAuthHandler> handler;
-    int rv = factory->CreateAuthHandlerFromString(tests[i].challenge,
-                                                  HttpAuth::AUTH_SERVER,
-                                                  origin,
-                                                  BoundNetLog(),
-                                                  &handler);
+    std::string challenge = tests[i].challenge;
+    HttpAuthChallengeTokenizer tokenizer(challenge.begin(), challenge.end());
+    scoped_ptr<HttpAuthHandler> handler =
+        factory->CreateAuthHandlerForScheme(tokenizer.NormalizedScheme());
+    ASSERT_TRUE(handler);
+    int rv = handler->HandleInitialChallenge(tokenizer, HttpAuth::AUTH_SERVER,
+                                             origin, BoundNetLog());
     if (tests[i].parsed_success) {
       EXPECT_EQ(OK, rv);
     } else {
       EXPECT_NE(OK, rv);
-      EXPECT_TRUE(handler.get() == NULL);
       continue;
     }
-    ASSERT_TRUE(handler.get() != NULL);
     HttpAuthHandlerDigest* digest =
         static_cast<HttpAuthHandlerDigest*>(handler.get());
     EXPECT_STREQ(tests[i].parsed_realm, digest->realm_.c_str());
     EXPECT_STREQ(tests[i].parsed_nonce, digest->nonce_.c_str());
     EXPECT_STREQ(tests[i].parsed_domain, digest->domain_.c_str());
     EXPECT_STREQ(tests[i].parsed_opaque, digest->opaque_.c_str());
     EXPECT_EQ(tests[i].parsed_stale, digest->stale_);
     EXPECT_EQ(tests[i].parsed_algorithm, digest->algorithm_);
     EXPECT_EQ(tests[i].parsed_qop, digest->qop_);
     EXPECT_TRUE(handler->NeedsIdentity());
@@ skipping 129 matching lines @@
       "Digest username=\"USER\", realm=\"Baztastic\", "
       "nonce=\"AAAAAAAA\", uri=\"/\", algorithm=MD5-sess, "
       "response=\"cbc1139821ee7192069580570c541a03\", "
       "qop=auth, nc=00000001, cnonce=\"15c07961ed8575c4\""
     }
   };
   GURL origin("http://www.example.com");
   scoped_ptr<HttpAuthHandlerDigest::Factory> factory(
       new HttpAuthHandlerDigest::Factory());
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    scoped_ptr<HttpAuthHandler> handler;
-    int rv = factory->CreateAuthHandlerFromString(tests[i].challenge,
-                                                  HttpAuth::AUTH_SERVER,
-                                                  origin,
-                                                  BoundNetLog(),
-                                                  &handler);
+    scoped_ptr<HttpAuthHandler> handler =
+        factory->CreateAuthHandlerForScheme("digest");
+    std::string challenge = tests[i].challenge;
+    HttpAuthChallengeTokenizer tokenizer(challenge.begin(), challenge.end());
+    int rv = handler->HandleInitialChallenge(tokenizer, HttpAuth::AUTH_SERVER,
+                                             origin, BoundNetLog());
     EXPECT_EQ(OK, rv);
-    ASSERT_TRUE(handler != NULL);
 
     HttpAuthHandlerDigest* digest =
         static_cast<HttpAuthHandlerDigest*>(handler.get());
     std::string creds =
         digest->AssembleCredentials(tests[i].req_method,
                                     tests[i].req_path,
                                     AuthCredentials(
                                         base::ASCIIToUTF16(tests[i].username),
                                         base::ASCIIToUTF16(tests[i].password)),
                                     tests[i].cnonce,
                                     tests[i].nonce_count);
 
     EXPECT_STREQ(tests[i].expected_creds, creds.c_str());
   }
 }
 
 TEST(HttpAuthHandlerDigest, HandleAnotherChallenge) {
   scoped_ptr<HttpAuthHandlerDigest::Factory> factory(
       new HttpAuthHandlerDigest::Factory());
-  scoped_ptr<HttpAuthHandler> handler;
   std::string default_challenge =
       "Digest realm=\"Oblivion\", nonce=\"nonce-value\"";
-  GURL origin("intranet.google.com");
-  int rv = factory->CreateAuthHandlerFromString(
-      default_challenge, HttpAuth::AUTH_SERVER, origin, BoundNetLog(),
-      &handler);
-  EXPECT_EQ(OK, rv);
-  ASSERT_TRUE(handler.get() != NULL);
   HttpAuthChallengeTokenizer tok_default(default_challenge.begin(),
                                          default_challenge.end());
+  GURL origin("intranet.google.com");
+  scoped_ptr<HttpAuthHandler> handler =
+      factory->CreateAuthHandlerForScheme(tok_default.NormalizedScheme());
+  EXPECT_EQ(OK, handler->HandleInitialChallenge(
+                    tok_default, HttpAuth::AUTH_SERVER, origin, BoundNetLog()));
+  ASSERT_TRUE(handler.get() != NULL);
   EXPECT_EQ(HttpAuth::AUTHORIZATION_RESULT_REJECT,
             handler->HandleAnotherChallenge(tok_default));
 
   std::string stale_challenge = default_challenge + ", stale=true";
   HttpAuthChallengeTokenizer tok_stale(stale_challenge.begin(),
                                        stale_challenge.end());
   EXPECT_EQ(HttpAuth::AUTHORIZATION_RESULT_STALE,
             handler->HandleAnotherChallenge(tok_stale));
 
   std::string stale_false_challenge = default_challenge + ", stale=false";
@@ skipping 121 matching lines @@
   EXPECT_EQ("Digest username=\"foo\", realm=\"Oblivion\", "
             "nonce=\"nonce-value\", uri=\"/path/to/resource\", "
             "response=\"5b1459beda5cee30d6ff9e970a69c0ea\", "
             "opaque=\"opaque text\", "
             "qop=auth, nc=00000001, cnonce=\"client_nonce\"",
             auth_token);
 }
 
 
 } // namespace net