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