Home | History | Annotate | Download | only in capture 
      1 // Copyright (c) 2013 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 "content/browser/media/capture/web_contents_audio_input_stream.h"
      6 
      7 #include <list>
      8 
      9 #include "base/bind.h"
     10 #include "base/bind_helpers.h"
     11 #include "base/message_loop/message_loop.h"
     12 #include "base/synchronization/waitable_event.h"
     13 #include "base/threading/thread.h"
     14 #include "content/browser/media/capture/audio_mirroring_manager.h"
     15 #include "content/browser/media/capture/web_contents_tracker.h"
     16 #include "content/public/browser/browser_thread.h"
     17 #include "content/public/test/test_browser_thread_bundle.h"
     18 #include "media/audio/simple_sources.h"
     19 #include "media/audio/virtual_audio_input_stream.h"
     20 #include "testing/gmock/include/gmock/gmock.h"
     21 #include "testing/gtest/include/gtest/gtest.h"
     22 
     23 using ::testing::_;
     24 using ::testing::Assign;
     25 using ::testing::DoAll;
     26 using ::testing::Invoke;
     27 using ::testing::InvokeWithoutArgs;
     28 using ::testing::NotNull;
     29 using ::testing::SaveArg;
     30 using ::testing::WithArgs;
     31 
     32 using media::AudioInputStream;
     33 using media::AudioOutputStream;
     34 using media::AudioParameters;
     35 using media::SineWaveAudioSource;
     36 using media::VirtualAudioInputStream;
     37 using media::VirtualAudioOutputStream;
     38 
     39 namespace content {
     40 
     41 namespace {
     42 
     43 const int kRenderProcessId = 123;
     44 const int kRenderFrameId = 456;
     45 const int kAnotherRenderProcessId = 789;
     46 const int kAnotherRenderFrameId = 1;
     47 
     48 const AudioParameters& TestAudioParameters() {
     49   static const AudioParameters params(
     50       AudioParameters::AUDIO_FAKE,
     51       media::CHANNEL_LAYOUT_STEREO,
     52       AudioParameters::kAudioCDSampleRate, 16,
     53       AudioParameters::kAudioCDSampleRate / 100);
     54   return params;
     55 }
     56 
     57 class MockAudioMirroringManager : public AudioMirroringManager {
     58  public:
     59   MockAudioMirroringManager() : AudioMirroringManager() {}
     60   virtual ~MockAudioMirroringManager() {}
     61 
     62   MOCK_METHOD1(StartMirroring, void(MirroringDestination* destination));
     63   MOCK_METHOD1(StopMirroring, void(MirroringDestination* destination));
     64 
     65  private:
     66   DISALLOW_COPY_AND_ASSIGN(MockAudioMirroringManager);
     67 };
     68 
     69 class MockWebContentsTracker : public WebContentsTracker {
     70  public:
     71   MockWebContentsTracker() : WebContentsTracker(false) {}
     72 
     73   MOCK_METHOD3(Start,
     74                void(int render_process_id, int render_frame_id,
     75                     const ChangeCallback& callback));
     76   MOCK_METHOD0(Stop, void());
     77 
     78  private:
     79   virtual ~MockWebContentsTracker() {}
     80 
     81   DISALLOW_COPY_AND_ASSIGN(MockWebContentsTracker);
     82 };
     83 
     84 // A fully-functional VirtualAudioInputStream, but methods are mocked to allow
     85 // tests to check how/when they are invoked.
     86 class MockVirtualAudioInputStream : public VirtualAudioInputStream {
     87  public:
     88   explicit MockVirtualAudioInputStream(
     89       const scoped_refptr<base::MessageLoopProxy>& worker_loop)
     90       : VirtualAudioInputStream(TestAudioParameters(), worker_loop,
     91                                 VirtualAudioInputStream::AfterCloseCallback()),
     92         real_(TestAudioParameters(), worker_loop,
     93               base::Bind(&MockVirtualAudioInputStream::OnRealStreamHasClosed,
     94                          base::Unretained(this))),
     95         real_stream_is_closed_(false) {
     96     // Set default actions of mocked methods to delegate to the concrete
     97     // implementation.
     98     ON_CALL(*this, Open())
     99         .WillByDefault(Invoke(&real_, &VirtualAudioInputStream::Open));
    100     ON_CALL(*this, Start(_))
    101         .WillByDefault(Invoke(&real_, &VirtualAudioInputStream::Start));
    102     ON_CALL(*this, Stop())
    103         .WillByDefault(Invoke(&real_, &VirtualAudioInputStream::Stop));
    104     ON_CALL(*this, Close())
    105         .WillByDefault(Invoke(&real_, &VirtualAudioInputStream::Close));
    106     ON_CALL(*this, GetMaxVolume())
    107         .WillByDefault(Invoke(&real_, &VirtualAudioInputStream::GetMaxVolume));
    108     ON_CALL(*this, SetVolume(_))
    109         .WillByDefault(Invoke(&real_, &VirtualAudioInputStream::SetVolume));
    110     ON_CALL(*this, GetVolume())
    111         .WillByDefault(Invoke(&real_, &VirtualAudioInputStream::GetVolume));
    112     ON_CALL(*this, SetAutomaticGainControl(_))
    113         .WillByDefault(
    114             Invoke(&real_, &VirtualAudioInputStream::SetAutomaticGainControl));
    115     ON_CALL(*this, GetAutomaticGainControl())
    116         .WillByDefault(
    117             Invoke(&real_, &VirtualAudioInputStream::GetAutomaticGainControl));
    118     ON_CALL(*this, AddOutputStream(NotNull(), _))
    119         .WillByDefault(
    120             Invoke(&real_, &VirtualAudioInputStream::AddOutputStream));
    121     ON_CALL(*this, RemoveOutputStream(NotNull(), _))
    122         .WillByDefault(
    123             Invoke(&real_, &VirtualAudioInputStream::RemoveOutputStream));
    124   }
    125 
    126   ~MockVirtualAudioInputStream() {
    127     DCHECK(real_stream_is_closed_);
    128   }
    129 
    130   MOCK_METHOD0(Open, bool());
    131   MOCK_METHOD1(Start, void(AudioInputStream::AudioInputCallback*));
    132   MOCK_METHOD0(Stop, void());
    133   MOCK_METHOD0(Close, void());
    134   MOCK_METHOD0(GetMaxVolume, double());
    135   MOCK_METHOD1(SetVolume, void(double));
    136   MOCK_METHOD0(GetVolume, double());
    137   MOCK_METHOD1(SetAutomaticGainControl, void(bool));
    138   MOCK_METHOD0(GetAutomaticGainControl, bool());
    139   MOCK_METHOD2(AddOutputStream, void(VirtualAudioOutputStream*,
    140                                      const AudioParameters&));
    141   MOCK_METHOD2(RemoveOutputStream, void(VirtualAudioOutputStream*,
    142                                         const AudioParameters&));
    143 
    144  private:
    145   void OnRealStreamHasClosed(VirtualAudioInputStream* stream) {
    146     DCHECK_EQ(&real_, stream);
    147     DCHECK(!real_stream_is_closed_);
    148     real_stream_is_closed_ = true;
    149   }
    150 
    151   VirtualAudioInputStream real_;
    152   bool real_stream_is_closed_;
    153 
    154   DISALLOW_COPY_AND_ASSIGN(MockVirtualAudioInputStream);
    155 };
    156 
    157 class MockAudioInputCallback : public AudioInputStream::AudioInputCallback {
    158  public:
    159   MockAudioInputCallback() {}
    160 
    161   MOCK_METHOD4(OnData,
    162                void(AudioInputStream* stream,
    163                     const media::AudioBus* src,
    164                     uint32 hardware_delay_bytes,
    165                     double volume));
    166   MOCK_METHOD1(OnError, void(AudioInputStream* stream));
    167 
    168  private:
    169   DISALLOW_COPY_AND_ASSIGN(MockAudioInputCallback);
    170 };
    171 
    172 }  // namespace
    173 
    174 class WebContentsAudioInputStreamTest : public testing::Test {
    175  public:
    176   WebContentsAudioInputStreamTest()
    177       : thread_bundle_(new TestBrowserThreadBundle(
    178             TestBrowserThreadBundle::REAL_IO_THREAD)),
    179         audio_thread_("Audio thread"),
    180         mock_mirroring_manager_(new MockAudioMirroringManager()),
    181         mock_tracker_(new MockWebContentsTracker()),
    182         mock_vais_(NULL),
    183         wcais_(NULL),
    184         destination_(NULL),
    185         current_render_process_id_(kRenderProcessId),
    186         current_render_frame_id_(kRenderFrameId),
    187         on_data_event_(false, false) {
    188     audio_thread_.Start();
    189   }
    190 
    191   virtual ~WebContentsAudioInputStreamTest() {
    192     audio_thread_.Stop();
    193     thread_bundle_.reset();
    194 
    195     DCHECK(!mock_vais_);
    196     DCHECK(!wcais_);
    197     EXPECT_FALSE(destination_);
    198     DCHECK(streams_.empty());
    199     DCHECK(sources_.empty());
    200   }
    201 
    202   void Open() {
    203     mock_vais_ =
    204         new MockVirtualAudioInputStream(audio_thread_.message_loop_proxy());
    205     EXPECT_CALL(*mock_vais_, Open());
    206     EXPECT_CALL(*mock_vais_, Close());  // At Close() time.
    207 
    208     ASSERT_EQ(kRenderProcessId, current_render_process_id_);
    209     ASSERT_EQ(kRenderFrameId, current_render_frame_id_);
    210     EXPECT_CALL(*mock_tracker_.get(),
    211                 Start(kRenderProcessId, kRenderFrameId, _))
    212         .WillOnce(DoAll(
    213              SaveArg<2>(&change_callback_),
    214              WithArgs<0, 1>(Invoke(this,
    215                                    &WebContentsAudioInputStreamTest::
    216                                        SimulateChangeCallback))));
    217 
    218     EXPECT_CALL(*mock_tracker_.get(), Stop());  // At Close() time.
    219 
    220     wcais_ = new WebContentsAudioInputStream(
    221         current_render_process_id_, current_render_frame_id_,
    222         mock_mirroring_manager_.get(),
    223         mock_tracker_, mock_vais_);
    224     wcais_->Open();
    225   }
    226 
    227   void Start() {
    228     EXPECT_CALL(*mock_vais_, Start(&mock_input_callback_));
    229     EXPECT_CALL(*mock_vais_, Stop());  // At Stop() time.
    230 
    231     EXPECT_CALL(*mock_mirroring_manager_, StartMirroring(NotNull()))
    232         .WillOnce(SaveArg<0>(&destination_))
    233         .RetiresOnSaturation();
    234     // At Stop() time, or when the mirroring target changes:
    235     EXPECT_CALL(*mock_mirroring_manager_, StopMirroring(NotNull()))
    236         .WillOnce(Assign(
    237             &destination_,
    238             static_cast<AudioMirroringManager::MirroringDestination*>(NULL)))
    239         .RetiresOnSaturation();
    240 
    241     EXPECT_CALL(mock_input_callback_, OnData(NotNull(), NotNull(), _, _))
    242         .WillRepeatedly(
    243             InvokeWithoutArgs(&on_data_event_, &base::WaitableEvent::Signal));
    244 
    245     wcais_->Start(&mock_input_callback_);
    246 
    247     // Test plumbing of volume controls and automatic gain controls.  Calls to
    248     // wcais_ methods should delegate directly to mock_vais_.
    249     EXPECT_CALL(*mock_vais_, GetVolume());
    250     double volume = wcais_->GetVolume();
    251     EXPECT_CALL(*mock_vais_, GetMaxVolume());
    252     const double max_volume = wcais_->GetMaxVolume();
    253     volume *= 2.0;
    254     if (volume < max_volume) {
    255       volume = max_volume;
    256     }
    257     EXPECT_CALL(*mock_vais_, SetVolume(volume));
    258     wcais_->SetVolume(volume);
    259     EXPECT_CALL(*mock_vais_, GetAutomaticGainControl());
    260     bool auto_gain = wcais_->GetAutomaticGainControl();
    261     auto_gain = !auto_gain;
    262     EXPECT_CALL(*mock_vais_, SetAutomaticGainControl(auto_gain));
    263     wcais_->SetAutomaticGainControl(auto_gain);
    264   }
    265 
    266   void AddAnotherInput() {
    267     // Note: WCAIS posts a task to invoke
    268     // MockAudioMirroringManager::StartMirroring() on the IO thread, which
    269     // causes our mock to set |destination_|.  Block until that has happened.
    270     base::WaitableEvent done(false, false);
    271     BrowserThread::PostTask(
    272         BrowserThread::IO, FROM_HERE, base::Bind(
    273             &base::WaitableEvent::Signal, base::Unretained(&done)));
    274     done.Wait();
    275     ASSERT_TRUE(destination_);
    276 
    277     EXPECT_CALL(*mock_vais_, AddOutputStream(NotNull(), _))
    278         .RetiresOnSaturation();
    279     // Later, when stream is closed:
    280     EXPECT_CALL(*mock_vais_, RemoveOutputStream(NotNull(), _))
    281         .RetiresOnSaturation();
    282 
    283     const AudioParameters& params = TestAudioParameters();
    284     AudioOutputStream* const out = destination_->AddInput(params);
    285     ASSERT_TRUE(out);
    286     streams_.push_back(out);
    287     EXPECT_TRUE(out->Open());
    288     SineWaveAudioSource* const source = new SineWaveAudioSource(
    289         params.channel_layout(), 200.0, params.sample_rate());
    290     sources_.push_back(source);
    291     out->Start(source);
    292   }
    293 
    294   void RemoveOneInputInFIFOOrder() {
    295     ASSERT_FALSE(streams_.empty());
    296     AudioOutputStream* const out = streams_.front();
    297     streams_.pop_front();
    298     out->Stop();
    299     out->Close();  // Self-deletes.
    300     ASSERT_TRUE(!sources_.empty());
    301     delete sources_.front();
    302     sources_.pop_front();
    303   }
    304 
    305   void ChangeMirroringTarget() {
    306     const int next_render_process_id =
    307         current_render_process_id_ == kRenderProcessId ?
    308             kAnotherRenderProcessId : kRenderProcessId;
    309     const int next_render_frame_id =
    310         current_render_frame_id_ == kRenderFrameId ?
    311             kAnotherRenderFrameId : kRenderFrameId;
    312 
    313     EXPECT_CALL(*mock_mirroring_manager_, StartMirroring(NotNull()))
    314         .WillOnce(SaveArg<0>(&destination_))
    315         .RetiresOnSaturation();
    316 
    317     SimulateChangeCallback(next_render_process_id, next_render_frame_id);
    318 
    319     current_render_process_id_ = next_render_process_id;
    320     current_render_frame_id_ = next_render_frame_id;
    321   }
    322 
    323   void LoseMirroringTarget() {
    324     EXPECT_CALL(mock_input_callback_, OnError(_));
    325 
    326     SimulateChangeCallback(-1, -1);
    327   }
    328 
    329   void Stop() {
    330     wcais_->Stop();
    331   }
    332 
    333   void Close() {
    334     // WebContentsAudioInputStream self-destructs on Close().  Its internal
    335     // objects hang around until they are no longer referred to (e.g., as tasks
    336     // on other threads shut things down).
    337     wcais_->Close();
    338     wcais_ = NULL;
    339     mock_vais_ = NULL;
    340   }
    341 
    342   void RunOnAudioThread(const base::Closure& closure) {
    343     audio_thread_.message_loop()->PostTask(FROM_HERE, closure);
    344   }
    345 
    346   // Block the calling thread until OnData() callbacks are being made.
    347   void WaitForData() {
    348     // Note: Arbitrarily chosen, but more iterations causes tests to take
    349     // significantly more time.
    350     static const int kNumIterations = 3;
    351     for (int i = 0; i < kNumIterations; ++i)
    352       on_data_event_.Wait();
    353   }
    354 
    355  private:
    356   void SimulateChangeCallback(int render_process_id, int render_frame_id) {
    357     ASSERT_FALSE(change_callback_.is_null());
    358     if (render_process_id == -1 || render_frame_id == -1) {
    359       change_callback_.Run(NULL);
    360     } else {
    361       // For our tests, any non-NULL value will suffice since it will not be
    362       // dereferenced.
    363       change_callback_.Run(reinterpret_cast<RenderWidgetHost*>(0xdeadbee5));
    364     }
    365   }
    366 
    367   scoped_ptr<TestBrowserThreadBundle> thread_bundle_;
    368   base::Thread audio_thread_;
    369 
    370   scoped_ptr<MockAudioMirroringManager> mock_mirroring_manager_;
    371   scoped_refptr<MockWebContentsTracker> mock_tracker_;
    372 
    373   MockVirtualAudioInputStream* mock_vais_;  // Owned by wcais_.
    374   WebContentsAudioInputStream* wcais_;  // Self-destructs on Close().
    375 
    376   // Mock consumer of audio data.
    377   MockAudioInputCallback mock_input_callback_;
    378 
    379   // Provided by WebContentsAudioInputStream to the mock WebContentsTracker.
    380   // This callback is saved here, and test code will invoke it to simulate
    381   // target change events.
    382   WebContentsTracker::ChangeCallback change_callback_;
    383 
    384   // Provided by WebContentsAudioInputStream to the mock AudioMirroringManager.
    385   // A pointer to the implementation is saved here, and test code will invoke it
    386   // to simulate: 1) calls to AddInput(); and 2) diverting audio data.
    387   AudioMirroringManager::MirroringDestination* destination_;
    388 
    389   // Current target RenderFrame.  These get flipped in ChangedMirroringTarget().
    390   int current_render_process_id_;
    391   int current_render_frame_id_;
    392 
    393   // Streams provided by calls to WebContentsAudioInputStream::AddInput().  Each
    394   // is started with a simulated source of audio data.
    395   std::list<AudioOutputStream*> streams_;
    396   std::list<SineWaveAudioSource*> sources_;  // 1:1 with elements in streams_.
    397 
    398   base::WaitableEvent on_data_event_;
    399 
    400   DISALLOW_COPY_AND_ASSIGN(WebContentsAudioInputStreamTest);
    401 };
    402 
    403 #define RUN_ON_AUDIO_THREAD(method) \
    404   RunOnAudioThread(base::Bind(&WebContentsAudioInputStreamTest::method,  \
    405                               base::Unretained(this)))
    406 
    407 TEST_F(WebContentsAudioInputStreamTest, OpenedButNeverStarted) {
    408   RUN_ON_AUDIO_THREAD(Open);
    409   RUN_ON_AUDIO_THREAD(Close);
    410 }
    411 
    412 TEST_F(WebContentsAudioInputStreamTest, MirroringNothing) {
    413   RUN_ON_AUDIO_THREAD(Open);
    414   RUN_ON_AUDIO_THREAD(Start);
    415   WaitForData();
    416   RUN_ON_AUDIO_THREAD(Stop);
    417   RUN_ON_AUDIO_THREAD(Close);
    418 }
    419 
    420 TEST_F(WebContentsAudioInputStreamTest, MirroringOutputOutlivesSession) {
    421   RUN_ON_AUDIO_THREAD(Open);
    422   RUN_ON_AUDIO_THREAD(Start);
    423   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    424   WaitForData();
    425   RUN_ON_AUDIO_THREAD(Stop);
    426   RUN_ON_AUDIO_THREAD(Close);
    427   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    428 }
    429 
    430 TEST_F(WebContentsAudioInputStreamTest, MirroringOutputWithinSession) {
    431   RUN_ON_AUDIO_THREAD(Open);
    432   RUN_ON_AUDIO_THREAD(Start);
    433   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    434   WaitForData();
    435   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    436   RUN_ON_AUDIO_THREAD(Stop);
    437   RUN_ON_AUDIO_THREAD(Close);
    438 }
    439 
    440 TEST_F(WebContentsAudioInputStreamTest, MirroringNothingWithTargetChange) {
    441   RUN_ON_AUDIO_THREAD(Open);
    442   RUN_ON_AUDIO_THREAD(Start);
    443   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
    444   RUN_ON_AUDIO_THREAD(Stop);
    445   RUN_ON_AUDIO_THREAD(Close);
    446 }
    447 
    448 TEST_F(WebContentsAudioInputStreamTest, MirroringOneStreamAfterTargetChange) {
    449   RUN_ON_AUDIO_THREAD(Open);
    450   RUN_ON_AUDIO_THREAD(Start);
    451   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
    452   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    453   WaitForData();
    454   RUN_ON_AUDIO_THREAD(Stop);
    455   RUN_ON_AUDIO_THREAD(Close);
    456   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    457 }
    458 
    459 TEST_F(WebContentsAudioInputStreamTest, MirroringOneStreamWithTargetChange) {
    460   RUN_ON_AUDIO_THREAD(Open);
    461   RUN_ON_AUDIO_THREAD(Start);
    462   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    463   WaitForData();
    464   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
    465   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    466   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    467   WaitForData();
    468   RUN_ON_AUDIO_THREAD(Stop);
    469   RUN_ON_AUDIO_THREAD(Close);
    470   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    471 }
    472 
    473 TEST_F(WebContentsAudioInputStreamTest, MirroringLostTarget) {
    474   RUN_ON_AUDIO_THREAD(Open);
    475   RUN_ON_AUDIO_THREAD(Start);
    476   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    477   WaitForData();
    478   RUN_ON_AUDIO_THREAD(LoseMirroringTarget);
    479   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    480   RUN_ON_AUDIO_THREAD(Stop);
    481   RUN_ON_AUDIO_THREAD(Close);
    482 }
    483 
    484 TEST_F(WebContentsAudioInputStreamTest, MirroringMultipleStreamsAndTargets) {
    485   RUN_ON_AUDIO_THREAD(Open);
    486   RUN_ON_AUDIO_THREAD(Start);
    487   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    488   WaitForData();
    489   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    490   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    491   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    492   WaitForData();
    493   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
    494   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    495   WaitForData();
    496   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    497   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    498   RUN_ON_AUDIO_THREAD(AddAnotherInput);
    499   WaitForData();
    500   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    501   WaitForData();
    502   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
    503   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
    504   RUN_ON_AUDIO_THREAD(Stop);
    505   RUN_ON_AUDIO_THREAD(Close);
    506 }
    507 
    508 }  // namespace content
    509