base::Bind: Convert net/proxy.

net/proxy/proxy_script_decider_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 <vector>
 

[csilv, 2011/12/20 01:05:13]

#include "base/bind.h"

[James Hawkins, 2011/12/20 01:08:47]

Done.

 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/test_completion_callback.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/proxy_config.h"
@@ skipping 72 matching lines @@
   RuleList rules_;
 };
 
 class RuleBasedProxyScriptFetcher : public ProxyScriptFetcher {
  public:
   explicit RuleBasedProxyScriptFetcher(const Rules* rules) : rules_(rules) {}
 
   // ProxyScriptFetcher implementation.
   virtual int Fetch(const GURL& url,
                     string16* text,
-                    OldCompletionCallback* callback) {
+                    const CompletionCallback& callback) {
     const Rules::Rule& rule = rules_->GetRuleByUrl(url);
     int rv = rule.fetch_error;
     EXPECT_NE(ERR_UNEXPECTED, rv);
     if (rv == OK)
       *text = rule.text();
     return rv;
   }
 
   virtual void Cancel() {}
 
   virtual URLRequestContext* GetRequestContext() const { return NULL; }
 
  private:
   const Rules* rules_;
 };
 
 // Succeed using custom PAC script.
 TEST(ProxyScriptDeciderTest, CustomPacSucceeds) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, &log);
   EXPECT_EQ(OK, decider.Start(
-      config, base::TimeDelta(), true, &callback));
+      config, base::TimeDelta(), true, callback.callback()));
   EXPECT_EQ(rule.text(), decider.script_data()->utf16());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
   EXPECT_TRUE(LogContainsBeginEvent(
@@ skipping 11 matching lines @@
 TEST(ProxyScriptDeciderTest, CustomPacFails1) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://custom/proxy.pac");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, &log);
   EXPECT_EQ(kFailedDownloading,
-            decider.Start(config, base::TimeDelta(), true, &callback));
+            decider.Start(config, base::TimeDelta(), true,
+                          callback.callback()));
   EXPECT_EQ(NULL, decider.script_data());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
   EXPECT_TRUE(LogContainsBeginEvent(
@@ skipping 10 matching lines @@
 TEST(ProxyScriptDeciderTest, CustomPacFails2) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailParsingRule("http://custom/proxy.pac");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
   EXPECT_EQ(kFailedParsing,
-            decider.Start(config, base::TimeDelta(), true, &callback));
+            decider.Start(config, base::TimeDelta(), true,
+                          callback.callback()));
   EXPECT_EQ(NULL, decider.script_data());
 }
 
 // Fail downloading the custom PAC script, because the fetcher was NULL.
 TEST(ProxyScriptDeciderTest, HasNullProxyScriptFetcher) {
   Rules rules;
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ProxyScriptDecider decider(NULL, &dhcp_fetcher, NULL);
   EXPECT_EQ(ERR_UNEXPECTED,
-            decider.Start(config, base::TimeDelta(), true, &callback));
+            decider.Start(config, base::TimeDelta(), true,
+                          callback.callback()));
   EXPECT_EQ(NULL, decider.script_data());
 }
 
 // Succeeds in choosing autodetect (WPAD DNS).
 TEST(ProxyScriptDeciderTest, AutodetectSuccess) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
 
   Rules::Rule rule = rules.AddSuccessRule("http://wpad/wpad.dat");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
   EXPECT_EQ(OK, decider.Start(
-      config, base::TimeDelta(), true, &callback));
+      config, base::TimeDelta(), true, callback.callback()));
   EXPECT_EQ(rule.text(), decider.script_data()->utf16());
 
   EXPECT_TRUE(decider.effective_config().has_pac_url());
   EXPECT_EQ(rule.url, decider.effective_config().pac_url());
 }
 
 // Fails at WPAD (downloading), but succeeds in choosing the custom PAC.
 TEST(ProxyScriptDeciderTest, AutodetectFailCustomSuccess1) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://wpad/wpad.dat");
   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
   EXPECT_EQ(OK, decider.Start(
-      config, base::TimeDelta(), true, &callback));
+      config, base::TimeDelta(), true, callback.callback()));
   EXPECT_EQ(rule.text(), decider.script_data()->utf16());
 
   EXPECT_TRUE(decider.effective_config().has_pac_url());
   EXPECT_EQ(rule.url, decider.effective_config().pac_url());
 }
 
 // Fails at WPAD (no DHCP config, DNS PAC fails parsing), but succeeds in
 // choosing the custom PAC.
 TEST(ProxyScriptDeciderTest, AutodetectFailCustomSuccess2) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://custom/proxy.pac"));
   config.proxy_rules().ParseFromString("unused-manual-proxy:99");
 
   rules.AddFailParsingRule("http://wpad/wpad.dat");
   Rules::Rule rule = rules.AddSuccessRule("http://custom/proxy.pac");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, &log);
   EXPECT_EQ(OK, decider.Start(config, base::TimeDelta(),
-                          true, &callback));
+                          true, callback.callback()));
   EXPECT_EQ(rule.text(), decider.script_data()->utf16());
 
   // Verify that the effective configuration no longer contains auto detect or
   // any of the manual settings.
   EXPECT_TRUE(decider.effective_config().Equals(
       ProxyConfig::CreateFromCustomPacURL(GURL("http://custom/proxy.pac"))));
 
   // Check the NetLog was filled correctly.
   // (Note that various states are repeated since both WPAD and custom
   // PAC scripts are tried).
