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

net/http/http_auth_controller.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_controller.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/auth.h"
 #include "net/base/host_resolver.h"
 #include "net/base/net_util.h"
 #include "net/http/http_auth_handler.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
@@ skipping 137 matching lines @@
     const GURL& auth_url,
     HttpAuthCache* http_auth_cache,
     HttpAuthHandlerFactory* http_auth_handler_factory)
     : target_(target),
       auth_url_(auth_url),
       auth_origin_(auth_url.GetOrigin()),
       auth_path_(HttpAuth::AUTH_PROXY ? std::string() : auth_url.path()),
       embedded_identity_used_(false),
       default_credentials_used_(false),
       http_auth_cache_(http_auth_cache),
-      http_auth_handler_factory_(http_auth_handler_factory),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          io_callback_(this, &HttpAuthController::OnIOComplete)),
-      user_callback_(NULL) {
+      http_auth_handler_factory_(http_auth_handler_factory) {
 }
 
 HttpAuthController::~HttpAuthController() {
   DCHECK(CalledOnValidThread());
-  user_callback_ = NULL;
 }
 
-int HttpAuthController::MaybeGenerateAuthToken(const HttpRequestInfo* request,
-                                               OldCompletionCallback* callback,
-                                               const BoundNetLog& net_log) {
+int HttpAuthController::MaybeGenerateAuthToken(
+    const HttpRequestInfo* request, const CompletionCallback& callback,
+    const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   bool needs_auth = HaveAuth() || SelectPreemptiveAuth(net_log);
   if (!needs_auth)
     return OK;
   const AuthCredentials* credentials = NULL;
   if (identity_.source != HttpAuth::IDENT_SRC_DEFAULT_CREDENTIALS)
     credentials = &identity_.credentials;
   DCHECK(auth_token_.empty());
-  DCHECK(NULL == user_callback_);
-  int rv = handler_->GenerateAuthToken(credentials,
-                                       request,
-                                       &io_callback_,
-                                       &auth_token_);
+  DCHECK(callback_.is_null());
+  int rv = handler_->GenerateAuthToken(
+      credentials, request,
+      base::Bind(&HttpAuthController::OnIOComplete, base::Unretained(this)),
+      &auth_token_);
   if (DisableOnAuthHandlerResult(rv))
     rv = OK;
   if (rv == ERR_IO_PENDING)
-    user_callback_ = callback;
+    callback_ = callback;
   else
     OnIOComplete(rv);
   return rv;
 }
 
 bool HttpAuthController::SelectPreemptiveAuth(const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(!HaveAuth());
   DCHECK(identity_.invalid);
 
@@ skipping 331 matching lines @@
 
     default:
       return false;
   }
 }
 
 void HttpAuthController::OnIOComplete(int result) {
   DCHECK(CalledOnValidThread());
   if (DisableOnAuthHandlerResult(result))
     result = OK;
-  if (user_callback_) {
-    OldCompletionCallback* c = user_callback_;
-    user_callback_ = NULL;
-    c->Run(result);
+  if (!callback_.is_null()) {
+    CompletionCallback c = callback_;
+    callback_.Reset();
+    c.Run(result);
   }
 }
 
 scoped_refptr<AuthChallengeInfo> HttpAuthController::auth_info() {
   DCHECK(CalledOnValidThread());
   return auth_info_;
 }
 
 bool HttpAuthController::IsAuthSchemeDisabled(HttpAuth::Scheme scheme) const {
   DCHECK(CalledOnValidThread());
   return disabled_schemes_.find(scheme) != disabled_schemes_.end();
 }
 
 void HttpAuthController::DisableAuthScheme(HttpAuth::Scheme scheme) {
   DCHECK(CalledOnValidThread());
   disabled_schemes_.insert(scheme);
 }
 
 }  // namespace net