content/browser/media/capture/web_contents_audio_muter.cc

   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