1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <string> 6 7 #include "base/bind.h" 8 #include "base/message_loop/message_loop.h" 9 #include "base/run_loop.h" 10 #include "content/browser/browser_thread_impl.h" 11 #include "content/browser/renderer_host/media/media_stream_manager.h" 12 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h" 13 #include "content/common/media/media_stream_options.h" 14 #include "content/public/test/test_browser_thread_bundle.h" 15 #include "media/audio/audio_manager_base.h" 16 #if defined(OS_ANDROID) 17 #include "media/audio/android/audio_manager_android.h" 18 #elif defined(OS_LINUX) || defined(OS_OPENBSD) 19 #include "media/audio/linux/audio_manager_linux.h" 20 #elif defined(OS_MACOSX) 21 #include "media/audio/mac/audio_manager_mac.h" 22 #elif defined(OS_WIN) 23 #include "media/audio/win/audio_manager_win.h" 24 #endif 25 #include "testing/gmock/include/gmock/gmock.h" 26 #include "testing/gtest/include/gtest/gtest.h" 27 28 using testing::_; 29 30 namespace content { 31 32 #if defined(OS_LINUX) || defined(OS_OPENBSD) 33 typedef media::AudioManagerLinux AudioManagerPlatform; 34 #elif defined(OS_MACOSX) 35 typedef media::AudioManagerMac AudioManagerPlatform; 36 #elif defined(OS_WIN) 37 typedef media::AudioManagerWin AudioManagerPlatform; 38 #elif defined(OS_ANDROID) 39 typedef media::AudioManagerAndroid AudioManagerPlatform; 40 #endif 41 42 43 // This class mocks the audio manager and overrides the 44 // GetAudioInputDeviceNames() method to ensure that we can run our tests on 45 // the buildbots. media::AudioManagerBase 46 class MockAudioManager : public AudioManagerPlatform { 47 public: 48 MockAudioManager() {} 49 virtual ~MockAudioManager() {} 50 51 virtual void GetAudioInputDeviceNames( 52 media::AudioDeviceNames* device_names) OVERRIDE { 53 if (HasAudioInputDevices()) { 54 AudioManagerBase::GetAudioInputDeviceNames(device_names); 55 } else { 56 device_names->push_back(media::AudioDeviceName("fake_device_name", 57 "fake_device_id")); 58 } 59 } 60 61 private: 62 DISALLOW_COPY_AND_ASSIGN(MockAudioManager); 63 }; 64 65 class MediaStreamManagerTest : public ::testing::Test { 66 public: 67 MediaStreamManagerTest() 68 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), 69 message_loop_(base::MessageLoopProxy::current()) { 70 // Create our own MediaStreamManager. 71 audio_manager_.reset(new MockAudioManager()); 72 media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get())); 73 74 // Use fake devices in order to run on the bots. 75 media_stream_manager_->UseFakeDevice(); 76 } 77 78 virtual ~MediaStreamManagerTest() { 79 media_stream_manager_->WillDestroyCurrentMessageLoop(); 80 } 81 82 MOCK_METHOD1(Response, void(int index)); 83 void ResponseCallback(int index, 84 const MediaStreamDevices& devices, 85 scoped_ptr<MediaStreamUIProxy> ui_proxy) { 86 Response(index); 87 message_loop_->PostTask(FROM_HERE, run_loop_.QuitClosure()); 88 } 89 90 protected: 91 std::string MakeMediaAccessRequest(int index) { 92 const int render_process_id = 1; 93 const int render_view_id = 1; 94 const int page_request_id = 1; 95 StreamOptions components(MEDIA_DEVICE_AUDIO_CAPTURE, 96 MEDIA_DEVICE_VIDEO_CAPTURE); 97 const GURL security_origin; 98 MediaStreamManager::MediaRequestResponseCallback callback = 99 base::Bind(&MediaStreamManagerTest::ResponseCallback, 100 base::Unretained(this), index); 101 return media_stream_manager_->MakeMediaAccessRequest(render_process_id, 102 render_view_id, 103 page_request_id, 104 components, 105 security_origin, 106 callback); 107 } 108 109 scoped_ptr<media::AudioManager> audio_manager_; 110 scoped_ptr<MediaStreamManager> media_stream_manager_; 111 content::TestBrowserThreadBundle thread_bundle_; 112 scoped_refptr<base::MessageLoopProxy> message_loop_; 113 base::RunLoop run_loop_; 114 115 private: 116 DISALLOW_COPY_AND_ASSIGN(MediaStreamManagerTest); 117 }; 118 119 TEST_F(MediaStreamManagerTest, MakeMediaAccessRequest) { 120 MakeMediaAccessRequest(0); 121 122 // Expecting the callback will be triggered and quit the test. 123 EXPECT_CALL(*this, Response(0)); 124 run_loop_.Run(); 125 } 126 127 TEST_F(MediaStreamManagerTest, MakeAndCancelMediaAccessRequest) { 128 std::string label = MakeMediaAccessRequest(0); 129 // No callback is expected. 130 media_stream_manager_->CancelRequest(label); 131 } 132 133 TEST_F(MediaStreamManagerTest, MakeMultipleRequests) { 134 // First request. 135 std::string label1 = MakeMediaAccessRequest(0); 136 137 // Second request. 138 int render_process_id = 2; 139 int render_view_id = 2; 140 int page_request_id = 2; 141 StreamOptions components(MEDIA_DEVICE_AUDIO_CAPTURE, 142 MEDIA_DEVICE_VIDEO_CAPTURE); 143 GURL security_origin; 144 MediaStreamManager::MediaRequestResponseCallback callback = 145 base::Bind(&MediaStreamManagerTest::ResponseCallback, 146 base::Unretained(this), 1); 147 std::string label2 = media_stream_manager_->MakeMediaAccessRequest( 148 render_process_id, 149 render_view_id, 150 page_request_id, 151 components, 152 security_origin, 153 callback); 154 155 // Expecting the callbackS from requests will be triggered and quit the test. 156 // Note, the callbacks might come in a different order depending on the 157 // value of labels. 158 EXPECT_CALL(*this, Response(0)); 159 EXPECT_CALL(*this, Response(1)); 160 run_loop_.Run(); 161 } 162 163 TEST_F(MediaStreamManagerTest, MakeAndCancelMultipleRequests) { 164 std::string label1 = MakeMediaAccessRequest(0); 165 std::string label2 = MakeMediaAccessRequest(1); 166 media_stream_manager_->CancelRequest(label1); 167 168 // Expecting the callback from the second request will be triggered and 169 // quit the test. 170 EXPECT_CALL(*this, Response(1)); 171 run_loop_.Run(); 172 } 173 174 } // namespace content 175