Stop refcounting URLRequestContext.

content/test/webrtc_audio_device_test.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/test/webrtc_audio_device_test.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
@@ skipping 63 matching lines @@
     // Restore the original renderer.
     content::GetContentClient()->set_renderer(saved_renderer_);
   }
  private:
   content::ContentRendererClient* saved_renderer_;
   DISALLOW_COPY_AND_ASSIGN(ReplaceContentClientRenderer);
 };
 
 namespace {
 
+class MockResourceContext : public content::ResourceContext {
+ public:
+  MockResourceContext() : test_request_context_(NULL) {}
+  virtual ~MockResourceContext() {}
+
+  void set_request_context(net::URLRequestContext* request_context) {
+    test_request_context_ = request_context;
+  }
+
+  // ResourceContext implementation:
+  virtual net::HostResolver* GetHostResolver() OVERRIDE {
+    return NULL;
+  }
+  virtual net::URLRequestContext* GetRequestContext() OVERRIDE {
+    return test_request_context_;
+  }
+
+ private:
+  net::URLRequestContext* test_request_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockResourceContext);
+};
+
 ACTION_P(QuitMessageLoop, loop_or_proxy) {
   loop_or_proxy->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
-}  // end namespace
+}  // namespace
 
 WebRTCAudioDeviceTest::WebRTCAudioDeviceTest()
     : render_thread_(NULL), audio_util_callback_(NULL),
       has_input_devices_(false), has_output_devices_(false) {
 }
 
 WebRTCAudioDeviceTest::~WebRTCAudioDeviceTest() {}
 
 void WebRTCAudioDeviceTest::SetUp() {
   // This part sets up a RenderThread environment to ensure that
   // RenderThread::current() (<=> TLS pointer) is valid.
   // Main parts are inspired by the RenderViewFakeResourcesTest.
   // Note that, the IPC part is not utilized in this test.
   saved_content_renderer_.reset(
       new ReplaceContentClientRenderer(&mock_content_renderer_client_));
   mock_process_.reset(new WebRTCMockRenderProcess());
   ui_thread_.reset(new content::TestBrowserThread(content::BrowserThread::UI,
                                                   MessageLoop::current()));
 
   // Construct the resource context on the UI thread.
-  resource_context_.reset(new content::MockResourceContext(NULL));
+  resource_context_.reset(new MockResourceContext);
 
   static const char kThreadName[] = "RenderThread";
   ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
       base::Bind(&WebRTCAudioDeviceTest::InitializeIOThread,
                  base::Unretained(this), kThreadName));
   WaitForIOThreadCompletion();
 
   render_thread_ = new RenderThreadImpl(kThreadName);
 }
 
@@ skipping 41 matching lines @@
   // See BrowserProcessSubThread::Init.
   initialize_com_.reset(new ScopedCOMInitializer());
 
   // Set the current thread as the IO thread.
   io_thread_.reset(new content::TestBrowserThread(content::BrowserThread::IO,
                                                   MessageLoop::current()));
 
   audio_manager_.reset(media::AudioManager::Create());
 
   // Populate our resource context.
-  test_request_context_ = new TestURLRequestContext();
-  resource_context_->set_request_context(test_request_context_.get());
+  test_request_context_.reset(new TestURLRequestContext());
+  MockResourceContext* resource_context =
+      static_cast<MockResourceContext*>(resource_context_.get());
+  resource_context->set_request_context(test_request_context_.get());
   media_observer_.reset(new MockMediaObserver());
 
   has_input_devices_ = audio_manager_->HasAudioInputDevices();
   has_output_devices_ = audio_manager_->HasAudioOutputDevices();
 
   // Create an IPC channel that handles incoming messages on the IO thread.
   CreateChannel(thread_name);
 }
 
 void WebRTCAudioDeviceTest::UninitializeIOThread() {
   resource_context_.reset();
 
   audio_manager_.reset();
-  test_request_context_ = NULL;
+  test_request_context_.reset();
   initialize_com_.reset();
 }
 
 void WebRTCAudioDeviceTest::CreateChannel(const char* name) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   audio_render_host_ = new AudioRendererHost(
       audio_manager_.get(), media_observer_.get());
   audio_render_host_->OnChannelConnected(base::GetCurrentProcId());
 
   audio_input_renderer_host_ = new AudioInputRendererHost(
@@ skipping 127 matching lines @@
 WebRTCTransportImpl::~WebRTCTransportImpl() {}
 
 int WebRTCTransportImpl::SendPacket(int channel, const void* data, int len) {
   return network_->ReceivedRTPPacket(channel, data, len);
 }
 
 int WebRTCTransportImpl::SendRTCPPacket(int channel, const void* data,
                                         int len) {
   return network_->ReceivedRTCPPacket(channel, data, len);
 }