Unmute Tab Audio For Desktop Share

content/browser/media/capture/web_contents_audio_input_stream.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/media/capture/web_contents_audio_input_stream.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
 #include "content/browser/media/capture/audio_mirroring_manager.h"
 #include "content/browser/media/capture/web_contents_tracker.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_media_capture_id.h"
 #include "media/audio/virtual_audio_input_stream.h"
 #include "media/audio/virtual_audio_output_stream.h"
+#include "media/audio/virtual_audio_sink.h"
 #include "media/base/bind_to_current_loop.h"
 
 namespace content {
 
 class WebContentsAudioInputStream::Impl
     : public base::RefCountedThreadSafe<WebContentsAudioInputStream::Impl>,
       public AudioMirroringManager::MirroringDestination {
  public:
   // Takes ownership of |mixer_stream|.  The rest outlive this instance.
-  Impl(int render_process_id, int main_render_frame_id,
+  Impl(int render_process_id,
+       int main_render_frame_id,
        AudioMirroringManager* mirroring_manager,
        const scoped_refptr<WebContentsTracker>& tracker,
-       media::VirtualAudioInputStream* mixer_stream);
+       media::VirtualAudioInputStream* mixer_stream,
+       bool is_duplication);
 
   // Open underlying VirtualAudioInputStream and start tracker.
   bool Open();
 
   // Start the underlying VirtualAudioInputStream and instruct
   // AudioMirroringManager to begin a mirroring session.
   void Start(AudioInputCallback* callback);
 
   // Stop the underlying VirtualAudioInputStream and instruct
   // AudioMirroringManager to shutdown a mirroring session.
@@ skipping 33 matching lines @@
   // successful audio capture.
   void UnmuteWebContentsAudio();
 
   // AudioMirroringManager::MirroringDestination implementation
   void QueryForMatches(const std::set<SourceFrameRef>& candidates,
                        const MatchesCallback& results_callback) override;
   void QueryForMatchesOnUIThread(const std::set<SourceFrameRef>& candidates,
                                  const MatchesCallback& results_callback);
   media::AudioOutputStream* AddInput(
       const media::AudioParameters& params) override;
+  media::AudioPushSink* AddPushInput(
+      const media::AudioParameters& params) override;
 
   // Callback which is run when |stream| is closed.  Deletes |stream|.
   void ReleaseInput(media::VirtualAudioOutputStream* stream);
+  void ReleasePushInput(media::VirtualAudioSink* sink);
 
   // Called by WebContentsTracker when the target of the audio mirroring has
   // changed.
   void OnTargetChanged(bool had_target);
 
   // Injected dependencies.
   const int initial_render_process_id_;
   const int initial_main_render_frame_id_;
   AudioMirroringManager* const mirroring_manager_;
   const scoped_refptr<WebContentsTracker> tracker_;
   // The AudioInputStream implementation that handles the audio conversion and
   // mixing details.
   const std::unique_ptr<media::VirtualAudioInputStream> mixer_stream_;
 
   State state_;
 
   // Set to true if |tracker_| reports a NULL target, which indicates the target
   // is permanently lost.
   bool is_target_lost_;
 
   // Current callback used to consume the resulting mixed audio data.
   AudioInputCallback* callback_;
 
+  // If true, this WebContentsAudioInputStream will request a duplication of
+  // audio data, instead of exclusive access to pull the audio data.
+  bool is_duplication_;
+
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(Impl);
 };
 
 WebContentsAudioInputStream::Impl::Impl(
-    int render_process_id, int main_render_frame_id,
+    int render_process_id,
+    int main_render_frame_id,
     AudioMirroringManager* mirroring_manager,
     const scoped_refptr<WebContentsTracker>& tracker,
-    media::VirtualAudioInputStream* mixer_stream)
+    media::VirtualAudioInputStream* mixer_stream,
+    bool is_duplication)
     : initial_render_process_id_(render_process_id),
       initial_main_render_frame_id_(main_render_frame_id),
       mirroring_manager_(mirroring_manager),
       tracker_(tracker),
       mixer_stream_(mixer_stream),
       state_(CONSTRUCTED),
       is_target_lost_(false),
