base::Bind: Convert net::NetworkDelegate.

net/url_request/url_request_unittest.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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <shlobj.h>
 #include <windows.h>
 #endif
 
 #include <algorithm>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"

[csilv, 2011/11/30 21:56:50]

add include for base/memory/weak_ptr.h

[James Hawkins, 2011/12/01 00:40:26]

Done.

 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/cookie_store_test_helpers.h"
@@ skipping 94 matching lines @@
 // A network delegate that blocks requests, optionally cancelling or redirecting
 // them.
 class BlockingNetworkDelegate : public TestNetworkDelegate {
  public:
   BlockingNetworkDelegate()
       : retval_(net::ERR_IO_PENDING),
         callback_retval_(net::OK),
         auth_retval_(NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING),
         auth_callback_retval_(
             NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION),
-        ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {}
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 
   void set_retval(int retval) { retval_ = retval; }
   void set_callback_retval(int retval) { callback_retval_ = retval; }
   void set_redirect_url(const GURL& url) { redirect_url_ = url; }
   void set_auth_retval(NetworkDelegate::AuthRequiredResponse retval) {
     auth_retval_ = retval; }
   void set_auth_callback_retval(NetworkDelegate::AuthRequiredResponse retval) {
     auth_callback_retval_ = retval; }
   void set_auth_credentials(const AuthCredentials& auth_credentials) {
     auth_credentials_ = auth_credentials;
   }
 
  private:
-  // TestNetworkDelegate:
+  // TestNetworkDelegate implementation.
   virtual int OnBeforeURLRequest(net::URLRequest* request,
-                                 net::OldCompletionCallback* callback,
-                                 GURL* new_url) {
+                                 const net::CompletionCallback& callback,
+                                 GURL* new_url) OVERRIDE {
     if (redirect_url_ == request->url()) {
       // We've already seen this request and redirected elsewhere.
       return net::OK;
     }
 
     TestNetworkDelegate::OnBeforeURLRequest(request, callback, new_url);
 
     if (!redirect_url_.is_empty())
       *new_url = redirect_url_;
 
     if (retval_ != net::ERR_IO_PENDING)
       return retval_;
 
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        method_factory_.NewRunnableMethod(&BlockingNetworkDelegate::DoCallback,
-                                          callback));
+        base::Bind(&BlockingNetworkDelegate::DoCallback,
+                   weak_factory_.GetWeakPtr(), callback));
     return net::ERR_IO_PENDING;
   }
 
   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
       AuthCredentials* credentials) OVERRIDE {
     TestNetworkDelegate::OnAuthRequired(request, auth_info, callback,
                                         credentials);
     switch (auth_retval_) {
       case NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION:
         break;
       case NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH:
         *credentials = auth_credentials_;
       case NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH:
         break;
       case NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING:
         MessageLoop::current()->PostTask(
             FROM_HERE,
-            method_factory_.NewRunnableMethod(
-                &BlockingNetworkDelegate::DoAuthCallback,
-                callback, credentials));
+            base::Bind(&BlockingNetworkDelegate::DoAuthCallback,
+                       weak_factory_.GetWeakPtr(), callback, credentials));
         break;
     }
     return auth_retval_;
   }
 
-  void DoCallback(net::OldCompletionCallback* callback) {
-    callback->Run(callback_retval_);
+  void DoCallback(const net::CompletionCallback& callback) {
+    callback.Run(callback_retval_);
   }
 
   void DoAuthCallback(const AuthCallback& callback,
                       AuthCredentials* credentials) {
     if (auth_callback_retval_ ==
         NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH) {
       *credentials = auth_credentials_;
     }
     callback.Run(auth_callback_retval_);
   }
 
 
   int retval_;
   int callback_retval_;
   GURL redirect_url_;
   NetworkDelegate::AuthRequiredResponse auth_retval_;
   NetworkDelegate::AuthRequiredResponse auth_callback_retval_;
   AuthCredentials auth_credentials_;
-  ScopedRunnableMethodFactory<BlockingNetworkDelegate> method_factory_;
+  base::WeakPtrFactory<BlockingNetworkDelegate> weak_factory_;
 };
 
 // A simple Interceptor that returns a pre-built URLRequestJob one time.
 class TestJobInterceptor : public URLRequestJobFactory::Interceptor {
  public:
   TestJobInterceptor()
       : main_intercept_job_(NULL) {
   }
 
   virtual URLRequestJob* MaybeIntercept(URLRequest* request) const OVERRIDE {
@@ skipping 3442 matching lines @@
   req.SetExtraRequestHeaders(headers);
   req.Start();
   MessageLoop::current()->Run();
   // If the net tests are being run with ChromeFrame then we need to allow for
   // the 'chromeframe' suffix which is added to the user agent before the
   // closing parentheses.
   EXPECT_TRUE(StartsWithASCII(d.data_received(), "Lynx (textmode", true));
 }
 
 }  // namespace net