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

net/http/http_auth_handler.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.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 HttpAuthHandler::HttpAuthHandler()
     : auth_scheme_(HttpAuth::AUTH_SCHEME_MAX),
       score_(-1),
       target_(HttpAuth::AUTH_NONE),
-      properties_(-1),
-      original_callback_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          wrapper_callback_(
-              this, &HttpAuthHandler::OnGenerateAuthTokenComplete)) {
+      properties_(-1) {
 }
 
 HttpAuthHandler::~HttpAuthHandler() {
 }
 
 bool HttpAuthHandler::InitFromChallenge(
     HttpAuth::ChallengeTokenizer* challenge,
     HttpAuth::Target target,
     const GURL& origin,
     const BoundNetLog& net_log) {
@@ skipping 24 matching lines @@
     case HttpAuth::AUTH_SERVER:
       return NetLog::TYPE_AUTH_SERVER;
     default:
       NOTREACHED();
       return NetLog::TYPE_CANCELLED;
   }
 }
 
 }  // namespace
 
-int HttpAuthHandler::GenerateAuthToken(const AuthCredentials* credentials,
-                                       const HttpRequestInfo* request,
-                                       OldCompletionCallback* callback,
-                                       std::string* auth_token) {
+int HttpAuthHandler::GenerateAuthToken(
+    const AuthCredentials* credentials, const HttpRequestInfo* request,
+    const CompletionCallback& callback, std::string* auth_token) {
   // TODO(cbentzel): Enforce non-NULL callback after cleaning up SocketStream.
   DCHECK(request);
   DCHECK(credentials != NULL || AllowsDefaultCredentials());
   DCHECK(auth_token != NULL);
-  DCHECK(original_callback_ == NULL);
-  original_callback_ = callback;
+  DCHECK(callback_.is_null());
+  callback_ = callback;
   net_log_.BeginEvent(EventTypeFromAuthTarget(target_), NULL);
-  int rv = GenerateAuthTokenImpl(credentials, request,
-                                 &wrapper_callback_, auth_token);
+  int rv = GenerateAuthTokenImpl(
+      credentials, request,
+      base::Bind(&HttpAuthHandler::OnGenerateAuthTokenComplete,
+                 base::Unretained(this)),
+      auth_token);
   if (rv != ERR_IO_PENDING)
     FinishGenerateAuthToken();
   return rv;
 }
 
 bool HttpAuthHandler::NeedsIdentity() {
   return true;
 }
 
 bool HttpAuthHandler::AllowsDefaultCredentials() {
   return false;
 }
 
 bool HttpAuthHandler::AllowsExplicitCredentials() {
   return true;
 }
 
 void HttpAuthHandler::OnGenerateAuthTokenComplete(int rv) {
-  OldCompletionCallback* callback = original_callback_;
+  CompletionCallback callback = callback_;
   FinishGenerateAuthToken();
-  if (callback)
-    callback->Run(rv);
+  if (!callback.is_null())
+    callback.Run(rv);
 }
 
 void HttpAuthHandler::FinishGenerateAuthToken() {
   // TOOD(cbentzel): Should this be done in OK case only?
   net_log_.EndEvent(EventTypeFromAuthTarget(target_), NULL);
-  original_callback_ = NULL;
+  callback_.Reset();
 }
 
 }  // namespace net