src/content/browser/media/capture/web_contents_audio_input_stream.cc

   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 <string>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/threading/thread_checker.h"
  14 #include "content/browser/media/capture/audio_mirroring_manager.h"
  15 #include "content/browser/media/capture/web_contents_capture_util.h"
  16 #include "content/browser/media/capture/web_contents_tracker.h"
  17 #include "content/public/browser/browser_thread.h"
  18 #include "content/public/browser/render_frame_host.h"
  19 #include "content/public/browser/web_contents.h"
  20 #include "media/audio/virtual_audio_input_stream.h"
  21 #include "media/audio/virtual_audio_output_stream.h"
  22 #include "media/base/bind_to_current_loop.h"
  23
  24 namespace content {
  25
  26 class WebContentsAudioInputStream::Impl
  27     : public base::RefCountedThreadSafe<WebContentsAudioInputStream::Impl>,
  28       public AudioMirroringManager::MirroringDestination {
  29  public:
  30   // Takes ownership of |mixer_stream|.  The rest outlive this instance.
  31   Impl(int render_process_id, int main_render_frame_id,
  32        AudioMirroringManager* mirroring_manager,
  33        const scoped_refptr<WebContentsTracker>& tracker,
  34        media::VirtualAudioInputStream* mixer_stream);
  35
  36   // Open underlying VirtualAudioInputStream and start tracker.
  37   bool Open();
  38
  39   // Start the underlying VirtualAudioInputStream and instruct
  40   // AudioMirroringManager to begin a mirroring session.
  41   void Start(AudioInputCallback* callback);
  42
  43   // Stop the underlying VirtualAudioInputStream and instruct
  44   // AudioMirroringManager to shutdown a mirroring session.
  45   void Stop();
  46
  47   // Close the underlying VirtualAudioInputStream and stop the tracker.
  48   void Close();
  49
  50   // Accessor to underlying VirtualAudioInputStream.
  51   media::VirtualAudioInputStream* mixer_stream() const {
  52     return mixer_stream_.get();
  53   }
  54
  55  private:
  56   friend class base::RefCountedThreadSafe<WebContentsAudioInputStream::Impl>;
  57
  58   typedef AudioMirroringManager::SourceFrameRef SourceFrameRef;
  59
  60   enum State {
  61     CONSTRUCTED,
  62     OPENED,
  63     MIRRORING,
  64     CLOSED
  65   };
  66
  67   virtual ~Impl();
  68
  69   // Notifies the consumer callback that the stream is now dead.
  70   void ReportError();
  71
  72   // (Re-)Start/Stop mirroring by posting a call to AudioMirroringManager on the
  73   // IO BrowserThread.
  74   void StartMirroring();
  75   void StopMirroring();
  76
  77   // Invoked on the UI thread to make sure WebContents muting is turned off for
  78   // successful audio capture.
  79   void UnmuteWebContentsAudio();
  80
  81   // AudioMirroringManager::MirroringDestination implementation
  82   virtual void QueryForMatches(
  83       const std::set<SourceFrameRef>& candidates,
  84       const MatchesCallback& results_callback) OVERRIDE;
  85   void QueryForMatchesOnUIThread(const std::set<SourceFrameRef>& candidates,
  86                                  const MatchesCallback& results_callback);
  87   virtual media::AudioOutputStream* AddInput(
  88       const media::AudioParameters& params) OVERRIDE;
  89
  90   // Callback which is run when |stream| is closed.  Deletes |stream|.
  91   void ReleaseInput(media::VirtualAudioOutputStream* stream);
  92
  93   // Called by WebContentsTracker when the target of the audio mirroring has
  94   // changed.
  95   void OnTargetChanged(RenderWidgetHost* target);
  96
  97   // Injected dependencies.
  98   const int initial_render_process_id_;
  99   const int initial_main_render_frame_id_;
 100   AudioMirroringManager* const mirroring_manager_;
 101   const scoped_refptr<WebContentsTracker> tracker_;
 102   // The AudioInputStream implementation that handles the audio conversion and
 103   // mixing details.
 104   const scoped_ptr<media::VirtualAudioInputStream> mixer_stream_;
 105
 106   State state_;
 107
 108   // Set to true if |tracker_| reports a NULL target, which indicates the target
 109   // is permanently lost.
 110   bool is_target_lost_;
 111
 112   // Current callback used to consume the resulting mixed audio data.
 113   AudioInputCallback* callback_;
 114
 115   base::ThreadChecker thread_checker_;
 116
 117   DISALLOW_COPY_AND_ASSIGN(Impl);
 118 };
 119
 120 WebContentsAudioInputStream::Impl::Impl(
 121     int render_process_id, int main_render_frame_id,
 122     AudioMirroringManager* mirroring_manager,
 123     const scoped_refptr<WebContentsTracker>& tracker,
 124     media::VirtualAudioInputStream* mixer_stream)
 125     : initial_render_process_id_(render_process_id),
 126       initial_main_render_frame_id_(main_render_frame_id),
 127       mirroring_manager_(mirroring_manager),
 128       tracker_(tracker),
 129       mixer_stream_(mixer_stream),
 130       state_(CONSTRUCTED),
 131       is_target_lost_(false),
 132       callback_(NULL) {
 133   DCHECK(mirroring_manager_);
 134   DCHECK(tracker_.get());
 135   DCHECK(mixer_stream_.get());
 136
 137   // WAIS::Impl can be constructed on any thread, but will DCHECK that all
 138   // its methods from here on are called from the same thread.
 139   thread_checker_.DetachFromThread();
 140 }
 141
 142 WebContentsAudioInputStream::Impl::~Impl() {
 143   DCHECK(state_ == CONSTRUCTED || state_ == CLOSED);
 144 }
 145
 146 bool WebContentsAudioInputStream::Impl::Open() {
 147   DCHECK(thread_checker_.CalledOnValidThread());
 148
 149   DCHECK_EQ(CONSTRUCTED, state_) << "Illegal to Open more than once.";
 150
 151   if (!mixer_stream_->Open())
 152     return false;
 153
 154   state_ = OPENED;
 155
 156   tracker_->Start(
 157       initial_render_process_id_, initial_main_render_frame_id_,
 158       base::Bind(&Impl::OnTargetChanged, this));
 159
 160   return true;
 161 }
 162
 163 void WebContentsAudioInputStream::Impl::Start(AudioInputCallback* callback) {
 164   DCHECK(thread_checker_.CalledOnValidThread());
 165   DCHECK(callback);
 166
 167   if (state_ != OPENED)
 168     return;
 169
 170   callback_ = callback;
 171   if (is_target_lost_) {
 172     ReportError();
 173     callback_ = NULL;
 174     return;
 175   }
 176
 177   state_ = MIRRORING;
 178   mixer_stream_->Start(callback);
 179
 180   StartMirroring();
 181
 182   // WebContents audio muting is implemented as audio capture to nowhere.
 183   // Unmuting will stop that audio capture, allowing AudioMirroringManager to
 184   // divert audio capture to here.
 185   BrowserThread::PostTask(
 186       BrowserThread::UI,
 187       FROM_HERE,
 188       base::Bind(&Impl::UnmuteWebContentsAudio, this));
 189 }
 190
 191 void WebContentsAudioInputStream::Impl::Stop() {
 192   DCHECK(thread_checker_.CalledOnValidThread());
 193
 194   if (state_ != MIRRORING)
 195     return;
 196
 197   state_ = OPENED;
 198
 199   mixer_stream_->Stop();
 200   callback_ = NULL;
 201
 202   StopMirroring();
 203 }
 204
 205 void WebContentsAudioInputStream::Impl::Close() {
 206   DCHECK(thread_checker_.CalledOnValidThread());
 207
 208   Stop();
 209
 210   if (state_ == OPENED) {
 211     state_ = CONSTRUCTED;
 212     tracker_->Stop();
 213     mixer_stream_->Close();
 214   }
 215
 216   DCHECK_EQ(CONSTRUCTED, state_);
 217   state_ = CLOSED;
 218 }
 219
 220 void WebContentsAudioInputStream::Impl::ReportError() {
 221   DCHECK(thread_checker_.CalledOnValidThread());
 222
 223   // TODO(miu): Need clean-up of AudioInputCallback interface in a future
 224   // change, since its only implementation ignores the first argument entirely
 225   callback_->OnError(NULL);
 226 }
 227
 228 void WebContentsAudioInputStream::Impl::StartMirroring() {
 229   DCHECK(thread_checker_.CalledOnValidThread());
 230
 231   BrowserThread::PostTask(
 232       BrowserThread::IO,
 233       FROM_HERE,
 234       base::Bind(&AudioMirroringManager::StartMirroring,
 235                  base::Unretained(mirroring_manager_),
 236                  make_scoped_refptr(this)));
 237 }
 238
 239 void WebContentsAudioInputStream::Impl::StopMirroring() {
 240   DCHECK(thread_checker_.CalledOnValidThread());
 241
 242   BrowserThread::PostTask(
 243       BrowserThread::IO,
 244       FROM_HERE,
 245       base::Bind(&AudioMirroringManager::StopMirroring,
 246                  base::Unretained(mirroring_manager_),
 247                  make_scoped_refptr(this)));
 248 }
 249
 250 void WebContentsAudioInputStream::Impl::UnmuteWebContentsAudio() {
 251   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 252
 253   WebContents* const contents = tracker_->web_contents();
 254   if (contents)
 255     contents->SetAudioMuted(false);
 256 }
 257
 258 void WebContentsAudioInputStream::Impl::QueryForMatches(
 259     const std::set<SourceFrameRef>& candidates,
 260     const MatchesCallback& results_callback) {
 261   BrowserThread::PostTask(
 262       BrowserThread::UI,
 263       FROM_HERE,
 264       base::Bind(&Impl::QueryForMatchesOnUIThread,
 265                  this,
 266                  candidates,
 267                  media::BindToCurrentLoop(results_callback)));
 268 }
 269
 270 void WebContentsAudioInputStream::Impl::QueryForMatchesOnUIThread(
 271     const std::set<SourceFrameRef>& candidates,
 272     const MatchesCallback& results_callback) {
 273   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 274
 275   std::set<SourceFrameRef> matches;
 276   WebContents* const contents = tracker_->web_contents();
 277   if (contents) {
 278     // Add each ID to |matches| if it maps to a RenderFrameHost that maps to the
 279     // currently-tracked WebContents.
 280     for (std::set<SourceFrameRef>::const_iterator i = candidates.begin();
 281          i != candidates.end(); ++i) {
 282       WebContents* const contents_containing_frame =
 283           WebContents::FromRenderFrameHost(
 284               RenderFrameHost::FromID(i->first, i->second));
 285       if (contents_containing_frame == contents)
 286         matches.insert(*i);
 287     }
 288   }
 289
 290   results_callback.Run(matches);
 291 }
 292
 293 media::AudioOutputStream* WebContentsAudioInputStream::Impl::AddInput(
 294     const media::AudioParameters& params) {
 295   // Note: The closure created here holds a reference to "this," which will
 296   // guarantee the VirtualAudioInputStream (mixer_stream_) outlives the
 297   // VirtualAudioOutputStream.
 298   return new media::VirtualAudioOutputStream(
 299       params,
 300       mixer_stream_.get(),
 301       base::Bind(&Impl::ReleaseInput, this));
 302 }
 303
 304 void WebContentsAudioInputStream::Impl::ReleaseInput(
 305     media::VirtualAudioOutputStream* stream) {
 306   delete stream;
 307 }
 308
 309 void WebContentsAudioInputStream::Impl::OnTargetChanged(
 310     RenderWidgetHost* target) {
 311   DCHECK(thread_checker_.CalledOnValidThread());
 312
 313   is_target_lost_ = !target;
 314
 315   if (state_ == MIRRORING) {
 316     if (is_target_lost_) {
 317       ReportError();
 318       Stop();
 319     } else {
 320       StartMirroring();
 321     }
 322   }
 323 }
 324
 325 // static
 326 WebContentsAudioInputStream* WebContentsAudioInputStream::Create(
 327     const std::string& device_id,
 328     const media::AudioParameters& params,
 329     const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
 330     AudioMirroringManager* audio_mirroring_manager) {
 331   int render_process_id;
 332   int main_render_frame_id;
 333   if (!WebContentsCaptureUtil::ExtractTabCaptureTarget(
 334           device_id, &render_process_id, &main_render_frame_id)) {
 335     return NULL;
 336   }
 337
 338   return new WebContentsAudioInputStream(
 339       render_process_id, main_render_frame_id,
 340       audio_mirroring_manager,
 341       new WebContentsTracker(false),
 342       new media::VirtualAudioInputStream(
 343           params, worker_task_runner,
 344           media::VirtualAudioInputStream::AfterCloseCallback()));
 345 }
 346
 347 WebContentsAudioInputStream::WebContentsAudioInputStream(
 348     int render_process_id, int main_render_frame_id,
 349     AudioMirroringManager* mirroring_manager,
 350     const scoped_refptr<WebContentsTracker>& tracker,
 351     media::VirtualAudioInputStream* mixer_stream)
 352     : impl_(new Impl(render_process_id, main_render_frame_id,
 353                      mirroring_manager, tracker, mixer_stream)) {}
 354
 355 WebContentsAudioInputStream::~WebContentsAudioInputStream() {}
 356
 357 bool WebContentsAudioInputStream::Open() {
 358   return impl_->Open();
 359 }
 360
 361 void WebContentsAudioInputStream::Start(AudioInputCallback* callback) {
 362   impl_->Start(callback);
 363 }
 364
 365 void WebContentsAudioInputStream::Stop() {
 366   impl_->Stop();
 367 }
 368
 369 void WebContentsAudioInputStream::Close() {
 370   impl_->Close();
 371   delete this;
 372 }
 373
 374 double WebContentsAudioInputStream::GetMaxVolume() {
 375   return impl_->mixer_stream()->GetMaxVolume();
 376 }
 377
 378 void WebContentsAudioInputStream::SetVolume(double volume) {
 379   impl_->mixer_stream()->SetVolume(volume);
 380 }
 381
 382 double WebContentsAudioInputStream::GetVolume() {
 383   return impl_->mixer_stream()->GetVolume();
 384 }
 385
 386 void WebContentsAudioInputStream::SetAutomaticGainControl(bool enabled) {
 387   impl_->mixer_stream()->SetAutomaticGainControl(enabled);
 388 }
 389
 390 bool WebContentsAudioInputStream::GetAutomaticGainControl() {
 391   return impl_->mixer_stream()->GetAutomaticGainControl();
 392 }
 393
 394 }  // namespace content