Home | History | Annotate | Download | only in capture 
      1 // Copyright 2014 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_muter.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/bind_helpers.h"
      9 #include "content/browser/media/capture/audio_mirroring_manager.h"
     10 #include "content/public/browser/browser_thread.h"
     11 #include "content/public/browser/render_frame_host.h"
     12 #include "content/public/browser/web_contents.h"
     13 #include "media/audio/audio_io.h"
     14 #include "media/audio/audio_manager.h"
     15 #include "media/audio/fake_audio_consumer.h"
     16 #include "media/base/bind_to_current_loop.h"
     17 
     18 namespace content {
     19 
     20 namespace {
     21 
     22 // An AudioOutputStream that pumps audio data, but does nothing with it.
     23 // Pumping the audio data is necessary because video playback is synchronized to
     24 // the audio stream and will freeze otherwise.
     25 //
     26 // TODO(miu): media::FakeAudioOutputStream does pretty much the same thing as
     27 // this class, but requires construction/destruction via media::AudioManagerBase
     28 // on the audio thread.  Once that's fixed, this class will no longer be needed.
     29 // http://crbug.com/416278
     30 class AudioDiscarder : public media::AudioOutputStream {
     31  public:
     32   explicit AudioDiscarder(const media::AudioParameters& params)
     33       : consumer_(media::AudioManager::Get()->GetWorkerTaskRunner(), params) {}
     34 
     35   // AudioOutputStream implementation.
     36   virtual bool Open() OVERRIDE { return true; }
     37   virtual void Start(AudioSourceCallback* callback) OVERRIDE {
     38     consumer_.Start(base::Bind(&AudioDiscarder::FetchAudioData, callback));
     39   }
     40   virtual void Stop() OVERRIDE { consumer_.Stop(); }
     41   virtual void SetVolume(double volume) OVERRIDE {}
     42   virtual void GetVolume(double* volume) OVERRIDE { *volume = 0; }
     43   virtual void Close() OVERRIDE { delete this; }
     44 
     45  private:
     46   virtual ~AudioDiscarder() {}
     47 
     48   static void FetchAudioData(AudioSourceCallback* callback,
     49                              media::AudioBus* audio_bus) {
     50     callback->OnMoreData(audio_bus, media::AudioBuffersState());
     51   }
     52 
     53   // Calls FetchAudioData() at regular intervals and discards the data.
     54   media::FakeAudioConsumer consumer_;
     55 
     56   DISALLOW_COPY_AND_ASSIGN(AudioDiscarder);
     57 };
     58 
     59 }  // namespace
     60 
     61 // A simple AudioMirroringManager::MirroringDestination implementation that
     62 // identifies the audio streams rendered by a WebContents and provides
     63 // AudioDiscarders to AudioMirroringManager.
     64 class WebContentsAudioMuter::MuteDestination
     65     : public base::RefCountedThreadSafe<MuteDestination>,
     66       public AudioMirroringManager::MirroringDestination {
     67  public:
     68   explicit MuteDestination(WebContents* web_contents)
     69       : web_contents_(web_contents) {}
     70 
     71  private:
     72   friend class base::RefCountedThreadSafe<MuteDestination>;
     73 
     74   typedef AudioMirroringManager::SourceFrameRef SourceFrameRef;
     75 
     76   virtual ~MuteDestination() {}
     77 
     78   virtual void QueryForMatches(
     79       const std::set<SourceFrameRef>& candidates,
     80       const MatchesCallback& results_callback) OVERRIDE {
     81     BrowserThread::PostTask(
     82         BrowserThread::UI,
     83         FROM_HERE,
     84         base::Bind(&MuteDestination::QueryForMatchesOnUIThread,
     85                    this,
     86                    candidates,
     87                    media::BindToCurrentLoop(results_callback)));
     88   }
     89 
     90   void QueryForMatchesOnUIThread(const std::set<SourceFrameRef>& candidates,
     91                                  const MatchesCallback& results_callback) {
     92     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     93     std::set<SourceFrameRef> matches;
     94     // Add each ID to |matches| if it maps to a RenderFrameHost that maps to the
     95     // WebContents being muted.
     96     for (std::set<SourceFrameRef>::const_iterator i = candidates.begin();
     97          i != candidates.end(); ++i) {
     98       WebContents* const contents_containing_frame =
     99           WebContents::FromRenderFrameHost(
    100               RenderFrameHost::FromID(i->first, i->second));
    101       if (contents_containing_frame == web_contents_)
    102         matches.insert(*i);
    103     }
    104     results_callback.Run(matches);
    105   }
    106 
    107   virtual media::AudioOutputStream* AddInput(
    108       const media::AudioParameters& params) OVERRIDE {
    109     return new AudioDiscarder(params);
    110   }
    111 
    112   WebContents* const web_contents_;
    113 
    114   DISALLOW_COPY_AND_ASSIGN(MuteDestination);
    115 };
    116 
    117 WebContentsAudioMuter::WebContentsAudioMuter(WebContents* web_contents)
    118     : destination_(new MuteDestination(web_contents)), is_muting_(false) {
    119   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    120 }
    121 
    122 WebContentsAudioMuter::~WebContentsAudioMuter() {
    123   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    124   StopMuting();
    125 }
    126 
    127 void WebContentsAudioMuter::StartMuting() {
    128   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    129   if (is_muting_)
    130     return;
    131   is_muting_ = true;
    132   BrowserThread::PostTask(
    133       BrowserThread::IO,
    134       FROM_HERE,
    135       base::Bind(&AudioMirroringManager::StartMirroring,
    136                  base::Unretained(AudioMirroringManager::GetInstance()),
    137                  destination_));
    138 }
    139 
    140 void WebContentsAudioMuter::StopMuting() {
    141   DCHECK_CURRENTLY_ON(BrowserThread::UI);
    142   if (!is_muting_)
    143     return;
    144   is_muting_ = false;
    145   BrowserThread::PostTask(
    146       BrowserThread::IO,
    147       FROM_HERE,
    148       base::Bind(&AudioMirroringManager::StopMirroring,
    149                  base::Unretained(AudioMirroringManager::GetInstance()),
    150                  destination_));
    151 }
    152 
    153 }  // namespace content
    154