[net/http auth] Make HttpAuthHandler challenge handling asynchronous.

net/http/http_auth_handler_factory_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 "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "net/base/net_errors.h"
+#include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_auth_challenge_tokenizer.h"
 #include "net/http/http_auth_handler.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_auth_handler_mock.h"
+#include "net/http/http_response_info.h"
 #include "net/http/mock_allow_url_security_manager.h"
 #include "net/http/url_security_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 class MockHttpAuthHandlerFactory : public HttpAuthHandlerFactory {
  public:
   explicit MockHttpAuthHandlerFactory(const char* scheme)
       : scheme_(base::ToLowerASCII(scheme)) {}
   ~MockHttpAuthHandlerFactory() override {}
 
   scoped_ptr<HttpAuthHandler> CreateAuthHandlerForScheme(
       const std::string& scheme) override {
+    if (scheme_.empty())
+      return scoped_ptr<HttpAuthHandler>();
     EXPECT_EQ(scheme, scheme_) << scheme << " vs. " << scheme_;
     return make_scoped_ptr(new HttpAuthHandlerMock());
   }
   scoped_ptr<HttpAuthHandler> CreateAndInitPreemptiveAuthHandler(
       HttpAuthCache::Entry* cache_entry,
-      const HttpAuthChallengeTokenizer& tokenizer,
       HttpAuth::Target target,
       const BoundNetLog& net_log) override {
     EXPECT_EQ(cache_entry->scheme(), scheme_) << cache_entry->scheme()
                                               << " vs. " << scheme_;
     return make_scoped_ptr(new HttpAuthHandlerMock());
   }
 
  private:
   std::string scheme_;
 };
