base::Bind: Convert most of net/http.

net/http/http_auth_handler_negotiate_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 "net/http/http_auth_handler_negotiate.h"
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
@@ skipping 202 matching lines @@
   scoped_ptr<HttpAuthHandlerNegotiate::Factory> factory_;
 };
 
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCname) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       true, false, true, "http://alias:500", &auth_handler));
 
   ASSERT_TRUE(auth_handler.get() != NULL);
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                &callback, &token));
+                                                callback.callback(), &token));
 #if defined(OS_WIN)
   EXPECT_EQ(L"HTTP/alias", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ(L"HTTP@alias", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCnameStandardPort) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       true, true, true, "http://alias:80", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                &callback, &token));
+                                                callback.callback(), &token));
 #if defined(OS_WIN)
   EXPECT_EQ(L"HTTP/alias", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ(L"HTTP@alias", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCnameNonstandardPort) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       true, true, true, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                &callback, &token));
+                                                callback.callback(), &token));
 #if defined(OS_WIN)
   EXPECT_EQ(L"HTTP/alias:500", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ(L"HTTP@alias:500", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, CnameSync) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       false, false, true, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   EXPECT_EQ(OK, auth_handler->GenerateAuthToken(NULL, &request_info,
-                                                &callback, &token));
+                                                callback.callback(), &token));
 #if defined(OS_WIN)
   EXPECT_EQ(L"HTTP/canonical.example.com", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ(L"HTTP@canonical.example.com", auth_handler->spn());
 #endif
 }
 
 TEST_F(HttpAuthHandlerNegotiateTest, CnameAsync) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       false, false, false, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   EXPECT_EQ(ERR_IO_PENDING, auth_handler->GenerateAuthToken(
-      NULL, &request_info, &callback, &token));
+      NULL, &request_info, callback.callback(), &token));
   EXPECT_EQ(OK, callback.WaitForResult());
 #if defined(OS_WIN)
   EXPECT_EQ(L"HTTP/canonical.example.com", auth_handler->spn());
 #elif defined(OS_POSIX)
   EXPECT_EQ(L"HTTP@canonical.example.com", auth_handler->spn());
 #endif
 }
 
 #if defined(OS_POSIX)
 
 // This test is only for GSSAPI, as we can't use explicit credentials with
 // that library.
 TEST_F(HttpAuthHandlerNegotiateTest, ServerNotInKerberosDatabase) {
   SetupErrorMocks(AuthLibrary(), GSS_S_FAILURE, 0x96C73A07);  // No server
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       false, false, false, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   EXPECT_EQ(ERR_IO_PENDING, auth_handler->GenerateAuthToken(
-      NULL, &request_info, &callback, &token));
+      NULL, &request_info, callback.callback(), &token));
   EXPECT_EQ(ERR_MISSING_AUTH_CREDENTIALS, callback.WaitForResult());
 }
 
 // This test is only for GSSAPI, as we can't use explicit credentials with
 // that library.
 TEST_F(HttpAuthHandlerNegotiateTest, NoKerberosCredentials) {
   SetupErrorMocks(AuthLibrary(), GSS_S_FAILURE, 0x96C73AC3);  // No credentials
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       false, false, false, "http://alias:500", &auth_handler));
   ASSERT_TRUE(auth_handler.get() != NULL);
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HttpRequestInfo request_info;
   std::string token;
   EXPECT_EQ(ERR_IO_PENDING, auth_handler->GenerateAuthToken(
-      NULL, &request_info, &callback, &token));
+      NULL, &request_info, callback.callback(), &token));
   EXPECT_EQ(ERR_MISSING_AUTH_CREDENTIALS, callback.WaitForResult());
 }
 
 #if defined(DLOPEN_KERBEROS)
 TEST_F(HttpAuthHandlerNegotiateTest, MissingGSSAPI) {
   scoped_ptr<HostResolver> host_resolver(new MockHostResolver());
   MockAllowURLSecurityManager url_security_manager;
   scoped_ptr<HttpAuthHandlerNegotiate::Factory> negotiate_factory(
       new HttpAuthHandlerNegotiate::Factory());
   negotiate_factory->set_host_resolver(host_resolver.get());
@@ skipping 10 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