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

net/http/http_auth_handler_negotiate_unittest.cc

 // Copyright (c) 2012 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_negotiate.h"
 
 #include <string>
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.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_request_info.h"
+#include "net/http/http_response_info.h"
 #include "net/http/mock_allow_url_security_manager.h"
 #if defined(OS_ANDROID)
 #include "net/android/dummy_spnego_authenticator.h"
 #elif defined(OS_WIN)
 #include "net/http/mock_sspi_library_win.h"
 #elif defined(OS_POSIX)
 #include "net/http/mock_gssapi_library_posix.h"
 #endif
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
@@ skipping 158 matching lines @@
     mock_library->ExpectSecurityContext(query.expected_package,
                                         query.response_code,
                                         query.minor_response_code,
                                         query.context_info,
                                         query.expected_input_token,
                                         query.output_token);
   }
 
 #endif  // defined(OS_POSIX)
 
-  int CreateHandler(bool disable_cname_lookup, bool use_port,
-                     bool synchronous_resolve_mode,
-                     const std::string& url_string,
-                     scoped_ptr<HttpAuthHandlerNegotiate>* handler) {
+  int CreateHandler(bool disable_cname_lookup,
+                    bool use_port,
+                    bool synchronous_resolve_mode,
+                    const std::string& url_string,
+                    scoped_ptr<HttpAuthHandlerNegotiate>* handler) {
     factory_->set_disable_cname_lookup(disable_cname_lookup);
     factory_->set_use_port(use_port);
     resolver_->set_synchronous_mode(synchronous_resolve_mode);
     GURL gurl(url_string);
 
     // Note: This is a little tricky because CreateAuthHandlerFromString
     // expects a scoped_ptr<HttpAuthHandler>* rather than a
     // scoped_ptr<HttpAuthHandlerNegotiate>*. This needs to do the cast
     // after creating the handler, and make sure that generic_handler
     // no longer holds on to the HttpAuthHandlerNegotiate object.
     std::string challenge = "Negotiate";
     HttpAuthChallengeTokenizer tokenizer(challenge.begin(), challenge.end());
 
     scoped_ptr<HttpAuthHandler> generic_handler =
         factory_->CreateAuthHandlerForScheme(tokenizer.NormalizedScheme());
     if (!generic_handler)
       return ERR_UNSUPPORTED_AUTH_SCHEME;
+    HttpResponseInfo fake_response_info;
+    TestCompletionCallback callback;
     int rv = generic_handler->HandleInitialChallenge(
-        tokenizer, HttpAuth::AUTH_SERVER, gurl, BoundNetLog());
+        tokenizer, fake_response_info, HttpAuth::AUTH_SERVER, gurl,
+        BoundNetLog(), callback.callback());
+    rv = callback.GetResult(rv);
     if (rv != OK)
       return rv;
     HttpAuthHandlerNegotiate* negotiate_handler =
         static_cast<HttpAuthHandlerNegotiate*>(generic_handler.release());
     handler->reset(negotiate_handler);
     return rv;
   }
 
   MockAuthLibrary* AuthLibrary() { return auth_library_; }
 
@@ skipping 157 matching lines @@
       BoundNetLog(),
       &generic_handler);
   EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv);
   EXPECT_TRUE(generic_handler.get() == NULL);
 }
 #endif  // defined(DLOPEN_KERBEROS)
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace net