Decouple IPC::MessageFilter from IPC::Channel

content/browser/renderer_host/media/media_stream_dispatcher_host_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 <string>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 245 matching lines @@
   virtual void SetUp() OVERRIDE {
     video_capture_device_factory_->GetDeviceNames(&physical_video_devices_);
     ASSERT_GT(physical_video_devices_.size(), 0u);
 
     media_stream_manager_->audio_input_device_manager()->GetFakeDeviceNames(
         &physical_audio_devices_);
     ASSERT_GT(physical_audio_devices_.size(), 0u);
   }
 
   virtual void TearDown() OVERRIDE {
-    host_->OnChannelClosing();
+    host_->OnSenderClosing();
   }
 
  protected:
   virtual void SetupFakeUI(bool expect_started) {
     scoped_ptr<MockMediaStreamUIProxy> stream_ui(new MockMediaStreamUIProxy());
     if (expect_started) {
       EXPECT_CALL(*stream_ui, OnStarted(_, _));
     }
     media_stream_manager_->UseFakeUI(
         stream_ui.PassAs<FakeMediaStreamUIProxy>());
@@ skipping 520 matching lines @@
                           run_loop1.QuitClosure());
 
   // Stop the video stream device from stream 1 while waiting for the
   // second stream to be generated.
   host_->OnStopStreamDevice(kRenderId, host_->video_devices_[0].device.id);
   run_loop1.Run();
 
   EXPECT_EQ(host_->video_devices_.size(), 1u);
 }
 
-TEST_F(MediaStreamDispatcherHostTest, CancelPendingStreamsOnChannelClosing) {
+TEST_F(MediaStreamDispatcherHostTest, CancelPendingStreamsOnSenderClosing) {
   StreamOptions options(false, true);
 
   base::RunLoop run_loop;
 
   // Create multiple GenerateStream requests.
   size_t streams = 5;
   for (size_t i = 1; i <= streams; ++i) {
     host_->OnGenerateStream(kRenderId, kPageRequestId + i, options, origin_,
                             run_loop.QuitClosure());
   }
 
-  // Calling OnChannelClosing() to cancel all the pending requests.
-  host_->OnChannelClosing();
+  // Calling OnSenderClosing() to cancel all the pending requests.
+  host_->OnSenderClosing();
   run_loop.RunUntilIdle();
 }
 
-TEST_F(MediaStreamDispatcherHostTest, StopGeneratedStreamsOnChannelClosing) {
+TEST_F(MediaStreamDispatcherHostTest, StopGeneratedStreamsOnSenderClosing) {
   StreamOptions options(false, true);
 
   // Create first group of streams.
   size_t generated_streams = 3;
   for (size_t i = 0; i < generated_streams; ++i) {
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId + i, options);
   }
 
-  // Calling OnChannelClosing() to cancel all the pending/generated streams.
-  host_->OnChannelClosing();
+  // Calling OnSenderClosing() to cancel all the pending/generated streams.
+  host_->OnSenderClosing();
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(MediaStreamDispatcherHostTest, CloseFromUI) {
   StreamOptions options(false, true);
 
   base::Closure close_callback;
   scoped_ptr<MockMediaStreamUIProxy> stream_ui(new MockMediaStreamUIProxy());
   EXPECT_CALL(*stream_ui, OnStarted(_, _))
       .WillOnce(SaveArg<0>(&close_callback));
@@ skipping 54 matching lines @@
 TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevicesNoAccess) {
   MockResourceContext* mock_resource_context =
       static_cast<MockResourceContext*>(browser_context_.GetResourceContext());
   mock_resource_context->set_camera_access(false);
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_VIDEO_CAPTURE);
   EXPECT_TRUE(DoesNotContainLabels(host_->enumerated_devices_));
 }
 
 };  // namespace content