@@ skipping 37 matching lines @@
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://wpad/wpad.dat");
   rules.AddFailDownloadRule("http://custom/proxy.pac");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
   EXPECT_EQ(kFailedDownloading,
-            decider.Start(config, base::TimeDelta(), true, &callback));
+            decider.Start(config, base::TimeDelta(), true,
+                          callback.callback()));
   EXPECT_EQ(NULL, decider.script_data());
 }
 
 // Fails at WPAD (downloading), and fails at custom PAC (parsing).
 TEST(ProxyScriptDeciderTest, AutodetectFailCustomFails2) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_auto_detect(true);
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://wpad/wpad.dat");
   rules.AddFailParsingRule("http://custom/proxy.pac");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
   EXPECT_EQ(kFailedParsing,
-            decider.Start(config, base::TimeDelta(), true, &callback));
+            decider.Start(config, base::TimeDelta(), true,
+                          callback.callback()));
   EXPECT_EQ(NULL, decider.script_data());
 }
 
 // This is a copy-paste of CustomPacFails1, with the exception that we give it
 // a 1 millisecond delay. This means it will now complete asynchronously.
 // Moreover, we test the NetLog to make sure it logged the pause.
 TEST(ProxyScriptDeciderTest, CustomPacFails1_WithPositiveDelay) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://custom/proxy.pac");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, &log);
   EXPECT_EQ(ERR_IO_PENDING,
             decider.Start(config, base::TimeDelta::FromMilliseconds(1),
-                      true, &callback));
+                      true, callback.callback()));
 
   EXPECT_EQ(kFailedDownloading, callback.WaitForResult());
   EXPECT_EQ(NULL, decider.script_data());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(6u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
@@ skipping 16 matching lines @@
 TEST(ProxyScriptDeciderTest, CustomPacFails1_WithNegativeDelay) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher;
 
   ProxyConfig config;
   config.set_pac_url(GURL("http://custom/proxy.pac"));
 
   rules.AddFailDownloadRule("http://custom/proxy.pac");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   CapturingNetLog log(CapturingNetLog::kUnbounded);
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, &log);
   EXPECT_EQ(kFailedDownloading,
             decider.Start(config, base::TimeDelta::FromSeconds(-5),
-                          true, &callback));
+                          true, callback.callback()));
   EXPECT_EQ(NULL, decider.script_data());
 
   // Check the NetLog was filled correctly.
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(4u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 1, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 2, NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 3, NetLog::TYPE_PROXY_SCRIPT_DECIDER));
 }
 
 class SynchronousSuccessDhcpFetcher : public DhcpProxyScriptFetcher {
  public:
   explicit SynchronousSuccessDhcpFetcher(const string16& expected_text)
       : gurl_("http://dhcppac/"), expected_text_(expected_text) {
   }
 
-  int Fetch(string16* utf16_text, OldCompletionCallback* callback) OVERRIDE {
+  int Fetch(string16* utf16_text, const CompletionCallback& callback) OVERRIDE {
     *utf16_text = expected_text_;
     return OK;
   }
 
   void Cancel() OVERRIDE {
   }
 
   const GURL& GetPacURL() const OVERRIDE {
     return gurl_;
   }
@@ skipping 19 matching lines @@
   RuleBasedProxyScriptFetcher fetcher(&rules);
   SynchronousSuccessDhcpFetcher dhcp_fetcher(
       WideToUTF16(L"http://bingo/!FindProxyForURL"));
 
   ProxyConfig config;
   config.set_auto_detect(true);
 
   rules.AddSuccessRule("http://bingo/");
   rules.AddFailDownloadRule("http://wpad/wpad.dat");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
   EXPECT_EQ(OK, decider.Start(
-      config, base::TimeDelta(), true, &callback));
+      config, base::TimeDelta(), true, callback.callback()));
   EXPECT_EQ(dhcp_fetcher.expected_text(),
             decider.script_data()->utf16());
 
   EXPECT_TRUE(decider.effective_config().has_pac_url());
   EXPECT_EQ(GURL("http://dhcppac/"), decider.effective_config().pac_url());
 }
 
 TEST(ProxyScriptDeciderTest, AutodetectDhcpFailParse) {
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
   SynchronousSuccessDhcpFetcher dhcp_fetcher(
       WideToUTF16(L"http://bingo/!invalid-script"));
 
   ProxyConfig config;
   config.set_auto_detect(true);
 
   rules.AddFailParsingRule("http://bingo/");
   rules.AddFailDownloadRule("http://wpad/wpad.dat");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   ProxyScriptDecider decider(&fetcher, &dhcp_fetcher, NULL);
   // Since there is fallback to DNS-based WPAD, the final error will be that
   // it failed downloading, not that it failed parsing.
   EXPECT_EQ(kFailedDownloading,
-      decider.Start(config, base::TimeDelta(), true, &callback));
+      decider.Start(config, base::TimeDelta(), true, callback.callback()));
   EXPECT_EQ(NULL, decider.script_data());
 
   EXPECT_FALSE(decider.effective_config().has_pac_url());
 }
 
 class AsyncFailDhcpFetcher
     : public DhcpProxyScriptFetcher,
       public base::RefCountedThreadSafe<AsyncFailDhcpFetcher> {
  public:
-  AsyncFailDhcpFetcher() : callback_(NULL) {
-  }
+  AsyncFailDhcpFetcher() {}
 
-  int Fetch(string16* utf16_text, OldCompletionCallback* callback) OVERRIDE {
+  int Fetch(string16* utf16_text, const CompletionCallback& callback) OVERRIDE {
     callback_ = callback;
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        NewRunnableMethod(this, &AsyncFailDhcpFetcher::CallbackWithFailure));
+        base::Bind(&AsyncFailDhcpFetcher::CallbackWithFailure, this));
     return ERR_IO_PENDING;
   }
 
   void Cancel() OVERRIDE {
-    callback_ = NULL;
+    callback_.Reset();
   }
 
   const GURL& GetPacURL() const OVERRIDE {
     return dummy_gurl_;
   }
 
   void CallbackWithFailure() {
-    if (callback_)
-      callback_->Run(ERR_PAC_NOT_IN_DHCP);
+    if (!callback_.is_null())
+      callback_.Run(ERR_PAC_NOT_IN_DHCP);
   }
 
  private:
   GURL dummy_gurl_;
