Stop refcounting URLRequestContext.

content/common/net/url_fetcher_impl_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 "content/common/net/url_fetcher_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 41 matching lines @@
     : public TestURLRequestContextGetter {
  public:
   ThrottlingTestURLRequestContextGetter(
       base::MessageLoopProxy* io_message_loop_proxy,
       TestURLRequestContext* request_context)
       : TestURLRequestContextGetter(io_message_loop_proxy),
         context_(request_context) {
   }
 
   virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE {
-    return context_.get();
+    return context_;
   }
 
  protected:
   virtual ~ThrottlingTestURLRequestContextGetter() {}
 
-  scoped_refptr<TestURLRequestContext> context_;
+  TestURLRequestContext* const context_;
 };
 
 }  // namespace
 
 class URLFetcherTest : public testing::Test,
                        public content::URLFetcherDelegate {
  public:
   URLFetcherTest()
       : fetcher_(NULL),
         context_(new ThrottlingTestURLRequestContext()) {
@@ skipping 36 matching lines @@
   }
 
   // URLFetcher is designed to run on the main UI thread, but in our tests
   // we assume that the current thread is the IO thread where the URLFetcher
   // dispatches its requests to.  When we wish to simulate being used from
   // a UI thread, we dispatch a worker thread to do so.
   MessageLoopForIO io_loop_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
 
   URLFetcherImpl* fetcher_;
-  scoped_refptr<TestURLRequestContext> context_;
+  const scoped_ptr<TestURLRequestContext> context_;
 };
 
 void URLFetcherTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, content::URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy(), request_context()));
   fetcher_->Start();
 }
 
 void URLFetcherTest::OnURLFetchComplete(const content::URLFetcher* source) {
@@ skipping 150 matching lines @@
  public:
   CancelTestURLRequestContextGetter(
       base::MessageLoopProxy* io_message_loop_proxy,
       const GURL& throttle_for_url)
       : TestURLRequestContextGetter(io_message_loop_proxy),
         io_message_loop_proxy_(io_message_loop_proxy),
         context_created_(false, false),
         throttle_for_url_(throttle_for_url) {
   }
   virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE {
-    if (!context_) {
-      context_ = new CancelTestURLRequestContext();
+    if (!context_.get()) {
+      context_.reset(new CancelTestURLRequestContext());
       DCHECK(context_->throttler_manager());
 
       // Registers an entry for test url. The backoff time is calculated by:
       //     new_backoff = 2.0 * old_backoff + 0
       // The initial backoff is 2 seconds and maximum backoff is 4 seconds.
       // Maximum retries allowed is set to 2.
       scoped_refptr<net::URLRequestThrottlerEntry> entry(
           new net::URLRequestThrottlerEntry(
               context_->throttler_manager(),
               "", 200, 3, 2000, 2.0, 0.0, 4000));
       context_->throttler_manager()->OverrideEntryForTests(
           throttle_for_url_, entry);
 
       context_created_.Signal();
     }
-    return context_;
+    return context_.get();
   }
   virtual scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() const {
     return io_message_loop_proxy_;
   }
   void WaitForContextCreation() {
     context_created_.Wait();
   }
 
  protected:
   virtual ~CancelTestURLRequestContextGetter() {}
 
  private:
-  scoped_refptr<ThrottlingTestURLRequestContext> context_;
+  scoped_ptr<TestURLRequestContext> context_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
   base::WaitableEvent context_created_;
   GURL throttle_for_url_;
 };
 
 // Version of URLFetcherTest that tests retying the same request twice.
 class URLFetcherMultipleAttemptTest : public URLFetcherTest {
  public:
   // content::URLFetcherDelegate
   virtual void OnURLFetchComplete(const content::URLFetcher* source) OVERRIDE;
@@ skipping 809 matching lines @@
       std::string(kTestServerFilePrefix) + kFileToFetch));
 
   MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
   MessageLoop::current()->RunAllPending();
   ASSERT_FALSE(file_util::PathExists(file_path_))
       << file_path_.value() << " not removed.";
 }
 
 }  // namespace.