base::Bind: Convert net::NetworkDelegate.

net/url_request/url_request.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.h"
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/metrics/stats_counters.h"
 #include "base/synchronization/lock.h"
 #include "net/base/auth.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
@@ skipping 123 matching lines @@
     : url_chain_(1, url),
       method_("GET"),
       load_flags_(LOAD_NORMAL),
       delegate_(delegate),
       is_pending_(false),
       redirect_limit_(kMaxRedirects),
       final_upload_progress_(0),
       priority_(LOWEST),
       identifier_(GenerateURLRequestIdentifier()),
       blocked_on_delegate_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          before_request_callback_(this, &URLRequest::BeforeRequestComplete)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(before_request_callback_(
+          base::Bind(&URLRequest::BeforeRequestComplete,
+                     base::Unretained(this)))),
       has_notified_completion_(false) {
   SIMPLE_STATS_COUNTER("URLRequestCount");
 
   // Sanity check out environment.
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
   DCHECK_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type()) <<
       "The current MessageLoop must be TYPE_IO";
 }
 
@@ skipping 247 matching lines @@
 void URLRequest::set_delegate(Delegate* delegate) {
   delegate_ = delegate;
 }
 
 void URLRequest::Start() {
   response_info_.request_time = Time::Now();
 
   // Only notify the delegate for the initial request.
   if (context_ && context_->network_delegate()) {
     int error = context_->network_delegate()->NotifyBeforeURLRequest(
-        this, &before_request_callback_, &delegate_redirect_url_);
+        this, before_request_callback_, &delegate_redirect_url_);
     if (error != net::OK) {
       if (error == net::ERR_IO_PENDING) {
         // Paused on the delegate, will invoke |before_request_callback_| later.
         SetBlockedOnDelegate();
       } else {
         // The delegate immediately returned some error code.
         BeforeRequestComplete(error);
       }
       return;
     }
@@ skipping 461 matching lines @@
 
 void URLRequest::SetUnblockedOnDelegate() {
   if (!blocked_on_delegate_)
     return;
   blocked_on_delegate_ = false;
   load_state_param_.clear();
   net_log_.EndEvent(NetLog::TYPE_URL_REQUEST_BLOCKED_ON_DELEGATE, NULL);
 }
 
 }  // namespace net