-  OldCompletionCallback* callback_;
+  CompletionCallback callback_;
 };
 
 TEST(ProxyScriptDeciderTest, DhcpCancelledByDestructor) {
   // This regression test would crash before
   // http://codereview.chromium.org/7044058/
   // Thus, we don't care much about actual results (hence no EXPECT or ASSERT
   // macros below), just that it doesn't crash.
   Rules rules;
   RuleBasedProxyScriptFetcher fetcher(&rules);
 
   scoped_refptr<AsyncFailDhcpFetcher> dhcp_fetcher(new AsyncFailDhcpFetcher());
 
   ProxyConfig config;
   config.set_auto_detect(true);
   rules.AddFailDownloadRule("http://wpad/wpad.dat");
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
 
   // Scope so ProxyScriptDecider gets destroyed early.
   {
     ProxyScriptDecider decider(&fetcher, dhcp_fetcher.get(), NULL);
-    decider.Start(config, base::TimeDelta(), true, &callback);
+    decider.Start(config, base::TimeDelta(), true, callback.callback());
   }
 
   // Run the message loop to let the DHCP fetch complete and post the results
   // back. Before the fix linked to above, this would try to invoke on
   // the callback object provided by ProxyScriptDecider after it was
   // no longer valid.
   MessageLoop::current()->RunAllPending();
 }
 
 }  // namespace
 }  // namespace net