@@ skipping 23 matching lines @@
       "digest", new MockHttpAuthHandlerFactory("digest"));
   handler = registry_factory.CreateAuthHandlerForScheme("basic");
   EXPECT_TRUE(handler);
   handler = registry_factory.CreateAuthHandlerForScheme("digest");
   EXPECT_TRUE(handler);
   handler = registry_factory.CreateAuthHandlerForScheme("bogus");
   EXPECT_FALSE(handler);
 
   // Test replacement of existing schemes.
   registry_factory.RegisterSchemeFactory("digest",
-                                         new HttpAuthHandlerMock::Factory());
+                                         new MockHttpAuthHandlerFactory(""));
   handler = registry_factory.CreateAuthHandlerForScheme("digest");
   EXPECT_FALSE(handler);
   registry_factory.RegisterSchemeFactory(
       "digest", new MockHttpAuthHandlerFactory("digest"));
   handler = registry_factory.CreateAuthHandlerForScheme("digest");
   EXPECT_TRUE(handler);
 }
 
 TEST(HttpAuthHandlerFactoryTest, DefaultFactory) {
   scoped_ptr<HostResolver> host_resolver(new MockHostResolver());
   MockAllowURLSecurityManager url_security_manager;
   scoped_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory(
       HttpAuthHandlerFactory::CreateDefault(host_resolver.get()));
   http_auth_handler_factory->SetURLSecurityManager(
       "negotiate", &url_security_manager);
   GURL server_origin("http://www.example.com");
   GURL proxy_origin("http://cache.example.com:3128");
+  TestCompletionCallback callback;
+  HttpResponseInfo response_info;
   {
     std::string challenge = "Basic realm=\"FooBar\"";
     HttpAuthChallengeTokenizer tokenizer(challenge.begin(), challenge.end());
     scoped_ptr<HttpAuthHandler> handler =
         http_auth_handler_factory->CreateAuthHandlerForScheme(
             tokenizer.NormalizedScheme());
     ASSERT_TRUE(handler);
-    int rv = handler->HandleInitialChallenge(tokenizer, HttpAuth::AUTH_SERVER,
-                                             server_origin, BoundNetLog());
-    EXPECT_EQ(OK, rv);
-    ASSERT_FALSE(handler.get() == NULL);
+    int rv = handler->HandleInitialChallenge(
+        tokenizer, response_info, HttpAuth::AUTH_SERVER, server_origin,
+        BoundNetLog(), callback.callback());
+    EXPECT_EQ(OK, callback.GetResult(rv));
     EXPECT_EQ("basic", handler->auth_scheme());
     EXPECT_STREQ("FooBar", handler->realm().c_str());
     EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target());
   }
   {
     scoped_ptr<HttpAuthHandler> handler =
         http_auth_handler_factory->CreateAuthHandlerForScheme("UNSUPPORTED");
     EXPECT_FALSE(handler);
   }
   {
     std::string challenge = "Digest realm=\"FooBar\", nonce=\"xyz\"";
     HttpAuthChallengeTokenizer tokenizer(challenge.begin(), challenge.end());
     scoped_ptr<HttpAuthHandler> handler =
         http_auth_handler_factory->CreateAuthHandlerForScheme(
             tokenizer.NormalizedScheme());
     ASSERT_TRUE(handler);
-    int rv = handler->HandleInitialChallenge(tokenizer, HttpAuth::AUTH_PROXY,
-                                             proxy_origin, BoundNetLog());
-    EXPECT_EQ(OK, rv);
-    ASSERT_FALSE(handler.get() == NULL);
+    int rv = handler->HandleInitialChallenge(
+        tokenizer, response_info, HttpAuth::AUTH_PROXY, proxy_origin,
+        BoundNetLog(), callback.callback());
+    EXPECT_EQ(OK, callback.GetResult(rv));
     EXPECT_EQ("digest", handler->auth_scheme());
     EXPECT_STREQ("FooBar", handler->realm().c_str());
     EXPECT_EQ(HttpAuth::AUTH_PROXY, handler->target());
   }
   {
     std::string challenge = "NTLM";
     HttpAuthChallengeTokenizer tokenizer(challenge.begin(), challenge.end());
     scoped_ptr<HttpAuthHandler> handler =
         http_auth_handler_factory->CreateAuthHandlerForScheme(
             tokenizer.NormalizedScheme());
     ASSERT_TRUE(handler);
-    int rv = handler->HandleInitialChallenge(tokenizer, HttpAuth::AUTH_SERVER,
-                                             server_origin, BoundNetLog());
-    EXPECT_EQ(OK, rv);
+    int rv = handler->HandleInitialChallenge(
+        tokenizer, response_info, HttpAuth::AUTH_SERVER, server_origin,
+        BoundNetLog(), callback.callback());
+    EXPECT_EQ(OK, callback.GetResult(rv));
     ASSERT_FALSE(handler.get() == NULL);
     EXPECT_EQ("ntlm", handler->auth_scheme());
     EXPECT_STREQ("", handler->realm().c_str());
     EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target());
   }
   {
     std::string challenge = "Negotiate";
     HttpAuthChallengeTokenizer tokenizer(challenge.begin(), challenge.end());
     scoped_ptr<HttpAuthHandler> handler =
         http_auth_handler_factory->CreateAuthHandlerForScheme(
             tokenizer.NormalizedScheme());
     ASSERT_TRUE(handler);
-    int rv = handler->HandleInitialChallenge(tokenizer, HttpAuth::AUTH_SERVER,
-                                             server_origin, BoundNetLog());
+    int rv = handler->HandleInitialChallenge(
+        tokenizer, response_info, HttpAuth::AUTH_SERVER, server_origin,
+        BoundNetLog(), callback.callback());
+    rv = callback.GetResult(rv);
 // Note the default factory doesn't support Kerberos on Android
 #if defined(USE_KERBEROS) && !defined(OS_ANDROID)
     EXPECT_EQ(OK, rv);
     ASSERT_FALSE(handler.get() == NULL);
     EXPECT_EQ("negotiate", handler->auth_scheme());
     EXPECT_STREQ("", handler->realm().c_str());
     EXPECT_EQ(HttpAuth::AUTH_SERVER, handler->target());
 #else
     EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv);
     EXPECT_TRUE(handler.get() == NULL);
 #endif  // defined(USE_KERBEROS) && !defined(OS_ANDROID)
   }
 }
 
 }  // namespace net