Allow ProxyService to share URLRequestContext with everything else.

net/proxy/proxy_script_decider_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 110 matching lines @@
     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;
   }
 
   void Cancel() override {}
 
+  void OnShutdown() override { request_context_ = nullptr; }
+
   URLRequestContext* GetRequestContext() const override {
     return request_context_;
   }
 
  private:
   const Rules* rules_;
   URLRequestContext* request_context_;
 };
 
 // A mock retriever, returns asynchronously when CompleteRequests() is called.
 class MockDhcpProxyScriptFetcher : public DhcpProxyScriptFetcher {
  public:
   MockDhcpProxyScriptFetcher();
   ~MockDhcpProxyScriptFetcher() override;
 
   int Fetch(base::string16* utf16_text,
             const CompletionCallback& callback) override;
   void Cancel() override;
+  void OnShutdown() override;
   const GURL& GetPacURL() const override;
 
   virtual void SetPacURL(const GURL& url);
 
   virtual void CompleteRequests(int result, const base::string16& script);
 
  private:
   CompletionCallback callback_;
   base::string16* utf16_text_;
   GURL gurl_;
   DISALLOW_COPY_AND_ASSIGN(MockDhcpProxyScriptFetcher);
 };
 
 MockDhcpProxyScriptFetcher::MockDhcpProxyScriptFetcher() { }
 
 MockDhcpProxyScriptFetcher::~MockDhcpProxyScriptFetcher() { }
 
 int MockDhcpProxyScriptFetcher::Fetch(base::string16* utf16_text,
                                       const CompletionCallback& callback) {
   utf16_text_ = utf16_text;
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 void MockDhcpProxyScriptFetcher::Cancel() { }
 
+void MockDhcpProxyScriptFetcher::OnShutdown() {}
+
 const GURL& MockDhcpProxyScriptFetcher::GetPacURL() const {
   return gurl_;
 }
 
 void MockDhcpProxyScriptFetcher::SetPacURL(const GURL& url) {
   gurl_ = url;
 }
 
 void MockDhcpProxyScriptFetcher::CompleteRequests(
     int result, const base::string16& script) {
@@ skipping 141 matching lines @@
     config_.set_auto_detect(true);
     decider_.reset(new ProxyScriptDecider(&fetcher_, &dhcp_fetcher_, NULL));
   }
 
   int StartDecider() {
     return decider_->Start(config_, base::TimeDelta(), true,
                             callback_.callback());
   }
 
  protected:
-  std::unique_ptr<ProxyScriptDecider> decider_;
   MockHostResolver resolver_;
   Rules rules_;
   Rules::Rule rule_;
   TestCompletionCallback callback_;
   RuleBasedProxyScriptFetcher fetcher_;
   ProxyConfig config_;
   DoNothingDhcpProxyScriptFetcher dhcp_fetcher_;
+  std::unique_ptr<ProxyScriptDecider> decider_;
 
  private:
   URLRequestContext request_context_;
 };
 
 // Fails if a synchronous DNS lookup success for wpad causes QuickCheck to fail.
 TEST_F(ProxyScriptDeciderQuickCheckTest, SyncSuccess) {
   resolver_.set_synchronous_mode(true);
   resolver_.rules()->AddRule("wpad", "1.2.3.4");
 
@@ skipping 77 matching lines @@
   config_.set_pac_url(GURL(kCustomUrl));
   Rules::Rule rule = rules_.AddSuccessRule(kCustomUrl);
   resolver_.rules()->AddSimulatedFailure("wpad");
   resolver_.rules()->AddRule("custom", "1.2.3.4");
   EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
   callback_.WaitForResult();
   EXPECT_TRUE(decider_->effective_config().has_pac_url());
   EXPECT_EQ(rule.url, decider_->effective_config().pac_url());
 }
 
+TEST_F(ProxyScriptDeciderQuickCheckTest, ShutdownDuringResolve) {
+  resolver_.set_ondemand_mode(true);
+
+  EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
+  EXPECT_TRUE(resolver_.has_pending_requests());
+
+  decider_->OnShutdown();
+  EXPECT_FALSE(resolver_.has_pending_requests());
+  EXPECT_EQ(ERR_CONTEXT_SHUT_DOWN, callback_.WaitForResult());
+}
+
 // Regression test for http://crbug.com/409698.
 // This test lets the state machine get into state QUICK_CHECK_COMPLETE, then
 // destroys the decider, causing a cancel.
 TEST_F(ProxyScriptDeciderQuickCheckTest, CancelPartway) {
   resolver_.set_synchronous_mode(false);
   resolver_.set_ondemand_mode(true);
   EXPECT_THAT(StartDecider(), IsError(ERR_IO_PENDING));
   decider_.reset(NULL);
 }
 
@@ skipping 212 matching lines @@
   }
 
   int Fetch(base::string16* utf16_text,
             const CompletionCallback& callback) override {
     *utf16_text = expected_text_;
     return OK;
   }
 
   void Cancel() override {}
 
+  void OnShutdown() override {}
+
   const GURL& GetPacURL() const override { return gurl_; }
 
   const base::string16& expected_text() const {
     return expected_text_;
   }
 
  private:
   GURL gurl_;
   base::string16 expected_text_;
 
@@ skipping 62 matching lines @@
             const CompletionCallback& callback) override {
     callback_ = callback;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&AsyncFailDhcpFetcher::CallbackWithFailure, AsWeakPtr()));
     return ERR_IO_PENDING;
   }
 
   void Cancel() override { callback_.Reset(); }
 
+  void OnShutdown() override {}
+
   const GURL& GetPacURL() const override { return dummy_gurl_; }
 
   void CallbackWithFailure() {
     if (!callback_.is_null())
       callback_.Run(ERR_PAC_NOT_IN_DHCP);
   }
 
  private:
   GURL dummy_gurl_;
   CompletionCallback callback_;
@@ skipping 24 matching lines @@
 
   // 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.
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 }  // namespace net