Unmute Tab Audio For Desktop Share

content/browser/media/capture/audio_mirroring_manager.h

 // 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.
 //
 // AudioMirroringManager is a singleton object that maintains a set of active
 // audio mirroring destinations and auto-connects/disconnects audio streams
 // to/from those destinations.  It is meant to be used exclusively on the IO
 // thread.
 //
 // How it works:
@@ skipping 14 matching lines @@
 //       request a "refresh" query on a MirroringDestination, and this will
 //       result in AudioMirroringManager starting/stopping only those Diverters
 //       that are not correctly routed to the destination.
 //   3c. When a mirroring session is stopped, the remaining destinations will be
 //       queried to determine whether diverting should continue to a different
 //       destination.
 
 #ifndef CONTENT_BROWSER_MEDIA_CAPTURE_AUDIO_MIRRORING_MANAGER_H_
 #define CONTENT_BROWSER_MEDIA_CAPTURE_AUDIO_MIRRORING_MANAGER_H_
 
+#include <map>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
 #include "content/common/content_export.h"
 #include "media/audio/audio_source_diverter.h"
+#include "media/audio/virtual_audio_sink.h"
 
 namespace media {
 class AudioOutputStream;
 }
 
 namespace content {
 
 class CONTENT_EXPORT AudioMirroringManager {
  public:
   // Interface for diverting audio data to an alternative AudioOutputStream.
   typedef media::AudioSourceDiverter Diverter;
 
   // A SourceFrameRef is a RenderFrameHost identified by a <render_process_id,
   // render_frame_id> pair.
   typedef std::pair<int, int> SourceFrameRef;
 
   // Interface to be implemented by audio mirroring destinations.  See comments
   // for StartMirroring() and StopMirroring() below.
   class MirroringDestination {
    public:
     // Asynchronously query whether this MirroringDestination wants to consume
     // audio sourced from each of the |candidates|.  |results_callback| is run
     // to indicate which of them (or none) should have audio routed to this
     // MirroringDestination.  |results_callback| must be run on the same thread
     // as the one that called QueryForMatches().
-    typedef base::Callback<void(const std::set<SourceFrameRef>&)>
+    typedef base::Callback<void(const std::set<SourceFrameRef>&, bool)>

[miu, 2016/05/02 20:06:13]

Please document what this new bool argument is for (i.e., the destination wants
either exclusive access to the audio flow and will pull the audio, or a
duplicated flow where audio is pushed to it).

[qiangchen, 2016/05/03 16:58:23]

Done.

         MatchesCallback;
     virtual void QueryForMatches(
         const std::set<SourceFrameRef>& candidates,
         const MatchesCallback& results_callback) = 0;
 
     // Create a consumer of audio data in the format specified by |params|, and
     // connect it as an input to mirroring.  When Close() is called on the
     // returned AudioOutputStream, the input is disconnected and the object
     // becomes invalid.

[miu, 2016/05/02 20:06:12]

Comment should add: This is used to provide the MirroringDestination with
exclusive access to pull (render) the audio flow from the source.

[qiangchen, 2016/05/03 16:58:23]

Done.

     virtual media::AudioOutputStream* AddInput(
         const media::AudioParameters& params) = 0;
 
+    virtual media::AudioPushSink* AddPushInput(

[miu, 2016/05/02 20:06:12]

Need comment here.  It should mention this is the path used to push a duplicated
audio flow to the MirroringDestination.

[qiangchen, 2016/05/03 16:58:23]

Done.

+        const media::AudioParameters& params) = 0;
+
    protected:
     virtual ~MirroringDestination() {}
   };
 
   // Note: Use GetInstance() for non-test code.
   AudioMirroringManager();
   virtual ~AudioMirroringManager();
 
   // Returns the global instance.
   static AudioMirroringManager* GetInstance();
@@ skipping 21 matching lines @@
     // The source render frame associated with the audio stream.
     SourceFrameRef source_render_frame;
 
     // The diverter for re-routing the audio stream.
     Diverter* diverter;
 
     // If not NULL, the audio stream is currently being diverted to this
     // destination.
     MirroringDestination* destination;
 
+    // The destinations to which audio stream is duplicated.

[miu, 2016/05/02 20:06:13]

Comment should mention that AudioPushSink is owned by the Diverter, but that AMM
must guarantee StopDuplicating() is called.

[qiangchen, 2016/05/03 16:58:23]

Done.

+    std::map<MirroringDestination*, media::AudioPushSink*> dup_destinations;

[miu, 2016/05/02 20:06:12]

naming nit: How about "duplications" instead?  (since this is a map tracking
duplication flows)

[qiangchen, 2016/05/03 16:58:23]

Done.

+
     StreamRoutingState(const SourceFrameRef& source_frame,
                        Diverter* stream_diverter);
     StreamRoutingState(const StreamRoutingState& other);
     ~StreamRoutingState();
   };
 
   typedef std::vector<StreamRoutingState> StreamRoutes;
   typedef std::vector<MirroringDestination*> Destinations;
 
   // Helper to find a destination other than |old_destination| for the given
   // |candidates| to be diverted to.
   void InitiateQueriesToFindNewDestination(
       MirroringDestination* old_destination,
       const std::set<SourceFrameRef>& candidates);
 
   // MirroringDestination query callback.  |matches| contains all RenderFrame
-  // sources that will be diverted to |destination|.  If |add_only| is false,
-  // then any Diverters currently routed to |destination| but not found in
-  // |matches| will be stopped.
+  // sources that will be diverted or dupliated to |destination|.

[miu, 2016/05/02 20:06:13]

typo: s/dupliated/duplicated/

[qiangchen, 2016/05/03 16:58:23]

Done.

+  // If |add_only| is false, then any Diverters currently routed to
+  // |destination| but not found in |matches| will be stopped.
+  // If |is_duplicate| is true, the audio source will be duplicate to the

[miu, 2016/05/02 20:06:12]

nit: s/audio source will be duplicate to/audio data flow will be duplicated to
the destination instead of diverted/

[qiangchen, 2016/05/03 16:58:23]

Done.

+  // destination, otherwise we will divert audio.
   void UpdateRoutesToDestination(MirroringDestination* destination,
                                  bool add_only,
-                                 const std::set<SourceFrameRef>& matches);
+                                 const std::set<SourceFrameRef>& matches,
+                                 bool is_duplicate);
+
+  // |matches| contains all RenderFrame sources that will be diverted to
+  // |destination|.  If |add_only| is false, then any Diverters currently routed
+  // to |destination| but not found in |matches| will be stopped.
+  void UpdateRoutesToDivertDestination(MirroringDestination* destination,
+                                       bool add_only,
+                                       const std::set<SourceFrameRef>& matches);
+
+  // |matches| contains all RenderFrame sources that will be duplicated to
+  // |destination|.  If |add_only| is false, then any Diverters currently
+  // duplicating to |destination| but not found in |matches| will be stopped.
+  void UpdateRoutesToDuplicateDestination(
+      MirroringDestination* destination,
+      bool add_only,
+      const std::set<SourceFrameRef>& matches);
 
   // Starts diverting audio to the |new_destination|, if not NULL.  Otherwise,
   // stops diverting audio.
   static void ChangeRoute(StreamRoutingState* route,
                           MirroringDestination* new_destination);
 
   // Routing table.  Contains one entry for each Diverter.
   StreamRoutes routes_;
 
   // All active mirroring sessions.
   Destinations sessions_;
 
   // Used to check that all AudioMirroringManager code runs on the same thread.
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioMirroringManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_MEDIA_CAPTURE_AUDIO_MIRRORING_MANAGER_H_