base::Bind: Convert net::NetworkDelegate.

net/url_request/url_request_http_job.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/url_request/url_request_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
@@ skipping 183 matching lines @@
     : URLRequestJob(request),
       response_info_(NULL),
       response_cookies_save_index_(0),
       proxy_auth_state_(AUTH_STATE_DONT_NEED_AUTH),
       server_auth_state_(AUTH_STATE_DONT_NEED_AUTH),
       ALLOW_THIS_IN_INITIALIZER_LIST(start_callback_(
           this, &URLRequestHttpJob::OnStartCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_(
           this, &URLRequestHttpJob::OnReadCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(notify_before_headers_sent_callback_(
-          this, &URLRequestHttpJob::NotifyBeforeSendHeadersCallback)),
+          base::Bind(&URLRequestHttpJob::NotifyBeforeSendHeadersCallback,
+                     base::Unretained(this)))),
       read_in_progress_(false),
       transaction_(NULL),
       throttling_entry_(URLRequestThrottlerManager::GetInstance()->
           RegisterRequestUrl(request->url())),
       sdch_dictionary_advertised_(false),
       sdch_test_activated_(false),
       sdch_test_control_(false),
       is_cached_content_(false),
       request_creation_time_(),
       packet_timing_enabled_(false),
       done_(false),
       bytes_observed_in_packets_(0),
       request_time_snapshot_(),
       final_packet_time_(),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           filter_context_(new HttpFilterContext(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          on_headers_received_callback_(
-              this, &URLRequestHttpJob::OnHeadersReceivedCallback)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(on_headers_received_callback_(
+          base::Bind(&URLRequestHttpJob::OnHeadersReceivedCallback,
+                     base::Unretained(this)))),
       awaiting_callback_(false) {
   ResetTimer();
 }
 
 void URLRequestHttpJob::NotifyHeadersComplete() {
   DCHECK(!response_info_);
 
   response_info_ = transaction_->GetResponseInfo();
 
   // Save boolean, as we'll need this info at destruction time, and filters may
@@ skipping 54 matching lines @@
 
   DoneWithRequest(ABORTED);
   transaction_.reset();
   response_info_ = NULL;
   context_ = NULL;
 }
 
 void URLRequestHttpJob::StartTransaction() {
   if (request_->context() && request_->context()->network_delegate()) {
     int rv = request_->context()->network_delegate()->NotifyBeforeSendHeaders(
-        request_, &notify_before_headers_sent_callback_,
+        request_, notify_before_headers_sent_callback_,
         &request_info_.extra_headers);
     // If an extension blocks the request, we rely on the callback to
     // StartTransactionInternal().
     if (rv == ERR_IO_PENDING) {
       SetBlockedOnDelegate();
       return;
     }
   }
   StartTransactionInternal();
 }
@@ skipping 388 matching lines @@
   }
 #endif
 
   if (result == OK) {
     scoped_refptr<HttpResponseHeaders> headers = GetResponseHeaders();
     if (request_->context() && request_->context()->network_delegate()) {
       // Note that |this| may not be deleted until
       // |on_headers_received_callback_| or
       // |NetworkDelegate::URLRequestDestroyed()| has been called.
       int error = request_->context()->network_delegate()->
-          NotifyHeadersReceived(request_, &on_headers_received_callback_,
+          NotifyHeadersReceived(request_, on_headers_received_callback_,
                                 headers, &override_response_headers_);
       if (error != net::OK) {
         if (error == net::ERR_IO_PENDING) {
           awaiting_callback_ = true;
           request_->net_log().BeginEvent(
               NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
         } else {
           request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
               make_scoped_refptr(
                   new NetLogStringParameter("source", "delegate")));
@@ skipping 682 matching lines @@
   return override_response_headers_.get() ?
       override_response_headers_ :
       transaction_->GetResponseInfo()->headers;
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net