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

net/http/http_auth_handler_negotiate.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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 88 matching lines @@
 #if defined(OS_WIN)
     : auth_system_(auth_library, "Negotiate", NEGOSSP_NAME, max_token_length),
 #elif defined(OS_POSIX)
     : auth_system_(auth_library, "Negotiate", CHROME_GSS_KRB5_MECH_OID_DESC),
 #endif
       disable_cname_lookup_(disable_cname_lookup),
       use_port_(use_port),
       resolver_(resolver),
       already_called_(false),
       has_credentials_(false),
-      user_callback_(NULL),
       auth_token_(NULL),
       next_state_(STATE_NONE),
       url_security_manager_(url_security_manager) {
 }
 
 HttpAuthHandlerNegotiate::~HttpAuthHandlerNegotiate() {
 }
 
 std::wstring HttpAuthHandlerNegotiate::CreateSPN(
     const AddressList& address_list, const GURL& origin) {
@@ skipping 85 matching lines @@
     auth_system_.Delegate();
   auth_scheme_ = HttpAuth::AUTH_SCHEME_NEGOTIATE;
   score_ = 4;
   properties_ = ENCRYPTS_IDENTITY | IS_CONNECTION_BASED;
   HttpAuth::AuthorizationResult auth_result =
       auth_system_.ParseChallenge(challenge);
   return (auth_result == HttpAuth::AUTHORIZATION_RESULT_ACCEPT);
 }
 
 int HttpAuthHandlerNegotiate::GenerateAuthTokenImpl(
-    const AuthCredentials* credentials,
-    const HttpRequestInfo* request,
-    OldCompletionCallback* callback,
-    std::string* auth_token) {
-  DCHECK(user_callback_ == NULL);
+    const AuthCredentials* credentials, const HttpRequestInfo* request,
+    const CompletionCallback& callback, std::string* auth_token) {
+  DCHECK(callback_.is_null());
   DCHECK(auth_token_ == NULL);
   auth_token_ = auth_token;
   if (already_called_) {
     DCHECK((!has_credentials_ && credentials == NULL) ||
            (has_credentials_ && credentials->Equals(credentials_)));
     next_state_ = STATE_GENERATE_AUTH_TOKEN;
   } else {
     already_called_ = true;
     if (credentials) {
       has_credentials_ = true;
       credentials_ = *credentials;
     }
     next_state_ = STATE_RESOLVE_CANONICAL_NAME;
   }
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
-    user_callback_ = callback;
+    callback_ = callback;
   return rv;
 }
 
 void HttpAuthHandlerNegotiate::OnIOComplete(int result) {
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
     DoCallback(rv);
 }
 
 void HttpAuthHandlerNegotiate::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
-  DCHECK(user_callback_);
-  OldCompletionCallback* callback = user_callback_;
-  user_callback_ = NULL;
-  callback->Run(rv);
+  DCHECK(!callback_.is_null());
+  CompletionCallback callback = callback_;
+  callback_.Reset();
+  callback.Run(rv);
 }
 
 int HttpAuthHandlerNegotiate::DoLoop(int result) {
   DCHECK(next_state_ != STATE_NONE);
 
   int rv = result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
@@ skipping 70 matching lines @@
 bool HttpAuthHandlerNegotiate::CanDelegate() const {
   // TODO(cbentzel): Should delegation be allowed on proxies?
   if (target_ == HttpAuth::AUTH_PROXY)
     return false;
   if (!url_security_manager_)
     return false;
   return url_security_manager_->CanDelegate(origin_);
 }
 
 }  // namespace net