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"
@@ skipping 11 matching lines @@
 #include "media/audio/virtual_audio_output_stream.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.

[miu, 2016/05/06 22:29:49]

nit: Append to the end of the sentence: "instead of exclusive access to pull the
audio data."

[qiangchen, 2016/05/10 22:36:52]

Done.

+  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.

[miu, 2016/05/06 22:29:49]

Note: The JavaScript API to start tab capture should specify whether it wants
the local audio diverted or duplicated. For historical reasons, if the
"constraint" or "parameter" for this is not specified, it should probably
default to "diverted."

[qiangchen, 2016/05/10 22:36:52]

For the current use case: Cast uses chrome.tabCapture, while hangouts uses
chrome.chooseDesktopMedia.
So we can set the duplication=true/false based on which API issues the request,
without touching API.

Your suggestion sounds more reasonable. I'll consider adding an entry in
AudioConstraint for the API call, so that we do not need to change the signature
of API.

   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