Stop refcounting URLRequestContext.

net/proxy/dhcp_proxy_script_fetcher_win_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 "net/proxy/dhcp_proxy_script_fetcher_win.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 30 matching lines @@
     printf("Adapter '%s' has PAC URL '%s' configured in DHCP.\n",
            adapter_name.c_str(),
            pac_url.c_str());
   }
 }
 
 // Helper for RealFetch* tests below.
 class RealFetchTester {
  public:
   RealFetchTester()
-      : context_((new TestURLRequestContext())),
+      : context_(new TestURLRequestContext),
         fetcher_(new DhcpProxyScriptFetcherWin(context_.get())),
         finished_(false),
         on_completion_is_error_(false) {
     // Make sure the test ends.
     timeout_.Start(FROM_HERE,
         base::TimeDelta::FromSeconds(5), this, &RealFetchTester::OnTimeout);
   }
 
   void RunTest() {
     int result = fetcher_->Fetch(
@@ skipping 45 matching lines @@
   // Attempts to give worker threads time to finish.  This is currently
   // very simplistic as completion (via completion callback or cancellation)
   // immediately "detaches" any worker threads, so the best we can do is give
   // them a little time.  If we start running into Valgrind leaks, we can
   // do something a bit more clever to track worker threads even when the
   // DhcpProxyScriptFetcherWin state machine has finished.
   void FinishTestAllowCleanup() {
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(30));
   }
 
-  scoped_refptr<URLRequestContext> context_;
+  scoped_ptr<URLRequestContext> context_;
   scoped_ptr<DhcpProxyScriptFetcherWin> fetcher_;
   bool finished_;
   string16 pac_text_;
   base::OneShotTimer<RealFetchTester> timeout_;
   base::OneShotTimer<RealFetchTester> cancel_timer_;
   bool on_completion_is_error_;
 };
 
 TEST(DhcpProxyScriptFetcherWin, RealFetch) {
   // This tests a call to Fetch() with no stubbing out of dependencies.
@@ skipping 65 matching lines @@
   }
 };
 
 TEST(DhcpProxyScriptFetcherWin, RealFetchWithDeferredCancel) {
   // Does a Fetch() with a slightly delayed cancel.  As before, just
   // exercises the code without stubbing out dependencies, but
   // introduces a guaranteed 20 ms delay on the worker threads so that
   // the cancel is called before they complete.
   RealFetchTester fetcher;
   fetcher.fetcher_.reset(
-      new DelayingDhcpProxyScriptFetcherWin(fetcher.context_));
+      new DelayingDhcpProxyScriptFetcherWin(fetcher.context_.get()));
   fetcher.on_completion_is_error_ = true;
   fetcher.RunTestWithDeferredCancel();
   fetcher.WaitUntilDone();
 }
 
 // The remaining tests are to exercise our state machine in various
 // situations, with actual network access fully stubbed out.
 
 class DummyDhcpProxyScriptAdapterFetcher
     : public DhcpProxyScriptAdapterFetcher {
@@ skipping 151 matching lines @@
 
   int max_wait_ms_;
   int num_fetchers_created_;
   base::WaitableEvent worker_finished_event_;
 };
 
 class FetcherClient {
 public:
   FetcherClient()
       : context_(new TestURLRequestContext),
-        fetcher_(context_),
+        fetcher_(context_.get()),
         finished_(false),
         result_(ERR_UNEXPECTED) {
   }
 
   void RunTest() {
     int result = fetcher_.Fetch(
         &pac_text_,
         base::Bind(&FetcherClient::OnCompletion, base::Unretained(this)));
     ASSERT_EQ(ERR_IO_PENDING, result);
   }
@@ skipping 18 matching lines @@
     result_ = result;
   }
 
   void ResetTestState() {
     finished_ = false;
     result_ = ERR_UNEXPECTED;
     pac_text_ = L"";
     fetcher_.ResetTestState();
   }
 
-  scoped_refptr<URLRequestContext> context_;
+  scoped_ptr<URLRequestContext> context_;
   MockDhcpProxyScriptFetcherWin fetcher_;
   bool finished_;
   int result_;
   string16 pac_text_;
 };
 
 // We separate out each test's logic so that we can easily implement
 // the ReuseFetcher test at the bottom.
 void TestNormalCaseURLConfiguredOneAdapter(FetcherClient* client) {
-  scoped_refptr<URLRequestContext> context(new TestURLRequestContext);
+  TestURLRequestContext context;
   scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
-      new DummyDhcpProxyScriptAdapterFetcher(context));
+      new DummyDhcpProxyScriptAdapterFetcher(&context));
   adapter_fetcher->Configure(true, OK, L"bingo", 1);
   client->fetcher_.PushBackAdapter("a", adapter_fetcher.release());
   client->RunTest();
   client->RunMessageLoopUntilComplete();
   ASSERT_EQ(OK, client->result_);
   ASSERT_EQ(L"bingo", client->pac_text_);
 }
 
 TEST(DhcpProxyScriptFetcherWin, NormalCaseURLConfiguredOneAdapter) {
   FetcherClient client;
@@ skipping 129 matching lines @@
       client->fetcher_.max_wait_ms_ - (client->fetcher_.max_wait_ms_ / 10)),
       timer.Elapsed());
 }
 
 TEST(DhcpProxyScriptFetcherWin, ShortCircuitLessPreferredAdapters) {
   FetcherClient client;
   TestShortCircuitLessPreferredAdapters(&client);
 }
 
 void TestImmediateCancel(FetcherClient* client) {
-  scoped_refptr<URLRequestContext> context(new TestURLRequestContext);
+  TestURLRequestContext context;
   scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
-      new DummyDhcpProxyScriptAdapterFetcher(context));
+      new DummyDhcpProxyScriptAdapterFetcher(&context));
   adapter_fetcher->Configure(true, OK, L"bingo", 1);
   client->fetcher_.PushBackAdapter("a", adapter_fetcher.release());
   client->RunTest();
   client->fetcher_.Cancel();
   client->RunMessageLoopUntilWorkerDone();
   ASSERT_EQ(0, client->fetcher_.num_fetchers_created_);
 }
 
 // Regression test to check that when we cancel immediately, no
 // adapter fetchers get created.
@@ skipping 35 matching lines @@
   }
 
   // Re-do the first test to make sure the last test that was run did
   // not leave things in a bad state.
   (*test_functions.begin())(&client);
 }
 
 }  // namespace
 
 }  // namespace net