-      callback_(NULL) {
+      callback_(NULL),
+      is_duplication_(is_duplication) {
   DCHECK(mirroring_manager_);
   DCHECK(tracker_);
   DCHECK(mixer_stream_);
 
   // WAIS::Impl can be constructed on any thread, but will DCHECK that all
   // its methods from here on are called from the same thread.
   thread_checker_.DetachFromThread();
 }
 
 WebContentsAudioInputStream::Impl::~Impl() {
@@ skipping 133 matching lines @@
     for (std::set<SourceFrameRef>::const_iterator i = candidates.begin();
          i != candidates.end(); ++i) {
       WebContents* const contents_containing_frame =
           WebContents::FromRenderFrameHost(
               RenderFrameHost::FromID(i->first, i->second));
       if (contents_containing_frame == contents)
         matches.insert(*i);
     }
   }
 
-  results_callback.Run(matches);
+  results_callback.Run(matches, is_duplication_);
 }
 
 media::AudioOutputStream* WebContentsAudioInputStream::Impl::AddInput(
     const media::AudioParameters& params) {
   // Note: The closure created here holds a reference to "this," which will
   // guarantee the VirtualAudioInputStream (mixer_stream_) outlives the
   // VirtualAudioOutputStream.
   return new media::VirtualAudioOutputStream(
       params,
       mixer_stream_.get(),
       base::Bind(&Impl::ReleaseInput, this));
 }
 
 void WebContentsAudioInputStream::Impl::ReleaseInput(
     media::VirtualAudioOutputStream* stream) {
   delete stream;
 }
 
+media::AudioPushSink* WebContentsAudioInputStream::Impl::AddPushInput(
+    const media::AudioParameters& params) {
+  // Note: The closure created here holds a reference to "this," which will
+  // guarantee the VirtualAudioInputStream (mixer_stream_) outlives the
+  // VirtualAudioSink.
+  return new media::VirtualAudioSink(params, mixer_stream_.get(),
+                                     base::Bind(&Impl::ReleasePushInput, this));
+}
+
+void WebContentsAudioInputStream::Impl::ReleasePushInput(
+    media::VirtualAudioSink* stream) {
+  delete stream;
+}
+
 void WebContentsAudioInputStream::Impl::OnTargetChanged(bool had_target) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   is_target_lost_ = !had_target;
 
   if (state_ == MIRRORING) {
     if (is_target_lost_) {
       ReportError();
       Stop();
     } else {
       StartMirroring();
     }
   }
 }
 
 // static
 WebContentsAudioInputStream* WebContentsAudioInputStream::Create(
     const std::string& device_id,
     const media::AudioParameters& params,
     const scoped_refptr<base::SingleThreadTaskRunner>& worker_task_runner,
     AudioMirroringManager* audio_mirroring_manager) {
   int render_process_id;
   int main_render_frame_id;
   if (!WebContentsMediaCaptureId::ExtractTabCaptureTarget(
           device_id, &render_process_id, &main_render_frame_id)) {
     return NULL;
   }
 
+  // TODO(qiangchen): Plug in true for the case of Tab Typed Desktop Share.
   return new WebContentsAudioInputStream(
-      render_process_id, main_render_frame_id,
-      audio_mirroring_manager,
+      render_process_id, main_render_frame_id, audio_mirroring_manager,
       new WebContentsTracker(false),
       new media::VirtualAudioInputStream(
           params, worker_task_runner,
-          media::VirtualAudioInputStream::AfterCloseCallback()));
+          media::VirtualAudioInputStream::AfterCloseCallback()),
+      false);
 }
 
 WebContentsAudioInputStream::WebContentsAudioInputStream(
-    int render_process_id, int main_render_frame_id,
+    int render_process_id,
+    int main_render_frame_id,
     AudioMirroringManager* mirroring_manager,
     const scoped_refptr<WebContentsTracker>& tracker,
-    media::VirtualAudioInputStream* mixer_stream)
-    : impl_(new Impl(render_process_id, main_render_frame_id,
-                     mirroring_manager, tracker, mixer_stream)) {}
+    media::VirtualAudioInputStream* mixer_stream,
+    bool is_duplication)
+    : impl_(new Impl(render_process_id,
+                     main_render_frame_id,
+                     mirroring_manager,
+                     tracker,
+                     mixer_stream,
+                     is_duplication)) {}
 
 WebContentsAudioInputStream::~WebContentsAudioInputStream() {}
 
 bool WebContentsAudioInputStream::Open() {
   return impl_->Open();
 }
 
 void WebContentsAudioInputStream::Start(AudioInputCallback* callback) {
   impl_->Start(callback);
 }
@@ skipping 25 matching lines @@
 
 bool WebContentsAudioInputStream::GetAutomaticGainControl() {
   return impl_->mixer_stream()->GetAutomaticGainControl();
 }
 
 bool WebContentsAudioInputStream::IsMuted() {
   return false;
 }
 
 }  // namespace content