Cancel when InitProxyResolver cancels, so we don't use callback later.

net/proxy/init_proxy_resolver_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>
 
+#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/init_proxy_resolver.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/proxy_config.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_script_fetcher.h"
@@ skipping 551 matching lines @@
     return gurl_;
   }
 
   const string16& expected_text() const {
     return expected_text_;
   }
 
  private:
   GURL gurl_;
   string16 expected_text_;
+
+  DISALLOW_COPY_AND_ASSIGN(SynchronousSuccessDhcpFetcher);
 };
 
 // All of the tests above that use InitProxyResolver have tested
 // failure to fetch a PAC file via DHCP configuration, so we now test
 // success at downloading and parsing, and then success at downloading,
 // failure at parsing.
 
 TEST(InitProxyResolverTest, AutodetectDhcpSuccess) {
   Rules rules;
   RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
@@ skipping 37 matching lines @@
   InitProxyResolver init(&resolver, &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,
       init.Init(config, base::TimeDelta(), &effective_config, &callback));
   EXPECT_EQ(NULL, resolver.script_data());
 
   EXPECT_FALSE(effective_config.has_pac_url());
 }
 
+class AsyncFailDhcpFetcher
+    : public DhcpProxyScriptFetcher,
+      public base::RefCountedThreadSafe<AsyncFailDhcpFetcher> {
+ public:
+  AsyncFailDhcpFetcher() : callback_(NULL) {
+  }
+
+  int Fetch(string16* utf16_text, CompletionCallback* callback) OVERRIDE {
+    callback_ = callback;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(this, &AsyncFailDhcpFetcher::CallbackWithFailure));
+    return ERR_IO_PENDING;
+  }
+
+  void Cancel() OVERRIDE {
+    callback_ = NULL;
+  }
+
+  const GURL& GetPacURL() const OVERRIDE {
+    return dummy_gurl_;
+  }
+
+  void CallbackWithFailure() {
+    if (callback_)
+      callback_->Run(ERR_PAC_NOT_IN_DHCP);
+  }
+
+ private:
+  GURL dummy_gurl_;
+  CompletionCallback* callback_;
+};
+
+TEST(InitProxyResolverTest, 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;
+  RuleBasedProxyResolver resolver(&rules, true /*expects_pac_bytes*/);
+  RuleBasedProxyScriptFetcher fetcher(&rules);
+
+  scoped_refptr<AsyncFailDhcpFetcher> dhcp_fetcher(new AsyncFailDhcpFetcher());
+
+  ProxyConfig config;
+  config.set_auto_detect(true);
+  rules.AddFailDownloadRule("http://wpad/wpad.dat");
+
+  TestCompletionCallback callback;
+
+  // Scope so InitProxyResolver gets destroyed early.
+  {
+    InitProxyResolver init(&resolver, &fetcher, dhcp_fetcher.get(), NULL);
+    init.Init(config, base::TimeDelta(), NULL, &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 InitProxyResolver after it was
+  // no longer valid.
+  MessageLoop::current()->RunAllPending();
+}
+
 }  // namespace
 }  // namespace net