Home | History | Annotate | Download | only in media 
      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